diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index a9792f69dc7..4e78be9f393 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -56,6 +56,13 @@ jobs:
           build-mode: none
         - language: rust
           build-mode: none
+          # Path exclusions work with `none`; inline unit tests remain in scope.
+          config: |
+            paths-ignore:
+              - '**/examples/**'
+              - '**/tests/**'
+              - '**/fuzz/**'
+              - '**/benches/**'
         # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
         # Use `c-cpp` to analyze code written in C, C++ or both
         # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
@@ -82,6 +89,7 @@ jobs:
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
+        config: ${{ matrix.config }}
         # If you wish to specify custom queries, you can do so here or in a config file.
         # By default, queries listed here will override any specified in a config file.
         # Prefix the list here with "+" to use these queries and those in the config file.
diff --git a/.gitignore b/.gitignore
index 78cd84318a8..682ceb272a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,8 @@ $**/fuzz/Cargo.lock
 
 # Instead of adding more environment-specific ignores here, like for the IDE in use, prefer Git's user-global
 # `core.excludesFile` mechanism, see https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreexcludesFile.
+
+# Share Zed tasks even when editor files are ignored globally; keep other Zed settings local.
+!/.zed/
+/.zed/*
+!/.zed/tasks.json
diff --git a/.zed/tasks.json b/.zed/tasks.json
new file mode 100644
index 00000000000..a46d249b6d3
--- /dev/null
+++ b/.zed/tasks.json
@@ -0,0 +1,233 @@
+// Feature-specific test configurations, with both hashes enabled where applicable.
+// gix-transport has no hash toggles, so enable them on its gix-hash dev-dependency.
+// gix-error tests enable anyhow through a dev-dependency; tree-error overrides auto-chain-error.
+[
+  {
+    "label": "test gix-error (default tree)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-error",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-error (auto-chain-error)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-error",
+      "--features",
+      "auto-chain-error",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-error (auto-chain-error, tree-error)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-error",
+      "--features",
+      "auto-chain-error,tree-error",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-protocol (blocking-client)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-protocol",
+      "--features",
+      "blocking-client,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-protocol (async-client)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-protocol",
+      "--features",
+      "async-client,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-transport (curl)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-transport",
+      "--features",
+      "http-client-curl,gix-hash/sha1,gix-hash/sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-transport (curl, insecure HTTP credentials)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-transport",
+      "--features",
+      "http-client-curl,http-client-insecure-credentials,gix-hash/sha1,gix-hash/sha256",
+      "--test",
+      "blocking-transport-http-only",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-transport (reqwest)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-transport",
+      "--features",
+      "http-client-reqwest,gix-hash/sha1,gix-hash/sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-transport (reqwest, insecure HTTP credentials)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-transport",
+      "--no-default-features",
+      "--features",
+      "blocking-client,http-client-reqwest,http-client-insecure-credentials,gix-hash/sha1,gix-hash/sha256",
+      "--test",
+      "blocking-transport",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix-transport (async-client)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix-transport",
+      "--features",
+      "async-client,gix-hash/sha1,gix-hash/sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix (basic, comfort, max-performance-safe)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix",
+      "--no-default-features",
+      "--features",
+      "basic,comfort,max-performance-safe,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix (basic, extras, comfort)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix",
+      "--no-default-features",
+      "--features",
+      "basic,extras,comfort,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix (async-network-client)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix",
+      "--features",
+      "async-network-client,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix (blocking-network-client)",
+    "command": "cargo",
+    "args": [
+      "nextest",
+      "run",
+      "-p",
+      "gix",
+      "--features",
+      "blocking-network-client,sha1,sha256",
+      "--no-fail-fast"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  },
+  {
+    "label": "test gix (async-std, flaky)",
+    "command": "cargo",
+    "args": [
+      "test",
+      "-p",
+      "gix",
+      "--features",
+      "async-network-client-async-std,sha1,sha256"
+    ],
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "env": { "GIX_TEST_IGNORE_ARCHIVES": "1" }
+  }
+]
diff --git a/AGENTS.md b/AGENTS.md
index a7c8485d67c..3b835eb4acc 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -37,13 +37,23 @@ Plumbing crates are migrating from `thiserror` enums to `gix-error`. Check wheth
 uses `gix-error` (look at its `Cargo.toml`); if it does, follow the patterns below. If it still uses
 `thiserror`, keep using `thiserror` for consistency within that crate.
 
-- **Error type alias**: `pub type Error = gix_error::Exn<gix_error::Message>;`
+- **Error types**: use `gix_error::Exn`, `gix_error::Exn<gix_error::Message>`, or the appropriate
+  concrete error directly, importing types under their canonical names as needed. Do not introduce
+  crate-specific or operation-specific forwarding aliases or renamed error exports.
+- **Exception results**: use `ExnResult<T, E>` for results with `Exn<E>` errors.
+  It defaults to `T = ()` and `E = gix_error::exn::Untyped`: use `ExnResult<T>` for erased errors,
+  bare `ExnResult` for erased unit results, and `ExnMessageResult<T>` for message contexts.
+  `ExnMessageResult` also defaults to unit success. Preserve concrete error types when adapting signatures.
+  Always import `ExnResult` and `ExnMessageResult` directly from `gix_error` (or their `gix` re-exports)
+  and use their bare names in signatures.
+- **Porcelain errors**: use the central `gix::Error` re-export at public API boundaries. Keep the
+  underlying error type and any `Exn` parameter when adapting an existing signature.
 - **Static messages**: `gix_error::message("something failed")`
 - **Formatted messages**: `gix_error::message!("failed to read {path}")`
 - **Wrapping callee errors with context**: `.or_raise(|| message("context about what failed"))?`
 - **Standalone error (no callee)**: `Err(message("something went wrong").raise())`
 - **Wrapping an `impl Error` with context**: `err.and_raise(message("context"))`
-- **Closure/callback bounds**: use `Result<T, Exn>` (bare), not `Exn<Message>`;
+- **Closure/callback bounds**: use `ExnResult<T>` with the default erased error type;
   inside the function, convert with `.or_raise(|| message("..."))?`;
   inside the closure, convert typed to bare with `.or_erased()`
 - **`Exn<E>` does NOT implement `std::error::Error`** — this is by design.
@@ -51,7 +61,7 @@ uses `gix-error` (look at its `Cargo.toml`); if it does, follow the patterns bel
   - Example: `std::io::Error::other(exn.into_error())`
 - **In tests** returning `gix_testtools::Result` (= `Result<(), Box<dyn Error>>`), `Exn` can't be used
   with `?` directly — use `.map_err(|e| e.into_error())?`
-- **Common imports**: `use gix_error::{message, ErrorExt, ResultExt};`
+- **Common imports**: `use gix_error::{message, ErrorExt, ExnMessageResult, ExnResult, ResultExt};`
 - See `gix-error/src/lib.rs` module docs for a full migration guide from `thiserror`
 
 ### Commit Messages
diff --git a/Cargo.lock b/Cargo.lock
index ce1b7d60c73..0decce5ed9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1526,7 +1526,6 @@ dependencies = [
  "smallvec",
  "sysinfo",
  "tempfile",
- "thiserror 2.0.18",
  "tracing",
  "tracing-forest 0.2.0",
  "tracing-subscriber",
@@ -1607,7 +1606,6 @@ dependencies = [
  "signal-hook 0.4.4",
  "smallvec",
  "termtree",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1620,6 +1618,7 @@ dependencies = [
  "gix-error",
  "gix-hash",
  "gix-testtools",
+ "insta",
  "pretty_assertions",
  "serde",
 ]
@@ -1661,6 +1660,7 @@ dependencies = [
  "gix-quote",
  "gix-testtools",
  "gix-trace",
+ "insta",
  "serde",
  "smallvec",
  "unicode-bom",
@@ -1694,9 +1694,9 @@ dependencies = [
  "gix-trace",
  "gix-traverse",
  "gix-worktree",
+ "insta",
  "pretty_assertions",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1711,10 +1711,12 @@ name = "gix-command"
 version = "0.10.1"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-path",
  "gix-quote",
  "gix-testtools",
  "gix-trace",
+ "insta",
 ]
 
 [[package]]
@@ -1728,6 +1730,7 @@ dependencies = [
  "gix-error",
  "gix-hash",
  "gix-testtools",
+ "insta",
  "memmap2",
  "nonempty",
  "serde",
@@ -1744,6 +1747,7 @@ dependencies = [
  "document-features",
  "gix-config",
  "gix-config-value",
+ "gix-error",
  "gix-features",
  "gix-glob",
  "gix-path",
@@ -1755,7 +1759,6 @@ dependencies = [
  "serde",
  "serial_test",
  "smallvec",
- "thiserror 2.0.18",
  "unicode-bom",
 ]
 
@@ -1766,10 +1769,12 @@ dependencies = [
  "bitflags 2.13.0",
  "bstr",
  "document-features",
+ "gix-error",
  "gix-path",
+ "gix-testtools",
+ "insta",
  "libc",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1789,8 +1794,8 @@ dependencies = [
  "gix-testtools",
  "gix-trace",
  "gix-url",
+ "insta",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1802,6 +1807,7 @@ dependencies = [
  "gix-error",
  "gix-hash",
  "gix-testtools",
+ "insta",
  "itoa",
  "jiff",
  "pretty_assertions",
@@ -1818,6 +1824,7 @@ dependencies = [
  "getrandom 0.4.3",
  "gix-attributes",
  "gix-command",
+ "gix-error",
  "gix-filter",
  "gix-fs",
  "gix-hash",
@@ -1835,7 +1842,6 @@ dependencies = [
  "insta",
  "pretty_assertions",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1845,6 +1851,7 @@ dependencies = [
  "bstr",
  "gix-dir",
  "gix-discover",
+ "gix-error",
  "gix-fs",
  "gix-ignore",
  "gix-index",
@@ -1855,8 +1862,8 @@ dependencies = [
  "gix-trace",
  "gix-utils",
  "gix-worktree",
+ "insta",
  "pretty_assertions",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1866,15 +1873,16 @@ dependencies = [
  "bstr",
  "defer",
  "dunce",
+ "gix-error",
  "gix-fs",
  "gix-path",
  "gix-ref",
  "gix-sec",
  "gix-testtools",
+ "insta",
  "is_ci",
  "serial_test",
  "tempfile",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1885,6 +1893,7 @@ dependencies = [
  "bstr",
  "document-features",
  "gix-error",
+ "gix-testtools",
  "insta",
 ]
 
@@ -1898,8 +1907,10 @@ dependencies = [
  "crossbeam-channel",
  "document-features",
  "gix-path",
+ "gix-testtools",
  "gix-trace",
  "gix-utils",
+ "insta",
  "libc",
  "once_cell",
  "parking_lot",
@@ -1919,6 +1930,7 @@ dependencies = [
  "encoding_rs",
  "gix-attributes",
  "gix-command",
+ "gix-error",
  "gix-filter",
  "gix-hash",
  "gix-object",
@@ -1929,8 +1941,8 @@ dependencies = [
  "gix-trace",
  "gix-utils",
  "gix-worktree",
+ "insta",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -1942,7 +1954,9 @@ dependencies = [
  "gix-error",
  "gix-features",
  "gix-path",
+ "gix-testtools",
  "gix-utils",
+ "insta",
  "is_ci",
  "serde",
  "tempfile",
@@ -1952,6 +1966,7 @@ dependencies = [
 name = "gix-fsck"
 version = "0.25.1"
 dependencies = [
+ "gix-error",
  "gix-hash",
  "gix-hashtable",
  "gix-object",
@@ -1985,6 +2000,7 @@ dependencies = [
  "gix-features",
  "gix-hash",
  "gix-testtools",
+ "insta",
  "serde",
  "sha1dc",
  "sha2",
@@ -2039,6 +2055,7 @@ dependencies = [
  "filetime",
  "fnv",
  "gix-bitmap",
+ "gix-error",
  "gix-features",
  "gix-fs",
  "gix-hash",
@@ -2058,7 +2075,6 @@ dependencies = [
  "rustix",
  "serde",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2071,7 +2087,9 @@ version = "24.0.0"
 dependencies = [
  "gix-error",
  "gix-tempfile",
+ "gix-testtools",
  "gix-utils",
+ "insta",
  "tempfile",
 ]
 
@@ -2095,6 +2113,7 @@ dependencies = [
  "gix-date",
  "gix-error",
  "gix-testtools",
+ "insta",
  "serde",
 ]
 
@@ -2108,6 +2127,7 @@ dependencies = [
  "document-features",
  "gix-command",
  "gix-diff",
+ "gix-error",
  "gix-filter",
  "gix-fs",
  "gix-hash",
@@ -2125,11 +2145,11 @@ dependencies = [
  "gix-trace",
  "gix-utils",
  "gix-worktree",
+ "insta",
  "nonempty",
  "pretty_assertions",
  "serde",
  "termtree",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2139,6 +2159,7 @@ dependencies = [
  "bitflags 2.13.0",
  "gix-commitgraph",
  "gix-date",
+ "gix-error",
  "gix-hash",
  "gix-object",
  "gix-odb",
@@ -2158,6 +2179,7 @@ dependencies = [
  "gix-object",
  "gix-odb",
  "gix-testtools",
+ "insta",
 ]
 
 [[package]]
@@ -2170,6 +2192,7 @@ dependencies = [
  "gix-actor",
  "gix-command",
  "gix-date",
+ "gix-error",
  "gix-features",
  "gix-hash",
  "gix-hashtable",
@@ -2186,7 +2209,6 @@ dependencies = [
  "serde",
  "smallvec",
  "termtree",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2211,13 +2233,13 @@ dependencies = [
  "gix-quote",
  "gix-testtools",
  "gix-zlib",
+ "insta",
  "maplit",
  "memmap2",
  "parking_lot",
  "pretty_assertions",
  "serde",
  "tempfile",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2249,7 +2271,6 @@ dependencies = [
  "parking_lot",
  "serde",
  "smallvec",
- "thiserror 2.0.18",
  "uluru",
 ]
 
@@ -2263,14 +2284,16 @@ dependencies = [
  "faster-hex",
  "futures-io",
  "futures-lite",
+ "gix-error",
  "gix-hash",
  "gix-macros",
  "gix-odb",
  "gix-pack",
+ "gix-testtools",
  "gix-trace",
+ "insta",
  "pin-project-lite",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2279,8 +2302,10 @@ version = "0.12.6"
 dependencies = [
  "bstr",
  "gix-error",
+ "gix-testtools",
  "gix-trace",
  "gix-validate",
+ "insta",
  "serial_test",
  "tempfile",
  "windows 0.62.2",
@@ -2295,11 +2320,12 @@ dependencies = [
  "bstr",
  "gix-attributes",
  "gix-config-value",
+ "gix-error",
  "gix-glob",
  "gix-path",
  "gix-testtools",
+ "insta",
  "serial_test",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2309,11 +2335,12 @@ dependencies = [
  "expectrl",
  "gix-command",
  "gix-config-value",
+ "gix-error",
  "gix-testtools",
+ "insta",
  "parking_lot",
  "rustix",
  "serial_test",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2328,6 +2355,7 @@ dependencies = [
  "futures-lite",
  "gix-credentials",
  "gix-date",
+ "gix-error",
  "gix-features",
  "gix-hash",
  "gix-lock",
@@ -2340,12 +2368,13 @@ dependencies = [
  "gix-refspec",
  "gix-revwalk",
  "gix-shallow",
+ "gix-testtools",
  "gix-trace",
  "gix-transport",
  "gix-utils",
+ "insta",
  "nonempty",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2385,7 +2414,6 @@ dependencies = [
  "libc",
  "memmap2",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2393,12 +2421,12 @@ name = "gix-refspec"
 version = "0.45.1"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-hash",
  "gix-testtools",
  "gix-validate",
  "insta",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2436,7 +2464,6 @@ dependencies = [
  "gix-object",
  "gix-testtools",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2461,12 +2488,12 @@ name = "gix-shallow"
 version = "0.13.0"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-hash",
  "gix-lock",
  "nonempty",
  "serde",
  "tempfile",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2478,6 +2505,7 @@ dependencies = [
  "filetime",
  "gix-diff",
  "gix-dir",
+ "gix-error",
  "gix-features",
  "gix-filter",
  "gix-fs",
@@ -2491,9 +2519,9 @@ dependencies = [
  "gix-testtools",
  "gix-worktree",
  "hashbrown 0.16.1",
+ "insta",
  "portable-atomic",
  "pretty_assertions",
- "thiserror 2.0.18",
  "windows-sys 0.61.2",
 ]
 
@@ -2510,7 +2538,7 @@ dependencies = [
  "gix-refspec",
  "gix-testtools",
  "gix-url",
- "thiserror 2.0.18",
+ "insta",
 ]
 
 [[package]]
@@ -2520,6 +2548,8 @@ dependencies = [
  "dashmap",
  "document-features",
  "gix-fs",
+ "gix-testtools",
+ "insta",
  "libc",
  "parking_lot",
  "signal-hook 0.4.4",
@@ -2614,13 +2644,14 @@ dependencies = [
  "gix-path",
  "gix-quote",
  "gix-sec",
+ "gix-testtools",
  "gix-transport",
  "gix-url",
+ "insta",
  "parking_lot",
  "pin-project-lite",
  "reqwest",
  "serde",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2630,6 +2661,7 @@ dependencies = [
  "bitflags 2.13.0",
  "gix-commitgraph",
  "gix-date",
+ "gix-error",
  "gix-hash",
  "gix-hashtable",
  "gix-object",
@@ -2640,7 +2672,6 @@ dependencies = [
  "gix-traverse",
  "insta",
  "smallvec",
- "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -2658,6 +2689,7 @@ dependencies = [
  "gix-path",
  "gix-testtools",
  "gix-utils",
+ "insta",
  "percent-encoding",
  "serde",
  "serde_json",
@@ -2679,7 +2711,9 @@ name = "gix-validate"
 version = "0.11.4"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-testtools",
+ "insta",
 ]
 
 [[package]]
@@ -2690,6 +2724,7 @@ dependencies = [
  "document-features",
  "gix-attributes",
  "gix-discover",
+ "gix-error",
  "gix-features",
  "gix-fs",
  "gix-glob",
@@ -2701,6 +2736,7 @@ dependencies = [
  "gix-path",
  "gix-testtools",
  "gix-validate",
+ "insta",
  "serde",
 ]
 
@@ -2709,6 +2745,7 @@ name = "gix-worktree-state"
 version = "0.34.1"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-features",
  "gix-filter",
  "gix-fs",
@@ -2720,8 +2757,8 @@ dependencies = [
  "gix-testtools",
  "gix-worktree",
  "gix-worktree-state",
+ "insta",
  "io-close",
- "thiserror 2.0.18",
  "walkdir",
 ]
 
@@ -2742,6 +2779,7 @@ dependencies = [
  "gix-traverse",
  "gix-worktree",
  "gix-worktree-stream",
+ "insta",
  "parking_lot",
 ]
 
@@ -2751,6 +2789,7 @@ version = "0.1.0"
 dependencies = [
  "bstr",
  "gix-error",
+ "insta",
  "serde",
  "zlib-rs",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 77abe48ec98..9c586acd93d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -381,7 +381,6 @@ explicit_deref_methods = "allow"  # x22
 inconsistent_struct_constructor = "allow"  # x18
 range_plus_one = "allow"  # x17
 inefficient_to_string = "allow"  # x14
-from_iter_instead_of_collect = "allow"  # x13
 unused_self = "allow"  # x10
 many_single_char_names = "allow"  # x10
 manual_string_new = "allow"  # x10
diff --git a/etc/plan/gix-error.md b/etc/plan/gix-error.md
deleted file mode 100644
index 59344f6b0bb..00000000000
--- a/etc/plan/gix-error.md
+++ /dev/null
@@ -1,179 +0,0 @@
-# gix-error / `Exn` Migration Plan
-
-Source issue: [GitoxideLabs/gitoxide#2351](https://github.com/GitoxideLabs/gitoxide/issues/2351)  
-Imported on: 2026-04-22  
-Working assumption: the checkboxes in this file reflect the current `gix-error` branch in this checkout, not only the historical state of the upstream issue.
-
-## Mission
-
-Finish the migration from `thiserror`-based error enums to `gix-error` / `Exn`, while preserving three caller-facing properties:
-
-- typed validation failures stay identifiable as `gix_error::ValidationError`
-- repository-open failures keep a distinct `NotARepository` path
-- crate-local plumbing errors stay cheap and composable until they are intentionally erased at the `gix` boundary
-
-## Constraints
-
-- Use the current workspace as the source of truth for completion.
-- Treat upstream PR history as context only. Several linked PRs are merged upstream, but that work is not fully reflected in this branch.
-- Keep migration leaf-first so downstream breakage stays local.
-
-## Reconciled Status
-
-- [x] Proof of concept completed in [#2352](https://github.com/GitoxideLabs/gitoxide/pull/2352), merged on January 12, 2026.
-- [x] `anyhow` / source-chain integration completed in [#2383](https://github.com/GitoxideLabs/gitoxide/pull/2383), merged on January 19, 2026.
-- [ ] Make `cargo nextest --workflow` run without `--exclude gix-error`.
-  Evidence: `.github/workflows/ci.yml` still excludes `gix-error`.
-- [ ] Replace `thiserror` with `gix-error` everywhere.
-  Evidence: 33 crates in this branch still carry a `thiserror` dependency and/or `thiserror::Error` usage.
-- [x] Keep `NotARepository` distinct from generic open failures.
-  Evidence: `gix::open::Error::NotARepository` exists and is asserted in tests.
-- [ ] Use `gix_error::Error` in tests when that simplifies `Exn`-heavy paths.
-  Evidence: partially adopted, but not clearly finished as a repo-wide sweep.
-- [x] Make `gix-validate` failures identifiable as `gix_error::ValidationError`.
-  Evidence: `gix-error` exports `ValidationError`, and downstream crates already use it directly.
-
-## Current Snapshot
-
-Workspace scan basis:
-
-- `thiserror` dependency present in `Cargo.toml`
-- `thiserror::Error` mentions under `src/**/*.rs`
-
-Result on 2026-04-22:
-
-- 32 crates are done
-- 33 crates are still pending
-
-## Linked Upstream PRs
-
-- [x] [#2352](https://github.com/GitoxideLabs/gitoxide/pull/2352) `gix-error` punch-through
-- [x] [#2373](https://github.com/GitoxideLabs/gitoxide/pull/2373) Convert more crates to `gix-error`
-- [x] [#2378](https://github.com/GitoxideLabs/gitoxide/pull/2378) `gix-commitgraph` to `gix-error`
-- [x] [#2383](https://github.com/GitoxideLabs/gitoxide/pull/2383) `anyhow` integration for `gix-error`
-- [x] [#2389](https://github.com/GitoxideLabs/gitoxide/pull/2389) custom error implementation follow-up
-- [x] [#2390](https://github.com/GitoxideLabs/gitoxide/pull/2390) make validate errors non-exhaustive
-- [x] [#2396](https://github.com/GitoxideLabs/gitoxide/pull/2396) `gix-actor`
-- [x] [#2400](https://github.com/GitoxideLabs/gitoxide/pull/2400) more `gix-error`
-- [x] [#2423](https://github.com/GitoxideLabs/gitoxide/pull/2423) batch 1, part 1
-
-## Migration Rules
-
-- Replace `thiserror` in `Cargo.toml` with `gix-error`.
-- Prefer `pub type Error = gix_error::Exn<gix_error::Message>;` unless the crate needs a more specific concrete error.
-- Convert validation/parsing-only paths to `gix_error::ValidationError`.
-- Replace `#[from]` / `#[source]` propagation with `.or_raise(...)` or `.ok_or_raise(...)`.
-- Keep `gix_error::Error` as the erased boundary type, mainly at `gix` and in tests that benefit from downcasting or frame inspection.
-- When migrating a crate, run its local checks and at least one downstream compile pass.
-
-## Execution Order
-
-### Batch 1: leaves
-
-- [ ] `gix-hash` - 7
-- [ ] `gix-url` - 3
-- [ ] `gix-packetline` - 3
-- [ ] `gix-features` - 3
-- [ ] `gix-path` - 2
-- [ ] `gix-attributes` - 2
-- [x] `gix-quote`
-- [ ] `gix-lock` - 1
-- [x] `gix-fs`
-- [x] `gix-bitmap`
-- [x] `gix-mailmap`
-
-### Batch 2: simple dependents
-
-- [ ] `gix-object` - 11
-- [ ] `gix-config-value` - 2
-- [ ] `gix-shallow` - 2
-- [ ] `gix-refspec` - 1
-
-### Batch 3: ref / filter layer
-
-- [ ] `gix-ref` - 22
-- [ ] `gix-filter` - 18
-- [ ] `gix-revwalk` - 4
-- [ ] `gix-pathspec` - 3
-- [ ] `gix-prompt` - 1
-
-### Batch 4: config and discovery
-
-- [ ] `gix-traverse` - 3
-- [ ] `gix-config` - 11
-- [ ] `gix-credentials` - 5
-- [ ] `gix-discover` - 4
-
-### Batch 5: transport and index-adjacent
-
-- [ ] `gix-index` - 11
-- [ ] `gix-transport` - 10
-- [x] `gix-worktree-stream`
-- [ ] `gix-submodule` - 6
-
-### Batch 6: diff / protocol tier
-
-- [ ] `gix-diff` - 8
-- [ ] `gix-protocol` - 8
-- [ ] `gix-dir` - 1
-- [ ] `gix-worktree-state` - 1
-- [x] `gix-archive`
-
-### Batch 7: heavier consumers
-
-- [ ] `gix-pack` - 23
-- [ ] `gix-merge` - 8
-- [ ] `gix-status` - 3
-- [ ] `gix-blame` - 1
-
-### Batch 8: object database
-
-- [ ] `gix-odb` - 11
-
-### Batch 9: top-level API
-
-- [ ] `gix` - 138
-
-## Already Done Outside The Active Queue
-
-- [x] `gix-actor`
-- [x] `gix-chunk`
-- [x] `gix-command`
-- [x] `gix-commitgraph`
-- [x] `gix-date`
-- [x] `gix-error`
-- [x] `gix-fetchhead`
-- [x] `gix-fsck`
-- [x] `gix-glob`
-- [x] `gix-hashtable`
-- [x] `gix-ignore`
-- [x] `gix-lfs`
-- [x] `gix-macros`
-- [x] `gix-negotiate`
-- [x] `gix-note`
-- [x] `gix-rebase`
-- [x] `gix-revision`
-- [x] `gix-sec`
-- [x] `gix-sequencer`
-- [x] `gix-tempfile`
-- [x] `gix-tix`
-- [x] `gix-trace`
-- [x] `gix-tui`
-- [x] `gix-utils`
-- [x] `gix-validate`
-- [x] `gix-worktree`
-
-## Immediate Next Moves
-
-- [ ] Finish Batch 1 in this branch before assuming the upstream batch-1 PR history is present locally.
-- [ ] Remove the `gix-error` special-case from `.github/workflows/ci.yml`.
-- [ ] Re-scan counts after each crate or mini-batch instead of trusting the original issue numbers.
-- [ ] Only move `gix` itself after all plumbing crates beneath it are clean.
-
-## Exit Criteria
-
-- [ ] No crate in this workspace depends on `thiserror`.
-- [ ] No `src/**/*.rs` file in this workspace mentions `thiserror::Error`.
-- [ ] `cargo nextest --workflow` no longer excludes `gix-error`.
-- [ ] The `gix` boundary still returns `gix_error::Error` where type erasure is desired.
-- [ ] Validation-heavy crates still expose typed validation failures where callers need them.
diff --git a/gitoxide-core/Cargo.toml b/gitoxide-core/Cargo.toml
index e4329b29ff2..f3a166ed9ee 100644
--- a/gitoxide-core/Cargo.toml
+++ b/gitoxide-core/Cargo.toml
@@ -58,7 +58,6 @@ gix-fsck = { version = "^0.25.1", path = "../gix-fsck" }
 gix-error-for-configuration-only = { package = "gix-error", version = "^0.3.2", path = "../gix-error", features = ["anyhow"] }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 anyhow = "1.0.102"
-thiserror = "2.0.18"
 bytesize = "2.3.1"
 tempfile = "3.26.0"
 unicode-width = "0.2.2"
@@ -131,6 +130,4 @@ ignored = [
     "gix-transport-configuration-only",
     # Imported as crate `layout`, which does not match the package name `layout-rs`.
     "layout-rs",
-    # Enabled through `estimate-hours` feature wiring only.
-    "smallvec",
 ]
diff --git a/gitoxide-core/src/discover.rs b/gitoxide-core/src/discover.rs
index d1ab7d3d23c..aff67c84456 100644
--- a/gitoxide-core/src/discover.rs
+++ b/gitoxide-core/src/discover.rs
@@ -22,7 +22,7 @@ pub fn discover(repo: &Path, mut out: impl std::io::Write) -> anyhow::Result<()>
 
     writeln!(out)?;
     writeln!(out, "discover (plumbing) from {}:", repo.display())?;
-    has_err |= print_result(&mut out, gix::discover::upwards(repo))?;
+    has_err |= print_result(&mut out, gix::discover::upwards(repo).map_err(gix::Exn::into_error))?;
 
     if has_err {
         writeln!(out)?;
diff --git a/gitoxide-core/src/hours/core.rs b/gitoxide-core/src/hours/core.rs
index e4ad7f7c54e..268a90b5260 100644
--- a/gitoxide-core/src/hours/core.rs
+++ b/gitoxide-core/src/hours/core.rs
@@ -6,7 +6,7 @@ use std::{
     },
 };
 
-use gix::bstr::BStr;
+use gix::{bstr::BStr, error::ResultExt};
 
 use crate::hours::{
     CommitIdx, FileStats, LineStats, WorkByEmail, WorkByPerson,
@@ -168,11 +168,9 @@ 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(std::io::Error::other)?;
+                                                    let mut diff = change.diff(cache).or_erased()?;
                                                     let mut nl = 0;
-                                                    if let Some(counts) =
-                                                        diff.line_counts().map_err(std::io::Error::other)?
-                                                    {
+                                                    if let Some(counts) = diff.line_counts().or_erased()? {
                                                         nl += counts.insertions as usize + counts.removals as usize;
                                                         lines.added += counts.insertions as usize;
                                                         lines.removed += counts.removals as usize;
@@ -182,7 +180,7 @@ pub fn spawn_tree_delta_threads<'scope>(
                                             }
                                         },
                                     }
-                                    Ok::<_, std::io::Error>(std::ops::ControlFlow::Continue(()))
+                                    Ok::<_, gix::Exn>(std::ops::ControlFlow::Continue(()))
                                 })?;
                             out.push((commit_idx, files, lines));
                         }
diff --git a/gitoxide-core/src/hours/mod.rs b/gitoxide-core/src/hours/mod.rs
index 8c5c29cc361..05ffcf17222 100644
--- a/gitoxide-core/src/hours/mod.rs
+++ b/gitoxide-core/src/hours/mod.rs
@@ -1,3 +1,4 @@
+use gix::ExnMessageResult;
 use std::{collections::BTreeSet, io, path::Path, time::Instant};
 
 use anyhow::bail;
@@ -85,7 +86,7 @@ fn parse_trailer_identity(trailer: gix::objs::commit::message::body::TrailerRef<
 fn commit_author_identities(
     commit_data: &[u8],
     object_hash: gix::hash::Kind,
-) -> Result<(gix::actor::SignatureRef<'_>, SmallVec<[ParsedIdentity<'_>; 2]>), gix::objs::decode::Error> {
+) -> ExnMessageResult<(gix::actor::SignatureRef<'_>, SmallVec<[ParsedIdentity<'_>; 2]>)> {
     let commit = gix::objs::CommitRef::from_bytes(commit_data, object_hash)?;
     let author = commit.author()?.trim();
     let mut authors = smallvec![ParsedIdentity::Borrowed(gix::actor::IdentityRef::from(author))];
@@ -254,7 +255,7 @@ where
                         }
                         commit_idx += 1;
                     }
-                    Err(gix::traverse::commit::simple::Error::Find { .. }) => {
+                    Err(err) if err.is_not_found() => {
                         is_shallow = true;
                         break;
                     }
diff --git a/gitoxide-core/src/index/checkout.rs b/gitoxide-core/src/index/checkout.rs
index 8c71380e184..a0b747bc957 100644
--- a/gitoxide-core/src/index/checkout.rs
+++ b/gitoxide-core/src/index/checkout.rs
@@ -4,7 +4,7 @@ use std::{
 };
 
 use anyhow::bail;
-use gix::{NestedProgress, Progress, objs::find::Error, worktree::state::checkout};
+use gix::{ExnResult, NestedProgress, Progress, worktree::state::checkout};
 
 use crate::{
     index,
@@ -107,7 +107,8 @@ pub fn checkout_exclusive(
             should_interrupt,
             opts,
         ),
-    }?;
+    }
+    .map_err(gix::Exn::into_error)?;
 
     files.show_throughput(start);
     bytes.show_throughput(start);
@@ -182,7 +183,7 @@ impl<Find> gix::objs::Find for EmptyOrDb<Find>
 where
     Find: gix::objs::Find,
 {
-    fn try_find<'a>(&self, id: &gix::oid, buf: &'a mut Vec<u8>) -> Result<Option<gix::objs::Data<'a>>, Error> {
+    fn try_find<'a>(&self, id: &gix::oid, buf: &'a mut Vec<u8>) -> ExnResult<Option<gix::objs::Data<'a>>> {
         if self.empty_files {
             // We always want to query the ODB here…
             let Some(kind) = self.db.try_find(id, buf)?.map(|d| d.kind) else {
@@ -205,7 +206,7 @@ where
 struct Empty;
 
 impl gix::objs::Find for Empty {
-    fn try_find<'a>(&self, id: &gix::oid, buffer: &'a mut Vec<u8>) -> Result<Option<gix::objs::Data<'a>>, Error> {
+    fn try_find<'a>(&self, id: &gix::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix::objs::Data<'a>>> {
         buffer.clear();
         Ok(Some(gix::objs::Data {
             kind: gix::object::Kind::Blob,
diff --git a/gitoxide-core/src/net.rs b/gitoxide-core/src/net.rs
index 72231b07181..0e6c55ad2c9 100644
--- a/gitoxide-core/src/net.rs
+++ b/gitoxide-core/src/net.rs
@@ -1,5 +1,8 @@
 use std::str::FromStr;
 
+#[cfg(any(feature = "async-client", feature = "blocking-client"))]
+use gix::ExnMessageResult;
+
 #[cfg(feature = "async-client")]
 use gix::protocol::transport::client::async_io as io_mode;
 #[cfg(feature = "blocking-client")]
@@ -45,7 +48,7 @@ mod impls {
 pub async fn connect<Url, E>(
     url: Url,
     options: io_mode::connect::Options,
-) -> Result<gix::protocol::SendFlushOnDrop<Box<dyn io_mode::Transport + Send>>, io_mode::connect::Error>
+) -> ExnMessageResult<gix::protocol::SendFlushOnDrop<Box<dyn io_mode::Transport + Send>>>
 where
     Url: TryInto<gix::url::Url, Error = E>,
     E: std::error::Error + Send + Sync + 'static,
diff --git a/gitoxide-core/src/organize.rs b/gitoxide-core/src/organize.rs
index 50d35734414..eae3ff688ef 100644
--- a/gitoxide-core/src/organize.rs
+++ b/gitoxide-core/src/organize.rs
@@ -209,8 +209,7 @@ fn handle(
             None => return Ok(()),
         })
         .join(to_relative({
-            let mut path =
-                gix_url::expand_path(None, url.path.as_bstr()).map_err(gix::url::expand_path::Error::into_error)?;
+            let mut path = gix_url::expand_path(None, url.path.as_bstr()).map_err(gix::Exn::into_error)?;
             match kind {
                 gix::repository::Kind::Submodule => {
                     unreachable!("BUG: We should not try to relocate submodules and not find them the first place")
diff --git a/gitoxide-core/src/pack/create.rs b/gitoxide-core/src/pack/create.rs
index 631db5376dc..837d2c0a303 100644
--- a/gitoxide-core/src/pack/create.rs
+++ b/gitoxide-core/src/pack/create.rs
@@ -5,6 +5,7 @@ use gix::{
     Count, NestedProgress, Progress, hash, hash::ObjectId, interrupt, objs::bstr::ByteVec, odb::pack,
     parallel::InOrderIter, prelude::Finalize, progress, traverse,
 };
+use gix::{ExnResult, error::ResultExt};
 
 use crate::OutputFormat;
 
@@ -106,7 +107,7 @@ where
     P: NestedProgress,
     P::SubProgress: 'static,
 {
-    type ObjectIdIter = dyn Iterator<Item = Result<ObjectId, Box<dyn std::error::Error + Send + Sync>>> + Send;
+    type ObjectIdIter = dyn Iterator<Item = ExnResult<ObjectId>> + Send;
 
     let repo = gix::discover(repository_path)?;
     let pack_compression = repo.pack_compression()?;
@@ -133,7 +134,7 @@ where
             let handle = repo.objects.into_shared_arc().to_cache_arc();
             let iter = Box::new(
                 traverse::commit::Simple::new(tips, handle.clone())
-                    .map(|res| res.map_err(|err| Box::new(err) as Box<_>).map(|c| c.id))
+                    .map(|res| res.map(|c| c.id))
                     .inspect(move |_| progress.inc()),
             );
             (handle, iter)
@@ -149,8 +150,8 @@ where
                         .lines()
                         .map(|hex_id| {
                             hex_id
-                                .map_err(|err| Box::new(err) as Box<_>)
-                                .and_then(|hex_id| ObjectId::from_hex(hex_id.as_bytes()).map_err(Into::into))
+                                .or_erased()
+                                .and_then(|hex_id| ObjectId::from_hex(hex_id.as_bytes()).or_erased())
                         })
                         .inspect(move |_| progress.inc()),
                 ),
@@ -358,16 +359,3 @@ struct Statistics {
     counts: pack::data::output::count::objects::Outcome,
     entries: pack::data::output::entry::iter_from_counts::Outcome,
 }
-
-pub mod input_iteration {
-    use gix::{hash, traverse};
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error("input objects couldn't be iterated completely")]
-        Iteration(#[from] traverse::commit::simple::Error),
-        #[error("An error occurred while reading hashes from standard input")]
-        InputLinesIo(#[from] std::io::Error),
-        #[error("Could not decode hex hash provided on standard input")]
-        HashDecode(#[from] hash::decode::Error),
-    }
-}
diff --git a/gitoxide-core/src/pack/explode.rs b/gitoxide-core/src/pack/explode.rs
index 68ab02000b2..372003d0f66 100644
--- a/gitoxide-core/src/pack/explode.rs
+++ b/gitoxide-core/src/pack/explode.rs
@@ -6,10 +6,14 @@ use std::{
 };
 
 use anyhow::{Result, anyhow};
+use gix::{
+    ExnResult,
+    error::{ErrorExt, ResultExt, message},
+};
 use gix::{
     NestedProgress,
     hash::ObjectId,
-    object, objs, odb,
+    object, odb,
     odb::{loose, pack},
     prelude::Write,
 };
@@ -64,32 +68,6 @@ impl From<SafetyCheck> for pack::index::traverse::SafetyCheck {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
-enum Error {
-    #[error("An IO error occurred while writing an object")]
-    Io(#[from] std::io::Error),
-    #[error("An object could not be written to the database")]
-    OdbWrite(#[from] loose::write::Error),
-    #[error("Failed to write {kind} object {id}")]
-    Write {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        kind: object::Kind,
-        id: ObjectId,
-    },
-    #[error("Object didn't verify after right after writing it")]
-    Verify(#[from] objs::data::verify::Error),
-    #[error("{kind} object wasn't re-encoded without change")]
-    ObjectEncodeMismatch {
-        #[source]
-        source: gix::hash::verify::Error,
-        kind: object::Kind,
-    },
-    #[error("The recently written file for loose object {id} could not be found")]
-    WrittenFileMissing { id: ObjectId },
-    #[error("The recently written file for loose object {id} cold not be read")]
-    WrittenFileCorrupt { source: loose::find::Error, id: ObjectId },
-}
-
 #[expect(
     clippy::large_enum_variant,
     reason = "will be removed once `gix-error` is used consistently"
@@ -101,31 +79,21 @@ enum OutputWriter {
 }
 
 impl gix::objs::Write for OutputWriter {
-    fn write_buf(&self, kind: object::Kind, from: &[u8]) -> Result<ObjectId, gix::objs::write::Error> {
+    fn write_buf(&self, kind: object::Kind, from: &[u8]) -> ExnResult<ObjectId> {
         match self {
             OutputWriter::Loose(db) => db.write_buf(kind, from),
             OutputWriter::Sink(db) => db.write_buf(kind, from),
         }
     }
 
-    fn write_buf_with_known_id(
-        &self,
-        kind: object::Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, gix::objs::write::Error> {
+    fn write_buf_with_known_id(&self, kind: object::Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         match self {
             OutputWriter::Loose(db) => db.write_buf_with_known_id(kind, from, id),
             OutputWriter::Sink(db) => db.write_buf_with_known_id(kind, from, id),
         }
     }
 
-    fn write_stream(
-        &self,
-        kind: object::Kind,
-        size: u64,
-        from: &mut dyn Read,
-    ) -> Result<ObjectId, gix::objs::write::Error> {
+    fn write_stream(&self, kind: object::Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         match self {
             OutputWriter::Loose(db) => db.write_stream(kind, size, from),
             OutputWriter::Sink(db) => db.write_stream(kind, size, from),
@@ -138,7 +106,7 @@ impl gix::objs::Write for OutputWriter {
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, gix::objs::write::Error> {
+    ) -> ExnResult<ObjectId> {
         match self {
             OutputWriter::Loose(db) => db.write_stream_with_known_id(kind, size, from, id),
             OutputWriter::Sink(db) => db.write_stream_with_known_id(kind, size, from, id),
@@ -184,12 +152,14 @@ pub fn pack_or_pack_index(
     use anyhow::Context;
 
     let path = pack_path.as_ref();
-    let bundle = pack::Bundle::at(path, object_hash).with_context(|| {
-        format!(
-            "Could not find .idx or .pack file from given file at '{}'",
-            path.display()
-        )
-    })?;
+    let bundle = pack::Bundle::at(path, object_hash)
+        .map_err(gix::Exn::into_error)
+        .with_context(|| {
+            format!(
+                "Could not find .idx or .pack file from given file at '{}'",
+                path.display()
+            )
+        })?;
 
     if !object_path.as_ref().is_none_or(|p| p.as_ref().is_dir()) {
         return Err(anyhow!(
@@ -228,11 +198,14 @@ pub fn pack_or_pack_index(
                     .flatten();
                 let mut read_buf = Vec::new();
                 move |object_kind, buf, index_entry, progress| {
-                    let written_id = out.write_buf(object_kind, buf).map_err(|err| Error::Write {
-                        source: err,
-                        kind: object_kind,
-                        id: index_entry.oid,
-                    })?;
+                    let written_id = out
+                        .write_buf(object_kind, buf)
+                        .or_raise_erased(|| {
+                            message!(
+                                "Failed to write {object_kind} object {}",
+                                index_entry.oid
+                            )
+                        })?;
                     if let Err(err) = written_id.verify(&index_entry.oid) {
                         if let object::Kind::Tree = object_kind {
                             progress.info(format!(
@@ -240,21 +213,26 @@ pub fn pack_or_pack_index(
                                 index_entry.oid, written_id
                             ));
                         } else {
-                            return Err(Error::ObjectEncodeMismatch {
-                                source: err,
-                                kind: object_kind,
-                            });
+                            return Err(err
+                                .raise(message!("{object_kind} object wasn't re-encoded without change"))
+                                .erased());
                         }
                     }
                     if let Some(verifier) = loose_odb.as_ref() {
                         let obj = verifier
                             .try_find(&written_id, &mut read_buf)
-                            .map_err(|err| Error::WrittenFileCorrupt {
-                                source: err,
-                                id: written_id,
+                            .or_raise_erased(|| {
+                                message!(
+                                    "The recently written file for loose object {written_id} could not be read"
+                                )
                             })?
-                            .ok_or(Error::WrittenFileMissing { id: written_id })?;
-                        obj.verify_checksum(&written_id)?;
+                            .ok_or_else(|| {
+                                gix::error::not_found(format!(
+                                    "The recently written file for loose object {written_id} could not be found"
+                                ))
+                                .raise_erased()
+                            })?;
+                        obj.verify_checksum(&written_id).or_erased()?;
                     }
                     Ok(())
                 }
@@ -267,6 +245,7 @@ pub fn pack_or_pack_index(
                 make_pack_lookup_cache: pack::cache::lru::StaticLinkedList::<64>::default,
             },
         )
+        .map_err(gix::Exn::into_error)
         .with_context(|| "Failed to explode the entire pack - some loose objects may have been created nonetheless")?;
 
     let (index_path, data_path) = (bundle.index.path().to_owned(), bundle.pack.path().to_owned());
diff --git a/gitoxide-core/src/pack/index.rs b/gitoxide-core/src/pack/index.rs
index e22ccee4add..3e0af6a4470 100644
--- a/gitoxide-core/src/pack/index.rs
+++ b/gitoxide-core/src/pack/index.rs
@@ -112,6 +112,7 @@ pub fn from_pack(
             options,
         ),
     }
+    .map_err(gix::Exn::into_error)
     .with_context(|| "Failed to write pack and index")?;
     match format {
         OutputFormat::Human => drop(human_output(out, res)),
diff --git a/gitoxide-core/src/pack/receive.rs b/gitoxide-core/src/pack/receive.rs
index 23540759a7f..3b88dc221c8 100644
--- a/gitoxide-core/src/pack/receive.rs
+++ b/gitoxide-core/src/pack/receive.rs
@@ -9,7 +9,11 @@ use crate::{OutputFormat, net, pack::receive::protocol::fetch::negotiate};
 use gix::protocol::transport::client::async_io::connect;
 #[cfg(feature = "blocking-client")]
 use gix::protocol::transport::client::blocking_io::connect;
-use gix::{DynNestedProgress, config::tree::Key, protocol::bisync, remote::fetch::Error};
+use gix::{DynNestedProgress, config::tree::Key, protocol::bisync};
+use gix::{
+    ExnMessageResult,
+    error::{ResultExt, message},
+};
 pub use gix::{
     NestedProgress, Progress,
     hash::ObjectId,
@@ -71,14 +75,17 @@ where
         vec![("agent".into(), Some(agent.clone()))],
         &mut progress,
     )
-    .await?;
+    .await
+    .map_err(gix::Exn::into_error)?;
     if wanted_refs.is_empty() {
         wanted_refs.push("refs/heads/*:refs/remotes/origin/*".into());
     }
     let fetch_refspecs: Vec<_> = wanted_refs
         .into_iter()
         .map(|ref_name| {
-            gix::refspec::parse(ref_name.as_bstr(), gix::refspec::parse::Operation::Fetch).map(|r| r.to_owned())
+            gix::refspec::parse(ref_name.as_bstr(), gix::refspec::parse::Operation::Fetch)
+                .map(|r| r.to_owned())
+                .map_err(gix::Exn::into_error)
         })
         .collect::<Result<_, _>>()?;
     let user_agent = ("agent", Some(agent.clone()));
@@ -88,22 +95,32 @@ where
         extra_refspecs: vec![],
     };
 
-    let fetch_refmap = handshake.prepare_lsrefs_or_extract_refmap(user_agent.clone(), true, context)?;
+    let fetch_refmap = handshake
+        .prepare_lsrefs_or_extract_refmap(user_agent.clone(), true, context)
+        .map_err(gix::Exn::into_error)?;
 
     #[cfg(feature = "async-client")]
     let refmap = fetch_refmap
         .fetch_async(&mut progress, &mut transport.inner, trace_packetlines)
-        .await?;
+        .await
+        .map_err(gix::Exn::into_error)?;
 
     #[cfg(feature = "blocking-client")]
-    let refmap = fetch_refmap.fetch_blocking(&mut progress, &mut transport.inner, trace_packetlines)?;
+    let refmap = fetch_refmap
+        .fetch_blocking(&mut progress, &mut transport.inner, trace_packetlines)
+        .map_err(gix::Exn::into_error)?;
 
     if refmap.is_missing_required_mapping() {
-        return Err(Error::NoMapping {
-            refspecs: refmap.refspecs.clone(),
-            num_remote_refs: refmap.remote_refs.len(),
-        }
-        .into());
+        anyhow::bail!(
+            "None of the refspec(s) {} matched any of the {} refs on the remote",
+            refmap
+                .refspecs
+                .iter()
+                .map(|spec| spec.to_ref().instruction().to_bstring().to_string())
+                .collect::<Vec<_>>()
+                .join(", "),
+            refmap.remote_refs.len()
+        );
     }
 
     let mut negotiate = Negotiate { refmap: &refmap };
@@ -122,6 +139,7 @@ where
                 ctx.object_hash,
                 ctx.format,
             )
+            .or_raise_erased(|| message("Failed to receive the pack"))
             .map(|_| true)
         },
         progress,
@@ -139,7 +157,8 @@ where
             reject_shallow_remote: true,
         },
     )
-    .await?;
+    .await
+    .map_err(gix::Exn::into_error)?;
     Ok(())
 }
 
@@ -148,7 +167,7 @@ struct Negotiate<'a> {
 }
 
 impl gix::protocol::fetch::Negotiate for Negotiate<'_> {
-    fn mark_complete_and_common_ref(&mut self) -> Result<negotiate::Action, negotiate::Error> {
+    fn mark_complete_and_common_ref(&mut self) -> ExnMessageResult<negotiate::Action> {
         Ok(negotiate::Action::MustNegotiate {
             remote_ref_target_known: vec![], /* we don't really negotiate */
         })
@@ -168,7 +187,7 @@ impl gix::protocol::fetch::Negotiate for Negotiate<'_> {
         _state: &mut negotiate::one_round::State,
         _arguments: &mut Arguments,
         _previous_response: Option<&Response>,
-    ) -> Result<(negotiate::Round, bool), negotiate::Error> {
+    ) -> ExnMessageResult<(negotiate::Round, bool)> {
         Ok((
             negotiate::Round {
                 haves_sent: 0,
diff --git a/gitoxide-core/src/pack/verify.rs b/gitoxide-core/src/pack/verify.rs
index 3aefaee09eb..edf3988cc03 100644
--- a/gitoxide-core/src/pack/verify.rs
+++ b/gitoxide-core/src/pack/verify.rs
@@ -119,13 +119,16 @@ where
     };
     let res = match ext {
         "pack" => {
-            let pack = odb::pack::data::File::at(path, object_hash).with_context(|| "Could not open pack file")?;
+            let pack = odb::pack::data::File::at(path, object_hash)
+                .map_err(gix::Exn::into_error)
+                .with_context(|| "Could not open pack file")?;
             pack.verify_checksum(&mut progress.add_child("Sha1 of pack"), should_interrupt)
                 .map(|id| (id, None))?
         }
         "idx" => {
-            let idx =
-                odb::pack::index::File::at(path, object_hash).with_context(|| "Could not open pack index file")?;
+            let idx = odb::pack::index::File::at(path, object_hash)
+                .map_err(gix::Exn::into_error)
+                .with_context(|| "Could not open pack index file")?;
             let packfile_path = path.with_extension("pack");
             let pack = odb::pack::data::File::at(&packfile_path, object_hash)
                 .map_err(|e| {
@@ -154,6 +157,7 @@ where
                 should_interrupt,
             )
             .map(|o| (o.actual_index_checksum, o.pack_traverse_statistics))
+            .map_err(gix::Exn::into_error)
             .with_context(|| "Verification failure")?
         }
         "" => match path.file_name() {
diff --git a/gitoxide-core/src/query/engine/update.rs b/gitoxide-core/src/query/engine/update.rs
index b345c62d9b4..69fad65d04f 100644
--- a/gitoxide-core/src/query/engine/update.rs
+++ b/gitoxide-core/src/query/engine/update.rs
@@ -7,11 +7,10 @@ use std::{
 
 use anyhow::{anyhow, bail};
 use gix::{
-    Count, Progress,
+    Count, ExnResult, Progress,
     bstr::{BStr, BString, ByteSlice},
     diff::{blob::platform::prepare_diff::Operation, rewrites::CopySource},
     features::progress,
-    objs::find::Error,
     parallel::{InOrderIter, SequenceId},
     prelude::ObjectIdExt,
 };
@@ -317,7 +316,7 @@ pub fn update(
                                                         });
                                                     }
                                                 }
-                                                Ok::<_, Infallible>(std::ops::ControlFlow::Continue(()))
+                                                Ok::<_, gix::Exn>(std::ops::ControlFlow::Continue(()))
                                             })?;
                                         out_chunk.push(CommitDiffStats {
                                             id: commit,
@@ -385,7 +384,7 @@ pub fn update(
         where
             Find: gix::prelude::Find + Clone,
         {
-            fn try_find<'b>(&self, id: &gix::oid, buf: &'b mut Vec<u8>) -> Result<Option<gix::objs::Data<'b>>, Error> {
+            fn try_find<'b>(&self, id: &gix::oid, buf: &'b mut Vec<u8>) -> ExnResult<Option<gix::objs::Data<'b>>> {
                 let obj = self.inner.try_find(id, buf)?;
                 let Some(obj) = obj else { return Ok(None) };
                 if !obj.kind.is_commit() {
@@ -441,7 +440,7 @@ pub fn update(
                         break;
                     }
                 }
-                Err(gix::traverse::commit::simple::Error::Find { .. }) => {
+                Err(traverse_err) if traverse_err.is_not_found() => {
                     writeln!(err, "shallow repository - commit history is truncated").ok();
                     break;
                 }
diff --git a/gitoxide-core/src/repository/credential.rs b/gitoxide-core/src/repository/credential.rs
index 06ce86447f2..aff1ac697bc 100644
--- a/gitoxide-core/src/repository/credential.rs
+++ b/gitoxide-core/src/repository/credential.rs
@@ -1,34 +1,30 @@
-#[derive(Debug, thiserror::Error)]
-enum Error {
-    #[error(transparent)]
-    UrlParse(#[from] gix::Error),
-    #[error(transparent)]
-    Configuration(#[from] gix::config::credential_helpers::Error),
-    #[error(transparent)]
-    Protocol(#[from] gix::credentials::protocol::Error),
-    #[error(transparent)]
-    ConfigLoad(#[from] gix::config::file::init::from_paths::Error),
-}
-
+use gix::ExnResult;
 pub fn function(repo: Option<gix::Repository>, action: gix::credentials::program::main::Action) -> anyhow::Result<()> {
     use gix::credentials::program::main::Action::*;
+    use gix::error::{OptionExt, ResultExt, message};
     gix::credentials::program::main(
         Some(action.as_str().into()),
         std::io::stdin(),
         std::io::stdout(),
         gix::credentials::protocol::ContextOptions::default(),
-        |action, context| -> Result<_, Error> {
+        |action, context| -> ExnResult<_> {
             let url = context
                 .url
                 .clone()
                 .or_else(|| context.to_url())
-                .ok_or(Error::Protocol(gix::credentials::protocol::Error::UrlMissing))?;
+                .ok_or_raise_erased(|| {
+                    gix::error::validation("Either 'url' field or both 'protocol' and 'host' fields must be provided")
+                })?;
 
-            let url = gix::url::parse(&url).map_err(gix::Exn::into_error)?;
+            let url = gix::url::parse(&url).or_erased()?;
             let (mut cascade, _action, prompt_options) = match repo {
-                Some(ref repo) => repo.config_snapshot().credential_helpers(url)?,
+                Some(ref repo) => repo
+                    .config_snapshot()
+                    .credential_helpers(url)
+                    .or_raise_erased(|| message("Could not configure credential helpers"))?,
                 None => {
-                    let config = gix::config::File::from_globals()?;
+                    let config = gix::config::File::from_globals()
+                        .or_raise_erased(|| message("Could not load global configuration"))?;
                     let environment = gix::open::permissions::Environment::all();
                     gix::config::credential_helpers(
                         url,
@@ -37,7 +33,8 @@ pub fn function(repo: Option<gix::Repository>, action: gix::credentials::program
                         |_| true, /* section filter */
                         environment,
                         false, /* use http path (override, uses configuration now)*/
-                    )?
+                    )
+                    .or_raise_erased(|| message("Could not configure credential helpers"))?
                 }
             };
             cascade
@@ -50,8 +47,8 @@ pub fn function(repo: Option<gix::Repository>, action: gix::credentials::program
                     prompt_options,
                 )
                 .map(|outcome| outcome.and_then(|outcome| (&outcome.next).try_into().ok()))
-                .map_err(Into::into)
         },
     )
-    .map_err(Into::into)
+    .map_err(gix::Exn::into_error)?;
+    Ok(())
 }
diff --git a/gitoxide-core/src/repository/diff.rs b/gitoxide-core/src/repository/diff.rs
index 35ab1773335..94ada38e02b 100644
--- a/gitoxide-core/src/repository/diff.rs
+++ b/gitoxide-core/src/repository/diff.rs
@@ -124,10 +124,10 @@ fn resolve_revspec(
 
     match result {
         Err(err) => {
-            // When the revspec is just a name, the delegate tries to resolve a reference which fails.
-            // We extract the error from the tree to learn the name, and treat it as file.
-            let not_found = err.downcast_any_ref::<gix::refs::file::find::existing::Error>();
-            if let Some(gix::refs::file::find::existing::Error::NotFound { name }) = not_found {
+            // `is_not_found()` also matches missing objects, which must not become filesystem paths.
+            // Extract the missing reference's name, which may differ from the revspec after following symbolic refs.
+            let not_found = err.downcast_any_ref::<gix::refs::file::find::NotFound>();
+            if let Some(gix::refs::file::find::NotFound { name }) = not_found {
                 let root = repo.workdir().map(ToOwned::to_owned);
                 let name = gix::path::os_string_into_bstring(name.into())?;
 
diff --git a/gitoxide-core/src/repository/merge/commit.rs b/gitoxide-core/src/repository/merge/commit.rs
index 84541a33c9b..65a048b102f 100644
--- a/gitoxide-core/src/repository/merge/commit.rs
+++ b/gitoxide-core/src/repository/merge/commit.rs
@@ -1,4 +1,4 @@
-use anyhow::{Context, anyhow, bail};
+use anyhow::{Context, bail};
 use gix::{
     bstr::{BString, ByteSlice},
     merge::tree::TreatAsUnresolved,
@@ -66,7 +66,7 @@ pub fn commit(
                 written += 1;
                 repo.write(tree)
             })
-            .map_err(|err| anyhow!("{err}"))?;
+            .map_err(gix::Exn::into_error)?;
         writeln!(out, "{tree_id} (wrote {written} trees)")?;
     }
 
diff --git a/gitoxide-core/src/repository/merge/file.rs b/gitoxide-core/src/repository/merge/file.rs
index 4e6b70f1753..34c085e46f7 100644
--- a/gitoxide-core/src/repository/merge/file.rs
+++ b/gitoxide-core/src/repository/merge/file.rs
@@ -79,7 +79,7 @@ pub fn file(
     let (pick, resolution) = platform.merge(&mut buf, labels, &repo.command_context()?)?;
     let buf = platform
         .buffer_by_pick(pick)
-        .map_err(|_| anyhow!("Participating object was too large"))?
+        .map_err(|()| anyhow!("Participating object was too large"))?
         .unwrap_or(&buf);
     out.write_all(buf)?;
 
diff --git a/gitoxide-core/src/repository/merge/tree.rs b/gitoxide-core/src/repository/merge/tree.rs
index 78e6e1166ae..d91fab9da8b 100644
--- a/gitoxide-core/src/repository/merge/tree.rs
+++ b/gitoxide-core/src/repository/merge/tree.rs
@@ -14,7 +14,7 @@ pub(super) mod function {
 
     use std::collections::BTreeSet;
 
-    use anyhow::{Context, anyhow, bail};
+    use anyhow::{Context, bail};
     use gix::{
         bstr::{BString, ByteSlice},
         merge::tree::TreatAsUnresolved,
@@ -100,7 +100,7 @@ pub(super) mod function {
                     written += 1;
                     repo.write(tree)
                 })
-                .map_err(|err| anyhow!("{err}"))?;
+                .map_err(gix::Exn::into_error)?;
             writeln!(out, "{tree_id} (wrote {written} trees)")?;
             tree_id
         };
@@ -139,7 +139,7 @@ pub(super) mod function {
     fn persist_in_memory_objects(repo: &mut gix::Repository) -> anyhow::Result<()> {
         let objects = repo.objects.take_object_memory().expect("always write in memory first");
         for (_id, (kind, data)) in objects.iter() {
-            repo.write_buf(*kind, data).map_err(|err| anyhow!("{err}"))?;
+            repo.write_buf(*kind, data).map_err(gix::Exn::into_error)?;
         }
         Ok(())
     }
diff --git a/gitoxide-core/src/repository/revision/explain.rs b/gitoxide-core/src/repository/revision/explain.rs
index f2c042e6c86..f5098eab6c3 100644
--- a/gitoxide-core/src/repository/revision/explain.rs
+++ b/gitoxide-core/src/repository/revision/explain.rs
@@ -1,6 +1,6 @@
 use anyhow::bail;
 use gix::{
-    Exn,
+    ExnResult,
     bstr::{BStr, BString},
     revision::plumbing::{
         spec,
@@ -41,7 +41,7 @@ impl<'a> Explain<'a> {
             err: None,
         }
     }
-    fn prefix(&mut self) -> Result<(), Exn> {
+    fn prefix(&mut self) -> ExnResult {
         self.call += 1;
         write!(self.out, "{:02}. ", self.call).ok();
         Ok(())
@@ -57,18 +57,14 @@ impl<'a> Explain<'a> {
 }
 
 impl delegate::Revision for Explain<'_> {
-    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
+    fn find_ref(&mut self, name: &BStr) -> ExnResult {
         self.prefix()?;
         self.ref_name = Some(name.into());
         writeln!(self.out, "Lookup the '{name}' reference").ok();
         Ok(())
     }
 
-    fn disambiguate_prefix(
-        &mut self,
-        prefix: gix::hash::Prefix,
-        hint: Option<delegate::PrefixHint<'_>>,
-    ) -> Result<(), Exn> {
+    fn disambiguate_prefix(&mut self, prefix: gix::hash::Prefix, hint: Option<delegate::PrefixHint<'_>>) -> ExnResult {
         self.prefix()?;
         self.oid_prefix = Some(prefix);
         writeln!(
@@ -86,7 +82,7 @@ impl delegate::Revision for Explain<'_> {
         Ok(())
     }
 
-    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn> {
+    fn reflog(&mut self, query: ReflogLookup) -> ExnResult {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let ref_name: &BStr = self.ref_name.as_ref().map_or_else(|| "HEAD".into(), AsRef::as_ref);
@@ -103,14 +99,14 @@ impl delegate::Revision for Explain<'_> {
         Ok(())
     }
 
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> ExnResult {
         self.prefix()?;
         self.has_implicit_anchor = true;
         writeln!(self.out, "Find the {branch_no}th checked-out branch of 'HEAD'").ok();
         Ok(())
     }
 
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn> {
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> ExnResult {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let ref_info = match self.ref_name.as_ref() {
@@ -132,7 +128,7 @@ impl delegate::Revision for Explain<'_> {
 }
 
 impl delegate::Navigate for Explain<'_> {
-    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn> {
+    fn traverse(&mut self, kind: Traversal) -> ExnResult {
         self.prefix()?;
         let name = self.revision_name();
         writeln!(
@@ -147,7 +143,7 @@ impl delegate::Navigate for Explain<'_> {
         Ok(())
     }
 
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn> {
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> ExnResult {
         self.prefix()?;
         writeln!(
             self.out,
@@ -163,7 +159,7 @@ impl delegate::Navigate for Explain<'_> {
         Ok(())
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> ExnResult {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let negate_text = if negated { "does not match" } else { "matches" };
@@ -188,7 +184,7 @@ impl delegate::Navigate for Explain<'_> {
         Ok(())
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> ExnResult {
         self.prefix()?;
         self.has_implicit_anchor = true;
         writeln!(
@@ -210,7 +206,7 @@ impl delegate::Navigate for Explain<'_> {
 }
 
 impl delegate::Kind for Explain<'_> {
-    fn kind(&mut self, kind: spec::Kind) -> Result<(), Exn> {
+    fn kind(&mut self, kind: spec::Kind) -> ExnResult {
         self.prefix()?;
         self.call = 0;
         writeln!(
@@ -232,7 +228,7 @@ impl delegate::Kind for Explain<'_> {
 }
 
 impl Delegate for Explain<'_> {
-    fn done(&mut self) -> Result<(), Exn> {
+    fn done(&mut self) -> ExnResult {
         if !self.has_implicit_anchor && self.ref_name.is_none() && self.oid_prefix.is_none() {
             self.err = Some("Incomplete specification lacks its anchor, like a reference or object name".into());
         }
diff --git a/gix-actor/Cargo.toml b/gix-actor/Cargo.toml
index 53ed2a4b336..52c5e330fa8 100644
--- a/gix-actor/Cargo.toml
+++ b/gix-actor/Cargo.toml
@@ -33,6 +33,7 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 pretty_assertions = "1.0.0"
 gix-testtools = { path = "../tests/tools", default-features = false }
 gix-hash = { path = "../gix-hash" }
diff --git a/gix-actor/src/identity.rs b/gix-actor/src/identity.rs
index 81c09a598f9..3851e19246e 100644
--- a/gix-actor/src/identity.rs
+++ b/gix-actor/src/identity.rs
@@ -1,4 +1,5 @@
 use bstr::ByteSlice;
+use gix_error::ExnMessageResult;
 
 use crate::{Identity, IdentityRef, signature::decode};
 
@@ -6,7 +7,7 @@ impl<'a> IdentityRef<'a> {
     /// Deserialize an identity from the given `data`.
     ///
     /// Typical input is `Name <name@example.com> 1700000000 +0000`.
-    pub fn from_bytes(mut data: &'a [u8]) -> Result<Self, gix_error::ValidationError> {
+    pub fn from_bytes(mut data: &'a [u8]) -> ExnMessageResult<Self> {
         Self::from_bytes_consuming(&mut data)
     }
 
@@ -14,7 +15,7 @@ impl<'a> IdentityRef<'a> {
     ///
     /// Typical input is `Name <name@example.com> 1700000000 +0000`; on success,
     /// `data` points to the bytes immediately after the closing `>`.
-    pub fn from_bytes_consuming(data: &mut &'a [u8]) -> Result<Self, gix_error::ValidationError> {
+    pub fn from_bytes_consuming(data: &mut &'a [u8]) -> ExnMessageResult<Self> {
         decode::identity(data)
     }
 
@@ -41,6 +42,9 @@ mod write {
     /// Output
     impl Identity {
         /// Serialize this instance to `out` in the git serialization format for signatures (but without timestamp).
+        /// Invalid name or email bytes are retained as `input` in the I/O error.
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
         pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
             self.to_ref().write_to(out)
         }
@@ -48,6 +52,9 @@ mod write {
 
     impl IdentityRef<'_> {
         /// Serialize this instance to `out` in the git serialization format for signatures (but without timestamp).
+        /// Invalid name or email bytes are retained as `input` in the I/O error.
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
         pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
             out.write_all(validated_token(self.name).map_err(std::io::Error::other)?)?;
             out.write_all(b" ")?;
diff --git a/gix-actor/src/signature/decode.rs b/gix-actor/src/signature/decode.rs
index 3889756734a..ba63165be49 100644
--- a/gix-actor/src/signature/decode.rs
+++ b/gix-actor/src/signature/decode.rs
@@ -1,11 +1,12 @@
 pub(crate) mod function {
     use bstr::ByteSlice;
-    use gix_error::ValidationError;
+    use gix_error::ExnMessageResult;
+    use gix_error::validation;
 
     use crate::{IdentityRef, SignatureRef};
 
     /// Parse a signature from the bytes input `i`, and change it to point to the unparsed bytes afterwards.
-    pub fn decode<'a>(i: &mut &'a [u8]) -> Result<SignatureRef<'a>, ValidationError> {
+    pub fn decode<'a>(i: &mut &'a [u8]) -> ExnMessageResult<SignatureRef<'a>> {
         let identity = identity(i)?;
         if i.first() == Some(&b' ') {
             *i = &i[1..];
@@ -26,23 +27,23 @@ pub(crate) mod function {
     }
 
     /// Parse an identity from the bytes input `i` (like `name <email>`).
-    pub fn identity<'a>(i: &mut &'a [u8]) -> Result<IdentityRef<'a>, ValidationError> {
+    pub fn identity<'a>(i: &mut &'a [u8]) -> ExnMessageResult<IdentityRef<'a>> {
         let eol_idx = i.find_byte(b'\n').unwrap_or(i.len());
         let right_delim_idx = i[..eol_idx]
             .rfind_byte(b'>')
-            .ok_or_else(|| ValidationError::new("Closing '>' not found"))?;
+            .ok_or_else(|| validation("Closing '>' not found"))?;
         let i_name_and_email = &i[..right_delim_idx];
         let skip_from_right = i_name_and_email.iter().rev().take_while(|b| **b == b'>').count();
         let left_delim_idx = i_name_and_email
             .find_byte(b'<')
-            .ok_or_else(|| ValidationError::new("Opening '<' not found"))?;
+            .ok_or_else(|| validation("Opening '<' not found"))?;
         let skip_from_left = i[left_delim_idx..].iter().take_while(|b| **b == b'<').count();
         let mut name = i[..left_delim_idx].as_bstr();
         name = name.strip_suffix(b" ").unwrap_or(name).as_bstr();
 
         let email = i
             .get(left_delim_idx + skip_from_left..right_delim_idx - skip_from_right)
-            .ok_or_else(|| ValidationError::new("Skipped parts run into each other"))?
+            .ok_or_else(|| validation("Skipped parts run into each other"))?
             .as_bstr();
         *i = i.get(right_delim_idx + 1..).unwrap_or(&[]);
         Ok(IdentityRef { name, email })
@@ -57,11 +58,11 @@ pub use function::identity;
 #[cfg(test)]
 mod tests {
     mod parse_signature {
-        use gix_error::ValidationError;
+        use gix_error::ExnMessageResult;
 
         use crate::SignatureRef;
 
-        fn decode(mut i: &[u8]) -> Result<(&[u8], SignatureRef<'_>), ValidationError> {
+        fn decode(mut i: &[u8]) -> ExnMessageResult<(&[u8], SignatureRef<'_>)> {
             SignatureRef::from_bytes_consuming(&mut i).map(|signature| (i, signature))
         }
 
@@ -142,12 +143,8 @@ mod tests {
 
         #[test]
         fn invalid_signature() {
-            assert_eq!(
-                decode(b"hello < 12345 -1215")
-                    .expect_err("parse fails as > is missing")
-                    .to_string(),
-                "Closing '>' not found"
-            );
+            insta::assert_debug_snapshot!(decode(b"hello < 12345 -1215")
+                    .expect_err("parse fails as > is missing"), "invalid signature", @"Closing '>' not found");
         }
 
         #[test]
diff --git a/gix-actor/src/signature/mod.rs b/gix-actor/src/signature/mod.rs
index df909737064..71c4232b0d5 100644
--- a/gix-actor/src/signature/mod.rs
+++ b/gix-actor/src/signature/mod.rs
@@ -1,5 +1,6 @@
 mod _ref {
     use bstr::ByteSlice;
+    use gix_error::ExnMessageResult;
 
     use crate::{IdentityRef, Signature, SignatureRef, signature::decode};
 
@@ -8,7 +9,7 @@ mod _ref {
         /// Deserialize a signature from the given `data`.
         ///
         /// Typical input is `Name <name@example.com> 1700000000 +0000`.
-        pub fn from_bytes(mut data: &'a [u8]) -> Result<SignatureRef<'a>, gix_error::ValidationError> {
+        pub fn from_bytes(mut data: &'a [u8]) -> ExnMessageResult<SignatureRef<'a>> {
             Self::from_bytes_consuming(&mut data)
         }
 
@@ -17,12 +18,12 @@ mod _ref {
         /// Typical input is `Name <name@example.com> 1700000000 +0000`; on
         /// success, `data` points to the bytes immediately after the parsed
         /// signature.
-        pub fn from_bytes_consuming(data: &mut &'a [u8]) -> Result<SignatureRef<'a>, gix_error::ValidationError> {
+        pub fn from_bytes_consuming(data: &mut &'a [u8]) -> ExnMessageResult<SignatureRef<'a>> {
             decode(data)
         }
 
         /// Try to parse the timestamp and create an owned instance from this shared one.
-        pub fn to_owned(&self) -> Result<Signature, gix_date::Error> {
+        pub fn to_owned(&self) -> ExnMessageResult<Signature> {
             Ok(Signature {
                 name: self.name.to_owned(),
                 email: self.email.to_owned(),
@@ -65,8 +66,8 @@ mod _ref {
 
         /// 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::Error> {
-            self.time.parse()
+        pub fn time(&self) -> ExnMessageResult<gix_date::Time> {
+            Ok(self.time.parse()?)
         }
     }
 }
@@ -104,12 +105,16 @@ mod convert {
 pub(crate) mod write {
     use bstr::{BStr, ByteSlice};
     use gix_date::parse::TimeBuf;
+    use gix_error::ExnMessageResult;
 
     use crate::{Signature, SignatureRef};
 
     /// Output
     impl Signature {
         /// Serialize this instance to `out` in the git serialization format for actors.
+        /// Invalid signature field bytes are retained as `input` in the I/O error.
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
         pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
             let mut buf = TimeBuf::default();
             self.to_ref(&mut buf).write_to(out)
@@ -122,6 +127,9 @@ pub(crate) mod write {
 
     impl SignatureRef<'_> {
         /// Serialize this instance to `out` in the git serialization format for actors.
+        /// Invalid signature field bytes are retained as `input` in the I/O error.
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
         pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
             out.write_all(validated_token(self.name).map_err(std::io::Error::other)?)?;
             out.write_all(b" ")?;
@@ -136,12 +144,13 @@ pub(crate) mod write {
         }
     }
 
-    pub(crate) fn validated_token(name: &BStr) -> Result<&BStr, gix_error::ValidationError> {
+    pub(crate) fn validated_token(name: &BStr) -> ExnMessageResult<&BStr> {
         if name.find_byteset(b"<>\n").is_some() {
-            return Err(gix_error::ValidationError::new_with_input(
-                "Signature name or email must not contain '<', '>' or \\n",
-                name,
-            ));
+            return Err(
+                gix_error::validation("Signature name or email must not contain '<', '>' or \\n")
+                    .with("input", name)
+                    .into(),
+            );
         }
         Ok(name)
     }
diff --git a/gix-actor/tests/actor/identity.rs b/gix-actor/tests/actor/identity.rs
index 7f600c01949..6a3a96bfe96 100644
--- a/gix-actor/tests/actor/identity.rs
+++ b/gix-actor/tests/actor/identity.rs
@@ -22,6 +22,7 @@ fn round_trip() -> gix_testtools::Result {
 
 #[test]
 fn lenient_parsing() -> gix_testtools::Result {
+    let mut error_snapshots = Vec::new();
     for (input, expected_email) in [
         (
             "First Last<<fl <First Last<fl@openoffice.org >> >",
@@ -41,11 +42,19 @@ fn lenient_parsing() -> gix_testtools::Result {
         let signature: Identity = identity.into();
         let mut output = Vec::new();
         let err = signature.write_to(&mut output).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            format!(r#"Signature name or email must not contain '<', '>' or \n: {expected_email:?}"#),
-            "this isn't roundtrippable as the name is technically incorrect - must not contain brackets"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(error_snapshots, "lenient parsing", @r#"
+    [
+        Custom {
+            kind: Other,
+            error: Signature name or email must not contain '<', '>' or \n, "input"="fl <First Last<fl@openoffice.org >> ",
+        },
+        Custom {
+            kind: Other,
+            error: Signature name or email must not contain '<', '>' or \n, "input"="fl <First Last<fl@openoffice.org",
+        },
+    ]
+    "#);
     Ok(())
 }
diff --git a/gix-actor/tests/actor/signature.rs b/gix-actor/tests/actor/signature.rs
index c5191b2a5a2..72d3537671a 100644
--- a/gix-actor/tests/actor/signature.rs
+++ b/gix-actor/tests/actor/signature.rs
@@ -10,10 +10,12 @@ mod write_to {
                 email: "ok".into(),
                 time: Time::default(),
             };
-            assert_eq!(
-                format!("{:?}", signature.write_to(&mut Vec::new())),
-                "Err(Custom { kind: Other, error: ValidationError { message: \"Signature name or email must not contain '<', '>' or \\\\n\", input: Some(\"invalid < middlename\") } })"
-            );
+            insta::assert_debug_snapshot!(signature.write_to(&mut Vec::new()).expect_err("the signature is invalid"), "signature names reject angle brackets", @r#"
+            Custom {
+                kind: Other,
+                error: Signature name or email must not contain '<', '>' or \n, "input"="invalid < middlename",
+            }
+            "#);
         }
 
         #[test]
@@ -23,10 +25,12 @@ mod write_to {
                 email: "server>.example.com".into(),
                 time: Time::default(),
             };
-            assert_eq!(
-                format!("{:?}", signature.write_to(&mut Vec::new())),
-                "Err(Custom { kind: Other, error: ValidationError { message: \"Signature name or email must not contain '<', '>' or \\\\n\", input: Some(\"server>.example.com\") } })"
-            );
+            insta::assert_debug_snapshot!(signature.write_to(&mut Vec::new()).expect_err("the signature is invalid"), "signature email addresses reject angle brackets", @r#"
+            Custom {
+                kind: Other,
+                error: Signature name or email must not contain '<', '>' or \n, "input"="server>.example.com",
+            }
+            "#);
         }
 
         #[test]
@@ -36,10 +40,12 @@ mod write_to {
                 email: "name@example.com".into(),
                 time: Time::default(),
             };
-            assert_eq!(
-                format!("{:?}", signature.write_to(&mut Vec::new())),
-                "Err(Custom { kind: Other, error: ValidationError { message: \"Signature name or email must not contain '<', '>' or \\\\n\", input: Some(\"hello\\nnewline\") } })"
-            );
+            insta::assert_debug_snapshot!(signature.write_to(&mut Vec::new()).expect_err("the signature is invalid"), "signature names reject newlines", @r#"
+            Custom {
+                kind: Other,
+                error: Signature name or email must not contain '<', '>' or \n, "input"="hello\nnewline",
+            }
+            "#);
         }
     }
 }
diff --git a/gix-archive/src/lib.rs b/gix-archive/src/lib.rs
index c93ed9de21b..e13884bd82a 100644
--- a/gix-archive/src/lib.rs
+++ b/gix-archive/src/lib.rs
@@ -18,9 +18,6 @@
 
 use bstr::BString;
 
-/// The error returned by [`write_stream()`].
-pub type Error = gix_error::Exn<gix_error::Message>;
-
 /// The supported container formats for use in [`write_stream()`].
 #[derive(Default, PartialEq, Eq, Copy, Clone, Debug)]
 pub enum Format {
diff --git a/gix-archive/src/write.rs b/gix-archive/src/write.rs
index d8fcab29010..035a396cbac 100644
--- a/gix-archive/src/write.rs
+++ b/gix-archive/src/write.rs
@@ -1,9 +1,10 @@
 #[cfg(any(feature = "tar", feature = "tar_gz", feature = "zip"))]
 use gix_error::ResultExt;
 use gix_error::{ErrorExt, message};
+use gix_error::{ExnMessageResult, ExnResult};
 use gix_worktree_stream::{Entry, Stream};
 
-use crate::{Error, Format, Options};
+use crate::{Format, Options};
 
 #[cfg(feature = "zip")]
 use std::io::Write;
@@ -22,9 +23,9 @@ pub fn write_stream<NextFn>(
     mut next_entry: NextFn,
     out: impl std::io::Write,
     opts: Options,
-) -> Result<(), Error>
+) -> ExnMessageResult
 where
-    NextFn: FnMut(&mut Stream) -> Result<Option<Entry<'_>>, gix_error::Exn>,
+    NextFn: FnMut(&mut Stream) -> ExnResult<Option<Entry<'_>>>,
 {
     if opts.format == Format::InternalTransientNonPersistable {
         return Err(message("The internal format cannot be used as an archive, it's merely a debugging tool").raise());
@@ -39,7 +40,7 @@ where
         }
 
         impl<W: std::io::Write> State<W> {
-            pub fn new(format: Format, mtime: gix_date::SecondsSinceUnixEpoch, out: W) -> Result<Self, Error> {
+            pub fn new(format: Format, mtime: gix_date::SecondsSinceUnixEpoch, out: W) -> ExnMessageResult<Self> {
                 match format {
                     Format::InternalTransientNonPersistable => unreachable!("handled earlier"),
                     Format::Zip { .. } => {
@@ -148,9 +149,9 @@ pub fn write_stream_seek<NextFn>(
     mut next_entry: NextFn,
     out: impl std::io::Write + std::io::Seek,
     opts: Options,
-) -> Result<(), Error>
+) -> ExnMessageResult
 where
-    NextFn: FnMut(&mut Stream) -> Result<Option<Entry<'_>>, gix_error::Exn>,
+    NextFn: FnMut(&mut Stream) -> ExnResult<Option<Entry<'_>>>,
 {
     let compression_level = match opts.format {
         Format::Zip { compression_level } => compression_level.map(i64::from),
@@ -204,7 +205,7 @@ fn append_zip_entry<W: std::io::Write + std::io::Seek>(
     mtime: rawzip::time::UtcDateTime,
     compression_level: Option<i64>,
     tree_prefix: Option<&bstr::BString>,
-) -> Result<(), Error> {
+) -> ExnMessageResult {
     use bstr::ByteSlice;
     let path = add_prefix(entry.relative_path(), tree_prefix).into_owned();
     let unix_permissions = if entry.mode.is_executable() { 0o755 } else { 0o644 };
@@ -299,7 +300,7 @@ fn append_tar_entry<W: std::io::Write>(
     mut entry: gix_worktree_stream::Entry<'_>,
     mtime_seconds_since_epoch: i64,
     opts: &Options,
-) -> Result<(), Error> {
+) -> ExnMessageResult {
     let mut header = tar::Header::new_gnu();
     header.set_mtime(mtime_seconds_since_epoch as u64);
     header.set_entry_type(tar_entry_type(entry.mode));
diff --git a/gix-attributes/Cargo.toml b/gix-attributes/Cargo.toml
index 8d4bb8c49d7..4edcfdfe1c9 100644
--- a/gix-attributes/Cargo.toml
+++ b/gix-attributes/Cargo.toml
@@ -41,6 +41,7 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 criterion = "0.8.2"
 gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
 gix-fs = { path = "../gix-fs" }
diff --git a/gix-attributes/src/name.rs b/gix-attributes/src/name.rs
index 4cc4acb959a..300e77d090e 100644
--- a/gix-attributes/src/name.rs
+++ b/gix-attributes/src/name.rs
@@ -24,8 +24,10 @@ impl AsRef<str> for NameRef<'_> {
 }
 
 impl<'a> TryFrom<&'a BStr> for NameRef<'a> {
-    type Error = Error;
+    type Error = gix_error::Message;
 
+    /// Invalid name bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     fn try_from(attr: &'a BStr) -> Result<Self, Self::Error> {
         fn attr_valid(attr: &BStr) -> bool {
             if attr.is_empty() || attr.first() == Some(&b'-') {
@@ -38,7 +40,9 @@ impl<'a> TryFrom<&'a BStr> for NameRef<'a> {
 
         attr_valid(attr)
             .then(|| NameRef(attr.to_str().expect("no illformed utf8")))
-            .ok_or_else(|| Error::new_with_input("Attribute has non-ascii characters or starts with '-'", attr))
+            .ok_or_else(|| {
+                gix_error::validation("Attribute has non-ascii characters or starts with '-'").with("input", attr)
+            })
     }
 }
 
@@ -92,6 +96,3 @@ impl<'de> serde::Deserialize<'de> for Name {
             .map_err(serde::de::Error::custom)
     }
 }
-
-/// The error returned by [`parse::Iter`][crate::parse::Iter].
-pub type Error = gix_error::ValidationError;
diff --git a/gix-attributes/src/parse.rs b/gix-attributes/src/parse.rs
index 6a2cad26678..f3d9a26c801 100644
--- a/gix-attributes/src/parse.rs
+++ b/gix-attributes/src/parse.rs
@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 
 use bstr::{BStr, ByteSlice};
-use gix_error::{ErrorExt, ResultExt, ValidationError};
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt, validation};
 
-use crate::{AssignmentRef, Name, NameRef, StateRef, name};
+use crate::{AssignmentRef, Name, NameRef, StateRef};
 
 /// The kind of attribute that was parsed.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
@@ -15,9 +15,6 @@ pub enum Kind {
     Macro(Name),
 }
 
-/// The error returned by [`parse::Lines`][crate::parse::Lines].
-pub type Error = gix_error::Exn<ValidationError>;
-
 /// An iterator over attribute assignments, parsed line by line.
 pub struct Lines<'a> {
     lines: bstr::Lines<'a>,
@@ -31,13 +28,15 @@ pub struct Iter<'a> {
 
 impl<'a> Iter<'a> {
     /// Create a new instance to parse attribute assignments from `input`.
+    /// Iterator errors store invalid name bytes as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     pub fn new(input: &'a BStr) -> Self {
         Iter {
             attrs: input.split(is_blank as fn(&u8) -> bool),
         }
     }
 
-    fn parse_attr(&self, attr: &'a [u8]) -> Result<AssignmentRef<'a>, name::Error> {
+    fn parse_attr(&self, attr: &'a [u8]) -> ExnMessageResult<AssignmentRef<'a>> {
         let mut tokens = attr.splitn(2, |b| *b == b'=');
         let attr = tokens.next().expect("attr itself").as_bstr();
         let possibly_value = tokens.next();
@@ -52,16 +51,16 @@ impl<'a> Iter<'a> {
     }
 }
 
-fn check_attr(attr: &BStr) -> Result<NameRef<'_>, name::Error> {
-    NameRef::try_from(attr).and_then(|name| {
-        (!name.as_str().starts_with("builtin_"))
-            .then_some(name)
-            .ok_or_else(|| name::Error::new_with_input("Attribute name uses the reserved 'builtin_' prefix", attr))
-    })
+fn check_attr(attr: &BStr) -> ExnMessageResult<NameRef<'_>> {
+    Ok(NameRef::try_from(attr).and_then(|name| {
+        (!name.as_str().starts_with("builtin_")).then_some(name).ok_or_else(|| {
+            gix_error::validation("Attribute name uses the reserved 'builtin_' prefix").with("input", attr)
+        })
+    })?)
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = Result<AssignmentRef<'a>, name::Error>;
+    type Item = ExnMessageResult<AssignmentRef<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let attr = self.attrs.find(|a| !a.is_empty())?;
@@ -72,6 +71,7 @@ impl<'a> Iterator for Iter<'a> {
 /// Instantiation
 impl<'a> Lines<'a> {
     /// Create a new instance to parse all attributes in all lines of the input `bytes`.
+    /// Iterator errors include invalid macro name or pattern bytes as `input` [metadata](gix_error::Exn::metadata()).
     pub fn new(bytes: &'a [u8]) -> Self {
         let bom = unicode_bom::Bom::from(bytes);
         Lines {
@@ -82,7 +82,7 @@ impl<'a> Lines<'a> {
 }
 
 impl<'a> Iterator for Lines<'a> {
-    type Item = Result<(Kind, Iter<'a>, usize), Error>;
+    type Item = ExnMessageResult<(Kind, Iter<'a>, usize)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         fn skip_blanks(line: &BStr) -> &BStr {
@@ -103,7 +103,7 @@ impl<'a> Iterator for Lines<'a> {
     }
 }
 
-fn parse_line(line: &BStr, line_number: usize) -> Option<Result<(Kind, Iter<'_>, usize), Error>> {
+fn parse_line(line: &BStr, line_number: usize) -> Option<ExnMessageResult<(Kind, Iter<'_>, usize)>> {
     if line.is_empty() {
         return None;
     }
@@ -122,15 +122,15 @@ fn parse_line(line: &BStr, line_number: usize) -> Option<Result<(Kind, Iter<'_>,
 
     let kind_res = match line.strip_prefix(b"[attr]").filter(|name| !name.is_empty()) {
         Some(macro_name) => check_attr(macro_name.into())
-            .or_raise(|| ValidationError::new(format!("Macro in line {line_number} has an invalid name")))
+            .or_raise(|| validation(format!("Macro in line {line_number} has an invalid name")))
             .map(|name| Kind::Macro(name.to_owned())),
         None => {
             let pattern = gix_glob::Pattern::from_bytes(line.as_ref())?;
             if pattern.mode.contains(gix_glob::pattern::Mode::NEGATIVE) {
-                Err(ValidationError::new_with_input(
-                    format!(r"Line {line_number} has a negative pattern, for literal characters use \!"),
-                    line.as_ref(),
-                )
+                Err(validation(format!(
+                    r"Line {line_number} has a negative pattern, for literal characters use \!"
+                ))
+                .with("input", line.as_ref())
                 .raise())
             } else {
                 Ok(Kind::Pattern(pattern))
diff --git a/gix-attributes/src/search/attributes.rs b/gix-attributes/src/search/attributes.rs
index 32671ddca25..2cdcd321a22 100644
--- a/gix-attributes/src/search/attributes.rs
+++ b/gix-attributes/src/search/attributes.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::path::{Path, PathBuf};
 
 use bstr::{BStr, ByteSlice};
@@ -128,7 +129,7 @@ impl Pattern for Attributes {
 
     fn bytes_to_patterns(&self, bytes: &[u8], _source: &std::path::Path) -> Vec<pattern::Mapping<Self::Value>> {
         fn into_owned_assignments<'a>(
-            attrs: impl Iterator<Item = Result<crate::AssignmentRef<'a>, crate::name::Error>>,
+            attrs: impl Iterator<Item = ExnMessageResult<crate::AssignmentRef<'a>>>,
         ) -> Option<Assignments> {
             let res = attrs
                 .map(|res| {
@@ -137,7 +138,7 @@ impl Pattern for Attributes {
                         inner: a.to_owned(),
                     })
                 })
-                .collect::<Result<Assignments, _>>();
+                .collect::<std::result::Result<Assignments, _>>();
             match res {
                 Ok(res) => Some(res),
                 Err(_err) => {
diff --git a/gix-attributes/tests/attributes/main.rs b/gix-attributes/tests/attributes/main.rs
index fad4b9a5011..9deb66ed8ba 100644
--- a/gix-attributes/tests/attributes/main.rs
+++ b/gix-attributes/tests/attributes/main.rs
@@ -1,4 +1,3 @@
-pub use gix_testtools::TestResult as Result;
 mod assignment;
 mod parse;
 mod search;
diff --git a/gix-attributes/tests/attributes/parse.rs b/gix-attributes/tests/attributes/parse.rs
index 610a1054bea..61293844578 100644
--- a/gix-attributes/tests/attributes/parse.rs
+++ b/gix-attributes/tests/attributes/parse.rs
@@ -1,6 +1,7 @@
-use bstr::{BString, ByteSlice};
+use bstr::BString;
 use gix_attributes::{StateRef, parse, state::ValueRef};
-use gix_error::{ResultExt, ValidationError};
+use gix_error::ExnMessageResult;
+use gix_error::{Message, ResultExt, validation};
 use gix_glob::pattern::Mode;
 use gix_testtools::fixture_bytes;
 
@@ -95,18 +96,9 @@ fn exclamation_marks_must_be_escaped_or_error_unlike_gitignore() {
         line(r"\!hello"),
         (pattern(r"!hello", Mode::NO_SUB_DIR, None), vec![], 1)
     );
-    assert!(has_validation_message(
-        try_line(r"!hello"),
-        r"Line 1 has a negative pattern, for literal characters use \!"
-    ));
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"!hello")), "exclamation marks must be escaped or error unlike gitignore", @r#"Line 1 has a negative pattern, for literal characters use \!, "input"="!hello""#);
     assert!(lenient_lines(r#"!hello"#).is_empty());
-    assert!(
-        has_validation_message(
-            try_line(r#""!hello""#),
-            r"Line 1 has a negative pattern, for literal characters use \!"
-        ),
-        "even in quotes they trigger…"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r#""!hello""#)), "even in quotes they trigger…", @r#"Line 1 has a negative pattern, for literal characters use \!, "input"="!hello""#);
     assert!(lenient_lines(r#""!hello""#).is_empty());
     assert_eq!(
         line(r#""\\!hello""#),
@@ -196,84 +188,103 @@ fn the_macro_prefix_without_a_name_is_a_pattern() {
 
 #[test]
 fn custom_macros_must_be_valid_attribute_names() {
-    assert!(has_validation_message(
-        try_line(r"[attr]-prefixdash"),
-        "Macro in line 1 has an invalid name"
-    ));
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"[attr]-prefixdash")), "custom macros must be valid attribute names", @r#"
+    Macro in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="-prefixdash"
+    "#);
     assert!(lenient_lines(r"[attr]-prefixdash").is_empty());
-    assert!(has_validation_message(
-        try_line(r"[attr]!exclamation"),
-        "Macro in line 1 has an invalid name"
-    ));
-    assert!(has_validation_message(
-        try_line(r"[attr]assignment=value"),
-        "Macro in line 1 has an invalid name"
-    ));
-    assert!(has_validation_message(
-        try_line(r"[attr]你好"),
-        "Macro in line 1 has an invalid name"
-    ));
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"[attr]!exclamation")), "custom macros must be valid attribute names", @r#"
+    Macro in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="!exclamation"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"[attr]assignment=value")), "custom macros must be valid attribute names", @r#"
+    Macro in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="assignment=value"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"[attr]你好")), "custom macros must be valid attribute names", @r#"
+    Macro in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="你好"
+    "#);
     assert!(lenient_lines(r"[attr]你好").is_empty());
 }
 
 #[test]
 fn invalid_names_retain_line_context_and_the_validation_cause() {
-    for (input, context) in [
-        ("p 你好", "Attribute in line 1 has an invalid name"),
-        ("[attr]你好", "Macro in line 1 has an invalid name"),
-    ] {
+    let mut error_snapshots = Vec::new();
+    for input in ["p 你好", "[attr]你好"] {
         let err = try_line(input).unwrap_err();
-        assert_eq!(err, context);
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         let cause = err
             .iter()
             .skip(1)
-            .find_map(|frame| frame.error().downcast_ref::<ValidationError>())
+            .find_map(|frame| frame.error().downcast_ref::<Message>())
             .expect("invalid names remain a typed validation cause");
-        assert_eq!(cause.message, "Attribute has non-ascii characters or starts with '-'");
+        assert_eq!(cause.class, Some(gix_error::Class::Validation));
         assert_eq!(
-            cause.input.as_ref().map(|input| input.as_bstr()),
-            Some("你好".as_bytes().as_bstr())
+            cause.values.get("input"),
+            Some(&gix_error::MetadataValue::Bytes("你好".into()))
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid names retain line context and the validation cause", @r#"
+    [
+        Attribute in line 1 has an invalid name
+        |
+        └─ Attribute has non-ascii characters or starts with '-', "input"="你好",
+        Macro in line 1 has an invalid name
+        |
+        └─ Attribute has non-ascii characters or starts with '-', "input"="你好",
+    ]
+    "#);
 }
 
 #[test]
 fn attribute_names_must_not_begin_with_dash_and_must_be_ascii_only() {
-    assert!(has_validation_message(
-        try_line(r"p !-a"),
-        "Attribute in line 1 has an invalid name"
-    ));
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p !-a")), "attribute names must not begin with dash and must be ascii only", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="-a"
+    "#);
     assert!(lenient_lines(r"p !-a").is_empty());
-    assert!(
-        has_validation_message(try_line(r#"p !!a"#), "Attribute in line 1 has an invalid name"),
-        "exclamation marks aren't allowed either"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r#"p !!a"#)), "exclamation marks aren't allowed either", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="!a"
+    "#);
     assert!(lenient_lines(r#"p !!a"#).is_empty());
-    assert!(
-        has_validation_message(try_line(r#"p 你好"#), "Attribute in line 1 has an invalid name"),
-        "nor is utf-8 encoded characters - gitoxide could consider to relax this when established"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r#"p 你好"#)), "nor is utf-8 encoded characters - gitoxide could consider to relax this when established", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="你好"
+    "#);
     assert!(lenient_lines(r#"p 你好"#).is_empty());
 }
 
 #[test]
 fn attribute_names_must_not_be_empty() {
-    assert!(
-        has_validation_message(try_line(r"p text =lf"), "Attribute in line 1 has an invalid name"),
-        "a blank in front of the equals sign leaves the assignment without a name"
-    );
-    assert!(
-        has_validation_message(try_line(r"p ="), "Attribute in line 1 has an invalid name"),
-        "an assignment that is nothing but an equals sign has no name either"
-    );
-    assert!(
-        has_validation_message(try_line(r"p -"), "Attribute in line 1 has an invalid name"),
-        "prefixes need a name to apply to"
-    );
-    assert!(
-        has_validation_message(try_line(r"p !"), "Attribute in line 1 has an invalid name"),
-        "the unspecified prefix needs one as well"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p text =lf")), "a blank in front of the equals sign leaves the assignment without a name", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"=""
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p =")), "an assignment that is nothing but an equals sign has no name either", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"=""
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p -")), "prefixes need a name to apply to", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"=""
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p !")), "the unspecified prefix needs one as well", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"=""
+    "#);
     assert!(
         gix_attributes::NameRef::try_from(bstr::BStr::new(b"")).is_err(),
         "names can't be created empty either, which `attr_name_valid()` rejects via `namelen <= 0`"
@@ -282,28 +293,22 @@ fn attribute_names_must_not_be_empty() {
 
 #[test]
 fn attribute_names_must_not_use_the_reserved_builtin_prefix() {
-    assert!(
-        has_validation_message(
-            try_line(r"p builtin_objectmode"),
-            "Attribute in line 1 has an invalid name"
-        ),
-        "Git reserves 'builtin_' for built-in attributes and drops lines that assign to it"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p builtin_objectmode")), "Git reserves 'builtin_' for built-in attributes and drops lines that assign to it", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute name uses the reserved 'builtin_' prefix, "input"="builtin_objectmode"
+    "#);
     assert!(lenient_lines(r"p builtin_objectmode").is_empty());
-    assert!(
-        has_validation_message(
-            try_line(r"p -builtin_objectmode"),
-            "Attribute in line 1 has an invalid name"
-        ),
-        "the prefix is checked after '-' and '!' are stripped, just like in `parse_attr()`"
-    );
-    assert!(
-        has_validation_message(
-            try_line(r"[attr]builtin_macro -text"),
-            "Macro in line 1 has an invalid name"
-        ),
-        "macro names are checked against the reserved namespace as well"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"p -builtin_objectmode")), "the prefix is checked after '-' and '!' are stripped, just like in `parse_attr()`", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute name uses the reserved 'builtin_' prefix, "input"="builtin_objectmode"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line(r"[attr]builtin_macro -text")), "macro names are checked against the reserved namespace as well", @r#"
+    Macro in line 1 has an invalid name
+    |
+    └─ Attribute name uses the reserved 'builtin_' prefix, "input"="builtin_macro"
+    "#);
     assert_eq!(
         line(r"p builtin"),
         (pattern("p", Mode::NO_SUB_DIR, None), vec![set("builtin")], 1),
@@ -361,25 +366,26 @@ fn only_ascii_blanks_separate_attributes() {
         ),
         "a non-breaking space belongs to the value it appears in"
     );
-    assert!(
-        has_validation_message(
-            try_line("p text\u{a0}eol=lf"),
-            "Attribute in line 1 has an invalid name"
-        ),
-        "in a name it makes the whole name invalid"
-    );
-    assert!(
-        has_validation_message(try_line("p a\u{b}b"), "Attribute in line 1 has an invalid name"),
-        "a vertical tab is part of the name, not a separator"
-    );
-    assert!(
-        has_validation_message(try_line("p a\u{c}b"), "Attribute in line 1 has an invalid name"),
-        "a form feed is part of the name, not a separator"
-    );
-    assert!(
-        has_validation_message(try_line("p a\u{2028}b"), "Attribute in line 1 has an invalid name"),
-        "vertical tabs, form feeds and unicode line separators aren't blanks either"
-    );
+    insta::assert_debug_snapshot!(assert_validation(try_line("p text\u{a0}eol=lf")), "in a name it makes the whole name invalid", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="text\u{a0}eol"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line("p a\u{b}b")), "a vertical tab is part of the name, not a separator", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="a\x0bb"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line("p a\u{c}b")), "a form feed is part of the name, not a separator", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="a\x0cb"
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(try_line("p a\u{2028}b")), "vertical tabs, form feeds and unicode line separators aren't blanks either", @r#"
+    Attribute in line 1 has an invalid name
+    |
+    └─ Attribute has non-ascii characters or starts with '-', "input"="a\u{2028}b"
+    "#);
 }
 
 #[test]
@@ -483,11 +489,16 @@ fn pattern(name: &str, flags: gix_glob::pattern::Mode, first_wildcard_pos: Optio
     })
 }
 
-fn has_validation_message<T>(result: Result<T, parse::Error>, expected: &str) -> bool {
-    result.is_err_and(|err| err.message == expected)
+fn assert_validation<T>(result: ExnMessageResult<T>) -> gix_error::Exn<gix_error::Message> {
+    let err = result.err().expect("attribute input must be rejected");
+    assert!(
+        err.is_validation(),
+        "invalid attribute syntax retains its classification"
+    );
+    err
 }
 
-fn try_line(input: &str) -> Result<ExpandedAttribute<'_>, parse::Error> {
+fn try_line(input: &str) -> ExnMessageResult<ExpandedAttribute<'_>> {
     let mut lines = gix_attributes::parse(input.as_bytes());
     let res = expand(lines.next().unwrap())?;
     assert!(lines.next().is_none(), "expected only one line");
@@ -502,7 +513,7 @@ fn byte_line(input: &[u8]) -> ExpandedAttribute<'_> {
     try_byte_line(input).unwrap()
 }
 
-fn try_byte_line(input: &[u8]) -> Result<ExpandedAttribute<'_>, parse::Error> {
+fn try_byte_line(input: &[u8]) -> ExnMessageResult<ExpandedAttribute<'_>> {
     let mut lines = gix_attributes::parse(input);
     let res = expand(lines.next().unwrap())?;
     assert!(lines.next().is_none(), "expected only one line");
@@ -516,17 +527,15 @@ fn lenient_lines(input: &str) -> Vec<ExpandedAttribute<'_>> {
         .collect()
 }
 
-fn try_lines(input: &str) -> Result<Vec<ExpandedAttribute<'_>>, parse::Error> {
+fn try_lines(input: &str) -> ExnMessageResult<Vec<ExpandedAttribute<'_>>> {
     gix_attributes::parse(input.as_bytes()).map(expand).collect()
 }
 
-fn expand(
-    input: Result<(parse::Kind, parse::Iter<'_>, usize), parse::Error>,
-) -> Result<ExpandedAttribute<'_>, parse::Error> {
+fn expand(input: ExnMessageResult<(parse::Kind, parse::Iter<'_>, usize)>) -> ExnMessageResult<ExpandedAttribute<'_>> {
     let (pattern, attrs, line_no) = input?;
     let attrs = attrs
         .map(|r| r.map(|attr| (attr.name.as_str().into(), attr.state)))
         .collect::<Result<Vec<_>, _>>()
-        .or_raise(|| ValidationError::new(format!("Attribute in line {line_no} has an invalid name")))?;
+        .or_raise(|| validation(format!("Attribute in line {line_no} has an invalid name")))?;
     Ok((pattern, attrs, line_no))
 }
diff --git a/gix-attributes/tests/attributes/search.rs b/gix-attributes/tests/attributes/search.rs
index 9a17ca7621e..e56acd9e571 100644
--- a/gix-attributes/tests/attributes/search.rs
+++ b/gix-attributes/tests/attributes/search.rs
@@ -63,7 +63,7 @@ mod specials {
 }
 
 #[test]
-fn baseline() -> crate::Result {
+fn baseline() -> gix_error::TestResult {
     let mut buf = Vec::new();
     // Due to the way our setup differs from gits dynamic stack (which involves trying to read files from disk
     // by path) we can only test one case baseline, so we require multiple platforms (or filesystems) to run this.
@@ -129,7 +129,7 @@ fn assert_references(out: &Outcome) {
 }
 
 #[test]
-fn all_attributes_are_listed_in_declaration_order() -> crate::Result {
+fn all_attributes_are_listed_in_declaration_order() -> gix_error::TestResult {
     let (mut group, mut collection, base, input) = baseline::user_attributes("lookup-order")?;
 
     let mut buf = Vec::new();
@@ -226,7 +226,7 @@ fn all_attributes_are_listed_in_declaration_order() -> crate::Result {
 }
 
 #[test]
-fn given_attributes_are_made_available_in_given_order() -> crate::Result {
+fn given_attributes_are_made_available_in_given_order() -> gix_error::TestResult {
     let (mut group, mut collection, base, input) =
         baseline::user_attributes_named_baseline("lookup-order", "baseline.selected")?;
 
@@ -268,13 +268,13 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
 }
 
 #[test]
-fn macro_attributes_expand_only_when_macro_is_set() -> crate::Result {
+fn macro_attributes_expand_only_when_macro_is_set() -> gix_error::TestResult {
     assert_baseline("macro-expansion")?;
     Ok(())
 }
 
 #[test]
-fn attribute_tokenisation_matches_git() -> crate::Result {
+fn attribute_tokenisation_matches_git() -> gix_error::TestResult {
     assert_baseline("tokenisation")?;
     Ok(())
 }
diff --git a/gix-bitmap/src/ewah.rs b/gix-bitmap/src/ewah.rs
index f8b308cfd4a..b2f7fceece1 100644
--- a/gix-bitmap/src/ewah.rs
+++ b/gix-bitmap/src/ewah.rs
@@ -1,16 +1,11 @@
-///
-pub mod decode {
-    /// The error returned by [`decode()`](super::decode()).
-    pub type Error = gix_error::Exn<gix_error::ValidationError>;
-}
-
+use gix_error::ExnMessageResult;
 /// Decode `data` as EWAH bitmap.
-pub fn decode(data: &[u8]) -> Result<(Vec, &[u8]), decode::Error> {
+pub fn decode(data: &[u8]) -> ExnMessageResult<(Vec, &[u8])> {
     use crate::decode;
-    use gix_error::{OptionExt, message};
+    use gix_error::{OptionExt, validation};
 
-    let (num_bits, data) = decode::u32(data).ok_or_raise(|| message("eof reading amount of bits").into())?;
-    let (len, data) = decode::u32(data).ok_or_raise(|| message("eof reading chunk length").into())?;
+    let (num_bits, data) = decode::u32(data).ok_or_raise(|| validation("eof reading amount of bits"))?;
+    let (len, data) = decode::u32(data).ok_or_raise(|| validation("eof reading chunk length"))?;
     let len = len as usize;
 
     // NOTE: git does this by copying all bytes first, and then it will change the endianness in a separate loop.
@@ -18,10 +13,10 @@ pub fn decode(data: &[u8]) -> Result<(Vec, &[u8]), decode::Error> {
     //       one day somebody will find out that it's worth it to use unsafe here.
     let word_bytes_len = len
         .checked_mul(std::mem::size_of::<u64>())
-        .ok_or_raise(|| message("chunk length overflows size calculation").into())?;
+        .ok_or_raise(|| validation("chunk length overflows size calculation"))?;
     let (mut bits, data) = data
         .split_at_checked(word_bytes_len)
-        .ok_or_raise(|| message("eof while reading bit data").into())?;
+        .ok_or_raise(|| validation("eof while reading bit data"))?;
     let mut buf = std::vec::Vec::<u64>::with_capacity(len);
     for _ in 0..len {
         let (bit_num, rest) = bits.split_at(std::mem::size_of::<u64>());
@@ -29,7 +24,7 @@ pub fn decode(data: &[u8]) -> Result<(Vec, &[u8]), decode::Error> {
         buf.push(u64::from_be_bytes(bit_num.try_into().unwrap()));
     }
 
-    let (rlw, data) = decode::u32(data).ok_or_raise(|| message("eof while reading run length width").into())?;
+    let (rlw, data) = decode::u32(data).ok_or_raise(|| validation("eof while reading run length width"))?;
 
     Ok((
         Vec {
@@ -42,6 +37,8 @@ pub fn decode(data: &[u8]) -> Result<(Vec, &[u8]), decode::Error> {
 }
 
 mod access {
+    use gix_error::{ResultExt, validation};
+
     use super::Vec;
 
     impl Vec {
@@ -77,15 +74,12 @@ mod access {
         ///
         /// These bytes can be parsed again with [`decode()`](super::decode()).
         pub fn write_to(&self, out: &mut impl std::io::Write) -> std::io::Result<()> {
-            let len: u32 = self.bits.len().try_into().map_err(|_| {
-                std::io::Error::new(std::io::ErrorKind::InvalidInput, "bit word count exceeds u32::MAX")
-            })?;
-            let rlw: u32 = self.rlw.try_into().map_err(|_| {
-                std::io::Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    "run length word offset exceeds u32::MAX",
-                )
-            })?;
+            let len = u32::try_from(self.bits.len())
+                .or_raise(|| validation("bit word count exceeds u32::MAX"))
+                .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err.into_error()))?;
+            let rlw = u32::try_from(self.rlw)
+                .or_raise(|| validation("run length word offset exceeds u32::MAX"))
+                .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err.into_error()))?;
 
             out.write_all(&self.num_bits.to_be_bytes())?;
             out.write_all(&len.to_be_bytes())?;
diff --git a/gix-blame/Cargo.toml b/gix-blame/Cargo.toml
index 82deb566de5..105af2bcc34 100644
--- a/gix-blame/Cargo.toml
+++ b/gix-blame/Cargo.toml
@@ -30,9 +30,9 @@ gix-worktree = { version = "^0.56.0", path = "../gix-worktree", default-features
 gix-traverse = { version = "^0.61.0", path = "../gix-traverse" }
 
 smallvec = "1.15.1"
-thiserror = "2.0.18"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-hash = { path = "../gix-hash", features = ["sha1", "sha256"] }
 gix-ref = { path = "../gix-ref", features = ["sha1", "sha256"] }
 gix-filter = { path = "../gix-filter" }
diff --git a/gix-blame/src/error.rs b/gix-blame/src/error.rs
deleted file mode 100644
index 9cedec7b600..00000000000
--- a/gix-blame/src/error.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use gix_object::bstr::BString;
-
-/// The error returned by [file()](crate::file()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("No commit was given")]
-    EmptyTraversal,
-    #[error(transparent)]
-    BlobDiffSetResource(#[from] gix_diff::blob::platform::set_resource::Error),
-    #[error(transparent)]
-    BlobDiffPrepare(#[from] gix_diff::blob::platform::prepare_diff::Error),
-    #[error("The file to blame at '{file_path}' wasn't found in the first commit at {commit_id}")]
-    FileMissing {
-        /// The file-path to the object to blame.
-        file_path: BString,
-        /// The commit whose tree didn't contain `file_path`.
-        commit_id: gix_hash::ObjectId,
-    },
-    #[error("Couldn't find commit or tree in the object database")]
-    FindObject(#[from] gix_object::find::Error),
-    #[error("Could not find existing blob or commit")]
-    FindExistingObject(#[from] gix_object::find::existing_object::Error),
-    #[error("Could not find existing iterator over a tree")]
-    FindExistingIter(#[from] gix_object::find::existing_iter::Error),
-    #[error("Failed to obtain the next commit in the commit-graph traversal")]
-    Traverse(#[source] Box<dyn std::error::Error + Send + Sync>),
-    #[error(transparent)]
-    DiffTree(#[from] gix_diff::tree::Error),
-    #[error(transparent)]
-    DiffTreeWithRewrites(#[from] gix_diff::tree_with_rewrites::Error),
-    #[error(
-        "Invalid line range was given, line range is expected to be a 1-based inclusive range in the format '<start>,<end>'"
-    )]
-    InvalidOneBasedLineRange,
-    #[error("Failure to decode commit during traversal")]
-    DecodeCommit(#[from] gix_object::decode::Error),
-    #[error("Failed to get parent from commitgraph during traversal")]
-    GetParentFromCommitGraph(#[from] gix_error::Message),
-}
diff --git a/gix-blame/src/file/function.rs b/gix-blame/src/file/function.rs
index 047ed5a3384..4ab550e081f 100644
--- a/gix-blame/src/file/function.rs
+++ b/gix-blame/src/file/function.rs
@@ -1,6 +1,7 @@
 use std::num::NonZeroU32;
 
 use gix_diff::{blob::TokenSource, tree::Visit};
+use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, message, not_found};
 use gix_hash::ObjectId;
 use gix_object::{
     FindExt,
@@ -11,7 +12,7 @@ use smallvec::SmallVec;
 
 use super::{Change, UnblamedHunk, process_changes};
 use crate::{
-    BlameEntry, Error, Options, Outcome, Statistics,
+    BlameEntry, Options, Outcome, Statistics,
     types::{BlamePathEntry, Start},
 };
 
@@ -71,7 +72,7 @@ pub fn file(
     resource_cache: &mut gix_diff::blob::Platform,
     file_path: &BStr,
     options: Options,
-) -> Result<Outcome, Error> {
+) -> ExnResult<Outcome> {
     let _span = gix_trace::coarse!("gix_blame::file()", ?file_path, ?start);
 
     let mut stats = Statistics::default();
@@ -107,8 +108,14 @@ pub fn file(
         gix_revwalk::PriorityQueue::new();
 
     if let Some(first_suspect) = first_suspect {
-        let commit = find_commit(cache.as_ref(), &odb, &first_suspect, &mut buf)?;
-        queue.insert(commit.commit_time()?, first_suspect);
+        let commit = find_commit(cache.as_ref(), &odb, &first_suspect, &mut buf)
+            .or_raise_erased(|| message("Could not find existing iterator over a tree"))?;
+        queue.insert(
+            commit
+                .commit_time()
+                .or_raise_erased(|| message("Failure to decode commit during traversal"))?,
+            first_suspect,
+        );
     }
 
     let mut diff_state = gix_diff::tree::State::default();
@@ -137,8 +144,11 @@ pub fn file(
             .clone()
             .unwrap_or_else(|| file_path.to_owned());
 
-        let commit = find_commit(cache.as_ref(), &odb, &suspect, &mut buf)?;
-        let commit_time = commit.commit_time()?;
+        let commit = find_commit(cache.as_ref(), &odb, &suspect, &mut buf)
+            .or_raise_erased(|| message("Could not find existing iterator over a tree"))?;
+        let commit_time = commit
+            .commit_time()
+            .or_raise_erased(|| message("Failure to decode commit during traversal"))?;
 
         if let Some(since) = options.since
             && commit_time < since.seconds
@@ -208,7 +218,11 @@ pub fn file(
         // identical to the corresponding lines in the *Source File*.
         #[cfg(debug_assertions)]
         {
-            let source_blob = odb.find_blob(&entry_id, &mut buf)?.data.to_vec();
+            let source_blob = odb
+                .find_blob(&entry_id, &mut buf)
+                .or_raise_erased(|| message("Could not find existing blob or commit"))?
+                .data
+                .to_vec();
             let mut source_interner = gix_diff::blob::Interner::new(source_blob.len() / 100);
             let source_lines_as_tokens: Vec<_> = tokens_for_diffing(&source_blob)
                 .tokenize()
@@ -566,15 +580,25 @@ fn tree_diff_at_file_path(
     lhs_tree_buf: &mut Vec<u8>,
     rhs_tree_buf: &mut Vec<u8>,
     rewrites: Option<gix_diff::Rewrites>,
-) -> Result<Option<TreeDiffChange>, Error> {
-    let parent_tree_id = find_commit(cache, &odb, &parent_id, commit_buf)?.tree_id()?;
-
-    let parent_tree_iter = odb.find_tree_iter(&parent_tree_id, lhs_tree_buf)?;
+) -> ExnResult<Option<TreeDiffChange>> {
+    let parent_tree_id = find_commit(cache, &odb, &parent_id, commit_buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?
+        .tree_id()
+        .or_raise_erased(|| message("Failure to decode commit during traversal"))?;
+
+    let parent_tree_iter = odb
+        .find_tree_iter(&parent_tree_id, lhs_tree_buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?;
     stats.trees_decoded += 1;
 
-    let tree_id = find_commit(cache, &odb, &id, commit_buf)?.tree_id()?;
+    let tree_id = find_commit(cache, &odb, &id, commit_buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?
+        .tree_id()
+        .or_raise_erased(|| message("Failure to decode commit during traversal"))?;
 
-    let tree_iter = odb.find_tree_iter(&tree_id, rhs_tree_buf)?;
+    let tree_iter = odb
+        .find_tree_iter(&tree_id, rhs_tree_buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?;
     stats.trees_decoded += 1;
 
     let result = tree_diff_without_rewrites_at_file_path(&odb, file_path, stats, state, parent_tree_iter, tree_iter)?;
@@ -613,7 +637,7 @@ fn tree_diff_without_rewrites_at_file_path(
     state: &mut gix_diff::tree::State,
     parent_tree_iter: gix_object::TreeRefIter<'_>,
     tree_iter: gix_object::TreeRefIter<'_>,
-) -> Result<Option<TreeDiffChange>, Error> {
+) -> ExnResult<Option<TreeDiffChange>> {
     struct FindChangeToPath {
         inner: gix_diff::tree::Recorder,
         interesting_path: BString,
@@ -702,7 +726,7 @@ fn tree_diff_without_rewrites_at_file_path(
 
     match result {
         Ok(_) | Err(gix_diff::tree::Error::Cancelled) => Ok(recorder.change.map(Into::into)),
-        Err(error) => Err(Error::DiffTree(error)),
+        Err(error) => Err(error.raise_erased()),
     }
 }
 
@@ -716,7 +740,7 @@ fn tree_diff_with_rewrites_at_file_path(
     parent_tree_iter: gix_object::TreeRefIter<'_>,
     tree_iter: gix_object::TreeRefIter<'_>,
     rewrites: gix_diff::Rewrites,
-) -> Result<Option<TreeDiffChange>, Error> {
+) -> ExnResult<Option<TreeDiffChange>> {
     let mut change: Option<gix_diff::tree_with_rewrites::Change> = None;
 
     let options: gix_diff::tree_with_rewrites::Options = gix_diff::tree_with_rewrites::Options {
@@ -729,7 +753,7 @@ fn tree_diff_with_rewrites_at_file_path(
         resource_cache,
         state,
         &odb,
-        |change_ref| -> Result<_, std::convert::Infallible> {
+        |change_ref| -> ExnResult<_> {
             if change_ref.location() == file_path {
                 change = Some(change_ref.into_owned());
                 Ok(std::ops::ControlFlow::Break(()))
@@ -742,10 +766,8 @@ fn tree_diff_with_rewrites_at_file_path(
     stats.trees_diffed_with_rewrites += 1;
 
     match result {
-        Ok(_) | Err(gix_diff::tree_with_rewrites::Error::Diff(gix_diff::tree::Error::Cancelled)) => {
-            Ok(change.map(Into::into))
-        }
-        Err(error) => Err(Error::DiffTreeWithRewrites(error)),
+        Ok(_) | Err(gix_diff::tree::Error::Cancelled) => Ok(change.map(Into::into)),
+        Err(error) => Err(error.raise_erased()),
     }
 }
 
@@ -759,24 +781,28 @@ fn blob_changes(
     previous_file_path: &BStr,
     diff_algorithm: gix_diff::blob::Algorithm,
     stats: &mut Statistics,
-) -> Result<Vec<Change>, Error> {
-    resource_cache.set_resource(
-        previous_oid,
-        // TODO(blame): add a test to show of symlink blaming works.
-        gix_object::tree::EntryKind::Blob,
-        previous_file_path,
-        gix_diff::blob::ResourceKind::OldOrSource,
-        &odb,
-    )?;
-    resource_cache.set_resource(
-        oid,
-        gix_object::tree::EntryKind::Blob,
-        file_path,
-        gix_diff::blob::ResourceKind::NewOrDestination,
-        &odb,
-    )?;
-
-    let outcome = resource_cache.prepare_diff()?;
+) -> ExnResult<Vec<Change>> {
+    resource_cache
+        .set_resource(
+            previous_oid,
+            // TODO(blame): add a test to show of symlink blaming works.
+            gix_object::tree::EntryKind::Blob,
+            previous_file_path,
+            gix_diff::blob::ResourceKind::OldOrSource,
+            &odb,
+        )
+        .or_erased()?;
+    resource_cache
+        .set_resource(
+            oid,
+            gix_object::tree::EntryKind::Blob,
+            file_path,
+            gix_diff::blob::ResourceKind::NewOrDestination,
+            &odb,
+        )
+        .or_erased()?;
+
+    let outcome = resource_cache.prepare_diff().or_erased()?;
 
     Ok(blob_changes_from_data(
         outcome.old.data.as_slice().unwrap_or_default(),
@@ -843,16 +869,23 @@ fn find_path_entry_in_commit(
     buf: &mut Vec<u8>,
     buf2: &mut Vec<u8>,
     stats: &mut Statistics,
-) -> Result<Option<ObjectId>, Error> {
-    let tree_id = find_commit(cache, odb, commit, buf)?.tree_id()?;
-    let tree_iter = odb.find_tree_iter(&tree_id, buf)?;
+) -> ExnResult<Option<ObjectId>> {
+    let tree_id = find_commit(cache, odb, commit, buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?
+        .tree_id()
+        .or_raise_erased(|| message("Failure to decode commit during traversal"))?;
+    let tree_iter = odb
+        .find_tree_iter(&tree_id, buf)
+        .or_raise_erased(|| message("Could not find existing iterator over a tree"))?;
     stats.trees_decoded += 1;
 
-    let res = tree_iter.lookup_entry(
-        odb,
-        buf2,
-        file_path.split(|b| *b == b'/').inspect(|_| stats.trees_decoded += 1),
-    )?;
+    let res = tree_iter
+        .lookup_entry(
+            odb,
+            buf2,
+            file_path.split(|b| *b == b'/').inspect(|_| stats.trees_decoded += 1),
+        )
+        .or_raise_erased(|| message("Couldn't find commit or tree in the object database"))?;
     stats.trees_decoded -= 1;
     Ok(res.map(|e| e.oid))
 }
@@ -864,7 +897,7 @@ fn collect_parents(
     odb: &impl gix_object::Find,
     cache: Option<&gix_commitgraph::Graph>,
     buf: &mut Vec<u8>,
-) -> Result<ParentIds, Error> {
+) -> ExnResult<ParentIds> {
     let mut parent_ids: ParentIds = Default::default();
     match commit {
         gix_traverse::commit::Either::CachedCommit(commit) => {
@@ -872,7 +905,9 @@ fn collect_parents(
                 .as_ref()
                 .expect("find returned a cached commit, so we expect cache to be present");
             for parent_pos in commit.iter_parents() {
-                let parent = cache.commit_at(parent_pos?);
+                let parent = cache.commit_at(
+                    parent_pos.or_raise_erased(|| message("Failed to get parent from commitgraph during traversal"))?,
+                );
                 parent_ids.push((parent.id().to_owned(), parent.committer_timestamp() as i64));
             }
         }
@@ -917,15 +952,20 @@ fn initial_state(
     buf: &mut Vec<u8>,
     buf2: &mut Vec<u8>,
     stats: &mut Statistics,
-) -> Result<InitialState, Error> {
+) -> ExnResult<InitialState> {
     match start {
         Start::Commit(suspect) => {
             let blamed_file_entry_id = find_path_entry_in_commit(&odb, &suspect, file_path, cache, buf, buf2, stats)?
-                .ok_or_else(|| Error::FileMissing {
-                file_path: file_path.to_owned(),
-                commit_id: suspect,
+                .ok_or_raise_erased(|| {
+                not_found(format!(
+                    "The file to blame at '{file_path}' wasn't found in the first commit at {suspect}"
+                ))
             })?;
-            let blamed_file_blob = odb.find_blob(&blamed_file_entry_id, buf)?.data.to_vec();
+            let blamed_file_blob = odb
+                .find_blob(&blamed_file_entry_id, buf)
+                .or_raise_erased(|| message("Could not find existing blob or commit"))?
+                .data
+                .to_vec();
             let num_lines_in_blamed = tokens_for_diffing(&blamed_file_blob).tokenize().count() as u32;
 
             // Binary or otherwise empty?
@@ -995,7 +1035,11 @@ fn initial_state(
                 });
             };
 
-            let first_suspect_blob = odb.find_blob(&first_suspect_entry_id, buf)?.data.to_vec();
+            let first_suspect_blob = odb
+                .find_blob(&first_suspect_entry_id, buf)
+                .or_raise_erased(|| message("Could not find existing blob or commit"))?
+                .data
+                .to_vec();
 
             let changes = blob_changes_from_data(&first_suspect_blob, &blamed_file_blob, options.diff_algorithm, stats);
             hunks_to_blame = process_changes(hunks_to_blame, changes, null_id, first_suspect);
diff --git a/gix-blame/src/file/tests.rs b/gix-blame/src/file/tests.rs
index 2b60af1d4a4..84dd21afa0e 100644
--- a/gix-blame/src/file/tests.rs
+++ b/gix-blame/src/file/tests.rs
@@ -986,13 +986,13 @@ mod process_changes {
 }
 
 mod blame_ranges {
-    use crate::{BlameRanges, Error};
+    use crate::BlameRanges;
 
     #[test]
     fn create_with_invalid_range() {
         let ranges = BlameRanges::from_one_based_inclusive_range(0..=10);
 
-        assert!(matches!(ranges, Err(Error::InvalidOneBasedLineRange)));
+        insta::assert_debug_snapshot!(ranges.expect_err("zero isn't a valid one-based line number"), "create with invalid range", @"Invalid line range was given, line range is expected to be a 1-based inclusive range in the format '<start>,<end>'");
     }
 
     #[test]
diff --git a/gix-blame/src/lib.rs b/gix-blame/src/lib.rs
index 7495189e6fc..94109e0a4ee 100644
--- a/gix-blame/src/lib.rs
+++ b/gix-blame/src/lib.rs
@@ -14,8 +14,6 @@
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
-mod error;
-pub use error::Error;
 mod types;
 pub use types::{BlameEntry, BlamePathEntry, BlameRanges, Options, Outcome, Start, Statistics};
 
diff --git a/gix-blame/src/types.rs b/gix-blame/src/types.rs
index c82cf6d103c..c9d28350d75 100644
--- a/gix-blame/src/types.rs
+++ b/gix-blame/src/types.rs
@@ -1,3 +1,5 @@
+use gix_error::ExnMessageResult;
+use gix_error::validation;
 use gix_hash::ObjectId;
 use gix_object::bstr::BString;
 use smallvec::SmallVec;
@@ -7,7 +9,6 @@ use std::{
     ops::{AddAssign, Range, SubAssign},
 };
 
-use crate::Error;
 use crate::file::function::tokens_for_diffing;
 
 /// A type to represent one or more line ranges to blame in a file.
@@ -54,7 +55,7 @@ impl BlameRanges {
     ///
     /// Note that the input range is 1-based inclusive, as used by git, and
     /// the output is a zero-based `BlameRanges` instance.
-    pub fn from_one_based_inclusive_range(range: RangeInclusive<u32>) -> Result<Self, Error> {
+    pub fn from_one_based_inclusive_range(range: RangeInclusive<u32>) -> ExnMessageResult<Self> {
         let zero_based_range = Self::inclusive_to_zero_based_exclusive(range)?;
         Ok(Self::PartialFile(vec![zero_based_range]))
     }
@@ -65,7 +66,7 @@ impl BlameRanges {
     /// the output is a zero-based `BlameRanges` instance.
     ///
     /// If the input vector is empty, the result will be `WholeFile`.
-    pub fn from_one_based_inclusive_ranges(ranges: Vec<RangeInclusive<u32>>) -> Result<Self, Error> {
+    pub fn from_one_based_inclusive_ranges(ranges: Vec<RangeInclusive<u32>>) -> ExnMessageResult<Self> {
         if ranges.is_empty() {
             return Ok(Self::WholeFile);
         }
@@ -82,9 +83,11 @@ impl BlameRanges {
     }
 
     /// Convert a 1-based inclusive range to a 0-based exclusive range.
-    fn inclusive_to_zero_based_exclusive(range: RangeInclusive<u32>) -> Result<Range<u32>, Error> {
+    fn inclusive_to_zero_based_exclusive(range: RangeInclusive<u32>) -> ExnMessageResult<Range<u32>> {
         if range.start() == &0 {
-            return Err(Error::InvalidOneBasedLineRange);
+            return Err(validation(
+                "Invalid line range was given, line range is expected to be a 1-based inclusive range in the format '<start>,<end>'",
+            ).into());
         }
         let start = range.start() - 1;
         let end = *range.end();
@@ -96,7 +99,7 @@ impl BlameRanges {
     /// Add a single range to blame.
     ///
     /// The new range will be merged with any overlapping existing ranges.
-    pub fn add_one_based_inclusive_range(&mut self, new_range: RangeInclusive<u32>) -> Result<(), Error> {
+    pub fn add_one_based_inclusive_range(&mut self, new_range: RangeInclusive<u32>) -> ExnMessageResult {
         let zero_based_range = Self::inclusive_to_zero_based_exclusive(new_range)?;
         self.merge_zero_based_exclusive_range(zero_based_range);
 
diff --git a/gix-blame/tests/blame.rs b/gix-blame/tests/blame.rs
index 99b14c9c34d..5bbcc66c04c 100644
--- a/gix-blame/tests/blame.rs
+++ b/gix-blame/tests/blame.rs
@@ -1,5 +1,7 @@
 use std::{collections::BTreeMap, path::PathBuf};
 
+use gix_error::ExnResult;
+
 use gix_blame::BlameRanges;
 use gix_hash::ObjectId;
 use gix_object::bstr;
@@ -218,7 +220,7 @@ impl Fixture {
         &mut self,
         source_file_name: &bstr::BStr,
         options: gix_blame::Options,
-    ) -> Result<gix_blame::Outcome, gix_blame::Error> {
+    ) -> ExnResult<gix_blame::Outcome> {
         gix_blame::file(
             &self.odb,
             gix_blame::Start::Commit(self.suspect),
@@ -234,7 +236,7 @@ impl Fixture {
         source_file_name: &bstr::BStr,
         contents: Vec<u8>,
         options: gix_blame::Options,
-    ) -> Result<gix_blame::Outcome, gix_blame::Error> {
+    ) -> ExnResult<gix_blame::Outcome> {
         gix_blame::file(
             &self.odb,
             gix_blame::Start::Contents {
diff --git a/gix-chunk/src/file/decode.rs b/gix-chunk/src/file/decode.rs
index 9f316066a19..e297aa36a64 100644
--- a/gix-chunk/src/file/decode.rs
+++ b/gix-chunk/src/file/decode.rs
@@ -1,5 +1,6 @@
-use gix_error::ValidationError;
+use gix_error::ExnMessageResult;
 use gix_error::bstr::ByteSlice;
+use gix_error::{ErrorExt, validation};
 use std::ops::Range;
 
 use crate::{file, file::index};
@@ -7,11 +8,12 @@ use crate::{file, file::index};
 impl file::Index {
     /// Provided a mapped file at the beginning via `data`, starting at `toc_offset` decode all chunk information to return
     /// an index with `num_chunks` chunks.
-    pub fn from_bytes(data: &[u8], toc_offset: usize, num_chunks: u32) -> Result<Self, ValidationError> {
+    pub fn from_bytes(data: &[u8], toc_offset: usize, num_chunks: u32) -> ExnMessageResult<Self> {
         if num_chunks == 0 {
-            return Err(ValidationError::new(
+            return Err(validation(
                 "Empty chunk indices are not allowed as the point of chunked files is to have chunks.",
-            ));
+            )
+            .into());
         }
 
         let data_len: u64 = data.len() as u64;
@@ -19,42 +21,47 @@ impl file::Index {
         let mut toc_entry = &data[toc_offset..];
         let expected_min_size = (num_chunks as usize + 1) * file::Index::ENTRY_SIZE;
         if toc_entry.len() < expected_min_size {
-            Err(format!(
+            return Err(validation(format!(
                 "The table of contents would be {expected_min_size} bytes, but got only {toc_entry_len}",
                 toc_entry_len = toc_entry.len()
-            ))?;
+            ))
+            .raise());
         }
 
         for chunk_idx in 0..num_chunks {
             let (kind, offset) = toc_entry.split_at(4);
             let kind = to_kind(kind);
             if kind == crate::SENTINEL {
-                Err(format!(
+                return Err(validation(format!(
                     "Sentinel value encountered while processing chunks {chunk_idx} of {num_chunks}"
-                ))?;
+                ))
+                .raise());
             }
             if chunks.iter().any(|c: &index::Entry| c.kind == kind) {
-                Err(format!(
+                return Err(validation(format!(
                     "The chunk of kind '{}' was encountered more than once",
                     kind.as_bstr()
-                ))?;
+                ))
+                .raise());
             }
 
             let offset = be_u64(offset);
             if offset > data_len {
-                Err(format!(
+                return Err(validation(format!(
                     "The chunk offset {offset} went past the file of length {data_len} - was it truncated?",
-                ))?;
+                ))
+                .raise());
             }
             toc_entry = &toc_entry[file::Index::ENTRY_SIZE..];
             let next_offset = be_u64(&toc_entry[4..]);
             if next_offset > data_len {
-                Err(format!(
+                return Err(validation(format!(
                     "The chunk offset {next_offset} went past the file of length {data_len} - was it truncated?"
-                ))?;
+                ))
+                .raise());
             }
             if next_offset <= offset {
-                Err("All chunk offsets must be incrementing.")?;
+                return Err(validation("All chunk offsets must be incrementing.").raise());
             }
             chunks.push(index::Entry {
                 kind,
@@ -67,7 +74,7 @@ impl file::Index {
 
         let sentinel = to_kind(&toc_entry[..4]);
         if sentinel != crate::SENTINEL {
-            Err(format!("Sentinel value wasn't found, saw '{}'", sentinel.as_bstr()))?;
+            return Err(validation(format!("Sentinel value wasn't found, saw '{}'", sentinel.as_bstr())).raise());
         }
 
         Ok(file::Index {
diff --git a/gix-chunk/src/file/index.rs b/gix-chunk/src/file/index.rs
index f2ead63d19c..1cc6877a2a7 100644
--- a/gix-chunk/src/file/index.rs
+++ b/gix-chunk/src/file/index.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::ops::Range;
 
 use crate::Id;
@@ -25,11 +26,12 @@ impl Index {
     }
 
     /// Find a chunk of `kind` and return its offset into the data if found
-    pub fn offset_by_id(&self, kind: Id) -> Result<Range<crate::file::Offset>, Message> {
-        self.chunks
+    pub fn offset_by_id(&self, kind: Id) -> ExnMessageResult<Range<crate::file::Offset>> {
+        Ok(self
+            .chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| c.offset.clone()))
-            .ok_or_else(make_message(kind))
+            .ok_or_else(make_message(kind))?)
     }
 
     /// Find a chunk of `kind` and return its offset as usize range into the data if found.
@@ -39,11 +41,12 @@ impl Index {
     ///
     /// - if the usize conversion fails, which isn't expected as memory maps can't be created if files are too large
     ///   to require such offsets.
-    pub fn usize_offset_by_id(&self, kind: Id) -> Result<Range<usize>, Message> {
-        self.chunks
+    pub fn usize_offset_by_id(&self, kind: Id) -> ExnMessageResult<Range<usize>> {
+        Ok(self
+            .chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| crate::range::into_usize_or_panic(c.offset.clone())))
-            .ok_or_else(make_message(kind))
+            .ok_or_else(make_message(kind))?)
     }
 
     /// Like [`Index::usize_offset_by_id()`] but with support for validation and transformation using a function.
@@ -51,16 +54,17 @@ impl Index {
         &self,
         kind: Id,
         validate: impl FnOnce(Range<usize>) -> T,
-    ) -> Result<T, Message> {
-        self.chunks
+    ) -> ExnMessageResult<T> {
+        Ok(self
+            .chunks
             .iter()
             .find_map(|c| (c.kind == kind).then(|| crate::range::into_usize_or_panic(c.offset.clone())))
             .map(validate)
-            .ok_or_else(make_message(kind))
+            .ok_or_else(make_message(kind))?)
     }
 
     /// Find a chunk of `kind` and return its data slice based on its offset.
-    pub fn data_by_id<'a>(&self, data: &'a [u8], kind: Id) -> Result<&'a [u8], Message> {
+    pub fn data_by_id<'a>(&self, data: &'a [u8], kind: Id) -> ExnMessageResult<&'a [u8]> {
         let offset = self.offset_by_id(kind)?;
         Ok(&data[crate::range::into_usize(offset)
             .ok_or_else(|| message("The offsets into the file couldn't be represented by usize"))?])
diff --git a/gix-chunk/src/lib.rs b/gix-chunk/src/lib.rs
index 9cc8d27754c..fc0a8e70c24 100644
--- a/gix-chunk/src/lib.rs
+++ b/gix-chunk/src/lib.rs
@@ -5,7 +5,7 @@
 //! ## Examples
 //!
 //! ```
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //! use std::io::Write;
 //!
 //! let mut index = gix_chunk::file::Index::for_writing();
diff --git a/gix-chunk/tests/decode.rs b/gix-chunk/tests/decode.rs
new file mode 100644
index 00000000000..b9b47153b71
--- /dev/null
+++ b/gix-chunk/tests/decode.rs
@@ -0,0 +1,79 @@
+use gix_chunk::{Id, SENTINEL, file::Index};
+
+#[test]
+fn malformed_chunk_tables_are_validation_errors() {
+    let cases = [
+        (
+            "empty index",
+            Vec::new(),
+            0,
+            "Empty chunk indices are not allowed as the point of chunked files is to have chunks.",
+        ),
+        (
+            "truncated table",
+            Vec::new(),
+            1,
+            "The table of contents would be 24 bytes, but got only 0",
+        ),
+        (
+            "early sentinel",
+            chunk_file(&[(SENTINEL, 24), (SENTINEL, 26)]),
+            1,
+            "Sentinel value encountered while processing chunks 0 of 1",
+        ),
+        (
+            "duplicate chunk",
+            chunk_file(&[(*b"DATA", 36), (*b"DATA", 37), (SENTINEL, 38)]),
+            2,
+            "The chunk of kind 'DATA' was encountered more than once",
+        ),
+        (
+            "chunk offset past the file",
+            chunk_file(&[(*b"DATA", 27), (SENTINEL, 26)]),
+            1,
+            "The chunk offset 27 went past the file of length 26 - was it truncated?",
+        ),
+        (
+            "next chunk offset past the file",
+            chunk_file(&[(*b"DATA", 24), (SENTINEL, 27)]),
+            1,
+            "The chunk offset 27 went past the file of length 26 - was it truncated?",
+        ),
+        (
+            "equal offsets",
+            chunk_file(&[(*b"DATA", 24), (SENTINEL, 24)]),
+            1,
+            "All chunk offsets must be incrementing.",
+        ),
+        (
+            "decreasing offsets",
+            chunk_file(&[(*b"DATA", 25), (SENTINEL, 24)]),
+            1,
+            "All chunk offsets must be incrementing.",
+        ),
+        (
+            "missing sentinel",
+            chunk_file(&[(*b"DATA", 24), (*b"MISS", 26)]),
+            1,
+            "Sentinel value wasn't found, saw 'MISS'",
+        ),
+    ];
+
+    for (case, data, num_chunks, expected_message) in cases {
+        let err = Index::from_bytes(&data, 0, num_chunks)
+            .err()
+            .expect("malformed chunk tables must be rejected");
+        assert_eq!(err.to_string(), expected_message, "{case} must retain its diagnostic");
+        assert!(err.is_validation(), "{case} must be classified as invalid input: {err}");
+    }
+}
+
+fn chunk_file(entries: &[(Id, u64)]) -> Vec<u8> {
+    let mut data = Vec::new();
+    for (kind, offset) in entries {
+        data.extend_from_slice(kind);
+        data.extend_from_slice(&offset.to_be_bytes());
+    }
+    data.extend_from_slice(b"ab");
+    data
+}
diff --git a/gix-command/Cargo.toml b/gix-command/Cargo.toml
index a7511fb29fe..222227c9720 100644
--- a/gix-command/Cargo.toml
+++ b/gix-command/Cargo.toml
@@ -15,6 +15,7 @@ include = ["/src/*.rs", "/LICENSE-*"]
 doctest = true
 
 [dependencies]
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-trace = { version = "^0.1.20", path = "../gix-trace" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-quote = { version = "^0.8.0", path = "../gix-quote" }
@@ -22,4 +23,5 @@ gix-quote = { version = "^0.8.0", path = "../gix-quote" }
 bstr = { version = "1.12.0", default-features = false, features = ["std", "unicode"] }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-testtools = { path = "../tests/tools", features = ["sha1"] }
diff --git a/gix-command/src/parse.rs b/gix-command/src/parse.rs
index 5c4b40dda95..7471fd4b9ca 100644
--- a/gix-command/src/parse.rs
+++ b/gix-command/src/parse.rs
@@ -1,6 +1,7 @@
 use std::ffi::OsString;
 
 use bstr::{BStr, BString};
+use gix_error::{ExnResult, ResultExt};
 
 /// The result of [`command_line()`].
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -14,6 +15,10 @@ pub struct Outcome {
 }
 
 /// The error returned when a command line cannot be parsed into a command.
+///
+/// Its source is a classification-only [`gix_error::ClassificationMarker`].
+/// Use [`gix_error::classify()`] or `is_validation()` on [`gix_error::Exn`] and [`gix_error::Error`] to check the classification.
+/// Downcast to this type for the parser failure.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Error {
     /// A quote was opened but never closed.
@@ -39,7 +44,11 @@ impl std::fmt::Display for Error {
     }
 }
 
-impl std::error::Error for Error {}
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::VALIDATION })
+    }
+}
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Quote {
@@ -61,7 +70,7 @@ struct Word {
 /// shell identifier. Assignment-only input is rejected because it contains no command to execute. Environment
 /// assignment names are strings, while their values, the command, and arguments are converted losslessly to OS
 /// strings or rejected if the platform cannot represent them.
-pub fn command_line(input: &BStr) -> Result<Outcome, Error> {
+pub fn command_line(input: &BStr) -> ExnResult<Outcome, Error> {
     let mut words = parse_words(input)?;
     let assignment_count = words
         .iter()
@@ -79,7 +88,7 @@ pub fn command_line(input: &BStr) -> Result<Outcome, Error> {
                 into_os_string(word.value[separator + 1..].to_owned().into())?,
             ))
         })
-        .collect::<Result<_, Error>>()?;
+        .collect::<ExnResult<_, Error>>()?;
     Ok(Outcome {
         env,
         command,
@@ -87,7 +96,7 @@ pub fn command_line(input: &BStr) -> Result<Outcome, Error> {
     })
 }
 
-pub(crate) fn arguments(input: &BStr) -> Result<Vec<OsString>, Error> {
+pub(crate) fn arguments(input: &BStr) -> ExnResult<Vec<OsString>, Error> {
     parse_words(input)?
         .into_iter()
         .map(|word| into_os_string(word.value))
@@ -187,8 +196,8 @@ fn push_unquoted(
     value.push(byte);
 }
 
-fn into_os_string(value: BString) -> Result<OsString, Error> {
+fn into_os_string(value: BString) -> ExnResult<OsString, Error> {
     gix_path::try_from_bstring(value)
         .map(std::path::PathBuf::into_os_string)
-        .map_err(|_| Error::UnrepresentableOsString)
+        .or_raise(|| Error::UnrepresentableOsString)
 }
diff --git a/gix-command/tests/command/command_line.rs b/gix-command/tests/command/command_line.rs
index b588322cbca..2b2f975e1f6 100644
--- a/gix-command/tests/command/command_line.rs
+++ b/gix-command/tests/command/command_line.rs
@@ -8,8 +8,8 @@ fn words_are_split_without_expansion() -> gix_testtools::Result {
         command_line(
             r#"cmd 'single quoted' "double \"quoted\"" escaped\ word "kept\q" "" # ignored
 next"#,
-        ),
-        Ok(Outcome {
+        )?,
+        Outcome {
             env: Vec::new(),
             command: "cmd".into(),
             args: args(&[
@@ -20,7 +20,7 @@ next"#,
                 "",
                 "next"
             ]),
-        })
+        }
     );
     assert_eq!(
         command_line("cmd one\\\ntwo")?.args,
@@ -64,21 +64,105 @@ fn invalid_assignment_names_are_arguments() -> gix_testtools::Result {
 
 #[test]
 fn unterminated_quotes_are_rejected() {
-    assert_eq!(command_line("cmd '"), Err(parse::Error::MissingClosingQuote));
-    assert_eq!(command_line("cmd \""), Err(parse::Error::MissingClosingQuote));
-    assert_eq!(command_line("cmd \"\\"), Err(parse::Error::MissingClosingQuote));
+    let mut error_snapshots = Vec::new();
+    for input in ["cmd '", "cmd \"", "cmd \"\\"] {
+        let err = parse::command_line(input.into()).expect_err("unterminated quote");
+        assert_eq!(*err, parse::Error::MissingClosingQuote);
+        error_snapshots.push((input, gix_testtools::redact_debug_snapshot(&err, &[])));
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "unterminated quotes are rejected", @r#"
+    [
+        (
+            "cmd '",
+            missing closing quote,
+        ),
+        (
+            "cmd \"",
+            missing closing quote,
+        ),
+        (
+            "cmd \"\\",
+            missing closing quote,
+        ),
+    ]
+    "#);
 }
 
 #[test]
 fn dangling_unquoted_escape_is_rejected() {
-    assert_eq!(command_line("cmd arg\\"), Err(parse::Error::MissingEscapedByte));
+    let err = parse::command_line("cmd arg\\".into()).expect_err("dangling escape");
+    assert_eq!(*err, parse::Error::MissingEscapedByte);
+    insta::assert_debug_snapshot!(err, "dangling unquoted escape is rejected", @"missing byte after escape");
 }
 
 #[test]
 fn a_command_is_required() {
+    let mut error_snapshots = Vec::new();
     for input in ["", " ", "\t\n", "# comment", "\\\n", "tool=name", "FOO=one BAR=two"] {
-        assert_eq!(command_line(input), Err(parse::Error::MissingCommand), "{input:?}");
+        let err = parse::command_line(input.into()).expect_err("no command");
+        assert_eq!(*err, parse::Error::MissingCommand, "{input:?}");
+        error_snapshots.push((input, gix_testtools::redact_debug_snapshot(&err, &[])));
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "a command is required", @r##"
+    [
+        (
+            "",
+            missing command,
+        ),
+        (
+            " ",
+            missing command,
+        ),
+        (
+            "\t\n",
+            missing command,
+        ),
+        (
+            "# comment",
+            missing command,
+        ),
+        (
+            "\\\n",
+            missing command,
+        ),
+        (
+            "tool=name",
+            missing command,
+        ),
+        (
+            "FOO=one BAR=two",
+            missing command,
+        ),
+    ]
+    "##);
+}
+
+#[test]
+fn parse_errors_retain_their_classification() {
+    let mut error_snapshots = Vec::new();
+    for input in ["cmd '", "cmd arg\\", "FOO=one"] {
+        let err = parse::command_line(input.into()).expect_err("the command line is invalid");
+        let cause = *err;
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "invalid commands classify as validation failures");
+        assert_eq!(
+            err.probable_cause().downcast_ref::<parse::Error>(),
+            Some(&cause),
+            "the parser error, not its classification marker, is the probable cause"
+        );
+        assert_eq!(
+            err.downcast_any_ref::<parse::Error>(),
+            Some(&cause),
+            "the original parser error remains available"
+        );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "parse errors retain their classification", @"
+    [
+        missing closing quote,
+        missing byte after escape,
+        missing command,
+    ]
+    ");
 }
 
 #[test]
@@ -88,7 +172,7 @@ fn non_utf8_input_is_preserved() -> gix_testtools::Result {
     use std::os::unix::ffi::OsStringExt;
 
     assert_eq!(
-        parse::command_line(b"FOO=\xff cmd \xfe".as_bstr())?,
+        parse::command_line(b"FOO=\xff cmd \xfe".as_bstr()).map_err(gix_error::Exn::into_error)?,
         Outcome {
             env: vec![("FOO".into(), OsString::from_vec(vec![0xff]))],
             command: "cmd".into(),
@@ -98,8 +182,8 @@ fn non_utf8_input_is_preserved() -> gix_testtools::Result {
     Ok(())
 }
 
-fn command_line(input: &str) -> Result<Outcome, parse::Error> {
-    parse::command_line(input.into())
+fn command_line(input: &str) -> Result<Outcome, gix_error::Error> {
+    parse::command_line(input.into()).map_err(gix_error::Exn::into_error)
 }
 
 fn args(input: &[&str]) -> Vec<OsString> {
diff --git a/gix-command/tests/command/prepare.rs b/gix-command/tests/command/prepare.rs
index 21a7ac983a3..388c5a9d50a 100644
--- a/gix-command/tests/command/prepare.rs
+++ b/gix-command/tests/command/prepare.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::sync::LazyLock;
 
 fn default_shell() -> &'static str {
@@ -236,7 +237,7 @@ fn invalid_utf8_commands_are_checked_for_shell_syntax() {
 }
 
 #[test]
-fn relative_existing_paths_with_shell_syntax_still_use_the_shell() -> crate::Result {
+fn relative_existing_paths_with_shell_syntax_still_use_the_shell() -> Result {
     let temp = gix_testtools::tempfile::Builder::new()
         .prefix("$HOME")
         .tempdir_in(".")?;
diff --git a/gix-command/tests/command/spawn.rs b/gix-command/tests/command/spawn.rs
index 3a7cd7d1b0a..ed96f4ef86b 100644
--- a/gix-command/tests/command/spawn.rs
+++ b/gix-command/tests/command/spawn.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use bstr::ByteSlice;
 
 #[test]
-fn environment_variables_are_passed_one_by_one() -> crate::Result {
+fn environment_variables_are_passed_one_by_one() -> Result {
     let out = gix_command::prepare("echo $FIRST $SECOND")
         .env("FIRST", "first")
         .env("SECOND", "second")
@@ -13,7 +14,7 @@ fn environment_variables_are_passed_one_by_one() -> crate::Result {
 }
 
 #[test]
-fn disallow_shell() -> crate::Result {
+fn disallow_shell() -> Result {
     let out = gix_command::prepare("PATH= echo hi")
         .command_may_be_shell_script_disallow_manual_argument_splitting()
         .spawn()?
@@ -32,7 +33,7 @@ fn disallow_shell() -> crate::Result {
 }
 
 #[test]
-fn script_with_dollar_at() -> crate::Result {
+fn script_with_dollar_at() -> Result {
     let out = std::process::Command::from(
         gix_command::prepare(r#"echo "$@""#)
             .command_may_be_shell_script()
@@ -49,7 +50,7 @@ fn script_with_dollar_at() -> crate::Result {
 }
 
 #[test]
-fn direct_command_execution_searches_in_path() -> crate::Result {
+fn direct_command_execution_searches_in_path() -> Result {
     assert!(
         gix_command::prepare(if cfg!(unix) { "ls" } else { "attrib.exe" })
             .spawn()?
@@ -61,16 +62,17 @@ fn direct_command_execution_searches_in_path() -> crate::Result {
 
 #[cfg(unix)]
 #[test]
-fn direct_command_with_absolute_command_path() -> crate::Result {
+fn direct_command_with_absolute_command_path() -> Result {
     assert!(gix_command::prepare("/usr/bin/env").spawn()?.wait()?.success());
     Ok(())
 }
 
 mod with_shell {
+    use crate::Result;
     use gix_testtools::bstr::ByteSlice;
 
     #[test]
-    fn command_in_path_with_args() -> crate::Result {
+    fn command_in_path_with_args() -> Result {
         // `ls` is occasionaly a builtin, as in busybox ash, but it is usually external.
         assert!(
             gix_command::prepare(if cfg!(unix) { "ls -l" } else { "attrib.exe /d" })
@@ -84,7 +86,7 @@ mod with_shell {
 
     #[cfg(unix)]
     #[test]
-    fn shell_builtin_or_command_in_path() -> crate::Result {
+    fn shell_builtin_or_command_in_path() -> Result {
         let out = gix_command::prepare("echo")
             .command_may_be_shell_script()
             .spawn()?
@@ -96,7 +98,7 @@ mod with_shell {
 
     #[cfg(unix)]
     #[test]
-    fn shell_builtin_or_command_in_path_with_single_extra_arg() -> crate::Result {
+    fn shell_builtin_or_command_in_path_with_single_extra_arg() -> Result {
         let out = gix_command::prepare("printf")
             .command_may_be_shell_script()
             .arg("1")
@@ -109,7 +111,7 @@ mod with_shell {
 
     #[cfg(unix)]
     #[test]
-    fn shell_builtin_or_command_in_path_with_multiple_extra_args() -> crate::Result {
+    fn shell_builtin_or_command_in_path_with_multiple_extra_args() -> Result {
         let out = gix_command::prepare("printf")
             .command_may_be_shell_script()
             .arg("%s")
@@ -122,7 +124,7 @@ mod with_shell {
     }
 
     #[test]
-    fn force_shell_builtin() -> crate::Result {
+    fn force_shell_builtin() -> Result {
         let out = gix_command::prepare("echo").with_shell().spawn()?.wait_with_output()?;
         assert!(out.status.success());
         assert_eq!(out.stdout.as_bstr(), "\n");
@@ -130,7 +132,7 @@ mod with_shell {
     }
 
     #[test]
-    fn force_shell_builtin_with_single_extra_arg() -> crate::Result {
+    fn force_shell_builtin_with_single_extra_arg() -> Result {
         let out = gix_command::prepare("printf")
             .with_shell()
             .arg("1")
@@ -142,7 +144,7 @@ mod with_shell {
     }
 
     #[test]
-    fn force_shell_builtin_with_multiple_extra_args() -> crate::Result {
+    fn force_shell_builtin_with_multiple_extra_args() -> Result {
         let out = gix_command::prepare("printf")
             .with_shell()
             .arg("%s")
@@ -155,7 +157,7 @@ mod with_shell {
     }
 
     #[test]
-    fn sh_shell_specific_script_code() -> crate::Result {
+    fn sh_shell_specific_script_code() -> Result {
         assert!(
             gix_command::prepare(":;:;:")
                 .command_may_be_shell_script()
@@ -167,7 +169,7 @@ mod with_shell {
     }
 
     #[test]
-    fn sh_shell_specific_script_code_with_single_extra_arg() -> crate::Result {
+    fn sh_shell_specific_script_code_with_single_extra_arg() -> Result {
         let out = gix_command::prepare(":;printf")
             .command_may_be_shell_script()
             .arg("1")
@@ -179,7 +181,7 @@ mod with_shell {
     }
 
     #[test]
-    fn sh_shell_specific_script_code_with_multiple_extra_args() -> crate::Result {
+    fn sh_shell_specific_script_code_with_multiple_extra_args() -> Result {
         let out = gix_command::prepare(":;printf")
             .command_may_be_shell_script()
             .arg("%s")
@@ -193,7 +195,7 @@ mod with_shell {
 
     #[cfg(unix)]
     #[test]
-    fn dollar_zero_in_minus_c_is_basename_of_default_shell() -> crate::Result {
+    fn dollar_zero_in_minus_c_is_basename_of_default_shell() -> Result {
         let out = gix_command::prepare(r#"printf %s "$0""#)
             .command_may_be_shell_script()
             .spawn()?
@@ -209,7 +211,7 @@ mod with_shell {
 
     #[cfg(unix)]
     #[test]
-    fn dollar_zero_in_minus_c_reflects_with_shell_program() -> crate::Result {
+    fn dollar_zero_in_minus_c_reflects_with_shell_program() -> Result {
         let out = std::process::Command::from(
             gix_command::prepare(r#"printf %s "$0""#)
                 .command_may_be_shell_script()
diff --git a/gix-commitgraph/Cargo.toml b/gix-commitgraph/Cargo.toml
index 164f4b11eeb..110488ada61 100644
--- a/gix-commitgraph/Cargo.toml
+++ b/gix-commitgraph/Cargo.toml
@@ -36,6 +36,7 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-testtools = { path = "../tests/tools", default-features = false }
 gix-date = { path = "../gix-date" }
 gix-hash = { path = "../gix-hash", features = ["sha1", "sha256"] }
diff --git a/gix-commitgraph/src/file/commit.rs b/gix-commitgraph/src/file/commit.rs
index dee517ae361..0648ee0508b 100644
--- a/gix-commitgraph/src/file/commit.rs
+++ b/gix-commitgraph/src/file/commit.rs
@@ -3,7 +3,8 @@ use crate::{
     File, Position,
     file::{self, EXTENDED_EDGES_MASK, LAST_EXTENDED_EDGE_MASK, NO_PARENT},
 };
-use gix_error::{Message, message};
+use gix_error::ExnMessageResult;
+use gix_error::message;
 use std::{
     fmt::{Debug, Formatter},
     slice::Chunks,
@@ -77,7 +78,7 @@ impl<'a> Commit<'a> {
     }
 
     /// Returns the first parent of this commit.
-    pub fn parent1(&self) -> Result<Option<Position>, Message> {
+    pub fn parent1(&self) -> ExnMessageResult<Option<Position>> {
         self.iter_parents().next().transpose()
     }
 
@@ -122,7 +123,7 @@ pub struct Parents<'a> {
 }
 
 impl Iterator for Parents<'_> {
-    type Item = Result<Position, Message>;
+    type Item = ExnMessageResult<Position>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let state = std::mem::replace(&mut self.state, ParentIteratorState::Exhausted);
@@ -133,7 +134,8 @@ impl Iterator for Parents<'_> {
                     _ => Some(Err(message!(
                         "commit {} has a second parent but not a first parent",
                         self.commit_data.id()
-                    ))),
+                    )
+                    .into())),
                 },
                 ParentEdge::GraphPosition(pos) => {
                     self.state = ParentIteratorState::Second;
@@ -142,7 +144,8 @@ impl Iterator for Parents<'_> {
                 ParentEdge::ExtraEdgeIndex(_) => Some(Err(message!(
                     "commit {}'s first parent is an extra edge index, which is invalid",
                     self.commit_data.id(),
-                ))),
+                )
+                .into())),
             },
             ParentIteratorState::Second => match self.commit_data.parent2 {
                 ParentEdge::None => None,
@@ -164,13 +167,15 @@ impl Iterator for Parents<'_> {
                             Some(Err(message!(
                                 "commit {}'s extra edges overflows the commit-graph file's extra edges list",
                                 self.commit_data.id()
-                            )))
+                            )
+                            .into()))
                         }
                     } else {
                         Some(Err(message!(
                             "commit {} has extra edges, but commit-graph file has no extra edges list",
                             self.commit_data.id()
-                        )))
+                        )
+                        .into()))
                     }
                 }
             },
@@ -188,7 +193,8 @@ impl Iterator for Parents<'_> {
                     Some(Err(message!(
                         "commit {}'s extra edges overflows the commit-graph file's extra edges list",
                         self.commit_data.id()
-                    )))
+                    )
+                    .into()))
                 }
             }
             ParentIteratorState::Exhausted => None,
diff --git a/gix-commitgraph/src/file/init.rs b/gix-commitgraph/src/file/init.rs
index ee98d0b7ad6..e74cf005595 100644
--- a/gix-commitgraph/src/file/init.rs
+++ b/gix-commitgraph/src/file/init.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use gix_error::{ErrorExt, Exn, Message, ResultExt, message};
+use gix_error::{ErrorExt, Exn, ExnMessageResult, Message, ResultExt, message};
 
 use crate::{
     File,
@@ -17,7 +17,7 @@ const MIN_FILE_SIZE: usize = HEADER_LEN
 
 impl File {
     /// Try to parse the commit graph file at `path`.
-    pub fn at(path: impl AsRef<Path>) -> Result<File, Exn<Message>> {
+    pub fn at(path: impl AsRef<Path>) -> ExnMessageResult<File> {
         Self::try_from(path.as_ref())
     }
 
@@ -26,7 +26,7 @@ impl File {
     ///
     /// Note that `path` is only used for verification of the hash its basename contains, but otherwise
     /// is not of importance.
-    pub fn new(data: memmap2::Mmap, path: PathBuf) -> Result<File, Exn<Message>> {
+    pub fn new(data: memmap2::Mmap, path: PathBuf) -> ExnMessageResult<File> {
         let data_size = data.len();
         if data_size < MIN_FILE_SIZE {
             return Err(message("Commit-graph file too small even for an empty graph").raise());
diff --git a/gix-commitgraph/src/file/verify.rs b/gix-commitgraph/src/file/verify.rs
index 73571946370..9138e3a2213 100644
--- a/gix-commitgraph/src/file/verify.rs
+++ b/gix-commitgraph/src/file/verify.rs
@@ -5,7 +5,7 @@ use std::{
     path::Path,
 };
 
-use gix_error::{ErrorExt, Exn, Message, ResultExt, message};
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, ResultExt, message};
 
 use crate::{File, GENERATION_NUMBER_INFINITY, GENERATION_NUMBER_MAX, file};
 
@@ -35,9 +35,9 @@ impl File {
     /// Traverse all [commits][file::Commit] stored in this file and call `processor(commit) -> Result<(), Error>` on it.
     ///
     /// If the `processor` fails, the iteration will be stopped and the entire call results in the respective error.
-    pub fn traverse<'a, Processor>(&'a self, mut processor: Processor) -> Result<Outcome, Exn<Message>>
+    pub fn traverse<'a, Processor>(&'a self, mut processor: Processor) -> ExnMessageResult<Outcome>
     where
-        Processor: FnMut(&file::Commit<'a>) -> Result<(), Exn>,
+        Processor: FnMut(&file::Commit<'a>) -> ExnResult,
     {
         self.verify_checksum()?;
         verify_split_chain_filename_hash(&self.path, self.checksum())?;
@@ -102,26 +102,24 @@ impl File {
     /// Assure the [`checksum`][File::checksum()] matches the actual checksum over all content of this file, excluding the trailing
     /// checksum itself.
     ///
-    /// Return the actual checksum on success or [`Exn<Message>`] if there is a mismatch.
-    pub fn verify_checksum(&self) -> Result<gix_hash::ObjectId, Exn<Message>> {
-        // Even though we could use gix_hash::bytes_of_file(…), this would require extending our
-        // Error type to support io::Error. As we only gain progress, there probably isn't much value
-        // as these files are usually small enough to process them in less than a second, even for the large ones.
-        // But it's possible, once a progress instance is passed.
+    /// Return the actual checksum on success or [`Exn<Message>`](gix_error::Exn) if there is a mismatch.
+    pub fn verify_checksum(&self) -> ExnMessageResult<gix_hash::ObjectId> {
         let data_len_without_trailer = self.data.len() - self.hash_len;
         let mut hasher = gix_hash::hasher(self.object_hash());
         hasher.update(&self.data[..data_len_without_trailer]);
         let actual = hasher
             .try_finalize()
-            .map_err(|e| message!("failed to hash commit graph file: {e}").raise())?;
-        actual.verify(self.checksum()).map_err(|e| message!("{e}").raise())?;
+            .or_raise(|| message("failed to hash commit graph file"))?;
+        actual
+            .verify(self.checksum())
+            .or_raise(|| message("commit-graph checksum does not match"))?;
         Ok(actual)
     }
 }
 
 /// If the given path's filename matches "graph-{hash}.graph", check that `hash` matches the
 /// expected hash.
-fn verify_split_chain_filename_hash(path: &Path, expected: &gix_hash::oid) -> Result<(), Exn<Message>> {
+fn verify_split_chain_filename_hash(path: &Path, expected: &gix_hash::oid) -> ExnMessageResult {
     path.file_name()
         .and_then(std::ffi::OsStr::to_str)
         .and_then(|filename| filename.strip_suffix(".graph"))
diff --git a/gix-commitgraph/src/init.rs b/gix-commitgraph/src/init.rs
index ac0de2b3d5f..6d4b2fbde48 100644
--- a/gix-commitgraph/src/init.rs
+++ b/gix-commitgraph/src/init.rs
@@ -1,4 +1,5 @@
 use crate::{File, Graph, MAX_COMMITS};
+use gix_error::ExnMessageResult;
 use gix_error::{ErrorExt, Exn, Message, ResultExt, message};
 use std::{
     io::{BufRead, BufReader},
@@ -10,12 +11,12 @@ impl Graph {
     /// Instantiate a commit graph from `path` which may be a directory containing graph files or the graph file itself.
     ///
     /// Filesystem errors retain their [`std::io::Error`] source, including when `path` does not exist.
-    pub fn at(path: &Path) -> Result<Self, Exn<Message>> {
+    pub fn at(path: &Path) -> ExnMessageResult<Self> {
         Self::try_from(path)
     }
 
     /// Instantiate a commit graph from the directory containing all of its files.
-    pub fn from_commit_graphs_dir(path: &Path) -> Result<Self, Exn<Message>> {
+    pub fn from_commit_graphs_dir(path: &Path) -> ExnMessageResult<Self> {
         let commit_graphs_dir = path;
         let chain_file_path = commit_graphs_dir.join("commit-graph-chain");
         let chain_file = std::fs::File::open(&chain_file_path).or_raise(|| {
@@ -38,31 +39,31 @@ impl Graph {
                     .or_raise(|| message!("Could not open commit-graph file at '{}'", graph_file_path.display()))?,
             );
         }
-        Ok(Self::new(files)?)
+        Self::new(files)
     }
 
     /// Instantiate a commit graph from a `.git/objects/info/commit-graph` or
     /// `.git/objects/info/commit-graphs/graph-*.graph` file.
-    pub fn from_file(path: &Path) -> Result<Self, Exn<Message>> {
+    pub fn from_file(path: &Path) -> ExnMessageResult<Self> {
         let file = File::at(path).or_raise(|| message!("Could not open commit-graph file at '{}'", path.display()))?;
-        Ok(Self::new(vec![file])?)
+        Self::new(vec![file])
     }
 
     /// Instantiate a commit graph from an `.git/objects/info` directory.
-    pub fn from_info_dir(info_dir: &Path) -> Result<Self, Exn<Message>> {
+    pub fn from_info_dir(info_dir: &Path) -> ExnMessageResult<Self> {
         Self::from_file(&info_dir.join("commit-graph"))
             .or_else(|_| Self::from_commit_graphs_dir(&info_dir.join("commit-graphs")))
     }
 
     /// Create a new commit graph from a list of `files`.
-    pub fn new(files: Vec<File>) -> Result<Self, Message> {
+    pub fn new(files: Vec<File>) -> ExnMessageResult<Self> {
         let files = nonempty::NonEmpty::from_vec(files)
             .ok_or_else(|| message!("Commit-graph must contain at least one file"))?;
         let num_commits: u64 = files.iter().map(|f| u64::from(f.num_commits())).sum();
         if num_commits > u64::from(MAX_COMMITS) {
             return Err(message!(
                 "Commit-graph files contain {num_commits} commits altogether, but only {MAX_COMMITS} commits are allowed"
-            ));
+            ).into());
         }
 
         let mut f1 = files.first();
@@ -74,7 +75,8 @@ impl Graph {
                     hash1 = f1.object_hash(),
                     path2 = f2.path().display(),
                     hash2 = f2.object_hash(),
-                ));
+                )
+                .into());
             }
             f1 = f2;
         }
@@ -86,7 +88,7 @@ impl Graph {
 impl TryFrom<&Path> for Graph {
     type Error = Exn<Message>;
 
-    fn try_from(path: &Path) -> Result<Self, Self::Error> {
+    fn try_from(path: &Path) -> std::result::Result<Self, Self::Error> {
         let metadata = path
             .metadata()
             .or_raise(|| message!("Could not access commit-graph path at '{}'", path.display()))?;
diff --git a/gix-commitgraph/src/lib.rs b/gix-commitgraph/src/lib.rs
index 7368250c25d..f1708eac173 100644
--- a/gix-commitgraph/src/lib.rs
+++ b/gix-commitgraph/src/lib.rs
@@ -15,9 +15,10 @@
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg))]
 #![deny(missing_docs, unsafe_code)]
 
-use gix_error::{Exn, Message};
 use std::path::Path;
 
+use gix_error::ExnMessageResult;
+
 /// A single commit-graph file.
 ///
 /// All operations on a `File` are local to that graph file. Since a commit graph can span multiple
@@ -45,7 +46,7 @@ pub struct Graph {
 }
 
 /// Instantiate a commit graph from an `.git/objects/info` directory, or one of the various commit-graph files.
-pub fn at(path: impl AsRef<Path>) -> Result<Graph, Exn<Message>> {
+pub fn at(path: impl AsRef<Path>) -> ExnMessageResult<Graph> {
     Graph::at(path.as_ref())
 }
 
diff --git a/gix-commitgraph/src/verify.rs b/gix-commitgraph/src/verify.rs
index 52160867df7..e27c0a07538 100644
--- a/gix-commitgraph/src/verify.rs
+++ b/gix-commitgraph/src/verify.rs
@@ -4,7 +4,7 @@ use std::{
     collections::BTreeMap,
 };
 
-use gix_error::{ErrorExt, Exn, Message, ResultExt, message};
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt, message};
 
 use crate::{
     GENERATION_NUMBER_MAX, Graph, Position,
@@ -34,7 +34,7 @@ impl Graph {
     pub fn verify_integrity<E>(
         &self,
         mut processor: impl FnMut(&file::Commit<'_>) -> Result<(), E>,
-    ) -> Result<Outcome, Exn<Message>>
+    ) -> ExnMessageResult<Outcome>
     where
         E: std::error::Error + Send + Sync + 'static,
     {
@@ -93,7 +93,7 @@ impl Graph {
             let file_stats = file.traverse(|commit| {
                 let mut max_parent_generation = 0u32;
                 for parent_pos in commit.iter_parents() {
-                    let parent_pos = parent_pos.map_err(|err| err.raise_erased())?;
+                    let parent_pos = parent_pos.map_err(gix_error::Exn::erased)?;
                     if parent_pos >= next_file_start_pos {
                         return Err(message!(
                             "Commit {} has parent position {parent_pos} that is out of range (should be in range 0-{})",
diff --git a/gix-commitgraph/tests/commitgraph.rs b/gix-commitgraph/tests/commitgraph.rs
index 07aa851dcc6..b736c40d2c8 100644
--- a/gix-commitgraph/tests/commitgraph.rs
+++ b/gix-commitgraph/tests/commitgraph.rs
@@ -11,21 +11,43 @@ use gix_testtools::scripted_fixture_read_only;
 mod access;
 
 #[test]
-fn missing_path_keeps_io_error() -> gix_testtools::Result {
+fn missing_path_is_not_found() -> gix_testtools::Result {
     let dir = gix_testtools::tempfile::tempdir()?;
     let err = gix_commitgraph::at(dir.path().join("missing"))
         .err()
         .expect("a missing path cannot contain a commit-graph");
-    assert_eq!(
-        err.downcast_any_ref::<std::io::Error>()
-            .expect("the filesystem error is preserved")
-            .kind(),
-        std::io::ErrorKind::NotFound,
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(dir.path()).to_string_lossy(), "<tmp>")]), "callers can distinguish a missing optional cache from other failures", @"
+    Could not access commit-graph path at '<tmp>/missing'
+    |
+    └─ NotFound
+    ");
+    assert!(
+        err.is_not_found(),
         "callers can distinguish a missing optional cache from other failures"
     );
     Ok(())
 }
 
+#[test]
+fn checksum_mismatches_retain_their_classification() -> gix_testtools::Result {
+    let repo = gix_testtools::scripted_fixture_writable("single_commit.sh")?;
+    let mut data = std::fs::read(repo.path().join(".git/objects/info/commit-graph"))?;
+    *data.last_mut().expect("the graph has a checksum trailer") ^= 1;
+    // Git can make its graph read-only; corrupt a separate file.
+    let path = repo.path().join("corrupt-commit-graph");
+    std::fs::write(&path, data)?;
+
+    let graph = gix_commitgraph::File::at(path).map_err(gix_error::Exn::into_error)?;
+    let err = graph.verify_checksum().expect_err("the checksum no longer matches");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "a checksum mismatch is corruption", @"
+    commit-graph checksum does not match
+    |
+    └─ Hash was Oid(1), but should have been Oid(2)
+    ");
+    assert!(err.is_corrupted(), "a checksum mismatch is corruption");
+    Ok(())
+}
+
 pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHasher>) {
     cg.verify_integrity(|_| Ok::<_, gix_error::Message>(()))
         .expect("graph is valid");
diff --git a/gix-config-value/Cargo.toml b/gix-config-value/Cargo.toml
index 730bc421b2e..cdfcf5508d7 100644
--- a/gix-config-value/Cargo.toml
+++ b/gix-config-value/Cargo.toml
@@ -20,8 +20,8 @@ serde = ["dep:serde", "bstr/serde"]
 
 [dependencies]
 gix-path = { version = "^0.12.4", path = "../gix-path" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
-thiserror = "2.0.18"
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 bitflags = "2"
@@ -34,3 +34,7 @@ libc = "0.2"
 [package.metadata.docs.rs]
 all-features = true
 features = ["document-features"]
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
diff --git a/gix-config-value/fuzz/fuzz_targets/fuzz_value.rs b/gix-config-value/fuzz/fuzz_targets/fuzz_value.rs
index f80d64ba319..664c2e5a712 100644
--- a/gix-config-value/fuzz/fuzz_targets/fuzz_value.rs
+++ b/gix-config-value/fuzz/fuzz_targets/fuzz_value.rs
@@ -24,19 +24,19 @@ struct Ctx<'a> {
 }
 
 fn fuzz(ctx: Ctx) -> Result<()> {
-    let b = Boolean::try_from(BStr::new(ctx.bool_str))?;
+    let b = Boolean::try_from(BStr::new(ctx.bool_str)).map_err(|err| err.into_error())?;
     _ = black_box(b.is_true());
 
-    _ = black_box(Color::try_from(BStr::new(ctx.color_str)))?;
+    _ = black_box(Color::try_from(BStr::new(ctx.color_str))).map_err(|err| err.into_error())?;
 
     let mut buf = String::with_capacity(128);
-    let a = Attribute::from_str(ctx.attribute_str)?;
+    let a = Attribute::from_str(ctx.attribute_str).map_err(|err| err.into_error())?;
     _ = black_box(write!(&mut buf, "{a}"));
 
-    let name = Name::from_str(ctx.name_str)?;
+    let name = Name::from_str(ctx.name_str).map_err(|err| err.into_error())?;
     _ = black_box(write!(&mut buf, "{name}"));
 
-    let i = Integer::try_from(BStr::new(ctx.integer_str))?;
+    let i = Integer::try_from(BStr::new(ctx.integer_str)).map_err(|err| err.into_error())?;
     _ = black_box(i.to_decimal());
 
     let p = Path::from(BStr::new(ctx.path_str));
diff --git a/gix-config-value/src/boolean.rs b/gix-config-value/src/boolean.rs
index 444b929e827..006698ed0d3 100644
--- a/gix-config-value/src/boolean.rs
+++ b/gix-config-value/src/boolean.rs
@@ -1,22 +1,21 @@
 use std::{borrow::Cow, ffi::OsString, fmt::Display};
 
 use bstr::{BStr, BString};
+use gix_error::{ErrorExt, Message, ResultExt, validation};
 
-use crate::{Boolean, Error, Integer};
+use crate::{Boolean, Integer};
 
-fn bool_err(input: impl Into<BString>) -> Error {
-    Error::new(
-        "Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number",
-        input,
-    )
+fn bool_err(input: impl Into<BString>) -> Message {
+    validation("Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number")
+        .with("input", gix_error::MetadataValue::Bytes(input.into()))
 }
 
 impl TryFrom<OsString> for Boolean {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: OsString) -> Result<Self, Self::Error> {
         let value = gix_path::os_str_into_bstr(&value)
-            .map_err(|_| Error::new("Illformed UTF-8", std::path::Path::new(&value).display().to_string()))?;
+            .or_raise(|| validation("Illformed UTF-8").with("input", value.as_encoded_bytes()))?;
         Self::try_from(value)
     }
 }
@@ -36,7 +35,7 @@ impl TryFrom<OsString> for Boolean {
 /// Instead of this, obtain booleans with `config.boolean(…)`, which handles the case were no separator is
 /// present correctly.
 impl TryFrom<&BStr> for Boolean {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &BStr) -> Result<Self, Self::Error> {
         if parse_true(value) {
@@ -46,13 +45,13 @@ impl TryFrom<&BStr> for Boolean {
         } else if let Some(integer) = Integer::try_from(value).ok().and_then(|integer| integer.to_decimal()) {
             Ok(Boolean(integer != 0))
         } else {
-            Err(bool_err(value))
+            Err(bool_err(value).raise())
         }
     }
 }
 
 impl TryFrom<&str> for Boolean {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(value))
@@ -69,14 +68,14 @@ impl Boolean {
 }
 
 impl TryFrom<Cow<'_, BStr>> for Boolean {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
     fn try_from(c: Cow<'_, BStr>) -> Result<Self, Self::Error> {
         Self::try_from(c.as_ref())
     }
 }
 
 impl TryFrom<BString> for Boolean {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
     fn try_from(value: BString) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(&value))
     }
diff --git a/gix-config-value/src/color.rs b/gix-config-value/src/color.rs
index c8da8b2f30c..c42335edacb 100644
--- a/gix-config-value/src/color.rs
+++ b/gix-config-value/src/color.rs
@@ -1,8 +1,9 @@
 use std::{borrow::Cow, fmt::Display, str::FromStr};
 
 use bstr::{BStr, BString};
+use gix_error::{ErrorExt, Message, ResultExt, validation};
 
-use crate::{Color, Error};
+use crate::Color;
 
 impl Display for Color {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -30,18 +31,16 @@ impl Display for Color {
     }
 }
 
-fn color_err(input: impl Into<BString>) -> Error {
-    Error::new(
-        "Colors are specific color values and their attributes, like 'brightred', or 'blue'",
-        input,
-    )
+fn color_err(input: impl Into<BString>) -> Message {
+    validation("Colors are specific color values and their attributes, like 'brightred', or 'blue'")
+        .with("input", gix_error::MetadataValue::Bytes(input.into()))
 }
 
 impl TryFrom<&BStr> for Color {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(s: &BStr) -> Result<Self, Self::Error> {
-        let s = std::str::from_utf8(s).map_err(|err| color_err(s).with_err(err))?;
+        let s = std::str::from_utf8(s).or_raise(|| color_err(s))?;
         enum ColorItem {
             Value(Name),
             Attr(Attribute),
@@ -71,12 +70,12 @@ impl TryFrom<&BStr> for Color {
                         } else if background.is_none() {
                             background = Some(v);
                         } else {
-                            return Err(color_err(s));
+                            return Err(color_err(s).raise());
                         }
                     }
                     ColorItem::Attr(a) => attributes |= a,
                 },
-                Err(_) => return Err(color_err(s)),
+                Err(_) => return Err(color_err(s).raise()),
             }
         }
 
@@ -89,7 +88,7 @@ impl TryFrom<&BStr> for Color {
 }
 
 impl TryFrom<&str> for Color {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(value))
@@ -97,7 +96,7 @@ impl TryFrom<&str> for Color {
 }
 
 impl TryFrom<Cow<'_, BStr>> for Color {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(c: Cow<'_, BStr>) -> Result<Self, Self::Error> {
         Self::try_from(c.as_ref())
@@ -105,7 +104,7 @@ impl TryFrom<Cow<'_, BStr>> for Color {
 }
 
 impl TryFrom<BString> for Color {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: BString) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(&value))
@@ -230,7 +229,7 @@ fn parse_hex(hex: &[u8]) -> Option<(u8, u8, u8)> {
 }
 
 impl FromStr for Name {
-    type Err = Error;
+    type Err = gix_error::Exn<gix_error::Message>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         const BASIC: &[(&str, Name, Name)] = &[
@@ -260,7 +259,7 @@ impl FromStr for Name {
         }
 
         if is_bright {
-            return Err(color_err(s));
+            return Err(color_err(s).raise());
         }
 
         if s.eq_ignore_ascii_case("normal") || s == "-1" {
@@ -281,15 +280,15 @@ impl FromStr for Name {
             return Ok(Self::Rgb(r, g, b));
         }
 
-        Err(color_err(s))
+        Err(color_err(s).raise())
     }
 }
 
 impl TryFrom<&BStr> for Name {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(s: &BStr) -> Result<Self, Self::Error> {
-        Self::from_str(std::str::from_utf8(s).map_err(|err| color_err(s).with_err(err))?)
+        Self::from_str(std::str::from_utf8(s).or_raise(|| color_err(s))?)
     }
 }
 
@@ -383,7 +382,7 @@ impl serde::Serialize for Attribute {
 }
 
 impl FromStr for Attribute {
-    type Err = Error;
+    type Err = gix_error::Exn<gix_error::Message>;
 
     fn from_str(mut s: &str) -> Result<Self, Self::Err> {
         let inverted = if let Some(rest) = s.strip_prefix("no-").or_else(|| s.strip_prefix("no")) {
@@ -395,7 +394,7 @@ impl FromStr for Attribute {
 
         if s.eq_ignore_ascii_case("reset") {
             return if inverted {
-                Err(color_err(s))
+                Err(color_err(s).raise())
             } else {
                 Ok(Attribute::RESET)
             };
@@ -416,15 +415,15 @@ impl FromStr for Attribute {
             "italic" if inverted => Ok(Attribute::NO_ITALIC),
             "strike" if !inverted => Ok(Attribute::STRIKE),
             "strike" if inverted => Ok(Attribute::NO_STRIKE),
-            _ => Err(color_err(s)),
+            _ => Err(color_err(s).raise()),
         }
     }
 }
 
 impl TryFrom<&BStr> for Attribute {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(s: &BStr) -> Result<Self, Self::Error> {
-        Self::from_str(std::str::from_utf8(s).map_err(|err| color_err(s).with_err(err))?)
+        Self::from_str(std::str::from_utf8(s).or_raise(|| color_err(s))?)
     }
 }
diff --git a/gix-config-value/src/integer.rs b/gix-config-value/src/integer.rs
index 81c7fd33e07..f48d9d2f140 100644
--- a/gix-config-value/src/integer.rs
+++ b/gix-config-value/src/integer.rs
@@ -1,8 +1,9 @@
 use std::{borrow::Cow, fmt::Display, str::FromStr};
 
-use bstr::{BStr, BString};
+use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, Message, ResultExt, validation};
 
-use crate::{Error, Integer};
+use crate::Integer;
 
 impl Integer {
     /// Canonicalize values as simple decimal numbers.
@@ -47,11 +48,9 @@ impl serde::Serialize for Integer {
     }
 }
 
-fn int_err(input: impl Into<BString>) -> Error {
-    Error::new(
-        "Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G",
-        input,
-    )
+fn int_err(input: impl Into<BString>) -> Message {
+    validation("Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G")
+        .with("input", gix_error::MetadataValue::Bytes(input.into()))
 }
 
 /// Parse `input` the way `git_parse_signed()` does, which hands the value to
@@ -85,21 +84,21 @@ fn parse_like_git(input: &str) -> Option<i64> {
 }
 
 impl TryFrom<&BStr> for Integer {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(s: &BStr) -> Result<Self, Self::Error> {
-        let s = std::str::from_utf8(s).map_err(|err| int_err(s).with_err(err))?;
+        let s = std::str::from_utf8(s).or_raise(|| int_err(s))?;
         if let Some(value) = parse_like_git(s) {
             return Ok(Self { value, suffix: None });
         }
 
         if s.len() <= 1 {
-            return Err(int_err(s));
+            return Err(int_err(s).raise());
         }
 
         let last_idx = s.len() - 1;
         if !s.is_char_boundary(last_idx) {
-            return Err(int_err(s));
+            return Err(int_err(s).raise());
         }
 
         let (number, suffix) = s.split_at(s.len() - 1);
@@ -109,13 +108,13 @@ impl TryFrom<&BStr> for Integer {
                 suffix: Some(suffix),
             })
         } else {
-            Err(int_err(s))
+            Err(int_err(s).raise())
         }
     }
 }
 
 impl TryFrom<&str> for Integer {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(value))
@@ -123,7 +122,7 @@ impl TryFrom<&str> for Integer {
 }
 
 impl TryFrom<Cow<'_, BStr>> for Integer {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(c: Cow<'_, BStr>) -> Result<Self, Self::Error> {
         Self::try_from(c.as_ref())
@@ -131,7 +130,7 @@ impl TryFrom<Cow<'_, BStr>> for Integer {
 }
 
 impl TryFrom<BString> for Integer {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: BString) -> Result<Self, Self::Error> {
         Self::try_from(BStr::new(&value))
@@ -191,12 +190,7 @@ impl FromStr for Suffix {
     type Err = ();
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "k" | "K" => Ok(Self::Kibi),
-            "m" | "M" => Ok(Self::Mebi),
-            "g" | "G" => Ok(Self::Gibi),
-            _ => Err(()),
-        }
+        Self::try_from(BStr::new(s))
     }
 }
 
@@ -204,6 +198,11 @@ impl TryFrom<&BStr> for Suffix {
     type Error = ();
 
     fn try_from(s: &BStr) -> Result<Self, Self::Error> {
-        Self::from_str(std::str::from_utf8(s).map_err(|_| ())?)
+        match s.as_bytes() {
+            b"k" | b"K" => Ok(Self::Kibi),
+            b"m" | b"M" => Ok(Self::Mebi),
+            b"g" | b"G" => Ok(Self::Gibi),
+            _ => Err(()),
+        }
     }
 }
diff --git a/gix-config-value/src/lib.rs b/gix-config-value/src/lib.rs
index 763661a7e55..4073a457652 100644
--- a/gix-config-value/src/lib.rs
+++ b/gix-config-value/src/lib.rs
@@ -25,33 +25,6 @@
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg))]
 #![deny(missing_docs, unsafe_code)]
 
-/// The error returned when any config value couldn't be instantiated due to malformed input.
-#[derive(Debug, thiserror::Error, Eq, PartialEq)]
-#[expect(missing_docs)]
-#[error("Could not decode '{input}': {message}")]
-pub struct Error {
-    pub message: &'static str,
-    pub input: bstr::BString,
-    #[source]
-    pub utf8_err: Option<std::str::Utf8Error>,
-}
-
-impl Error {
-    /// Create a new value error from `message`, with `input` being what's causing the error.
-    pub fn new(message: &'static str, input: impl Into<bstr::BString>) -> Self {
-        Error {
-            message,
-            input: input.into(),
-            utf8_err: None,
-        }
-    }
-
-    pub(crate) fn with_err(mut self, err: std::str::Utf8Error) -> Self {
-        self.utf8_err = Some(err);
-        self
-    }
-}
-
 mod boolean;
 /// Color value parsing and the supported color names and attributes.
 pub mod color;
diff --git a/gix-config-value/src/path.rs b/gix-config-value/src/path.rs
index f26fe5d872c..64299102617 100644
--- a/gix-config-value/src/path.rs
+++ b/gix-config-value/src/path.rs
@@ -1,6 +1,7 @@
 use std::{borrow::Cow, path::PathBuf};
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, not_found, validation};
 
 use crate::Path;
 
@@ -30,22 +31,6 @@ pub mod interpolate {
         }
     }
 
-    /// The error returned by [`Path::interpolate()`][crate::Path::interpolate()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("{} is missing", .what)]
-        Missing { what: &'static str },
-        #[error("Ill-formed UTF-8 in {}", .what)]
-        Utf8Conversion {
-            what: &'static str,
-            #[source]
-            err: gix_path::Utf8Error,
-        },
-        #[error("Ill-formed UTF-8 in username")]
-        UsernameConversion(#[from] std::str::Utf8Error),
-    }
-
     /// Obtain the home directory for the given user `name` or return `None` if the user wasn't found
     /// or any other error occurred.
     /// It can be used as `home_for_user` parameter in [`Path::interpolate()`][crate::Path::interpolate()].
@@ -159,6 +144,8 @@ impl Path {
     ///
     /// Any other, non-empty path value is returned unchanged and error is returned in case of an empty path value or if the required
     /// input wasn't provided.
+    /// UTF-8 conversion failures include the invalid path or username bytes as `input`
+    /// [metadata](gix_error::Exn::metadata()).
     pub fn interpolate(
         self,
         interpolate::Context {
@@ -166,23 +153,18 @@ impl Path {
             home_dir,
             home_for_user,
         }: interpolate::Context<'_>,
-    ) -> Result<PathBuf, interpolate::Error> {
+    ) -> ExnResult<PathBuf> {
         if self.is_empty() {
-            return Err(interpolate::Error::Missing { what: "path" });
+            return Err(not_found("path is missing").raise_erased());
         }
 
         const PREFIX: &[u8] = b"%(prefix)/";
         if self.starts_with(PREFIX) {
-            let git_install_dir = git_install_dir.ok_or(interpolate::Error::Missing {
-                what: "git install dir",
-            })?;
+            let git_install_dir = git_install_dir.ok_or_raise_erased(|| not_found("git install dir is missing"))?;
             let (_prefix, path_without_trailing_slash) = self.split_at(PREFIX.len());
             let path_without_trailing_slash =
-                gix_path::try_from_bstring(path_without_trailing_slash).map_err(|err| {
-                    interpolate::Error::Utf8Conversion {
-                        what: "path past %(prefix)",
-                        err,
-                    }
+                gix_path::try_from_bstring(path_without_trailing_slash).or_raise_erased(|| {
+                    validation("Ill-formed UTF-8 in path past %(prefix)").with("input", path_without_trailing_slash)
                 })?;
             Ok(git_install_dir.join(path_without_trailing_slash))
         } else if let Some(val) = self.strip_prefix(b"~") {
@@ -193,7 +175,7 @@ impl Path {
             let (mut home, what) = if username.is_empty() {
                 (
                     home_dir
-                        .ok_or(interpolate::Error::Missing { what: "home dir" })?
+                        .ok_or_raise_erased(|| not_found("home dir is missing"))?
                         .to_path_buf(),
                     "path past ~/",
                 )
@@ -201,9 +183,7 @@ impl Path {
                 (
                     Self::home_for_username(
                         username,
-                        home_for_user.ok_or(interpolate::Error::Missing {
-                            what: "home for user lookup",
-                        })?,
+                        home_for_user.ok_or_raise_erased(|| not_found("home for user lookup is missing"))?,
                     )?,
                     "path past ~user/",
                 )
@@ -211,7 +191,7 @@ impl Path {
             if let Some(path) = path {
                 home.push(
                     gix_path::try_from_byte_slice(path)
-                        .map_err(|err| interpolate::Error::Utf8Conversion { what, err })?,
+                        .or_raise_erased(|| validation(format!("Ill-formed UTF-8 in {what}")).with("input", path))?,
                 );
             }
             Ok(home)
@@ -220,11 +200,9 @@ impl Path {
         }
     }
 
-    fn home_for_username(
-        username: &[u8],
-        home_for_user: fn(&str) -> Option<PathBuf>,
-    ) -> Result<PathBuf, interpolate::Error> {
-        let username = std::str::from_utf8(username)?;
-        home_for_user(username).ok_or(interpolate::Error::Missing { what: "pwd user info" })
+    fn home_for_username(username: &[u8], home_for_user: fn(&str) -> Option<PathBuf>) -> ExnResult<PathBuf> {
+        let username = std::str::from_utf8(username)
+            .or_raise_erased(|| validation("Ill-formed UTF-8 in username").with("input", username))?;
+        home_for_user(username).ok_or_raise_erased(|| not_found("pwd user info is missing"))
     }
 }
diff --git a/gix-config-value/src/types.rs b/gix-config-value/src/types.rs
index 4c2d1c399d6..99884f45aae 100644
--- a/gix-config-value/src/types.rs
+++ b/gix-config-value/src/types.rs
@@ -7,6 +7,7 @@ use crate::{color, integer};
 /// Note that `git-config` allows color values to simply be a collection of
 /// [`color::Attribute`]s, and does not require a [`color::Name`] for either the
 /// foreground or background color.
+/// Conversion errors expose invalid `input` bytes as [metadata](gix_error::Exn::metadata()).
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
 pub struct Color {
     /// A provided foreground color
@@ -25,6 +26,7 @@ pub struct Color {
 /// suffix after fetching the value. [`integer::Suffix`] provides
 /// [`bitwise_offset()`][integer::Suffix::bitwise_offset] to help with the
 /// math, or [`to_decimal()`][Integer::to_decimal()] for obtaining a usable value in one step.
+/// Conversion errors expose invalid `input` bytes as [metadata](gix_error::Exn::metadata()).
 #[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct Integer {
     /// The value, without any suffix modification
@@ -34,6 +36,7 @@ pub struct Integer {
 }
 
 /// Any value that can be interpreted as a boolean.
+/// Conversion errors expose invalid `input` bytes as [metadata](gix_error::Exn::metadata()).
 #[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub struct Boolean(
     /// The interpreted boolean value.
diff --git a/gix-config-value/tests/value/boolean.rs b/gix-config-value/tests/value/boolean.rs
index f201dcbcedc..58799158b90 100644
--- a/gix-config-value/tests/value/boolean.rs
+++ b/gix-config-value/tests/value/boolean.rs
@@ -1,7 +1,8 @@
 use gix_config_value::Boolean;
+use gix_error::Result;
 
 #[test]
-fn from_utf8_str() -> crate::Result {
+fn from_utf8_str() -> Result {
     assert_eq!(
         Boolean::try_from("yes")?,
         Boolean(true),
@@ -11,7 +12,7 @@ fn from_utf8_str() -> crate::Result {
 }
 
 #[test]
-fn from_str_false() -> crate::Result {
+fn from_str_false() -> Result {
     assert!(!Boolean::try_from("no")?.0);
     assert!(!Boolean::try_from("off")?.0);
     assert!(!Boolean::try_from("false")?.0);
@@ -21,10 +22,10 @@ fn from_str_false() -> crate::Result {
 }
 
 #[test]
-fn from_str_true() -> crate::Result {
-    assert_eq!(Boolean::try_from("yes").map(Into::into), Ok(true));
-    assert_eq!(Boolean::try_from("on"), Ok(Boolean(true)));
-    assert_eq!(Boolean::try_from("true"), Ok(Boolean(true)));
+fn from_str_true() -> Result {
+    assert!(Boolean::try_from("yes")?.0);
+    assert!(Boolean::try_from("on")?.0);
+    assert!(Boolean::try_from("true")?.0);
     assert!(Boolean::try_from("1")?.0);
     assert!(Boolean::try_from("+10")?.0);
     assert!(Boolean::try_from("-1")?.0);
@@ -35,14 +36,16 @@ fn from_str_true() -> crate::Result {
 fn ignores_case() {
     // Random subset
     for word in &["no", "yes", "on", "off", "true", "false"] {
-        let first: bool = Boolean::try_from(*word).unwrap().into();
-        let second: bool = Boolean::try_from(word.to_uppercase().as_str()).unwrap().into();
+        let first: bool = Boolean::try_from(*word).expect("valid boolean").into();
+        let second: bool = Boolean::try_from(word.to_uppercase().as_str())
+            .expect("valid boolean")
+            .into();
         assert_eq!(first, second);
     }
 }
 
 #[test]
-fn numbers_are_parsed_as_integers() {
+fn numbers_are_parsed_as_integers() -> Result {
     // Use the same bases, suffixes, and full `i64` range as `Integer`.
     for (input, expected) in [
         ("0x10", true),
@@ -68,11 +71,12 @@ fn numbers_are_parsed_as_integers() {
         ("-8589934592g", true), // i64::MIN after applying the suffix
     ] {
         assert_eq!(
-            Boolean::try_from(input).map(Into::into),
-            Ok(expected),
+            Boolean::try_from(input)?.0,
+            expected,
             "{input:?}: zero integers are false and nonzero integers are true"
         );
     }
+    Ok(())
 }
 
 #[test]
diff --git a/gix-config-value/tests/value/color.rs b/gix-config-value/tests/value/color.rs
index 3fea7d4d5f0..112e4b261d7 100644
--- a/gix-config-value/tests/value/color.rs
+++ b/gix-config-value/tests/value/color.rs
@@ -1,7 +1,8 @@
 use gix_config_value::Color;
+use gix_error::Result;
 
 #[test]
-fn from_utf8_str() -> crate::Result {
+fn from_utf8_str() -> Result {
     assert_eq!(
         Color::try_from("red bold")?.to_string(),
         "red bold",
@@ -15,31 +16,35 @@ mod name {
 
     use gix_config_value::color::Name;
 
+    fn name(input: &str) -> Name {
+        Name::from_str(input).expect("valid color name")
+    }
+
     #[test]
     fn non_bright() {
-        assert_eq!(Name::from_str("normal"), Ok(Name::Normal));
-        assert_eq!(Name::from_str("-1"), Ok(Name::Normal));
-        assert_eq!(Name::from_str("default"), Ok(Name::Default));
-        assert_eq!(Name::from_str("black"), Ok(Name::Black));
-        assert_eq!(Name::from_str("red"), Ok(Name::Red));
-        assert_eq!(Name::from_str("green"), Ok(Name::Green));
-        assert_eq!(Name::from_str("yellow"), Ok(Name::Yellow));
-        assert_eq!(Name::from_str("blue"), Ok(Name::Blue));
-        assert_eq!(Name::from_str("magenta"), Ok(Name::Magenta));
-        assert_eq!(Name::from_str("cyan"), Ok(Name::Cyan));
-        assert_eq!(Name::from_str("white"), Ok(Name::White));
+        assert_eq!(name("normal"), Name::Normal);
+        assert_eq!(name("-1"), Name::Normal);
+        assert_eq!(name("default"), Name::Default);
+        assert_eq!(name("black"), Name::Black);
+        assert_eq!(name("red"), Name::Red);
+        assert_eq!(name("green"), Name::Green);
+        assert_eq!(name("yellow"), Name::Yellow);
+        assert_eq!(name("blue"), Name::Blue);
+        assert_eq!(name("magenta"), Name::Magenta);
+        assert_eq!(name("cyan"), Name::Cyan);
+        assert_eq!(name("white"), Name::White);
     }
 
     #[test]
     fn bright() {
-        assert_eq!(Name::from_str("brightblack"), Ok(Name::BrightBlack));
-        assert_eq!(Name::from_str("brightred"), Ok(Name::BrightRed));
-        assert_eq!(Name::from_str("brightgreen"), Ok(Name::BrightGreen));
-        assert_eq!(Name::from_str("brightyellow"), Ok(Name::BrightYellow));
-        assert_eq!(Name::from_str("brightblue"), Ok(Name::BrightBlue));
-        assert_eq!(Name::from_str("brightmagenta"), Ok(Name::BrightMagenta));
-        assert_eq!(Name::from_str("brightcyan"), Ok(Name::BrightCyan));
-        assert_eq!(Name::from_str("brightwhite"), Ok(Name::BrightWhite));
+        assert_eq!(name("brightblack"), Name::BrightBlack);
+        assert_eq!(name("brightred"), Name::BrightRed);
+        assert_eq!(name("brightgreen"), Name::BrightGreen);
+        assert_eq!(name("brightyellow"), Name::BrightYellow);
+        assert_eq!(name("brightblue"), Name::BrightBlue);
+        assert_eq!(name("brightmagenta"), Name::BrightMagenta);
+        assert_eq!(name("brightcyan"), Name::BrightCyan);
+        assert_eq!(name("brightwhite"), Name::BrightWhite);
     }
 
     #[test]
@@ -53,8 +58,8 @@ mod name {
             ("BRIGHTWHITE", Name::BrightWhite),
         ] {
             assert_eq!(
-                Name::from_str(input),
-                Ok(expected),
+                name(input),
+                expected,
                 "{input:?}: color names and the 'bright' prefix are case-insensitive, like in Git"
             );
         }
@@ -72,16 +77,16 @@ mod name {
 
     #[test]
     fn ansi() {
-        assert_eq!(Name::from_str("255"), Ok(Name::Ansi(255)));
-        assert_eq!(Name::from_str("0"), Ok(Name::Ansi(0)));
+        assert_eq!(name("255"), Name::Ansi(255));
+        assert_eq!(name("0"), Name::Ansi(0));
     }
 
     #[test]
     fn hex() {
-        assert_eq!(Name::from_str("#ff0010"), Ok(Name::Rgb(255, 0, 16)));
-        assert_eq!(Name::from_str("#ffffff"), Ok(Name::Rgb(255, 255, 255)));
-        assert_eq!(Name::from_str("#000000"), Ok(Name::Rgb(0, 0, 0)));
-        assert_eq!(Name::from_str("#FF0010"), Ok(Name::Rgb(255, 0, 16)));
+        assert_eq!(name("#ff0010"), Name::Rgb(255, 0, 16));
+        assert_eq!(name("#ffffff"), Name::Rgb(255, 255, 255));
+        assert_eq!(name("#000000"), Name::Rgb(0, 0, 0));
+        assert_eq!(name("#FF0010"), Name::Rgb(255, 0, 16));
     }
 
     #[test]
@@ -95,15 +100,15 @@ mod name {
             ("#fff", Name::Rgb(0xff, 0xff, 0xff), "#ffffff"),
             ("#aBc", Name::Rgb(0xaa, 0xbb, 0xcc), "#aabbcc"),
         ] {
-            let actual = Name::from_str(input);
-            assert_eq!(actual, Ok(expected), "{input:?}");
+            let actual = name(input);
+            assert_eq!(actual, expected, "{input:?}");
             assert_eq!(
                 actual,
-                Name::from_str(long_form),
+                name(long_form),
                 "{input:?}: the shorthand and the long form it stands for are the same color"
             );
             assert_eq!(
-                actual.expect("the shorthand parses, as asserted above").to_string(),
+                actual.to_string(),
                 long_form,
                 "{input:?}: a shorthand renders back as the long form, since `Name::Rgb` keeps no record of which spelling it came from"
             );
@@ -144,38 +149,42 @@ mod attribute {
 
     use gix_config_value::color::Attribute;
 
+    fn attribute(input: &str) -> Attribute {
+        Attribute::from_str(input).expect("valid color attribute")
+    }
+
     #[test]
     fn non_inverted() {
-        assert_eq!(Attribute::from_str("reset"), Ok(Attribute::RESET));
-        assert_eq!(Attribute::from_str("bold"), Ok(Attribute::BOLD));
-        assert_eq!(Attribute::from_str("dim"), Ok(Attribute::DIM));
-        assert_eq!(Attribute::from_str("ul"), Ok(Attribute::UL));
-        assert_eq!(Attribute::from_str("blink"), Ok(Attribute::BLINK));
-        assert_eq!(Attribute::from_str("reverse"), Ok(Attribute::REVERSE));
-        assert_eq!(Attribute::from_str("italic"), Ok(Attribute::ITALIC));
-        assert_eq!(Attribute::from_str("strike"), Ok(Attribute::STRIKE));
+        assert_eq!(attribute("reset"), Attribute::RESET);
+        assert_eq!(attribute("bold"), Attribute::BOLD);
+        assert_eq!(attribute("dim"), Attribute::DIM);
+        assert_eq!(attribute("ul"), Attribute::UL);
+        assert_eq!(attribute("blink"), Attribute::BLINK);
+        assert_eq!(attribute("reverse"), Attribute::REVERSE);
+        assert_eq!(attribute("italic"), Attribute::ITALIC);
+        assert_eq!(attribute("strike"), Attribute::STRIKE);
     }
 
     #[test]
     fn inverted_no_dash() {
-        assert_eq!(Attribute::from_str("nobold"), Ok(Attribute::NO_BOLD));
-        assert_eq!(Attribute::from_str("nodim"), Ok(Attribute::NO_DIM));
-        assert_eq!(Attribute::from_str("noul"), Ok(Attribute::NO_UL));
-        assert_eq!(Attribute::from_str("noblink"), Ok(Attribute::NO_BLINK));
-        assert_eq!(Attribute::from_str("noreverse"), Ok(Attribute::NO_REVERSE));
-        assert_eq!(Attribute::from_str("noitalic"), Ok(Attribute::NO_ITALIC));
-        assert_eq!(Attribute::from_str("nostrike"), Ok(Attribute::NO_STRIKE));
+        assert_eq!(attribute("nobold"), Attribute::NO_BOLD);
+        assert_eq!(attribute("nodim"), Attribute::NO_DIM);
+        assert_eq!(attribute("noul"), Attribute::NO_UL);
+        assert_eq!(attribute("noblink"), Attribute::NO_BLINK);
+        assert_eq!(attribute("noreverse"), Attribute::NO_REVERSE);
+        assert_eq!(attribute("noitalic"), Attribute::NO_ITALIC);
+        assert_eq!(attribute("nostrike"), Attribute::NO_STRIKE);
     }
 
     #[test]
     fn inverted_dashed() {
-        assert_eq!(Attribute::from_str("no-bold"), Ok(Attribute::NO_BOLD));
-        assert_eq!(Attribute::from_str("no-dim"), Ok(Attribute::NO_DIM));
-        assert_eq!(Attribute::from_str("no-ul"), Ok(Attribute::NO_UL));
-        assert_eq!(Attribute::from_str("no-blink"), Ok(Attribute::NO_BLINK));
-        assert_eq!(Attribute::from_str("no-reverse"), Ok(Attribute::NO_REVERSE));
-        assert_eq!(Attribute::from_str("no-italic"), Ok(Attribute::NO_ITALIC));
-        assert_eq!(Attribute::from_str("no-strike"), Ok(Attribute::NO_STRIKE));
+        assert_eq!(attribute("no-bold"), Attribute::NO_BOLD);
+        assert_eq!(attribute("no-dim"), Attribute::NO_DIM);
+        assert_eq!(attribute("no-ul"), Attribute::NO_UL);
+        assert_eq!(attribute("no-blink"), Attribute::NO_BLINK);
+        assert_eq!(attribute("no-reverse"), Attribute::NO_REVERSE);
+        assert_eq!(attribute("no-italic"), Attribute::NO_ITALIC);
+        assert_eq!(attribute("no-strike"), Attribute::NO_STRIKE);
     }
 
     #[test]
@@ -193,6 +202,7 @@ mod attribute {
 mod from_git {
     use bstr::BStr;
     use gix_config_value::Color;
+    use gix_error::Result;
 
     #[test]
     fn reset() {
@@ -280,7 +290,7 @@ mod from_git {
         try_color(name).expect("input color is expected to be valid")
     }
 
-    fn try_color<'a>(name: impl Into<&'a BStr>) -> crate::Result<String> {
+    fn try_color<'a>(name: impl Into<&'a BStr>) -> Result<String> {
         Ok(Color::try_from(name.into())?.to_string())
     }
 }
diff --git a/gix-config-value/tests/value/integer.rs b/gix-config-value/tests/value/integer.rs
index 4423ff70e4c..7ed18d3c239 100644
--- a/gix-config-value/tests/value/integer.rs
+++ b/gix-config-value/tests/value/integer.rs
@@ -1,7 +1,8 @@
 use gix_config_value::{Integer, integer::Suffix};
+use gix_error::Result;
 
 #[test]
-fn from_utf8_str() -> crate::Result {
+fn from_utf8_str() -> Result {
     assert_eq!(
         Integer::try_from("1k")?,
         Integer {
diff --git a/gix-config-value/tests/value/main.rs b/gix-config-value/tests/value/main.rs
index 937346a2774..3d23b8e5374 100644
--- a/gix-config-value/tests/value/main.rs
+++ b/gix-config-value/tests/value/main.rs
@@ -1,5 +1,3 @@
-type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
-
 mod boolean;
 mod color;
 mod integer;
diff --git a/gix-config-value/tests/value/path.rs b/gix-config-value/tests/value/path.rs
index be09051ed51..69f267d3f04 100644
--- a/gix-config-value/tests/value/path.rs
+++ b/gix-config-value/tests/value/path.rs
@@ -1,10 +1,14 @@
 mod interpolate {
+    use gix_error::Result;
     use std::path::{Path, PathBuf};
 
+    use gix_error::ExnResult;
+
+    use bstr::BString;
     use gix_config_value::path;
 
     #[test]
-    fn backslash_is_not_special_and_they_are_not_escaping_anything() -> crate::Result {
+    fn backslash_is_not_special_and_they_are_not_escaping_anything() -> Result {
         for path in [r"C:\foo\bar", "/foo/bar"] {
             let actual = gix_config_value::Path::from(path).interpolate(Default::default())?;
             assert_eq!(actual, Path::new(path));
@@ -14,10 +18,9 @@ mod interpolate {
 
     #[test]
     fn empty_path_is_error() {
-        assert!(matches!(
-            interpolate_without_context(""),
-            Err(path::interpolate::Error::Missing { what: "path" })
-        ));
+        let err = interpolate_without_context("").expect_err("empty paths are invalid");
+        insta::assert_debug_snapshot!(err, "empty path is error", @"path is missing");
+        assert!(err.is_not_found());
     }
 
     #[test]
@@ -32,7 +35,7 @@ mod interpolate {
                             git_install_dir: Path::new(git_install_dir).into(),
                             ..Default::default()
                         })
-                        .unwrap(),
+                        .expect("valid interpolation"),
                     expected,
                     "prefix interpolation keeps separators as they are"
                 );
@@ -50,33 +53,37 @@ mod interpolate {
                     git_install_dir: Path::new(git_install_dir).into(),
                     ..Default::default()
                 })
-                .unwrap(),
+                .expect("valid interpolation"),
             Path::new(path)
         );
     }
 
     #[test]
-    fn tilde_alone_substitutes_current_user() -> crate::Result {
-        let home = std::env::current_dir()?;
+    fn tilde_alone_substitutes_current_user() -> Result {
+        let home = std::env::current_dir().expect("current directory is available");
         assert_eq!(
-            gix_config_value::Path::from("~")
-                .interpolate(path::interpolate::Context {
-                    home_dir: Some(&home),
-                    ..Default::default()
-                })
-                .unwrap(),
+            gix_config_value::Path::from("~").interpolate(path::interpolate::Context {
+                home_dir: Some(&home),
+                ..Default::default()
+            })?,
             home
         );
-        assert!(matches!(
-            interpolate_without_context("~"),
-            Err(path::interpolate::Error::Missing { what: "home dir" })
-        ));
+        let err = interpolate_without_context("~").expect_err("tilde expansion needs the current user's home");
+        insta::assert_debug_snapshot!(err.classify()
+                .find(|classification| classification.class() == gix_error::Class::NotFound)
+                .expect("missing home directories are classified as not found")
+                .error(), "tilde expansion reports the missing home directory", @r#"
+        Message {
+            message: "home dir is missing",
+            class: NotFound,
+        }
+        "#);
         Ok(())
     }
 
     #[test]
-    fn tilde_slash_substitutes_current_user() -> crate::Result {
-        let home = std::env::current_dir()?;
+    fn tilde_slash_substitutes_current_user() -> Result {
+        let home = std::env::current_dir().expect("current directory is available");
         for suffix in ["", "user/bar", r"user\bar", "/user/bar"] {
             let actual = gix_config_value::Path::from(format!("~/{suffix}").as_str()).interpolate(
                 path::interpolate::Context {
@@ -95,8 +102,9 @@ mod interpolate {
     }
 
     #[test]
-    fn tilde_with_given_user() -> crate::Result {
-        let home = std::env::current_dir()?;
+    fn tilde_with_given_user() -> Result {
+        let mut error_snapshots = Vec::new();
+        let home = std::env::current_dir().expect("current directory is available");
 
         for path_suffix in &["foo/bar", r"foo\bar", ""] {
             let path = format!("~user/{path_suffix}");
@@ -114,20 +122,38 @@ mod interpolate {
             home.join("user"),
             "~user without trailing slash is expanded like git does"
         );
-        assert!(matches!(
-            interpolate_without_context("~nonexistent"),
-            Err(path::interpolate::Error::Missing { what: "pwd user info" })
-        ));
-        assert!(matches!(
-            interpolate_without_context("~nonexistent/foo"),
-            Err(path::interpolate::Error::Missing { what: "pwd user info" })
-        ));
+        for path in ["~nonexistent", "~nonexistent/foo"] {
+            let err = interpolate_without_context(path).expect_err("the named user does not exist");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.is_not_found(), "named-user expansion classifies missing users");
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "tilde with given user", @"
+        [
+            pwd user info is missing,
+            pwd user info is missing,
+        ]
+        ");
         Ok(())
     }
 
-    fn interpolate_without_context(
-        path: impl AsRef<str>,
-    ) -> Result<PathBuf, gix_config_value::path::interpolate::Error> {
+    #[test]
+    fn malformed_usernames_are_validation_errors_with_the_utf8_cause() {
+        let err = gix_config_value::Path::from(BString::from(vec![b'~', 0xff, b'/', b'x']))
+            .interpolate(path::interpolate::Context {
+                home_for_user: Some(home_for_user),
+                ..Default::default()
+            })
+            .expect_err("the username is not UTF-8");
+        insta::assert_debug_snapshot!(err, "malformed usernames are validation errors with the utf8 cause", @r#"
+        Ill-formed UTF-8 in username, "input"="\xff"
+        |
+        └─ invalid utf-8 sequence of 1 bytes from index 0
+        "#);
+        assert!(err.is_validation());
+        assert!(err.downcast_any_ref::<std::str::Utf8Error>().is_some());
+    }
+
+    fn interpolate_without_context(path: impl AsRef<str>) -> ExnResult<PathBuf> {
         gix_config_value::Path::from(path.as_ref()).interpolate(path::interpolate::Context {
             home_for_user: Some(home_for_user),
             ..Default::default()
@@ -138,7 +164,10 @@ mod interpolate {
         if name == "nonexistent" {
             return None;
         }
-        std::env::current_dir().unwrap().join(name).into()
+        std::env::current_dir()
+            .expect("current directory is available")
+            .join(name)
+            .into()
     }
 }
 
diff --git a/gix-config/Cargo.toml b/gix-config/Cargo.toml
index 3a99d2aba68..39792670ffd 100644
--- a/gix-config/Cargo.toml
+++ b/gix-config/Cargo.toml
@@ -24,13 +24,13 @@ serde = ["dep:serde", "bstr/serde", "gix-sec/serde", "gix-ref/serde", "gix-glob/
 [dependencies]
 gix-features = { version = "^0.49.1", path = "../gix-features" }
 gix-config-value = { version = "^0.19.1", path = "../gix-config-value" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-sec = { version = "^0.14.2", path = "../gix-sec" }
 gix-ref = { version = "^0.67.0", path = "../gix-ref" }
 gix-glob = { version = "^0.27.1", path = "../gix-glob" }
 gix-utils = { version = "^0.3.6", path = "../gix-utils", features = ["bstr"] }
 
-thiserror = "2.0.18"
 unicode-bom = { version = "2.0.3" }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
diff --git a/gix-config/fuzz/fuzz_targets/fuzz_file.rs b/gix-config/fuzz/fuzz_targets/fuzz_file.rs
index 8ab93ddbfe5..8fb23b31550 100644
--- a/gix-config/fuzz/fuzz_targets/fuzz_file.rs
+++ b/gix-config/fuzz/fuzz_targets/fuzz_file.rs
@@ -34,7 +34,9 @@ fn fuzz_mutable_section(
 
     // Mutate section.
     let section_id = {
-        let mut section = file.section_mut(section_name, subsection_name)?;
+        let mut section = file
+            .section_mut(section_name, subsection_name)
+            .map_err(|err| err.into_error())?;
         let key = section.value_names().next();
 
         if let Some(key) = key {
@@ -94,7 +96,8 @@ fn fuzz_mutable_section(
 fn fuzz(input: &[u8]) -> Result<()> {
     let meta = Metadata::default();
     let options = Options::default();
-    let file = gix_config::File::from_bytes_no_includes(input, meta.clone(), options)?;
+    let file =
+        gix_config::File::from_bytes_no_includes(input, meta.clone(), options).map_err(|err| err.into_error())?;
 
     // Sections and frontmatter.
     _ = black_box(file.sections_and_ids().count());
@@ -120,11 +123,10 @@ fn fuzz(input: &[u8]) -> Result<()> {
     }
 
     _ = black_box(mutated_file.append(file));
-    _ = black_box(gix_config::File::from_bytes_no_includes(
-        &mutated_file.to_bstring(),
-        meta,
-        options,
-    )?);
+    _ = black_box(
+        gix_config::File::from_bytes_no_includes(&mutated_file.to_bstring(), meta, options)
+            .map_err(|err| err.into_error())?,
+    );
 
     Ok(())
 }
diff --git a/gix-config/src/file/access/comfort.rs b/gix-config/src/file/access/comfort.rs
index 9ba42d581f0..6d0ea859541 100644
--- a/gix-config/src/file/access/comfort.rs
+++ b/gix-config/src/file/access/comfort.rs
@@ -1,6 +1,8 @@
 use bstr::{BStr, BString};
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, validation};
 
-use crate::{AsBStrOpt, AsKey, File, file::Metadata, value};
+use crate::{AsBStrOpt, AsKey, File, file::Metadata};
 
 /// Comfortable API for accessing values
 impl File {
@@ -85,7 +87,7 @@ impl File {
     }
 
     /// Like [`boolean_by()`](File::boolean_by()), but suitable for statically known `key`s like `remote.origin.url`.
-    pub fn boolean(&self, key: impl AsKey) -> Result<Option<bool>, value::Error> {
+    pub fn boolean(&self, key: impl AsKey) -> ExnMessageResult<Option<bool>> {
         self.boolean_filter(key, |_| true)
     }
 
@@ -95,7 +97,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<Option<bool>, value::Error> {
+    ) -> ExnMessageResult<Option<bool>> {
         self.boolean_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -104,7 +106,7 @@ impl File {
         &self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<bool>, value::Error> {
+    ) -> ExnMessageResult<Option<bool>> {
         let Some(key) = key.try_as_key() else {
             return Ok(None);
         };
@@ -118,7 +120,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<bool>, value::Error> {
+    ) -> ExnMessageResult<Option<bool>> {
         let section_name = section_name.as_ref();
         let section_ids = self
             .section_ids_by_name_and_subname(section_name, subsection_name.as_bstr_opt())
@@ -142,7 +144,7 @@ impl File {
     }
 
     /// Like [`integer_by()`](File::integer_by()), but suitable for statically known `key`s like `remote.origin.url`.
-    pub fn integer(&self, key: impl AsKey) -> Result<Option<i64>, value::Error> {
+    pub fn integer(&self, key: impl AsKey) -> ExnMessageResult<Option<i64>> {
         self.integer_filter(key, |_| true)
     }
 
@@ -152,7 +154,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<Option<i64>, value::Error> {
+    ) -> ExnMessageResult<Option<i64>> {
         self.integer_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -161,7 +163,7 @@ impl File {
         &self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<i64>, value::Error> {
+    ) -> ExnMessageResult<Option<i64>> {
         let Some(key) = key.try_as_key() else {
             return Ok(None);
         };
@@ -169,13 +171,14 @@ impl File {
     }
 
     /// Like [`integer_by()`](File::integer_by()), but the section containing the returned value must pass `filter` as well.
+    /// Invalid or overflowing values include their bytes as `input` [metadata](gix_error::Exn::metadata()).
     pub fn integer_filter_by(
         &self,
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<i64>, value::Error> {
+    ) -> ExnMessageResult<Option<i64>> {
         let Some(int) = self
             .raw_value_filter_by(section_name, subsection_name, value_name, filter)
             .ok()
@@ -183,7 +186,10 @@ impl File {
             return Ok(None);
         };
         crate::Integer::try_from(BStr::new(&int))
-            .and_then(|b| b.to_decimal().ok_or_else(|| value::Error::new("Integer overflow", int)))
+            .and_then(|b| {
+                b.to_decimal()
+                    .ok_or_else(|| validation("Integer overflow").with("input", BStr::new(&int)).raise())
+            })
             .map(Some)
     }
 
@@ -222,7 +228,7 @@ impl File {
     }
 
     /// Like [`integers()`](File::integers()), but suitable for statically known `key`s like `remote.origin.url`.
-    pub fn integers(&self, key: impl AsKey) -> Result<Option<Vec<i64>>, value::Error> {
+    pub fn integers(&self, key: impl AsKey) -> ExnMessageResult<Option<Vec<i64>>> {
         self.integers_filter(key, |_| true)
     }
 
@@ -233,7 +239,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<Option<Vec<i64>>, value::Error> {
+    ) -> ExnMessageResult<Option<Vec<i64>>> {
         self.integers_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -242,7 +248,7 @@ impl File {
         &self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<Vec<i64>>, value::Error> {
+    ) -> ExnMessageResult<Option<Vec<i64>>> {
         let Some(key) = key.try_as_key() else {
             return Ok(None);
         };
@@ -251,13 +257,14 @@ impl File {
 
     /// Similar to [`integers_by(…)`](File::integers_by()) but all integers are in sections that passed `filter`
     /// and that are not overflowing.
+    /// Invalid or overflowing values include their bytes as `input` [metadata](gix_error::Exn::metadata()).
     pub fn integers_filter_by(
         &self,
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<Vec<i64>>, value::Error> {
+    ) -> ExnMessageResult<Option<Vec<i64>>> {
         let Some(values) = self
             .raw_values_filter_by(section_name, subsection_name, value_name, filter)
             .ok()
@@ -267,8 +274,10 @@ impl File {
         values
             .into_iter()
             .map(|v| {
-                crate::Integer::try_from(BStr::new(&v))
-                    .and_then(|int| int.to_decimal().ok_or_else(|| value::Error::new("Integer overflow", v)))
+                crate::Integer::try_from(BStr::new(&v)).and_then(|int| {
+                    int.to_decimal()
+                        .ok_or_else(|| validation("Integer overflow").with("input", BStr::new(&v)).raise())
+                })
             })
             .collect::<Result<Vec<_>, _>>()
             .map(Some)
diff --git a/gix-config/src/file/access/mutate.rs b/gix-config/src/file/access/mutate.rs
index 95c8fb20a8e..5f2c6786bfe 100644
--- a/gix-config/src/file/access/mutate.rs
+++ b/gix-config/src/file/access/mutate.rs
@@ -1,9 +1,11 @@
 use bstr::BStr;
+use gix_error::ExnMessageResult;
+use gix_error::ExnResult;
 use gix_features::threading::OwnShared;
 
 use crate::{
     AsBStrOpt, File,
-    file::{self, IntoBStringOpt, Metadata, SectionId, SectionMut, rename_section, write::ends_with_newline},
+    file::{self, IntoBStringOpt, Metadata, SectionId, SectionMut, write::ends_with_newline},
     lookup,
     parse::{Event, FrontMatterEvents, Span, section},
 };
@@ -47,19 +49,11 @@ impl<T: crate::AsBStr + ?Sized> IntoBStringOpt for &T {
 /// Mutating low-level access methods.
 impl File {
     /// Returns the last mutable section with a given `name` and optional `subsection_name`, _if it exists_.
-    pub fn section_mut(
-        &mut self,
-        name: impl AsRef<str>,
-        subsection_name: impl AsBStrOpt,
-    ) -> Result<SectionMut<'_>, lookup::existing::Error> {
+    pub fn section_mut(&mut self, name: impl AsRef<str>, subsection_name: impl AsBStrOpt) -> ExnResult<SectionMut<'_>> {
         self.section_mut_inner(name.as_ref(), subsection_name.as_bstr_opt())
     }
 
-    fn section_mut_inner<'a>(
-        &'a mut self,
-        name: &str,
-        subsection_name: Option<&BStr>,
-    ) -> Result<SectionMut<'a>, lookup::existing::Error> {
+    fn section_mut_inner<'a>(&'a mut self, name: &str, subsection_name: Option<&BStr>) -> ExnResult<SectionMut<'a>> {
         let id = self
             .section_ids_by_name_and_subname(name, subsection_name)?
             .next_back()
@@ -71,8 +65,8 @@ impl File {
     }
 
     /// Returns the last found mutable section with a given `key`, identifying the name and subsection name like `core` or `remote.origin`.
-    pub fn section_mut_by_key(&mut self, key: impl crate::AsBStr) -> Result<SectionMut<'_>, lookup::existing::Error> {
-        let key = section::unvalidated::KeyRef::parse(&key).ok_or(lookup::existing::Error::KeyMissing)?;
+    pub fn section_mut_by_key(&mut self, key: impl crate::AsBStr) -> ExnResult<SectionMut<'_>> {
+        let key = section::unvalidated::KeyRef::parse(&key).ok_or_else(lookup::existing::key_missing)?;
         self.section_mut_inner(key.section_name, key.subsection_name)
     }
 
@@ -89,7 +83,7 @@ impl File {
         &mut self,
         name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
-    ) -> Result<SectionMut<'_>, section::header::Error> {
+    ) -> ExnMessageResult<SectionMut<'_>> {
         self.section_mut_or_create_new_inner(name.as_ref(), subsection_name.as_bstr_opt())
     }
 
@@ -97,7 +91,7 @@ impl File {
         &'a mut self,
         name: &str,
         subsection_name: Option<&BStr>,
-    ) -> Result<SectionMut<'a>, section::header::Error> {
+    ) -> ExnMessageResult<SectionMut<'a>> {
         self.section_mut_or_create_new_filter_inner(name, subsection_name, |_| true)
     }
 
@@ -108,7 +102,7 @@ impl File {
         name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<SectionMut<'_>, section::header::Error> {
+    ) -> ExnMessageResult<SectionMut<'_>> {
         self.section_mut_or_create_new_filter_inner(name.as_ref(), subsection_name.as_bstr_opt(), filter)
     }
 
@@ -117,7 +111,7 @@ impl File {
         name: &str,
         subsection_name: Option<&BStr>,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<SectionMut<'a>, section::header::Error> {
+    ) -> ExnMessageResult<SectionMut<'a>> {
         match self
             .section_ids_by_name_and_subname(name, subsection_name)
             .ok()
@@ -144,7 +138,7 @@ impl File {
         name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<file::SectionMut<'_>>, lookup::existing::Error> {
+    ) -> ExnResult<Option<file::SectionMut<'_>>> {
         self.section_mut_filter_inner(name.as_ref(), subsection_name.as_bstr_opt(), filter)
     }
 
@@ -153,7 +147,7 @@ impl File {
         name: &str,
         subsection_name: Option<&BStr>,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<file::SectionMut<'a>>, lookup::existing::Error> {
+    ) -> ExnResult<Option<file::SectionMut<'a>>> {
         let id = self
             .section_ids_by_name_and_subname(name, subsection_name)?
             .rev()
@@ -171,8 +165,8 @@ impl File {
         &mut self,
         key: impl crate::AsBStr,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<file::SectionMut<'_>>, lookup::existing::Error> {
-        let key = section::unvalidated::KeyRef::parse(&key).ok_or(lookup::existing::Error::KeyMissing)?;
+    ) -> ExnResult<Option<file::SectionMut<'_>>> {
+        let key = section::unvalidated::KeyRef::parse(&key).ok_or_else(lookup::existing::key_missing)?;
         self.section_mut_filter_inner(key.section_name, key.subsection_name, filter)
     }
 
@@ -191,7 +185,7 @@ impl File {
     /// let section = git_config.new_section("hello", "world")?;
     /// let nl = section.newline().to_owned();
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}"));
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
     /// ```
     ///
     /// Creating a new empty section and adding values to it:
@@ -208,21 +202,17 @@ impl File {
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}\ta = b{nl}"));
     /// let _section = git_config.new_section("core", None);
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}\ta = b{nl}[core]{nl}"));
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
     /// ```
     pub fn new_section(
         &mut self,
         name: impl AsRef<str>,
         subsection: impl IntoBStringOpt,
-    ) -> Result<SectionMut<'_>, section::header::Error> {
+    ) -> ExnMessageResult<SectionMut<'_>> {
         self.new_section_inner(name.as_ref(), subsection.into_bstring_opt())
     }
 
-    fn new_section_inner(
-        &mut self,
-        name: &str,
-        subsection: Option<bstr::BString>,
-    ) -> Result<SectionMut<'_>, section::header::Error> {
+    fn new_section_inner(&mut self, name: &str, subsection: Option<bstr::BString>) -> ExnMessageResult<SectionMut<'_>> {
         let section = file::SectionData::new(name, subsection, OwnShared::clone(&self.meta), &mut self.backing)?;
         let id = self.push_section_internal(section);
         let nl = self.detect_newline_style_smallvec();
@@ -250,7 +240,7 @@ impl File {
     /// let section = git_config.remove_section("hello", "world");
     /// assert!(section.is_some());
     /// assert_eq!(git_config.to_string(), "");
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
     /// ```
     ///
     /// Precedence example for removing sections with the same name:
@@ -268,7 +258,7 @@ impl File {
     /// let section = git_config.remove_section("hello", "world");
     /// assert!(section.is_some());
     /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n    some-value = 4\n");
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
     /// ```
     pub fn remove_section(&mut self, name: impl AsRef<str>, subsection_name: impl AsBStrOpt) -> Option<file::Section> {
         let id = self
@@ -332,7 +322,7 @@ impl File {
 
     /// Adds the provided `section` to the config, returning a mutable reference to it for immediate editing.
     /// Note that its meta-data will remain as is.
-    pub fn push_section(&mut self, section: file::Section) -> Result<SectionMut<'_>, crate::parse::span::Error> {
+    pub fn push_section(&mut self, section: file::Section) -> ExnMessageResult<SectionMut<'_>> {
         let section = section.into_data(&mut self.backing)?;
         let id = self.push_section_internal(section);
         let nl = self.detect_newline_style_smallvec();
@@ -349,7 +339,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         new_name: impl AsRef<str>,
         new_subsection_name: impl IntoBStringOpt,
-    ) -> Result<(), rename_section::Error> {
+    ) -> ExnResult {
         self.rename_section_filter(name, subsection_name, new_name, new_subsection_name, |_| true)
     }
 
@@ -358,8 +348,7 @@ impl File {
     ///
     /// Existing sections with the target name are preserved.
     ///
-    /// Note that the otherwise unused [`lookup::existing::Error::KeyMissing`] variant is used to indicate
-    /// that the `filter` rejected all candidates, leading to no section being renamed after all.
+    /// A not-found error indicates that the `filter` rejected all candidates, leading to no section being renamed.
     pub fn rename_section_filter(
         &mut self,
         name: impl AsRef<str>,
@@ -367,15 +356,17 @@ impl File {
         new_name: impl AsRef<str>,
         new_subsection_name: impl IntoBStringOpt,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<(), rename_section::Error> {
+    ) -> ExnResult {
         let ids: Vec<_> = self
             .section_ids_by_name_and_subname(name.as_ref(), subsection_name.as_bstr_opt())?
             .filter(|id| filter(&self.sections.get(id).expect("each id has a section").meta))
             .collect();
         if ids.is_empty() {
-            return Err(rename_section::Error::Lookup(lookup::existing::Error::KeyMissing));
+            return Err(lookup::existing::key_missing());
         }
-        let header = section::HeaderData::new_in(new_name, new_subsection_name.into_bstring_opt(), &mut self.backing)?;
+        use gix_error::ResultExt;
+        let header = section::HeaderData::new_in(new_name, new_subsection_name.into_bstring_opt(), &mut self.backing)
+            .or_erased()?;
         for id in ids {
             file::util::set_section_header(
                 self.sections
@@ -391,7 +382,7 @@ impl File {
     }
 
     /// Append another File to the end of ourselves, without losing any information.
-    pub fn append(&mut self, other: Self) -> Result<&mut Self, crate::parse::span::Error> {
+    pub fn append(&mut self, other: Self) -> ExnMessageResult<&mut Self> {
         self.append_or_insert(other, None)
     }
 
@@ -400,7 +391,7 @@ impl File {
         &mut self,
         mut other: Self,
         mut insert_after: Option<SectionId>,
-    ) -> Result<&mut Self, crate::parse::span::Error> {
+    ) -> ExnMessageResult<&mut Self> {
         let nl = self.detect_newline_style_smallvec();
         let our_last_section_before_append =
             insert_after.or_else(|| (self.next_section_id != 0).then(|| SectionId(self.next_section_id - 1)));
@@ -464,7 +455,7 @@ impl File {
         Ok(self)
     }
 
-    fn rebase_events(&mut self, offset: usize) -> Result<(), crate::parse::span::Error> {
+    fn rebase_events(&mut self, offset: usize) -> ExnMessageResult {
         for event in &mut self.frontmatter_events {
             event.rebase(offset)?;
         }
diff --git a/gix-config/src/file/access/raw.rs b/gix-config/src/file/access/raw.rs
index 2155da7f69a..a6dc076bf48 100644
--- a/gix-config/src/file/access/raw.rs
+++ b/gix-config/src/file/access/raw.rs
@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use bstr::{BStr, BString};
+use gix_error::{ExnResult, ResultExt};
 use smallvec::ToSmallVec;
 
 use crate::{
@@ -18,7 +19,7 @@ impl File {
     ///
     /// Consider [`Self::raw_values()`] if you want to get all values of
     /// a multivar instead.
-    pub fn raw_value(&self, key: impl AsKey) -> Result<BString, lookup::existing::Error> {
+    pub fn raw_value(&self, key: impl AsKey) -> ExnResult<BString> {
         let key = key.as_key();
         self.raw_value_filter_by(key.section_name, key.subsection_name, key.value_name, |_| true)
     }
@@ -33,7 +34,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<BString, lookup::existing::Error> {
+    ) -> ExnResult<BString> {
         self.raw_value_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -41,10 +42,7 @@ impl File {
     ///
     /// Resolution is identical to [`raw_value()`][Self::raw_value()]: the last explicit value wins, even across
     /// multiple matching sections.
-    pub fn raw_value_with_section(
-        &self,
-        key: impl AsKey,
-    ) -> Result<(BString, file::SectionRef<'_>), lookup::existing::Error> {
+    pub fn raw_value_with_section(&self, key: impl AsKey) -> ExnResult<(BString, file::SectionRef<'_>)> {
         let key = key.as_key();
         self.raw_value_with_section_by(key.section_name, key.subsection_name, key.value_name)
     }
@@ -58,7 +56,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<(BString, file::SectionRef<'_>), lookup::existing::Error> {
+    ) -> ExnResult<(BString, file::SectionRef<'_>)> {
         self.raw_value_with_section_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -70,7 +68,7 @@ impl File {
         &self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<(BString, file::SectionRef<'_>), lookup::existing::Error> {
+    ) -> ExnResult<(BString, file::SectionRef<'_>)> {
         let key = key.as_key();
         self.raw_value_with_section_filter_by(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -83,7 +81,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<(BString, file::SectionRef<'_>), lookup::existing::Error> {
+    ) -> ExnResult<(BString, file::SectionRef<'_>)> {
         self.raw_value_with_section_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -96,11 +94,7 @@ impl File {
     ///
     /// Consider [`Self::raw_values()`] if you want to get all values of
     /// a multivar instead.
-    pub fn raw_value_filter(
-        &self,
-        key: impl AsKey,
-        filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<BString, lookup::existing::Error> {
+    pub fn raw_value_filter(&self, key: impl AsKey, filter: impl FnMut(&Metadata) -> bool) -> ExnResult<BString> {
         let key = key.as_key();
         self.raw_value_filter_by(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -116,7 +110,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<BString, lookup::existing::Error> {
+    ) -> ExnResult<BString> {
         self.raw_value_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -131,7 +125,7 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<BString, lookup::existing::Error> {
+    ) -> ExnResult<BString> {
         self.raw_value_with_section_filter_inner(section_name, subsection_name, value_name, filter)
             .map(|(value, _section)| value)
     }
@@ -142,7 +136,7 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<(BString, file::SectionRef<'_>), lookup::existing::Error> {
+    ) -> ExnResult<(BString, file::SectionRef<'_>)> {
         let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         for section_id in section_ids.rev() {
             let section = self.sections.get(&section_id).expect("known section id");
@@ -154,14 +148,14 @@ impl File {
             }
         }
 
-        Err(lookup::existing::Error::KeyMissing)
+        Err(lookup::existing::key_missing())
     }
 
     /// Returns a mutable reference to an uninterpreted value given a `key`.
     ///
     /// Consider [`Self::raw_values_mut`] if you want to get mutable
     /// references to all values of a multivar instead.
-    pub fn raw_value_mut(&mut self, key: impl AsKey) -> Result<ValueMut<'_>, lookup::existing::Error> {
+    pub fn raw_value_mut(&mut self, key: impl AsKey) -> ExnResult<ValueMut<'_>> {
         let key = key.as_key();
         self.raw_value_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, |_| true)
     }
@@ -176,7 +170,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<ValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<ValueMut<'_>> {
         self.raw_value_mut_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -188,7 +182,7 @@ impl File {
         &mut self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<ValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<ValueMut<'_>> {
         let key = key.as_key();
         self.raw_value_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -203,7 +197,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<ValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<ValueMut<'_>> {
         self.raw_value_mut_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -218,11 +212,11 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<ValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<ValueMut<'_>> {
         let mut section_ids = self
             .section_ids_by_name_and_subname(section_name, subsection_name)?
             .rev();
-        let key = section::ValueName::try_from(value_name)?;
+        let key = section::ValueName::try_from(value_name).or_erased()?;
 
         while let Some(section_id) = section_ids.next() {
             let mut index = 0;
@@ -271,7 +265,7 @@ impl File {
             });
         }
 
-        Err(lookup::existing::Error::KeyMissing)
+        Err(lookup::existing::key_missing())
     }
 
     /// Returns all uninterpreted values given a `key`.
@@ -309,7 +303,7 @@ impl File {
     ///
     /// Consider [`Self::raw_value`] if you want to get the resolved single
     /// value for a given key, if your value does not support multi-valued values.
-    pub fn raw_values(&self, key: impl AsKey) -> Result<Vec<BString>, lookup::existing::Error> {
+    pub fn raw_values(&self, key: impl AsKey) -> ExnResult<Vec<BString>> {
         let key = key.as_key();
         self.raw_values_by(key.section_name, key.subsection_name, key.value_name)
     }
@@ -355,15 +349,12 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<Vec<BString>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<BString>> {
         self.raw_values_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
     /// Returns all uninterpreted values and their containing sections given a `key`, in order of occurrence.
-    pub fn raw_values_with_sections(
-        &self,
-        key: impl AsKey,
-    ) -> Result<Vec<(BString, file::SectionRef<'_>)>, lookup::existing::Error> {
+    pub fn raw_values_with_sections(&self, key: impl AsKey) -> ExnResult<Vec<(BString, file::SectionRef<'_>)>> {
         let key = key.as_key();
         self.raw_values_with_sections_by(key.section_name, key.subsection_name, key.value_name)
     }
@@ -375,7 +366,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<Vec<(BString, file::SectionRef<'_>)>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<(BString, file::SectionRef<'_>)>> {
         self.raw_values_with_sections_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -385,7 +376,7 @@ impl File {
         &self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<(BString, file::SectionRef<'_>)>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<(BString, file::SectionRef<'_>)>> {
         let key = key.as_key();
         self.raw_values_with_sections_filter_by(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -398,7 +389,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<(BString, file::SectionRef<'_>)>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<(BString, file::SectionRef<'_>)>> {
         self.raw_values_with_sections_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -411,11 +402,7 @@ impl File {
     ///
     /// The ordering means that the last of the returned values is the one that would be the
     /// value used in the single-value case.
-    pub fn raw_values_filter(
-        &self,
-        key: impl AsKey,
-        filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<BString>, lookup::existing::Error> {
+    pub fn raw_values_filter(&self, key: impl AsKey, filter: impl FnMut(&Metadata) -> bool) -> ExnResult<Vec<BString>> {
         let key = key.as_key();
         self.raw_values_filter_by(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -431,7 +418,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<BString>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<BString>> {
         self.raw_values_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -446,7 +433,7 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<BString>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<BString>> {
         self.raw_values_with_sections_filter_inner(section_name, subsection_name, value_name, filter)
             .map(|values| values.into_iter().map(|(value, _section)| value).collect())
     }
@@ -457,7 +444,7 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Vec<(BString, file::SectionRef<'_>)>, lookup::existing::Error> {
+    ) -> ExnResult<Vec<(BString, file::SectionRef<'_>)>> {
         let mut values = Vec::new();
         let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         for section_id in section_ids {
@@ -476,7 +463,7 @@ impl File {
         }
 
         if values.is_empty() {
-            Err(lookup::existing::Error::KeyMissing)
+            Err(lookup::existing::key_missing())
         } else {
             Ok(values)
         }
@@ -503,7 +490,7 @@ impl File {
     /// # use std::convert::TryFrom;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("b"),
     ///         bstr::BString::from("c"),
@@ -511,10 +498,10 @@ impl File {
     ///     ]
     /// );
     ///
-    /// git_config.raw_values_mut("core.a")?.set_all("g");
+    /// git_config.raw_values_mut("core.a").expect("values exist").set_all("g");
     ///
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("g"),
     ///         bstr::BString::from("g"),
@@ -529,7 +516,7 @@ impl File {
     ///
     /// Note that this operation is relatively expensive, requiring a full
     /// traversal of the config.
-    pub fn raw_values_mut(&mut self, key: impl AsKey) -> Result<MultiValueMut<'_>, lookup::existing::Error> {
+    pub fn raw_values_mut(&mut self, key: impl AsKey) -> ExnResult<MultiValueMut<'_>> {
         let key = key.as_key();
         self.raw_values_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, |_| true)
     }
@@ -556,7 +543,7 @@ impl File {
     /// # use std::convert::TryFrom;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("b"),
     ///         bstr::BString::from("c"),
@@ -564,10 +551,10 @@ impl File {
     ///     ]
     /// );
     ///
-    /// git_config.raw_values_mut_by("core", None, "a")?.set_all("g");
+    /// git_config.raw_values_mut_by("core", None, "a").expect("values exist").set_all("g");
     ///
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("g"),
     ///         bstr::BString::from("g"),
@@ -587,7 +574,7 @@ impl File {
         section_name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
-    ) -> Result<MultiValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<MultiValueMut<'_>> {
         self.raw_values_mut_filter_by(section_name, subsection_name, value_name, |_| true)
     }
 
@@ -597,7 +584,7 @@ impl File {
         &mut self,
         key: impl AsKey,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<MultiValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<MultiValueMut<'_>> {
         let key = key.as_key();
         self.raw_values_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, filter)
     }
@@ -610,7 +597,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<MultiValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<MultiValueMut<'_>> {
         self.raw_values_mut_filter_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -625,9 +612,9 @@ impl File {
         subsection_name: Option<&BStr>,
         value_name: &str,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<MultiValueMut<'_>, lookup::existing::Error> {
+    ) -> ExnResult<MultiValueMut<'_>> {
         let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
-        let key = section::ValueName::try_from(value_name)?;
+        let key = section::ValueName::try_from(value_name).or_erased()?;
 
         let mut offsets = HashMap::new();
         let mut entries = Vec::new();
@@ -671,7 +658,7 @@ impl File {
         entries.sort();
 
         if entries.is_empty() {
-            Err(lookup::existing::Error::KeyMissing)
+            Err(lookup::existing::key_missing())
         } else {
             Ok(MultiValueMut {
                 section: &mut self.sections,
@@ -705,10 +692,10 @@ impl File {
     /// # use gix_config::File;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
-    /// git_config.set_existing_raw_value("core.a", "e")?;
-    /// assert_eq!(git_config.raw_value("core.a")?, "e");
+    /// git_config.set_existing_raw_value("core.a", "e").expect("value exists");
+    /// assert_eq!(git_config.raw_value("core.a").expect("value exists"), "e");
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("b"),
     ///         bstr::BString::from("c"),
@@ -717,14 +704,11 @@ impl File {
     /// );
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
-    pub fn set_existing_raw_value(
-        &mut self,
-        key: impl AsKey,
-        new_value: impl crate::AsBStr,
-    ) -> Result<(), crate::file::set_raw_value::Error> {
+    pub fn set_existing_raw_value(&mut self, key: impl AsKey, new_value: impl crate::AsBStr) -> ExnResult {
         let key = key.as_key();
         self.raw_value_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, |_| true)?
-            .set(new_value)?;
+            .set(new_value)
+            .or_erased()?;
         Ok(())
     }
 
@@ -750,10 +734,10 @@ impl File {
     /// # use gix_config::File;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
-    /// git_config.set_existing_raw_value_by("core", None, "a", "e")?;
-    /// assert_eq!(git_config.raw_value("core.a")?, "e");
+    /// git_config.set_existing_raw_value_by("core", None, "a", "e").expect("value exists");
+    /// assert_eq!(git_config.raw_value("core.a").expect("value exists"), "e");
     /// assert_eq!(
-    ///     git_config.raw_values("core.a")?,
+    ///     git_config.raw_values("core.a").expect("values exist"),
     ///     vec![
     ///         bstr::BString::from("b"),
     ///         bstr::BString::from("c"),
@@ -768,9 +752,10 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         new_value: impl crate::AsBStr,
-    ) -> Result<(), crate::file::set_raw_value::Error> {
+    ) -> ExnResult {
         self.raw_value_mut_by(section_name, subsection_name, value_name)?
-            .set(new_value)?;
+            .set(new_value)
+            .or_erased()?;
         Ok(())
     }
 
@@ -791,18 +776,14 @@ impl File {
     /// ```
     /// # use gix_config::File;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b").unwrap();
-    /// let prev = git_config.set_raw_value(&"core.a", "e")?;
-    /// git_config.set_raw_value(&"core.b", "f")?;
+    /// let prev = git_config.set_raw_value(&"core.a", "e").expect("valid value");
+    /// git_config.set_raw_value(&"core.b", "f").expect("valid value");
     /// assert_eq!(prev.expect("present"), "b");
-    /// assert_eq!(git_config.raw_value("core.a")?, "e");
-    /// assert_eq!(git_config.raw_value("core.b")?, "f");
+    /// assert_eq!(git_config.raw_value("core.a").expect("value exists"), "e");
+    /// assert_eq!(git_config.raw_value("core.b").expect("value exists"), "f");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
-    pub fn set_raw_value(
-        &mut self,
-        key: impl AsKey,
-        new_value: impl crate::AsBStr,
-    ) -> Result<Option<BString>, crate::file::set_raw_value::Error> {
+    pub fn set_raw_value(&mut self, key: impl AsKey, new_value: impl crate::AsBStr) -> ExnResult<Option<BString>> {
         self.set_raw_value_filter(key, new_value, |_| true)
     }
 
@@ -823,11 +804,11 @@ impl File {
     /// ```
     /// # use gix_config::File;
     /// # let mut git_config = gix_config::File::try_from("[core]a=b").unwrap();
-    /// let prev = git_config.set_raw_value_by("core", None, "a", "e")?;
-    /// git_config.set_raw_value_by("core", None, "b", "f")?;
+    /// let prev = git_config.set_raw_value_by("core", None, "a", "e").expect("valid value");
+    /// git_config.set_raw_value_by("core", None, "b", "f").expect("valid value");
     /// assert_eq!(prev.expect("present"), "b");
-    /// assert_eq!(git_config.raw_value("core.a")?, "e");
-    /// assert_eq!(git_config.raw_value("core.b")?, "f");
+    /// assert_eq!(git_config.raw_value("core.a").expect("value exists"), "e");
+    /// assert_eq!(git_config.raw_value("core.b").expect("value exists"), "f");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn set_raw_value_by(
@@ -836,7 +817,7 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         new_value: impl crate::AsBStr,
-    ) -> Result<Option<BString>, crate::file::set_raw_value::Error> {
+    ) -> ExnResult<Option<BString>> {
         self.set_raw_value_filter_by(section_name, subsection_name, value_name, new_value, |_| true)
     }
 
@@ -847,7 +828,7 @@ impl File {
         key: impl AsKey,
         new_value: impl crate::AsBStr,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<BString>, crate::file::set_raw_value::Error> {
+    ) -> ExnResult<Option<BString>> {
         let key = key.as_key();
         self.set_raw_value_filter_by_inner(key.section_name, key.subsection_name, key.value_name, new_value, filter)
     }
@@ -861,7 +842,7 @@ impl File {
         value_name: impl AsRef<str>,
         new_value: impl crate::AsBStr,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<BString>, crate::file::set_raw_value::Error> {
+    ) -> ExnResult<Option<BString>> {
         self.set_raw_value_filter_by_inner(
             section_name.as_ref(),
             subsection_name.as_bstr_opt(),
@@ -878,10 +859,12 @@ impl File {
         value_name: &str,
         new_value: impl crate::AsBStr,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<BString>, crate::file::set_raw_value::Error> {
-        let key = section::ValueName::try_from(value_name)?;
-        let mut section = self.section_mut_or_create_new_filter_inner(section_name, subsection_name, filter)?;
-        section.set_inner(key, new_value.as_bstr()).map_err(Into::into)
+    ) -> ExnResult<Option<BString>> {
+        let key = section::ValueName::try_from(value_name).or_erased()?;
+        let mut section = self
+            .section_mut_or_create_new_filter_inner(section_name, subsection_name, filter)
+            .or_erased()?;
+        section.set_inner(key, new_value.as_bstr()).or_erased()
     }
 
     /// Sets a multivar in a given `key`.
@@ -921,8 +904,8 @@ impl File {
     ///     "y",
     ///     "z",
     /// ];
-    /// git_config.set_existing_raw_multi_value("core.a", new_values.into_iter())?;
-    /// let fetched_config = git_config.raw_values("core.a")?;
+    /// git_config.set_existing_raw_multi_value("core.a", new_values.into_iter()).expect("values exist");
+    /// let fetched_config = git_config.raw_values("core.a").expect("values exist");
     /// assert!(fetched_config.iter().any(|v| v == "x"));
     /// assert!(fetched_config.iter().any(|v| v == "y"));
     /// assert!(fetched_config.iter().any(|v| v == "z"));
@@ -939,8 +922,8 @@ impl File {
     ///     "x",
     ///     "y",
     /// ];
-    /// git_config.set_existing_raw_multi_value("core.a", new_values.into_iter())?;
-    /// let fetched_config = git_config.raw_values("core.a")?;
+    /// git_config.set_existing_raw_multi_value("core.a", new_values.into_iter()).expect("values exist");
+    /// let fetched_config = git_config.raw_values("core.a").expect("values exist");
     /// assert!(fetched_config.iter().any(|v| v == "x"));
     /// assert!(fetched_config.iter().any(|v| v == "y"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
@@ -958,22 +941,19 @@ impl File {
     ///     "z",
     ///     "discarded",
     /// ];
-    /// git_config.set_existing_raw_multi_value("core.a", new_values)?;
-    /// assert!(!git_config.raw_values("core.a")?.iter().any(|v| v == "discarded"));
+    /// git_config.set_existing_raw_multi_value("core.a", new_values).expect("values exist");
+    /// assert!(!git_config.raw_values("core.a").expect("values exist").iter().any(|v| v == "discarded"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
-    pub fn set_existing_raw_multi_value<Iter, Item>(
-        &mut self,
-        key: impl AsKey,
-        new_values: Iter,
-    ) -> Result<(), crate::file::set_raw_value::Error>
+    pub fn set_existing_raw_multi_value<Iter, Item>(&mut self, key: impl AsKey, new_values: Iter) -> ExnResult
     where
         Iter: IntoIterator<Item = Item>,
         Item: crate::AsBStr,
     {
         let key = key.as_key();
         self.raw_values_mut_filter_inner(key.section_name, key.subsection_name, key.value_name, |_| true)?
-            .set_values(new_values)?;
+            .set_values(new_values)
+            .or_erased()?;
         Ok(())
     }
 
@@ -1014,8 +994,8 @@ impl File {
     ///     "y",
     ///     "z",
     /// ];
-    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values.into_iter())?;
-    /// let fetched_config = git_config.raw_values("core.a")?;
+    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values.into_iter()).expect("values exist");
+    /// let fetched_config = git_config.raw_values("core.a").expect("values exist");
     /// assert!(fetched_config.iter().any(|v| v == "x"));
     /// assert!(fetched_config.iter().any(|v| v == "y"));
     /// assert!(fetched_config.iter().any(|v| v == "z"));
@@ -1032,8 +1012,8 @@ impl File {
     ///     "x",
     ///     "y",
     /// ];
-    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values.into_iter())?;
-    /// let fetched_config = git_config.raw_values("core.a")?;
+    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values.into_iter()).expect("values exist");
+    /// let fetched_config = git_config.raw_values("core.a").expect("values exist");
     /// assert!(fetched_config.iter().any(|v| v == "x"));
     /// assert!(fetched_config.iter().any(|v| v == "y"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
@@ -1051,8 +1031,8 @@ impl File {
     ///     "z",
     ///     "discarded",
     /// ];
-    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values)?;
-    /// assert!(!git_config.raw_values("core.a")?.iter().any(|v| v == "discarded"));
+    /// git_config.set_existing_raw_multi_value_by("core", None, "a", new_values).expect("values exist");
+    /// assert!(!git_config.raw_values("core.a").expect("values exist").iter().any(|v| v == "discarded"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn set_existing_raw_multi_value_by<Iter, Item>(
@@ -1061,13 +1041,14 @@ impl File {
         subsection_name: impl AsBStrOpt,
         value_name: impl AsRef<str>,
         new_values: Iter,
-    ) -> Result<(), crate::file::set_raw_value::Error>
+    ) -> ExnResult
     where
         Iter: IntoIterator<Item = Item>,
         Item: crate::AsBStr,
     {
         self.raw_values_mut_by(section_name, subsection_name, value_name)?
-            .set_values(new_values)?;
+            .set_values(new_values)
+            .or_erased()?;
         Ok(())
     }
 }
diff --git a/gix-config/src/file/access/read_only.rs b/gix-config/src/file/access/read_only.rs
index 10fbfc45f5b..ff225a5adc8 100644
--- a/gix-config/src/file/access/read_only.rs
+++ b/gix-config/src/file/access/read_only.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnResult;
 use gix_features::threading::OwnShared;
 use smallvec::SmallVec;
 
@@ -37,11 +38,11 @@ impl File {
     ///         a = 10k
     ///         c = false
     /// "#;
-    /// let git_config = gix_config::File::try_from(config)?;
+    /// let git_config = gix_config::File::try_from(config).expect("valid config");
     /// // You can either use the turbofish to determine the type...
-    /// let a_value = git_config.value::<Integer>("core.a")?;
+    /// let a_value = git_config.value::<Integer>("core.a").expect("valid value");
     /// // ... or explicitly declare the type to avoid the turbofish
-    /// let c_value: Boolean = git_config.value("core.c")?;
+    /// let c_value: Boolean = git_config.value("core.c").expect("valid value");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn value<T: TryFrom<BString>>(&self, key: impl AsKey) -> Result<T, lookup::Error<T::Error>> {
@@ -71,11 +72,11 @@ impl File {
     ///         a = 10k
     ///         c = false
     /// "#;
-    /// let git_config = gix_config::File::try_from(config)?;
+    /// let git_config = gix_config::File::try_from(config).expect("valid config");
     /// // You can either use the turbofish to determine the type...
-    /// let a_value = git_config.value_by::<Integer>("core", None, "a")?;
+    /// let a_value = git_config.value_by::<Integer>("core", None, "a").expect("valid value");
     /// // ... or explicitly declare the type to avoid the turbofish
-    /// let c_value: Boolean = git_config.value_by("core", None, "c")?;
+    /// let c_value: Boolean = git_config.value_by("core", None, "c").expect("valid value");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn value_by<T: TryFrom<BString>>(
@@ -162,9 +163,9 @@ impl File {
     ///         a
     ///         a = false
     /// "#;
-    /// let git_config = gix_config::File::try_from(config).unwrap();
+    /// let git_config = gix_config::File::try_from(config).expect("valid config");
     /// // You can either use the turbofish to determine the type...
-    /// let a_value = git_config.values::<Boolean>("core.a")?;
+    /// let a_value = git_config.values::<Boolean>("core.a").expect("valid values");
     /// assert_eq!(
     ///     a_value,
     ///     vec![
@@ -174,9 +175,9 @@ impl File {
     ///     ]
     /// );
     /// // ... or explicitly declare the type to avoid the turbofish
-    /// let c_value: Vec<Boolean> = git_config.values("core.c").unwrap();
+    /// let c_value: Vec<Boolean> = git_config.values("core.c")?;
     /// assert_eq!(c_value, vec![Boolean(false)]);
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), gix_config::lookup::Error<gix_error::Exn<gix_error::Message>>>(())
     /// ```
     ///
     /// [`value`]: crate::value
@@ -216,9 +217,9 @@ impl File {
     ///         a
     ///         a = false
     /// "#;
-    /// let git_config = gix_config::File::try_from(config).unwrap();
+    /// let git_config = gix_config::File::try_from(config).expect("valid config");
     /// // You can either use the turbofish to determine the type...
-    /// let a_value = git_config.values_by::<Boolean>("core", None, "a")?;
+    /// let a_value = git_config.values_by::<Boolean>("core", None, "a").expect("valid values");
     /// assert_eq!(
     ///     a_value,
     ///     vec![
@@ -228,9 +229,9 @@ impl File {
     ///     ]
     /// );
     /// // ... or explicitly declare the type to avoid the turbofish
-    /// let c_value: Vec<Boolean> = git_config.values_by("core", None, "c").unwrap();
+    /// let c_value: Vec<Boolean> = git_config.values_by("core", None, "c")?;
     /// assert_eq!(c_value, vec![Boolean(false)]);
-    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # Ok::<(), gix_config::lookup::Error<gix_error::Exn<gix_error::Message>>>(())
     /// ```
     ///
     /// [`value`]: crate::value
@@ -273,23 +274,16 @@ impl File {
     }
 
     /// Returns the last found immutable section with a given `name` and optional `subsection_name`.
-    pub fn section(
-        &self,
-        name: impl AsRef<str>,
-        subsection_name: impl AsBStrOpt,
-    ) -> Result<file::SectionRef<'_>, lookup::existing::Error> {
+    pub fn section(&self, name: impl AsRef<str>, subsection_name: impl AsBStrOpt) -> ExnResult<file::SectionRef<'_>> {
         self.section_filter(name, subsection_name, |_| true)?
-            .ok_or(lookup::existing::Error::SectionMissing)
+            .ok_or_else(lookup::existing::section_missing)
     }
 
     /// Returns the last found immutable section with a given `section_key`, identifying the name and subsection name like `core`
     /// or `remote.origin`.
-    pub fn section_by_key(
-        &self,
-        section_key: impl crate::AsBStr,
-    ) -> Result<file::SectionRef<'_>, lookup::existing::Error> {
+    pub fn section_by_key(&self, section_key: impl crate::AsBStr) -> ExnResult<file::SectionRef<'_>> {
         let key = crate::parse::section::unvalidated::KeyRef::parse(section_key.as_bstr())
-            .ok_or(lookup::existing::Error::KeyMissing)?;
+            .ok_or_else(lookup::existing::key_missing)?;
         self.section(key.section_name, key.subsection_name)
     }
 
@@ -302,7 +296,7 @@ impl File {
         name: impl AsRef<str>,
         subsection_name: impl AsBStrOpt,
         mut filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<file::SectionRef<'_>>, lookup::existing::Error> {
+    ) -> ExnResult<Option<file::SectionRef<'_>>> {
         Ok(self
             .section_ids_by_name_and_subname(name.as_ref(), subsection_name.as_bstr_opt())?
             .rev()
@@ -320,9 +314,9 @@ impl File {
         &self,
         section_key: impl crate::AsBStr,
         filter: impl FnMut(&Metadata) -> bool,
-    ) -> Result<Option<file::SectionRef<'_>>, lookup::existing::Error> {
+    ) -> ExnResult<Option<file::SectionRef<'_>>> {
         let key = crate::parse::section::unvalidated::KeyRef::parse(section_key.as_bstr())
-            .ok_or(lookup::existing::Error::KeyMissing)?;
+            .ok_or_else(lookup::existing::key_missing)?;
         self.section_filter(key.section_name, key.subsection_name, filter)
     }
 
diff --git a/gix-config/src/file/includes/mod.rs b/gix-config/src/file/includes/mod.rs
index 073f4ee8793..f89ed13d0f7 100644
--- a/gix-config/src/file/includes/mod.rs
+++ b/gix-config/src/file/includes/mod.rs
@@ -1,13 +1,13 @@
 use std::path::{Path, PathBuf};
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, message, not_found, validation};
 use gix_features::threading::OwnShared;
 use gix_ref::Category;
 
 use crate::{
     File, file,
     file::{Metadata, SectionId, includes, init},
-    path,
 };
 
 impl File {
@@ -30,7 +30,7 @@ impl File {
     ///   We can fix this by 'splitting' the include section if needed so the included sections are put into the right place.
     /// - `hasconfig:remote.*.url` will not prevent itself to include files with `[remote "name"]\nurl = x` values, but it also
     ///   won't match them, i.e. one cannot include something that will cause the condition to match or to always be true.
-    pub fn resolve_includes(&mut self, options: init::Options<'_>) -> Result<(), Error> {
+    pub fn resolve_includes(&mut self, options: init::Options<'_>) -> ExnResult {
         if options.includes.max_depth == 0 {
             return Ok(());
         }
@@ -39,7 +39,7 @@ impl File {
     }
 }
 
-pub(crate) fn resolve(config: &mut File, buf: &mut Vec<u8>, options: init::Options<'_>) -> Result<(), Error> {
+pub(crate) fn resolve(config: &mut File, buf: &mut Vec<u8>, options: init::Options<'_>) -> ExnResult {
     resolve_includes_recursive(None, config, 0, buf, options)
 }
 
@@ -49,12 +49,14 @@ fn resolve_includes_recursive(
     depth: u8,
     buf: &mut Vec<u8>,
     options: init::Options<'_>,
-) -> Result<(), Error> {
+) -> ExnResult {
     if depth == options.includes.max_depth {
         return if options.includes.err_on_max_depth_exceeded {
-            Err(Error::IncludeDepthExceeded {
-                max_depth: options.includes.max_depth,
-            })
+            Err(validation(format!(
+                "The maximum allowed length {} of the file include chain built by following nested resolve_includes is exceeded",
+                options.includes.max_depth
+            ))
+            .raise_erased())
         } else {
             Ok(())
         };
@@ -94,7 +96,7 @@ fn insert_includes_recursively(
     depth: u8,
     options: init::Options<'_>,
     buf: &mut Vec<u8>,
-) -> Result<(), Error> {
+) -> ExnResult {
     for (section_id, config_path) in section_ids_and_include_paths {
         let meta = OwnShared::clone(&target_config.sections[&section_id].meta);
         let target_config_path = meta.path.as_deref();
@@ -108,13 +110,15 @@ fn insert_includes_recursively(
 
         buf.clear();
         std::io::copy(
-            &mut std::fs::File::open(&config_path).map_err(|err| Error::Io {
-                source: err,
-                path: config_path.to_owned(),
+            &mut std::fs::File::open(&config_path).or_raise_erased(|| {
+                message!(
+                    "Could not read included configuration file at '{}'",
+                    config_path.display()
+                )
             })?,
             buf,
         )
-        .map_err(Error::CopyBuffer)?;
+        .or_raise_erased(|| message("Failed to copy configuration file into buffer"))?;
         let config_meta = Metadata {
             path: Some(config_path),
             trust: meta.trust,
@@ -126,16 +130,13 @@ fn insert_includes_recursively(
             ..options
         };
 
-        let mut include_config =
-            File::from_bytes_owned(buf, config_meta, no_follow_options).map_err(|err| match err {
-                init::Error::Parse(err) => Error::Parse(err),
-                init::Error::Interpolate(err) => Error::Interpolate(err),
-                init::Error::Span(err) => Error::Span(err),
-                init::Error::Includes(_) => unreachable!("BUG: {:?} not possible due to no-follow options", err),
-            })?;
+        let mut include_config = File::from_bytes_owned(buf, config_meta, no_follow_options)
+            .or_raise_erased(|| message("Could not parse included configuration file"))?;
         resolve_includes_recursive(Some(target_config), &mut include_config, depth + 1, buf, options)?;
 
-        target_config.append_or_insert(include_config, Some(section_id))?;
+        target_config
+            .append_or_insert(include_config, Some(section_id))
+            .or_raise_erased(|| message("Could not append included configuration"))?;
     }
     Ok(())
 }
@@ -154,7 +155,7 @@ fn include_condition_match(
     target_config_path: Option<&Path>,
     search_config: &File,
     options: Options<'_>,
-) -> Result<bool, Error> {
+) -> ExnResult<bool> {
     let mut tokens = condition.splitn(2, |b| *b == b':');
     let (prefix, condition) = match (tokens.next(), tokens.next()) {
         (Some(a), Some(b)) => (a, b),
@@ -241,16 +242,20 @@ fn gitdir_matches(
         ..
     }: Options<'_>,
     wildmatch_mode: gix_glob::wildmatch::Mode,
-) -> Result<bool, Error> {
+) -> ExnResult<bool> {
     if !err_on_interpolation_failure && git_dir.is_none() {
         return Ok(false);
     }
-    let git_dir = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(git_dir.ok_or(Error::MissingGitDir)?));
+    let git_dir = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(git_dir.ok_or_raise_erased(|| {
+        not_found("The git directory must be provided to support `gitdir:` conditional includes")
+    })?));
 
     let mut pattern_path = match check_interpolation_result(
         err_on_interpolation_failure,
         crate::Path::from(condition_path.to_owned()).interpolate(context),
-    )? {
+    )
+    .or_raise_erased(|| message("Could not interpolate conditional include path"))?
+    {
         Some(path) => gix_path::into_bstr(path).into_owned(),
         // Git keeps the original condition pattern when interpolation fails.
         None => condition_path.to_owned(),
@@ -265,7 +270,11 @@ fn gitdir_matches(
             return Ok(false);
         }
         let parent_dir = target_config_path
-            .ok_or(Error::MissingConfigPath)?
+            .ok_or_raise_erased(|| {
+                not_found(
+                    "Include paths from environment variables must not be relative as no config file path exists as root",
+                )
+            })?
             .parent()
             .expect("config path can never be /");
         let mut joined_path = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(parent_dir)).into_owned();
@@ -290,9 +299,10 @@ fn gitdir_matches(
         return Ok(true);
     }
 
-    let expanded_git_dir = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(gix_path::realpath(
-        gix_path::from_byte_slice(&git_dir),
-    )?));
+    let expanded_git_dir = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(
+        gix_path::realpath(gix_path::from_byte_slice(&git_dir))
+            .or_raise_erased(|| message("Could not resolve the git directory to its real path"))?,
+    ));
     Ok(gix_glob::wildmatch(
         pattern_path.as_bstr(),
         expanded_git_dir.as_ref(),
@@ -300,21 +310,14 @@ fn gitdir_matches(
     ))
 }
 
-fn check_interpolation_result(
-    disable: bool,
-    res: Result<impl Into<PathBuf>, path::interpolate::Error>,
-) -> Result<Option<PathBuf>, path::interpolate::Error> {
+fn check_interpolation_result(disable: bool, res: ExnResult<impl Into<PathBuf>>) -> ExnResult<Option<PathBuf>> {
     if disable {
         return res.map(|path| Some(path.into()));
     }
     match res {
         Ok(good) => Ok(Some(good.into())),
-        Err(err) => match err {
-            path::interpolate::Error::Missing { .. } => Ok(None),
-            path::interpolate::Error::UsernameConversion(_) | path::interpolate::Error::Utf8Conversion { .. } => {
-                Err(err)
-            }
-        },
+        Err(err) if err.is_validation() => Err(err),
+        Err(_) => Ok(None),
     }
 }
 
@@ -327,8 +330,10 @@ fn resolve_path(
         err_on_missing_config_path,
         ..
     }: includes::Options<'_>,
-) -> Result<Option<PathBuf>, Error> {
-    let path = match check_interpolation_result(err_on_interpolation_failure, path.interpolate(context))? {
+) -> ExnResult<Option<PathBuf>> {
+    let path = match check_interpolation_result(err_on_interpolation_failure, path.interpolate(context))
+        .or_raise_erased(|| message("Could not interpolate include path"))?
+    {
         Some(p) => p,
         None => return Ok(None),
     };
@@ -337,7 +342,11 @@ fn resolve_path(
             return Ok(None);
         }
         target_config_path
-            .ok_or(Error::MissingConfigPath)?
+            .ok_or_raise_erased(|| {
+                not_found(
+                    "Include paths from environment variables must not be relative as no config file path exists as root",
+                )
+            })?
             .parent()
             .expect("path is a config file which naturally lives in a directory")
             .join(path)
@@ -348,4 +357,4 @@ fn resolve_path(
 }
 
 mod types;
-pub use types::{Error, Options, conditional};
+pub use types::{Options, conditional};
diff --git a/gix-config/src/file/includes/types.rs b/gix-config/src/file/includes/types.rs
index 66aa6752b19..7f8aa5fcbe3 100644
--- a/gix-config/src/file/includes/types.rs
+++ b/gix-config/src/file/includes/types.rs
@@ -1,30 +1,4 @@
-use std::path::PathBuf;
-
-use crate::{parse, path::interpolate};
-
-/// The error returned when following includes.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to copy configuration file into buffer")]
-    CopyBuffer(#[source] std::io::Error),
-    #[error("Could not read included configuration file at '{}'", path.display())]
-    Io { path: PathBuf, source: std::io::Error },
-    #[error(transparent)]
-    Parse(#[from] parse::Error),
-    #[error(transparent)]
-    Span(#[from] parse::span::Error),
-    #[error(transparent)]
-    Interpolate(#[from] interpolate::Error),
-    #[error("The maximum allowed length {} of the file include chain built by following nested resolve_includes is exceeded", .max_depth)]
-    IncludeDepthExceeded { max_depth: u8 },
-    #[error("Include paths from environment variables must not be relative as no config file paths exists as root")]
-    MissingConfigPath,
-    #[error("The git directory must be provided to support `gitdir:` conditional includes")]
-    MissingGitDir,
-    #[error(transparent)]
-    Realpath(#[from] gix_path::realpath::Error),
-}
+use crate::path::interpolate;
 
 /// Options to handle includes, like `include.path` or `includeIf.<condition>.path`,
 #[derive(Clone, Copy)]
diff --git a/gix-config/src/file/init/comfort.rs b/gix-config/src/file/init/comfort.rs
index 275a7b0e53c..13e8eadad07 100644
--- a/gix-config/src/file/init/comfort.rs
+++ b/gix-config/src/file/init/comfort.rs
@@ -3,6 +3,7 @@ use crate::{
     file::{Metadata, init},
     path, source,
 };
+use gix_error::{ExnMessageResult, ExnResult};
 
 /// Easy-instantiation of typical non-repository git configuration files with all configuration defaulting to typical values.
 ///
@@ -23,7 +24,7 @@ impl File {
     /// which excludes repository local configuration, as well as override-configuration from environment variables.
     ///
     /// Note that the file might [be empty][File::is_void()] in case no configuration file was found.
-    pub fn from_globals() -> Result<File, init::from_paths::Error> {
+    pub fn from_globals() -> ExnMessageResult<File> {
         let metas = [
             source::Kind::GitInstallation,
             source::Kind::System,
@@ -60,7 +61,7 @@ impl File {
     /// See [`git-config`'s documentation] for more information on the environment variables in question.
     ///
     /// [`git-config`'s documentation]: https://git-scm.com/docs/git-config#Documentation/git-config.txt-GITCONFIGCOUNT
-    pub fn from_environment_overrides() -> Result<File, init::from_env::Error> {
+    pub fn from_environment_overrides() -> ExnResult<File> {
         let home = gix_path::env::home_dir();
         let options = init::Options {
             includes: init::includes::Options::follow_without_conditional(home.as_deref()),
@@ -84,7 +85,9 @@ impl File {
     ///
     /// Includes will be resolved within limits as some information like the git installation directory is missing to interpolate
     /// paths with as well as git repository information like the branch name.
-    pub fn from_git_dir(dir: std::path::PathBuf) -> Result<File, from_git_dir::Error> {
+    pub fn from_git_dir(dir: std::path::PathBuf) -> ExnMessageResult<File> {
+        use gix_error::{ResultExt, message};
+
         let (mut local, git_dir) = {
             let source = Source::Local;
             let mut path = dir;
@@ -93,7 +96,8 @@ impl File {
                     .storage_location(&mut gix_path::env::var)
                     .expect("location available for local"),
             );
-            let local = Self::from_path_no_includes(path.clone(), source)?;
+            let local = Self::from_path_no_includes(path.clone(), source)
+                .or_raise(|| message("Could not read repository-local configuration"))?;
             path.pop();
             (local, path)
         };
@@ -110,7 +114,8 @@ impl File {
             }),
             _ => None,
         }
-        .transpose()?;
+        .transpose()
+        .or_raise(|| message("Could not read worktree configuration"))?;
 
         let home = gix_path::env::home_dir();
         let options = init::Options {
@@ -127,37 +132,31 @@ impl File {
             ..Default::default()
         };
 
-        let mut globals = Self::from_globals()?;
-        globals.resolve_includes(options)?;
-        local.resolve_includes(options)?;
+        let mut globals = Self::from_globals().or_raise(|| message("Could not read global configuration"))?;
+        globals
+            .resolve_includes(options)
+            .or_raise(|| message("Could not resolve includes in global configuration"))?;
+        local
+            .resolve_includes(options)
+            .or_raise(|| message("Could not resolve includes in repository-local configuration"))?;
 
-        globals.append(local)?;
+        globals
+            .append(local)
+            .or_raise(|| message("Could not append repository-local configuration"))?;
         if let Some(mut worktree) = worktree {
-            worktree.resolve_includes(options)?;
-            globals.append(worktree)?;
+            worktree
+                .resolve_includes(options)
+                .or_raise(|| message("Could not resolve includes in worktree configuration"))?;
+            globals
+                .append(worktree)
+                .or_raise(|| message("Could not append worktree configuration"))?;
         }
-        globals.append(Self::from_environment_overrides()?)?;
+        let environment =
+            Self::from_environment_overrides().or_raise(|| message("Could not read environment configuration"))?;
+        globals
+            .append(environment)
+            .or_raise(|| message("Could not append environment configuration"))?;
 
         Ok(globals)
     }
 }
-
-///
-pub mod from_git_dir {
-    use crate::file::init;
-
-    /// The error returned by [`File::from_git_dir()`][crate::File::from_git_dir()].
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error(transparent)]
-        FromPaths(#[from] init::from_paths::Error),
-        #[error(transparent)]
-        FromEnv(#[from] init::from_env::Error),
-        #[error(transparent)]
-        Init(#[from] init::Error),
-        #[error(transparent)]
-        Includes(#[from] init::includes::Error),
-        #[error(transparent)]
-        Span(#[from] crate::parse::span::Error),
-    }
-}
diff --git a/gix-config/src/file/init/from_env.rs b/gix-config/src/file/init/from_env.rs
index 32effaa2418..1f1a547da30 100644
--- a/gix-config/src/file/init/from_env.rs
+++ b/gix-config/src/file/init/from_env.rs
@@ -1,30 +1,7 @@
 use bstr::ByteSlice;
+use gix_error::ExnResult;
 
-use crate::{File, KeyRef, file, file::init, parse::section, path::interpolate};
-
-/// Represents the errors that may occur when calling [`File::from_env()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Configuration {kind} at index {index} contained illformed UTF-8")]
-    IllformedUtf8 { index: usize, kind: &'static str },
-    #[error("GIT_CONFIG_COUNT was not a positive integer: {}", .input)]
-    InvalidConfigCount { input: String },
-    #[error("GIT_CONFIG_KEY_{} was not set", .key_id)]
-    InvalidKeyId { key_id: usize },
-    #[error("GIT_CONFIG_KEY_{} was set to an invalid value: {}", .key_id, .key_val)]
-    InvalidKeyValue { key_id: usize, key_val: String },
-    #[error("GIT_CONFIG_VALUE_{} was not set", .value_id)]
-    InvalidValueId { value_id: usize },
-    #[error(transparent)]
-    PathInterpolationError(#[from] interpolate::Error),
-    #[error(transparent)]
-    Includes(#[from] init::includes::Error),
-    #[error(transparent)]
-    Section(#[from] section::header::Error),
-    #[error(transparent)]
-    SectionValue(#[from] file::section::value::Error),
-}
+use crate::{File, KeyRef, file, file::init};
 
 /// Instantiation from environment variables
 impl File {
@@ -32,12 +9,18 @@ impl File {
     /// See [`git-config`'s documentation] for more information on the environment variables in question.
     ///
     /// With `options` configured, it's possible to resolve `include.path` or `includeIf.<condition>.path` directives as well.
+    /// Integer parsing failures for `GIT_CONFIG_COUNT` and key parsing failures for `GIT_CONFIG_KEY_*` include their
+    /// bytes as `input`
+    /// [metadata](gix_error::Exn::metadata()).
     ///
     /// [`git-config`'s documentation]: https://git-scm.com/docs/git-config#Documentation/git-config.txt-GITCONFIGCOUNT
-    pub fn from_env(options: init::Options<'_>) -> Result<Option<File>, Error> {
+    pub fn from_env(options: init::Options<'_>) -> ExnResult<Option<File>> {
+        use gix_error::{ErrorExt, OptionExt, ResultExt, message, not_found, validation};
         use std::env;
         let count: usize = match env::var("GIT_CONFIG_COUNT") {
-            Ok(v) => v.parse().map_err(|_| Error::InvalidConfigCount { input: v })?,
+            Ok(v) => v.parse::<usize>().or_raise_erased(|| {
+                validation("GIT_CONFIG_COUNT was not a positive integer").with("input", v.into_bytes())
+            })?,
             Err(_) => return Ok(None),
         };
 
@@ -54,33 +37,38 @@ impl File {
         let mut config = File::new(meta);
         for i in 0..count {
             let key = gix_path::os_string_into_bstring(
-                env::var_os(format!("GIT_CONFIG_KEY_{i}")).ok_or(Error::InvalidKeyId { key_id: i })?,
+                env::var_os(format!("GIT_CONFIG_KEY_{i}"))
+                    .ok_or_raise_erased(|| not_found(format!("GIT_CONFIG_KEY_{i} was not set")))?,
             )
-            .map_err(|_| Error::IllformedUtf8 { index: i, kind: "key" })?;
-            let value = env::var_os(format!("GIT_CONFIG_VALUE_{i}")).ok_or(Error::InvalidValueId { value_id: i })?;
-            let key = KeyRef::parse_unvalidated(key.as_ref()).ok_or_else(|| Error::InvalidKeyValue {
-                key_id: i,
-                key_val: key.to_string(),
+            .or_raise_erased(|| validation(format!("Configuration key at index {i} contained illformed UTF-8")))?;
+            let value = env::var_os(format!("GIT_CONFIG_VALUE_{i}"))
+                .ok_or_raise_erased(|| not_found(format!("GIT_CONFIG_VALUE_{i} was not set")))?;
+            let key = KeyRef::parse_unvalidated(key.as_ref()).ok_or_else(|| {
+                validation(format!("GIT_CONFIG_KEY_{i} was set to an invalid value"))
+                    .with("input", key.as_bstr())
+                    .raise_erased()
             })?;
 
             config
-                .section_mut_or_create_new_inner(key.section_name, key.subsection_name)?
+                .section_mut_or_create_new_inner(key.section_name, key.subsection_name)
+                .or_erased()?
                 .push(
                     key.value_name,
                     Some(
                         gix_path::os_str_into_bstr(&value)
-                            .map_err(|_| Error::IllformedUtf8 {
-                                index: i,
-                                kind: "value",
+                            .or_raise_erased(|| {
+                                validation(format!("Configuration value at index {i} contained illformed UTF-8"))
                             })?
                             .as_bytes()
                             .into(),
                     ),
-                )?;
+                )
+                .or_erased()?;
         }
 
         let mut buf = Vec::new();
-        init::includes::resolve(&mut config, &mut buf, options)?;
+        init::includes::resolve(&mut config, &mut buf, options)
+            .or_raise_erased(|| message("Could not resolve includes in environment configuration"))?;
         Ok(Some(config))
     }
 }
diff --git a/gix-config/src/file/init/from_paths.rs b/gix-config/src/file/init/from_paths.rs
index 63227112aa9..bcde512c817 100644
--- a/gix-config/src/file/init/from_paths.rs
+++ b/gix-config/src/file/init/from_paths.rs
@@ -1,51 +1,38 @@
 use std::collections::BTreeSet;
 
+use gix_error::ExnMessageResult;
+
 use crate::{
     File,
-    file::{Metadata, init, init::Options},
+    file::{Metadata, init::Options},
 };
 
-/// The error returned by [`File::from_paths_metadata()`] and [`File::from_path_no_includes()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("The configuration file at \"{}\" could not be read", path.display())]
-    Io {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error(transparent)]
-    Init(#[from] init::Error),
-}
-
 /// Instantiation from one or more paths
 impl File {
     /// Load the single file at `path` with `source` without following include directives.
     ///
     /// Note that the path will be checked for ownership to derive trust.
-    pub fn from_path_no_includes(path: std::path::PathBuf, source: crate::Source) -> Result<Self, Error> {
-        let trust = match gix_sec::Trust::from_path_ownership(&path) {
-            Ok(t) => t,
-            Err(err) => return Err(Error::Io { source: err, path }),
-        };
+    pub fn from_path_no_includes(path: std::path::PathBuf, source: crate::Source) -> ExnMessageResult<Self> {
+        use gix_error::{ResultExt, message};
+        let trust = gix_sec::Trust::from_path_ownership(&path).or_raise(|| {
+            message!(
+                "The configuration file at \"{}\" could not be inspected",
+                path.display()
+            )
+        })?;
 
         let mut buf = Vec::new();
-        match std::io::copy(
-            &mut match std::fs::File::open(&path) {
-                Ok(f) => f,
-                Err(err) => return Err(Error::Io { source: err, path }),
-            },
-            &mut buf,
-        ) {
-            Ok(_) => {}
-            Err(err) => return Err(Error::Io { source: err, path }),
-        }
+        let mut file = std::fs::File::open(&path)
+            .or_raise(|| message!("The configuration file at \"{}\" could not be read", path.display()))?;
+        std::io::copy(&mut file, &mut buf)
+            .or_raise(|| message!("The configuration file at \"{}\" could not be read", path.display()))?;
 
-        Ok(File::from_bytes_owned(
+        File::from_bytes_owned(
             &mut buf,
             Metadata::from(source).at(path).with(trust),
             Default::default(),
-        )?)
+        )
+        .or_raise(|| message("Could not initialize configuration from a path"))
     }
 
     /// Constructs a `git-config` file from the provided metadata, which must include a path to read from or be ignored.
@@ -56,7 +43,7 @@ impl File {
     pub fn from_paths_metadata(
         path_meta: impl IntoIterator<Item = impl Into<Metadata>>,
         options: Options<'_>,
-    ) -> Result<Option<Self>, Error> {
+    ) -> ExnMessageResult<Option<Self>> {
         let mut buf = Vec::with_capacity(512);
         let err_on_nonexisting_paths = true;
         Self::from_paths_metadata_buf(
@@ -76,7 +63,8 @@ impl File {
         buf: &mut Vec<u8>,
         err_on_non_existing_paths: bool,
         options: Options<'_>,
-    ) -> Result<Option<Self>, Error> {
+    ) -> ExnMessageResult<Option<Self>> {
+        use gix_error::{ErrorExt, ResultExt, message};
         let mut target = None;
         let mut seen = BTreeSet::default();
         for (path, mut meta) in path_meta.filter_map(|mut meta| meta.path.take().map(|p| (p, meta))) {
@@ -90,7 +78,10 @@ impl File {
                     Ok(f) => f,
                     Err(err) if !err_on_non_existing_paths && err.kind() == std::io::ErrorKind::NotFound => continue,
                     Err(err) => {
-                        let err = Error::Io { source: err, path };
+                        let err = err.and_raise(message!(
+                            "The configuration file at \"{}\" could not be read",
+                            path.display()
+                        ));
                         if options.ignore_io_errors {
                             gix_features::trace::warn!("ignoring: {err:#?}");
                             continue;
@@ -103,29 +94,30 @@ impl File {
             ) {
                 Ok(_) => {}
                 Err(err) => {
+                    let err = err.and_raise(message!(
+                        "The configuration file at \"{}\" could not be read",
+                        path.display()
+                    ));
                     if options.ignore_io_errors {
-                        gix_features::trace::warn!(
-                            "ignoring: {:#?}",
-                            Error::Io {
-                                source: err,
-                                path: path.clone()
-                            }
-                        );
+                        gix_features::trace::warn!("ignoring: {err:#?}");
                         buf.clear();
                     } else {
-                        return Err(Error::Io { source: err, path });
+                        return Err(err);
                     }
                 }
             }
             meta.path = Some(path);
 
-            let config = Self::from_bytes_owned(buf, meta, options)?;
+            let config = Self::from_bytes_owned(buf, meta, options)
+                .or_raise(|| message("Could not initialize configuration from a path"))?;
             match &mut target {
                 None => {
                     target = Some(config);
                 }
                 Some(target) => {
-                    target.append(config).map_err(init::Error::from)?;
+                    target
+                        .append(config)
+                        .or_raise(|| message("Could not append configuration from a path"))?;
                 }
             }
         }
diff --git a/gix-config/src/file/init/mod.rs b/gix-config/src/file/init/mod.rs
index 356b3a9c5d4..46321604950 100644
--- a/gix-config/src/file/init/mod.rs
+++ b/gix-config/src/file/init/mod.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnResult;
 use gix_features::threading::OwnShared;
 
 use crate::{
@@ -7,7 +8,7 @@ use crate::{
 };
 
 mod types;
-pub use types::{Error, Options};
+pub use types::Options;
 
 mod comfort;
 ///
@@ -36,10 +37,12 @@ impl File {
         input: &[u8],
         meta: impl Into<OwnShared<Metadata>>,
         options: Options<'_>,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
+        use gix_error::{ResultExt, message};
         let meta = meta.into();
         Ok(Self::from_parse_events_no_includes(
-            parse::Events::from_bytes(input, options.to_event_filter())?,
+            parse::Events::from_bytes(input, options.to_event_filter())
+                .or_raise_erased(|| message("Could not parse configuration"))?,
             meta,
         ))
     }
@@ -82,13 +85,16 @@ impl File {
         input_and_buf: &mut Vec<u8>,
         meta: impl Into<OwnShared<Metadata>>,
         options: Options<'_>,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
+        use gix_error::{ResultExt, message};
         let mut config = Self::from_parse_events_no_includes(
-            parse::Events::from_bytes(input_and_buf, options.to_event_filter()).map_err(Error::from)?,
+            parse::Events::from_bytes(input_and_buf, options.to_event_filter())
+                .or_raise_erased(|| message("Could not parse configuration"))?,
             meta,
         );
 
-        includes::resolve(&mut config, input_and_buf, options).map_err(Error::from)?;
+        includes::resolve(&mut config, input_and_buf, options)
+            .or_raise_erased(|| message("Could not resolve configuration includes"))?;
         Ok(config)
     }
 }
diff --git a/gix-config/src/file/init/types.rs b/gix-config/src/file/init/types.rs
index c1b4f32e518..ca397605f0e 100644
--- a/gix-config/src/file/init/types.rs
+++ b/gix-config/src/file/init/types.rs
@@ -1,18 +1,4 @@
-use crate::{file::init, parse, parse::EventRef, path::interpolate};
-
-/// The error returned by [`File::from_bytes_no_includes()`][crate::File::from_bytes_no_includes()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Parse(#[from] parse::Error),
-    #[error(transparent)]
-    Interpolate(#[from] interpolate::Error),
-    #[error(transparent)]
-    Includes(#[from] init::includes::Error),
-    #[error(transparent)]
-    Span(#[from] parse::span::Error),
-}
+use crate::{file::init, parse::EventRef};
 
 /// Options when loading git config using [`File::from_paths_metadata()`][crate::File::from_paths_metadata()].
 #[derive(Clone, Copy, Default)]
diff --git a/gix-config/src/file/mod.rs b/gix-config/src/file/mod.rs
index 5f4c4350906..fc6a00bbade 100644
--- a/gix-config/src/file/mod.rs
+++ b/gix-config/src/file/mod.rs
@@ -24,36 +24,6 @@ mod util;
 ///
 pub mod section;
 
-///
-pub mod rename_section {
-    /// The error returned by [`File::rename_section(…)`][crate::File::rename_section()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Lookup(#[from] crate::lookup::existing::Error),
-        #[error(transparent)]
-        Section(#[from] crate::parse::section::header::Error),
-    }
-}
-
-///
-pub mod set_raw_value {
-    /// The error returned by [`File::set_raw_value(…)`][crate::File::set_raw_value()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Lookup(#[from] crate::lookup::existing::Error),
-        #[error(transparent)]
-        Header(#[from] crate::parse::section::header::Error),
-        #[error(transparent)]
-        ValueName(#[from] crate::parse::section::value_name::Error),
-        #[error(transparent)]
-        Span(#[from] crate::parse::span::Error),
-    }
-}
-
 /// Convert ergonomic subsection inputs into an optional owned name.
 pub trait IntoBStringOpt {
     /// Convert into an optional owned subsection name.
diff --git a/gix-config/src/file/mutable/mod.rs b/gix-config/src/file/mutable/mod.rs
index e6e5ad9fa5b..3011adf8030 100644
--- a/gix-config/src/file/mutable/mod.rs
+++ b/gix-config/src/file/mutable/mod.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_error::ExnMessageResult;
 
 use crate::{file, parse::Event};
 
@@ -53,7 +54,7 @@ impl Default for Whitespace {
 }
 
 impl Whitespace {
-    fn key_value_separators(&self, backing: &mut Vec<u8>) -> Result<Vec<Event>, crate::parse::span::Error> {
+    fn key_value_separators(&self, backing: &mut Vec<u8>) -> ExnMessageResult<Vec<Event>> {
         let mut out = Vec::with_capacity(3);
         if let Some(ws) = &self.pre_sep {
             out.push(Event::Whitespace(crate::parse::Span::append(backing, ws)?));
diff --git a/gix-config/src/file/mutable/multi_value.rs b/gix-config/src/file/mutable/multi_value.rs
index 19711e20bfb..50a3f785090 100644
--- a/gix-config/src/file/mutable/multi_value.rs
+++ b/gix-config/src/file/mutable/multi_value.rs
@@ -1,5 +1,8 @@
+use gix_error::ExnMessageResult;
 use std::{collections::HashMap, ops::DerefMut};
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, BString, ByteVec};
 
 use crate::{
@@ -37,7 +40,7 @@ pub struct MultiValueMut<'borrow> {
 
 impl MultiValueMut<'_> {
     /// Returns the actual values.
-    pub fn get(&self) -> Result<Vec<BString>, lookup::existing::Error> {
+    pub fn get(&self) -> ExnResult<Vec<BString>> {
         let mut expect_value = false;
         let mut values = Vec::new();
         let mut concatenated_value = BString::default();
@@ -74,7 +77,7 @@ impl MultiValueMut<'_> {
         }
 
         if values.is_empty() {
-            return Err(lookup::existing::Error::KeyMissing);
+            return Err(lookup::existing::key_missing());
         }
 
         Ok(values)
@@ -98,7 +101,7 @@ impl MultiValueMut<'_> {
     /// # Safety
     ///
     /// This will panic if the index is out of range.
-    pub fn set_string_at(&mut self, index: usize, value: impl AsRef<str>) -> Result<(), crate::parse::span::Error> {
+    pub fn set_string_at(&mut self, index: usize, value: impl AsRef<str>) -> ExnMessageResult {
         self.set_at(index, value.as_ref())
     }
 
@@ -107,7 +110,7 @@ impl MultiValueMut<'_> {
     /// # Safety
     ///
     /// This will panic if the index is out of range.
-    pub fn set_at(&mut self, index: usize, value: impl crate::AsBStr) -> Result<(), crate::parse::span::Error> {
+    pub fn set_at(&mut self, index: usize, value: impl crate::AsBStr) -> ExnMessageResult {
         let EntryData {
             section_id,
             offset_index,
@@ -130,7 +133,7 @@ impl MultiValueMut<'_> {
     /// remaining values are ignored.
     ///
     /// [`zip`]: std::iter::Iterator::zip
-    pub fn set_values<Iter, Item>(&mut self, values: Iter) -> Result<(), crate::parse::span::Error>
+    pub fn set_values<Iter, Item>(&mut self, values: Iter) -> ExnMessageResult
     where
         Iter: IntoIterator<Item = Item>,
         Item: crate::AsBStr,
@@ -158,7 +161,7 @@ impl MultiValueMut<'_> {
 
     /// Sets all values in this multivar to the provided one without owning the
     /// provided input.
-    pub fn set_all(&mut self, input: impl crate::AsBStr) -> Result<(), crate::parse::span::Error> {
+    pub fn set_all(&mut self, input: impl crate::AsBStr) -> ExnMessageResult {
         let input = input.as_bstr();
         for EntryData {
             section_id,
@@ -186,7 +189,7 @@ impl MultiValueMut<'_> {
         section_id: SectionId,
         offset_index: usize,
         value: &BStr,
-    ) -> Result<(), crate::parse::span::Error> {
+    ) -> ExnMessageResult {
         let (offset, size) = MultiValueMut::index_and_size(offsets, section_id, offset_index);
         let whitespace = Whitespace::from_body(section, backing);
         let value = crate::parse::Span::append(backing, &escape_value(value))?;
diff --git a/gix-config/src/file/mutable/section.rs b/gix-config/src/file/mutable/section.rs
index 3f8ba026f0f..a8f1fc87a2b 100644
--- a/gix-config/src/file/mutable/section.rs
+++ b/gix-config/src/file/mutable/section.rs
@@ -1,5 +1,8 @@
+use gix_error::ExnMessageResult;
 use std::{collections::HashMap, ops::Range};
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, BString, ByteSlice, ByteVec};
 use gix_sec::Trust;
 use smallvec::SmallVec;
@@ -42,7 +45,7 @@ impl SectionMut<'_> {
         &mut self,
         name: impl AsRef<str>,
         subsection_name: impl IntoBStringOpt,
-    ) -> Result<&mut Self, parse::section::header::Error> {
+    ) -> ExnMessageResult<&mut Self> {
         let header = parse::section::HeaderData::new_in(name, subsection_name.into_bstring_opt(), self.backing)?;
         self.set_header(header);
         Ok(self)
@@ -50,11 +53,7 @@ impl SectionMut<'_> {
 
     /// Adds an entry to the end of this section name `value_name` and `value`. If `value` is `None`, no equal sign will be written leaving
     /// just the key. This is useful for boolean values which are true if merely the key exists.
-    pub fn push(
-        &mut self,
-        value_name: impl AsRef<str>,
-        value: impl AsBStrOpt,
-    ) -> Result<&mut Self, file::section::value::Error> {
+    pub fn push(&mut self, value_name: impl AsRef<str>, value: impl AsBStrOpt) -> ExnMessageResult<&mut Self> {
         let value_name = ValueName::try_from(value_name.as_ref())?;
         self.push_with_comment_inner(value_name, value.as_bstr_opt(), None)?;
         Ok(self)
@@ -69,7 +68,7 @@ impl SectionMut<'_> {
         value_name: impl AsRef<str>,
         value: impl AsBStrOpt,
         comment: impl crate::AsBStr,
-    ) -> Result<&mut Self, file::section::value::Error> {
+    ) -> ExnMessageResult<&mut Self> {
         let value_name = ValueName::try_from(value_name.as_ref())?;
         self.push_with_comment_inner(value_name, value.as_bstr_opt(), Some(comment.as_bstr()))?;
         Ok(self)
@@ -80,7 +79,7 @@ impl SectionMut<'_> {
         value_name: ValueName,
         value: Option<&BStr>,
         comment: Option<&BStr>,
-    ) -> Result<(), parse::span::Error> {
+    ) -> ExnMessageResult {
         let mut events = Vec::new();
         if let Some(ws) = &self.whitespace.pre_key {
             events.push(Event::Whitespace(Span::append(self.backing, ws)?));
@@ -169,20 +168,12 @@ impl SectionMut<'_> {
     /// Sets the last key value pair if it exists, or adds the new value.
     /// Returns the previous value if it replaced a value, or None if it adds
     /// the value.
-    pub fn set(
-        &mut self,
-        value_name: impl AsRef<str>,
-        value: impl crate::AsBStr,
-    ) -> Result<Option<BString>, file::section::value::Error> {
+    pub fn set(&mut self, value_name: impl AsRef<str>, value: impl crate::AsBStr) -> ExnMessageResult<Option<BString>> {
         let value_name = ValueName::try_from(value_name.as_ref())?;
-        self.set_inner(value_name, value.as_bstr()).map_err(Into::into)
+        self.set_inner(value_name, value.as_bstr())
     }
 
-    pub(crate) fn set_inner(
-        &mut self,
-        value_name: ValueName,
-        value: &BStr,
-    ) -> Result<Option<BString>, parse::span::Error> {
+    pub(crate) fn set_inner(&mut self, value_name: ValueName, value: &BStr) -> ExnMessageResult<Option<BString>> {
         match self.section.body.key_and_value_range_by_in(self.backing, &value_name) {
             None => {
                 self.push_with_comment_inner(value_name, Some(value), None)?;
@@ -216,7 +207,7 @@ impl SectionMut<'_> {
 
     /// Adds a new line event. Note that you don't need to call this unless
     /// you've disabled implicit newlines.
-    pub fn push_newline(&mut self) -> Result<&mut Self, parse::span::Error> {
+    pub fn push_newline(&mut self) -> ExnMessageResult<&mut Self> {
         let newline = Span::append(self.backing, &self.newline)?;
         self.section.body.0.push(Event::Newline(newline));
         Ok(self)
@@ -394,7 +385,7 @@ impl<'a> SectionMut<'a> {
         }
     }
 
-    pub(crate) fn get(&self, key: &ValueName, start: Index, end: Index) -> Result<BString, lookup::existing::Error> {
+    pub(crate) fn get(&self, key: &ValueName, start: Index, end: Index) -> ExnResult<BString> {
         let mut expect_value = false;
         let mut concatenated_value = BString::default();
 
@@ -419,7 +410,7 @@ impl<'a> SectionMut<'a> {
             }
         }
 
-        Err(lookup::existing::Error::KeyMissing)
+        Err(lookup::existing::key_missing())
     }
 
     pub(crate) fn delete(&mut self, start: Index, end: Index) {
@@ -454,12 +445,7 @@ impl<'a> SectionMut<'a> {
         }
     }
 
-    pub(crate) fn set_internal(
-        &mut self,
-        index: Index,
-        key: ValueName,
-        value: &BStr,
-    ) -> Result<Size, parse::span::Error> {
+    pub(crate) fn set_internal(&mut self, index: Index, key: ValueName, value: &BStr) -> ExnMessageResult<Size> {
         let mut size = 0;
         let value = Span::append(self.backing, &escape_value(value))?;
         let sep_events = self.whitespace.key_value_separators(self.backing)?;
diff --git a/gix-config/src/file/mutable/value.rs b/gix-config/src/file/mutable/value.rs
index 00da62e8b25..20b7e830642 100644
--- a/gix-config/src/file/mutable/value.rs
+++ b/gix-config/src/file/mutable/value.rs
@@ -1,9 +1,10 @@
 use bstr::BString;
+use gix_error::ExnMessageResult;
+use gix_error::ExnResult;
 
 use crate::{
     file,
     file::{Index, Size, mutable::section::SectionMut},
-    lookup,
     parse::section,
 };
 
@@ -19,21 +20,21 @@ pub struct ValueMut<'borrow> {
 impl<'borrow> ValueMut<'borrow> {
     /// Returns the actual value. This is computed each time this is called
     /// requiring an allocation for multi-line values.
-    pub fn get(&self) -> Result<BString, lookup::existing::Error> {
+    pub fn get(&self) -> ExnResult<BString> {
         self.section.get(&self.key, self.index, self.index + self.size)
     }
 
     /// Update the value to the provided one. This modifies the value such that
     /// the Value event(s) are replaced with a single new event containing the
     /// new value.
-    pub fn set_string(&mut self, input: impl AsRef<str>) -> Result<(), crate::parse::span::Error> {
+    pub fn set_string(&mut self, input: impl AsRef<str>) -> ExnMessageResult {
         self.set(input.as_ref())
     }
 
     /// Update the value to the provided one. This modifies the value such that
     /// the Value event(s) are replaced with a single new event containing the
     /// new value.
-    pub fn set(&mut self, input: impl crate::AsBStr) -> Result<(), crate::parse::span::Error> {
+    pub fn set(&mut self, input: impl crate::AsBStr) -> ExnMessageResult {
         let new_size = self
             .section
             .set_internal(self.index, self.key.to_owned(), input.as_bstr())?;
diff --git a/gix-config/src/file/section/body.rs b/gix-config/src/file/section/body.rs
index 8b33aa4014b..01fa4f48981 100644
--- a/gix-config/src/file/section/body.rs
+++ b/gix-config/src/file/section/body.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{borrow::Cow, iter::FusedIterator, ops::Range, slice};
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
@@ -221,16 +222,12 @@ impl BodyData {
         })
     }
 
-    pub(crate) fn copy_to_backing_in(
-        &self,
-        source: &[u8],
-        target: &mut Vec<u8>,
-    ) -> Result<Self, crate::parse::span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Self> {
         Ok(BodyData(
             self.0
                 .iter()
                 .map(|event| event.copy_to_backing_in(source, target))
-                .collect::<Result<_, _>>()?,
+                .collect::<std::result::Result<_, _>>()?,
         ))
     }
 }
diff --git a/gix-config/src/file/section/mod.rs b/gix-config/src/file/section/mod.rs
index a7770c8a3d7..4dc63eacbe3 100644
--- a/gix-config/src/file/section/mod.rs
+++ b/gix-config/src/file/section/mod.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
 use smallvec::SmallVec;
 
 use crate::{
@@ -15,19 +16,6 @@ use gix_features::threading::OwnShared;
 
 use crate::file::{SectionId, write::platform_newline};
 
-/// Errors related to changing values in a section.
-pub mod value {
-    /// The error returned when adding or changing a value in a section.
-    #[derive(Debug, thiserror::Error)]
-    #[allow(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ValueName(#[from] crate::parse::section::value_name::Error),
-        #[error(transparent)]
-        Span(#[from] crate::parse::span::Error),
-    }
-}
-
 impl std::ops::Deref for SectionData {
     type Target = BodyData;
 
@@ -85,11 +73,13 @@ impl<'file> SectionRef<'file> {
 
 impl Section {
     /// Create an owned section with an empty body.
+    /// Invalid section or subsection name bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     pub fn new(
         name: impl AsRef<str>,
         subsection: impl IntoBStringOpt,
         meta: impl Into<OwnShared<file::Metadata>>,
-    ) -> Result<Self, parse::section::header::Error> {
+    ) -> ExnMessageResult<Self> {
         let mut backing = Vec::new();
         let data = SectionData::new(name, subsection.into_bstring_opt(), meta, &mut backing)?;
         Ok(Section { backing, data })
@@ -120,7 +110,7 @@ impl Section {
         Section { backing, data }
     }
 
-    pub(crate) fn into_data(self, target: &mut Vec<u8>) -> Result<SectionData, parse::span::Error> {
+    pub(crate) fn into_data(self, target: &mut Vec<u8>) -> ExnMessageResult<SectionData> {
         self.data.copy_to_backing_in(&self.backing, target)
     }
 }
@@ -132,7 +122,7 @@ impl SectionData {
         subsection: impl Into<Option<BString>>,
         meta: impl Into<OwnShared<file::Metadata>>,
         backing: &mut Vec<u8>,
-    ) -> Result<Self, parse::section::header::Error> {
+    ) -> ExnMessageResult<Self> {
         Ok(SectionData {
             header: parse::section::HeaderData::new_in(name, subsection, backing)?,
             body: Default::default(),
@@ -155,7 +145,7 @@ impl SectionData {
         &self.meta
     }
 
-    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> Result<Self, parse::span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Self> {
         Ok(SectionData {
             header: self.header.copy_to_backing_in(source, target)?,
             body: self.body.copy_to_backing_in(source, target)?,
diff --git a/gix-config/src/file/util.rs b/gix-config/src/file/util.rs
index 4fa0a516250..4a234d16e0f 100644
--- a/gix-config/src/file/util.rs
+++ b/gix-config/src/file/util.rs
@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, BString, ByteSlice};
 
 use crate::{
@@ -62,29 +64,29 @@ impl File {
         &'a self,
         section_name: &'a str,
         subsection_name: Option<&BStr>,
-    ) -> Result<impl ExactSizeIterator<Item = SectionId> + DoubleEndedIterator + 'a, lookup::existing::Error> {
+    ) -> ExnResult<impl ExactSizeIterator<Item = SectionId> + DoubleEndedIterator + 'a> {
         let section_name = section::Name::from_str_unchecked(section_name);
         let lookup = self
             .section_lookup_tree
             .get(&section_name)
-            .ok_or(lookup::existing::Error::SectionMissing)?;
+            .ok_or_else(lookup::existing::section_missing)?;
         match subsection_name {
             Some(name) => lookup.by_subsection.get(name),
             None => (!lookup.without_subsection.is_empty()).then_some(&lookup.without_subsection),
         }
-        .ok_or(lookup::existing::Error::SubSectionMissing)
+        .ok_or_else(lookup::existing::subsection_missing)
         .map(|ids| ids.iter().copied())
     }
 
     pub(crate) fn section_ids_by_name<'a>(
         &'a self,
         section_name: &str,
-    ) -> Result<impl Iterator<Item = SectionId> + 'a + use<'a>, lookup::existing::Error> {
+    ) -> ExnResult<impl Iterator<Item = SectionId> + 'a + use<'a>> {
         let lookup_name = section::Name::from_str_unchecked(section_name);
         let lookup = self
             .section_lookup_tree
             .get(&lookup_name)
-            .ok_or(lookup::existing::Error::SectionMissing)?;
+            .ok_or_else(lookup::existing::section_missing)?;
         let mut ids = Vec::with_capacity(self.section_order.len());
         ids.extend_from_slice(&lookup.without_subsection);
         ids.extend(lookup.by_subsection.values().flatten().copied());
diff --git a/gix-config/src/lookup.rs b/gix-config/src/lookup.rs
index f16d073a39e..f2ba7c738e9 100644
--- a/gix-config/src/lookup.rs
+++ b/gix-config/src/lookup.rs
@@ -1,26 +1,62 @@
 /// The error when looking up a value, for example via [`File::try_value()`][crate::File::try_value()].
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 #[expect(missing_docs)]
 pub enum Error<E> {
-    #[error(transparent)]
-    ValueMissing(#[from] existing::Error),
-    #[error(transparent)]
+    ValueMissing(gix_error::Error),
     FailedConversion(E),
 }
 
+impl<E: Into<gix_error::Error>> Error<E> {
+    /// Convert this lookup error into a standard error, retaining the inner exception's context.
+    pub fn into_error(self) -> gix_error::Error {
+        match self {
+            Error::ValueMissing(err) => err,
+            Error::FailedConversion(err) => err.into(),
+        }
+    }
+}
+
+impl<E: std::fmt::Display> std::fmt::Display for Error<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::ValueMissing(err) => std::fmt::Display::fmt(err, f),
+            Error::FailedConversion(err) => std::fmt::Display::fmt(err, f),
+        }
+    }
+}
+
+impl<E: std::error::Error + 'static> std::error::Error for Error<E> {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::ValueMissing(err) => Some(err),
+            Error::FailedConversion(err) => Some(err),
+        }
+    }
+}
+
+impl<E> From<gix_error::Exn> for Error<E> {
+    fn from(err: gix_error::Exn) -> Self {
+        Error::ValueMissing(err.into_error())
+    }
+}
+
 ///
 pub mod existing {
-    /// The error when looking up a value that doesn't exist, for example via [`File::value()`][crate::File::value()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The requested section does not exist")]
-        SectionMissing,
-        #[error("The requested subsection does not exist")]
-        SubSectionMissing,
-        #[error("The key does not exist in the requested section")]
-        KeyMissing,
-        #[error(transparent)]
-        ValueName(#[from] crate::parse::section::value_name::Error),
+
+    pub(crate) fn section_missing() -> gix_error::Exn {
+        not_found("The requested section does not exist")
+    }
+
+    pub(crate) fn subsection_missing() -> gix_error::Exn {
+        not_found("The requested subsection does not exist")
+    }
+
+    pub(crate) fn key_missing() -> gix_error::Exn {
+        not_found("The key does not exist in the requested section")
+    }
+
+    fn not_found(message: &'static str) -> gix_error::Exn {
+        use gix_error::ErrorExt;
+        gix_error::not_found(message).raise_erased()
     }
 }
diff --git a/gix-config/src/parse/comment.rs b/gix-config/src/parse/comment.rs
index 3f8a26bec15..225f750fd0b 100644
--- a/gix-config/src/parse/comment.rs
+++ b/gix-config/src/parse/comment.rs
@@ -1,11 +1,8 @@
 use crate::parse::Comment;
+use gix_error::ExnMessageResult;
 
 impl Comment {
-    pub(crate) fn copy_to_backing_in(
-        &self,
-        source: &[u8],
-        target: &mut Vec<u8>,
-    ) -> Result<Comment, crate::parse::span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Comment> {
         Ok(Comment {
             tag: self.tag,
             text: self.text.copy_to_backing_in(source, target)?,
diff --git a/gix-config/src/parse/error.rs b/gix-config/src/parse/error.rs
index 611568c39e5..dd2431d2815 100644
--- a/gix-config/src/parse/error.rs
+++ b/gix-config/src/parse/error.rs
@@ -109,4 +109,8 @@ impl Display for Error {
     }
 }
 
-impl std::error::Error for Error {}
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::VALIDATION })
+    }
+}
diff --git a/gix-config/src/parse/event.rs b/gix-config/src/parse/event.rs
index be328595048..4d6fb60e5dd 100644
--- a/gix-config/src/parse/event.rs
+++ b/gix-config/src/parse/event.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::fmt::Display;
 
 use bstr::{BStr, BString};
@@ -6,7 +7,7 @@ use crate::parse::{Event, EventRef};
 
 impl Event {
     /// Shift all backing-buffer spans in this event forward by `offset` bytes.
-    pub(crate) fn rebase(&mut self, offset: usize) -> Result<(), crate::parse::span::Error> {
+    pub(crate) fn rebase(&mut self, offset: usize) -> ExnMessageResult {
         match self {
             Event::Comment(comment) => comment.text.rebase(offset),
             Event::SectionHeader(header) => header.rebase(offset),
@@ -20,11 +21,7 @@ impl Event {
         }
     }
 
-    pub(crate) fn copy_to_backing_in(
-        &self,
-        source: &[u8],
-        target: &mut Vec<u8>,
-    ) -> Result<Event, crate::parse::span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Event> {
         Ok(match self {
             Event::Comment(comment) => Event::Comment(comment.copy_to_backing_in(source, target)?),
             Event::SectionHeader(header) => Event::SectionHeader(header.copy_to_backing_in(source, target)?),
diff --git a/gix-config/src/parse/format.rs b/gix-config/src/parse/format.rs
index 85b0ab0bc6d..a8a89010ca7 100644
--- a/gix-config/src/parse/format.rs
+++ b/gix-config/src/parse/format.rs
@@ -8,6 +8,7 @@
 //! newlines and the `=` separator are rewritten according to [`Options`](crate::parse::format::Options).
 
 use bstr::BString;
+use gix_error::ExnMessageResult;
 
 use crate::parse::{self, EventRef};
 
@@ -76,8 +77,8 @@ impl Default for Options {
 ///
 /// # Errors
 ///
-/// Returns a [`parse::Error`] if `input` is not a syntactically valid git-config file.
-pub fn normalize(input: &[u8], options: &Options) -> Result<BString, parse::Error> {
+/// Returns an error classified as [`gix_error::Class::Validation`] if `input` is not a syntactically valid git-config file.
+pub fn normalize(input: &[u8], options: &Options) -> ExnMessageResult<BString> {
     let parsed = parse::Events::from_bytes(input, None)?;
     let events: Vec<_> = parsed.iter().collect();
     Ok(normalize_events(&events, options))
diff --git a/gix-config/src/parse/from_bytes/mod.rs b/gix-config/src/parse/from_bytes/mod.rs
index a8585bdbe9f..c51e8eb1a2a 100644
--- a/gix-config/src/parse/from_bytes/mod.rs
+++ b/gix-config/src/parse/from_bytes/mod.rs
@@ -39,7 +39,7 @@ pub(crate) fn from_bytes(mut input: &[u8], dispatch: &mut dyn FnMut(Event)) -> R
         } else if !input.starts_with(b"[") {
             let mut node = ParseNode::SectionHeader;
             key_value_pair(backing, &mut input, &mut node, dispatch)
-                .map_err(|_| Error::parse(newlines_from(backing, input), node, input.as_bstr().into()))?;
+                .map_err(|()| Error::parse(newlines_from(backing, input), node, input.as_bstr().into()))?;
         }
         if input.len() == before.len() {
             break;
@@ -53,7 +53,7 @@ pub(crate) fn from_bytes(mut input: &[u8], dispatch: &mut dyn FnMut(Event)) -> R
     let mut node = ParseNode::SectionHeader;
     while !input.is_empty() {
         section(backing, &mut input, &mut node, dispatch)
-            .map_err(|_| Error::parse(newlines_from(backing, input), node, input.as_bstr().into()))?;
+            .map_err(|()| Error::parse(newlines_from(backing, input), node, input.as_bstr().into()))?;
     }
     Ok(())
 }
diff --git a/gix-config/src/parse/from_bytes/tests.rs b/gix-config/src/parse/from_bytes/tests.rs
index 8bf40c48ddc..e43a1f506fb 100644
--- a/gix-config/src/parse/from_bytes/tests.rs
+++ b/gix-config/src/parse/from_bytes/tests.rs
@@ -8,12 +8,10 @@ fn input_size_is_limited_by_span_representation() {
     let err = ensure_supported_input_size(actual).expect_err("inputs above the span limit must be rejected");
     assert_eq!(err.line_number(), 1);
     assert!(err.remaining_data().is_empty());
-    assert_eq!(
-        err.to_string(),
-        format!(
-            "Configuration input is {actual} bytes large, but at most {} bytes are supported",
-            u32::MAX
-        )
+    insta::assert_debug_snapshot!(format_args!("{err}"), "oversized input reports the actual byte count and the supported limit", @"Configuration input is 4294967296 bytes large, but at most 4294967295 bytes are supported");
+    assert!(
+        gix_error::Error::from_error(err).is_validation(),
+        "input outside the parser's supported size range is invalid input"
     );
 }
 
diff --git a/gix-config/src/parse/mod.rs b/gix-config/src/parse/mod.rs
index c6717261de0..0077f687987 100644
--- a/gix-config/src/parse/mod.rs
+++ b/gix-config/src/parse/mod.rs
@@ -11,6 +11,7 @@
 //! [`File`]: crate::File
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
 
 mod from_bytes;
 
@@ -36,10 +37,13 @@ pub(crate) struct Span {
 
 /// Errors produced when a span cannot be represented.
 pub mod span {
-    /// A span offset or length exceeded the supported 32-bit representation.
-    #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, thiserror::Error)]
-    #[error("configuration data exceeds the supported span size of {} bytes", u32::MAX)]
-    pub struct Error;
+
+    pub(crate) fn error() -> gix_error::Message {
+        gix_error::validation(format!(
+            "configuration data exceeds the supported span size of {} bytes",
+            u32::MAX
+        ))
+    }
 }
 
 /// A raw span whose semantic value may have required decoding while parsing.
@@ -74,11 +78,11 @@ impl MaybeDecoded {
             .map_or_else(|| self.raw.as_bstr_in(backing), |value| value.as_bstr())
     }
 
-    pub(crate) fn rebase(&mut self, offset: usize) -> Result<(), span::Error> {
+    pub(crate) fn rebase(&mut self, offset: usize) -> ExnMessageResult {
         self.raw.rebase(offset)
     }
 
-    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> Result<Self, span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Self> {
         Ok(Self {
             raw: self.raw.copy_to_backing_in(source, target)?,
             decoded: self.decoded.clone(),
@@ -87,18 +91,21 @@ impl MaybeDecoded {
 }
 
 impl Span {
-    pub(crate) fn append(backing: &mut Vec<u8>, bytes: &[u8]) -> Result<Self, span::Error> {
+    pub(crate) fn append(backing: &mut Vec<u8>, bytes: &[u8]) -> ExnMessageResult<Self> {
         let start = backing.len();
         let span = Self::range(start, bytes.len())?;
-        backing.len().checked_add(bytes.len()).ok_or(span::Error)?;
+        backing.len().checked_add(bytes.len()).ok_or_else(span::error)?;
         backing.extend_from_slice(bytes);
         Ok(span)
     }
 
-    pub(crate) fn range(start: usize, len: usize) -> Result<Self, span::Error> {
+    pub(crate) fn range(start: usize, len: usize) -> ExnMessageResult<Self> {
+        if start > u32::MAX as usize || len > u32::MAX as usize {
+            return Err(span::error().into());
+        }
         Ok(Span {
-            start: start.try_into().map_err(|_| span::Error)?,
-            len: len.try_into().map_err(|_| span::Error)?,
+            start: start as u32,
+            len: len as u32,
         })
     }
 
@@ -132,15 +139,15 @@ impl Span {
         self.as_slice_in(backing).into()
     }
 
-    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> Result<Self, span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<Self> {
         Span::append(target, self.as_slice_in(source))
     }
 
-    pub(crate) fn rebase(&mut self, offset: usize) -> Result<(), span::Error> {
+    pub(crate) fn rebase(&mut self, offset: usize) -> ExnMessageResult {
         self.start = (self.start as usize)
             .checked_add(offset)
             .and_then(|start| start.try_into().ok())
-            .ok_or(span::Error)?;
+            .ok_or_else(span::error)?;
         Ok(())
     }
 }
@@ -255,6 +262,9 @@ pub(crate) struct Comment {
 /// A parser error reports the one-indexed line number where the parsing error
 /// occurred, as well as the last parser node and the remaining data to be
 /// parsed.
+/// Its source is a classification-only [`gix_error::ClassificationMarker`].
+/// Use [`gix_error::classify()`] or `is_validation()` on [`gix_error::Exn`] and [`gix_error::Error`] to check the
+/// classification. Downcast to this type for parser details.
 #[derive(PartialEq, Debug)]
 pub struct Error {
     kind: error::Kind,
diff --git a/gix-config/src/parse/section/header.rs b/gix-config/src/parse/section/header.rs
index e6629898500..ac5f7e6467b 100644
--- a/gix-config/src/parse/section/header.rs
+++ b/gix-config/src/parse/section/header.rs
@@ -1,25 +1,16 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
 
 use crate::parse::{Span, section::HeaderData};
 
-/// The error returned when creating a section header.
-#[derive(Debug, PartialOrd, PartialEq, Eq, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("section names can only be ascii, '-'")]
-    InvalidName,
-    #[error("sub-section names must not contain newlines or null bytes")]
-    InvalidSubSection,
-    #[error(transparent)]
-    Span(#[from] crate::parse::span::Error),
-}
-
 impl HeaderData {
+    /// Invalid section or subsection name bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     pub(crate) fn new_in(
         name: impl AsRef<str>,
         subsection: impl Into<Option<BString>>,
         backing: &mut Vec<u8>,
-    ) -> Result<HeaderData, Error> {
+    ) -> ExnMessageResult<HeaderData> {
         let name = validated_name(name.as_ref().as_bytes().as_bstr())?;
         let name = Span::append(backing, &name)?;
         let (separator, subsection_name) = match subsection.into() {
@@ -50,21 +41,27 @@ pub fn is_valid_subsection(name: impl crate::AsBStr) -> bool {
     name.as_bstr().find_byteset(b"\n\0").is_none()
 }
 
-fn validated_subsection(name: &BStr) -> Result<BString, Error> {
-    is_valid_subsection(name)
-        .then(|| name.into())
-        .ok_or(Error::InvalidSubSection)
+fn validated_subsection(name: &BStr) -> ExnMessageResult<BString> {
+    is_valid_subsection(name).then(|| name.into()).ok_or_else(|| {
+        gix_error::validation("sub-section names must not contain newlines or null bytes")
+            .with("input", name)
+            .into()
+    })
 }
 
-fn validated_name(name: &BStr) -> Result<BString, Error> {
+fn validated_name(name: &BStr) -> ExnMessageResult<BString> {
     name.iter()
         .all(|b| b.is_ascii_alphanumeric() || *b == b'-')
         .then(|| name.into())
-        .ok_or(Error::InvalidName)
+        .ok_or_else(|| {
+            gix_error::validation("section names can only be ascii, '-'")
+                .with("input", name)
+                .into()
+        })
 }
 
 impl HeaderData {
-    pub(crate) fn rebase(&mut self, offset: usize) -> Result<(), crate::parse::span::Error> {
+    pub(crate) fn rebase(&mut self, offset: usize) -> ExnMessageResult {
         self.name.rebase(offset)?;
         if let Some(separator) = &mut self.separator {
             separator.rebase(offset)?;
@@ -75,11 +72,7 @@ impl HeaderData {
         Ok(())
     }
 
-    pub(crate) fn copy_to_backing_in(
-        &self,
-        source: &[u8],
-        target: &mut Vec<u8>,
-    ) -> Result<HeaderData, crate::parse::span::Error> {
+    pub(crate) fn copy_to_backing_in(&self, source: &[u8], target: &mut Vec<u8>) -> ExnMessageResult<HeaderData> {
         Ok(HeaderData {
             name: self.name.copy_to_backing_in(source, target)?,
             separator: self
diff --git a/gix-config/src/parse/section/mod.rs b/gix-config/src/parse/section/mod.rs
index 0e1d0f68d2f..c9d4222beb0 100644
--- a/gix-config/src/parse/section/mod.rs
+++ b/gix-config/src/parse/section/mod.rs
@@ -23,16 +23,12 @@ mod types {
     use bstr::ByteSlice;
 
     macro_rules! generate_case_insensitive {
-        ($name:ident, $module:ident, $err_doc:literal, $validate:ident, $cow_inner_type:ty, $comment:literal) => {
-            ///
-            pub mod $module {
-                /// The error returned when `TryFrom` is invoked to create an instance.
-                #[derive(Debug, thiserror::Error, Copy, Clone)]
-                #[error($err_doc)]
-                pub struct Error;
-            }
-
+        ($name:ident, $err_doc:literal, $validate:ident, $cow_inner_type:ty, $comment:literal) => {
             #[doc = $comment]
+            ///
+            /// Conversion errors store invalid name bytes as `input` in [`gix_error::Message::values`].
+            /// After [wrapping](gix_error::Error::from_error()), inspect them with
+            /// [metadata](gix_error::Error::metadata()).
             #[derive(Clone, Eq, Debug, Default)]
             pub struct $name(pub(crate) bstr::BString);
 
@@ -82,7 +78,7 @@ mod types {
             }
 
             impl std::convert::TryFrom<&str> for $name {
-                type Error = $module::Error;
+                type Error = gix_error::Message;
 
                 fn try_from(s: &str) -> Result<Self, Self::Error> {
                     Self::try_from(bstr::ByteSlice::as_bstr(s.as_bytes()))
@@ -90,7 +86,7 @@ mod types {
             }
 
             impl std::convert::TryFrom<String> for $name {
-                type Error = $module::Error;
+                type Error = gix_error::Message;
 
                 fn try_from(s: String) -> Result<Self, Self::Error> {
                     Self::try_from(bstr::BString::from(s))
@@ -98,25 +94,25 @@ mod types {
             }
 
             impl std::convert::TryFrom<bstr::BString> for $name {
-                type Error = $module::Error;
+                type Error = gix_error::Message;
 
                 fn try_from(s: bstr::BString) -> Result<Self, Self::Error> {
                     if $validate(s.as_slice().as_bstr()) {
                         Ok(Self(s.into()))
                     } else {
-                        Err($module::Error)
+                        Err(gix_error::validation($err_doc).with("input", s))
                     }
                 }
             }
 
             impl std::convert::TryFrom<&bstr::BStr> for $name {
-                type Error = $module::Error;
+                type Error = gix_error::Message;
 
                 fn try_from(s: &bstr::BStr) -> Result<Self, Self::Error> {
                     if $validate(s) {
                         Ok(Self(s.into()))
                     } else {
-                        Err($module::Error)
+                        Err(gix_error::validation($err_doc).with("input", s))
                     }
                 }
             }
@@ -146,7 +142,6 @@ mod types {
 
     generate_case_insensitive!(
         Name,
-        name,
         "Valid names consist of alphanumeric characters or dashes.",
         is_valid_name,
         bstr::BStr,
@@ -155,15 +150,14 @@ mod types {
 
     generate_case_insensitive!(
         ValueName,
-        value_name,
         "Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character.",
         is_valid_value_name,
         bstr::BStr,
         "Wrapper struct for value names, like `path` in `include.path`, since keys are case-insensitive."
     );
 }
+pub use types::Name;
 pub(crate) use types::ValueName;
-pub use types::{Name, name, value_name};
 
 #[cfg(test)]
 mod tests {
diff --git a/gix-config/src/parse/tests.rs b/gix-config/src/parse/tests.rs
index da8b6702afe..5f08a3abf08 100644
--- a/gix-config/src/parse/tests.rs
+++ b/gix-config/src/parse/tests.rs
@@ -67,7 +67,7 @@ mod span {
         assert!(Span::range(0, u32::MAX as usize + 1).is_err());
 
         let mut span = Span::range(u32::MAX as usize, 0).expect("the maximum offset is representable");
-        assert_eq!(span.rebase(1), Err(crate::parse::span::Error));
+        insta::assert_debug_snapshot!(span.rebase(1).expect_err("rebasing beyond u32 must fail"), "reports range and rebase overflow", @"configuration data exceeds the supported span size of 4294967295 bytes");
     }
 }
 
diff --git a/gix-config/src/value/mod.rs b/gix-config/src/value/mod.rs
index 56d02a94981..61a9857ad4d 100644
--- a/gix-config/src/value/mod.rs
+++ b/gix-config/src/value/mod.rs
@@ -1,4 +1,2 @@
-pub use gix_config_value::Error;
-
 mod normalize;
 pub use normalize::normalize;
diff --git a/gix-config/tests/config/file/access/mutate.rs b/gix-config/tests/config/file/access/mutate.rs
index 2c4b320001c..c9ee4fe6d20 100644
--- a/gix-config/tests/config/file/access/mutate.rs
+++ b/gix-config/tests/config/file/access/mutate.rs
@@ -1,6 +1,8 @@
 mod new_section {
+    use crate::Result;
+
     #[test]
-    fn accepts_a_borrowed_subsection_name() -> crate::Result {
+    fn accepts_a_borrowed_subsection_name() -> Result {
         let mut file = gix_config::File::default();
         file.new_section("remote", "origin")?;
         file.new_section("branch", "main")?;
@@ -15,7 +17,7 @@ mod new_section {
     }
 
     #[test]
-    fn owned_sections_accept_a_borrowed_subsection_name() -> crate::Result {
+    fn owned_sections_accept_a_borrowed_subsection_name() -> Result {
         let section = gix_config::file::Section::new("remote", "origin", gix_config::file::Metadata::default())?;
         assert_eq!(section.to_ref().header().subsection_name(), Some("origin".into()));
         Ok(())
@@ -23,6 +25,8 @@ mod new_section {
 }
 
 mod remove_section {
+    use crate::Result;
+
     #[test]
     fn removal_of_all_sections_programmatically_with_sections_and_ids_by_name() {
         let mut file = gix_config::File::try_from("[core] \na = b\nb=c\n\n[core \"name\"]\nd = 1\ne = 2").unwrap();
@@ -71,7 +75,7 @@ mod remove_section {
     }
 
     #[test]
-    fn removing_lookup_buckets_preserves_siblings_and_drops_the_final_name() -> crate::Result {
+    fn removing_lookup_buckets_preserves_siblings_and_drops_the_final_name() -> Result {
         let mut file = gix_config::File::try_from(
             "[core] key=plain\n\
              [core \"a\"] key=a\n\
@@ -79,28 +83,23 @@ mod remove_section {
         )?;
 
         file.remove_section("core", None).expect("plain section exists");
-        assert!(
-            matches!(
-                file.section("core", None),
-                Err(gix_config::lookup::existing::Error::SubSectionMissing)
-            ),
-            "the `core` section name still exists through its siblings, but its no-subsection bucket was removed"
-        );
+        let err = file.section("core", None).unwrap_err();
+        assert!(err.is_not_found());
+        insta::assert_debug_snapshot!(err, "the `core` section name still exists through its siblings, but its no-subsection bucket was removed", @"The requested subsection does not exist");
         assert_eq!(file.section("core", "a")?.value("key"), Some("a".into()));
 
         file.remove_section("core", "a").expect("first subsection exists");
         assert_eq!(file.section("core", "b")?.value("key"), Some("b".into()));
 
         file.remove_section("core", "b").expect("final subsection exists");
-        assert!(matches!(
-            file.section("core", "b"),
-            Err(gix_config::lookup::existing::Error::SectionMissing)
-        ));
+        let err = file.section("core", "b").unwrap_err();
+        assert!(err.is_not_found());
+        insta::assert_debug_snapshot!(err, "removing lookup buckets preserves siblings and drops the final name", @"The requested section does not exist");
         Ok(())
     }
 
     #[test]
-    fn removed_sections_can_be_mutated_and_reinserted() -> crate::Result {
+    fn removed_sections_can_be_mutated_and_reinserted() -> Result {
         let mut file = gix_config::File::try_from("[core]\na = b\n")?;
         let mut section = file.remove_section("core", None).expect("section is present");
         let removed_id = section.to_ref().id();
@@ -145,26 +144,22 @@ mod remove_section_filter {
 }
 
 mod rename_section {
-    use gix_config::{file::rename_section, parse::section};
+    use crate::Result;
 
     #[test]
     fn section_renaming_validates_new_name() {
         let mut file = gix_config::File::try_from("[core] a = b").unwrap();
-        assert!(matches!(
-            file.rename_section("core", None, "new_core", None),
-            Err(rename_section::Error::Section(section::header::Error::InvalidName))
-        ));
-
-        assert!(matches!(
-            file.rename_section("core", None, "new-core", "a\nb"),
-            Err(rename_section::Error::Section(
-                section::header::Error::InvalidSubSection
-            ))
-        ));
+        let err = file.rename_section("core", None, "new_core", None).unwrap_err();
+        assert!(err.is_validation());
+        insta::assert_debug_snapshot!(err, "section renaming validates new name", @r#"section names can only be ascii, '-', "input"="new_core""#);
+
+        let err = file.rename_section("core", None, "new-core", "a\nb").unwrap_err();
+        assert!(err.is_validation());
+        insta::assert_debug_snapshot!(err, "section renaming validates new name", @r#"sub-section names must not contain newlines or null bytes, "input"="a\nb""#);
     }
 
     #[test]
-    fn accepts_borrowed_new_subsection_names() -> crate::Result {
+    fn accepts_borrowed_new_subsection_names() -> Result {
         let mut file = gix_config::File::try_from("[core] a = b")?;
         file.rename_section("core", None, "remote", "origin")?;
         assert_eq!(
@@ -182,7 +177,7 @@ mod rename_section {
     }
 
     #[test]
-    fn all_matching_sections_are_renamed_and_target_collisions_are_preserved() -> crate::Result {
+    fn all_matching_sections_are_renamed_and_target_collisions_are_preserved() -> Result {
         let mut file = gix_config::File::try_from(
             "[branch \"source\"] key = one\n\
              [some \"gar\"] key = unrelated\n\
@@ -206,7 +201,7 @@ mod rename_section {
     }
 
     #[test]
-    fn filter_renames_every_accepted_section() -> crate::Result {
+    fn filter_renames_every_accepted_section() -> Result {
         let mut file = gix_config::File::try_from(
             "[branch \"source\"] key = one\n\
              [branch \"source\"] key = two\n\
@@ -238,15 +233,11 @@ mod rename_section {
         "#);
 
         let prev = file.to_string();
-        assert!(
-            matches!(
-                file.rename_section_filter("branch", "source", "branch", "other", |_| false),
-                Err(rename_section::Error::Lookup(
-                    gix_config::lookup::existing::Error::KeyMissing
-                )),
-            ),
-            "matching nothing causes an error"
-        );
+        let err = file
+            .rename_section_filter("branch", "source", "branch", "other", |_| false)
+            .unwrap_err();
+        assert!(err.is_not_found());
+        insta::assert_debug_snapshot!(err, "matching nothing causes an error", @"The key does not exist in the requested section");
         assert_eq!(
             file.to_string(),
             prev,
@@ -256,7 +247,7 @@ mod rename_section {
     }
 
     #[test]
-    fn renaming_to_the_same_identity_updates_all_headers() -> crate::Result {
+    fn renaming_to_the_same_identity_updates_all_headers() -> Result {
         let mut file = gix_config::File::try_from(
             "[branch.source] one = 1\n\
              [branch.source] two = 2\n",
@@ -272,23 +263,21 @@ mod rename_section {
     }
 
     #[test]
-    fn an_empty_lookup_bucket_is_reported_as_missing() -> crate::Result {
+    fn an_empty_lookup_bucket_is_reported_as_missing() -> Result {
         let mut file = gix_config::File::try_from("[core] key = value\n")?;
         file.remove_section("core", None).expect("section exists");
-        assert!(matches!(
-            file.rename_section("core", None, "other", None),
-            Err(rename_section::Error::Lookup(
-                gix_config::lookup::existing::Error::SectionMissing
-            ))
-        ));
+        let err = file.rename_section("core", None, "other", None).unwrap_err();
+        assert!(err.is_not_found());
+        insta::assert_debug_snapshot!(err, "an empty lookup bucket is reported as missing", @"The requested section does not exist");
         Ok(())
     }
 }
 mod set_meta {
+    use crate::Result;
     use gix_config::file;
 
     #[test]
-    fn affects_newly_added_sections() -> crate::Result {
+    fn affects_newly_added_sections() -> Result {
         let mut file = gix_config::File::default();
         let expected = &file::Metadata::api();
         assert_eq!(file.meta(), expected);
diff --git a/gix-config/tests/config/file/access/raw/raw_multi_value.rs b/gix-config/tests/config/file/access/raw/raw_multi_value.rs
index b8c1fcaf2ab..dca64d1c664 100644
--- a/gix-config/tests/config/file/access/raw/raw_multi_value.rs
+++ b/gix-config/tests/config/file/access/raw/raw_multi_value.rs
@@ -1,23 +1,24 @@
-use gix_config::{File, lookup};
+use crate::Result;
+use gix_config::File;
 
 use crate::file::bstring;
 
 #[test]
-fn single_value_is_identical_to_single_value_query() -> crate::Result {
+fn single_value_is_identical_to_single_value_query() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
     assert_eq!(vec![config.raw_value("core.a")?], config.raw_values("core.a")?);
     Ok(())
 }
 
 #[test]
-fn multi_value_in_section() -> crate::Result {
+fn multi_value_in_section() -> Result {
     let config = File::try_from("[core]\na=b\na=c")?;
     assert_eq!(config.raw_values("core.a")?, vec![bstring("b"), bstring("c")]);
     Ok(())
 }
 
 #[test]
-fn multi_value_across_sections() -> crate::Result {
+fn multi_value_across_sections() -> Result {
     let config = File::try_from(
         "[core]\n\
          a=b\n\
@@ -32,7 +33,7 @@ fn multi_value_across_sections() -> crate::Result {
 }
 
 #[test]
-fn values_with_sections_identify_each_values_section_in_file_order() -> crate::Result {
+fn values_with_sections_identify_each_values_section_in_file_order() -> Result {
     let config = File::try_from(
         "[core]\n\
          a=b\n\
@@ -61,7 +62,7 @@ fn values_with_sections_identify_each_values_section_in_file_order() -> crate::R
 }
 
 #[test]
-fn values_with_sections_filter_returns_values_from_accepted_sections() -> crate::Result {
+fn values_with_sections_filter_returns_values_from_accepted_sections() -> Result {
     let config = File::try_from(
         "[core]\n\
          a=b\n\
@@ -92,37 +93,34 @@ fn values_with_sections_filter_returns_values_from_accepted_sections() -> crate:
 }
 
 #[test]
-fn section_not_found() -> crate::Result {
+fn section_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_values("foo.a"),
-        Err(lookup::existing::Error::SectionMissing)
-    ));
+    let err = config.raw_values("foo.a").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "section not found", @"The requested section does not exist");
     Ok(())
 }
 
 #[test]
-fn subsection_not_found() -> crate::Result {
+fn subsection_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_values("core.a.a"),
-        Err(lookup::existing::Error::SubSectionMissing)
-    ));
+    let err = config.raw_values("core.a.a").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "subsection not found", @"The requested subsection does not exist");
     Ok(())
 }
 
 #[test]
-fn key_not_found() -> crate::Result {
+fn key_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_values("core.aaaaaa"),
-        Err(lookup::existing::Error::KeyMissing)
-    ));
+    let err = config.raw_values("core.aaaaaa").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "key not found", @"The key does not exist in the requested section");
     Ok(())
 }
 
 #[test]
-fn subsection_must_be_respected() -> crate::Result {
+fn subsection_must_be_respected() -> Result {
     let config = File::try_from("[core]a=b\n[core.a]a=c")?;
     assert_eq!(config.raw_values("core.a")?, vec![bstring("b")]);
     assert_eq!(config.raw_values("core.a.a")?, vec![bstring("c")]);
@@ -130,7 +128,7 @@ fn subsection_must_be_respected() -> crate::Result {
 }
 
 #[test]
-fn non_relevant_subsection_is_ignored() -> crate::Result {
+fn non_relevant_subsection_is_ignored() -> Result {
     let config = File::try_from("[core]\na=b\na=c\n[core]a=d\n[core]g=g")?;
     assert_eq!(
         config.raw_values("core.a")?,
diff --git a/gix-config/tests/config/file/access/raw/raw_value.rs b/gix-config/tests/config/file/access/raw/raw_value.rs
index df76bd10fe4..d3520902b3d 100644
--- a/gix-config/tests/config/file/access/raw/raw_value.rs
+++ b/gix-config/tests/config/file/access/raw/raw_value.rs
@@ -1,7 +1,8 @@
-use gix_config::{File, lookup};
+use crate::Result;
+use gix_config::File;
 
 #[test]
-fn single_section() -> crate::Result {
+fn single_section() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
     assert_eq!(config.raw_value("core.a")?, "b");
     assert_eq!(config.raw_value_by("core", None, "c")?, "d");
@@ -9,32 +10,28 @@ fn single_section() -> crate::Result {
 }
 
 #[test]
-fn global_property_uses_empty_section_name() -> crate::Result {
+fn global_property_uses_empty_section_name() -> Result {
     let config = File::try_from("a=b\n[core]\na=c")?;
-    assert_eq!(
-        config.raw_value_by("", None, "a").unwrap_err().to_string(),
-        "The requested section does not exist",
-        "these are not readable because the supporting this adds a lot of complexity"
-    );
+    insta::assert_debug_snapshot!(config.raw_value_by("", None, "a").expect_err("these are not readable because the supporting this adds a lot of complexity"), "these are not readable because the supporting this adds a lot of complexity", @"The requested section does not exist");
     Ok(())
 }
 
 #[test]
-fn last_one_wins_respected_in_section() -> crate::Result {
+fn last_one_wins_respected_in_section() -> Result {
     let config = File::try_from("[core]\na=b\na=d")?;
     assert_eq!(config.raw_value("core.a")?, "d");
     Ok(())
 }
 
 #[test]
-fn last_one_wins_respected_across_section() -> crate::Result {
+fn last_one_wins_respected_across_section() -> Result {
     let config = File::try_from("[core]\na=b\n[core]\na=d")?;
     assert_eq!(config.raw_value("core.a")?, "d");
     Ok(())
 }
 
 #[test]
-fn value_with_section_identifies_the_section_containing_the_resolved_value() -> crate::Result {
+fn value_with_section_identifies_the_section_containing_the_resolved_value() -> Result {
     let config = File::try_from(
         "[core]\n\
          a=first\n\
@@ -54,7 +51,7 @@ fn value_with_section_identifies_the_section_containing_the_resolved_value() ->
 }
 
 #[test]
-fn value_with_section_filter_identifies_the_section_containing_the_resolved_value() -> crate::Result {
+fn value_with_section_filter_identifies_the_section_containing_the_resolved_value() -> Result {
     let config = File::try_from(
         "[core]\n\
          a=first\n\
@@ -76,7 +73,7 @@ fn value_with_section_filter_identifies_the_section_containing_the_resolved_valu
 }
 
 #[test]
-fn mutable_value_filters_have_key_and_component_variants() -> crate::Result {
+fn mutable_value_filters_have_key_and_component_variants() -> Result {
     let mut config = File::try_from(
         "[core]\n\
          a=first\n\
@@ -113,51 +110,46 @@ fn mutable_value_filters_have_key_and_component_variants() -> crate::Result {
 }
 
 #[test]
-fn section_not_found() -> crate::Result {
+fn section_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_value("foo.a"),
-        Err(lookup::existing::Error::SectionMissing)
-    ));
+    let err = config.raw_value("foo.a").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "section not found", @"The requested section does not exist");
     Ok(())
 }
 
 #[test]
-fn subsection_not_found() -> crate::Result {
+fn subsection_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_value("core.a.a"),
-        Err(lookup::existing::Error::SubSectionMissing)
-    ));
+    let err = config.raw_value("core.a.a").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "subsection not found", @"The requested subsection does not exist");
     Ok(())
 }
 
 #[test]
-fn key_not_found() -> crate::Result {
+fn key_not_found() -> Result {
     let config = File::try_from("[core]\na=b\nc=d")?;
-    assert!(matches!(
-        config.raw_value("core.aaaaaa"),
-        Err(lookup::existing::Error::KeyMissing)
-    ));
+    let err = config.raw_value("core.aaaaaa").unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "key not found", @"The key does not exist in the requested section");
     Ok(())
 }
 
 #[test]
-fn invalid_value_names_are_reported_by_mutable_lookups() -> crate::Result {
+fn invalid_value_names_are_reported_by_mutable_lookups() -> Result {
     let mut config = File::try_from("[core]\na=b")?;
-    assert!(matches!(
-        config.raw_value_mut_by("core", None, "1invalid"),
-        Err(lookup::existing::Error::ValueName(_))
-    ));
-    assert!(matches!(
-        config.raw_values_mut_by("core", None, "contains.dot"),
-        Err(lookup::existing::Error::ValueName(_))
-    ));
+    let err = config.raw_value_mut_by("core", None, "1invalid").unwrap_err();
+    assert!(err.is_validation());
+    insta::assert_debug_snapshot!(err, "invalid value names are reported by mutable lookups", @r#"Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character., "input"="1invalid""#);
+    let err = config.raw_values_mut_by("core", None, "contains.dot").unwrap_err();
+    assert!(err.is_validation());
+    insta::assert_debug_snapshot!(err, "invalid value names are reported by mutable lookups", @r#"Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character., "input"="contains.dot""#);
     Ok(())
 }
 
 #[test]
-fn subsection_must_be_respected() -> crate::Result {
+fn subsection_must_be_respected() -> Result {
     let config = File::try_from("[core]a=b\n[core.a]a=c")?;
     assert_eq!(config.raw_value("core.a")?, "b");
     assert_eq!(config.raw_value("core.a.a")?, "c");
diff --git a/gix-config/tests/config/file/access/raw/set_existing_raw_value.rs b/gix-config/tests/config/file/access/raw/set_existing_raw_value.rs
index 02c53ebbea5..792cd2a1c2c 100644
--- a/gix-config/tests/config/file/access/raw/set_existing_raw_value.rs
+++ b/gix-config/tests/config/file/access/raw/set_existing_raw_value.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+
 fn file(input: &str) -> gix_config::File {
     input.parse().unwrap()
 }
@@ -23,14 +25,10 @@ fn single_line() {
 }
 
 #[test]
-fn global_property_uses_empty_section_name() -> crate::Result {
+fn global_property_uses_empty_section_name() -> Result {
     let mut file = file("a=b\n[core]\na=c");
     let err = file.set_existing_raw_value_by("", None, "a", "d").unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "The requested section does not exist",
-        "cannot set global values"
-    );
+    insta::assert_debug_snapshot!(err, "cannot set global values", @"The requested section does not exist");
     Ok(())
 }
 
diff --git a/gix-config/tests/config/file/access/raw/set_raw_value.rs b/gix-config/tests/config/file/access/raw/set_raw_value.rs
index 7bcf9820ca0..ba8b523eb84 100644
--- a/gix-config/tests/config/file/access/raw/set_raw_value.rs
+++ b/gix-config/tests/config/file/access/raw/set_raw_value.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+
 fn file(input: &str) -> gix_config::File {
     input.parse().unwrap()
 }
@@ -51,7 +53,7 @@ fn comment_included() {
 }
 
 #[test]
-fn non_existing_values_cannot_be_set() -> crate::Result {
+fn non_existing_values_cannot_be_set() -> Result {
     let mut file = gix_config::File::default();
     file.set_raw_value_by("new", None, "key", "value")?;
     file.set_raw_value_by("new", "subsection", "key", "subsection-value")?;
@@ -66,7 +68,7 @@ fn non_existing_values_cannot_be_set() -> crate::Result {
 }
 
 #[test]
-fn accepts_short_lived_keys() -> crate::Result {
+fn accepts_short_lived_keys() -> Result {
     let mut file = gix_config::File::default();
     let key = String::from("new.key");
 
@@ -79,9 +81,8 @@ fn accepts_short_lived_keys() -> crate::Result {
 #[test]
 fn invalid_value_names_fail_without_creating_a_section() {
     let mut file = gix_config::File::default();
-    assert!(matches!(
-        file.set_raw_value_by("new", None, "not.valid", "value"),
-        Err(gix_config::file::set_raw_value::Error::ValueName(_))
-    ));
+    let err = file.set_raw_value_by("new", None, "not.valid", "value").unwrap_err();
+    assert!(err.is_validation());
+    insta::assert_debug_snapshot!(err, "invalid value names fail without creating a section", @r#"Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character., "input"="not.valid""#);
     assert_eq!(file.sections().count(), 0, "validation precedes section creation");
 }
diff --git a/gix-config/tests/config/file/access/read_only.rs b/gix-config/tests/config/file/access/read_only.rs
index 4bd3fabd4c1..ff81f13600e 100644
--- a/gix-config/tests/config/file/access/read_only.rs
+++ b/gix-config/tests/config/file/access/read_only.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::fs;
 
 use bstr::{BString, ByteSlice};
@@ -9,8 +10,53 @@ use gix_config::{
 
 use crate::file::bstring;
 
+fn lookup_error(err: gix_config::lookup::Error<gix_error::Exn<gix_error::Message>>) -> gix_error::Error {
+    err.into_error()
+}
+
+#[test]
+fn typed_lookup_errors_can_be_erased() -> Result {
+    let mut error_snapshots = Vec::new();
+    use gix_error::ResultExt;
+
+    let config = File::try_from("[core]\nvalue = invalid\n")?;
+    for result in [
+        config.value::<Boolean>("core.value").map(|_| ()),
+        config.value::<Integer>("core.value").map(|_| ()),
+        config.value::<Color>("core.value").map(|_| ()),
+        config.values::<Boolean>("core.value").map(|_| ()),
+        config.values::<Integer>("core.value").map(|_| ()),
+        config.values::<Color>("core.value").map(|_| ()),
+    ] {
+        let err = result
+            .map_err(gix_config::lookup::Error::into_error)
+            .or_erased()
+            .expect_err("invalid typed values must fail conversion")
+            .into_error();
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "erasure retains the conversion error");
+    }
+    let err = config
+        .value::<Boolean>("core.missing")
+        .expect_err("the key does not exist")
+        .into_error();
+    insta::assert_debug_snapshot!(err, "erasure retains missing-value classification", @"The key does not exist in the requested section");
+    assert!(err.is_not_found(), "erasure retains missing-value classification");
+    insta::assert_debug_snapshot!(error_snapshots, "typed lookup errors can be erased", @r#"
+    [
+        Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid",
+        Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G, "input"="invalid",
+        Colors are specific color values and their attributes, like 'brightred', or 'blue', "input"="invalid",
+        Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid",
+        Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G, "input"="invalid",
+        Colors are specific color values and their attributes, like 'brightred', or 'blue', "input"="invalid",
+    ]
+    "#);
+    Ok(())
+}
+
 #[test]
-fn parsed_section_header_legacy_check_uses_backing_buffer() -> crate::Result {
+fn parsed_section_header_legacy_check_uses_backing_buffer() -> Result {
     let config = File::try_from(
         "[remote.origin]\n\turl = https://example.com\n[remote \"upstream\"]\n\turl = https://example.com\n",
     )?;
@@ -24,7 +70,7 @@ fn parsed_section_header_legacy_check_uses_backing_buffer() -> crate::Result {
 
 /// Asserts we can cast into all variants of our type
 #[test]
-fn get_value_for_all_provided_values() -> crate::Result {
+fn get_value_for_all_provided_values() -> Result {
     let config = r#"
         [core]
             other-quoted = "hello"
@@ -53,7 +99,7 @@ fn get_value_for_all_provided_values() -> crate::Result {
             },
         )?;
 
-        assert!(!config.value::<Boolean>("core.bool-explicit")?.0);
+        assert!(!config.value::<Boolean>("core.bool-explicit").map_err(lookup_error)?.0);
         assert!(!config.boolean("core.bool-explicit")?.expect("exists"));
         assert!(!config.boolean("core.bool-explicit")?.expect("exists"));
 
@@ -105,7 +151,9 @@ fn get_value_for_all_provided_values() -> crate::Result {
         assert_eq!(config.string("doesn't.exist"), None);
 
         assert_eq!(
-            config.value::<Integer>("core.integer-no-prefix")?,
+            config
+                .value::<Integer>("core.integer-no-prefix")
+                .map_err(lookup_error)?,
             Integer {
                 value: 10,
                 suffix: None
@@ -113,7 +161,9 @@ fn get_value_for_all_provided_values() -> crate::Result {
         );
 
         assert_eq!(
-            config.value::<Integer>("core.integer-no-prefix")?,
+            config
+                .value::<Integer>("core.integer-no-prefix")
+                .map_err(lookup_error)?,
             Integer {
                 value: 10,
                 suffix: None
@@ -121,7 +171,7 @@ fn get_value_for_all_provided_values() -> crate::Result {
         );
 
         assert_eq!(
-            config.value::<Integer>("core.integer-prefix")?,
+            config.value::<Integer>("core.integer-prefix").map_err(lookup_error)?,
             Integer {
                 value: 10,
                 suffix: Some(integer::Suffix::Gibi),
@@ -129,7 +179,7 @@ fn get_value_for_all_provided_values() -> crate::Result {
         );
 
         assert_eq!(
-            config.value::<Color>("core.color")?,
+            config.value::<Color>("core.color").map_err(lookup_error)?,
             Color {
                 foreground: Some(color::Name::BrightGreen),
                 background: Some(color::Name::Red),
@@ -188,7 +238,7 @@ fn get_value_for_all_provided_values() -> crate::Result {
 }
 
 #[test]
-fn get_value_looks_up_all_sections_before_failing() -> crate::Result {
+fn get_value_looks_up_all_sections_before_failing() -> Result {
     let config = r#"
         [core]
             bool-explicit = false
@@ -201,7 +251,7 @@ fn get_value_looks_up_all_sections_before_failing() -> crate::Result {
 
     // Checks that we check the last entry first still
     assert!(
-        !file.value::<Boolean>("core.bool-implicit")?.0,
+        !file.value::<Boolean>("core.bool-implicit").map_err(lookup_error)?.0,
         "implicit bool is invisible to `value` and boolean is the only value we want. Would have to special case it."
     );
     assert!(
@@ -210,7 +260,7 @@ fn get_value_looks_up_all_sections_before_failing() -> crate::Result {
     );
 
     assert!(
-        !file.value::<Boolean>("core.bool-explicit")?.0,
+        !file.value::<Boolean>("core.bool-explicit").map_err(lookup_error)?.0,
         "explicit values always work"
     );
 
@@ -218,7 +268,7 @@ fn get_value_looks_up_all_sections_before_failing() -> crate::Result {
 }
 
 #[test]
-fn interpreted_values_can_be_returned_with_their_sections() -> crate::Result {
+fn interpreted_values_can_be_returned_with_their_sections() -> Result {
     let file = File::try_from(
         "[core]\n\
          a=1\n\
@@ -228,52 +278,59 @@ fn interpreted_values_can_be_returned_with_their_sections() -> crate::Result {
     )?;
     let section_ids: Vec<_> = file.sections().map(|section| section.id()).collect();
 
-    let (value, section) = file.value_with_section::<Integer>("core.a")?;
+    let (value, section) = file.value_with_section::<Integer>("core.a").map_err(lookup_error)?;
     assert_eq!(value.value, 3);
     assert_eq!(section.id(), section_ids[1]);
 
-    let values = file.values_with_sections::<Integer>("core.a")?;
+    let values = file.values_with_sections::<Integer>("core.a").map_err(lookup_error)?;
     let actual: Vec<_> = values
         .into_iter()
         .map(|(value, section)| (value.value, section.id()))
         .collect();
     assert_eq!(actual, [(1, section_ids[0]), (2, section_ids[0]), (3, section_ids[1])]);
 
-    let (value, section) = file.value_with_section_by::<Integer>("core", None, "a")?;
+    let (value, section) = file
+        .value_with_section_by::<Integer>("core", None, "a")
+        .map_err(lookup_error)?;
     assert_eq!((value.value, section.id()), (3, section_ids[1]));
-    assert_eq!(file.values_with_sections_by::<Integer>("core", None, "a")?.len(), 3);
+    assert_eq!(
+        file.values_with_sections_by::<Integer>("core", None, "a")
+            .map_err(lookup_error)?
+            .len(),
+        3
+    );
     Ok(())
 }
 
 #[test]
-fn section_names_are_case_insensitive() -> crate::Result {
+fn section_names_are_case_insensitive() -> Result {
     let config = "[core] a=true";
     let file = File::try_from(config)?;
     assert_eq!(
-        file.value::<Boolean>("core.a").unwrap(),
-        file.value::<Boolean>("CORE.a").unwrap()
+        file.value::<Boolean>("core.a").map_err(lookup_error)?,
+        file.value::<Boolean>("CORE.a").map_err(lookup_error)?
     );
 
     Ok(())
 }
 
 #[test]
-fn value_names_are_case_insensitive() -> crate::Result {
+fn value_names_are_case_insensitive() -> Result {
     let config = "[core]
         a = true
         A = false";
     let file = File::try_from(config)?;
-    assert_eq!(file.values::<Boolean>("core.a")?.len(), 2);
+    assert_eq!(file.values::<Boolean>("core.a").map_err(lookup_error)?.len(), 2);
     assert_eq!(
-        file.value::<Boolean>("core.a").unwrap(),
-        file.value::<Boolean>("core.A").unwrap()
+        file.value::<Boolean>("core.a").map_err(lookup_error)?,
+        file.value::<Boolean>("core.A").map_err(lookup_error)?
     );
 
     Ok(())
 }
 
 #[test]
-fn section_value_access_is_case_insensitive() -> crate::Result {
+fn section_value_access_is_case_insensitive() -> Result {
     let file = File::try_from("[core]\nMixedCase = one\nMIXEDCASE = two")?;
     let section = file.section("core", None)?;
 
@@ -301,7 +358,7 @@ fn single_section() {
 }
 
 #[test]
-fn sections_by_name() -> crate::Result {
+fn sections_by_name() -> Result {
     let config = r#"
     [core]
         repositoryformatversion = 0
@@ -320,7 +377,7 @@ fn sections_by_name() -> crate::Result {
 }
 
 #[test]
-fn sections_by_name_ignores_subsections_and_preserves_file_order() -> crate::Result {
+fn sections_by_name_ignores_subsections_and_preserves_file_order() -> Result {
     let config = File::try_from(
         "[remote] marker=plain\n\
          [other] marker=unrelated\n\
@@ -348,22 +405,20 @@ fn sections_by_name_ignores_subsections_and_preserves_file_order() -> crate::Res
 }
 
 #[test]
-fn unknown_section() -> crate::Result {
+fn unknown_section() -> Result {
     let config = File::default();
-    assert!(matches!(
-        config.section("missing", None).unwrap_err(),
-        gix_config::lookup::existing::Error::SectionMissing
-    ));
+    let err = config.section("missing", None).unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "unknown section", @"The requested section does not exist");
 
     let config = r#"
     [present]
         key = false
     "#;
     let mut config = File::try_from(config)?;
-    assert!(matches!(
-        config.section("present", Some("subsection".into())).unwrap_err(),
-        gix_config::lookup::existing::Error::SubSectionMissing
-    ));
+    let err = config.section("present", Some("subsection".into())).unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "unknown section", @"The requested subsection does not exist");
 
     config.set_raw_value_by("present", "subsection", "key", "value")?;
     assert!(config.section("present", Some("subsection".into())).is_ok());
@@ -374,10 +429,9 @@ fn unknown_section() -> crate::Result {
     for id in config.sections_and_ids().map(|(_, id)| id).collect::<Vec<_>>() {
         assert!(config.remove_section_by_id(id).is_some());
     }
-    assert!(matches!(
-        config.section("present", None).unwrap_err(),
-        gix_config::lookup::existing::Error::SectionMissing
-    ));
+    let err = config.section("present", None).unwrap_err();
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(err, "unknown section", @"The requested section does not exist");
 
     Ok(())
 }
@@ -487,7 +541,7 @@ fn multi_line_value_with_empty_continuation_line() {
 }
 
 #[test]
-fn multi_line_value_starting_on_a_continuation_line_is_not_indented() -> crate::Result {
+fn multi_line_value_starting_on_a_continuation_line_is_not_indented() -> Result {
     let baseline = crate::scripted_fixture_read_only("make_value_whitespace_baseline.sh")?;
     let baseline = fs::read(baseline.join("baseline.git"))?;
     let baseline = baseline
@@ -522,12 +576,16 @@ fn overrides_with_implicit_booleans_work_in_single_section() {
             b = false
             b
         "#;
-    let config = File::try_from(config).unwrap();
-    assert_eq!(config.boolean("a.b"), Ok(Some(true)), "empty implicit booleans ");
+    let config = File::try_from(config).expect("valid config");
+    assert_eq!(
+        config.boolean("a.b").expect("valid boolean"),
+        Some(true),
+        "empty implicit booleans "
+    );
 }
 
 #[test]
-fn implicit_booleans_may_be_followed_by_whitespace() -> crate::Result {
+fn implicit_booleans_may_be_followed_by_whitespace() -> Result {
     for config in [
         "[a]\n\tb \n",
         "[a]\n\tb\t\n",
@@ -539,8 +597,8 @@ fn implicit_booleans_may_be_followed_by_whitespace() -> crate::Result {
     ] {
         let file = File::try_from(config)?;
         assert_eq!(
-            file.boolean("a.b"),
-            Ok(Some(true)),
+            file.boolean("a.b")?,
+            Some(true),
             "Git sees no separator in {config:?}, so the value is an implicit boolean and thus true"
         );
         assert_eq!(
@@ -553,8 +611,8 @@ fn implicit_booleans_may_be_followed_by_whitespace() -> crate::Result {
     for config in ["[a]\n\tb =\n", "[a]\n\tb = \n", "[a]\n\tb=\"\"\n", "[a]\n\tb ="] {
         let file = File::try_from(config)?;
         assert_eq!(
-            file.boolean("a.b"),
-            Ok(Some(false)),
+            file.boolean("a.b")?,
+            Some(false),
             "a separator in {config:?} makes the value explicitly empty, and an empty value is false"
         );
         assert_eq!(
@@ -575,6 +633,10 @@ fn overrides_with_implicit_booleans_work_across_sections() {
         [a]
             b
         "#;
-    let config = File::try_from(config).unwrap();
-    assert_eq!(config.boolean("a.b"), Ok(Some(true)), "empty implicit booleans ");
+    let config = File::try_from(config).expect("valid config");
+    assert_eq!(
+        config.boolean("a.b").expect("valid boolean"),
+        Some(true),
+        "empty implicit booleans "
+    );
 }
diff --git a/gix-config/tests/config/file/impls.rs b/gix-config/tests/config/file/impls.rs
index dddc5ba9d2d..fdc101e46bd 100644
--- a/gix-config/tests/config/file/impls.rs
+++ b/gix-config/tests/config/file/impls.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_config::File;
 
 #[test]
@@ -70,7 +71,7 @@ fn can_reconstruct_configs_without_whitespace_in_middle() {
 }
 
 #[test]
-fn equality_ignores_section_and_value_name_case_but_not_subsection_case() -> crate::Result {
+fn equality_ignores_section_and_value_name_case_but_not_subsection_case() -> Result {
     let mixed_case = File::try_from("[Core]\nMixedCase = value\n[Remote \"Origin\"]\nURL = location\n")?;
     let equivalent = File::try_from("[core]\nmixedcase = value\n[remote \"Origin\"]\nurl = location\n")?;
     assert_eq!(mixed_case, equivalent, "section and value names are case-insensitive");
diff --git a/gix-config/tests/config/file/init/comfort.rs b/gix-config/tests/config/file/init/comfort.rs
index 740f209eb3f..a7a5f4cd8f6 100644
--- a/gix-config/tests/config/file/init/comfort.rs
+++ b/gix-config/tests/config/file/init/comfort.rs
@@ -1,10 +1,11 @@
+use crate::Result;
 use gix_config::source;
 
 use serial_test::serial;
 
 #[test]
 #[serial]
-fn from_globals() -> crate::Result {
+fn from_globals() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let worktree_dir = crate::scripted_fixture_read_only("make_config_repo.sh")?.canonicalize()?;
     let _environment = _environment.set(
@@ -22,7 +23,7 @@ fn from_globals() -> crate::Result {
 
 #[test]
 #[serial]
-fn from_environment_overrides() -> crate::Result {
+fn from_environment_overrides() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("GIT_CONFIG_COUNT", "0");
     let config = gix_config::File::from_environment_overrides()?;
     assert!(config.is_void());
@@ -31,7 +32,7 @@ fn from_environment_overrides() -> crate::Result {
 
 #[test]
 #[serial]
-fn from_git_dir() -> crate::Result {
+fn from_git_dir() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let worktree_dir = crate::scripted_fixture_read_only("make_config_repo.sh")?;
     let git_dir = worktree_dir.join(".git");
@@ -96,7 +97,7 @@ fn from_git_dir() -> crate::Result {
 
 #[test]
 #[serial]
-fn from_git_dir_with_worktree_extension() -> crate::Result {
+fn from_git_dir_with_worktree_extension() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let git_dir = crate::scripted_fixture_read_only("config_with_worktree_extension.sh")?
         .join("main-worktree")
diff --git a/gix-config/tests/config/file/init/from_env.rs b/gix-config/tests/config/file/init/from_env.rs
index d00eb43cb07..830ad573156 100644
--- a/gix-config/tests/config/file/init/from_env.rs
+++ b/gix-config/tests/config/file/init/from_env.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use std::fs;
 
 use gix_config::{
     File,
-    file::{includes, init, init::from_env},
+    file::{includes, init},
 };
 use gix_testtools::tempfile::tempdir;
 use serial_test::serial;
@@ -11,7 +12,7 @@ use crate::file::init::from_paths::escape_backslashes;
 
 #[test]
 #[serial]
-fn empty_without_relevant_environment() -> crate::Result {
+fn empty_without_relevant_environment() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.unset("GIT_CONFIG_COUNT");
     let config = File::from_env(Default::default())?;
     assert!(config.is_none());
@@ -20,7 +21,7 @@ fn empty_without_relevant_environment() -> crate::Result {
 
 #[test]
 #[serial]
-fn empty_with_zero_count() -> crate::Result {
+fn empty_with_zero_count() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("GIT_CONFIG_COUNT", "0");
     let config = File::from_env(Default::default())?;
     assert!(config.is_none());
@@ -29,16 +30,21 @@ fn empty_with_zero_count() -> crate::Result {
 
 #[test]
 #[serial]
-fn parse_error_with_invalid_count() -> crate::Result {
+fn parse_error_with_invalid_count() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("GIT_CONFIG_COUNT", "invalid");
-    let err = File::from_env(Default::default()).unwrap_err();
-    assert!(matches!(err, from_env::Error::InvalidConfigCount { .. }));
+    let err = File::from_env(Default::default()).expect_err("the configuration count is not an integer");
+    assert!(err.is_validation(), "invalid counts are validation errors");
+    insta::assert_debug_snapshot!(err, "parse error with invalid count", @r#"
+    GIT_CONFIG_COUNT was not a positive integer, "input"="invalid"
+    |
+    └─ invalid digit found in string
+    "#);
     Ok(())
 }
 
 #[test]
 #[serial]
-fn single_key_value_pair() -> crate::Result {
+fn single_key_value_pair() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?
         .set("GIT_CONFIG_COUNT", "1")
         .set("GIT_CONFIG_KEY_0", "core.key")
@@ -57,7 +63,7 @@ fn single_key_value_pair() -> crate::Result {
 
 #[test]
 #[serial]
-fn multiple_key_value_pairs() -> crate::Result {
+fn multiple_key_value_pairs() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?
         .set("GIT_CONFIG_COUNT", "3")
         .set("GIT_CONFIG_KEY_0", "core.a")
@@ -78,7 +84,7 @@ fn multiple_key_value_pairs() -> crate::Result {
 
 #[test]
 #[serial]
-fn error_on_relative_paths_in_include_paths() -> crate::Result {
+fn error_on_relative_paths_in_include_paths() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?
         .set("GIT_CONFIG_COUNT", "1")
         .set("GIT_CONFIG_KEY_0", "include.path")
@@ -92,16 +98,22 @@ fn error_on_relative_paths_in_include_paths() -> crate::Result {
         .strict(),
         ..Default::default()
     });
-    assert!(matches!(
-        res,
-        Err(from_env::Error::Includes(includes::Error::MissingConfigPath))
-    ));
+    let err = res.expect_err("relative includes without a configuration path must fail");
+    insta::assert_debug_snapshot!(err.classify()
+            .find(|classification| classification.class() == gix_error::Class::NotFound)
+            .expect("the missing configuration path is retained")
+            .error(), "error on relative paths in include paths", @r#"
+    Message {
+        message: "Include paths from environment variables must not be relative as no config file path exists as root",
+        class: NotFound,
+    }
+    "#);
     Ok(())
 }
 
 #[test]
 #[serial]
-fn follow_include_paths() -> crate::Result {
+fn follow_include_paths() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let dir = tempdir().unwrap();
     let a_path = dir.path().join("a");
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/mod.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/mod.rs
index ca99033df1a..77178610acb 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/mod.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/mod.rs
@@ -1,5 +1,6 @@
 mod util;
 
+use crate::Result;
 use gix_testtools::Env;
 use serial_test::serial;
 use util::{Condition, GitEnv, assert_section_value};
@@ -7,12 +8,12 @@ use util::{Condition, GitEnv, assert_section_value};
 use crate::file::init::from_paths::escape_backslashes;
 
 #[test]
-fn relative_path_with_trailing_slash_matches_like_star_star() -> crate::Result {
+fn relative_path_with_trailing_slash_matches_like_star_star() -> Result {
     assert_section_value(Condition::new("gitdir:worktree/"), GitEnv::repo_name("worktree")?)
 }
 
 #[test]
-fn relative_path_without_trailing_slash_does_not_match() -> crate::Result {
+fn relative_path_without_trailing_slash_does_not_match() -> Result {
     assert_section_value(
         Condition::new("gitdir:worktree").expect_original_value(),
         GitEnv::repo_name("worktree")?,
@@ -20,18 +21,18 @@ fn relative_path_without_trailing_slash_does_not_match() -> crate::Result {
 }
 
 #[test]
-fn relative_path_without_trailing_slash_and_dot_git_suffix_matches() -> crate::Result {
+fn relative_path_without_trailing_slash_and_dot_git_suffix_matches() -> Result {
     assert_section_value(Condition::new("gitdir:worktree/.git"), GitEnv::repo_name("worktree")?)
 }
 
 #[test]
-fn tilde_slash_expands_the_current_user_home() -> crate::Result {
+fn tilde_slash_expands_the_current_user_home() -> Result {
     let env = GitEnv::repo_name(std::path::Path::new("subdir").join("worktree"))?;
     assert_section_value(Condition::new("gitdir:~/subdir/worktree/"), env)
 }
 
 #[test]
-fn failed_user_expansion_matches_the_literal_pattern() -> crate::Result {
+fn failed_user_expansion_matches_the_literal_pattern() -> Result {
     let temp = gix_testtools::tempfile::tempdir()?;
     let name = format!(
         "~gix-config-{}",
@@ -86,18 +87,18 @@ path = included.config
 }
 
 #[test]
-fn tilde_alone_does_not_match_even_if_home_is_git_directory() -> crate::Result {
+fn tilde_alone_does_not_match_even_if_home_is_git_directory() -> Result {
     let env = GitEnv::repo_in_home()?;
     assert_section_value(Condition::new("gitdir:~").expect_original_value(), env)
 }
 
 #[test]
-fn explicit_star_star_prefix_and_suffix_match_zero_or_more_path_components() -> crate::Result {
+fn explicit_star_star_prefix_and_suffix_match_zero_or_more_path_components() -> Result {
     assert_section_value(Condition::new("gitdir:**/worktree/**"), GitEnv::repo_name("worktree")?)
 }
 
 #[test]
-fn double_slash_does_not_match() -> crate::Result {
+fn double_slash_does_not_match() -> Result {
     assert_section_value(
         Condition::new("gitdir://worktree").expect_original_value(),
         GitEnv::repo_name("worktree")?,
@@ -105,7 +106,7 @@ fn double_slash_does_not_match() -> crate::Result {
 }
 
 #[test]
-fn absolute_git_dir_with_os_separators_match() -> crate::Result {
+fn absolute_git_dir_with_os_separators_match() -> Result {
     assert_section_value(
         original_value_on_windows(Condition::new("gitdir:$gitdir")),
         GitEnv::repo_name("worktree")?,
@@ -113,7 +114,7 @@ fn absolute_git_dir_with_os_separators_match() -> crate::Result {
 }
 
 #[test]
-fn absolute_worktree_dir_with_os_separators_does_not_match_if_trailing_slash_is_missing() -> crate::Result {
+fn absolute_worktree_dir_with_os_separators_does_not_match_if_trailing_slash_is_missing() -> Result {
     assert_section_value(
         Condition::new("gitdir:$worktree").expect_original_value(),
         GitEnv::repo_name("worktree")?,
@@ -121,7 +122,7 @@ fn absolute_worktree_dir_with_os_separators_does_not_match_if_trailing_slash_is_
 }
 
 #[test]
-fn absolute_worktree_dir_with_os_separators_matches_with_trailing_glob() -> crate::Result {
+fn absolute_worktree_dir_with_os_separators_matches_with_trailing_glob() -> Result {
     assert_section_value(
         original_value_on_windows(Condition::new(format!(
             "gitdir:$worktree{}**",
@@ -132,7 +133,7 @@ fn absolute_worktree_dir_with_os_separators_matches_with_trailing_glob() -> crat
 }
 
 #[test]
-fn dot_slash_path_is_replaced_with_directory_containing_the_including_config_file() -> crate::Result {
+fn dot_slash_path_is_replaced_with_directory_containing_the_including_config_file() -> Result {
     assert_section_value(
         Condition::new("gitdir:./").set_user_config_instead_of_repo_config(),
         GitEnv::repo_name("worktree")?,
@@ -142,7 +143,7 @@ fn dot_slash_path_is_replaced_with_directory_containing_the_including_config_fil
 
 #[test]
 #[serial]
-fn dot_slash_from_environment_causes_error() -> crate::Result {
+fn dot_slash_from_environment_causes_error() -> Result {
     let _isolated_environment = gix_testtools::isolate_git_environment()?;
     let env = GitEnv::repo_name("worktree")?;
     // Only slashes can be used as matches, even on Windows.
@@ -155,15 +156,16 @@ fn dot_slash_from_environment_causes_error() -> crate::Result {
             .set("GIT_CONFIG_VALUE_0", "./include.path");
 
         let res = gix_config::File::from_env(env.to_init_options());
+        let err = res.expect_err("resolving the relative include path must fail");
         assert!(
-            matches!(
-                res,
-                Err(gix_config::file::init::from_env::Error::Includes(
-                    gix_config::file::includes::Error::MissingConfigPath
-                ))
-            ),
-            "this is a failure of resolving the include path, after trying to include it"
+            err.is_not_found(),
+            "relative environment includes have no configuration-file base"
         );
+        insta::assert_debug_snapshot!(err, "relative environment includes and patterns require a containing configuration file", @"
+        Could not resolve includes in environment configuration
+        |
+        └─ Include paths from environment variables must not be relative as no config file path exists as root
+        ");
     }
 
     let absolute_path = escape_backslashes(env.home_dir().join("include.config"));
@@ -174,15 +176,16 @@ fn dot_slash_from_environment_causes_error() -> crate::Result {
             .set("GIT_CONFIG_VALUE_0", &absolute_path);
 
         let res = gix_config::File::from_env(env.to_init_options());
+        let err = res.expect_err("resolving the relative pattern must fail");
         assert!(
-            matches!(
-                res,
-                Err(gix_config::file::init::from_env::Error::Includes(
-                    gix_config::file::includes::Error::MissingConfigPath
-                ))
-            ),
-            "here the pattern path tries to be resolved and fails as target config isn't set"
+            err.is_not_found(),
+            "relative environment includes have no configuration-file base"
         );
+        insta::assert_debug_snapshot!(err, "relative environment includes and patterns require a containing configuration file", @"
+        Could not resolve includes in environment configuration
+        |
+        └─ Include paths from environment variables must not be relative as no config file path exists as root
+        ");
     }
 
     {
@@ -199,7 +202,7 @@ fn dot_slash_from_environment_causes_error() -> crate::Result {
 }
 
 #[test]
-fn dot_dot_slash_prefixes_are_not_special_and_are_not_what_you_want() -> crate::Result {
+fn dot_dot_slash_prefixes_are_not_special_and_are_not_what_you_want() -> Result {
     assert_section_value(
         Condition::new("gitdir:../")
             .set_user_config_instead_of_repo_config()
@@ -209,12 +212,12 @@ fn dot_dot_slash_prefixes_are_not_special_and_are_not_what_you_want() -> crate::
 }
 
 #[test]
-fn leading_dots_are_not_special() -> crate::Result {
+fn leading_dots_are_not_special() -> Result {
     assert_section_value(Condition::new("gitdir:.hidden/"), GitEnv::repo_name(".hidden")?)
 }
 
 #[test]
-fn dot_slash_path_with_dot_git_suffix_matches() -> crate::Result {
+fn dot_slash_path_with_dot_git_suffix_matches() -> Result {
     assert_section_value(
         Condition::new("gitdir:./worktree/.git").set_user_config_instead_of_repo_config(),
         GitEnv::repo_name("worktree")?,
@@ -222,7 +225,7 @@ fn dot_slash_path_with_dot_git_suffix_matches() -> crate::Result {
 }
 
 #[test]
-fn globbing_and_wildcards() -> crate::Result {
+fn globbing_and_wildcards() -> Result {
     assert_section_value(
         Condition::new("gitdir:stan?ard/glo*ng/[xwz]ildcards/.git").set_user_config_instead_of_repo_config(),
         GitEnv::repo_name("standard/globbing/wildcards")?,
@@ -230,7 +233,7 @@ fn globbing_and_wildcards() -> crate::Result {
 }
 
 #[test]
-fn case_insensitive_matches_any_case() -> crate::Result {
+fn case_insensitive_matches_any_case() -> Result {
     assert_section_value(Condition::new("gitdir/i:WORKTREE/"), GitEnv::repo_name("worktree")?)?;
     assert_section_value(
         Condition::new("gitdir:WORKTREE/").expect_original_value(),
@@ -239,7 +242,7 @@ fn case_insensitive_matches_any_case() -> crate::Result {
 }
 
 #[test]
-fn pattern_with_escaped_backslash() -> crate::Result {
+fn pattern_with_escaped_backslash() -> Result {
     assert_section_value(
         original_value_on_windows(Condition::new(r"gitdir:\\work\\tree\\/")),
         GitEnv::repo_name("worktree")?,
@@ -247,12 +250,12 @@ fn pattern_with_escaped_backslash() -> crate::Result {
 }
 
 #[test]
-fn pattern_with_backslash() -> crate::Result {
+fn pattern_with_backslash() -> Result {
     assert_section_value(Condition::new(r"gitdir:work\tree/"), GitEnv::repo_name("worktree")?)
 }
 
 #[test]
-fn star_star_in_the_middle() -> crate::Result {
+fn star_star_in_the_middle() -> Result {
     assert_section_value(
         Condition::new("gitdir:**/dir/**/worktree/**"),
         GitEnv::repo_name("dir/worktree")?,
@@ -261,14 +264,14 @@ fn star_star_in_the_middle() -> crate::Result {
 
 #[test]
 #[cfg(not(windows))]
-fn tilde_expansion_with_symlink() -> crate::Result {
+fn tilde_expansion_with_symlink() -> Result {
     let env = util::git_env_with_symlinked_repo()?;
     assert_section_value(Condition::new("gitdir:~/worktree/"), env)
 }
 
 #[test]
 #[cfg(not(windows))]
-fn dot_path_with_symlink() -> crate::Result {
+fn dot_path_with_symlink() -> Result {
     let env = util::git_env_with_symlinked_repo()?;
     assert_section_value(
         Condition::new("gitdir:./symlink-worktree/.git").set_user_config_instead_of_repo_config(),
@@ -278,7 +281,7 @@ fn dot_path_with_symlink() -> crate::Result {
 
 #[test]
 #[cfg(not(windows))]
-fn relative_path_matching_symlink() -> crate::Result {
+fn relative_path_matching_symlink() -> Result {
     let env = util::git_env_with_symlinked_repo()?;
     assert_section_value(
         Condition::new("gitdir:symlink-worktree/").set_user_config_instead_of_repo_config(),
@@ -288,7 +291,7 @@ fn relative_path_matching_symlink() -> crate::Result {
 
 #[test]
 #[cfg(not(windows))]
-fn dot_path_matching_symlink_with_icase() -> crate::Result {
+fn dot_path_matching_symlink_with_icase() -> Result {
     let env = util::git_env_with_symlinked_repo()?;
     assert_section_value(
         Condition::new("gitdir/i:SYMLINK-WORKTREE/").set_user_config_instead_of_repo_config(),
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 8d49ad8d9bf..41c9fd95719 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
@@ -1,5 +1,6 @@
 #![cfg_attr(windows, allow(dead_code))]
 
+use crate::Result;
 use std::{
     io::Write,
     path::{Path, PathBuf},
@@ -66,7 +67,7 @@ impl Condition {
 }
 
 impl GitEnv {
-    pub fn repo_name(repo_name: impl AsRef<Path>) -> crate::Result<Self> {
+    pub fn repo_name(repo_name: impl AsRef<Path>) -> Result<Self> {
         let tempdir = gix_testtools::tempfile::tempdir()?;
         let root_dir = gix_path::realpath(tempdir.path())?;
         let worktree_dir = root_dir.join(repo_name);
@@ -80,7 +81,7 @@ impl GitEnv {
         })
     }
 
-    pub fn repo_in_home() -> crate::Result<Self> {
+    pub fn repo_in_home() -> Result<Self> {
         Self::repo_name("")
     }
 }
@@ -118,7 +119,7 @@ pub fn assert_section_value(
         config_location,
     }: Condition,
     env: GitEnv,
-) -> crate::Result {
+) -> Result {
     write_config(condition, &env, config_location)?;
 
     let mut paths = vec![env.git_dir().join("config")];
@@ -147,7 +148,7 @@ pub fn assert_section_value(
     assure_git_agrees(expected, env)
 }
 
-pub fn git_env_with_symlinked_repo() -> crate::Result<GitEnv> {
+pub fn git_env_with_symlinked_repo() -> Result<GitEnv> {
     let mut env = GitEnv::repo_name("worktree")?;
     let link_destination = env.root_dir().join("symlink-worktree");
     crate::file::init::from_paths::includes::conditional::create_symlink(&link_destination, env.worktree_dir());
@@ -157,7 +158,7 @@ pub fn git_env_with_symlinked_repo() -> crate::Result<GitEnv> {
     Ok(env)
 }
 
-fn assure_git_agrees(expected: Option<Value>, env: GitEnv) -> crate::Result {
+fn assure_git_agrees(expected: Option<Value>, env: GitEnv) -> Result {
     let output = gix_testtools::git_command(env.worktree_dir())
         .args(["config", "--get", "section.value"])
         .env("HOME", env.home_dir())
@@ -187,18 +188,18 @@ fn assure_git_agrees(expected: Option<Value>, env: GitEnv) -> crate::Result {
     Ok(())
 }
 
-fn write_config(condition: impl AsRef<str>, env: &GitEnv, overwrite_config_location: ConfigLocation) -> crate::Result {
+fn write_config(condition: impl AsRef<str>, env: &GitEnv, overwrite_config_location: ConfigLocation) -> Result {
     let include_config = write_included_config(env)?;
     write_main_config(condition, include_config, env, overwrite_config_location)
 }
 
-fn write_included_config(env: &GitEnv) -> crate::Result<PathBuf> {
+fn write_included_config(env: &GitEnv) -> Result<PathBuf> {
     let include_path = env.worktree_dir().join("include.path");
     write_append_config_value(&include_path, "override-value")?;
     Ok(include_path)
 }
 
-fn write_append_config_value(path: impl AsRef<std::path::Path>, value: &str) -> crate::Result {
+fn write_append_config_value(path: impl AsRef<std::path::Path>, value: &str) -> Result {
     let mut file = std::fs::OpenOptions::new().append(true).create(true).open(path)?;
     file.write_all(
         format!(
@@ -216,7 +217,7 @@ fn write_main_config(
     include_file_path: PathBuf,
     env: &GitEnv,
     overwrite_config_location: ConfigLocation,
-) -> crate::Result {
+) -> Result {
     git_init(env.worktree_dir(), false)?;
 
     if overwrite_config_location == ConfigLocation::Repo {
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 1e6844d344c..527fe1bd82a 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,9 +1,10 @@
+use crate::Result;
 use std::path::{Path, PathBuf};
 
 use gix_config::file::{includes, init};
 
 #[test]
-fn simple() -> crate::Result {
+fn simple() -> Result {
     let (config, root) = config_with_includes("basic")?;
     compare_baseline(&config, "user.this", root.join("expected"));
     assert_eq!(config.string("user.that"), None);
@@ -11,7 +12,7 @@ fn simple() -> crate::Result {
 }
 
 #[test]
-fn inclusion_order() -> crate::Result {
+fn inclusion_order() -> Result {
     let (config, root) = config_with_includes("inclusion-order")?;
     for key in ["one", "two", "three"] {
         compare_baseline(&config, format!("user.{key}"), root.join(format!("expected.{key}")));
@@ -20,7 +21,7 @@ fn inclusion_order() -> crate::Result {
 }
 
 #[test]
-fn globs() -> crate::Result {
+fn globs() -> Result {
     let (config, root) = config_with_includes("globs")?;
     for key in ["dss", "dse", "dsm", "ssm"] {
         compare_baseline(&config, format!("user.{key}"), root.join(format!("expected.{key}")));
@@ -30,7 +31,7 @@ fn globs() -> crate::Result {
 }
 
 #[test]
-fn cycle_breaker() -> crate::Result {
+fn cycle_breaker() -> Result {
     for name in ["cycle-breaker-direct", "cycle-breaker-indirect"] {
         let (_config, _root) = config_with_includes(name)?;
     }
@@ -39,7 +40,7 @@ fn cycle_breaker() -> crate::Result {
 }
 
 #[test]
-fn no_cycle() -> crate::Result {
+fn no_cycle() -> Result {
     let (config, root) = config_with_includes("no-cycle")?;
     compare_baseline(&config, "user.name", root.join("expected"));
     Ok(())
@@ -59,7 +60,7 @@ fn compare_baseline(config: &gix_config::File, key: impl AsRef<str>, expected: i
     );
 }
 
-fn config_with_includes(name: &str) -> crate::Result<(gix_config::File, PathBuf)> {
+fn config_with_includes(name: &str) -> Result<(gix_config::File, PathBuf)> {
     let root = crate::scripted_fixture_read_only("hasconfig.sh")?.join(name);
     let options = init::Options {
         includes: includes::Options::follow(Default::default(), Default::default()),
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/mod.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/mod.rs
index a21beb98d18..4b63be11267 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/conditional/mod.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/conditional/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{fs, path::Path, str::FromStr};
 
 use gix_config::{
@@ -14,7 +15,7 @@ mod hasconfig;
 mod onbranch;
 
 #[test]
-fn include_and_includeif_correct_inclusion_order_and_delayed_resolve_include() -> crate::Result {
+fn include_and_includeif_correct_inclusion_order_and_delayed_resolve_include() -> Result {
     let dir = tempdir()?;
     let config_path = dir.path().join("root");
     let first_include_path = dir.path().join("first-incl");
@@ -139,7 +140,7 @@ fn options_with_git_dir(git_dir: &Path) -> init::Options<'_> {
     }
 }
 
-fn git_init(dir: impl AsRef<std::path::Path>, bare: bool) -> crate::Result {
+fn git_init(dir: impl AsRef<std::path::Path>, bare: bool) -> Result {
     let dir = dir.as_ref();
     let mut args = vec!["init"];
     if bare {
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/onbranch.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/onbranch.rs
index 3c3fb09a169..694e822aee0 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/conditional/onbranch.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/conditional/onbranch.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::fs;
 
 use bstr::{BString, ByteSlice};
@@ -11,8 +12,6 @@ use gix_testtools::tempfile::tempdir;
 
 use crate::file::{bstring, init::from_paths::includes::conditional::git_init};
 
-type Result = crate::Result;
-
 #[test]
 fn literal_branch_names_match() -> Result {
     assert_section_value(
@@ -178,7 +177,7 @@ struct GitEnv {
 }
 
 impl GitEnv {
-    fn new() -> crate::Result<Self> {
+    fn new() -> Result<Self> {
         let dir = tempdir()?;
         git_init(dir.path(), true)?;
         Ok(GitEnv { dir })
@@ -191,7 +190,7 @@ struct Options<'a> {
     expect: Value,
 }
 
-fn assert_section_value(opts: Options, env: &mut GitEnv) -> crate::Result {
+fn assert_section_value(opts: Options, env: &mut GitEnv) -> Result {
     assert_section_value_msg(opts, env, None)
 }
 
@@ -203,7 +202,7 @@ fn assert_section_value_msg(
     }: Options,
     GitEnv { dir }: &mut GitEnv,
     message: Option<&str>,
-) -> crate::Result<()> {
+) -> Result<()> {
     let root_config = dir.path().join("config");
     let included_config = dir.path().join("include.config");
 
@@ -274,7 +273,7 @@ value = branch-override-by-include
     Ok(())
 }
 
-fn assure_git_agrees(expected: Value, dir: &mut gix_testtools::tempfile::TempDir) -> crate::Result {
+fn assure_git_agrees(expected: Value, dir: &mut gix_testtools::tempfile::TempDir) -> Result {
     let git_dir = dir.path();
     let output = gix_testtools::git_command(git_dir)
         .args(["config", "--get", "section.value"])
diff --git a/gix-config/tests/config/file/init/from_paths/includes/unconditional.rs b/gix-config/tests/config/file/init/from_paths/includes/unconditional.rs
index 2a1697b5350..7a75811b9bb 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/unconditional.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/unconditional.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use std::fs;
 
 use gix_config::{
     File,
-    file::{includes, init, init::from_paths},
+    file::{includes, init},
 };
 use gix_testtools::tempfile::tempdir;
 
@@ -18,8 +19,16 @@ fn follow_options() -> init::Options<'static> {
     }
 }
 
+fn assert_include_depth(err: gix_error::Exn<gix_error::Message>) -> gix_error::Exn<gix_error::Message> {
+    assert!(
+        err.is_validation(),
+        "exceeding the include depth is invalid configuration"
+    );
+    err
+}
+
 #[test]
-fn multiple() -> crate::Result {
+fn multiple() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -77,16 +86,16 @@ fn multiple() -> crate::Result {
     let config = File::from_paths_metadata(into_meta(vec![c_path]), follow_options())?.expect("non-empty");
 
     assert_eq!(config.string_by("core", None, "c"), Some(bstring("12")));
-    assert_eq!(config.integer_by("core", None, "d"), Ok(Some(41)));
-    assert_eq!(config.boolean_by("http", None, "sslVerify"), Ok(Some(false)));
-    assert_eq!(config.boolean_by("diff", None, "renames"), Ok(Some(true)));
-    assert_eq!(config.boolean_by("core", None, "a"), Ok(Some(false)));
+    assert_eq!(config.integer_by("core", None, "d")?, Some(41));
+    assert_eq!(config.boolean_by("http", None, "sslVerify")?, Some(false));
+    assert_eq!(config.boolean_by("diff", None, "renames")?, Some(true));
+    assert_eq!(config.boolean_by("core", None, "a")?, Some(false));
 
     Ok(())
 }
 
 #[test]
-fn respect_max_depth() -> crate::Result {
+fn respect_max_depth() -> Result {
     let dir = tempdir()?;
 
     // 0 includes 1 - base level
@@ -121,8 +130,8 @@ fn respect_max_depth() -> crate::Result {
 
     let config =
         File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), follow_options())?.expect("non-empty");
-    assert_eq!(config.integers_by("core", None, "i"), Ok(Some(vec![0, 1, 2, 3, 4])));
-    assert_eq!(config.integers("core.i"), Ok(Some(vec![0, 1, 2, 3, 4])));
+    assert_eq!(config.integers_by("core", None, "i")?, Some(vec![0, 1, 2, 3, 4]));
+    assert_eq!(config.integers("core.i")?, Some(vec![0, 1, 2, 3, 4]));
 
     fn make_options(max_depth: u8, error_on_max_depth_exceeded: bool) -> init::Options<'static> {
         init::Options {
@@ -139,8 +148,8 @@ fn respect_max_depth() -> crate::Result {
     // this is equivalent to running git with --no-includes option
     let options = make_options(1, false);
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
-    assert_eq!(config.integer_by("core", None, "i"), Ok(Some(1)));
-    assert_eq!(config.integer("core.i"), Ok(Some(1)));
+    assert_eq!(config.integer_by("core", None, "i")?, Some(1));
+    assert_eq!(config.integer("core.i")?, Some(1));
 
     // with default max_allowed_depth of 10 and 4 levels of includes, last level is read
     let options = init::Options {
@@ -148,42 +157,44 @@ fn respect_max_depth() -> crate::Result {
         ..Default::default()
     };
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
-    assert_eq!(config.integer_by("core", None, "i"), Ok(Some(4)));
+    assert_eq!(config.integer_by("core", None, "i")?, Some(4));
 
     // with max_allowed_depth of 5, the base and 4 levels of includes, last level is read
     let options = make_options(5, false);
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
-    assert_eq!(config.integer_by("core", None, "i"), Ok(Some(4)));
+    assert_eq!(config.integer_by("core", None, "i")?, Some(4));
 
     // with max_allowed_depth of 2 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
     let options = make_options(2, true);
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options);
-    assert!(matches!(
-        config.unwrap_err(),
-        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
-            max_depth: 2
-        }))
-    ));
+    insta::assert_debug_snapshot!(assert_include_depth(config.expect_err("the configured include depth must be enforced")), "include-depth limits report the configured maximum", @"
+    Could not initialize configuration from a path
+    |
+    └─ Could not resolve configuration includes
+    |
+    └─ The maximum allowed length 2 of the file include chain built by following nested resolve_includes is exceeded
+    ");
 
     // with max_allowed_depth of 2 and 4 levels of includes and error_on_max_depth_exceeded: false , max_allowed_depth is exceeded and the value of level 2 is returned
     let options = make_options(2, false);
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
-    assert_eq!(config.integer_by("core", None, "i"), Ok(Some(2)));
+    assert_eq!(config.integer_by("core", None, "i")?, Some(2));
 
     // with max_allowed_depth of 0 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
     let options = make_options(0, true);
     let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options);
-    assert!(matches!(
-        config.unwrap_err(),
-        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
-            max_depth: 0
-        }))
-    ));
+    insta::assert_debug_snapshot!(assert_include_depth(config.expect_err("the configured include depth must be enforced")), "include-depth limits report the configured maximum", @"
+    Could not initialize configuration from a path
+    |
+    └─ Could not resolve configuration includes
+    |
+    └─ The maximum allowed length 0 of the file include chain built by following nested resolve_includes is exceeded
+    ");
     Ok(())
 }
 
 #[test]
-fn simple() -> crate::Result {
+fn simple() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -214,12 +225,12 @@ fn simple() -> crate::Result {
     )?;
 
     let config = File::from_paths_metadata(into_meta(vec![a_path]), follow_options())?.expect("non-empty");
-    assert_eq!(config.boolean_by("core", None, "b"), Ok(Some(false)));
+    assert_eq!(config.boolean_by("core", None, "b")?, Some(false));
     Ok(())
 }
 
 #[test]
-fn cycle_detection() -> crate::Result {
+fn cycle_detection() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -258,12 +269,13 @@ fn cycle_detection() -> crate::Result {
         ..Default::default()
     };
     let config = File::from_paths_metadata(into_meta(vec![a_path.clone()]), options);
-    assert!(matches!(
-        config.unwrap_err(),
-        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
-            max_depth: 4
-        }))
-    ));
+    insta::assert_debug_snapshot!(assert_include_depth(config.expect_err("the configured include depth must be enforced")), "include-depth limits report the configured maximum", @"
+    Could not initialize configuration from a path
+    |
+    └─ Could not resolve configuration includes
+    |
+    └─ The maximum allowed length 4 of the file include chain built by following nested resolve_includes is exceeded
+    ");
 
     let options = init::Options {
         includes: includes::Options {
@@ -274,12 +286,12 @@ fn cycle_detection() -> crate::Result {
         ..Default::default()
     };
     let config = File::from_paths_metadata(into_meta(vec![a_path]), options)?.expect("non-empty");
-    assert_eq!(config.integers_by("core", None, "b"), Ok(Some(vec![0, 1, 0, 1, 0])));
+    assert_eq!(config.integers_by("core", None, "b")?, Some(vec![0, 1, 0, 1, 0]));
     Ok(())
 }
 
 #[test]
-fn nested() -> crate::Result {
+fn nested() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -319,8 +331,8 @@ fn nested() -> crate::Result {
 
     let config = File::from_paths_metadata(into_meta(vec![c_path]), follow_options())?.expect("non-empty");
 
-    assert_eq!(config.integer_by("core", None, "c"), Ok(Some(1)));
-    assert_eq!(config.boolean_by("core", None, "b"), Ok(Some(true)));
-    assert_eq!(config.boolean_by("core", None, "a"), Ok(Some(false)));
+    assert_eq!(config.integer_by("core", None, "c")?, Some(1));
+    assert_eq!(config.boolean_by("core", None, "b")?, Some(true));
+    assert_eq!(config.boolean_by("core", None, "a")?, Some(false));
     Ok(())
 }
diff --git a/gix-config/tests/config/file/init/from_paths/mod.rs b/gix-config/tests/config/file/init/from_paths/mod.rs
index 9cdf3526db7..9f8eea45fce 100644
--- a/gix-config/tests/config/file/init/from_paths/mod.rs
+++ b/gix-config/tests/config/file/init/from_paths/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{fs, path::PathBuf};
 
 use gix_config::{File, Source};
@@ -17,8 +18,25 @@ mod from_path_no_includes {
         let config_path = dir.path().join("config");
 
         let err = gix_config::File::from_path_no_includes(config_path, gix_config::Source::Local).unwrap_err();
-        assert!(
-            matches!(err,  gix_config::file::init::from_paths::Error::Io{source: io_error, ..} if io_error.kind() == std::io::ErrorKind::NotFound)
+        #[cfg(not(windows))]
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(dir.path()).to_string_lossy(), "<tmp>")]), "file not found", @r#"
+        The configuration file at "<tmp>/config" could not be inspected
+        |
+        └─ NotFound
+        "#);
+        #[cfg(windows)]
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(dir.path()).to_string_lossy(), "<tmp>")]), "file not found", @r#"
+        The configuration file at "<tmp>/config" could not be inspected
+        |
+        └─ I/O error (NotFound)
+        |
+        └─ "<tmp>/config" does not exist.
+        "#);
+        assert_eq!(
+            err.downcast_any_ref::<std::io::Error>()
+                .expect("the I/O source is retained")
+                .kind(),
+            std::io::ErrorKind::NotFound
         );
     }
 
@@ -36,7 +54,7 @@ mod from_path_no_includes {
 }
 
 #[test]
-fn multiple_paths_single_value() -> crate::Result {
+fn multiple_paths_single_value() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -54,9 +72,9 @@ fn multiple_paths_single_value() -> crate::Result {
     let paths = vec![a_path, b_path, c_path, d_path];
     let config = File::from_paths_metadata(into_meta(paths), Default::default())?.expect("non-empty");
 
-    assert_eq!(config.boolean("core.a"), Ok(Some(false)));
-    assert_eq!(config.boolean("core.b"), Ok(Some(true)));
-    assert_eq!(config.boolean("core.c"), Ok(Some(true)));
+    assert_eq!(config.boolean("core.a")?, Some(false));
+    assert_eq!(config.boolean("core.b")?, Some(true));
+    assert_eq!(config.boolean("core.c")?, Some(true));
     assert_eq!(config.num_values(), 4);
     assert_eq!(config.sections().count(), 4, "each value is in a dedicated section");
 
@@ -64,7 +82,7 @@ fn multiple_paths_single_value() -> crate::Result {
 }
 
 #[test]
-fn frontmatter_is_maintained_in_multiple_files() -> crate::Result {
+fn frontmatter_is_maintained_in_multiple_files() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
@@ -125,7 +143,7 @@ fn frontmatter_is_maintained_in_multiple_files() -> crate::Result {
 }
 
 #[test]
-fn multiple_paths_multi_value_and_filter() -> crate::Result {
+fn multiple_paths_multi_value_and_filter() -> Result {
     let dir = tempdir()?;
 
     let a_path = dir.path().join("a");
diff --git a/gix-config/tests/config/file/init/from_str.rs b/gix-config/tests/config/file/init/from_str.rs
index da15368d7ab..6ceb2464e22 100644
--- a/gix-config/tests/config/file/init/from_str.rs
+++ b/gix-config/tests/config/file/init/from_str.rs
@@ -1,5 +1,7 @@
+use crate::Result;
+
 #[test]
-fn empty_yields_default_file() -> crate::Result {
+fn empty_yields_default_file() -> Result {
     let a: gix_config::File = "".parse()?;
     assert_eq!(a, gix_config::File::default());
     assert_eq!(a.to_string(), "");
@@ -7,7 +9,7 @@ fn empty_yields_default_file() -> crate::Result {
 }
 
 #[test]
-fn whitespace_without_section_contains_front_matter() -> crate::Result {
+fn whitespace_without_section_contains_front_matter() -> Result {
     let input = "    \t";
     let a: gix_config::File = input.parse()?;
     assert_eq!(a.to_string(), input);
diff --git a/gix-config/tests/config/file/mod.rs b/gix-config/tests/config/file/mod.rs
index 47ca46a0df8..1c017039269 100644
--- a/gix-config/tests/config/file/mod.rs
+++ b/gix-config/tests/config/file/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::PathBuf;
 
 use bstr::BString;
@@ -73,7 +74,7 @@ fn fuzzed_stackoverflow() {
 }
 
 #[test]
-fn fuzzed_long_runtime() -> crate::Result {
+fn fuzzed_long_runtime() -> Result {
     let config = std::fs::read(fixture_path("fuzzed/long-parsetime.config"))?;
     let file = File::from_bytes_no_includes(&config, gix_config::file::Metadata::default(), Default::default())?;
     assert_eq!(file.sections().count(), 52);
diff --git a/gix-config/tests/config/file/mutable/multi_value.rs b/gix-config/tests/config/file/mutable/multi_value.rs
index 6a9cbc2fd48..e221602e87f 100644
--- a/gix-config/tests/config/file/mutable/multi_value.rs
+++ b/gix-config/tests/config/file/mutable/multi_value.rs
@@ -1,8 +1,9 @@
 mod get {
+    use crate::Result;
     use crate::file::{bstring, mutable::multi_value::init_config};
 
     #[test]
-    fn single_lines() -> crate::Result {
+    fn single_lines() -> Result {
         let mut config = init_config();
 
         let value = config.raw_values_mut_by("core", None, "a")?;
@@ -11,7 +12,7 @@ mod get {
     }
 
     #[test]
-    fn multi_line() -> crate::Result {
+    fn multi_line() -> Result {
         let mut config: gix_config::File = r#"[core]
             a=b\
 "100"
@@ -36,7 +37,7 @@ c
     }
 
     #[test]
-    fn value_names_are_case_insensitive() -> crate::Result {
+    fn value_names_are_case_insensitive() -> Result {
         let mut config: gix_config::File = "[core]\nMixedCase = one\nMIXEDCASE = two".parse()?;
         assert_eq!(
             config.raw_values_mut_by("core", None, "mixedcase")?.get()?,
@@ -47,10 +48,11 @@ c
 }
 
 mod access {
+    use crate::Result;
     use crate::file::mutable::multi_value::init_config;
 
     #[test]
-    fn non_empty_sizes() -> crate::Result {
+    fn non_empty_sizes() -> Result {
         let mut config = init_config();
         assert_eq!(config.raw_values_mut_by("core", None, "a")?.len(), 3);
         assert!(!config.raw_values_mut_by("core", None, "a")?.is_empty());
@@ -59,10 +61,11 @@ mod access {
 }
 
 mod set {
+    use crate::Result;
     use crate::file::{bstring, mutable::multi_value::init_config};
 
     #[test]
-    fn values_are_escaped() -> crate::Result {
+    fn values_are_escaped() -> Result {
         for value in ["a b", " a b", "a b\t", ";c", "#c", "a\nb\n\tc"] {
             let mut config = init_config();
             let mut values = config.raw_values_mut_by("core", None, "a")?;
@@ -80,7 +83,7 @@ mod set {
     }
 
     #[test]
-    fn single_at_start() -> crate::Result {
+    fn single_at_start() -> Result {
         let mut config = init_config();
         let mut values = config.raw_values_mut_by("core", None, "a")?;
         values.set_string_at(0, "Hello")?;
@@ -92,7 +95,7 @@ mod set {
     }
 
     #[test]
-    fn single_at_end() -> crate::Result {
+    fn single_at_end() -> Result {
         let mut config = init_config();
         let mut values = config.raw_values_mut_by("core", None, "a")?;
         values.set_string_at(2, "Hello")?;
@@ -104,7 +107,7 @@ mod set {
     }
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let mut config = init_config();
         let mut values = config.raw_values_mut_by("core", None, "a")?;
         values.set_all("Hello")?;
@@ -116,7 +119,7 @@ mod set {
     }
 
     #[test]
-    fn all_empty() -> crate::Result {
+    fn all_empty() -> Result {
         let mut config = init_config();
         let mut values = config.raw_values_mut_by("core", None, "a")?;
         values.set_all("")?;
@@ -129,10 +132,11 @@ mod set {
 }
 
 mod delete {
+    use crate::Result;
     use crate::file::mutable::multi_value::init_config;
 
     #[test]
-    fn single_at_start_and_end() -> crate::Result {
+    fn single_at_start_and_end() -> Result {
         let mut config = init_config();
         {
             let mut values = config.raw_values_mut_by("core", None, "a")?;
@@ -150,7 +154,7 @@ mod delete {
     }
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let mut config = init_config();
         let mut values = config.raw_values_mut_by("core", None, "a")?;
         values.delete_all();
diff --git a/gix-config/tests/config/file/mutable/section.rs b/gix-config/tests/config/file/mutable/section.rs
index 9d0b971e4e0..2f461be38ac 100644
--- a/gix-config/tests/config/file/mutable/section.rs
+++ b/gix-config/tests/config/file/mutable/section.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+
 #[test]
 fn section_mut_must_exist_as_section_is_not_created_automatically() {
     let mut config = multi_value_section();
@@ -5,7 +7,7 @@ fn section_mut_must_exist_as_section_is_not_created_automatically() {
 }
 
 #[test]
-fn section_mut_or_create_new_is_infallible() -> crate::Result {
+fn section_mut_or_create_new_is_infallible() -> Result {
     let mut config = multi_value_section();
     let section = config.section_mut_or_create_new("name", "subsection")?;
     assert_eq!(section.header().name(), "name");
@@ -14,7 +16,7 @@ fn section_mut_or_create_new_is_infallible() -> crate::Result {
 }
 
 #[test]
-fn section_mut_or_create_new_filter_may_reject_existing_sections() -> crate::Result {
+fn section_mut_or_create_new_filter_may_reject_existing_sections() -> Result {
     let mut config = multi_value_section();
     let section = config.section_mut_or_create_new_filter("a", None, |_| false)?;
     assert_eq!(section.header().name(), "a");
@@ -38,10 +40,11 @@ fn section_mut_by_id() {
 }
 
 mod rename {
+    use crate::Result;
     use bstr::ByteSlice;
 
     #[test]
-    fn detached_sections_can_be_renamed() -> crate::Result {
+    fn detached_sections_can_be_renamed() -> Result {
         let mut section = gix_config::file::Section::new("remote", "origin", gix_config::file::Metadata::default())?;
         section.to_mut().rename("branch", "main")?;
 
@@ -52,7 +55,7 @@ mod rename {
     }
 
     #[test]
-    fn attached_sections_are_renamed_unambiguously_and_update_lookups() -> crate::Result {
+    fn attached_sections_are_renamed_unambiguously_and_update_lookups() -> Result {
         let mut file = gix_config::File::try_from(
             "[target \"same\"] key = first\n\
              [source \"old\"] key = selected\n\
@@ -90,7 +93,7 @@ mod rename {
     }
 
     #[test]
-    fn invalid_names_leave_attached_sections_unchanged() -> crate::Result {
+    fn invalid_names_leave_attached_sections_unchanged() -> Result {
         let mut file = gix_config::File::try_from("[core] key = value\n")?;
         assert!(file.section_mut("core", None)?.rename("not_valid", None).is_err());
         assert_eq!(
@@ -108,9 +111,10 @@ mod rename {
 
 mod remove {
     use super::multi_value_section;
+    use crate::Result;
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let mut config = multi_value_section();
         let mut section = config.section_mut("a", None)?;
 
@@ -134,9 +138,10 @@ mod remove {
 
 mod pop {
     use super::multi_value_section;
+    use crate::Result;
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let mut config = multi_value_section();
         let mut section = config.section_mut_by_key("a")?;
 
@@ -160,9 +165,10 @@ mod pop {
 
 mod set {
     use super::multi_value_section;
+    use crate::Result;
 
     #[test]
-    fn various_escapes_onto_various_kinds_of_values() -> crate::Result {
+    fn various_escapes_onto_various_kinds_of_values() -> Result {
         let mut config = multi_value_section();
         let mut section = config.section_mut("a", None)?;
         let values = vec!["", " a", "b\t", "; comment", "a\n\tc  d\\ \"x\""];
@@ -189,31 +195,49 @@ mod set {
 }
 
 mod value_name_validation {
-    use gix_config::file::section::value;
+    use crate::Result;
 
     #[test]
-    fn mutations_validate_names_and_leave_the_section_unchanged_on_error() -> crate::Result {
+    fn mutations_validate_names_and_leave_the_section_unchanged_on_error() -> Result {
         let mut config = gix_config::File::default();
         let mut section = config.new_section("core", None)?;
 
-        assert!(matches!(
-            section.push("not.valid", Some("value".into())),
-            Err(value::Error::ValueName(_))
-        ));
-        assert!(matches!(
-            section.push_with_comment("1invalid", Some("value".into()), "comment"),
-            Err(value::Error::ValueName(_))
-        ));
-        assert!(matches!(
-            section.set("also invalid", "value"),
-            Err(value::Error::ValueName(_))
-        ));
+        let err: gix_error::Message = section
+            .push("not.valid", Some("value".into()))
+            .unwrap_err()
+            .into_inner();
+        insta::assert_debug_snapshot!(err, "mutations validate names and leave the section unchanged on error", @r#"
+        Message {
+            message: "Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character.",
+            class: Validation,
+            values: {"input": Bytes("not.valid")},
+        }
+        "#);
+        let err: gix_error::Message = section
+            .push_with_comment("1invalid", Some("value".into()), "comment")
+            .unwrap_err()
+            .into_inner();
+        insta::assert_debug_snapshot!(err, "mutations validate names and leave the section unchanged on error", @r#"
+        Message {
+            message: "Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character.",
+            class: Validation,
+            values: {"input": Bytes("1invalid")},
+        }
+        "#);
+        let err: gix_error::Message = section.set("also invalid", "value").unwrap_err().into_inner();
+        insta::assert_debug_snapshot!(err, "mutations validate names and leave the section unchanged on error", @r#"
+        Message {
+            message: "Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character.",
+            class: Validation,
+            values: {"input": Bytes("also invalid")},
+        }
+        "#);
         assert_eq!(section.num_values(), 0, "validation happens before mutation");
         Ok(())
     }
 
     #[test]
-    fn names_returned_by_public_apis_are_strings() -> crate::Result {
+    fn names_returned_by_public_apis_are_strings() -> Result {
         let mut config = super::multi_value_section();
         let mut section = config.section_mut("a", None)?;
         let names: Vec<String> = section.value_names().collect();
@@ -226,10 +250,11 @@ mod value_name_validation {
 }
 
 mod push {
+    use crate::Result;
     use crate::file::bstring;
 
     #[test]
-    fn none_as_value_omits_the_key_value_separator() -> crate::Result {
+    fn none_as_value_omits_the_key_value_separator() -> Result {
         let mut file = gix_config::File::default();
         let mut section = file.section_mut_or_create_new("a", "sub")?;
         section.push("key", None)?;
@@ -245,7 +270,7 @@ mod push {
     }
 
     #[test]
-    fn whitespace_is_derived_from_whitespace_before_first_value() -> crate::Result {
+    fn whitespace_is_derived_from_whitespace_before_first_value() -> Result {
         for (input, expected_pre_key, expected_sep) in [
             ("[a]\n\t\tb=c", Some("\t\t".into()), (None, None)),
             ("[a]\nb= c", None, (None, Some(" "))),
@@ -333,8 +358,10 @@ mod push_with_comment {
 }
 
 mod set_leading_whitespace {
+    use crate::Result;
+
     #[test]
-    fn any_whitespace_is_ok() -> crate::Result {
+    fn any_whitespace_is_ok() -> Result {
         let mut config = gix_config::File::default();
         let mut section = config.new_section("core", None)?;
 
diff --git a/gix-config/tests/config/file/mutable/value.rs b/gix-config/tests/config/file/mutable/value.rs
index d2668dc5a0c..8b6569c1b29 100644
--- a/gix-config/tests/config/file/mutable/value.rs
+++ b/gix-config/tests/config/file/mutable/value.rs
@@ -1,4 +1,5 @@
 mod get {
+    use crate::Result;
     use bstr::BString;
 
     use crate::file::mutable::value::init_config;
@@ -29,7 +30,7 @@ mod get {
     }
 
     #[test]
-    fn value_is_correct() -> crate::Result {
+    fn value_is_correct() -> Result {
         let mut config = init_config();
 
         let value = config.raw_value_mut_by("core", None, "a")?;
@@ -38,7 +39,7 @@ mod get {
     }
 
     #[test]
-    fn value_names_are_case_insensitive() -> crate::Result {
+    fn value_names_are_case_insensitive() -> Result {
         let mut config: gix_config::File = "[core]\nMixedCase = value".parse()?;
         assert_eq!(config.raw_value_mut_by("core", None, "mIxEdCaSe")?.get()?, "value");
         Ok(())
@@ -46,6 +47,7 @@ mod get {
 }
 
 mod set_string {
+    use crate::Result;
     use crate::file::mutable::value::init_config;
 
     fn assert_set_string(expected: &str) {
@@ -125,7 +127,7 @@ mod set_string {
     }
 
     #[test]
-    fn unquoted_comments_end_continued_values_and_survive_replacement() -> crate::Result {
+    fn unquoted_comments_end_continued_values_and_survive_replacement() -> Result {
         for newline in ["\n", "\r\n"] {
             for comment in ["# comment", "; comment"] {
                 let mut config: gix_config::File =
@@ -144,7 +146,7 @@ mod set_string {
     }
 
     #[test]
-    fn quoted_comment_markers_in_continued_values_are_value_content() -> crate::Result {
+    fn quoted_comment_markers_in_continued_values_are_value_content() -> Result {
         let mut config: gix_config::File = r#"[a]
 k="one\
 #not;comments"
@@ -166,7 +168,7 @@ next=value"#
     }
 
     #[test]
-    fn simple_value_and_empty_string() -> crate::Result {
+    fn simple_value_and_empty_string() -> Result {
         let mut config = init_config();
 
         let mut value = config.raw_value_mut_by("core", None, "a")?;
@@ -198,9 +200,10 @@ next=value"#
 
 mod delete {
     use super::init_config;
+    use crate::Result;
 
     #[test]
-    fn single_line_value() -> crate::Result {
+    fn single_line_value() -> Result {
         let mut config = init_config();
 
         let mut value = config.raw_value_mut_by("core", None, "a")?;
@@ -220,7 +223,7 @@ mod delete {
     }
 
     #[test]
-    fn get_value_after_deleted() -> crate::Result {
+    fn get_value_after_deleted() -> Result {
         let mut config = init_config();
 
         let mut value = config.raw_value_mut_by("core", None, "a")?;
@@ -230,7 +233,7 @@ mod delete {
     }
 
     #[test]
-    fn set_string_after_deleted() -> crate::Result {
+    fn set_string_after_deleted() -> Result {
         let mut config = init_config();
 
         let mut value = config.raw_value_mut_by("core", None, "a")?;
@@ -249,7 +252,7 @@ mod delete {
     }
 
     #[test]
-    fn idempotency() -> crate::Result {
+    fn idempotency() -> Result {
         let mut config = init_config();
 
         let mut value = config.raw_value_mut_by("core", None, "a")?;
@@ -264,7 +267,7 @@ mod delete {
     }
 
     #[test]
-    fn multi_line_value() -> crate::Result {
+    fn multi_line_value() -> Result {
         let mut config: gix_config::File = r#"[core]
             a=b"100"\
 c\
diff --git a/gix-config/tests/config/file/resolve_includes.rs b/gix-config/tests/config/file/resolve_includes.rs
index 4493d2e8b69..a91ec08a5c2 100644
--- a/gix-config/tests/config/file/resolve_includes.rs
+++ b/gix-config/tests/config/file/resolve_includes.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use gix_config::{file, file::init};
 
 #[test]
-fn missing_includes_are_ignored_by_default() -> crate::Result {
+fn missing_includes_are_ignored_by_default() -> Result {
     let input = r#"
         [include]
             path = /etc/absolute/missing.config
diff --git a/gix-config/tests/config/file/write.rs b/gix-config/tests/config/file/write.rs
index 223ce1089f2..5355c47257b 100644
--- a/gix-config/tests/config/file/write.rs
+++ b/gix-config/tests/config/file/write.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteVec;
 use gix_config::file::{Metadata, init};
 
@@ -77,7 +78,7 @@ fn inserted_newlines_use_each_sections_newline_style() {
 }
 
 #[test]
-fn crlf_after_a_comment_is_detected_and_used_for_insertions() -> crate::Result {
+fn crlf_after_a_comment_is_detected_and_used_for_insertions() -> Result {
     let input = "; root\r\n[core]\nkey=value\n";
     let mut config = gix_config::File::try_from(input)?;
     assert_eq!(
@@ -163,11 +164,12 @@ fn complex_lossless_roundtrip() {
 }
 
 mod to_filter {
+    use crate::Result;
     use bstr::ByteSlice;
     use gix_config::file::Metadata;
 
     #[test]
-    fn allows_only_selected_sections() -> crate::Result {
+    fn allows_only_selected_sections() -> Result {
         let mut config = gix_config::File::new(Metadata::api());
         config.set_raw_value_by("a", None, "b", "c")?;
 
diff --git a/gix-config/tests/config/parse/error.rs b/gix-config/tests/config/parse/error.rs
index b9ece239e4e..8ea9539984a 100644
--- a/gix-config/tests/config/parse/error.rs
+++ b/gix-config/tests/config/parse/error.rs
@@ -2,59 +2,50 @@ use crate::parse::Events;
 
 #[test]
 fn line_no_is_one_indexed() {
-    assert_eq!(Events::from_str("[hello").unwrap_err().line_number(), 1);
+    let err = Events::from_str("[hello").expect_err("the section header is unterminated");
+    assert_eq!(err.line_number(), 1);
+    insta::assert_debug_snapshot!(format_args!("{err}"), "parser diagnostics use one-based line numbers", @"Got an unexpected token on line 1 while trying to parse a section header: '[hello'");
 }
 
 #[test]
-fn remaining_data_contains_bad_tokens() {
-    assert_eq!(Events::from_str("[hello").unwrap_err().remaining_data(), b"[hello");
+fn malformed_input_retains_validation_and_bad_tokens() {
+    use gix_error::ErrorExt;
+
+    let err = Events::from_str("[hello")
+        .expect_err("the section header is unterminated")
+        .raise();
+    insta::assert_debug_snapshot!(err, "malformed configuration retains the offending input", @"Got an unexpected token on line 1 while trying to parse a section header: '[hello'");
+    assert!(err.is_validation(), "malformed configuration is invalid input");
+    assert!(
+        err.probable_cause().is::<gix_config::parse::Error>(),
+        "the parser error, not its classification marker, is the probable cause"
+    );
+    assert_eq!(err.remaining_data(), b"[hello", "the parser retains the unparsed input");
 }
 
 #[test]
 fn to_string_truncates_extra_values() {
-    assert_eq!(
-        Events::from_str("[1234567890").unwrap_err().to_string(),
-        "Got an unexpected token on line 1 while trying to parse a section header: '[123456789' ... (1 characters omitted)"
-    );
+    let err = Events::from_str("[1234567890").expect_err("the section header is unterminated");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "long invalid tokens show ten characters and the omitted length", @"Got an unexpected token on line 1 while trying to parse a section header: '[123456789' ... (1 characters omitted)");
 }
 
 #[test]
 fn to_string() {
-    let input = "[a_b]\n c=d";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 1 while trying to parse a section header: '[a_b]\n c=d'",
-        "underscores in section names aren't allowed and will be rejected by git"
-    );
-    let input = "[core] a=b\\\n cd\n[core]\n\n 4a=3";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 5 while trying to parse a name: '4a=3'"
-    );
-    let input = "[core] a=b\\\n cd\n 4a=3";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 3 while trying to parse a name: '4a=3'"
-    );
-    let input = "[core] a=b\n 4a=3";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 2 while trying to parse a name: '4a=3'"
-    );
-    let input = "[core] a=b\n =3";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 2 while trying to parse a name: '=3'"
-    );
-    let input = "[core";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 1 while trying to parse a section header: '[core'"
-    );
-    let input = "[a]\n\tb \u{8}\n";
-    assert_eq!(
-        Events::from_str(input).unwrap_err().to_string(),
-        "Got an unexpected token on line 2 while trying to parse a name: '\u{8}\n'",
-        "Git rejects backspace as trailing whitespace after an implicit boolean"
-    );
+    let err = Events::from_str("[a_b]\n c=d").expect_err("underscores are invalid in section names");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "underscores in section names are rejected by Git", @"
+    Got an unexpected token on line 1 while trying to parse a section header: '[a_b]
+     c=d'
+    ");
+    let err = Events::from_str("[core] a=b\\\n cd\n[core]\n\n 4a=3").expect_err("names cannot start with a digit");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "line numbers include continuations, section headers, and blank lines", @"Got an unexpected token on line 5 while trying to parse a name: '4a=3'");
+    let err = Events::from_str("[core] a=b\\\n cd\n 4a=3").expect_err("names cannot start with a digit");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "line numbers include continued values", @"Got an unexpected token on line 3 while trying to parse a name: '4a=3'");
+    let err = Events::from_str("[core] a=b\n 4a=3").expect_err("names cannot start with a digit");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "an invalid name is reported with its line and unparsed input", @"Got an unexpected token on line 2 while trying to parse a name: '4a=3'");
+    let err = Events::from_str("[core] a=b\n =3").expect_err("names cannot be empty");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "a missing name reports the remaining assignment", @"Got an unexpected token on line 2 while trying to parse a name: '=3'");
+    let err = Events::from_str("[core").expect_err("the section header is unterminated");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "an unterminated header identifies the section parser", @"Got an unexpected token on line 1 while trying to parse a section header: '[core'");
+    let err = Events::from_str("[a]\n\tb \u{8}\n").expect_err("backspace is not trailing whitespace");
+    insta::assert_debug_snapshot!(format_args!("{err}"), "Git rejects backspace as trailing whitespace after an implicit boolean", @"Got an unexpected token on line 2 while trying to parse a name: '\u{8}\n'");
 }
diff --git a/gix-config/tests/config/parse/section.rs b/gix-config/tests/config/parse/section.rs
index f61d71b97f8..977bb6c550f 100644
--- a/gix-config/tests/config/parse/section.rs
+++ b/gix-config/tests/config/parse/section.rs
@@ -11,48 +11,68 @@ pub fn header_event(name: &'static str, subsection: impl Into<Option<&'static st
 
 mod header {
     use gix_config::file::IntoBStringOpt;
+    use gix_error::ExnMessageResult;
 
-    fn serialized(
-        name: &str,
-        subsection: impl IntoBStringOpt,
-    ) -> Result<bstr::BString, gix_config::parse::section::header::Error> {
+    fn serialized(name: &str, subsection: impl IntoBStringOpt) -> ExnMessageResult<bstr::BString> {
         let mut config = gix_config::File::default();
         let section = config.new_section(name, subsection.into_bstring_opt())?;
         Ok(section.header().to_bstring())
     }
 
     mod write_to {
+        use crate::Result;
         use crate::parse::section::header::serialized;
 
         #[test]
-        fn subsection_backslashes_and_quotes_are_escaped() -> crate::Result {
+        fn subsection_backslashes_and_quotes_are_escaped() -> Result {
             assert_eq!(serialized("core", r"a\b")?, r#"[core "a\\b"]"#);
             assert_eq!(serialized("core", r#"a:"b""#)?, r#"[core "a:\"b\""]"#);
             Ok(())
         }
 
         #[test]
-        fn everything_is_allowed() -> crate::Result {
+        fn everything_is_allowed() -> Result {
             assert_eq!(serialized("core", "a/b \t\t a\\b")?, "[core \"a/b \t\t a\\\\b\"]");
             Ok(())
         }
     }
     mod new {
-        use gix_config::parse::section;
-
         use crate::parse::section::header::serialized;
 
         #[test]
         fn names_must_be_mostly_ascii() {
+            let mut message_diagnostics = Vec::new();
             for name in ["🤗", "x.y", "x y", "x\ny"] {
-                assert_eq!(serialized(name, None), Err(section::header::Error::InvalidName));
+                message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                    &(serialized(name, None).expect_err("name must be rejected")),
+                    &[],
+                ));
             }
+            insta::assert_debug_snapshot!(message_diagnostics, "names must be mostly ascii", @r#"
+            [
+                section names can only be ascii, '-', "input"="🤗",
+                section names can only be ascii, '-', "input"="x.y",
+                section names can only be ascii, '-', "input"="x y",
+                section names can only be ascii, '-', "input"="x\ny",
+            ]
+            "#);
         }
 
         #[test]
         fn subsections_with_newlines_and_null_bytes_are_rejected() {
-            assert_eq!(serialized("a", "a\nb"), Err(section::header::Error::InvalidSubSection));
-            assert_eq!(serialized("a", "a\0b"), Err(section::header::Error::InvalidSubSection));
+            let mut message_diagnostics = Vec::new();
+            for subsection in ["a\nb", "a\0b"] {
+                message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                    &(serialized("a", subsection).expect_err("subsection must be rejected")),
+                    &[],
+                ));
+            }
+            insta::assert_debug_snapshot!(message_diagnostics, "subsections with newlines and null bytes are rejected", @r#"
+            [
+                sub-section names must not contain newlines or null bytes, "input"="a\nb",
+                sub-section names must not contain newlines or null bytes, "input"="a\0b",
+            ]
+            "#);
         }
     }
 }
diff --git a/gix-credentials/Cargo.toml b/gix-credentials/Cargo.toml
index b001e539398..5a30219d164 100644
--- a/gix-credentials/Cargo.toml
+++ b/gix-credentials/Cargo.toml
@@ -30,7 +30,6 @@ gix-prompt = { version = "^0.17.0", path = "../gix-prompt" }
 gix-date = { version = "^0.16.0", path = "../gix-date" }
 gix-trace = { version = "^0.1.21", path = "../gix-trace" }
 
-thiserror = "2.0.18"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 
@@ -39,6 +38,7 @@ bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-sec = { path = "../gix-sec" }
 gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 
diff --git a/gix-credentials/examples/custom-helper.rs b/gix-credentials/examples/custom-helper.rs
index a678b9193c9..ea830f8ed30 100644
--- a/gix-credentials/examples/custom-helper.rs
+++ b/gix-credentials/examples/custom-helper.rs
@@ -1,22 +1,24 @@
 use gix_credentials::{program, protocol};
+use gix_error::ErrorExt;
+use gix_error::ExnResult;
 
 /// Run like this `echo url=https://example.com | cargo run --example custom-helper -- get`
-pub fn main() -> Result<(), gix_credentials::program::main::Error> {
+pub fn main() -> ExnResult {
     gix_credentials::program::main(
         std::env::args_os().skip(1),
         std::io::stdin(),
         std::io::stdout(),
         protocol::ContextOptions::default(),
-        |action, context| -> std::io::Result<_> {
+        |action, context| -> ExnResult<_> {
             match action {
                 program::main::Action::Get => Ok(Some(protocol::Context {
                     username: Some("user".into()),
                     password: Some("pass".into()),
                     ..context
                 })),
-                program::main::Action::Erase => Err(std::io::Error::other(
-                    "Refusing to delete credentials for demo purposes",
-                )),
+                program::main::Action::Erase => {
+                    Err(gix_error::message("Refusing to delete credentials for demo purposes").raise_erased())
+                }
                 program::main::Action::Store => Ok(None),
             }
         },
diff --git a/gix-credentials/examples/git-credential-lite.rs b/gix-credentials/examples/git-credential-lite.rs
index 8c7c2fb2b7b..c53a7a62c98 100644
--- a/gix-credentials/examples/git-credential-lite.rs
+++ b/gix-credentials/examples/git-credential-lite.rs
@@ -1,5 +1,6 @@
+use gix_error::ExnResult;
 /// Run like this `echo url=https://example.com | cargo run --example git-credential-light -- fill`
-pub fn main() -> Result<(), gix_credentials::program::main::Error> {
+pub fn main() -> ExnResult {
     gix_credentials::program::main(
         std::env::args_os().skip(1),
         std::io::stdin(),
diff --git a/gix-credentials/examples/invoke-git-credential.rs b/gix-credentials/examples/invoke-git-credential.rs
index 5d4f780f7aa..cc6a14e9fed 100644
--- a/gix-credentials/examples/invoke-git-credential.rs
+++ b/gix-credentials/examples/invoke-git-credential.rs
@@ -1,5 +1,5 @@
 /// Invokes `git credential` with the passed url as argument and prints obtained credentials.
-pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+pub fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let out = gix_credentials::builtin(gix_credentials::helper::Action::get_for_url(
         std::env::args()
             .nth(1)
diff --git a/gix-credentials/src/helper/cascade.rs b/gix-credentials/src/helper/cascade.rs
index 42cb4073354..74126888c59 100644
--- a/gix-credentials/src/helper/cascade.rs
+++ b/gix-credentials/src/helper/cascade.rs
@@ -4,6 +4,7 @@ use crate::{
     protocol,
     protocol::{Context, ContextOptions},
 };
+use gix_error::ResultExt;
 
 impl Default for Cascade {
     fn default() -> Self {
@@ -75,14 +76,10 @@ impl Cascade {
     /// When _getting_ credentials, all programs are asked until the credentials are complete, stopping the cascade.
     /// When _storing_ or _erasing_ all programs are instructed in order.
     /// The input context is validated even if no helpers are available.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
     pub fn invoke(&mut self, mut action: helper::Action, mut prompt: gix_prompt::Options) -> protocol::Result {
         if let Some(ctx) = action.context_mut() {
             ctx.options = self.context_options;
-            ctx.write_to(std::io::sink()).map_err(helper::Error::from)?;
+            ctx.write_to(std::io::sink()).or_erased()?;
         }
         let mut url = action
             .context_mut()
@@ -119,7 +116,7 @@ impl Cascade {
                         www_authenticate: _,
                         url: ctx_url,
                         quit,
-                    } = Context::from_bytes(&stdout, self.context_options)?;
+                    } = Context::from_bytes(&stdout, self.context_options).or_erased()?;
                     if let Some(dst_ctx) = action.context_mut() {
                         if let Some(src) = path {
                             dst_ctx.path = Some(src);
@@ -158,8 +155,8 @@ impl Cascade {
                         }
                     }
                 }
-                Err(helper::Error::CredentialsHelperFailed { .. }) => continue, // ignore helpers that we can't call
-                Err(err) if action.context().is_some() => return Err(err.into()), // communication errors are fatal when getting credentials
+                Err(err) if err.is_retryable() => continue,
+                Err(err) if action.context().is_some() => return Err(err), // communication errors are fatal when getting credentials
                 Err(_) => {} // for other actions, ignore everything, try the operation
             }
         }
@@ -172,20 +169,14 @@ impl Cascade {
                 let message = ctx.to_prompt("Username");
                 prompt.mode = gix_prompt::Mode::Visible;
                 ctx.username = gix_prompt::ask(&message, &prompt)
-                    .map_err(|err| protocol::Error::Prompt {
-                        prompt: message,
-                        source: err,
-                    })?
+                    .or_raise_erased(|| gix_error::message!("Couldn't obtain {message}"))?
                     .into();
             }
             if ctx.password.is_none() {
                 let message = ctx.to_prompt("Password");
                 prompt.mode = gix_prompt::Mode::Hidden;
                 ctx.password = gix_prompt::ask(&message, &prompt)
-                    .map_err(|err| protocol::Error::Prompt {
-                        prompt: message,
-                        source: err,
-                    })?
+                    .or_raise_erased(|| gix_error::message!("Couldn't obtain {message}"))?
                     .into();
             }
         }
diff --git a/gix-credentials/src/helper/invoke.rs b/gix-credentials/src/helper/invoke.rs
index e922af0ad68..1b019709ebf 100644
--- a/gix-credentials/src/helper/invoke.rs
+++ b/gix-credentials/src/helper/invoke.rs
@@ -1,6 +1,8 @@
 use std::io::Read;
 
-use crate::helper::{Action, Context, Error, NextAction, Outcome, Result};
+use gix_error::{Class, ClassificationMarker, ErrorExt, ExnResult, ResultExt, message};
+
+use crate::helper::{Action, Context, NextAction, Outcome, Result};
 
 impl Action {
     /// Send ourselves to the given `write` which is expected to be credentials-helper compatible
@@ -27,7 +29,7 @@ pub fn invoke(helper: &mut crate::Program, action: &Action) -> Result {
     match raw(helper, action)? {
         None => Ok(None),
         Some(stdout) => {
-            let ctx = Context::from_bytes(stdout.as_slice(), options)?;
+            let ctx = Context::from_bytes(stdout.as_slice(), options).or_erased()?;
             Ok(Some(Outcome {
                 username: ctx.username,
                 password: ctx.password,
@@ -42,12 +44,13 @@ pub fn invoke(helper: &mut crate::Program, action: &Action) -> Result {
     }
 }
 
-pub(crate) fn raw(helper: &mut crate::Program, action: &Action) -> std::result::Result<Option<Vec<u8>>, Error> {
-    let (mut stdin, stdout) = helper.start(action)?;
+pub(crate) fn raw(helper: &mut crate::Program, action: &Action) -> ExnResult<Option<Vec<u8>>> {
+    let communication_error = || message("An IO error occurred while communicating to the credentials helper");
+    let (mut stdin, stdout) = helper.start(action).or_raise_erased(communication_error)?;
     if let (Action::Get(_), None) = (&action, &stdout) {
         panic!("BUG: `Helper` impls must return an output handle to read output from if Action::Get is provided")
     }
-    action.send(&mut stdin)?;
+    action.send(&mut stdin).or_raise_erased(communication_error)?;
     drop(stdin);
     let stdout = stdout
         .map(|mut stdout| {
@@ -55,12 +58,12 @@ pub(crate) fn raw(helper: &mut crate::Program, action: &Action) -> std::result::
             stdout.read_to_end(&mut buf).map(|_| buf)
         })
         .transpose()
-        .map_err(|err| Error::CredentialsHelperFailed { source: err })?;
+        .map_err(|err| ClassificationMarker::with_source(Class::Retryable, err).raise_erased())?;
     helper.finish().map_err(|err| {
         if err.kind() == std::io::ErrorKind::Other {
-            Error::CredentialsHelperFailed { source: err }
+            ClassificationMarker::with_source(Class::Retryable, err).raise_erased()
         } else {
-            err.into()
+            err.and_raise(communication_error()).erased()
         }
     })?;
 
diff --git a/gix-credentials/src/helper/mod.rs b/gix-credentials/src/helper/mod.rs
index 49641470606..73c7b0668df 100644
--- a/gix-credentials/src/helper/mod.rs
+++ b/gix-credentials/src/helper/mod.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString};
+use gix_error::{Exn, ExnResult, Message};
 
 use crate::{Program, protocol, protocol::Context};
 
@@ -54,19 +55,7 @@ impl Outcome {
 }
 
 /// The Result type used in [`invoke()`][crate::helper::invoke()].
-pub type Result = std::result::Result<Option<Outcome>, Error>;
-
-/// The error used in the [credentials helper invocation][crate::helper::invoke()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    ContextDecode(#[from] protocol::context::decode::Error),
-    #[error("An IO error occurred while communicating to the credentials helper")]
-    Io(#[from] std::io::Error),
-    #[error(transparent)]
-    CredentialsHelperFailed { source: std::io::Error },
-}
+pub type Result = ExnResult<Option<Outcome>>;
 
 /// The action to perform by the credentials [helper][`crate::helper::invoke()`].
 #[derive(Clone, Debug)]
@@ -147,7 +136,7 @@ pub struct NextAction {
 }
 
 impl TryFrom<&NextAction> for Context {
-    type Error = protocol::context::decode::Error;
+    type Error = Exn<Message>;
 
     fn try_from(value: &NextAction) -> std::result::Result<Self, Self::Error> {
         Context::from_bytes(value.previous_output.as_ref(), value.options)
diff --git a/gix-credentials/src/lib.rs b/gix-credentials/src/lib.rs
index 039bf978189..9500800004b 100644
--- a/gix-credentials/src/lib.rs
+++ b/gix-credentials/src/lib.rs
@@ -33,10 +33,6 @@ pub mod protocol;
 /// and does everything `git` typically does. The `action` should have been created with [`helper::Action::get_for_url()`] to
 /// contain only the URL to kick off the process, or should be created by [`helper::NextAction`].
 /// If more control is required, use the [`Cascade`][helper::Cascade] type.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 pub fn builtin(action: helper::Action) -> protocol::Result {
     protocol::helper_outcome_to_result(
         helper::invoke(&mut Program::from_kind(program::Kind::Builtin), &action)?,
diff --git a/gix-credentials/src/program/main.rs b/gix-credentials/src/program/main.rs
index e7ef34cfc0a..4a99104b81a 100644
--- a/gix-credentials/src/program/main.rs
+++ b/gix-credentials/src/program/main.rs
@@ -1,6 +1,6 @@
 use std::ffi::OsString;
 
-use bstr::BString;
+use gix_error::{Message, validation};
 
 /// The action passed to the credential helper implementation in [`main()`][crate::program::main()].
 #[derive(Debug, Copy, Clone)]
@@ -14,14 +14,21 @@ pub enum Action {
 }
 
 impl TryFrom<OsString> for Action {
-    type Error = Error;
+    type Error = Message;
 
+    /// Invalid action bytes are stored as `input` in [`Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     fn try_from(value: OsString) -> Result<Self, Self::Error> {
         Ok(match value.to_str() {
             Some("fill" | "get") => Action::Get,
             Some("approve" | "store") => Action::Store,
             Some("reject" | "erase") => Action::Erase,
-            _ => return Err(Error::ActionInvalid { name: value }),
+            _ => {
+                return Err(validation(
+                    "Action is invalid, need 'get', 'store', 'erase' or 'fill', 'approve', 'reject'",
+                )
+                .with("input", value.as_encoded_bytes()));
+            }
         })
     }
 }
@@ -37,33 +44,13 @@ impl Action {
     }
 }
 
-/// The error of [`main()`][crate::program::main()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Action named {name:?} is invalid, need 'get', 'store', 'erase' or 'fill', 'approve', 'reject'")]
-    ActionInvalid { name: OsString },
-    #[error("The first argument must be the action to perform")]
-    ActionMissing,
-    #[error(transparent)]
-    Helper {
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-    #[error(transparent)]
-    Context(#[from] crate::protocol::context::decode::Error),
-    #[error("Credentials for {url:?} could not be obtained")]
-    CredentialsMissing { url: BString },
-    #[error("Either 'url' field or both 'protocol' and 'host' fields must be provided")]
-    UrlMissing,
-}
-
 pub(crate) mod function {
     use std::ffi::OsString;
 
+    use gix_error::{ErrorExt, ExnResult, ResultExt, validation};
+
     use crate::{
-        program::main::{Action, Error},
+        program::main::Action,
         protocol::{Context, ContextOptions},
     };
 
@@ -75,25 +62,30 @@ pub(crate) mod function {
     ///
     /// Call this function from a programs `main`, passing `std::env::args_os()`, `stdin()` and `stdout` accordingly, along with
     /// the context encoding `options` and your own helper implementation.
-    pub fn main<CredentialsFn, E>(
+    pub fn main<CredentialsFn>(
         args: impl IntoIterator<Item = OsString>,
         mut stdin: impl std::io::Read,
         stdout: impl std::io::Write,
         options: ContextOptions,
         credentials: CredentialsFn,
-    ) -> Result<(), Error>
+    ) -> ExnResult
     where
-        CredentialsFn: FnOnce(Action, Context) -> Result<Option<Context>, E>,
-        E: std::error::Error + Send + Sync + 'static,
+        CredentialsFn: FnOnce(Action, Context) -> ExnResult<Option<Context>>,
     {
-        let action: Action = args.into_iter().next().ok_or(Error::ActionMissing)?.try_into()?;
+        let action = args
+            .into_iter()
+            .next()
+            .ok_or_else(|| validation("The first argument must be the action to perform").raise_erased())?;
+        let action = Action::try_from(action).or_erased()?;
         let mut buf = Vec::<u8>::with_capacity(512);
-        stdin.read_to_end(&mut buf)?;
-        let ctx = Context::from_bytes(&buf, options)?;
+        stdin.read_to_end(&mut buf).or_erased()?;
+        let ctx = Context::from_bytes(&buf, options).or_erased()?;
         if ctx.url.is_none() && (ctx.protocol.is_none() || ctx.host.is_none()) {
-            return Err(Error::UrlMissing);
+            return Err(
+                validation("Either 'url' field or both 'protocol' and 'host' fields must be provided").raise_erased(),
+            );
         }
-        let res = credentials(action, ctx.clone()).map_err(|err| Error::Helper { source: Box::new(err) })?;
+        let res = credentials(action, ctx.clone())?;
         match (action, res) {
             (Action::Get, None) => {
                 let ctx_for_error = ctx;
@@ -102,11 +94,13 @@ pub(crate) mod function {
                     .clone()
                     .or_else(|| ctx_for_error.to_url())
                     .expect("URL is available either directly or via protocol+host which we checked for");
-                return Err(Error::CredentialsMissing { url });
+                return Err(
+                    gix_error::not_found(format!("Credentials for {url:?} could not be obtained")).raise_erased(),
+                );
             }
             (Action::Get, Some(mut ctx)) => {
                 ctx.options = options;
-                ctx.write_to(stdout)?;
+                ctx.write_to(stdout).or_erased()?;
             }
             (Action::Erase | Action::Store, None) => {}
             (Action::Erase | Action::Store, Some(_)) => {
diff --git a/gix-credentials/src/protocol/context/mod.rs b/gix-credentials/src/protocol/context/mod.rs
index f71d124aa95..dae6e3029fe 100644
--- a/gix-credentials/src/protocol/context/mod.rs
+++ b/gix-credentials/src/protocol/context/mod.rs
@@ -2,14 +2,6 @@ use bstr::BString;
 
 use crate::protocol::{Context, ContextOptions};
 
-/// Indicates key or values contain errors that can't be encoded.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("{key:?}={value:?} must not contain null bytes or newlines neither in key nor in value.")]
-    Encoding { key: String, value: BString },
-}
-
 impl Context {
     /// Create a context containing `url`, encoded and decoded according to `options`.
     pub fn from_url(url: impl Into<BString>, options: ContextOptions) -> Self {
@@ -99,25 +91,24 @@ mod access {
 
 mod mutate {
     use bstr::ByteSlice;
+    use gix_error::ExnResult;
+    use gix_error::{OptionExt, ResultExt, validation};
 
-    use crate::{protocol, protocol::Context};
+    use crate::protocol::Context;
 
     /// In-place mutation
     impl Context {
         /// Destructure the url at our `url` field into parts like protocol, host, username and path and store
         /// them in our respective fields. If `use_http_path` is set, http paths are significant even though
         /// normally this isn't the case.
-        #[expect(
-            clippy::result_large_err,
-            reason = "will be removed once `gix-error` is used consistently"
-        )]
-        pub fn destructure_url_in_place(&mut self, use_http_path: bool) -> Result<&mut Self, protocol::Error> {
+        pub fn destructure_url_in_place(&mut self, use_http_path: bool) -> ExnResult<&mut Self> {
             if self.url.is_none() {
-                self.url = Some(self.to_url().ok_or(protocol::Error::UrlMissing)?);
+                self.url = Some(self.to_url().ok_or_raise_erased(|| {
+                    validation("Either 'url' field or both 'protocol' and 'host' fields must be provided")
+                })?);
             }
 
-            let url = gix_url::parse(self.url.as_ref().expect("URL is present after check above"))
-                .map_err(gix_error::Exn::into_error)?;
+            let url = gix_url::parse(self.url.as_ref().expect("URL is present after check above")).or_erased()?;
             self.protocol = Some(url.scheme.as_str().into());
             self.username = url.user().map(ToOwned::to_owned);
             self.password = url.password().map(ToOwned::to_owned);
diff --git a/gix-credentials/src/protocol/context/serde.rs b/gix-credentials/src/protocol/context/serde.rs
index b66bdf0062f..f543f0816fa 100644
--- a/gix-credentials/src/protocol/context/serde.rs
+++ b/gix-credentials/src/protocol/context/serde.rs
@@ -1,6 +1,5 @@
 use bstr::BStr;
-
-use crate::protocol::context::Error;
+use gix_error::ExnMessageResult;
 
 mod write {
     use bstr::{BStr, BString};
@@ -9,6 +8,9 @@ mod write {
 
     impl Context {
         /// Write ourselves to `out` such that [`from_bytes()`][Self::from_bytes()] can decode it losslessly.
+        /// Invalid field values are retained as `input` bytes in the I/O error.
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
         pub fn write_to(&self, mut out: impl std::io::Write) -> std::io::Result<()> {
             use bstr::ByteSlice;
             fn write_key(out: &mut impl std::io::Write, key: &str, value: &BStr) -> std::io::Result<()> {
@@ -75,26 +77,19 @@ mod write {
 
 ///
 pub mod decode {
-    use bstr::{BString, ByteSlice};
-
-    use crate::protocol::{Context, ContextOptions, context, context::serde::validate};
+    use bstr::ByteSlice;
+    use gix_error::ExnMessageResult;
+    use gix_error::validation;
 
-    /// The error returned by [`from_bytes()`][Context::from_bytes()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Illformed UTF-8 in value of key {key:?}: {value:?}")]
-        IllformedUtf8InValue { key: String, value: BString },
-        #[error(transparent)]
-        Encoding(#[from] context::Error),
-        #[error("Invalid format in line {line:?}, expecting key=value")]
-        Syntax { line: BString },
-    }
+    use crate::protocol::{Context, ContextOptions, context::serde::validate};
 
     impl Context {
         /// Decode ourselves from `input` which is the format written by [`write_to()`][Self::write_to()].
         /// `options` control what to support during deserialization.
-        pub fn from_bytes(input: &[u8], options: ContextOptions) -> Result<Self, Error> {
+        /// Invalid line or value bytes are stored as `input` in [`gix_error::Message::values`].
+        /// After [wrapping](gix_error::Error::from_error()), inspect them with
+        /// [metadata](gix_error::Error::metadata()).
+        pub fn from_bytes(input: &[u8], options: ContextOptions) -> ExnMessageResult<Self> {
             let mut ctx = Context {
                 options,
                 ..Context::default()
@@ -118,17 +113,21 @@ pub mod decode {
                     it.next().and_then(|k| k.to_str().ok()),
                     it.next().map(ByteSlice::as_bstr),
                 ) {
-                    (Some(key), Some(value)) => validate(key, value, options.protect_protocol)
-                        .map(|_| (key, value.to_owned()))
-                        .map_err(Into::into),
-                    _ => Err(Error::Syntax { line: line.into() }),
+                    (Some(key), Some(value)) => {
+                        validate(key, value, options.protect_protocol).map(|_| (key, value.to_owned()))
+                    }
+                    _ => Err(validation("Invalid format, expecting key=value")
+                        .with("input", line)
+                        .into()),
                 }
             }) {
                 let (key, value) = res?;
                 match key {
                     "protocol" | "host" | "username" | "password" | "oauth_refresh_token" => {
                         if !value.is_utf8() {
-                            return Err(Error::IllformedUtf8InValue { key: key.into(), value });
+                            return Err(validation(format!("Illformed UTF-8 in value of key {key:?}"))
+                                .with("input", value)
+                                .into());
                         }
                         let value = value.to_string();
                         *match key {
@@ -159,7 +158,7 @@ pub mod decode {
     }
 }
 
-fn validate(key: &str, value: &BStr, protect_protocol: bool) -> Result<(), Error> {
+fn validate(key: &str, value: &BStr, protect_protocol: bool) -> ExnMessageResult {
     if key.contains('\0')
         || key.contains('\n')
         || key.contains('\r')
@@ -167,10 +166,11 @@ fn validate(key: &str, value: &BStr, protect_protocol: bool) -> Result<(), Error
         || value.contains(&b'\n')
         || (protect_protocol && value.contains(&b'\r'))
     {
-        return Err(Error::Encoding {
-            key: key.to_owned(),
-            value: value.to_owned(),
-        });
+        return Err(gix_error::validation(format!(
+            "{key:?}={value:?} must not contain null bytes or newlines neither in key nor in value."
+        ))
+        .with("input", value)
+        .into());
     }
     Ok(())
 }
diff --git a/gix-credentials/src/protocol/mod.rs b/gix-credentials/src/protocol/mod.rs
index 9279e2c1113..f1c84419b15 100644
--- a/gix-credentials/src/protocol/mod.rs
+++ b/gix-credentials/src/protocol/mod.rs
@@ -1,4 +1,6 @@
 use bstr::BString;
+use gix_error::ErrorExt;
+use gix_error::ExnResult;
 
 use crate::helper;
 
@@ -12,32 +14,7 @@ pub struct Outcome {
 }
 
 /// The Result type used in credentials top-level functions to obtain a complete identity.
-pub type Result = std::result::Result<Option<Outcome>, Error>;
-
-/// The error returned top-level credential functions.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    UrlParse(#[from] gix_error::Error),
-    #[error("Either 'url' field or both 'protocol' and 'host' fields must be provided")]
-    UrlMissing,
-    #[error(transparent)]
-    ContextDecode(#[from] context::decode::Error),
-    #[error(transparent)]
-    InvokeHelper(#[from] helper::Error),
-    #[error("Could not configure credential helpers")]
-    ConfigureCredentialHelpers {
-        #[source]
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-    #[error("Could not obtain identity for context: {}", { let mut buf = Vec::<u8>::new(); context.write_to(&mut buf).ok(); String::from_utf8_lossy(&buf).into_owned() })]
-    IdentityMissing { context: Context },
-    #[error("The handler asked to stop trying to obtain credentials")]
-    Quit,
-    #[error("Couldn't obtain {prompt}")]
-    Prompt { prompt: String, source: gix_prompt::Error },
-}
+pub type Result = ExnResult<Option<Outcome>>;
 
 /// Additional context to be passed to the credentials helper.
 #[derive(Debug, Default, Clone, Eq, PartialEq)]
@@ -88,31 +65,34 @@ impl Default for ContextOptions {
 }
 
 /// Convert the outcome of a helper invocation to a helper result, assuring that the identity is complete in the process.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 pub fn helper_outcome_to_result(outcome: Option<helper::Outcome>, action: helper::Action) -> Result {
     match (action, outcome) {
-        (helper::Action::Get(ctx), None) => Err(Error::IdentityMissing {
-            context: ctx.redacted(),
-        }),
+        (helper::Action::Get(ctx), None) => Err(identity_missing(ctx)),
         (helper::Action::Get(ctx), Some(mut outcome)) => match outcome.consume_identity() {
             Some(identity) => Ok(Some(Outcome {
                 identity,
                 next: outcome.next,
             })),
             None => Err(if outcome.quit {
-                Error::Quit
+                gix_error::message("The handler asked to stop trying to obtain credentials").raise_erased()
             } else {
-                Error::IdentityMissing {
-                    context: ctx.redacted(),
-                }
+                identity_missing(ctx)
             }),
         },
         (helper::Action::Store(_) | helper::Action::Erase(_), _ignore) => Ok(None),
     }
 }
 
+fn identity_missing(context: Context) -> gix_error::Exn {
+    let mut buf = Vec::new();
+    // Invalid protocol values must not prevent reporting the missing identity.
+    context.redacted().write_to(&mut buf).ok();
+    gix_error::not_found(format!(
+        "Could not obtain identity for context: {}",
+        String::from_utf8_lossy(&buf)
+    ))
+    .raise_erased()
+}
+
 ///
 pub mod context;
diff --git a/gix-credentials/tests/helper/cascade.rs b/gix-credentials/tests/helper/cascade.rs
index 26dc02d084e..de37ff3998c 100644
--- a/gix-credentials/tests/helper/cascade.rs
+++ b/gix-credentials/tests/helper/cascade.rs
@@ -1,4 +1,5 @@
 mod invoke {
+    use crate::Result;
     use bstr::ByteSlice;
     use gix_credentials::{
         Program,
@@ -10,6 +11,7 @@ mod invoke {
 
     #[test]
     fn invalid_authentication_challenges_fail_without_helpers() {
+        let mut error_snapshots = Vec::new();
         for value in [
             b"Basic realm=\"a\rb\"".as_slice(),
             b"Basic\nusername=other",
@@ -24,18 +26,29 @@ mod invoke {
                 }),
             )
             .expect_err("malformed authentication challenges must fail without panicking");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
             assert!(
-                matches!(
-                    err,
-                    protocol::Error::InvokeHelper(gix_credentials::helper::Error::Io(_))
-                ),
+                err.downcast_any_ref::<std::io::Error>().is_some(),
                 "protocol validation must run even when no helper is configured and prompting is disabled"
             );
         }
+        insta::assert_debug_snapshot!(error_snapshots, "invalid authentication challenges fail without helpers", @r#"
+        [
+            I/O error (Other)
+            |
+            └─ "wwwauth[]"="Basic realm=\"a\rb\"" must not contain null bytes or newlines neither in key nor in value., "input"="Basic realm=\"a\rb\"",
+            I/O error (Other)
+            |
+            └─ "wwwauth[]"="Basic\nusername=other" must not contain null bytes or newlines neither in key nor in value., "input"="Basic\nusername=other",
+            I/O error (Other)
+            |
+            └─ "wwwauth[]"="Basic\0realm=example" must not contain null bytes or newlines neither in key nor in value., "input"="Basic\0realm=example",
+        ]
+        "#);
     }
 
     #[test]
-    fn a_helper_closing_its_input_does_not_prevent_fallback_with_challenges() -> crate::Result {
+    fn a_helper_closing_its_input_does_not_prevent_fallback_with_challenges() -> Result {
         let outcome = Cascade::default()
             .extend([
                 Program::from_custom_definition("!f() { exit 1; }; f"),
@@ -54,7 +67,8 @@ mod invoke {
                     mode: gix_prompt::Mode::Disable,
                     askpass: None,
                 },
-            )?
+            )
+            .map_err(gix_error::Exn::into_error)?
             .expect("the fallback helper supplies a complete credential");
         assert_eq!(
             outcome.identity,
@@ -65,7 +79,7 @@ mod invoke {
     }
 
     #[test]
-    fn authentication_challenges_reach_all_helpers_until_credentials_are_complete() -> crate::Result {
+    fn authentication_challenges_reach_all_helpers_until_credentials_are_complete() -> Result {
         let outcome = Cascade::default()
             .extend([
                 Program::from_custom_definition("!f() { cat >/dev/null; echo username=user; }; f"),
@@ -89,7 +103,8 @@ mod invoke {
                     mode: gix_prompt::Mode::Disable,
                     askpass: None,
                 },
-            )?
+            )
+            .map_err(gix_error::Exn::into_error)?
             .expect("both helpers contribute to the credential");
         assert_eq!(
             outcome.identity,
@@ -297,7 +312,6 @@ mod invoke {
         }
     }
 
-    #[expect(clippy::result_large_err)]
     fn invoke_cascade<'a>(names: impl IntoIterator<Item = &'a str>, action: Action) -> protocol::Result {
         Cascade::default().use_http_path(true).extend(fixtures(names)).invoke(
             action,
diff --git a/gix-credentials/tests/helper/context.rs b/gix-credentials/tests/helper/context.rs
index da8dc96238b..98ac8a8593d 100644
--- a/gix-credentials/tests/helper/context.rs
+++ b/gix-credentials/tests/helper/context.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_credentials::protocol::{Context, ContextOptions};
 
 #[test]
-fn authentication_challenges_survive_a_protocol_roundtrip() -> crate::Result {
+fn authentication_challenges_survive_a_protocol_roundtrip() -> Result {
     let input = b"protocol=https
 host=github.com
 wwwauth[]=Basic realm=\"GitHub\" domain_hint=\"example\"
@@ -86,6 +87,7 @@ mod write_to {
 
     #[test]
     fn record_delimiters_are_invalid() {
+        let mut error_snapshots = Vec::new();
         for input in [&b"foo\0"[..], b"foo\n", b"foo\r"] {
             let ctx = Context {
                 url: Some(input.into()),
@@ -93,8 +95,25 @@ mod write_to {
             };
             let mut buf = Vec::<u8>::new();
             let err = ctx.write_to(&mut buf).unwrap_err();
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
             assert_eq!(err.kind(), std::io::ErrorKind::Other);
         }
+        insta::assert_debug_snapshot!(error_snapshots, "record delimiters are invalid", @r#"
+        [
+            Custom {
+                kind: Other,
+                error: "url"="foo\0" must not contain null bytes or newlines neither in key nor in value., "input"="foo\0",
+            },
+            Custom {
+                kind: Other,
+                error: "url"="foo\n" must not contain null bytes or newlines neither in key nor in value., "input"="foo\n",
+            },
+            Custom {
+                kind: Other,
+                error: "url"="foo\r" must not contain null bytes or newlines neither in key nor in value., "input"="foo\r",
+            },
+        ]
+        "#);
     }
 
     #[test]
@@ -173,10 +192,7 @@ username=bob";
     #[test]
     fn null_bytes_when_decoding() {
         let err = Context::from_bytes(b"url=https://foo\0", ContextOptions::default()).unwrap_err();
-        assert!(matches!(
-            err,
-            gix_credentials::protocol::context::decode::Error::Encoding(_)
-        ));
+        insta::assert_debug_snapshot!(err, "null bytes when decoding", @r#""url"="https://foo\0" must not contain null bytes or newlines neither in key nor in value., "input"="https://foo\0""#);
     }
 
     #[test]
diff --git a/gix-credentials/tests/helper/invoke.rs b/gix-credentials/tests/helper/invoke.rs
index b4176e70442..c76031560c6 100644
--- a/gix-credentials/tests/helper/invoke.rs
+++ b/gix-credentials/tests/helper/invoke.rs
@@ -67,27 +67,31 @@ fn store_and_reject() {
 }
 
 mod program {
+    use crate::Result;
     use gix_credentials::{Program, helper, program::Kind};
 
     use crate::helper::script_helper;
 
     #[test]
-    fn builtin() -> crate::Result {
+    fn builtin() -> Result {
         // Other tests resolve fixture paths relative to the working directory, so change it only in a child.
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
         let temp = gix_testtools::tempfile::tempdir()?;
         let _cwd = gix_testtools::set_current_dir(temp.path())?;
+        let err = gix_credentials::helper::invoke(
+            &mut Program::from_kind(Kind::Builtin).suppress_stderr(),
+            &helper::Action::get_for_url("/path/without/scheme/fails/with/error"),
+        )
+        .expect_err("the builtin helper rejects a URL without a scheme");
+        insta::assert_debug_snapshot!(err, "this failure indicates we could launch the helper, even though it wasn't happy which is fine. It doesn't like the URL", @"
+        I/O error (Other)
+        |
+        └─ Credentials helper program failed with status code Some(128)
+        ");
         assert!(
-            matches!(
-                gix_credentials::helper::invoke(
-                    &mut Program::from_kind(Kind::Builtin).suppress_stderr(),
-                    &helper::Action::get_for_url("/path/without/scheme/fails/with/error"),
-                )
-                .unwrap_err(),
-                helper::Error::CredentialsHelperFailed { .. }
-            ),
+            err.is_retryable(),
             "this failure indicates we could launch the helper, even though it wasn't happy which is fine. It doesn't like the URL"
         );
         Ok(())
@@ -138,7 +142,7 @@ mod program {
     }
 
     #[test]
-    fn path_to_helper_as_script_to_workaround_executable_bits() -> crate::Result {
+    fn path_to_helper_as_script_to_workaround_executable_bits() -> Result {
         assert_eq!(
             gix_credentials::helper::invoke(
                 &mut script_helper("custom-helper"),
diff --git a/gix-credentials/tests/helper/mod.rs b/gix-credentials/tests/helper/mod.rs
index 867675c05fd..e3db117bd83 100644
--- a/gix-credentials/tests/helper/mod.rs
+++ b/gix-credentials/tests/helper/mod.rs
@@ -19,7 +19,40 @@ mod invoke_outcome_to_helper_result {
             action,
         )
         .unwrap_err();
-        assert!(matches!(err, protocol::Error::IdentityMissing { .. }));
+        insta::assert_debug_snapshot!(err, "missing username or password causes failure with get action", @"Could not obtain identity for context: url=does/not/matter");
+        assert!(err.is_not_found());
+    }
+
+    #[test]
+    fn invalid_context_still_reports_missing_identity() {
+        let mut error_snapshots = Vec::new();
+        for value in ["invalid\nvalue", "invalid\0value", "invalid\rvalue"] {
+            for context in [
+                protocol::Context::from_url(value, Default::default()),
+                protocol::Context {
+                    path: Some(value.into()),
+                    ..Default::default()
+                },
+            ] {
+                let err = helper_outcome_to_result(None, helper::Action::Get(context))
+                    .expect_err("Missing credentials must return an error even when the context is invalid");
+                error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+                assert!(
+                    err.is_not_found(),
+                    "Invalid context must not replace the missing-credentials classification"
+                );
+            }
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "invalid context still reports missing identity", @"
+        [
+            Could not obtain identity for context: ,
+            Could not obtain identity for context: ,
+            Could not obtain identity for context: ,
+            Could not obtain identity for context: ,
+            Could not obtain identity for context: ,
+            Could not obtain identity for context: ,
+        ]
+        ");
     }
 
     #[test]
@@ -36,7 +69,7 @@ mod invoke_outcome_to_helper_result {
             action,
         )
         .unwrap_err();
-        assert!(matches!(err, protocol::Error::Quit));
+        insta::assert_debug_snapshot!(err, "quit message in context causes special error ignoring missing identity", @"The handler asked to stop trying to obtain credentials");
     }
 }
 
diff --git a/gix-credentials/tests/program/main.rs b/gix-credentials/tests/program/main.rs
index 3b45dc8edfc..00596aca511 100644
--- a/gix-credentials/tests/program/main.rs
+++ b/gix-credentials/tests/program/main.rs
@@ -1,9 +1,19 @@
 use gix_credentials::program::main;
+use gix_error::ExnResult;
 use std::io::Cursor;
 
-#[derive(Debug, thiserror::Error)]
-#[error("Test error")]
-struct TestError;
+#[test]
+#[cfg(unix)]
+fn invalid_non_utf8_action_is_preserved() {
+    use std::{ffi::OsString, os::unix::ffi::OsStringExt};
+
+    let err = main::Action::try_from(OsString::from_vec(vec![0xff])).expect_err("the action is invalid");
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::Bytes(vec![0xff].into())),
+        "the invalid action is retained"
+    );
+}
 
 #[test]
 fn context_options_apply_to_input_and_output() {
@@ -18,7 +28,7 @@ fn context_options_apply_to_input_and_output() {
         Cursor::new(input),
         &mut output,
         options,
-        |_action, context| -> Result<Option<gix_credentials::protocol::Context>, TestError> {
+        |_action, context| -> ExnResult<Option<gix_credentials::protocol::Context>> {
             assert_eq!(
                 context.url.as_ref().map(|url| url.as_slice()),
                 Some(&input[4..input.len() - 1])
@@ -45,7 +55,7 @@ fn protocol_and_host_without_url_is_valid() {
         Cursor::new(input),
         &mut output,
         gix_credentials::protocol::ContextOptions::default(),
-        |_action, context| -> Result<Option<gix_credentials::protocol::Context>, TestError> {
+        |_action, context| -> ExnResult<Option<gix_credentials::protocol::Context>> {
             assert_eq!(context.protocol.as_deref(), Some("https"));
             assert_eq!(context.host.as_deref(), Some("github.com"));
             assert_eq!(context.url, None, "the URL isn't automatically populated");
@@ -57,19 +67,18 @@ fn protocol_and_host_without_url_is_valid() {
 
     // This should fail because our mock helper returned None (no credentials found)
     // but it should NOT fail because of missing URL
-    match result {
-        Err(gix_credentials::program::main::Error::CredentialsMissing { .. }) => {
-            assert!(
-                called,
-                "The helper gets called, but as nothing is provided in the function it ulimately fails"
-            );
-        }
-        other => panic!("Expected CredentialsMissing error, got: {other:?}"),
-    }
+    let err = result.expect_err("missing credentials must fail");
+    insta::assert_debug_snapshot!(err, "protocol and host without url is valid", @r#"Credentials for "https://github.com" could not be obtained"#);
+    assert!(err.is_not_found());
+    assert!(
+        called,
+        "The helper gets called, but as nothing is provided in the function it ultimately fails"
+    );
 }
 
 #[test]
 fn missing_protocol_with_only_host_or_protocol_fails() {
+    let mut error_snapshots = Vec::new();
     for input in ["host=github.com\n", "protocol=https\n"] {
         let mut output = Vec::new();
 
@@ -79,19 +88,23 @@ fn missing_protocol_with_only_host_or_protocol_fails() {
             Cursor::new(input),
             &mut output,
             gix_credentials::protocol::ContextOptions::default(),
-            |_action, _context| -> Result<Option<gix_credentials::protocol::Context>, TestError> {
+            |_action, _context| -> ExnResult<Option<gix_credentials::protocol::Context>> {
                 called = true;
                 Ok(None)
             },
         );
 
-        match result {
-            Err(gix_credentials::program::main::Error::UrlMissing) => {
-                assert!(!called, "the context is lacking, hence nothing gets called");
-            }
-            other => panic!("Expected UrlMissing error, got: {other:?}"),
-        }
+        let err = result.expect_err("incomplete URL must fail validation");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation());
+        assert!(!called, "the context is lacking, hence nothing gets called");
     }
+    insta::assert_debug_snapshot!(error_snapshots, "missing protocol with only host or protocol fails", @"
+    [
+        Either 'url' field or both 'protocol' and 'host' fields must be provided,
+        Either 'url' field or both 'protocol' and 'host' fields must be provided,
+    ]
+    ");
 }
 
 #[test]
@@ -105,7 +118,7 @@ fn url_alone_is_valid() {
         Cursor::new(input),
         &mut output,
         gix_credentials::protocol::ContextOptions::default(),
-        |_action, context| -> Result<Option<gix_credentials::protocol::Context>, TestError> {
+        |_action, context| -> ExnResult<Option<gix_credentials::protocol::Context>> {
             called = true;
             assert_eq!(context.url.unwrap(), "https://github.com");
             assert_eq!(context.host, None, "not auto-populated");
@@ -117,10 +130,8 @@ fn url_alone_is_valid() {
 
     // This should fail because our mock helper returned None (no credentials found)
     // but it should NOT fail because of missing URL
-    match result {
-        Err(gix_credentials::program::main::Error::CredentialsMissing { .. }) => {
-            assert!(called);
-        }
-        other => panic!("Expected CredentialsMissing error, got: {other:?}"),
-    }
+    let err = result.expect_err("missing credentials must fail");
+    insta::assert_debug_snapshot!(err, "url alone is valid", @r#"Credentials for "https://github.com" could not be obtained"#);
+    assert!(err.is_not_found());
+    assert!(called);
 }
diff --git a/gix-credentials/tests/protocol/context.rs b/gix-credentials/tests/protocol/context.rs
index 8a021f1ef6b..ad76fc7ecee 100644
--- a/gix-credentials/tests/protocol/context.rs
+++ b/gix-credentials/tests/protocol/context.rs
@@ -1,4 +1,5 @@
 mod destructure_url_in_place {
+    use crate::Result;
     use gix_credentials::protocol::Context;
 
     fn url_ctx(url: &str) -> Context {
@@ -38,7 +39,7 @@ mod destructure_url_in_place {
     }
 
     #[test]
-    fn passwords_are_placed_in_context_too() -> crate::Result {
+    fn passwords_are_placed_in_context_too() -> Result {
         let mut ctx = url_ctx("http://user:password@host/path");
         ctx.destructure_url_in_place(false)?;
         assert_eq!(ctx.password.as_deref(), Some("password"));
@@ -108,10 +109,7 @@ mod destructure_url_in_place {
             host: Some("github.com".into()),
             ..Default::default()
         };
-        assert_eq!(
-            ctx_no_protocol.destructure_url_in_place(false).unwrap_err().to_string(),
-            "Either 'url' field or both 'protocol' and 'host' fields must be provided"
-        );
+        insta::assert_debug_snapshot!(ctx_no_protocol.destructure_url_in_place(false).expect_err("missing protocol or host without url fails"), "missing protocol or host without url fails", @"Either 'url' field or both 'protocol' and 'host' fields must be provided");
 
         let mut ctx_no_host = Context {
             protocol: Some("https".into()),
diff --git a/gix-date/Cargo.toml b/gix-date/Cargo.toml
index 27611d0aa3e..383cbc147c6 100644
--- a/gix-date/Cargo.toml
+++ b/gix-date/Cargo.toml
@@ -28,6 +28,7 @@ jiff = "0.2.25"
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-hash = { path = "../gix-hash" }
 gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
 pretty_assertions = "1.4.1"
diff --git a/gix-date/src/lib.rs b/gix-date/src/lib.rs
index d61a94dd1ab..22de767aa63 100644
--- a/gix-date/src/lib.rs
+++ b/gix-date/src/lib.rs
@@ -34,8 +34,6 @@ pub mod parse;
 pub use jiff::Zoned;
 pub use parse::function::{parse, parse_header};
 
-pub use gix_error::ValidationError as Error;
-
 /// A timestamp with timezone.
 #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/gix-date/src/parse/function.rs b/gix-date/src/parse/function.rs
index bf803adf533..54dac5c32ee 100644
--- a/gix-date/src/parse/function.rs
+++ b/gix-date/src/parse/function.rs
@@ -5,17 +5,18 @@ use jiff::{Zoned, civil::Date, fmt::rfc2822, tz::TimeZone};
 use crate::parse::git::parse_git_date_format;
 use crate::parse::raw::parse_raw;
 use crate::{
-    Error, OffsetInSeconds, SecondsSinceUnixEpoch, Time,
+    OffsetInSeconds, SecondsSinceUnixEpoch, Time,
     parse::relative,
     time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
 };
-use gix_error::{Exn, ResultExt};
+use gix_error::{ExnMessageResult, ResultExt};
 
 /// The widest timezone offset git reads, as `match_tz()` in `date.c` takes the four digits as a
 /// clock time: hours below 24 and minutes below 60, so `+2359` is the last offset it accepts.
 const MAX_OFFSET_IN_SECONDS: i32 = 23 * 3600 + 59 * 60;
 
 /// Parse `input` as any time that Git can parse when inputting a date.
+/// Unknown formats and timezone conversion failures include `input` bytes as [metadata](gix_error::Exn::metadata()).
 ///
 /// ## Examples
 ///
@@ -101,7 +102,7 @@ const MAX_OFFSET_IN_SECONDS: i32 = 23 * 3600 + 59 * 60;
 ///
 /// In any of these formats, a timezone offset wider than `±23:59` is not a timezone to Git, so it
 /// is not accepted here either.
-pub fn parse(input: &str, now: Option<Zoned>) -> Result<Time, Exn<Error>> {
+pub fn parse(input: &str, now: Option<Zoned>) -> ExnMessageResult<Time> {
     // A leading `@` explicitly names epoch seconds, including small and negative values.
     if let Some(rest) = input.strip_prefix('@') {
         if let Some(val) = parse_raw(rest) {
@@ -114,7 +115,7 @@ pub fn parse(input: &str, now: Option<Zoned>) -> Result<Time, Exn<Error>> {
     let time = if let Ok(val) = Date::strptime(SHORT.0, input) {
         let val = val
             .to_zoned(TimeZone::UTC)
-            .or_raise(|| Error::new_with_input("Timezone conversion failed", input))?;
+            .or_raise(|| gix_error::validation("Timezone conversion failed").with("input", input.as_bytes()))?;
         Time::new(val.timestamp().as_second(), val.offset().seconds())
     } else if let Ok(val) = rfc2822_relaxed(input) {
         Time::new(val.timestamp().as_second(), val.offset().seconds())
@@ -140,12 +141,12 @@ pub fn parse(input: &str, now: Option<Zoned>) -> Result<Time, Exn<Error>> {
         // Format::Raw
         val
     } else {
-        return Err(Error::new_with_input("Unknown date format", input))?;
+        return Err(gix_error::validation("Unknown date format").with("input", input.as_bytes()))?;
     };
 
     // Jiff parses textual offsets up to 25:59:59, beyond Git's accepted range.
     if time.offset.abs() > MAX_OFFSET_IN_SECONDS {
-        Err(Error::new_with_input("Unknown date format", input))?;
+        Err(gix_error::validation("Unknown date format").with("input", input.as_bytes()))?;
     }
     Ok(time)
 }
diff --git a/gix-date/src/parse/mod.rs b/gix-date/src/parse/mod.rs
index ee40ae27ade..c7f559aa07a 100644
--- a/gix-date/src/parse/mod.rs
+++ b/gix-date/src/parse/mod.rs
@@ -1,7 +1,7 @@
 use std::io;
 use std::str::FromStr;
 
-use crate::{Error, Time};
+use crate::Time;
 
 /// A container for just enough bytes to hold the largest possible serialization of a [`Time`].
 #[derive(Default, Clone)]
@@ -64,10 +64,12 @@ impl Time {
 }
 
 impl FromStr for Time {
-    type Err = Error;
+    type Err = gix_error::Message;
 
+    /// Invalid time bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        crate::parse_header(s).ok_or_else(|| Error::new_with_input("invalid time", s))
+        crate::parse_header(s).ok_or_else(|| gix_error::validation("invalid time").with("input", s.as_bytes()))
     }
 }
 
diff --git a/gix-date/src/parse/relative.rs b/gix-date/src/parse/relative.rs
index 272bff7546a..3072a79dc08 100644
--- a/gix-date/src/parse/relative.rs
+++ b/gix-date/src/parse/relative.rs
@@ -1,10 +1,9 @@
 use std::str::FromStr;
 
-use crate::Error;
-use gix_error::{Exn, ResultExt, ValidationError};
+use gix_error::{ExnMessageResult, ResultExt, validation};
 use jiff::{SignedDuration, Zoned, civil, tz::TimeZone};
 
-pub fn parse(input: &str, now: Option<Zoned>) -> Option<Result<Zoned, Exn<Error>>> {
+pub fn parse(input: &str, now: Option<Zoned>) -> Option<ExnMessageResult<Zoned>> {
     // First try named dates
     if let Some(result) = parse_named(input, now.as_ref()) {
         return Some(result);
@@ -15,7 +14,7 @@ pub fn parse(input: &str, now: Option<Zoned>) -> Option<Result<Zoned, Exn<Error>
 }
 
 /// Parse named relative dates like "now", "today", "yesterday".
-fn parse_named(input: &str, now: Option<&Zoned>) -> Option<Result<Zoned, Exn<Error>>> {
+fn parse_named(input: &str, now: Option<&Zoned>) -> Option<ExnMessageResult<Zoned>> {
     let input = input.trim();
     let duration = if input.eq_ignore_ascii_case("now") {
         SignedDuration::ZERO
@@ -140,7 +139,7 @@ fn unit(period: &str, ago: bool) -> Option<(&str, Unit)> {
 /// Seconds-based units subtract from the timestamp, while months and years only step down the
 /// respective fields and normalize later, so that repeated units accumulate and a day beyond
 /// the end of the target month rolls over.
-fn subtract_pairs(now: Option<Zoned>, pairs: &[Pair<'_>]) -> Result<Zoned, Exn<Error>> {
+fn subtract_pairs(now: Option<Zoned>, pairs: &[Pair<'_>]) -> ExnMessageResult<Zoned> {
     /// The calendar and clock fields for subtraction.
     struct Fields {
         year: i16,
@@ -165,23 +164,24 @@ fn subtract_pairs(now: Option<Zoned>, pairs: &[Pair<'_>]) -> Result<Zoned, Exn<E
     impl Fields {
         /// Turn the fields back into a point in time: a day beyond the end of the month rolls over into the
         /// following month. One month before May 31st is thus May 1st, a day after April 30th.
-        fn normalize(&self) -> Result<Zoned, Exn<Error>> {
-            let first_of_month = civil::Date::new(self.year, self.month, 1)
-                .or_raise(|| Error::new(format!("Date lies out of range: {}-{:02}", self.year, self.month)))?;
+        fn normalize(&self) -> ExnMessageResult<Zoned> {
+            let first_of_month = civil::Date::new(self.year, self.month, 1).or_raise(|| {
+                gix_error::validation(format!("Date lies out of range: {}-{:02}", self.year, self.month))
+            })?;
             let days_beyond_first = SignedDuration::from_secs((i64::from(self.day) - 1) * 24 * 60 * 60);
             first_of_month
                 .checked_add(days_beyond_first)
-                .or_raise(|| Error::new(format!("Day {} lies out of range", self.day)))?
+                .or_raise(|| gix_error::validation(format!("Day {} lies out of range", self.day)))?
                 .to_datetime(self.time)
                 .to_zoned(self.timezone.clone())
-                .or_raise(|| Error::new("Could not convert date to a point in time"))
+                .or_raise(|| gix_error::validation("Could not convert date to a point in time"))
         }
     }
 
-    let now = now.ok_or(ValidationError::new("Missing current time"))?;
+    let now = now.ok_or(validation("Missing current time"))?;
     let mut fields = Fields::from(now);
     for Pair { period, count, unit } in pairs {
-        let err = || Error::new(format!("Couldn't parse span from '{period} {count}'"));
+        let err = || gix_error::validation(format!("Couldn't parse span from '{period} {count}'"));
         match unit {
             Unit::Seconds(factor) => {
                 let seconds = count
@@ -205,10 +205,10 @@ fn subtract_pairs(now: Option<Zoned>, pairs: &[Pair<'_>]) -> Result<Zoned, Exn<E
     fields.normalize()
 }
 
-fn subtract_duration(now: Option<&Zoned>, duration: SignedDuration) -> Result<Zoned, Exn<ValidationError>> {
-    let now = now.ok_or(ValidationError::new("Missing current time"))?;
+fn subtract_duration(now: Option<&Zoned>, duration: SignedDuration) -> ExnMessageResult<Zoned> {
+    let now = now.ok_or(validation("Missing current time"))?;
     now.timestamp()
         .checked_sub(duration)
         .map(|timestamp| timestamp.to_zoned(now.time_zone().clone()))
-        .or_raise(|| Error::new(format!("Failed to subtract {duration} from {now}")))
+        .or_raise(|| gix_error::validation(format!("Failed to subtract {duration} from {now}")))
 }
diff --git a/gix-date/tests/time/main.rs b/gix-date/tests/time/main.rs
index 44be61ce0e6..45f25e80e5d 100644
--- a/gix-date/tests/time/main.rs
+++ b/gix-date/tests/time/main.rs
@@ -27,7 +27,12 @@ mod write_to {
             offset: (100 * 60 * 60) + 30 * 60,
         };
         let err = time.write_to(&mut Vec::new()).unwrap_err();
-        assert_eq!(err.to_string(), "Cannot represent offsets larger than +-9900");
+        insta::assert_debug_snapshot!(err, "invalid", @r#"
+        Custom {
+            kind: Other,
+            error: "Cannot represent offsets larger than +-9900",
+        }
+        "#);
     }
 
     #[test]
diff --git a/gix-date/tests/time/parse/mod.rs b/gix-date/tests/time/parse/mod.rs
index 1fbb3e02a13..d1e1f487cef 100644
--- a/gix-date/tests/time/parse/mod.rs
+++ b/gix-date/tests/time/parse/mod.rs
@@ -1,5 +1,5 @@
 use gix_date::Time;
-use gix_error::Exn;
+use gix_error::ExnMessageResult;
 
 #[test]
 fn time_without_offset_defaults_to_utc() {
@@ -62,7 +62,7 @@ fn git_rfc2822() {
 }
 
 #[test]
-fn raw() -> Result<(), Exn<gix_date::Error>> {
+fn raw() -> ExnMessageResult {
     assert_eq!(
         gix_date::parse("1660874655 +0800", None)?,
         Time {
@@ -176,10 +176,7 @@ fn git_default() {
 
 #[test]
 fn invalid_dates_can_be_produced_without_current_time() {
-    assert_eq!(
-        gix_date::parse("foobar", None).unwrap_err().to_string(),
-        "Unknown date format: \"foobar\""
-    );
+    insta::assert_debug_snapshot!(gix_date::parse("foobar", None).expect_err("invalid dates can be produced without current time"), "invalid dates can be produced without current time", @r#"Unknown date format, "input"="foobar""#);
 }
 
 /// Tests for compact ISO8601 formats (YYYYMMDDTHHMMSS variants)
diff --git a/gix-date/tests/time/parse/relative.rs b/gix-date/tests/time/parse/relative.rs
index 17af0dfc146..ecae1ace3fc 100644
--- a/gix-date/tests/time/parse/relative.rs
+++ b/gix-date/tests/time/parse/relative.rs
@@ -14,23 +14,19 @@ fn large_offsets() {
 
 #[test]
 fn large_offsets_do_not_panic() {
-    assert_eq!(
-        gix_date::parse("9999999999 weeks ago", Some(utc(SystemTime::UNIX_EPOCH)))
-            .unwrap_err()
-            .to_string(),
-        "Couldn't parse span from 'week 9999999999'"
-    );
-    assert_eq!(
-        gix_date::parse(
+    insta::assert_debug_snapshot!(gix_date::parse("9999999999 weeks ago", Some(utc(SystemTime::UNIX_EPOCH)))
+            .expect_err("large offsets do not panic"), "large offsets do not panic", @"
+    Couldn't parse span from 'week 9999999999'
+    |
+    └─ parameter 'Unix timestamp seconds' is not in the required range of -377705023201..=253402207200
+    ");
+    insta::assert_debug_snapshot!(gix_date::parse(
             "2027 years 9223372036854775807 months ago",
             Some(utc(
                 SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_774_958_400)
             )),
         )
-        .expect_err("month subtraction beyond i64::MIN must fail")
-        .to_string(),
-        "Couldn't parse span from 'month 9223372036854775807'"
-    );
+        .expect_err("month subtraction beyond i64::MIN must fail"), "large offsets do not panic", @"Couldn't parse span from 'month 9223372036854775807'");
 }
 
 #[test]
diff --git a/gix-diff/Cargo.toml b/gix-diff/Cargo.toml
index 8084d285656..c8841c953bc 100644
--- a/gix-diff/Cargo.toml
+++ b/gix-diff/Cargo.toml
@@ -56,6 +56,7 @@ gix-index = { version = "^0.55.0", path = "../gix-index", optional = true }
 gix-pathspec = { version = "^0.20.0", path = "../gix-pathspec", optional = true }
 gix-attributes = { version = "^0.35.0", path = "../gix-attributes", optional = true }
 gix-hash = { version = "^0.26.1", path = "../gix-hash" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-object = { version = "^0.64.0", path = "../gix-object" }
 gix-filter = { version = "^0.34.0", path = "../gix-filter", optional = true }
 gix-worktree = { version = "^0.56.0", path = "../gix-worktree", default-features = false, features = ["attributes"], optional = true }
@@ -67,7 +68,6 @@ gix-trace = { version = "^0.1.21", path = "../gix-trace", optional = true }
 gix-traverse = { version = "^0.61.0", path = "../gix-traverse", optional = true }
 imara-diff = { package = "gix-imara-diff", version = "^0.2.5", optional = true, path = "../gix-imara-diff" }
 
-thiserror = "2.0.18"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 getrandom = { version = "0.4", optional = true, default-features = false, features = ["wasm_js"] }
 bstr = { version = "1.12.0", default-features = false }
diff --git a/gix-diff/src/blob/pipeline.rs b/gix-diff/src/blob/pipeline.rs
index 72e43457b07..2063c459e4d 100644
--- a/gix-diff/src/blob/pipeline.rs
+++ b/gix-diff/src/blob/pipeline.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use bstr::{BStr, ByteSlice};
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt, message, not_found};
 use gix_filter::{
     driver::apply::{Delay, MaybeDelayed},
     pipeline::convert::{ToGitOutcome, ToWorktreeOutcome, to_worktree},
@@ -122,52 +123,6 @@ impl Mode {
     }
 }
 
-///
-pub mod convert_to_diffable {
-    use std::collections::TryReserveError;
-
-    use bstr::BString;
-    use gix_object::tree::EntryKind;
-
-    /// The error returned by [Pipeline::convert_to_diffable()](super::Pipeline::convert_to_diffable()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Entry at '{rela_path}' must be regular file or symlink, but was {actual:?}")]
-        InvalidEntryKind { rela_path: BString, actual: EntryKind },
-        #[error("Entry at '{rela_path}' is declared as symlink but symlinks are disabled via core.symlinks")]
-        SymlinkDisabled { rela_path: BString },
-        #[error("Entry at '{rela_path}' could not be read as symbolic link")]
-        ReadLink { rela_path: BString, source: std::io::Error },
-        #[error("Entry at '{rela_path}' could not be opened for reading or read from")]
-        OpenOrRead { rela_path: BString, source: std::io::Error },
-        #[error("Entry at '{rela_path}' could not be copied from a filter process to a memory buffer")]
-        StreamCopy { rela_path: BString, source: std::io::Error },
-        #[error("Failed to run '{cmd}' for binary-to-text conversion of entry at {rela_path}")]
-        RunTextConvFilter {
-            rela_path: BString,
-            cmd: String,
-            source: std::io::Error,
-        },
-        #[error("Tempfile for binary-to-text conversion for entry at {rela_path} could not be created")]
-        CreateTempfile { rela_path: BString, source: std::io::Error },
-        #[error("Binary-to-text conversion '{cmd}' for entry at {rela_path} failed with: {stderr}")]
-        TextConvFilterFailed {
-            rela_path: BString,
-            cmd: String,
-            stderr: BString,
-        },
-        #[error(transparent)]
-        FindObject(#[from] gix_object::find::existing_object::Error),
-        #[error(transparent)]
-        ConvertToWorktree(#[from] gix_filter::pipeline::convert::to_worktree::Error),
-        #[error(transparent)]
-        ConvertToGit(#[from] gix_filter::pipeline::convert::to_git::Error),
-        #[error("Memory allocation failed")]
-        OutOfMemory(#[from] TryReserveError),
-    }
-}
-
 /// Lifecycle
 impl Pipeline {
     /// Create a new instance of a pipeline which produces blobs suitable for diffing. `roots` allow to read worktree files directly, otherwise
@@ -242,15 +197,14 @@ impl Pipeline {
         objects: &dyn gix_object::FindObjectOrHeader,
         convert: Mode,
         out: &mut Vec<u8>,
-    ) -> Result<Outcome, convert_to_diffable::Error> {
+    ) -> ExnMessageResult<Outcome> {
         let is_symlink = match mode {
             EntryKind::Link => true,
             EntryKind::Blob | EntryKind::BlobExecutable => false,
             _ => {
-                return Err(convert_to_diffable::Error::InvalidEntryKind {
-                    rela_path: rela_path.to_owned(),
-                    actual: mode,
-                });
+                return Err(
+                    message!("Entry at '{rela_path}' must be regular file or symlink, but was {mode:?}").raise(),
+                );
             }
         };
 
@@ -277,16 +231,13 @@ impl Pipeline {
                 self.path.push(gix_path::from_bstr(rela_path));
                 let data = if is_symlink {
                     if !self.options.fs.symlink {
-                        return Err(convert_to_diffable::Error::SymlinkDisabled {
-                            rela_path: rela_path.to_owned(),
-                        });
+                        return Err(message!(
+                            "Entry at '{rela_path}' is declared as symlink but symlinks are disabled via core.symlinks"
+                        )
+                        .raise());
                     }
-                    let target = none_if_missing(std::fs::read_link(&self.path)).map_err(|err| {
-                        convert_to_diffable::Error::ReadLink {
-                            rela_path: rela_path.to_owned(),
-                            source: err,
-                        }
-                    })?;
+                    let target = none_if_missing(std::fs::read_link(&self.path))
+                        .or_raise(|| message!("Entry at '{rela_path}' could not be read as symbolic link"))?;
                     target.map(|target| {
                         out.extend_from_slice(gix_path::into_bstr(target).as_ref());
                         Data::Buffer { is_derived: false }
@@ -296,11 +247,8 @@ impl Pipeline {
                     let size_in_bytes = (need_size_only
                         || (is_binary != Some(false) && self.options.large_file_threshold_bytes > 0))
                         .then(|| {
-                            none_if_missing(self.path.metadata().map(|md| md.len())).map_err(|err| {
-                                convert_to_diffable::Error::OpenOrRead {
-                                    rela_path: rela_path.to_owned(),
-                                    source: err,
-                                }
+                            none_if_missing(self.path.metadata().map(|md| md.len())).or_raise(|| {
+                                message!("Entry at '{rela_path}' could not be opened for reading or read from")
                             })
                         })
                         .transpose()?;
@@ -318,9 +266,10 @@ impl Pipeline {
                                     // Avoid letting the driver program fail if it doesn't exist.
                                     if self.options.large_file_threshold_bytes == 0
                                         && none_if_missing(std::fs::symlink_metadata(&self.path))
-                                            .map_err(|err| convert_to_diffable::Error::OpenOrRead {
-                                                rela_path: rela_path.to_owned(),
-                                                source: err,
+                                            .or_raise(|| {
+                                                message!(
+                                                    "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                )
                                             })?
                                             .is_none()
                                     {
@@ -331,57 +280,59 @@ impl Pipeline {
                                     }
                                 }
                                 None => {
-                                    let file = none_if_missing(std::fs::File::open(&self.path)).map_err(|err| {
-                                        convert_to_diffable::Error::OpenOrRead {
-                                            rela_path: rela_path.to_owned(),
-                                            source: err,
-                                        }
+                                    let file = none_if_missing(std::fs::File::open(&self.path)).or_raise(|| {
+                                        message!("Entry at '{rela_path}' could not be opened for reading or read from")
                                     })?;
 
                                     match file {
                                         Some(mut file) => {
                                             if convert.to_git() {
-                                                let res = self.worktree_filter.convert_to_git(
-                                                    file,
-                                                    gix_path::from_bstr(rela_path).as_ref(),
-                                                    attributes,
-                                                    &mut |buf| {
-                                                        if id.is_null() {
-                                                            return Ok(None);
-                                                        }
-                                                        objects.try_find(id, buf).map(|obj| obj.map(|_| ()))
-                                                    },
-                                                )?;
+                                                let res = self
+                                                    .worktree_filter
+                                                    .convert_to_git(
+                                                        file,
+                                                        gix_path::from_bstr(rela_path).as_ref(),
+                                                        attributes,
+                                                        &mut |buf| {
+                                                            if id.is_null() {
+                                                                return Ok(None);
+                                                            }
+                                                            objects.try_find(id, buf).map(|obj| obj.map(|_| ()))
+                                                        },
+                                                    )
+                                                    .or_raise(|| {
+                                                        message!(
+                                                            "Entry at '{rela_path}' could not be converted to Git form"
+                                                        )
+                                                    })?;
 
                                                 match res {
                                                     ToGitOutcome::Unchanged(mut file) => {
-                                                        file.read_to_end(out).map_err(|err| {
-                                                            convert_to_diffable::Error::OpenOrRead {
-                                                                rela_path: rela_path.to_owned(),
-                                                                source: err,
-                                                            }
+                                                        file.read_to_end(out).or_raise(|| {
+                                                            message!(
+                                                                "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                            )
                                                         })?;
                                                     }
                                                     ToGitOutcome::Process(mut stream) => {
-                                                        stream.read_to_end(out).map_err(|err| {
-                                                            convert_to_diffable::Error::OpenOrRead {
-                                                                rela_path: rela_path.to_owned(),
-                                                                source: err,
-                                                            }
+                                                        stream.read_to_end(out).or_raise(|| {
+                                                            message!(
+                                                                "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                            )
                                                         })?;
                                                     }
                                                     ToGitOutcome::Buffer(buf) => {
                                                         out.clear();
-                                                        out.try_reserve(buf.len())?;
+                                                        out.try_reserve(buf.len())
+                                                            .or_raise(|| message("Memory allocation failed"))?;
                                                         out.extend_from_slice(buf);
                                                     }
                                                 }
                                             } else {
-                                                file.read_to_end(out).map_err(|err| {
-                                                    convert_to_diffable::Error::OpenOrRead {
-                                                        rela_path: rela_path.to_owned(),
-                                                        source: err,
-                                                    }
+                                                file.read_to_end(out).or_raise(|| {
+                                                    message!(
+                                                        "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                    )
                                                 })?;
                                             }
 
@@ -408,8 +359,9 @@ impl Pipeline {
                 } else {
                     let header = objects
                         .try_header(id)
-                        .map_err(gix_object::find::existing_object::Error::Find)?
-                        .ok_or_else(|| gix_object::find::existing_object::Error::NotFound { oid: id.to_owned() })?;
+                        .or_raise(|| message!("Could not find object {id}"))?
+                        .ok_or_else(|| not_found(format!("An object with id {id} could not be found")))
+                        .or_raise(|| message!("Could not find object {id}"))?;
                     if is_binary.is_none()
                         && self.options.large_file_threshold_bytes > 0
                         && header.size > self.options.large_file_threshold_bytes
@@ -421,23 +373,29 @@ impl Pipeline {
                     } else {
                         objects
                             .try_find(id, out)
-                            .map_err(gix_object::find::existing_object::Error::Find)?
-                            .ok_or_else(|| gix_object::find::existing_object::Error::NotFound { oid: id.to_owned() })?;
+                            .or_raise(|| message!("Could not find object {id}"))?
+                            .ok_or_else(|| not_found(format!("An object with id {id} could not be found")))
+                            .or_raise(|| message!("Could not find object {id}"))?;
                         let mut is_derived = false;
                         if matches!(mode, EntryKind::Blob | EntryKind::BlobExecutable)
                             && convert == Mode::ToWorktreeAndBinaryToText
                             || (convert == Mode::ToGitUnlessBinaryToTextIsPresent
                                 && driver.is_some_and(|d| d.binary_to_text_command.is_some()))
                         {
-                            let res = self.worktree_filter.convert_to_worktree(
-                                out,
-                                rela_path,
-                                attributes,
-                                to_worktree::Options {
-                                    can_delay: Delay::Forbid,
-                                    unknown_encoding: to_worktree::UnknownEncoding::Fail,
-                                },
-                            )?;
+                            let res = self
+                                .worktree_filter
+                                .convert_to_worktree(
+                                    out,
+                                    rela_path,
+                                    attributes,
+                                    to_worktree::Options {
+                                        can_delay: Delay::Forbid,
+                                        unknown_encoding: to_worktree::UnknownEncoding::Fail,
+                                    },
+                                )
+                                .or_raise(|| {
+                                    message!("Entry at '{rela_path}' could not be converted to worktree form")
+                                })?;
 
                             let cmd_and_file = driver
                                 .and_then(|d| {
@@ -462,9 +420,10 @@ impl Pipeline {
                                     })
                                 })
                                 .transpose()
-                                .map_err(|err| convert_to_diffable::Error::CreateTempfile {
-                                    source: err,
-                                    rela_path: rela_path.to_owned(),
+                                .or_raise(|| {
+                                    message!(
+                                        "Tempfile for binary-to-text conversion for entry at {rela_path} could not be created"
+                                    )
                                 })?;
                             match cmd_and_file {
                                 Some((cmd, mut tmp_file)) => {
@@ -479,11 +438,10 @@ impl Pipeline {
                                             unreachable!("we prohibit this")
                                         }
                                     }
-                                    .map_err(|err| {
-                                        convert_to_diffable::Error::StreamCopy {
-                                            source: err,
-                                            rela_path: rela_path.to_owned(),
-                                        }
+                                    .or_raise(|| {
+                                        message!(
+                                            "Entry at '{rela_path}' could not be copied from a filter process to a memory buffer"
+                                        )
                                     })?;
                                     out.clear();
                                     run_cmd(rela_path, cmd, out)?;
@@ -493,15 +451,15 @@ impl Pipeline {
                                     ToWorktreeOutcome::Unchanged(_) => {}
                                     ToWorktreeOutcome::Buffer(src) => {
                                         out.clear();
-                                        out.try_reserve(src.len())?;
+                                        out.try_reserve(src.len())
+                                            .or_raise(|| message("Memory allocation failed"))?;
                                         out.extend_from_slice(src);
                                     }
                                     ToWorktreeOutcome::Process(MaybeDelayed::Immediate(mut stream)) => {
-                                        std::io::copy(&mut stream, out).map_err(|err| {
-                                            convert_to_diffable::Error::StreamCopy {
-                                                rela_path: rela_path.to_owned(),
-                                                source: err,
-                                            }
+                                        std::io::copy(&mut stream, out).or_raise(|| {
+                                            message!(
+                                                "Entry at '{rela_path}' could not be copied from a filter process to a memory buffer"
+                                            )
                                         })?;
                                     }
                                     ToWorktreeOutcome::Process(MaybeDelayed::Delayed(_)) => {
@@ -542,21 +500,17 @@ fn none_if_missing<T>(res: std::io::Result<T>) -> std::io::Result<Option<T>> {
     }
 }
 
-fn run_cmd(rela_path: &BStr, mut cmd: Command, out: &mut Vec<u8>) -> Result<(), convert_to_diffable::Error> {
+fn run_cmd(rela_path: &BStr, mut cmd: Command, out: &mut Vec<u8>) -> ExnMessageResult {
     gix_trace::debug!(cmd = ?cmd, "Running binary-to-text command");
     let mut res = cmd
         .output()
-        .map_err(|err| convert_to_diffable::Error::RunTextConvFilter {
-            rela_path: rela_path.to_owned(),
-            cmd: format!("{cmd:?}"),
-            source: err,
-        })?;
+        .or_raise(|| message!("Failed to run '{cmd:?}' for binary-to-text conversion of entry at {rela_path}"))?;
     if !res.status.success() {
-        return Err(convert_to_diffable::Error::TextConvFilterFailed {
-            rela_path: rela_path.to_owned(),
-            cmd: format!("{cmd:?}"),
-            stderr: res.stderr.into(),
-        });
+        return Err(message!(
+            "Binary-to-text conversion '{cmd:?}' for entry at {rela_path} failed with: {}",
+            BStr::new(&res.stderr)
+        )
+        .raise());
     }
     out.append(&mut res.stdout);
     Ok(())
diff --git a/gix-diff/src/blob/platform.rs b/gix-diff/src/blob/platform.rs
index 3f26d212560..36db14a3ef7 100644
--- a/gix-diff/src/blob/platform.rs
+++ b/gix-diff/src/blob/platform.rs
@@ -1,6 +1,7 @@
 use std::{cmp::Ordering, io::Write, process::Stdio};
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnMessageResult, OptionExt, ResultExt, message, validation};
 
 use super::Algorithm;
 use crate::blob::{Pipeline, Platform, ResourceKind, pipeline};
@@ -238,35 +239,6 @@ pub mod resource {
     }
 }
 
-///
-pub mod set_resource {
-    use bstr::BString;
-
-    use crate::blob::{ResourceKind, pipeline};
-
-    /// The error returned by [Platform::set_resource](super::Platform::set_resource).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Can only diff blobs and links, not {mode:?}")]
-        InvalidMode { mode: gix_object::tree::EntryKind },
-        #[error("Failed to read {kind} worktree data from '{rela_path}'")]
-        Io {
-            rela_path: BString,
-            kind: ResourceKind,
-            source: std::io::Error,
-        },
-        #[error("Failed to obtain attributes for {kind} resource at '{rela_path}'")]
-        Attributes {
-            rela_path: BString,
-            kind: ResourceKind,
-            source: std::io::Error,
-        },
-        #[error(transparent)]
-        ConvertToDiffable(#[from] pipeline::convert_to_diffable::Error),
-    }
-}
-
 ///
 pub mod prepare_diff {
     use bstr::BStr;
@@ -333,38 +305,12 @@ pub mod prepare_diff {
             )
         }
     }
-
-    /// The error returned by [Platform::prepare_diff()](super::Platform::prepare_diff()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Either the source or the destination of the diff operation were not set")]
-        SourceOrDestinationUnset,
-        #[error("Tried to diff resources that are both considered removed")]
-        SourceAndDestinationRemoved,
-    }
 }
 
 ///
 pub mod prepare_diff_command {
     use std::ops::{Deref, DerefMut};
 
-    use bstr::BString;
-
-    /// The error returned by [Platform::prepare_diff_command()](super::Platform::prepare_diff_command()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Either the source or the destination of the diff operation were not set")]
-        SourceOrDestinationUnset,
-        #[error("Binary resources can't be diffed with an external command (as we don't have the data anymore)")]
-        SourceOrDestinationBinary,
-        #[error("Tempfile to store content of '{rela_path}' for passing to external diff command could not be created")]
-        CreateTempfile { rela_path: BString, source: std::io::Error },
-        #[error("Could not write content of '{rela_path}' to tempfile for passing to external diff command")]
-        WriteTempfile { rela_path: BString, source: std::io::Error },
-    }
-
     /// The outcome of a [`prepare_diff_command`](super::Platform::prepare_diff_command()) operation.
     ///
     /// This type acts like [`std::process::Command`], ready to run, with `stdin`, `stdout` and `stderr` set to *inherit*
@@ -458,7 +404,7 @@ impl Platform {
         rela_path: &BStr,
         kind: ResourceKind,
         objects: &impl gix_object::FindObjectOrHeader, // TODO: make this `dyn` once https://github.com/rust-lang/rust/issues/65991 is stable, then also make tracker.rs `objects` dyn
-    ) -> Result<(), set_resource::Error> {
+    ) -> ExnMessageResult {
         let res = self.set_resource_inner(id, mode, rela_path, kind, objects);
         if res.is_err() {
             *match kind {
@@ -489,11 +435,11 @@ impl Platform {
         context: gix_command::Context,
         count: usize,
         total: usize,
-    ) -> Result<prepare_diff_command::Command, prepare_diff_command::Error> {
+    ) -> ExnMessageResult<prepare_diff_command::Command> {
         fn add_resource(
             cmd: &mut std::process::Command,
             res: Resource<'_>,
-        ) -> Result<Option<gix_tempfile::Handle<gix_tempfile::handle::Closed>>, prepare_diff_command::Error> {
+        ) -> ExnMessageResult<Option<gix_tempfile::Handle<gix_tempfile::handle::Closed>>> {
             let tmpfile = match res.data {
                 resource::Data::Missing => {
                     cmd.args(["/dev/null", ".", "."]);
@@ -505,37 +451,49 @@ impl Platform {
                         gix_tempfile::ContainingDirectory::Exists,
                         gix_tempfile::AutoRemove::Tempfile,
                     )
-                    .map_err(|err| prepare_diff_command::Error::CreateTempfile {
-                        rela_path: res.rela_path.to_owned(),
-                        source: err,
+                    .or_raise(|| {
+                        message!(
+                            "Tempfile to store content of '{}' for passing to external diff command could not be created",
+                            res.rela_path
+                        )
+                    })?;
+                    tmp.write_all(buf).or_raise(|| {
+                        message!(
+                            "Could not write content of '{}' to tempfile for passing to external diff command",
+                            res.rela_path
+                        )
                     })?;
-                    tmp.write_all(buf)
-                        .map_err(|err| prepare_diff_command::Error::WriteTempfile {
-                            rela_path: res.rela_path.to_owned(),
-                            source: err,
-                        })?;
                     tmp.with_mut(|f| {
                         cmd.arg(f.path());
                     })
-                    .map_err(|err| prepare_diff_command::Error::WriteTempfile {
-                        rela_path: res.rela_path.to_owned(),
-                        source: err,
+                    .or_raise(|| {
+                        message!(
+                            "Could not access tempfile for '{}' while preparing external diff command",
+                            res.rela_path
+                        )
                     })?;
                     cmd.arg(res.id.to_string()).arg(res.mode.as_octal_str().to_string());
-                    let tmp = tmp.close().map_err(|err| prepare_diff_command::Error::WriteTempfile {
-                        rela_path: res.rela_path.to_owned(),
-                        source: err,
+                    let tmp = tmp.close().or_raise(|| {
+                        message!(
+                            "Could not close tempfile for '{}' while preparing external diff command",
+                            res.rela_path
+                        )
                     })?;
                     Some(tmp)
                 }
-                resource::Data::Binary { .. } => return Err(prepare_diff_command::Error::SourceOrDestinationBinary),
+                resource::Data::Binary { .. } => {
+                    return Err(message(
+                        "Binary resources can't be diffed with an external command (as we don't have the data anymore)",
+                    )
+                    .raise());
+                }
             };
             Ok(tmpfile)
         }
 
         let (old, new) = self
             .resources()
-            .ok_or(prepare_diff_command::Error::SourceOrDestinationUnset)?;
+            .ok_or_raise(|| message("Either the source or the destination of the diff operation were not set"))?;
         let mut cmd: std::process::Command = gix_command::prepare(gix_path::from_bstring(diff_command))
             .command_may_be_shell_script_disallow_manual_argument_splitting()
             .with_context(context)
@@ -592,17 +550,23 @@ impl Platform {
     ///
     /// The returned outcome allows to easily perform diff operations, based on the [`prepare_diff::Outcome::operation`] field,
     /// which hints at what should be done.
-    pub fn prepare_diff(&mut self) -> Result<prepare_diff::Outcome<'_>, prepare_diff::Error> {
-        let old_key = &self.old.as_ref().ok_or(prepare_diff::Error::SourceOrDestinationUnset)?;
+    pub fn prepare_diff(&mut self) -> ExnMessageResult<prepare_diff::Outcome<'_>> {
+        let old_key = &self
+            .old
+            .as_ref()
+            .ok_or_else(|| validation("Either the source or the destination of the diff operation were not set"))?;
         let old = self
             .diff_cache
             .get(old_key)
-            .ok_or(prepare_diff::Error::SourceOrDestinationUnset)?;
-        let new_key = &self.new.as_ref().ok_or(prepare_diff::Error::SourceOrDestinationUnset)?;
+            .ok_or_else(|| validation("Either the source or the destination of the diff operation were not set"))?;
+        let new_key = &self
+            .new
+            .as_ref()
+            .ok_or_else(|| validation("Either the source or the destination of the diff operation were not set"))?;
         let new = self
             .diff_cache
             .get(new_key)
-            .ok_or(prepare_diff::Error::SourceOrDestinationUnset)?;
+            .ok_or_else(|| validation("Either the source or the destination of the diff operation were not set"))?;
         let mut out = {
             let old = Resource::new(old_key, old);
             let new = Resource::new(new_key, new);
@@ -615,7 +579,9 @@ impl Platform {
         };
 
         match (old.conversion.data, new.conversion.data) {
-            (None, None) => return Err(prepare_diff::Error::SourceAndDestinationRemoved),
+            (None, None) => {
+                return Err(validation("Tried to diff resources that are both considered removed").into());
+            }
             (Some(pipeline::Data::Binary { .. }), _) | (_, Some(pipeline::Data::Binary { .. })) => return Ok(out),
             _either_missing_or_non_binary => {
                 if let Some(command) = old
@@ -696,12 +662,12 @@ impl Platform {
         rela_path: &BStr,
         kind: ResourceKind,
         objects: &impl gix_object::FindObjectOrHeader,
-    ) -> Result<(), set_resource::Error> {
+    ) -> ExnMessageResult {
         if matches!(
             mode,
             gix_object::tree::EntryKind::Commit | gix_object::tree::EntryKind::Tree
         ) {
-            return Err(set_resource::Error::InvalidMode { mode });
+            return Err(message!("Can only diff blobs and links, not {mode:?}").raise());
         }
         let storage = match kind {
             ResourceKind::OldOrSource => &mut self.old,
@@ -717,27 +683,26 @@ impl Platform {
         if self.diff_cache.contains_key(storage) {
             return Ok(());
         }
-        let entry =
-            self.attr_stack
-                .at_entry(rela_path, None, objects)
-                .map_err(|err| set_resource::Error::Attributes {
-                    source: err,
-                    kind,
-                    rela_path: rela_path.to_owned(),
-                })?;
+        let entry = self
+            .attr_stack
+            .at_entry(rela_path, None, objects)
+            .or_raise(|| message!("Failed to obtain attributes for {kind} resource at '{rela_path}'"))?;
         let mut buf = self.free_list.pop().unwrap_or_default();
-        let out = self.filter.convert_to_diffable(
-            &id,
-            mode,
-            rela_path,
-            kind,
-            &mut |_, out| {
-                let _ = entry.matching_attributes(out);
-            },
-            objects,
-            self.filter_mode,
-            &mut buf,
-        )?;
+        let out = self
+            .filter
+            .convert_to_diffable(
+                &id,
+                mode,
+                rela_path,
+                kind,
+                &mut |_, out| {
+                    let _ = entry.matching_attributes(out);
+                },
+                objects,
+                self.filter_mode,
+                &mut buf,
+            )
+            .or_raise(|| message!("Failed to convert {kind} resource at '{rela_path}' to diffable data"))?;
         let key = storage.clone();
         assert!(
             self.diff_cache
diff --git a/gix-diff/src/index/function.rs b/gix-diff/src/index/function.rs
index baccdcb6e50..4bc8fe6c1f2 100644
--- a/gix-diff/src/index/function.rs
+++ b/gix-diff/src/index/function.rs
@@ -1,9 +1,10 @@
 use std::{borrow::Cow, cell::RefCell, cmp::Ordering};
 
 use bstr::BStr;
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, message};
 use gix_filter::attributes::glob::pattern::Case;
 
-use super::{Action, ChangeRef, Error, RewriteOptions};
+use super::{Action, ChangeRef, RewriteOptions};
 use crate::rewrites;
 
 /// Produce an entry-by-entry diff between `lhs` and `rhs`, sending changes to `cb(change) -> Action` for consumption,
@@ -26,27 +27,28 @@ use crate::rewrites;
 /// The entries in `lhs` and `rhs` are both expected to be sorted like index entries are typically sorted.
 ///
 /// Note that sparse indices aren't supported, they must be "unsparsed" before.
-pub fn diff<'rhs, 'lhs: 'rhs, E, Find>(
+pub fn diff<'rhs, 'lhs: 'rhs, Find>(
     lhs: &'lhs gix_index::State,
     rhs: &'rhs gix_index::State,
-    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> Result<Action, E>,
+    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> ExnResult<Action>,
     rewrite_options: Option<RewriteOptions<'_, Find>>,
     pathspec: &mut gix_pathspec::Search,
     pathspec_attributes: &mut dyn FnMut(&BStr, Case, bool, &mut gix_attributes::search::Outcome) -> bool,
-) -> Result<Option<rewrites::Outcome>, Error>
+) -> ExnMessageResult<Option<rewrites::Outcome>>
 where
-    E: Into<Box<dyn std::error::Error + Send + Sync>>,
     Find: gix_object::FindObjectOrHeader,
 {
     if lhs.is_sparse() || rhs.is_sparse() {
-        return Err(Error::IsSparse);
+        return Err(message("Cannot diff indices that contain sparse entries").raise());
     }
     if lhs
         .entries()
         .iter()
         .any(|e| e.stage() != gix_index::entry::Stage::Unconflicted)
     {
-        return Err(Error::LhsHasUnmerged);
+        return Err(
+            message("Unmerged entries aren't allowed in the left-hand index, only in the right-hand index").raise(),
+        );
     }
 
     let lhs_range = lhs
@@ -122,7 +124,7 @@ where
                                 Some(tracker) => tracker.try_push_change(change, rhs_path),
                             };
                             if let Some(change) = change {
-                                match cb(change).map_err(|err| Error::Callback(err.into()))? {
+                                match cb(change).map_err(callback_error)? {
                                     std::ops::ControlFlow::Continue(()) => {}
                                     std::ops::ControlFlow::Break(()) => return Ok(None),
                                 }
@@ -183,7 +185,7 @@ where
                     Ok(std::ops::ControlFlow::Continue(())) => std::ops::ControlFlow::Continue(()),
                     Ok(std::ops::ControlFlow::Break(())) => std::ops::ControlFlow::Break(()),
                     Err(err) => {
-                        cb_err = Some(Error::Callback(err.into()));
+                        cb_err = Some(callback_error(err));
                         std::ops::ControlFlow::Break(())
                     }
                 }
@@ -220,14 +222,11 @@ where
     }
 }
 
-fn emit_deletion<'rhs, 'lhs: 'rhs, E>(
+fn emit_deletion<'rhs, 'lhs: 'rhs>(
     (idx, path, entry): (usize, &'lhs BStr, &'lhs gix_index::Entry),
-    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> Result<Action, E>,
+    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> ExnResult<Action>,
     tracker: Option<&mut rewrites::Tracker<ChangeRef<'lhs, 'rhs>>>,
-) -> Result<Action, Error>
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync>>,
-{
+) -> ExnMessageResult<Action> {
     let change = ChangeRef::Deletion {
         location: Cow::Borrowed(path),
         index: idx,
@@ -243,17 +242,14 @@ where
         },
     };
 
-    cb(change).map_err(|err| Error::Callback(err.into()))
+    cb(change).map_err(callback_error)
 }
 
-fn emit_addition<'rhs, 'lhs: 'rhs, E>(
+fn emit_addition<'rhs, 'lhs: 'rhs>(
     (idx, path, entry): (usize, &'rhs BStr, &'rhs gix_index::Entry),
-    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> Result<Action, E>,
+    mut cb: impl FnMut(ChangeRef<'lhs, 'rhs>) -> ExnResult<Action>,
     tracker: Option<&mut rewrites::Tracker<ChangeRef<'lhs, 'rhs>>>,
-) -> Result<Action, Error>
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync>>,
-{
+) -> ExnMessageResult<Action> {
     if ignore_unmerged_and_intent_to_add((idx, path, entry)) {
         return Ok(std::ops::ControlFlow::Continue(()));
     }
@@ -273,7 +269,11 @@ where
         },
     };
 
-    cb(change).map_err(|err| Error::Callback(err.into()))
+    cb(change).map_err(callback_error)
+}
+
+fn callback_error(err: gix_error::Exn) -> gix_error::Exn<gix_error::Message> {
+    err.raise(message("The callback indicated failure"))
 }
 
 fn ignore_unmerged_and_intent_to_add<'rhs, 'lhs: 'rhs>(
diff --git a/gix-diff/src/index/mod.rs b/gix-diff/src/index/mod.rs
index 1a380ac8dee..d7e621e19a2 100644
--- a/gix-diff/src/index/mod.rs
+++ b/gix-diff/src/index/mod.rs
@@ -2,20 +2,6 @@ use std::borrow::Cow;
 
 use bstr::BStr;
 
-/// The error returned by [`index()`](crate::index()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Cannot diff indices that contain sparse entries")]
-    IsSparse,
-    #[error("Unmerged entries aren't allowed in the left-hand index, only in the right-hand index")]
-    LhsHasUnmerged,
-    #[error("The callback indicated failure")]
-    Callback(#[source] Box<dyn std::error::Error + Send + Sync>),
-    #[error("Failure during rename tracking")]
-    RenameTracking(#[from] crate::rewrites::tracker::emit::Error),
-}
-
 /// What to do after a [ChangeRef] was passed ot the callback of [`index()`](crate::index()).
 ///
 /// Use [`std::ops::ControlFlow::Continue`] to continue the operation.
diff --git a/gix-diff/src/rewrites/tracker.rs b/gix-diff/src/rewrites/tracker.rs
index df5b440adee..15d079c9478 100644
--- a/gix-diff/src/rewrites/tracker.rs
+++ b/gix-diff/src/rewrites/tracker.rs
@@ -11,6 +11,7 @@
 use std::ops::Range;
 
 use bstr::{BStr, ByteSlice};
+use gix_error::{ExnMessageResult, ResultExt};
 use gix_object::tree::{EntryKind, EntryMode};
 
 use crate::{
@@ -133,23 +134,6 @@ pub mod visit {
     }
 }
 
-///
-pub mod emit {
-    /// The error returned by [Tracker::emit()](super::Tracker::emit()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not find blob for similarity checking")]
-        FindExistingBlob(#[from] gix_object::find::existing_object::Error),
-        #[error("Could not obtain exhaustive item set to use as possible sources for copy detection")]
-        GetItemsForExhaustiveCopyDetection(#[source] Box<dyn std::error::Error + Send + Sync>),
-        #[error(transparent)]
-        SetResource(#[from] crate::blob::platform::set_resource::Error),
-        #[error(transparent)]
-        PrepareDiff(#[from] crate::blob::platform::prepare_diff::Error),
-    }
-}
-
 /// Lifecycle
 impl<T: Change> Tracker<T> {
     /// Create a new instance with `rewrites` configuration.
@@ -220,7 +204,7 @@ impl<T: Change> Tracker<T> {
         diff_cache: &mut crate::blob::Platform,
         objects: &impl gix_object::FindObjectOrHeader,
         mut push_source_tree: PushSourceTreeFn,
-    ) -> Result<Outcome, emit::Error>
+    ) -> ExnMessageResult<Outcome>
     where
         PushSourceTreeFn: FnMut(&mut dyn FnMut(T, &BStr)) -> Result<(), E>,
         E: std::error::Error + Send + Sync + 'static,
@@ -307,7 +291,11 @@ impl<T: Change> Tracker<T> {
                                 self.items.last_mut().expect("just pushed").emitted = true;
                             }
                         })
-                        .map_err(|err| emit::Error::GetItemsForExhaustiveCopyDetection(Box::new(err)))?;
+                        .or_raise(|| {
+                            gix_error::message(
+                                "Could not obtain exhaustive item set to use as possible sources for copy detection",
+                            )
+                        })?;
                         self.sort_items_by_id_and_location();
 
                         self.match_pairs_of_kind(
@@ -373,7 +361,7 @@ impl<T: Change> Tracker<T> {
         diff_cache: &mut crate::blob::Platform,
         objects: &impl gix_object::FindObjectOrHeader,
         filter: Option<fn(&T) -> bool>,
-    ) -> Result<(), emit::Error> {
+    ) -> ExnMessageResult {
         // we try to cheaply reduce the set of possibilities first, before possibly looking more exhaustively.
         let needs_second_pass = !needs_exact_match(percentage);
 
@@ -424,7 +412,7 @@ impl<T: Change> Tracker<T> {
         diff_cache: &mut crate::blob::Platform,
         objects: &impl gix_object::FindObjectOrHeader,
         filter: Option<fn(&T) -> bool>,
-    ) -> Result<Action, emit::Error> {
+    ) -> ExnMessageResult<Action> {
         let mut dest_ofs = 0;
         let mut num_checks = 0;
         let max_checks = {
@@ -535,7 +523,7 @@ impl<T: Change> Tracker<T> {
         kind: visit::SourceKind,
         src_parent_id: ChangeId,
         dst_parent_id: ChangeId,
-    ) -> Result<Action, emit::Error> {
+    ) -> ExnMessageResult<Action> {
         debug_assert_ne!(
             src_parent_id, dst_parent_id,
             "src and destination directories must be distinct"
@@ -598,7 +586,7 @@ impl<T: Change> Tracker<T> {
     fn match_renamed_directories(
         &mut self,
         cb: &mut impl FnMut(visit::Destination<'_, T>, Option<visit::Source<'_, T>>) -> Action,
-    ) -> Result<(), emit::Error> {
+    ) -> ExnMessageResult {
         fn unemitted_directory_matching_relation_id<T: Change>(items: &[Item<T>], child_id: ChangeId) -> Option<usize> {
             items.iter().position(|i| {
                 !i.emitted && matches!(i.change.relation(), Some(Relation::Parent(pid)) if pid == child_id)
@@ -704,7 +692,7 @@ fn find_match<'a, T: Change>(
     diff_cache: &mut crate::blob::Platform,
     path_backing: &[u8],
     num_checks: &mut usize,
-) -> Result<Option<SourceTuple<'a, T>>, emit::Error> {
+) -> ExnMessageResult<Option<SourceTuple<'a, T>>> {
     let (item_id, item_mode) = item.change.id_and_entry_mode();
     // Symlinks and gitlinks only participate in exact-ID matching; neither has meaningful blob similarity here.
     if needs_exact_match(percentage) || item_mode.is_link() || item_mode.is_commit() {
@@ -772,7 +760,9 @@ fn find_match<'a, T: Change>(
                 ResourceKind::OldOrSource,
                 objects,
             )?;
-            let prep = diff_cache.prepare_diff()?;
+            let prep = diff_cache
+                .prepare_diff()
+                .or_raise(|| gix_error::message("Could not prepare resources for similarity checking"))?;
             stats.num_similarity_checks += 1;
             *num_checks += 1;
             match prep.operation {
diff --git a/gix-diff/src/tree/function.rs b/gix-diff/src/tree/function.rs
index 88e334b22fa..f268091e770 100644
--- a/gix-diff/src/tree/function.rs
+++ b/gix-diff/src/tree/function.rs
@@ -225,7 +225,12 @@ fn catchup_rhs_with_lhs(
                     break;
                 }
             },
-            Some(Err(err)) => return Err(Error::EntriesDecode(err.to_owned())),
+            Some(Err(_)) => {
+                let Err(err) = rhs_entries.next().expect("the peeked item to be present") else {
+                    unreachable!("peeked error changed before it was consumed")
+                };
+                return Err(err.into());
+            }
             None => {
                 delegate.pop_path_component();
                 delete_entry_schedule_recursion(lhs, queue, change_id, relation_to_propagate, delegate)?;
@@ -274,7 +279,12 @@ fn catchup_lhs_with_rhs(
                     break;
                 }
             },
-            Some(Err(err)) => return Err(Error::EntriesDecode(err.to_owned())),
+            Some(Err(_)) => {
+                let Err(err) = lhs_entries.next().expect("the peeked item to be present") else {
+                    unreachable!("peeked error changed before it was consumed")
+                };
+                return Err(err.into());
+            }
             None => {
                 delegate.pop_path_component();
                 add_entry_schedule_recursion(rhs, queue, change_id, relation_to_propagate, delegate)?;
diff --git a/gix-diff/src/tree/mod.rs b/gix-diff/src/tree/mod.rs
index 52064b1c309..537dfcf952f 100644
--- a/gix-diff/src/tree/mod.rs
+++ b/gix-diff/src/tree/mod.rs
@@ -7,15 +7,44 @@ use gix_object::bstr::BString;
 use crate::tree::visit::Relation;
 
 /// The error returned by [`tree()`](super::tree()).
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 #[expect(missing_docs)]
 pub enum Error {
-    #[error(transparent)]
-    Find(#[from] gix_object::find::existing_iter::Error),
-    #[error("The delegate cancelled the operation")]
     Cancelled,
-    #[error(transparent)]
-    EntriesDecode(#[from] gix_object::decode::Error),
+    Failure(gix_error::Error),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Cancelled => f.write_str("The delegate cancelled the operation"),
+            Error::Failure(err) => std::fmt::Display::fmt(err, f),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Cancelled => None,
+            Error::Failure(err) => Some(err),
+        }
+    }
+}
+
+impl<E> From<gix_error::Exn<E>> for Error
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    fn from(err: gix_error::Exn<E>) -> Self {
+        Error::Failure(err.into_error())
+    }
+}
+
+impl From<gix_error::Message> for Error {
+    fn from(err: gix_error::Message) -> Self {
+        Error::Failure(gix_error::Error::from_error(err))
+    }
 }
 
 /// A trait to allow responding to a traversal designed to figure out the [changes](visit::Change)
diff --git a/gix-diff/src/tree_with_rewrites/change.rs b/gix-diff/src/tree_with_rewrites/change.rs
index b613e203942..f5df21aa674 100644
--- a/gix-diff/src/tree_with_rewrites/change.rs
+++ b/gix-diff/src/tree_with_rewrites/change.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
 
 use crate::{
     blob::{DiffLineStats, ResourceKind},
@@ -341,7 +342,7 @@ impl crate::blob::Platform {
         &mut self,
         change: ChangeRef<'_>,
         objects: &impl gix_object::FindObjectOrHeader,
-    ) -> Result<&mut Self, crate::blob::platform::set_resource::Error> {
+    ) -> ExnMessageResult<&mut Self> {
         match change {
             ChangeRef::Addition {
                 location,
diff --git a/gix-diff/src/tree_with_rewrites/function.rs b/gix-diff/src/tree_with_rewrites/function.rs
index 669a70a32b3..edfc04f76dc 100644
--- a/gix-diff/src/tree_with_rewrites/function.rs
+++ b/gix-diff/src/tree_with_rewrites/function.rs
@@ -1,8 +1,10 @@
 use bstr::BStr;
+use gix_error::ExnResult;
+use gix_error::ResultExt;
 use gix_object::TreeRefIter;
 
-use super::{Action, ChangeRef, Error, Options};
-use crate::{rewrites, rewrites::tracker};
+use super::{Action, ChangeRef, Options};
+use crate::{rewrites, rewrites::tracker, tree::Error};
 
 /// 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.
@@ -21,18 +23,20 @@ use crate::{rewrites, rewrites::tracker};
 /// `rhs` or `lhs` can be empty to indicate deletion or addition of an entire tree.
 ///
 /// Note that the rewrite outcome is only available if [rewrite-tracking was enabled](Options::rewrites).
-pub fn diff<E>(
+pub fn diff(
     lhs: TreeRefIter<'_>,
     rhs: TreeRefIter<'_>,
     resource_cache: &mut crate::blob::Platform,
     tree_diff_state: &mut crate::tree::State,
     objects: &impl gix_object::FindObjectOrHeader,
-    for_each: impl FnMut(ChangeRef<'_>) -> Result<Action, E>,
+    for_each: impl FnMut(ChangeRef<'_>) -> ExnResult<Action>,
     options: Options,
-) -> Result<Option<rewrites::Outcome>, Error>
-where
-    E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-{
+) -> Result<Option<rewrites::Outcome>, Error> {
+    fn callback_error(err: gix_error::Exn) -> Error {
+        err.raise(gix_error::message("The user-provided callback failed"))
+            .into()
+    }
+
     let mut delegate = Delegate {
         src_tree: lhs,
         recorder: crate::tree::Recorder::default().track_location(options.location),
@@ -46,41 +50,38 @@ where
         Ok(()) => {
             let outcome = delegate.process_tracked_changes(resource_cache)?;
             match delegate.err {
-                Some(err) => Err(Error::ForEach(err.into())),
+                Some(err) => Err(callback_error(err)),
                 None => Ok(outcome),
             }
         }
         Err(crate::tree::Error::Cancelled) => delegate
             .err
-            .map_or(Err(Error::Diff(crate::tree::Error::Cancelled)), |err| {
-                Err(Error::ForEach(err.into()))
-            }),
-        Err(err) => Err(err.into()),
+            .map_or(Err(Error::Cancelled), |err| Err(callback_error(err))),
+        Err(err) => Err(err),
     }
 }
 
-struct Delegate<'a, 'old, VisitFn, E, Objects> {
+struct Delegate<'a, 'old, VisitFn, Objects> {
     src_tree: TreeRefIter<'old>,
     recorder: crate::tree::Recorder,
     objects: &'a Objects,
     visit: VisitFn,
     tracked: Option<rewrites::Tracker<crate::tree::visit::Change>>,
     location: Option<crate::tree::recorder::Location>,
-    err: Option<E>,
+    err: Option<gix_error::Exn>,
 }
 
-impl<VisitFn, E, Objects> Delegate<'_, '_, VisitFn, E, Objects>
+impl<VisitFn, Objects> Delegate<'_, '_, VisitFn, Objects>
 where
     Objects: gix_object::FindObjectOrHeader,
-    VisitFn: FnMut(ChangeRef<'_>) -> Result<Action, E>,
-    E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
+    VisitFn: FnMut(ChangeRef<'_>) -> ExnResult<Action>,
 {
     /// Call `visit` on an attached version of `change`.
     fn emit_change(
         change: crate::tree::visit::Change,
         location: &BStr,
         visit: &mut VisitFn,
-        stored_err: &mut Option<E>,
+        stored_err: &mut Option<gix_error::Exn>,
     ) -> crate::tree::visit::Action {
         use crate::tree::visit::Change::*;
         let change = match change {
@@ -137,53 +138,55 @@ where
             None => return Ok(None),
         };
 
-        let outcome = tracked.emit(
-            |dest, source| match source {
-                Some(source) => {
-                    let (oid, mode) = dest.change.oid_and_entry_mode();
-                    let change = ChangeRef::Rewrite {
-                        source_location: source.location,
-                        source_entry_mode: source.entry_mode,
-                        source_id: source.id,
-                        source_relation: source.change.relation(),
-                        entry_mode: mode,
-                        id: oid.to_owned(),
-                        relation: dest.change.relation(),
-                        diff: source.diff,
-                        location: dest.location,
-                        copy: match source.kind {
-                            tracker::visit::SourceKind::Rename => false,
-                            tracker::visit::SourceKind::Copy => true,
-                        },
-                    };
-                    match (self.visit)(change) {
-                        Ok(std::ops::ControlFlow::Break(())) => std::ops::ControlFlow::Break(()),
-                        Ok(std::ops::ControlFlow::Continue(())) => std::ops::ControlFlow::Continue(()),
-                        Err(err) => {
-                            self.err = Some(err);
-                            std::ops::ControlFlow::Break(())
+        let outcome = tracked
+            .emit(
+                |dest, source| match source {
+                    Some(source) => {
+                        let (oid, mode) = dest.change.oid_and_entry_mode();
+                        let change = ChangeRef::Rewrite {
+                            source_location: source.location,
+                            source_entry_mode: source.entry_mode,
+                            source_id: source.id,
+                            source_relation: source.change.relation(),
+                            entry_mode: mode,
+                            id: oid.to_owned(),
+                            relation: dest.change.relation(),
+                            diff: source.diff,
+                            location: dest.location,
+                            copy: match source.kind {
+                                tracker::visit::SourceKind::Rename => false,
+                                tracker::visit::SourceKind::Copy => true,
+                            },
+                        };
+                        match (self.visit)(change) {
+                            Ok(std::ops::ControlFlow::Break(())) => std::ops::ControlFlow::Break(()),
+                            Ok(std::ops::ControlFlow::Continue(())) => std::ops::ControlFlow::Continue(()),
+                            Err(err) => {
+                                self.err = Some(err);
+                                std::ops::ControlFlow::Break(())
+                            }
                         }
                     }
-                }
-                None => Self::emit_change(dest.change, dest.location, &mut self.visit, &mut self.err),
-            },
-            diff_cache,
-            self.objects,
-            |push| {
-                let mut delegate = tree_to_changes::Delegate::new(push, self.location);
-                let state = gix_traverse::tree::breadthfirst::State::default();
-                gix_traverse::tree::breadthfirst(self.src_tree, state, self.objects, &mut delegate)
-            },
-        )?;
+                    None => Self::emit_change(dest.change, dest.location, &mut self.visit, &mut self.err),
+                },
+                diff_cache,
+                self.objects,
+                |push| {
+                    let mut delegate = tree_to_changes::Delegate::new(push, self.location);
+                    let state = gix_traverse::tree::breadthfirst::State::default();
+                    gix_traverse::tree::breadthfirst(self.src_tree, state, self.objects, &mut delegate)
+                        .map_err(gix_error::Exn::into_error)
+                },
+            )
+            .or_raise(|| gix_error::message("Failure during rename tracking"))?;
         Ok(Some(outcome))
     }
 }
 
-impl<VisitFn, E, Objects> crate::tree::Visit for Delegate<'_, '_, VisitFn, E, Objects>
+impl<VisitFn, Objects> crate::tree::Visit for Delegate<'_, '_, VisitFn, Objects>
 where
     Objects: gix_object::FindObjectOrHeader,
-    VisitFn: FnMut(ChangeRef<'_>) -> Result<Action, E>,
-    E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
+    VisitFn: FnMut(ChangeRef<'_>) -> ExnResult<Action>,
 {
     fn pop_front_tracked_path_and_set_current(&mut self) {
         self.recorder.pop_front_tracked_path_and_set_current();
diff --git a/gix-diff/src/tree_with_rewrites/mod.rs b/gix-diff/src/tree_with_rewrites/mod.rs
index 28d608f5017..0c7362bfb90 100644
--- a/gix-diff/src/tree_with_rewrites/mod.rs
+++ b/gix-diff/src/tree_with_rewrites/mod.rs
@@ -3,18 +3,6 @@ use crate::{Rewrites, tree::recorder::Location};
 mod change;
 pub use change::{Change, ChangeRef};
 
-/// The error returned by [`tree_with_rewrites()`](super::tree_with_rewrites()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Diff(#[from] crate::tree::Error),
-    #[error("The user-provided callback failed")]
-    ForEach(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error("Failure during rename tracking")]
-    RenameTracking(#[from] crate::rewrites::tracker::emit::Error),
-}
-
 /// Returned by the [`tree_with_rewrites()`](super::tree_with_rewrites()) function to control flow.
 ///
 /// Use [`std::ops::ControlFlow::Continue`] to continue the traversal of changes.
diff --git a/gix-diff/tests/diff/blob/pipeline.rs b/gix-diff/tests/diff/blob/pipeline.rs
index 10978084432..1ba6c015b28 100644
--- a/gix-diff/tests/diff/blob/pipeline.rs
+++ b/gix-diff/tests/diff/blob/pipeline.rs
@@ -1,5 +1,6 @@
 pub(crate) mod convert_to_diffable {
 
+    use crate::Result;
     use gix_diff::blob::{
         ResourceKind, pipeline,
         pipeline::{Options, WorktreeRoots},
@@ -10,7 +11,7 @@ pub(crate) mod convert_to_diffable {
     use crate::util::{insert, object_db};
 
     #[test]
-    fn simple() -> crate::Result {
+    fn simple() -> Result {
         for mode in [
             pipeline::Mode::ToWorktreeAndBinaryToText,
             pipeline::Mode::ToGit,
@@ -92,7 +93,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn binary_below_large_file_threshold() -> crate::Result {
+    fn binary_below_large_file_threshold() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let mut filter = gix_diff::blob::Pipeline::new(
             WorktreeRoots {
@@ -147,7 +148,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn above_large_file_threshold() -> crate::Result {
+    fn above_large_file_threshold() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let mut filter = gix_diff::blob::Pipeline::new(
             WorktreeRoots {
@@ -230,7 +231,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn non_existing() -> crate::Result {
+    fn non_existing() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let mut filter = gix_diff::blob::Pipeline::new(
             WorktreeRoots {
@@ -300,7 +301,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn worktree_filter() -> crate::Result {
+    fn worktree_filter() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let filter = gix_filter::Pipeline::new(
             Default::default(),
@@ -434,7 +435,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn worktree_filter_skips_null_id_lookups() -> crate::Result {
+    fn worktree_filter_skips_null_id_lookups() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         std::fs::write(tmp.path().join("a"), "worktree\r\n")?;
         let mut filter = gix_diff::blob::Pipeline::new(
@@ -494,7 +495,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn binary_by_buffer_inspection() -> crate::Result {
+    fn binary_by_buffer_inspection() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let root = crate::scripted_fixture_read_only("make_blob_repo.sh")?;
         let mut attributes = crate::blob::new_attributes_stack(root);
@@ -582,7 +583,7 @@ pub(crate) mod convert_to_diffable {
     }
 
     #[test]
-    fn with_driver() -> crate::Result {
+    fn with_driver() -> Result {
         let root = crate::scripted_fixture_read_only("make_blob_repo.sh")?;
         let command = "echo to-text; cat <";
         let mut attributes = crate::blob::new_attributes_stack(&root);
diff --git a/gix-diff/tests/diff/blob/platform.rs b/gix-diff/tests/diff/blob/platform.rs
index d388a15f901..1c19ea66a12 100644
--- a/gix-diff/tests/diff/blob/platform.rs
+++ b/gix-diff/tests/diff/blob/platform.rs
@@ -1,7 +1,6 @@
-use gix_diff::blob::{
-    Algorithm, Platform, ResourceKind, pipeline, platform,
-    platform::{prepare_diff, prepare_diff::Operation},
-};
+use crate::Result;
+use gix_diff::blob::{Algorithm, Platform, ResourceKind, pipeline, platform, platform::prepare_diff::Operation};
+use gix_error::ExnMessageResult;
 use gix_object::{
     bstr::{BString, ByteSlice},
     tree::EntryKind,
@@ -14,7 +13,7 @@ use crate::{
 };
 
 #[test]
-fn resources_of_worktree_and_odb_and_check_link() -> crate::Result {
+fn resources_of_worktree_and_odb_and_check_link() -> Result {
     let mut platform = new_platform(
         Some(gix_diff::blob::Driver {
             name: "a".into(),
@@ -181,12 +180,7 @@ fn resources_of_worktree_and_odb_and_check_link() -> crate::Result {
     Ok(())
 }
 
-fn comparable_ext_diff(
-    cmd: Result<
-        gix_diff::blob::platform::prepare_diff_command::Command,
-        gix_diff::blob::platform::prepare_diff_command::Error,
-    >,
-) -> String {
+fn comparable_ext_diff(cmd: ExnMessageResult<gix_diff::blob::platform::prepare_diff_command::Command>) -> String {
     let cmd = cmd.expect("no error");
     let command = format!("{:?}", *cmd);
     let parsed = gix_diff::command::parse::command_line(command.as_str().into()).expect("parses fine");
@@ -216,7 +210,7 @@ fn comparable_ext_diff(
 }
 
 #[test]
-fn diff_binary() -> crate::Result {
+fn diff_binary() -> Result {
     let mut platform = new_platform(
         Some(gix_diff::blob::Driver {
             name: "a".into(),
@@ -245,10 +239,9 @@ fn diff_binary() -> crate::Result {
     );
 
     match platform.prepare_diff_command("test".into(), Default::default(), 0, 1) {
-        Err(err) => assert_eq!(
-            err.to_string(),
-            "Binary resources can't be diffed with an external command (as we don't have the data anymore)"
-        ),
+        Err(err) => {
+            insta::assert_debug_snapshot!(err, "diff binary", @"Binary resources can't be diffed with an external command (as we don't have the data anymore)");
+        }
         Ok(_) => unreachable!("must error"),
     }
 
@@ -256,7 +249,7 @@ fn diff_binary() -> crate::Result {
 }
 
 #[test]
-fn diff_performed_despite_external_command() -> crate::Result {
+fn diff_performed_despite_external_command() -> Result {
     let mut platform = new_platform(
         Some(gix_diff::blob::Driver {
             name: "a".into(),
@@ -295,7 +288,7 @@ fn diff_performed_despite_external_command() -> crate::Result {
 }
 
 #[test]
-fn diff_skipped_due_to_external_command_and_enabled_option() -> crate::Result {
+fn diff_skipped_due_to_external_command_and_enabled_option() -> Result {
     let command: BString = "something-to-be-ignored".into();
     let mut platform = new_platform(
         Some(gix_diff::blob::Driver {
@@ -333,7 +326,7 @@ fn diff_skipped_due_to_external_command_and_enabled_option() -> crate::Result {
 }
 
 #[test]
-fn source_and_destination_do_not_exist() -> crate::Result {
+fn source_and_destination_do_not_exist() -> Result {
     let mut platform = new_platform(None, pipeline::Mode::default());
     platform.set_resource(
         gix_hash::Kind::Sha1.null(),
@@ -359,10 +352,9 @@ fn source_and_destination_do_not_exist() -> crate::Result {
     assert_eq!(new.driver_index, None);
     assert_eq!(new.mode, EntryKind::BlobExecutable);
 
-    assert!(matches!(
-        platform.prepare_diff(),
-        Err(prepare_diff::Error::SourceAndDestinationRemoved)
-    ));
+    insta::assert_debug_snapshot!(platform
+            .prepare_diff()
+            .expect_err("both resources are missing"), "source and destination do not exist", @"Tried to diff resources that are both considered removed");
 
     assert_eq!(
         format!(
@@ -393,10 +385,11 @@ fn source_and_destination_do_not_exist() -> crate::Result {
 
 #[test]
 fn invalid_resource_types() {
+    let mut error_snapshots = Vec::new();
     let mut platform = new_platform(None, pipeline::Mode::default());
-    for (mode, name) in [(EntryKind::Commit, "Commit"), (EntryKind::Tree, "Tree")] {
-        assert_eq!(
-            platform
+    for mode in [EntryKind::Commit, EntryKind::Tree] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(platform
                 .set_resource(
                     gix_hash::Kind::Sha1.null(),
                     mode,
@@ -404,11 +397,16 @@ fn invalid_resource_types() {
                     ResourceKind::NewOrDestination,
                     &gix_object::find::Never,
                 )
-                .unwrap_err()
-                .to_string(),
-            format!("Can only diff blobs and links, not {name}")
-        );
+                .unwrap_err()),
+            &[],
+        ));
     }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid resource types", @"
+    [
+        Can only diff blobs and links, not Commit,
+        Can only diff blobs and links, not Tree,
+    ]
+    ");
 }
 
 fn new_platform(
diff --git a/gix-diff/tests/diff/blob/slider.rs b/gix-diff/tests/diff/blob/slider.rs
index 6c424b3adab..7cc8690f7fc 100644
--- a/gix-diff/tests/diff/blob/slider.rs
+++ b/gix-diff/tests/diff/blob/slider.rs
@@ -693,11 +693,12 @@ mod baseline {
 
 mod heuristics {
     //! We can consider to move some of these tests to the actual imara-diff test-suite as well.
+    use crate::Result;
     use gix_diff::blob::{self, diff_with_slider_heuristics};
     use gix_object::bstr::BStr;
 
     #[test]
-    fn basic_usage() -> crate::Result {
+    fn basic_usage() -> Result {
         let before = r#"fn foo() {
         let x = 1;
         println!("x = {}", x);
@@ -725,7 +726,7 @@ mod heuristics {
     }
 
     #[test]
-    fn unified_diff_with_bstr_printer_usage() -> crate::Result {
+    fn unified_diff_with_bstr_printer_usage() -> Result {
         let before: &BStr = r#"fn foo() {
         let x = 1;
         println!("x = {}", x);
@@ -756,7 +757,7 @@ mod heuristics {
 
     /// Test slider heuristics with indentation
     #[test]
-    fn slider_heuristics_with_indentation() -> crate::Result {
+    fn slider_heuristics_with_indentation() -> Result {
         let before = r#"fn main() {
         if true {
             println!("hello");
@@ -785,7 +786,7 @@ mod heuristics {
 
     /// Test that Myers algorithm also works with slider heuristics
     #[test]
-    fn myers_with_slider_heuristics() -> crate::Result {
+    fn myers_with_slider_heuristics() -> Result {
         let before = "a\nb\nc\n";
         let after = "a\nx\nc\n";
 
@@ -803,7 +804,7 @@ mod heuristics {
 
     /// Test empty diff
     #[test]
-    fn empty_diff_with_slider_heuristics() -> crate::Result {
+    fn empty_diff_with_slider_heuristics() -> Result {
         let before = "unchanged\n";
         let after = "unchanged\n";
 
@@ -818,7 +819,7 @@ mod heuristics {
 
     /// Test complex multi-hunk diff with slider heuristics
     #[test]
-    fn multi_hunk_diff_with_slider_heuristics() -> crate::Result {
+    fn multi_hunk_diff_with_slider_heuristics() -> Result {
         let before = r#"struct Foo {
         x: i32,
     }
@@ -858,7 +859,7 @@ mod heuristics {
 
     /// Test custom context size in the local unified diff printer.
     #[test]
-    fn custom_context_size() -> crate::Result {
+    fn custom_context_size() -> Result {
         let before = "line1\nline2\nline3\nline4\nline5\nline6\nline7\n";
         let after = "line1\nline2\nline3\nMODIFIED\nline5\nline6\nline7\n";
 
@@ -896,7 +897,7 @@ mod heuristics {
 
     /// Test that hunks iterator works correctly
     #[test]
-    fn hunks_iterator() -> crate::Result {
+    fn hunks_iterator() -> Result {
         let before = "a\nb\nc\nd\ne\n";
         let after = "a\nX\nc\nY\ne\n";
 
@@ -931,7 +932,7 @@ mod heuristics {
 
     /// Test postprocessing without heuristic
     #[test]
-    fn postprocess_no_heuristic() -> crate::Result {
+    fn postprocess_no_heuristic() -> Result {
         let before = "a\nb\nc\n";
         let after = "a\nX\nc\n";
 
@@ -951,7 +952,7 @@ mod heuristics {
     }
 
     #[test]
-    fn indent_heuristic_available() -> crate::Result {
+    fn indent_heuristic_available() -> Result {
         let before = "fn foo() {\n    x\n}\n";
         let after = "fn foo() {\n    y\n}\n";
 
diff --git a/gix-diff/tests/diff/blob/textconv.rs b/gix-diff/tests/diff/blob/textconv.rs
index 16778caa54d..a47908a52b6 100644
--- a/gix-diff/tests/diff/blob/textconv.rs
+++ b/gix-diff/tests/diff/blob/textconv.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_diff::blob::{self, ResourceKind, pipeline::WorktreeRoots};
@@ -72,7 +73,7 @@ fn binary_diff_with_textconv() -> gix_testtools::Result {
     Ok(())
 }
 
-fn read_id(path: &Path) -> crate::Result<gix_hash::ObjectId> {
+fn read_id(path: &Path) -> Result<gix_hash::ObjectId> {
     let hex = std::fs::read_to_string(path)?;
 
     Ok(gix_hash::ObjectId::from_hex(hex.trim().as_bytes())?)
diff --git a/gix-diff/tests/diff/blob/unified_diff.rs b/gix-diff/tests/diff/blob/unified_diff.rs
index 58221c55b18..7e070afff8c 100644
--- a/gix-diff/tests/diff/blob/unified_diff.rs
+++ b/gix-diff/tests/diff/blob/unified_diff.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_diff::blob::UnifiedDiff;
 use gix_diff::blob::unified_diff::ConsumeBinaryHunk;
 use gix_diff::blob::{
@@ -7,7 +8,7 @@ use gix_diff::blob::{
 use gix_object::bstr::BString;
 
 #[test]
-fn removed_modified_added() -> crate::Result {
+fn removed_modified_added() -> Result {
     let a = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10";
     let b = "2\n3\n4\n5\nsix\n7\n8\n9\n10\neleven\ntwelve";
 
@@ -99,7 +100,7 @@ fn removed_modified_added() -> crate::Result {
 }
 
 #[test]
-fn context_overlap_by_one_line_move_up() -> crate::Result {
+fn context_overlap_by_one_line_move_up() -> Result {
     let a = "2\n3\n4\n5\n6\n7\n";
     let b = "7\n2\n3\n4\n5\n6\n";
 
@@ -126,7 +127,7 @@ fn context_overlap_by_one_line_move_up() -> crate::Result {
 }
 
 #[test]
-fn non_utf8() -> crate::Result {
+fn non_utf8() -> Result {
     let a = &b"\xC0\x80"[..];
     let b = b"ascii";
 
@@ -138,11 +139,17 @@ fn non_utf8() -> crate::Result {
         ContextSize::symmetrical(3),
     )
     .unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "invalid UTF-8 found at byte offset 1",
-        "strings enforce an encoding, which fails here"
-    );
+    insta::assert_debug_snapshot!(err, "strings enforce an encoding, which fails here", @"
+    Custom {
+        kind: Other,
+        error: Utf8Error {
+            valid_up_to: 1,
+            error_len: Some(
+                1,
+            ),
+        },
+    }
+    ");
 
     let actual = render(
         Algorithm::Myers,
@@ -159,7 +166,7 @@ fn non_utf8() -> crate::Result {
 }
 
 #[test]
-fn context_overlap_by_one_line_move_down() -> crate::Result {
+fn context_overlap_by_one_line_move_down() -> Result {
     let a = "2\n3\n4\n5\n6\n7\n";
     let b = "7\n2\n3\n4\n5\n6\n";
 
@@ -186,7 +193,7 @@ fn context_overlap_by_one_line_move_down() -> crate::Result {
 }
 
 #[test]
-fn added_on_top_keeps_context_correctly_sized() -> crate::Result {
+fn added_on_top_keeps_context_correctly_sized() -> Result {
     let a = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10";
     let b = "1\n2\n3\n4\n4.5\n5\n6\n7\n8\n9\n10";
 
@@ -289,7 +296,7 @@ fn added_on_top_keeps_context_correctly_sized() -> crate::Result {
 }
 
 #[test]
-fn removed_modified_added_with_newlines_in_tokens() -> crate::Result {
+fn removed_modified_added_with_newlines_in_tokens() -> Result {
     let a = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10";
     let b = "2\n3\n4\n5\nsix\n7\n8\n9\n10\neleven\ntwelve";
 
@@ -413,7 +420,7 @@ fn removed_modified_added_with_newlines_in_tokens() -> crate::Result {
 }
 
 #[test]
-fn all_added_or_removed() -> crate::Result {
+fn all_added_or_removed() -> Result {
     let content = "1\n2\n3\n4\n5";
 
     let samples = [0, 1, 3, 100];
@@ -462,7 +469,7 @@ fn all_added_or_removed() -> crate::Result {
 }
 
 #[test]
-fn empty() -> crate::Result {
+fn empty() -> Result {
     let interner = gix_diff::blob::InternedInput::new(&b""[..], &b""[..]);
     let actual = render(
         Algorithm::Myers,
diff --git a/gix-diff/tests/diff/index.rs b/gix-diff/tests/diff/index.rs
index 188c19f502c..f30234e914a 100644
--- a/gix-diff/tests/diff/index.rs
+++ b/gix-diff/tests/diff/index.rs
@@ -1,12 +1,14 @@
+use crate::Result;
 use gix_diff::{
     Rewrites,
     index::Change,
     rewrites::{Copies, CopySource},
 };
+use gix_error::ErrorExt;
 use gix_object::bstr::BStr;
 
 #[test]
-fn empty_to_new_tree_without_rename_tracking() -> crate::Result {
+fn empty_to_new_tree_without_rename_tracking() -> Result {
     let changes = collect_changes_no_renames(None, "c1 - initial").expect("really just an addition - nothing to track");
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"
     [
@@ -50,23 +52,23 @@ fn empty_to_new_tree_without_rename_tracking() -> crate::Result {
         let err = gix_diff::index(
             &lhs,
             &rhs,
-            |_change| Err(std::io::Error::other("custom error")),
+            |_change| Err(gix_error::message("custom error").raise_erased()),
             None::<gix_diff::index::RewriteOptions<'_, gix_odb::Handle>>,
             &mut pathspec,
             &mut |_, _, _, _| true,
         )
         .unwrap_err();
-        assert_eq!(
-            format!("{err:?}"),
-            r#"Callback(Custom { kind: Other, error: "custom error" })"#,
-            "custom errors made visible and not squelched"
-        );
+        insta::assert_debug_snapshot!(err, "index diff retains both callback context and the callback's error", @"
+        The callback indicated failure
+        |
+        └─ custom error
+        ");
     }
     Ok(())
 }
 
 #[test]
-fn changes_against_modified_tree_with_filename_tracking() -> crate::Result {
+fn changes_against_modified_tree_with_filename_tracking() -> Result {
     let changes = collect_changes_no_renames("c2", "c3-modification")?;
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"
     [
@@ -102,7 +104,7 @@ fn changes_against_modified_tree_with_filename_tracking() -> crate::Result {
 }
 
 #[test]
-fn renames_by_identity() -> crate::Result {
+fn renames_by_identity() -> Result {
     for (from, to, expected, assert_msg, track_empty) in [
         (
             "c3-modification",
@@ -193,7 +195,7 @@ fn renames_by_identity() -> crate::Result {
 }
 
 #[test]
-fn rename_by_similarity() -> crate::Result {
+fn rename_by_similarity() -> Result {
     insta::allow_duplicates! {
     for percentage in [
         None,
@@ -299,7 +301,7 @@ fn rename_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn renames_by_similarity_with_limit() -> crate::Result {
+fn renames_by_similarity_with_limit() -> Result {
     let (changes, out) = collect_changes_opts(
         "c6",
         "r5",
@@ -357,7 +359,7 @@ fn renames_by_similarity_with_limit() -> crate::Result {
 }
 
 #[test]
-fn copies_by_identity() -> crate::Result {
+fn copies_by_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "c7",
         "tc1-identity",
@@ -428,7 +430,7 @@ fn copies_by_identity() -> crate::Result {
 }
 
 #[test]
-fn copies_by_similarity() -> crate::Result {
+fn copies_by_similarity() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc1-identity",
         "tc2-similarity",
@@ -499,7 +501,7 @@ fn copies_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn copies_in_entire_tree_by_similarity() -> crate::Result {
+fn copies_in_entire_tree_by_similarity() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc2-similarity",
         "tc3-find-harder",
@@ -613,7 +615,7 @@ fn copies_in_entire_tree_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn copies_in_entire_tree_by_similarity_with_limit() -> crate::Result {
+fn copies_in_entire_tree_by_similarity_with_limit() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc2-similarity",
         "tc3-find-harder",
@@ -697,7 +699,7 @@ fn copies_in_entire_tree_by_similarity_with_limit() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_by_identity() -> crate::Result {
+fn realistic_renames_by_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "r1-base",
         "r1-change",
@@ -759,7 +761,7 @@ fn realistic_renames_by_identity() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_disabled() -> crate::Result {
+fn realistic_renames_disabled() -> Result {
     let changes = collect_changes_no_renames("r1-base", "r1-change")?;
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&(changes.into_iter().collect::<Vec<_>>())).0, @r#"
     [
@@ -806,7 +808,7 @@ fn realistic_renames_disabled() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_disabled_3() -> crate::Result {
+fn realistic_renames_disabled_3() -> Result {
     let changes = collect_changes_no_renames("r3-base", "r3-change")?;
 
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&(changes.into_iter().collect::<Vec<_>>())).0, @r#"
@@ -850,7 +852,7 @@ fn realistic_renames_disabled_3() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_by_identity_3() -> crate::Result {
+fn realistic_renames_by_identity_3() -> Result {
     let (changes, out) = collect_changes_opts(
         "r3-base",
         "r3-change",
@@ -909,7 +911,7 @@ fn realistic_renames_by_identity_3() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_2() -> crate::Result {
+fn realistic_renames_2() -> Result {
     let (changes, out) = collect_changes_opts(
         "r2-base",
         "r2-change",
@@ -1068,7 +1070,7 @@ fn realistic_renames_2() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_3_without_identity() -> crate::Result {
+fn realistic_renames_3_without_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "r4-base",
         "r4-dir-rename-non-identity",
@@ -1268,7 +1270,7 @@ fn realistic_renames_3_without_identity() -> crate::Result {
 }
 
 #[test]
-fn unmerged_entries_and_intent_to_add() -> crate::Result {
+fn unmerged_entries_and_intent_to_add() -> Result {
     let (changes, _out) = collect_changes_opts(
         "r4-dir-rename-non-identity",
         ".git/index",
@@ -1300,14 +1302,14 @@ fn unmerged_entries_and_intent_to_add() -> crate::Result {
 }
 
 mod util {
-    use std::{
-        convert::Infallible,
-        path::{Path, PathBuf},
-    };
+    use crate::Result;
+    use std::path::{Path, PathBuf};
+
+    use gix_error::ExnResult;
 
     use gix_diff::rewrites;
 
-    fn repo_workdir() -> crate::Result<PathBuf> {
+    fn repo_workdir() -> Result<PathBuf> {
         crate::scripted_fixture_read_only("make_diff_for_rewrites_repo.sh")
     }
 
@@ -1375,7 +1377,7 @@ mod util {
         let rewrites_info = gix_diff::index(
             &from,
             &to,
-            |change| -> Result<_, Infallible> {
+            |change| -> ExnResult<_> {
                 out.push(change.into_owned());
                 Ok(std::ops::ControlFlow::Continue(()))
             },
diff --git a/gix-diff/tests/diff/main.rs b/gix-diff/tests/diff/main.rs
index 89b7b4a2a48..70f75629245 100644
--- a/gix-diff/tests/diff/main.rs
+++ b/gix-diff/tests/diff/main.rs
@@ -74,7 +74,8 @@ mod tree;
 mod tree_with_rewrites;
 
 mod util {
-    use gix_object::{Write, find::Error};
+    use gix_error::ExnResult;
+    use gix_object::Write;
 
     pub type ObjectDb = gix_odb::memory::Proxy<gix_object::find::Never>;
 
@@ -83,7 +84,7 @@ mod util {
     }
 
     /// Insert `data` and return its hash. That can be used to find it again.
-    pub fn insert(db: &ObjectDb, data: &str) -> Result<gix_hash::ObjectId, Error> {
+    pub fn insert(db: &ObjectDb, data: &str) -> ExnResult<gix_hash::ObjectId> {
         db.write_buf(gix_object::Kind::Blob, data.as_bytes())
     }
 }
diff --git a/gix-diff/tests/diff/rewrites/tracker.rs b/gix-diff/tests/diff/rewrites/tracker.rs
index 42424be20a8..3802bb1b914 100644
--- a/gix-diff/tests/diff/rewrites/tracker.rs
+++ b/gix-diff/tests/diff/rewrites/tracker.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_diff::{
     Rewrites,
     blob::DiffLineStats,
@@ -20,7 +21,7 @@ use crate::{
 };
 
 #[test]
-fn rename_by_id() -> crate::Result {
+fn rename_by_id() -> Result {
     // Limits are only applied when doing rewrite-checks
     for limit in [0, 1] {
         let rewrites = Rewrites {
@@ -130,7 +131,7 @@ fn gitlinks_are_renamed_only_by_id() {
 }
 
 #[test]
-fn copy_by_similarity_reports_limit_if_encountered() -> crate::Result {
+fn copy_by_similarity_reports_limit_if_encountered() -> Result {
     let rewrites = Rewrites {
         copies: Some(Copies {
             source: CopySource::FromSetOfModifiedFiles,
@@ -181,7 +182,7 @@ fn copy_by_similarity_reports_limit_if_encountered() -> crate::Result {
 }
 
 #[test]
-fn copy_by_id() -> crate::Result {
+fn copy_by_id() -> Result {
     // Limits are only applied when doing rewrite-checks
     for limit in [0, 1] {
         let rewrites = Rewrites {
@@ -259,7 +260,7 @@ fn copy_by_id() -> crate::Result {
 }
 
 #[test]
-fn copy_by_id_search_in_all_sources() -> crate::Result {
+fn copy_by_id_search_in_all_sources() -> Result {
     // Limits are only applied when doing rewrite-checks
     for limit in [0, 1] {
         let rewrites = Rewrites {
@@ -344,7 +345,7 @@ fn copy_by_id_search_in_all_sources() -> crate::Result {
 }
 
 #[test]
-fn copy_by_50_percent_similarity() -> crate::Result {
+fn copy_by_50_percent_similarity() -> Result {
     let rewrites = Rewrites {
         copies: Some(Copies {
             source: CopySource::FromSetOfModifiedFiles,
@@ -427,7 +428,7 @@ fn copy_by_50_percent_similarity() -> crate::Result {
 }
 
 #[test]
-fn copy_by_id_in_additions_only() -> crate::Result {
+fn copy_by_id_in_additions_only() -> Result {
     let rewrites = Rewrites {
         copies: Some(Copies {
             source: CopySource::FromSetOfModifiedFiles,
@@ -481,7 +482,7 @@ fn copy_by_id_in_additions_only() -> crate::Result {
 }
 
 #[test]
-fn rename_by_similarity_reports_limit_if_encountered() -> crate::Result {
+fn rename_by_similarity_reports_limit_if_encountered() -> Result {
     let rewrites = Rewrites {
         copies: None,
         percentage: Some(0.5),
@@ -527,7 +528,7 @@ fn rename_by_similarity_reports_limit_if_encountered() -> crate::Result {
 }
 
 #[test]
-fn rename_by_50_percent_similarity() -> crate::Result {
+fn rename_by_50_percent_similarity() -> Result {
     let rewrites = Rewrites {
         copies: None,
         percentage: Some(0.5),
@@ -612,7 +613,7 @@ fn rename_by_50_percent_similarity() -> crate::Result {
 }
 
 #[test]
-fn rename_by_similarity_prefers_stronger_match_over_same_filename_match() -> crate::Result {
+fn rename_by_similarity_prefers_stronger_match_over_same_filename_match() -> Result {
     let rewrites = Rewrites {
         copies: None,
         percentage: Some(0.5),
@@ -671,7 +672,7 @@ fn rename_by_similarity_prefers_stronger_match_over_same_filename_match() -> cra
 }
 
 #[test]
-fn directories_without_relation_are_ignored() -> crate::Result {
+fn directories_without_relation_are_ignored() -> Result {
     let mut track = util::new_tracker(Default::default());
     let tree_without_relation = Change {
         id: *NULL_ID,
@@ -688,7 +689,7 @@ fn directories_without_relation_are_ignored() -> crate::Result {
 }
 
 #[test]
-fn directory_renames_by_id_can_fail_gracefully() -> crate::Result {
+fn directory_renames_by_id_can_fail_gracefully() -> Result {
     let rename_by_similarity = Rewrites {
         copies: None,
         percentage: Some(0.5),
@@ -837,7 +838,7 @@ fn directory_renames_by_id_can_fail_gracefully() -> crate::Result {
 }
 
 #[test]
-fn simple_directory_rename_by_id() -> crate::Result {
+fn simple_directory_rename_by_id() -> Result {
     let renames_by_identity = Rewrites {
         copies: None,
         percentage: None,
@@ -1004,7 +1005,7 @@ fn simple_directory_rename_by_id() -> crate::Result {
 }
 
 #[test]
-fn remove_only() -> crate::Result {
+fn remove_only() -> Result {
     let mut track = util::new_tracker(Default::default());
     assert!(
         track.try_push_change(Change::deletion(), "a".into()).is_none(),
@@ -1025,7 +1026,7 @@ fn remove_only() -> crate::Result {
 }
 
 #[test]
-fn add_only() -> crate::Result {
+fn add_only() -> Result {
     let mut track = util::new_tracker(Default::default());
     assert!(
         track.try_push_change(Change::addition(), "a".into()).is_none(),
@@ -1045,7 +1046,7 @@ fn add_only() -> crate::Result {
 }
 
 #[test]
-fn rename_tracking_is_order_independent() -> crate::Result {
+fn rename_tracking_is_order_independent() -> Result {
     // #1832: exactly one of several identical-content additions can be matched as the rename of a
     // deletion. Which one is chosen must not depend on the order in which items are pushed - but
     // the parallel dirwalk and index-traversal threads deliver them in a nondeterministic order,
@@ -1083,7 +1084,7 @@ fn rename_tracking_is_order_independent() -> crate::Result {
 }
 
 #[test]
-fn copy_source_selection_is_order_independent() -> crate::Result {
+fn copy_source_selection_is_order_independent() -> Result {
     // #1832, exhaustive-copy variant: with copies searched against all sources - including the whole
     // source tree that is pushed in during `emit` - the source chosen for an identical-content
     // destination must not depend on the order items were pushed. This also exercises the second
@@ -1159,6 +1160,7 @@ fn permutations<T: Clone>(items: Vec<T>) -> Vec<Vec<T>> {
     out
 }
 mod util {
+    use crate::Result;
     use gix_diff::{
         Rewrites, rewrites,
         rewrites::tracker::visit::{Destination, Source},
@@ -1174,7 +1176,7 @@ mod util {
     pub fn add_retained_blobs<'a>(
         tracker: &mut rewrites::Tracker<Change>,
         blobs: impl IntoIterator<Item = (Change, &'a str, &'a str)>,
-    ) -> crate::Result<ObjectDb> {
+    ) -> Result<ObjectDb> {
         let db = object_db();
         for (mut change, location, data) in blobs {
             change.id = insert(&db, data)?;
@@ -1213,7 +1215,7 @@ mod util {
                 cb,
                 &mut new_platform_no_worktree(),
                 &objects,
-                |cb| -> Result<(), std::io::Error> {
+                |cb| -> std::result::Result<(), std::io::Error> {
                     let sources = std::mem::take(&mut sources);
                     if sources.is_empty() {
                         panic!("Should not access more sources unless these are specified");
diff --git a/gix-diff/tests/diff/tree.rs b/gix-diff/tests/diff/tree.rs
index 990afee5787..77aa56ecebd 100644
--- a/gix-diff/tests/diff/tree.rs
+++ b/gix-diff/tests/diff/tree.rs
@@ -1,5 +1,6 @@
 mod changes {
     mod to_obtain_tree {
+        use crate::Result;
         use std::collections::HashMap;
 
         use gix_diff::tree::{
@@ -15,7 +16,7 @@ mod changes {
 
         type Changes = Vec<recorder::Change>;
 
-        fn db(args: impl IntoIterator<Item = &'static str>) -> crate::Result<gix_odb::Handle> {
+        fn db(args: impl IntoIterator<Item = &'static str>) -> Result<gix_odb::Handle> {
             crate::open_odb(
                 crate::scripted_fixture_read_only_with_args("make_diff_repo.sh", args)?
                     .join(".git")
@@ -28,7 +29,7 @@ mod changes {
             db: &gix_odb::Handle,
             commit: &oid,
             buf: &'a mut Vec<u8>,
-        ) -> crate::Result<TreeRefIter<'a>> {
+        ) -> Result<TreeRefIter<'a>> {
             let tree_id = db
                 .try_find(commit, buf)?
                 .ok_or_else(|| format!("start commit {commit:?} to be present"))?
@@ -51,7 +52,7 @@ mod changes {
             lhs: impl Into<Option<ObjectId>>,
             rhs: &oid,
             location: Option<Location>,
-        ) -> crate::Result<Changes> {
+        ) -> Result<Changes> {
             let mut buf = Vec::new();
             let lhs_tree = lhs
                 .into()
@@ -69,7 +70,7 @@ mod changes {
             Ok(recorder.records)
         }
 
-        fn diff_with_previous_commit_from(db: &gix_odb::Handle, commit_id: &oid) -> crate::Result<Changes> {
+        fn diff_with_previous_commit_from(db: &gix_odb::Handle, commit_id: &oid) -> Result<Changes> {
             let mut buf = Vec::new();
             let (main_tree_id, parent_commit_id) = {
                 let commit = db
@@ -133,7 +134,7 @@ mod changes {
 
             let head = head_of(db);
             gix_traverse::commit::Simple::new(Some(head), &db)
-                .collect::<Result<Vec<_>, _>>()
+                .collect::<std::result::Result<Vec<_>, _>>()
                 .expect("valid iteration")
                 .into_iter()
                 .map(|c| {
@@ -153,7 +154,7 @@ mod changes {
         }
 
         #[test]
-        fn many_different_states() -> crate::Result {
+        fn many_different_states() -> Result {
             let db = db(None)?;
             let all_commits = all_commits(&db);
             pretty_assertions::assert_eq!(
@@ -557,7 +558,7 @@ mod changes {
         }
 
         #[test]
-        fn many_different_states_nested() -> crate::Result {
+        fn many_different_states_nested() -> Result {
             let db = db(["a"].iter().copied())?;
             let all_commits = all_commits(&db);
 
@@ -628,7 +629,7 @@ mod changes {
         }
 
         #[test]
-        fn maximal_difference() -> crate::Result {
+        fn maximal_difference() -> Result {
             let db = db(None)?;
             let all_commits = all_commits(&db);
 
@@ -694,7 +695,7 @@ mod changes {
         }
 
         #[test]
-        fn maximal_difference_nested() -> crate::Result {
+        fn maximal_difference_nested() -> Result {
             let db = db(["a"].iter().copied())?;
             let all_commits = all_commits(&db);
             let empty_blob_id = hex_to_id(
@@ -765,7 +766,7 @@ mod changes {
         }
 
         #[test]
-        fn directory_rename() -> crate::Result {
+        fn directory_rename() -> Result {
             let db = db(None)?;
             let all_commits = all_commits(&db);
             let empty_blob_id = hex_to_id(
@@ -854,7 +855,7 @@ mod changes {
         }
 
         #[test]
-        fn reverse_directory_rename() -> crate::Result {
+        fn reverse_directory_rename() -> Result {
             let db = db(None)?;
             let all_commits = all_commits(&db);
             let empty_blob_id = hex_to_id(
diff --git a/gix-diff/tests/diff/tree_with_rewrites.rs b/gix-diff/tests/diff/tree_with_rewrites.rs
index a26cddc964d..ca1145af360 100644
--- a/gix-diff/tests/diff/tree_with_rewrites.rs
+++ b/gix-diff/tests/diff/tree_with_rewrites.rs
@@ -1,13 +1,16 @@
+use crate::Result;
 use gix_diff::{
     Rewrites,
     rewrites::{Copies, CopySource},
     tree::{recorder::Location, visit::Relation},
     tree_with_rewrites::{Change, Options},
 };
+use gix_error::ErrorExt;
 use gix_object::{TreeRefIter, bstr::BStr};
 
 #[test]
-fn empty_to_new_tree_without_rename_tracking() -> crate::Result {
+fn empty_to_new_tree_without_rename_tracking() -> Result {
+    let mut error_snapshots = Vec::new();
     let (changes, _out) = collect_changes(None, "c1 - initial").expect("full path tracking is the default");
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"
     [
@@ -112,21 +115,26 @@ fn empty_to_new_tree_without_rename_tracking() -> crate::Result {
             &mut cache,
             &mut Default::default(),
             &odb,
-            |_change| Err(std::io::Error::other("custom error")),
+            |_change| Err(gix_error::message("custom error").raise_erased()),
             Options::default(),
         )
         .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "The user-provided callback failed",
-            "custom errors made visible and not squelched"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(error_snapshots, "empty to new tree without rename tracking", @"
+    [
+        Failure(
+            The user-provided callback failed
+            |
+            └─ custom error,
+        ),
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn changes_against_modified_tree_with_filename_tracking() -> crate::Result {
+fn changes_against_modified_tree_with_filename_tracking() -> Result {
     let (changes, _out) = collect_changes("c2", "c3-modification")?;
 
     insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"
@@ -191,7 +199,7 @@ fn changes_against_modified_tree_with_filename_tracking() -> crate::Result {
 }
 
 #[test]
-fn renames_by_identity() -> crate::Result {
+fn renames_by_identity() -> Result {
     for (from, to, expected, assert_msg, track_empty) in [
         (
             "c3-modification",
@@ -286,7 +294,7 @@ fn renames_by_identity() -> crate::Result {
 }
 
 #[test]
-fn rename_by_similarity() -> crate::Result {
+fn rename_by_similarity() -> Result {
     insta::allow_duplicates! {
     for percentage in [
         None,
@@ -404,7 +412,7 @@ fn rename_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn renames_by_similarity_with_limit() -> crate::Result {
+fn renames_by_similarity_with_limit() -> Result {
     let (changes, out) = collect_changes_opts(
         "c6",
         "r5",
@@ -433,7 +441,7 @@ fn renames_by_similarity_with_limit() -> crate::Result {
 }
 
 #[test]
-fn copies_by_identity() -> crate::Result {
+fn copies_by_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "c7",
         "tc1-identity",
@@ -505,7 +513,7 @@ fn copies_by_identity() -> crate::Result {
 }
 
 #[test]
-fn copies_by_similarity() -> crate::Result {
+fn copies_by_similarity() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc1-identity",
         "tc2-similarity",
@@ -593,7 +601,7 @@ fn copies_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn copies_in_entire_tree_by_similarity() -> crate::Result {
+fn copies_in_entire_tree_by_similarity() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc2-similarity",
         "tc3-find-harder",
@@ -705,7 +713,7 @@ fn copies_in_entire_tree_by_similarity() -> crate::Result {
 }
 
 #[test]
-fn copies_in_entire_tree_by_similarity_with_limit() -> crate::Result {
+fn copies_in_entire_tree_by_similarity_with_limit() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc2-similarity",
         "tc3-find-harder",
@@ -776,7 +784,7 @@ fn copies_in_entire_tree_by_similarity_with_limit() -> crate::Result {
 }
 
 #[test]
-fn copies_by_similarity_with_limit() -> crate::Result {
+fn copies_by_similarity_with_limit() -> Result {
     let (changes, out) = collect_changes_opts(
         "tc1-identity",
         "tc2-similarity",
@@ -838,7 +846,7 @@ fn copies_by_similarity_with_limit() -> crate::Result {
 }
 
 #[test]
-fn realistic_renames_by_identity() -> crate::Result {
+fn realistic_renames_by_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "r1-base",
         "r1-change",
@@ -918,7 +926,7 @@ index e69de29..8ba3a16 100644
 }
 
 #[test]
-fn realistic_renames_disabled() -> crate::Result {
+fn realistic_renames_disabled() -> Result {
     let (changes, out) = collect_changes_opts(
         "r1-base",
         "r1-change",
@@ -991,7 +999,7 @@ index e69de29..8ba3a16 100644
 }
 
 #[test]
-fn realistic_renames_disabled_2() -> crate::Result {
+fn realistic_renames_disabled_2() -> Result {
     let (changes, out) = collect_changes_opts(
         "r2-base",
         "r2-change",
@@ -1258,7 +1266,7 @@ index 0000000..e69de29
 }
 
 #[test]
-fn realistic_renames_disabled_3() -> crate::Result {
+fn realistic_renames_disabled_3() -> Result {
     let (changes, out) = collect_changes_opts(
         "r3-base",
         "r3-change",
@@ -1330,7 +1338,7 @@ index e69de29..0000000
 }
 
 #[test]
-fn realistic_renames_by_identity_3() -> crate::Result {
+fn realistic_renames_by_identity_3() -> Result {
     let (changes, out) = collect_changes_opts(
         "r3-base",
         "r3-change",
@@ -1409,7 +1417,7 @@ rename to src/gix.rs
 }
 
 #[test]
-fn realistic_renames_2() -> crate::Result {
+fn realistic_renames_2() -> Result {
     let (changes, out) = collect_changes_opts(
         "r2-base",
         "r2-change",
@@ -1672,7 +1680,7 @@ rename to gix-sec/tests/sec.rs
 }
 
 #[test]
-fn realistic_renames_3_without_identity() -> crate::Result {
+fn realistic_renames_3_without_identity() -> Result {
     let (changes, out) = collect_changes_opts(
         "r4-base",
         "r4-dir-rename-non-identity",
@@ -1888,15 +1896,15 @@ fn realistic_renames_3_without_identity() -> crate::Result {
 }
 
 mod util {
-    use std::{
-        convert::Infallible,
-        path::{Path, PathBuf},
-    };
+    use crate::Result;
+    use std::path::{Path, PathBuf};
+
+    use gix_error::ExnResult;
 
     use gix_diff::rewrites;
     use gix_object::{FindExt, TreeRefIter};
 
-    pub fn repo_workdir() -> crate::Result<PathBuf> {
+    pub fn repo_workdir() -> Result<PathBuf> {
         crate::scripted_fixture_read_only("make_diff_for_rewrites_repo.sh")
     }
 
@@ -1953,7 +1961,7 @@ mod util {
             &mut cache,
             &mut Default::default(),
             &odb,
-            |change| -> Result<_, Infallible> {
+            |change| -> ExnResult<_> {
                 out.push(change.into_owned());
                 Ok(std::ops::ControlFlow::Continue(()))
             },
diff --git a/gix-dir/Cargo.toml b/gix-dir/Cargo.toml
index 5d75af230c9..e95ab8860dd 100644
--- a/gix-dir/Cargo.toml
+++ b/gix-dir/Cargo.toml
@@ -22,6 +22,7 @@ sha1 = ["gix-index/sha1", "gix-worktree/sha1"]
 sha256 = ["gix-index/sha256", "gix-worktree/sha256"]
 
 [dependencies]
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-trace = { version = "^0.1.21", path = "../gix-trace" }
 gix-index = { version = "^0.55.0", path = "../gix-index" }
 gix-discover = { version = "^0.55.0", path = "../gix-discover" }
@@ -34,9 +35,9 @@ gix-ignore = { version = "^0.22.1", path = "../gix-ignore" }
 gix-utils = { version = "^0.3.6", path = "../gix-utils", features = ["bstr"] }
 
 bstr = { version = "1.12.0", default-features = false }
-thiserror = "2.0.18"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-dir = { path = ".", features = ["sha1", "sha256"] }
 gix-testtools = { path = "../tests/tools" }
 gix-fs = { path = "../gix-fs" }
diff --git a/gix-dir/src/walk/classify.rs b/gix-dir/src/walk/classify.rs
index 6bf9d0b6961..534ec241a1b 100644
--- a/gix-dir/src/walk/classify.rs
+++ b/gix-dir/src/walk/classify.rs
@@ -4,11 +4,12 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ExnResult, ResultExt, message};
 
 use crate::{
     Entry, EntryRef, entry,
     entry::PathspecMatch,
-    walk::{Context, Error, ForDeletionMode, Options},
+    walk::{Context, ForDeletionMode, Options},
 };
 
 /// Classify the `worktree_relative_root` path and return the first `PathKind` that indicates that
@@ -20,7 +21,7 @@ pub fn root(
     worktree_relative_root: &Path,
     options: Options<'_>,
     ctx: &mut Context<'_>,
-) -> Result<(Outcome, bool), Error> {
+) -> ExnResult<(Outcome, bool)> {
     buf.clear();
     let mut last_length = None;
     let mut path_buf = worktree_root.to_owned();
@@ -146,7 +147,7 @@ pub fn path(
         ..
     }: Options<'_>,
     ctx: &mut Context<'_>,
-) -> Result<Outcome, Error> {
+) -> ExnResult<Outcome> {
     let mut out = Outcome {
         status: entry::Status::Pruned,
         property: None,
@@ -176,7 +177,7 @@ pub fn path(
                         )
                         .map(|platform| platform.excluded_kind())
                 })
-                .map_err(Error::ExcludesAccess)?
+                .or_raise_erased(|| message("Failed to update the excludes stack to see if a path is excluded"))?
                 .filter(|_| filename_start_idx > 0)
         {
             out.status = entry::Status::Ignored(excluded);
@@ -253,7 +254,7 @@ pub fn path(
                 .at_entry(rela_path.as_bstr(), is_dir, ctx.objects)
                 .map(|platform| platform.excluded_kind())
         })
-        .map_err(Error::ExcludesAccess)?
+        .or_raise_erased(|| message("Failed to update the excludes stack to see if a path is excluded"))?
     {
         if emit_ignored.is_some() {
             if matches!(
diff --git a/gix-dir/src/walk/function.rs b/gix-dir/src/walk/function.rs
index 674737ff20b..f867cdd0e9e 100644
--- a/gix-dir/src/walk/function.rs
+++ b/gix-dir/src/walk/function.rs
@@ -4,10 +4,11 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, validation};
 
 use crate::{
     EntryRef, entry,
-    walk::{Action, Context, Delegate, Error, ForDeletionMode, Options, Outcome, classify, readdir},
+    walk::{Action, Context, Delegate, ForDeletionMode, Options, Outcome, classify, readdir},
 };
 
 /// A function to perform a git-style, unsorted, directory walk.
@@ -48,7 +49,7 @@ pub fn walk(
     mut ctx: Context<'_>,
     options: Options<'_>,
     delegate: &mut dyn Delegate,
-) -> Result<(Outcome, PathBuf), Error> {
+) -> ExnResult<(Outcome, PathBuf)> {
     let root = match ctx.explicit_traversal_root {
         Some(root) => root.to_owned(),
         None => ctx
@@ -88,7 +89,7 @@ pub fn walk(
     );
     if !can_recurse {
         if buf.is_empty() && !root_info.disk_kind.is_some_and(|kind| kind.is_dir()) {
-            return Err(Error::WorktreeRootIsFile { root: root.to_owned() });
+            return Err(validation(format!("Worktree root at '{}' is not a directory", root.display())).raise_erased());
         }
         if options.precompose_unicode {
             buf = gix_utils::str::precompose_bstr(buf.into()).into_owned();
@@ -128,29 +129,30 @@ pub fn walk(
 /// Note that we only check symlinks on the way from `worktree_root` to `root`,
 /// so `worktree_root` may go through a symlink.
 /// Returns `(worktree_root, normalized_worktree_relative_root)`.
-fn assure_no_symlink_in_root<'root>(
-    worktree_root: &Path,
-    root: &'root Path,
-) -> Result<(PathBuf, Cow<'root, Path>), Error> {
+fn assure_no_symlink_in_root<'root>(worktree_root: &Path, root: &'root Path) -> ExnResult<(PathBuf, Cow<'root, Path>)> {
     let mut current = worktree_root.to_owned();
     let worktree_relative = root
         .strip_prefix(worktree_root)
         .expect("BUG: root was created from worktree_root + prefix");
-    let worktree_relative = gix_path::normalize(worktree_relative.into(), Path::new(""))
-        .ok_or(Error::NormalizeRoot { root: root.to_owned() })?;
+    let worktree_relative = gix_path::normalize(worktree_relative.into(), Path::new("")).ok_or_raise_erased(|| {
+        validation(format!(
+            "Traversal root '{}' contains relative path components and could not be normalized",
+            root.display()
+        ))
+    })?;
 
     for (idx, component) in worktree_relative.components().enumerate() {
         current.push(component);
-        let meta = current.symlink_metadata().map_err(|err| Error::SymlinkMetadata {
-            source: err,
-            path: current.to_owned(),
-        })?;
+        let meta = current
+            .symlink_metadata()
+            .or_raise_erased(|| gix_error::message!("Could not obtain symlink metadata on '{}'", current.display()))?;
         if meta.is_symlink() {
-            return Err(Error::SymlinkInRoot {
-                root: root.to_owned(),
-                worktree_root: worktree_root.to_owned(),
-                component_index: idx,
-            });
+            return Err(validation(format!(
+                "A symlink was found at component {idx} of traversal root '{}' as seen from worktree root '{}'",
+                root.display(),
+                worktree_root.display()
+            ))
+            .raise_erased());
         }
     }
     Ok((current, worktree_relative))
diff --git a/gix-dir/src/walk/mod.rs b/gix-dir/src/walk/mod.rs
index 0529f097cca..1529ba8ddf3 100644
--- a/gix-dir/src/walk/mod.rs
+++ b/gix-dir/src/walk/mod.rs
@@ -1,4 +1,4 @@
-use std::{collections::BTreeSet, path::PathBuf, sync::atomic::AtomicBool};
+use std::{collections::BTreeSet, sync::atomic::AtomicBool};
 
 use bstr::{BStr, BString};
 
@@ -273,38 +273,6 @@ pub struct Outcome {
     pub seen_entries: u32,
 }
 
-/// The error returned by [`walk()`](function::walk()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Interrupted")]
-    Interrupted,
-    #[error("Worktree root at '{}' is not a directory", root.display())]
-    WorktreeRootIsFile { root: PathBuf },
-    #[error("Traversal root '{}' contains relative path components and could not be normalized", root.display())]
-    NormalizeRoot { root: PathBuf },
-    #[error("A symlink was found at component {component_index} of traversal root '{}' as seen from worktree root '{}'", root.display(), worktree_root.display())]
-    SymlinkInRoot {
-        root: PathBuf,
-        worktree_root: PathBuf,
-        /// This index starts at 0, with 0 being the first component.
-        component_index: usize,
-    },
-    #[error("Failed to update the excludes stack to see if a path is excluded")]
-    ExcludesAccess(std::io::Error),
-    #[error("Failed to read the directory at '{}'", path.display())]
-    ReadDir { path: PathBuf, source: std::io::Error },
-    #[error("Could not obtain directory entry in root of '{}'", parent_directory.display())]
-    DirEntry {
-        parent_directory: PathBuf,
-        source: std::io::Error,
-    },
-    #[error("Could not obtain filetype of directory entry '{}'", path.display())]
-    DirEntryFileType { path: PathBuf, source: std::io::Error },
-    #[error("Could not obtain symlink metadata on '{}'", path.display())]
-    SymlinkMetadata { path: PathBuf, source: std::io::Error },
-}
-
 mod classify;
 pub(crate) mod function;
 mod readdir;
diff --git a/gix-dir/src/walk/readdir.rs b/gix-dir/src/walk/readdir.rs
index 56374cb2f86..55fa6805f17 100644
--- a/gix-dir/src/walk/readdir.rs
+++ b/gix-dir/src/walk/readdir.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 
 use crate::{
     Entry, EntryRef, entry,
@@ -13,7 +14,7 @@ use crate::{
     walk::{
         Action, CollapsedEntriesEmissionMode, Context, Delegate,
         EmissionMode::CollapseDirectory,
-        Error, ForDeletionMode, Options, Outcome, classify,
+        ForDeletionMode, Options, Outcome, classify,
         function::{can_recurse, emit_entry},
     },
 };
@@ -32,23 +33,20 @@ pub(super) fn recursive(
     delegate: &mut dyn Delegate,
     out: &mut Outcome,
     state: &mut State,
-) -> Result<(Action, bool), Error> {
+) -> ExnResult<(Action, bool)> {
     if ctx.should_interrupt.is_some_and(|flag| flag.load(Ordering::Relaxed)) {
-        return Err(Error::Interrupted);
+        return Err(message("Interrupted").raise_erased());
     }
     out.read_dir_calls += 1;
-    let entries = gix_fs::read_dir(current, opts.precompose_unicode).map_err(|err| Error::ReadDir {
-        path: current.to_owned(),
-        source: err,
-    })?;
+    let entries = gix_fs::read_dir(current, opts.precompose_unicode)
+        .or_raise_erased(|| gix_error::message!("Failed to read the directory at '{}'", current.display()))?;
 
     let mut num_entries = 0;
     let mark = state.mark(may_collapse);
     let mut prevent_collapse = false;
     for entry in entries {
-        let entry = entry.map_err(|err| Error::DirEntry {
-            parent_directory: current.to_owned(),
-            source: err,
+        let entry = entry.or_raise_erased(|| {
+            gix_error::message!("Could not obtain directory entry in root of '{}'", current.display())
         })?;
         // Important to count right away, otherwise the directory could be seen as empty even though it's not.
         // That is, this should be independent of the kind.
diff --git a/gix-dir/tests/dir/walk.rs b/gix-dir/tests/dir/walk.rs
index 44a1795f805..3141aac501e 100644
--- a/gix-dir/tests/dir/walk.rs
+++ b/gix-dir/tests/dir/walk.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{collections::BTreeSet, sync::atomic::AtomicBool};
 
 use gix_dir::{
@@ -36,10 +37,8 @@ fn root_is_fifo() {
         )
     })
     .unwrap_err();
-    assert!(
-        matches!(err, gix_dir::walk::Error::WorktreeRootIsFile { .. }),
-        "roots simply need to be directories to work"
-    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(root).to_string_lossy(), "<root>")]), "roots simply need to be directories to work", @"Worktree root at '<root>/' is not a directory");
+    assert!(err.is_validation(), "roots simply need to be directories to work");
 }
 
 #[test]
@@ -113,7 +112,7 @@ fn fifo_in_traversal() {
 }
 
 #[test]
-fn symlink_to_dir_can_be_excluded() -> crate::Result {
+fn symlink_to_dir_can_be_excluded() -> Result {
     let root = fixture_in("many-symlinks", "excluded-symlinks-to-dir");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -187,11 +186,12 @@ fn symlink_to_dir_can_be_excluded() -> crate::Result {
 }
 
 #[test]
-fn root_may_not_lead_through_symlinks() -> crate::Result {
-    for (name, intermediate, expected) in [
-        ("immediate-breakout-symlink", "", 0),
-        ("breakout-symlink", "hide", 1),
-        ("breakout-symlink", "hide/../hide", 1),
+fn root_may_not_lead_through_symlinks() -> Result {
+    let mut error_snapshots = Vec::new();
+    for (name, intermediate) in [
+        ("immediate-breakout-symlink", ""),
+        ("breakout-symlink", "hide"),
+        ("breakout-symlink", "hide/../hide"),
     ] {
         let root = fixture_in("many-symlinks", name);
         let troot = root.join(intermediate).join("breakout");
@@ -204,16 +204,24 @@ fn root_may_not_lead_through_symlinks() -> crate::Result {
             Default::default(),
         )
         .unwrap_err();
-        assert!(
-            matches!(err, walk::Error::SymlinkInRoot { component_index, .. } if component_index == expected),
-            "{name} should have component {expected}"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(err),
+            &[(&(root).to_string_lossy(), "<root>")],
+        ));
+        assert!(err.is_validation(), "symlinks in the traversal root are invalid");
     }
+    insta::assert_debug_snapshot!(error_snapshots, "root may not lead through symlinks", @"
+    [
+        A symlink was found at component 0 of traversal root '<root>/breakout' as seen from worktree root '<root>',
+        A symlink was found at component 1 of traversal root '<root>/hide/breakout' as seen from worktree root '<root>',
+        A symlink was found at component 1 of traversal root '<root>/hide/../hide/breakout' as seen from worktree root '<root>',
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn root_may_be_a_symlink_if_it_is_the_worktree() -> crate::Result {
+fn root_may_be_a_symlink_if_it_is_the_worktree() -> Result {
     let root = fixture_in("many-symlinks", "worktree-root-is-symlink");
     let ((_out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -246,7 +254,7 @@ fn root_may_be_a_symlink_if_it_is_the_worktree() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn assume_unchanged_submodule_replaced_with_symlink_is_hidden() -> crate::Result {
+fn assume_unchanged_submodule_replaced_with_symlink_is_hidden() -> Result {
     let root = fixture_in("many-symlinks", "submodule-assume-unchanged-symlink");
     let ((out, _root), entries) = try_collect_filtered_opts_collect(
         &root,
@@ -276,7 +284,7 @@ fn assume_unchanged_submodule_replaced_with_symlink_is_hidden() -> crate::Result
 
 #[test]
 #[cfg(unix)]
-fn submodule_replaced_with_symlink_without_assume_unchanged_is_untracked() -> crate::Result {
+fn submodule_replaced_with_symlink_without_assume_unchanged_is_untracked() -> Result {
     let root = fixture_in("many-symlinks", "submodule-symlink");
     let ((out, _root), entries) = try_collect_filtered_opts_collect(
         &root,
@@ -320,11 +328,11 @@ fn should_interrupt_works_even_in_empty_directories() {
         },
     )
     .unwrap_err();
-    assert!(matches!(err, gix_dir::walk::Error::Interrupted));
+    insta::assert_debug_snapshot!(err, "should interrupt works even in empty directories", @"Interrupted");
 }
 
 #[test]
-fn empty_root() -> crate::Result {
+fn empty_root() -> Result {
     let root = fixture("empty");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options(), keep));
     assert_eq!(
@@ -369,7 +377,7 @@ fn empty_root() -> crate::Result {
 }
 
 #[test]
-fn complex_empty() -> crate::Result {
+fn complex_empty() -> Result {
     let root = fixture("complex-empty");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -469,7 +477,7 @@ fn complex_empty() -> crate::Result {
 }
 
 #[test]
-fn ignored_with_prefix_pathspec_collapses_just_like_untracked() -> crate::Result {
+fn ignored_with_prefix_pathspec_collapses_just_like_untracked() -> Result {
     let root = fixture("untracked-and-ignored-for-collapse");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -543,7 +551,7 @@ fn ignored_with_prefix_pathspec_collapses_just_like_untracked() -> crate::Result
 }
 
 #[test]
-fn ignored_collapse_of_empty_directories_is_not_classified_as_empty_directory() -> crate::Result {
+fn ignored_collapse_of_empty_directories_is_not_classified_as_empty_directory() -> Result {
     let root = fixture("ignored-with-only-empty-dirs");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -580,7 +588,7 @@ fn ignored_collapse_of_empty_directories_is_not_classified_as_empty_directory()
 }
 
 #[test]
-fn ignored_dir_with_cwd_handling() -> crate::Result {
+fn ignored_dir_with_cwd_handling() -> Result {
     let root = fixture("untracked-and-ignored-for-collapse");
     let ((out, _root), entries) = collect_filtered_with_cwd(
         &root,
@@ -692,7 +700,7 @@ fn ignored_dir_with_cwd_handling() -> crate::Result {
 }
 
 #[test]
-fn ignored_with_cwd_handling() -> crate::Result {
+fn ignored_with_cwd_handling() -> Result {
     let root = gix_path::realpath(fixture("ignored-with-empty"))?;
     let ((out, _root), entries) = collect_filtered_with_cwd(
         &root,
@@ -772,7 +780,7 @@ fn ignored_with_cwd_handling() -> crate::Result {
 }
 
 #[test]
-fn only_untracked_with_cwd_handling() -> crate::Result {
+fn only_untracked_with_cwd_handling() -> Result {
     let root = fixture("only-untracked");
     let ((out, _root), entries) = collect_filtered_with_cwd(
         &root,
@@ -927,7 +935,7 @@ fn only_untracked_with_cwd_handling() -> crate::Result {
 }
 
 #[test]
-fn only_untracked_with_pathspec() -> crate::Result {
+fn only_untracked_with_pathspec() -> Result {
     let root = fixture("only-untracked");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -996,7 +1004,7 @@ fn only_untracked_with_pathspec() -> crate::Result {
 }
 
 #[test]
-fn only_untracked_with_prefix_deletion() -> crate::Result {
+fn only_untracked_with_prefix_deletion() -> Result {
     let root = fixture("only-untracked");
     let troot = root.join("d");
     let ((out, _root), entries) = collect(&root, Some(&troot), |keep, ctx| {
@@ -1054,7 +1062,7 @@ fn only_untracked_with_prefix_deletion() -> crate::Result {
 }
 
 #[test]
-fn only_untracked() -> crate::Result {
+fn only_untracked() -> Result {
     let root = fixture("only-untracked");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options(), keep));
     assert_eq!(
@@ -1129,7 +1137,7 @@ fn only_untracked() -> crate::Result {
 }
 
 #[test]
-fn only_untracked_explicit_pathspec_selection() -> crate::Result {
+fn only_untracked_explicit_pathspec_selection() -> Result {
     let root = fixture("only-untracked");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -1348,7 +1356,7 @@ fn expendable_and_precious() {
 }
 
 #[test]
-fn subdir_untracked() -> crate::Result {
+fn subdir_untracked() -> Result {
     let root = fixture("subdir-untracked");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options(), keep));
     assert_eq!(
@@ -1406,7 +1414,7 @@ fn subdir_untracked() -> crate::Result {
 }
 
 #[test]
-fn only_untracked_from_subdir() -> crate::Result {
+fn only_untracked_from_subdir() -> Result {
     let root = fixture("only-untracked");
     let troot = root.join("d").join("d");
     let ((out, _root), entries) = collect(&root, Some(&troot), |keep, ctx| walk(&root, ctx, options(), keep));
@@ -1427,7 +1435,7 @@ fn only_untracked_from_subdir() -> crate::Result {
 }
 
 #[test]
-fn untracked_and_ignored_pathspec_guidance() -> crate::Result {
+fn untracked_and_ignored_pathspec_guidance() -> Result {
     for for_deletion in [None, Some(Default::default())] {
         let root = fixture("subdir-untracked-and-ignored");
         let ((out, _root), entries) = collect_filtered(
@@ -1466,7 +1474,7 @@ fn untracked_and_ignored_pathspec_guidance() -> crate::Result {
 }
 
 #[test]
-fn untracked_and_ignored_for_deletion_negative_wildcard_spec() -> crate::Result {
+fn untracked_and_ignored_for_deletion_negative_wildcard_spec() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -1521,7 +1529,7 @@ fn untracked_and_ignored_for_deletion_negative_wildcard_spec() -> crate::Result
 }
 
 #[test]
-fn untracked_and_ignored_for_deletion_positive_wildcard_spec() -> crate::Result {
+fn untracked_and_ignored_for_deletion_positive_wildcard_spec() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -1574,7 +1582,7 @@ fn untracked_and_ignored_for_deletion_positive_wildcard_spec() -> crate::Result
 }
 
 #[test]
-fn untracked_and_ignored_for_deletion_nonmatching_wildcard_spec() -> crate::Result {
+fn untracked_and_ignored_for_deletion_nonmatching_wildcard_spec() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -1624,7 +1632,7 @@ fn untracked_and_ignored_for_deletion_nonmatching_wildcard_spec() -> crate::Resu
     Ok(())
 }
 #[test]
-fn nested_precious_repo_respects_wildcards() -> crate::Result {
+fn nested_precious_repo_respects_wildcards() -> Result {
     let root = fixture("precious-nested-repository");
     for for_deletion in [
         Some(ForDeletionMode::FindNonBareRepositoriesInIgnoredDirectories),
@@ -1657,7 +1665,7 @@ fn nested_precious_repo_respects_wildcards() -> crate::Result {
 }
 
 #[test]
-fn nested_ignored_dirs_for_deletion_nonmatching_wildcard_spec() -> crate::Result {
+fn nested_ignored_dirs_for_deletion_nonmatching_wildcard_spec() -> Result {
     let root = fixture("ignored-dir-nested-minimal");
     let (_out, entries) = collect_filtered(
         &root,
@@ -1724,7 +1732,7 @@ fn nested_ignored_dirs_for_deletion_nonmatching_wildcard_spec() -> crate::Result
 }
 
 #[test]
-fn expendable_and_precious_in_ignored_dir_with_pathspec() -> crate::Result {
+fn expendable_and_precious_in_ignored_dir_with_pathspec() -> Result {
     let root = fixture("expendable-and-precious-nested-in-ignored-dir");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -1872,7 +1880,7 @@ fn expendable_and_precious_in_ignored_dir_with_pathspec() -> crate::Result {
 }
 
 #[test]
-fn untracked_and_ignored() -> crate::Result {
+fn untracked_and_ignored() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -2066,7 +2074,7 @@ fn untracked_and_ignored() -> crate::Result {
 }
 
 #[test]
-fn untracked_and_ignored_collapse_handling_mixed() -> crate::Result {
+fn untracked_and_ignored_collapse_handling_mixed() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -2154,7 +2162,7 @@ fn untracked_and_ignored_collapse_handling_mixed() -> crate::Result {
 }
 
 #[test]
-fn untracked_and_ignored_collapse_handling_mixed_with_prefix() -> crate::Result {
+fn untracked_and_ignored_collapse_handling_mixed_with_prefix() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -2247,7 +2255,7 @@ fn untracked_and_ignored_collapse_handling_mixed_with_prefix() -> crate::Result
 }
 
 #[test]
-fn untracked_and_ignored_collapse_handling_for_deletion_with_wildcards() -> crate::Result {
+fn untracked_and_ignored_collapse_handling_for_deletion_with_wildcards() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -2350,7 +2358,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_with_wildcards() -> crat
 }
 
 #[test]
-fn untracked_and_ignored_collapse_handling_for_deletion_with_prefix_wildcards() -> crate::Result {
+fn untracked_and_ignored_collapse_handling_for_deletion_with_prefix_wildcards() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect_filtered(
         &root,
@@ -2387,7 +2395,7 @@ fn untracked_and_ignored_collapse_handling_for_deletion_with_prefix_wildcards()
 }
 
 #[test]
-fn untracked_and_ignored_collapse_handling_for_deletion_mixed() -> crate::Result {
+fn untracked_and_ignored_collapse_handling_for_deletion_mixed() -> Result {
     let root = fixture("subdir-untracked-and-ignored");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -2846,7 +2854,7 @@ fn precious_are_not_expendable() {
     not(target_vendor = "apple"),
     ignore = "Needs filesystem that folds unicode composition"
 )]
-fn decomposed_unicode_in_directory_is_returned_precomposed() -> crate::Result {
+fn decomposed_unicode_in_directory_is_returned_precomposed() -> Result {
     let root = gix_testtools::tempfile::TempDir::new()?;
 
     let decomposed = "a\u{308}";
@@ -2915,7 +2923,7 @@ fn decomposed_unicode_in_directory_is_returned_precomposed() -> crate::Result {
 }
 
 #[test]
-fn worktree_root_can_be_symlink() -> crate::Result {
+fn worktree_root_can_be_symlink() -> Result {
     let root = fixture_in("many-symlinks", "symlink-to-breakout-symlink");
     let troot = root.join("file");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -2943,7 +2951,7 @@ fn worktree_root_can_be_symlink() -> crate::Result {
 }
 
 #[test]
-fn root_may_not_go_through_dot_git() -> crate::Result {
+fn root_may_not_go_through_dot_git() -> Result {
     let root = fixture("with-nested-dot-git");
     for (dir, expected_pathspec) in [("", Some(Verbatim)), ("subdir", None)] {
         let troot = root.join("dir").join(".git").join(dir);
@@ -2972,7 +2980,7 @@ fn root_may_not_go_through_dot_git() -> crate::Result {
 }
 
 #[test]
-fn root_at_submodule_repository_allows_walk() -> crate::Result {
+fn root_at_submodule_repository_allows_walk() -> Result {
     let root = fixture("repo-with-submodule");
     let troot = root.join("submodule");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3013,7 +3021,7 @@ fn root_at_submodule_repository_allows_walk() -> crate::Result {
 }
 
 #[test]
-fn root_in_submodule_repository_allows_walk() -> crate::Result {
+fn root_in_submodule_repository_allows_walk() -> Result {
     let root = fixture("repo-with-submodule");
     let troot = root.join("submodule");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3054,7 +3062,7 @@ fn root_in_submodule_repository_allows_walk() -> crate::Result {
 }
 
 #[test]
-fn root_in_submodule_from_superproject_repository_allows_walk() -> crate::Result {
+fn root_in_submodule_from_superproject_repository_allows_walk() -> Result {
     let root = fixture("repo-with-submodule");
     let troot = root.join("submodule").join("dir");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3096,7 +3104,7 @@ fn root_in_submodule_from_superproject_repository_allows_walk() -> crate::Result
 }
 
 #[test]
-fn root_enters_directory_with_dot_git_in_reconfigured_worktree_tracked() -> crate::Result {
+fn root_enters_directory_with_dot_git_in_reconfigured_worktree_tracked() -> Result {
     let root = fixture("nonstandard-worktree");
     let troot = root.join("dir-with-dot-git").join("inside");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3166,7 +3174,7 @@ fn root_enters_directory_with_dot_git_in_reconfigured_worktree_tracked() -> crat
 }
 
 #[test]
-fn root_enters_directory_with_dot_git_in_reconfigured_worktree_untracked() -> crate::Result {
+fn root_enters_directory_with_dot_git_in_reconfigured_worktree_untracked() -> Result {
     let root = fixture("nonstandard-worktree-untracked");
     let troot = root.join("dir-with-dot-git").join("inside");
     let (_out, entries) = try_collect_filtered_opts_collect_with_root(
@@ -3187,7 +3195,7 @@ fn root_enters_directory_with_dot_git_in_reconfigured_worktree_untracked() -> cr
 }
 
 #[test]
-fn root_may_not_go_through_nested_repository_unless_enabled() -> crate::Result {
+fn root_may_not_go_through_nested_repository_unless_enabled() -> Result {
     let root = fixture("nested-repository");
     let troot = root.join("nested").join("file");
     let (_out, entries) = try_collect_filtered_opts_collect_with_root(
@@ -3239,7 +3247,7 @@ fn root_may_not_go_through_nested_repository_unless_enabled() -> crate::Result {
 }
 
 #[test]
-fn root_may_not_go_through_submodule() -> crate::Result {
+fn root_may_not_go_through_submodule() -> Result {
     let root = fixture("with-submodule");
     let troot = root.join("submodule").join("dir").join("file");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3268,7 +3276,7 @@ fn root_may_not_go_through_submodule() -> crate::Result {
 }
 
 #[test]
-fn walk_with_submodule() -> crate::Result {
+fn walk_with_submodule() -> Result {
     let root = fixture("with-submodule");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -3293,7 +3301,7 @@ fn walk_with_submodule() -> crate::Result {
 }
 
 #[test]
-fn root_that_is_tracked_file_is_returned() -> crate::Result {
+fn root_that_is_tracked_file_is_returned() -> Result {
     let root = fixture("dir-with-tracked-file");
     let troot = &root.join("dir").join("file");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3322,7 +3330,7 @@ fn root_that_is_tracked_file_is_returned() -> crate::Result {
 }
 
 #[test]
-fn root_that_is_untracked_file_is_returned() -> crate::Result {
+fn root_that_is_untracked_file_is_returned() -> Result {
     let root = fixture("dir-with-file");
     let troot = root.join("dir").join("file");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3354,11 +3362,12 @@ fn root_that_is_untracked_file_is_returned() -> crate::Result {
 fn top_level_root_that_is_a_file() {
     let root = fixture("just-a-file");
     let err = try_collect(&root, None, |keep, ctx| walk(&root, ctx, options(), keep)).unwrap_err();
-    assert!(matches!(err, walk::Error::WorktreeRootIsFile { .. }));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(root).to_string_lossy(), "<root>")]), "top level root that is a file", @"Worktree root at '<root>/' is not a directory");
+    assert!(err.is_validation());
 }
 
 #[test]
-fn root_can_be_pruned_early_with_pathspec() -> crate::Result {
+fn root_can_be_pruned_early_with_pathspec() -> Result {
     let root = fixture("dir-with-file");
     let troot = root.join("dir");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3387,7 +3396,7 @@ fn root_can_be_pruned_early_with_pathspec() -> crate::Result {
 }
 
 #[test]
-fn submodules() -> crate::Result {
+fn submodules() -> Result {
     let root = fixture("multiple-submodules");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -3452,7 +3461,7 @@ fn submodules() -> crate::Result {
 }
 
 #[test]
-fn cancel_with_collection_does_not_fail() -> crate::Result {
+fn cancel_with_collection_does_not_fail() -> Result {
     struct CancelDelegate {
         emits_left_until_cancel: usize,
     }
@@ -3516,7 +3525,7 @@ fn cancel_with_collection_does_not_fail() -> crate::Result {
 }
 
 #[test]
-fn file_root_is_shown_if_pathspec_matches_exactly() -> crate::Result {
+fn file_root_is_shown_if_pathspec_matches_exactly() -> Result {
     let root = fixture("dir-with-file");
     let troot = root.join("dir").join("file");
     let ((out, _root), entries) = try_collect_filtered_opts_collect_with_root(
@@ -3545,7 +3554,7 @@ fn file_root_is_shown_if_pathspec_matches_exactly() -> crate::Result {
 }
 
 #[test]
-fn root_that_is_tracked_and_ignored_is_considered_tracked() -> crate::Result {
+fn root_that_is_tracked_and_ignored_is_considered_tracked() -> Result {
     let root = fixture("tracked-is-ignored");
     let walk_root = "dir/file";
     let troot = root.join(walk_root);
@@ -3576,7 +3585,7 @@ fn root_that_is_tracked_and_ignored_is_considered_tracked() -> crate::Result {
 }
 
 #[test]
-fn root_with_dir_that_is_tracked_and_ignored() -> crate::Result {
+fn root_with_dir_that_is_tracked_and_ignored() -> Result {
     let root = fixture("tracked-is-ignored");
     for emission in [Matching, CollapseDirectory] {
         let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
@@ -3617,7 +3626,7 @@ fn root_with_dir_that_is_tracked_and_ignored() -> crate::Result {
 }
 
 #[test]
-fn empty_and_nested_untracked() -> crate::Result {
+fn empty_and_nested_untracked() -> Result {
     let root = fixture("empty-and-untracked-dir");
     for for_deletion in [None, Some(Default::default())] {
         let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
@@ -3685,7 +3694,7 @@ fn empty_and_nested_untracked() -> crate::Result {
 }
 
 #[test]
-fn root_that_is_ignored_is_listed_for_files_and_directories() -> crate::Result {
+fn root_that_is_ignored_is_listed_for_files_and_directories() -> Result {
     let root = fixture("ignored-dir");
     for walk_root in ["dir", "dir/file"] {
         let troot = root.join(walk_root);
@@ -3729,7 +3738,7 @@ fn root_that_is_ignored_is_listed_for_files_and_directories() -> crate::Result {
 }
 
 #[test]
-fn nested_bare_repos_in_ignored_directories() -> crate::Result {
+fn nested_bare_repos_in_ignored_directories() -> Result {
     let root = fixture("ignored-dir-with-nested-bare-repository");
     let (_out, entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -3809,7 +3818,7 @@ fn nested_bare_repos_in_ignored_directories() -> crate::Result {
 }
 
 #[test]
-fn nested_repos_in_untracked_directories() -> crate::Result {
+fn nested_repos_in_untracked_directories() -> Result {
     let root = fixture("untracked-hidden-bare");
     let (_out, entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -3856,7 +3865,7 @@ fn nested_repos_in_untracked_directories() -> crate::Result {
 }
 
 #[test]
-fn nested_repos_in_ignored_directories() -> crate::Result {
+fn nested_repos_in_ignored_directories() -> Result {
     let root = fixture("ignored-dir-with-nested-repository");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| {
         walk(
@@ -3962,7 +3971,7 @@ fn nested_repos_in_ignored_directories() -> crate::Result {
     not(target_vendor = "apple"),
     ignore = "Needs filesystem that folds unicode composition"
 )]
-fn decomposed_unicode_in_root_is_returned_precomposed() -> crate::Result {
+fn decomposed_unicode_in_root_is_returned_precomposed() -> Result {
     let root = gix_testtools::tempfile::TempDir::new()?;
 
     let decomposed = "a\u{308}";
@@ -4033,7 +4042,7 @@ fn decomposed_unicode_in_root_is_returned_precomposed() -> crate::Result {
 }
 
 #[test]
-fn precompose_unicode_preserves_noncanonical_combining_mark_order() -> crate::Result {
+fn precompose_unicode_preserves_noncanonical_combining_mark_order() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("noncanonical-combining-mark-order.sh")?.join("tracked");
 
     let ((_out, _root), entries) = collect(&root, None, |keep, ctx| {
@@ -4057,7 +4066,7 @@ fn precompose_unicode_preserves_noncanonical_combining_mark_order() -> crate::Re
 }
 
 #[test]
-fn precompose_unicode_preserves_untracked_noncanonical_combining_mark_order() -> crate::Result {
+fn precompose_unicode_preserves_untracked_noncanonical_combining_mark_order() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("noncanonical-combining-mark-order.sh")?.join("untracked");
 
     let ((_out, _root), entries) = collect(&root, None, |keep, ctx| {
@@ -4196,7 +4205,7 @@ fn untracked_and_ignored_collapse_mix() {
 }
 
 #[test]
-fn root_cannot_pass_through_case_altered_capital_dot_git_if_case_insensitive() -> crate::Result {
+fn root_cannot_pass_through_case_altered_capital_dot_git_if_case_insensitive() -> Result {
     let root = fixture("with-nested-capitalized-dot-git");
     for (dir, expected_pathspec) in [("", Some(Verbatim)), ("subdir", None)] {
         let troot = root.join("dir").join(".GIT").join(dir);
@@ -4259,7 +4268,7 @@ fn root_cannot_pass_through_case_altered_capital_dot_git_if_case_insensitive() -
 }
 
 #[test]
-fn partial_checkout_cone_and_non_one() -> crate::Result {
+fn partial_checkout_cone_and_non_one() -> Result {
     for fixture_name in ["partial-checkout-cone-mode", "partial-checkout-non-cone"] {
         let root = fixture(fixture_name);
         let not_in_cone_but_created_locally_by_hand = "d/file-created-manually";
@@ -4547,7 +4556,7 @@ fn type_mismatch_ignore_case_clash_file_is_dir() {
 }
 
 #[test]
-fn top_level_slash_with_negations() -> crate::Result {
+fn top_level_slash_with_negations() -> Result {
     for repo_name in ["slash-in-root-and-negated", "star-in-root-and-negated"] {
         let root = fixture(repo_name);
         let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
@@ -4604,7 +4613,7 @@ fn top_level_slash_with_negations() -> crate::Result {
 }
 
 #[test]
-fn subdir_slash_with_negations() -> crate::Result {
+fn subdir_slash_with_negations() -> Result {
     for repo_name in ["slash-in-subdir-and-negated", "star-in-subdir-and-negated"] {
         let root = fixture(repo_name);
         let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
@@ -4661,7 +4670,7 @@ fn subdir_slash_with_negations() -> crate::Result {
 }
 
 #[test]
-fn one_ignored_submodule() -> crate::Result {
+fn one_ignored_submodule() -> Result {
     let root = fixture("one-ignored-submodule");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -4705,7 +4714,7 @@ fn one_ignored_submodule() -> crate::Result {
 }
 
 #[test]
-fn ignored_sub_repo() -> crate::Result {
+fn ignored_sub_repo() -> Result {
     let root = fixture("with-sub-repo");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -4764,7 +4773,7 @@ fn ignored_sub_repo() -> crate::Result {
 }
 
 #[test]
-fn in_repo_worktree() -> crate::Result {
+fn in_repo_worktree() -> Result {
     let root = fixture("in-repo-worktree");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
@@ -4820,7 +4829,7 @@ fn in_repo_worktree() -> crate::Result {
 }
 
 #[test]
-fn in_repo_hidden_worktree() -> crate::Result {
+fn in_repo_hidden_worktree() -> Result {
     let root = fixture("in-repo-hidden-worktree");
     let ((out, _root), entries) = collect(&root, None, |keep, ctx| walk(&root, ctx, options_emit_all(), keep));
     assert_eq!(
diff --git a/gix-dir/tests/walk_utils/mod.rs b/gix-dir/tests/walk_utils/mod.rs
index 0abee1d026e..3567e6ee300 100644
--- a/gix-dir/tests/walk_utils/mod.rs
+++ b/gix-dir/tests/walk_utils/mod.rs
@@ -3,6 +3,8 @@ use std::{
     sync::atomic::AtomicBool,
 };
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 use gix_dir::{Entry, entry, walk};
 use gix_testtools::scripted_fixture_read_only;
@@ -183,7 +185,7 @@ impl EntryExt for (Entry, Option<entry::Status>) {
 pub fn collect(
     worktree_root: &Path,
     root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
 ) -> ((walk::Outcome, PathBuf), Entries) {
     try_collect(worktree_root, root, cb).unwrap()
 }
@@ -191,7 +193,7 @@ pub fn collect(
 pub fn collect_filtered(
     worktree_root: &Path,
     root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
 ) -> ((walk::Outcome, PathBuf), Entries) {
     try_collect_filtered(worktree_root, root, cb, patterns).unwrap()
@@ -200,27 +202,27 @@ pub fn collect_filtered(
 pub fn try_collect(
     worktree_root: &Path,
     root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
-) -> Result<((walk::Outcome, PathBuf), Entries), walk::Error> {
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
+) -> Result<((walk::Outcome, PathBuf), Entries), gix_error::Error> {
     try_collect_filtered(worktree_root, root, cb, None::<&str>)
 }
 
 pub fn try_collect_filtered(
     worktree_root: &Path,
     root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
-) -> Result<((walk::Outcome, PathBuf), Entries), walk::Error> {
+) -> Result<((walk::Outcome, PathBuf), Entries), gix_error::Error> {
     try_collect_filtered_opts_collect(worktree_root, root, cb, patterns, Default::default())
 }
 
 pub fn try_collect_filtered_opts_collect(
     worktree_root: &Path,
     root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
     options: Options<'_>,
-) -> Result<((walk::Outcome, PathBuf), Entries), walk::Error> {
+) -> Result<((walk::Outcome, PathBuf), Entries), gix_error::Error> {
     let mut dlg = gix_dir::walk::delegate::Collect::default();
     let outcome = try_collect_filtered_opts(worktree_root, root, None, None, cb, patterns, &mut dlg, options)?;
     Ok((outcome, dlg.into_entries_by_path()))
@@ -230,10 +232,10 @@ pub fn try_collect_filtered_opts_collect_with_root(
     worktree_root: &Path,
     root: Option<&Path>,
     explicit_traversal_root: Option<&Path>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
     options: Options<'_>,
-) -> Result<((walk::Outcome, PathBuf), Entries), walk::Error> {
+) -> Result<((walk::Outcome, PathBuf), Entries), gix_error::Error> {
     let mut dlg = gix_dir::walk::delegate::Collect::default();
     let outcome = try_collect_filtered_opts(
         worktree_root,
@@ -252,7 +254,7 @@ pub fn collect_filtered_with_cwd(
     worktree_root: &Path,
     root: Option<&Path>,
     cwd_suffix: Option<&str>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
 ) -> ((walk::Outcome, PathBuf), Entries) {
     let mut dlg = gix_dir::walk::delegate::Collect::default();
@@ -276,7 +278,7 @@ pub fn try_collect_filtered_opts(
     root: Option<&Path>,
     explicit_traversal_root: Option<&Path>,
     append_to_cwd: Option<&str>,
-    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> Result<(walk::Outcome, PathBuf), walk::Error>,
+    cb: impl FnOnce(&mut dyn walk::Delegate, walk::Context) -> ExnResult<(walk::Outcome, PathBuf)>,
     patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
     delegate: &mut dyn gix_dir::walk::Delegate,
     Options {
@@ -284,7 +286,7 @@ pub fn try_collect_filtered_opts(
         git_dir,
         should_interrupt,
     }: Options<'_>,
-) -> Result<(walk::Outcome, PathBuf), walk::Error> {
+) -> Result<(walk::Outcome, PathBuf), gix_error::Error> {
     let git_dir = worktree_root.join(git_dir.unwrap_or(".git"));
     let mut index = std::fs::read(git_dir.join("index")).ok().map_or_else(
         || gix_index::State::new(gix_testtools::object_hash()),
@@ -361,6 +363,7 @@ pub fn try_collect_filtered_opts(
             should_interrupt,
         },
     )
+    .map_err(Into::into)
 }
 
 pub struct Options<'a> {
diff --git a/gix-discover/Cargo.toml b/gix-discover/Cargo.toml
index 77ea827d23d..0b2db5ff1c1 100644
--- a/gix-discover/Cargo.toml
+++ b/gix-discover/Cargo.toml
@@ -25,15 +25,16 @@ gix-sec = { version = "^0.14.2", path = "../gix-sec" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-ref = { version = "^0.67.0", path = "../gix-ref" }
 gix-fs = { version = "^0.22.1", path = "../gix-fs" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
 bstr = { version = "1.12.0", default-features = false, features = ["std", "unicode"] }
-thiserror = "2.0.18"
 
 [target.'cfg(windows)'.dependencies]
 dunce = "1.0.3"
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools" }
+insta = "1.46.3"
+gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 serial_test = { version = "3.4.0", default-features = false }
 is_ci = "1.1.1"
 
diff --git a/gix-discover/src/is.rs b/gix-discover/src/is.rs
index b9d3eaf5280..7739161106f 100644
--- a/gix-discover/src/is.rs
+++ b/gix-discover/src/is.rs
@@ -1,5 +1,7 @@
 use std::{borrow::Cow, ffi::OsStr, path::Path};
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, corruption, message, not_found};
+
 use crate::DOT_GIT_DIR;
 use crate::path::RepositoryKind;
 
@@ -28,13 +30,13 @@ pub fn submodule_git_dir(git_dir: &Path) -> bool {
 ///   * …a refs directory
 ///
 /// This obtains filesystem metadata for `git_dir` before checking its repository layout.
-pub fn git(git_dir: &Path) -> Result<crate::repository::Kind, crate::is_git::Error> {
-    let git_dir_metadata = git_dir.metadata().map_err(|err| crate::is_git::Error::Metadata {
-        source: err,
-        path: git_dir.into(),
-    })?;
+pub fn git(git_dir: &Path) -> ExnResult<crate::repository::Kind> {
+    let git_dir_metadata = git_dir
+        .metadata()
+        .or_raise_erased(|| gix_error::message!("Could not retrieve metadata of \"{}\"", git_dir.display()))?;
     // precompose-unicode can't be known here, so we just default it to false, hoping it won't matter.
-    let cwd = gix_fs::current_dir(false)?;
+    let cwd = gix_fs::current_dir(false)
+        .or_raise_erased(|| message("Could not obtain current directory for resolving the '.' repository path"))?;
     git_with_metadata(git_dir, &git_dir_metadata, &cwd)
 }
 
@@ -42,7 +44,7 @@ pub(crate) fn git_with_metadata(
     git_dir: &Path,
     git_dir_metadata: &std::fs::Metadata,
     cwd: &Path,
-) -> Result<crate::repository::Kind, crate::is_git::Error> {
+) -> ExnResult<crate::repository::Kind> {
     #[derive(Eq, PartialEq)]
     enum Kind {
         MaybeRepo,
@@ -52,7 +54,7 @@ pub(crate) fn git_with_metadata(
     }
 
     let dot_git = if git_dir_metadata.is_file() {
-        let private_git_dir = crate::path::from_gitdir_file(git_dir)?;
+        let private_git_dir = crate::path::from_gitdir_file(git_dir).or_erased()?;
         Cow::Owned(private_git_dir)
     } else {
         Cow::Borrowed(git_dir)
@@ -61,7 +63,7 @@ pub(crate) fn git_with_metadata(
     {
         // Fast-path: avoid doing the complete search if HEAD is already not there.
         if !dot_git.join("HEAD").exists() {
-            return Err(crate::is_git::Error::MissingHead);
+            return Err(not_found("Missing HEAD at '.git/HEAD'").raise_erased());
         }
         // We expect to be able to parse any ref-hash, so we shouldn't have to know the repos hash here.
         // With ref-table, the hash is probably stored as part of the ref-db itself, so we can handle it from there.
@@ -70,19 +72,20 @@ pub(crate) fn git_with_metadata(
         match refs.find_loose("HEAD") {
             Ok(head) => {
                 if head.name.as_bstr() != "HEAD" {
-                    return Err(crate::is_git::Error::MisplacedHead {
-                        name: head.name.into_inner(),
-                    });
+                    return Err(
+                        corruption(format!("Expected HEAD at '.git/HEAD', got '.git/{}'", head.name)).raise_erased(),
+                    );
                 }
             }
-            Err(gix_ref::file::find::existing::Error::Find(gix_ref::file::find::Error::ReferenceCreation {
-                source: _,
-                relative_path,
-            })) if relative_path == Path::new("HEAD") => {
+            Err(err)
+                if err
+                    .downcast_any_ref::<gix_ref::file::find::ReferenceDecode>()
+                    .is_some_and(|err| err.relative_path == Path::new("HEAD")) =>
+            {
                 // It's fine as long as the reference is found is `HEAD`.
             }
             Err(err) => {
-                return Err(err.into());
+                return Err(err.raise(message("Could not find a valid HEAD reference")).erased());
             }
         }
     }
@@ -91,10 +94,12 @@ pub(crate) fn git_with_metadata(
         let common_dir = dot_git.join("commondir");
         match crate::path::from_plain_file(&common_dir) {
             Some(Err(err)) => {
-                return Err(crate::is_git::Error::MissingCommonDir {
-                    missing: common_dir,
-                    source: err,
-                });
+                return Err(err
+                    .and_raise(gix_error::message!(
+                        "The worktree's private repo's commondir file at '{}' is missing or could not be read",
+                        common_dir.display()
+                    ))
+                    .erased());
             }
             Some(Ok(common_dir)) => {
                 let common_dir = dot_git.join(common_dir);
@@ -123,13 +128,15 @@ pub(crate) fn git_with_metadata(
     {
         let objects_path = common_dir.join("objects");
         if !objects_path.is_dir() {
-            return Err(crate::is_git::Error::MissingObjectsDirectory { missing: objects_path });
+            return Err(
+                not_found(format!("Expected an objects directory at '{}'", objects_path.display())).raise_erased(),
+            );
         }
     }
     {
         let refs_path = common_dir.join("refs");
         if !refs_path.is_dir() {
-            return Err(crate::is_git::Error::MissingRefsDirectory { missing: refs_path });
+            return Err(not_found(format!("Expected a refs directory at '{}'", refs_path.display())).raise_erased());
         }
     }
     Ok(match kind {
diff --git a/gix-discover/src/lib.rs b/gix-discover/src/lib.rs
index bc64e8da35a..bf1d19acea1 100644
--- a/gix-discover/src/lib.rs
+++ b/gix-discover/src/lib.rs
@@ -17,7 +17,8 @@
 //! # )?;
 //! # let nested = dir.path().join("src").join("module");
 //! # std::fs::create_dir_all(&nested)?;
-//! let (path, _trust) = gix_discover::upwards(&nested)?;
+//! let (path, _trust) =
+//!     gix_discover::upwards(&nested).map_err(gix_error::Exn::into_error)?;
 //! let (repository_dir, worktree_dir) = path.into_repository_and_work_tree_directories();
 //!
 //! assert_eq!(repository_dir, git_dir);
@@ -37,39 +38,6 @@ pub const MODULES: &str = "modules";
 ///
 pub mod repository;
 
-///
-pub mod is_git {
-    use std::path::PathBuf;
-
-    /// The error returned by [`crate::is_git()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not find a valid HEAD reference")]
-        FindHeadRef(#[from] gix_ref::file::find::existing::Error),
-        #[error("Missing HEAD at '.git/HEAD'")]
-        MissingHead,
-        #[error("Expected HEAD at '.git/HEAD', got '.git/{}'", .name)]
-        MisplacedHead { name: bstr::BString },
-        #[error("Expected an objects directory at '{}'", .missing.display())]
-        MissingObjectsDirectory { missing: PathBuf },
-        #[error("The worktree's private repo's commondir file at '{}' or it could not be read", .missing.display())]
-        MissingCommonDir { missing: PathBuf, source: std::io::Error },
-        #[error("Expected a refs directory at '{}'", .missing.display())]
-        MissingRefsDirectory { missing: PathBuf },
-        #[error(transparent)]
-        GitFile(#[from] crate::path::from_gitdir_file::Error),
-        #[error("Could not retrieve metadata of \"{path}\"")]
-        Metadata { source: std::io::Error, path: PathBuf },
-        #[error(
-            "The repository's config file doesn't exist or didn't have a 'bare' configuration or contained core.worktree without value"
-        )]
-        Inconclusive,
-        #[error("Could not obtain current directory for resolving the '.' repository path")]
-        CurrentDir(#[from] std::io::Error),
-    }
-}
-
 mod is;
 #[expect(
     deprecated,
diff --git a/gix-discover/src/parse.rs b/gix-discover/src/parse.rs
index 38c6fd4b17d..6b5ba293789 100644
--- a/gix-discover/src/parse.rs
+++ b/gix-discover/src/parse.rs
@@ -1,33 +1,22 @@
 use std::path::PathBuf;
 
 use bstr::ByteSlice;
-
-///
-pub mod gitdir {
-    use bstr::BString;
-
-    /// The error returned by [`parse::gitdir()`][super::gitdir()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Format should be 'gitdir: <path>', but got: {:?}", .input)]
-        InvalidFormat { input: BString },
-        #[error("Couldn't decode {:?} as UTF8", .input)]
-        IllformedUtf8 { input: BString },
-    }
-}
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt};
 
 /// Parse typical `gitdir` files as seen in worktrees and submodules.
-pub fn gitdir(input: &[u8]) -> Result<PathBuf, gitdir::Error> {
+/// Errors include the original `input` bytes as [metadata](gix_error::Exn::metadata()).
+pub fn gitdir(input: &[u8]) -> ExnMessageResult<PathBuf> {
     let path = input
         .strip_prefix(b"gitdir: ")
-        .ok_or_else(|| gitdir::Error::InvalidFormat { input: input.into() })?
+        .ok_or_else(|| gix_error::validation("Format should be 'gitdir: <path>', but got").with("input", input))?
         .as_bstr();
     let path = path.trim_end().as_bstr();
     if path.is_empty() {
-        return Err(gitdir::Error::InvalidFormat { input: input.into() });
+        return Err(gix_error::validation("Format should be 'gitdir: <path>', but got")
+            .with("input", input)
+            .raise());
     }
     Ok(gix_path::try_from_bstr(path)
-        .map_err(|_| gitdir::Error::IllformedUtf8 { input: input.into() })?
+        .or_raise(|| gix_error::validation("Couldn't decode input as UTF8").with("input", input))?
         .into_owned())
 }
diff --git a/gix-discover/src/path.rs b/gix-discover/src/path.rs
index 76e5c75cb19..1bc2f4f14cb 100644
--- a/gix-discover/src/path.rs
+++ b/gix-discover/src/path.rs
@@ -1,4 +1,6 @@
 use crate::{DOT_GIT_DIR, MODULES};
+use gix_error::ExnResult;
+use gix_error::ResultExt;
 use std::ffi::OsStr;
 use std::path::Path;
 use std::{io::Read, path::PathBuf};
@@ -14,19 +16,6 @@ pub enum RepositoryKind {
     Common,
 }
 
-///
-pub mod from_gitdir_file {
-    /// The error returned by [`from_gitdir_file()`][crate::path::from_gitdir_file()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        Parse(#[from] crate::parse::gitdir::Error),
-    }
-}
-
 fn read_regular_file_content_with_size_limit(path: &std::path::Path) -> std::io::Result<Vec<u8>> {
     let mut file = std::fs::File::open(path)?;
     let max_file_size = 1024 * 64; // NOTE: git allows 1MB here
@@ -131,9 +120,9 @@ pub fn from_plain_file_relative_to_file(path: &std::path::Path) -> Option<std::i
 }
 
 /// Reads typical `gitdir: ` files from disk as used by worktrees and submodules.
-pub fn from_gitdir_file(path: &std::path::Path) -> Result<PathBuf, from_gitdir_file::Error> {
-    let buf = read_regular_file_content_with_size_limit(path)?;
-    let mut gitdir = crate::parse::gitdir(&buf)?;
+pub fn from_gitdir_file(path: &std::path::Path) -> ExnResult<PathBuf> {
+    let buf = read_regular_file_content_with_size_limit(path).or_erased()?;
+    let mut gitdir = crate::parse::gitdir(&buf).or_erased()?;
     if let Some(parent) = path.parent() {
         gitdir = parent.join(gitdir);
     }
diff --git a/gix-discover/src/upwards/mod.rs b/gix-discover/src/upwards/mod.rs
index bc2a37a8313..33eb2d57c04 100644
--- a/gix-discover/src/upwards/mod.rs
+++ b/gix-discover/src/upwards/mod.rs
@@ -1,5 +1,5 @@
 mod types;
-pub use types::{Error, Options, TrustPolicy};
+pub use types::{Options, TrustPolicy};
 
 mod util;
 
@@ -11,9 +11,10 @@ pub(crate) mod function {
         path::{Path, PathBuf},
     };
 
+    use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, message, not_found, validation};
     use gix_sec::Trust;
 
-    use super::{Error, Options, TrustPolicy};
+    use super::{Options, TrustPolicy};
     #[cfg(unix)]
     use crate::upwards::util::device_id;
     use crate::{
@@ -83,15 +84,19 @@ pub(crate) mod function {
             self.physical_parent_steps.is_some()
         }
 
-        pub fn metadata(&mut self) -> Result<&std::fs::Metadata, Error> {
+        pub fn metadata(&mut self) -> ExnResult<&std::fs::Metadata> {
             if self.current_metadata.is_none() {
                 let path = if self.current.as_os_str().is_empty() {
                     Path::new(".")
                 } else {
                     self.current.as_ref()
                 };
-                self.current_metadata = Some(path.metadata().map_err(|_| Error::InaccessibleDirectory {
-                    path: self.current.clone(),
+                let inaccessible_path = self.current.clone();
+                self.current_metadata = Some(path.metadata().or_raise_erased(|| {
+                    gix_error::message!(
+                        "Failed to access a directory, or path is not a directory: '{}'",
+                        inaccessible_path.display()
+                    )
                 })?);
             }
             Ok(self
@@ -207,25 +212,30 @@ pub(crate) mod function {
             current_dir,
             dot_git_only,
         }: Options<'_>,
-    ) -> Result<(crate::repository::Path, gix_sec::Trust), Error> {
+    ) -> ExnResult<(crate::repository::Path, gix_sec::Trust)> {
         // Normalize the path so that `Path::parent()` _actually_ gives
         // us the parent directory. (`Path::parent` just strips off the last
         // path component, which means it will not do what you expect when
         // working with paths that contain '..'.)
-        let cwd = current_dir.map_or_else(
-            || {
-                // The paths we return are relevant to the repository, but at this time it's impossible to know
-                // what `core.precomposeUnicode` is going to be. Hence, the one using these paths will have to
-                // transform the paths as needed, because we can't. `false` means to leave the obtained path as is.
-                gix_fs::current_dir(false).map(Cow::Owned)
-            },
-            |cwd| Ok(Cow::Borrowed(cwd)),
-        )?;
+        let cwd = current_dir
+            .map_or_else(
+                || {
+                    // The paths we return are relevant to the repository, but at this time it's impossible to know
+                    // what `core.precomposeUnicode` is going to be. Hence, the one using these paths will have to
+                    // transform the paths as needed, because we can't. `false` means to leave the obtained path as is.
+                    gix_fs::current_dir(false).map(Cow::Owned)
+                },
+                |cwd| Ok(Cow::Borrowed(cwd)),
+            )
+            .or_raise_erased(|| message("Could not obtain the current working directory"))?;
         #[cfg(windows)]
         let directory = dunce::simplified(directory);
         let logical = gix_path::normalize(directory.into(), cwd.as_ref())
-            .ok_or_else(|| Error::InvalidInput {
-                directory: directory.into(),
+            .ok_or_raise_erased(|| {
+                validation(format!(
+                    "Relative path \"{}\" tries to reach beyond root filesystem",
+                    directory.display()
+                ))
             })?
             .into_owned();
         let directory_to_access = if directory.is_absolute() {
@@ -233,22 +243,30 @@ pub(crate) mod function {
         } else {
             Cow::Owned(cwd.join(directory))
         };
-        let dir_metadata = directory_to_access
-            .metadata()
-            .map_err(|_| Error::InaccessibleDirectory { path: logical.clone() })?;
+        let dir_metadata = directory_to_access.metadata().or_raise_erased(|| {
+            gix_error::message!(
+                "Failed to access a directory, or path is not a directory: '{}'",
+                logical.display()
+            )
+        })?;
 
         if !dir_metadata.is_dir() {
-            return Err(Error::InaccessibleDirectory { path: logical });
+            return Err(validation(format!(
+                "Failed to access a directory, or path is not a directory: '{}'",
+                logical.display()
+            ))
+            .raise_erased());
         }
         #[cfg(unix)]
         let initial_device = device_id(&dir_metadata);
         let resolved = OnceCell::<Option<PathBuf>>::new();
         let resolved = || resolved.get_or_init(|| resolved_directory_for_parent_traversal(directory, cwd.as_ref()));
-        let filter_by_trust = |dir: &Path| -> Result<Result<Trust, Trust>, Error> {
+        let filter_by_trust = |dir: &Path| -> ExnResult<Result<Trust, Trust>> {
             match trust {
                 TrustPolicy::Required(required) => {
-                    let trust =
-                        Trust::from_path_ownership(dir).map_err(|err| Error::CheckTrust { path: dir.into(), err })?;
+                    let trust = Trust::from_path_ownership(dir).or_raise_erased(|| {
+                        gix_error::message!("Could not determine trust level for path '{}'.", dir.display())
+                    })?;
                     Ok(if trust >= required { Ok(trust) } else { Err(required) })
                 }
                 TrustPolicy::Assume(trust) => Ok(Ok(trust)),
@@ -272,7 +290,10 @@ pub(crate) mod function {
                 cwd.as_ref(),
             );
             if max_height.is_none() && match_ceiling_dir_or_error {
-                return Err(Error::NoMatchingCeilingDir);
+                return Err(validation(
+                    "None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.",
+                )
+                .raise_erased());
             }
             max_height
         } else {
@@ -282,28 +303,32 @@ pub(crate) mod function {
         let mut height = 0;
         'outer: loop {
             if max_height.is_some_and(|max| height > max) {
-                return Err(Error::NoGitRepositoryWithinCeiling {
-                    path: search.logical,
-                    ceiling_height: height,
-                });
+                return Err(not_found(format!(
+                    "Could not find a git repository in '{}' or in any of its parents within ceiling height of {height}",
+                    search.logical.display()
+                ))
+                .raise_erased());
             }
 
             #[cfg(unix)]
             if !cross_fs && device_id(search.metadata()?) != initial_device {
-                return Err(Error::NoGitRepositoryWithinFs {
-                    path: search.logical,
-                    limit: search.current,
-                });
+                return Err(not_found(format!(
+                    "Could not find a git repository in '{}' or in any of its parents within device limits below '{}'",
+                    search.logical.display(),
+                    search.current.display()
+                ))
+                .raise_erased());
             }
 
             if let Some((kind, appended_dot_git)) = search.probe_repository(cwd.as_ref(), dot_git_only) {
                 match filter_by_trust(&search.current)? {
-                    Err(required) => {
-                        break 'outer Err(Error::NoTrustedGitRepository {
-                            path: search.logical,
-                            candidate: search.current,
-                            required,
-                        });
+                    Err(_) => {
+                        break 'outer Err(not_found(format!(
+                            "Could not find a trusted git repository in '{}' or in any of its parents, candidate at '{}' discarded",
+                            search.logical.display(),
+                            search.current.display()
+                        ))
+                        .raise_erased());
                     }
                     Ok(trust) => {
                         let cursor = search.into_candidate(cwd.as_ref(), appended_dot_git);
@@ -315,11 +340,14 @@ pub(crate) mod function {
                             cursor
                         };
                         break 'outer Ok((
-                            crate::repository::Path::from_dot_git_dir(path, kind, cwd.as_ref()).ok_or_else(|| {
-                                Error::InvalidInput {
-                                    directory: directory.into(),
-                                }
-                            })?,
+                            crate::repository::Path::from_dot_git_dir(path, kind, cwd.as_ref()).ok_or_raise_erased(
+                                || {
+                                    validation(format!(
+                                        "Relative path \"{}\" tries to reach beyond root filesystem",
+                                        directory.display()
+                                    ))
+                                },
+                            )?,
                             trust,
                         ));
                     }
@@ -338,15 +366,22 @@ pub(crate) mod function {
                     search.current.components().next(),
                     Some(std::path::Component::RootDir | std::path::Component::Prefix(_))
                 ) {
-                    break Err(Error::NoGitRepository { path: search.logical });
+                    break Err(not_found(format!(
+                        "Could not find a git repository in '{}' or in any of its parents",
+                        search.logical.display()
+                    ))
+                    .raise_erased());
                 } else {
                     debug_assert!(
                         !search.current.as_os_str().is_empty(),
                         "only a non-empty relative cursor can require normalization after ascent stalls"
                     );
                     let current = gix_path::normalize(search.current.clone().into(), cwd.as_ref())
-                        .ok_or_else(|| Error::InvalidInput {
-                            directory: search.current.clone(),
+                        .ok_or_raise_erased(|| {
+                            validation(format!(
+                                "Relative path \"{}\" tries to reach beyond root filesystem",
+                                search.current.display()
+                            ))
                         })?
                         .into_owned();
                     search.set_current(current);
@@ -360,7 +395,7 @@ pub(crate) mod function {
     /// the trust level derived from Path ownership.
     ///
     /// Fail if no valid-looking git repository could be found.
-    pub fn discover(directory: &Path) -> Result<(crate::repository::Path, gix_sec::Trust), Error> {
+    pub fn discover(directory: &Path) -> ExnResult<(crate::repository::Path, gix_sec::Trust)> {
         discover_opts(directory, Default::default())
     }
 }
diff --git a/gix-discover/src/upwards/types.rs b/gix-discover/src/upwards/types.rs
index d4754292aad..15fa10c6128 100644
--- a/gix-discover/src/upwards/types.rs
+++ b/gix-discover/src/upwards/types.rs
@@ -1,37 +1,5 @@
 use std::{env, ffi::OsStr, path::PathBuf};
 
-/// The error returned by [`gix_discover::upwards()`][crate::upwards()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not obtain the current working directory")]
-    CurrentDir(#[from] std::io::Error),
-    #[error("Relative path \"{}\"tries to reach beyond root filesystem", directory.display())]
-    InvalidInput { directory: PathBuf },
-    #[error("Failed to access a directory, or path is not a directory: '{}'", .path.display())]
-    InaccessibleDirectory { path: PathBuf },
-    #[error("Could not find a git repository in '{}' or in any of its parents", .path.display())]
-    NoGitRepository { path: PathBuf },
-    #[error("Could not find a git repository in '{}' or in any of its parents within ceiling height of {}", .path.display(), .ceiling_height)]
-    NoGitRepositoryWithinCeiling { path: PathBuf, ceiling_height: usize },
-    #[error("Could not find a git repository in '{}' or in any of its parents within device limits below '{}'", .path.display(), .limit.display())]
-    NoGitRepositoryWithinFs { path: PathBuf, limit: PathBuf },
-    #[error("None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.")]
-    NoMatchingCeilingDir,
-    #[error("Could not find a trusted git repository in '{}' or in any of its parents, candidate at '{}' discarded", .path.display(), .candidate.display())]
-    NoTrustedGitRepository {
-        path: PathBuf,
-        candidate: PathBuf,
-        required: gix_sec::Trust,
-    },
-    #[error("Could not determine trust level for path '{}'.", .path.display())]
-    CheckTrust {
-        path: PathBuf,
-        #[source]
-        err: std::io::Error,
-    },
-}
-
 /// How to obtain the trust level for a discovered repository.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum TrustPolicy {
diff --git a/gix-discover/tests/discover/is_git.rs b/gix-discover/tests/discover/is_git.rs
index 52b9ba735bb..06a1320f6b7 100644
--- a/gix-discover/tests/discover/is_git.rs
+++ b/gix-discover/tests/discover/is_git.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use crate::upwards::repo_path;
 
 #[cfg(target_os = "macos")]
 #[test]
-fn verify_on_exfat() -> crate::Result<()> {
+fn verify_on_exfat() -> Result<()> {
     use std::process::Command;
 
     use gix_discover::repository::Kind;
@@ -41,7 +42,7 @@ fn verify_on_exfat() -> crate::Result<()> {
 }
 
 #[test]
-fn missing_configuration_file_is_not_a_dealbreaker_in_bare_repo() -> crate::Result {
+fn missing_configuration_file_is_not_a_dealbreaker_in_bare_repo() -> Result {
     for name in ["bare-no-config-after-init.git", "bare-no-config.git"] {
         let repo = repo_path()?.join(name);
         let kind = gix_discover::is_git(&repo)?;
@@ -51,7 +52,7 @@ fn missing_configuration_file_is_not_a_dealbreaker_in_bare_repo() -> crate::Resu
 }
 
 #[test]
-fn bare_repo_with_index_file_looks_still_looks_like_bare() -> crate::Result {
+fn bare_repo_with_index_file_looks_still_looks_like_bare() -> Result {
     let repo = repo_path()?.join("bare-with-index.git");
     let kind = gix_discover::is_git(&repo)?;
     assert_eq!(kind, gix_discover::repository::Kind::PossiblyBare);
@@ -59,7 +60,7 @@ fn bare_repo_with_index_file_looks_still_looks_like_bare() -> crate::Result {
 }
 
 #[test]
-fn non_bare_repo_without_workdir() -> crate::Result {
+fn non_bare_repo_without_workdir() -> Result {
     let repo = repo_path()?.join("non-bare-without-worktree");
     let kind = gix_discover::is_git(&repo)?;
     assert_eq!(
@@ -71,7 +72,7 @@ fn non_bare_repo_without_workdir() -> crate::Result {
 }
 
 #[test]
-fn non_bare_repo_without_workdir_with_index() -> crate::Result {
+fn non_bare_repo_without_workdir_with_index() -> Result {
     let repo = repo_path()?.join("non-bare-without-worktree-with-index");
     let kind = gix_discover::is_git(&repo)?;
     assert_eq!(
@@ -83,7 +84,7 @@ fn non_bare_repo_without_workdir_with_index() -> crate::Result {
 }
 
 #[test]
-fn bare_repo_with_index_file_looks_still_looks_like_bare_if_it_was_renamed() -> crate::Result {
+fn bare_repo_with_index_file_looks_still_looks_like_bare_if_it_was_renamed() -> Result {
     for repo_name in ["bare-with-index-bare", "bare-with-index-no-config-bare"] {
         let repo = repo_path()?.join(repo_name);
         let kind = gix_discover::is_git(&repo)?;
@@ -93,7 +94,7 @@ fn bare_repo_with_index_file_looks_still_looks_like_bare_if_it_was_renamed() ->
 }
 
 #[test]
-fn no_bare_repo_without_index_file_looks_like_worktree() -> crate::Result {
+fn no_bare_repo_without_index_file_looks_like_worktree() -> Result {
     let repo = repo_path()?.join("non-bare-without-index").join(".git");
     let kind = gix_discover::is_git(&repo)?;
     assert_eq!(kind, gix_discover::repository::Kind::WorkTree { linked_git_dir: None });
@@ -101,19 +102,19 @@ fn no_bare_repo_without_index_file_looks_like_worktree() -> crate::Result {
 }
 
 #[test]
-fn non_bare_repo_with_git_extension_is_not_a_worktree() -> crate::Result {
+fn non_bare_repo_with_git_extension_is_not_a_worktree() -> Result {
     let worktree = repo_path()?.join("repo.git");
     let err = gix_discover::is_git(&worktree).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "Missing HEAD at '.git/HEAD'",
-        "repo.git isn't a .git directory after all"
+    insta::assert_debug_snapshot!(err, "repo.git isn't a .git directory after all", @"Missing HEAD at '.git/HEAD'");
+    assert!(
+        err.is_not_found(),
+        "a missing repository marker is classified as not found"
     );
     Ok(())
 }
 
 #[test]
-fn missing_configuration_file_is_not_a_dealbreaker_in_nonbare_repo() -> crate::Result {
+fn missing_configuration_file_is_not_a_dealbreaker_in_nonbare_repo() -> Result {
     for name in ["worktree-no-config-after-init/.git", "worktree-no-config/.git"] {
         let repo = repo_path()?.join(name);
         let kind = gix_discover::is_git(&repo)?;
@@ -123,7 +124,7 @@ fn missing_configuration_file_is_not_a_dealbreaker_in_nonbare_repo() -> crate::R
 }
 
 #[test]
-fn split_worktree_using_configuration() -> crate::Result {
+fn split_worktree_using_configuration() -> Result {
     for name in [
         "repo-with-worktree-in-config",
         "repo-with-worktree-in-config-unborn",
@@ -144,7 +145,7 @@ fn split_worktree_using_configuration() -> crate::Result {
 }
 
 #[test]
-fn reftable() -> crate::Result {
+fn reftable() -> Result {
     let Some(root) = gix_testtools::scripted_fixture_read_only_with_git_version("make_reftable_repo.sh", |version| {
         version >= (2, 44, 0)
     })?
diff --git a/gix-discover/tests/discover/parse.rs b/gix-discover/tests/discover/parse.rs
index ec2f80f844b..234f7dcba36 100644
--- a/gix-discover/tests/discover/parse.rs
+++ b/gix-discover/tests/discover/parse.rs
@@ -1,15 +1,28 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_discover::parse;
 
 #[test]
-fn valid() -> crate::Result {
-    assert_eq!(parse::gitdir(b"gitdir: a")?, Path::new("a"));
-    assert_eq!(parse::gitdir(b"gitdir: relative/path")?, Path::new("relative/path"));
-    assert_eq!(parse::gitdir(b"gitdir: ./relative/path")?, Path::new("./relative/path"));
-    assert_eq!(parse::gitdir(b"gitdir: /absolute/path\n")?, Path::new("/absolute/path"));
+fn valid() -> Result {
     assert_eq!(
-        parse::gitdir(b"gitdir: C:/hello/there\r\n")?,
+        parse::gitdir(b"gitdir: a").map_err(gix_error::Exn::into_error)?,
+        Path::new("a")
+    );
+    assert_eq!(
+        parse::gitdir(b"gitdir: relative/path").map_err(gix_error::Exn::into_error)?,
+        Path::new("relative/path")
+    );
+    assert_eq!(
+        parse::gitdir(b"gitdir: ./relative/path").map_err(gix_error::Exn::into_error)?,
+        Path::new("./relative/path")
+    );
+    assert_eq!(
+        parse::gitdir(b"gitdir: /absolute/path\n").map_err(gix_error::Exn::into_error)?,
+        Path::new("/absolute/path")
+    );
+    assert_eq!(
+        parse::gitdir(b"gitdir: C:/hello/there\r\n").map_err(gix_error::Exn::into_error)?,
         Path::new("C:/hello/there")
     );
 
@@ -18,25 +31,25 @@ fn valid() -> crate::Result {
 
 #[test]
 fn invalid() {
-    assert!(
-        matches!(
-            parse::gitdir(b"gitdir:"),
-            Err(parse::gitdir::Error::InvalidFormat { .. })
-        ),
-        "missing prefix"
-    );
-    assert!(
-        matches!(
-            parse::gitdir(b"bogus: foo"),
-            Err(parse::gitdir::Error::InvalidFormat { .. })
-        ),
-        "invalid prefix"
-    );
-    assert!(
-        matches!(
-            parse::gitdir(b"gitdir: "),
-            Err(parse::gitdir::Error::InvalidFormat { .. })
-        ),
-        "empty path"
-    );
+    let mut error_snapshots = Vec::new();
+    for (input, reason) in [
+        (b"gitdir:".as_slice(), "missing prefix"),
+        (b"bogus: foo".as_slice(), "invalid prefix"),
+        (b"gitdir: ".as_slice(), "empty path"),
+    ] {
+        let err = parse::gitdir(input).expect_err(reason);
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::Bytes(input.into())),
+            "{reason}"
+        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid", @r#"
+    [
+        Format should be 'gitdir: <path>', but got, "input"="gitdir:",
+        Format should be 'gitdir: <path>', but got, "input"="bogus: foo",
+        Format should be 'gitdir: <path>', but got, "input"="gitdir: ",
+    ]
+    "#);
 }
diff --git a/gix-discover/tests/discover/path.rs b/gix-discover/tests/discover/path.rs
index 8412abc2f07..d712fd69659 100644
--- a/gix-discover/tests/discover/path.rs
+++ b/gix-discover/tests/discover/path.rs
@@ -1,4 +1,5 @@
 mod from_git_dir_file {
+    use crate::Result;
     use std::{
         io::Write,
         path::{Path, PathBuf},
@@ -8,7 +9,7 @@ mod from_git_dir_file {
 
     #[cfg(not(windows))]
     #[test]
-    fn absolute_path_unix() -> crate::Result {
+    fn absolute_path_unix() -> Result {
         let (path, _) = write_and_read(b"gitdir: /absolute/path/.git")?;
         assert_eq!(path, Path::new("/absolute/path/.git"));
         Ok(())
@@ -16,7 +17,7 @@ mod from_git_dir_file {
 
     #[cfg(windows)]
     #[test]
-    fn absolute_path_windows() -> crate::Result {
+    fn absolute_path_windows() -> Result {
         let (path, _) = write_and_read(b"gitdir: C:/absolute/path/.git")?;
         assert_eq!(path, Path::new("C:/absolute/path/.git"));
 
@@ -26,13 +27,13 @@ mod from_git_dir_file {
     }
 
     #[test]
-    fn relative_path_is_made_absolute_relative_to_containing_dir() -> crate::Result {
+    fn relative_path_is_made_absolute_relative_to_containing_dir() -> Result {
         let (path, gitdir_file) = write_and_read(b"gitdir: relative/path")?;
         assert_eq!(path, gitdir_file.parent().unwrap().join(Path::new("relative/path")));
         Ok(())
     }
 
-    fn write_and_read(content: &[u8]) -> crate::Result<(PathBuf, PathBuf)> {
+    fn write_and_read(content: &[u8]) -> Result<(PathBuf, PathBuf)> {
         let file = gitdir_with_content(content)?;
         Ok((gix_discover::path::from_gitdir_file(file.path())?, file.path().into()))
     }
@@ -45,33 +46,51 @@ mod from_git_dir_file {
 }
 
 mod from_plain_file_relative_to_file {
+    use crate::Result;
     use crate::path::plain_file_with_content;
     use std::path::{Path, PathBuf};
 
     #[test]
-    fn relative_path_is_made_absolute_relative_to_containing_dir() -> crate::Result {
+    fn relative_path_is_made_absolute_relative_to_containing_dir() -> Result {
         let (path, plain_file) = write_and_read(b"relative/path\n")?;
         assert_eq!(path, plain_file.parent().unwrap().join(Path::new("relative/path")));
         Ok(())
     }
 
     #[test]
-    fn empty_or_whitespace_only_path_is_invalid() -> crate::Result {
+    fn empty_or_whitespace_only_path_is_invalid() -> Result {
+        let mut error_snapshots = Vec::new();
         for content in [b"".as_slice(), b"   \n".as_slice()] {
             let file = plain_file_with_content(content)?;
             let err = gix_discover::path::from_plain_file_relative_to_file(file.path())
                 .expect("file exists")
                 .expect_err("empty paths must be rejected");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(file.path()).to_string_lossy(), "<path-file>")],
+            ));
             assert_eq!(
                 err.kind(),
                 std::io::ErrorKind::InvalidData,
                 "empty plain path files are malformed, just like in Git"
             );
         }
+        insta::assert_debug_snapshot!(error_snapshots, "empty or whitespace only path is invalid", @r#"
+        [
+            Custom {
+                kind: InvalidData,
+                error: "Refusing to read an empty path from '<path-file>'",
+            },
+            Custom {
+                kind: InvalidData,
+                error: "Refusing to read an empty path from '<path-file>'",
+            },
+        ]
+        "#);
         Ok(())
     }
 
-    fn write_and_read(content: &[u8]) -> crate::Result<(PathBuf, PathBuf)> {
+    fn write_and_read(content: &[u8]) -> Result<(PathBuf, PathBuf)> {
         let file = plain_file_with_content(content)?;
         Ok((
             gix_discover::path::from_plain_file_relative_to_file(file.path())
@@ -83,21 +102,39 @@ mod from_plain_file_relative_to_file {
 }
 
 mod from_plain_file {
+    use crate::Result;
     use crate::path::plain_file_with_content;
 
     #[test]
-    fn empty_or_whitespace_only_path_is_invalid() -> crate::Result {
+    fn empty_or_whitespace_only_path_is_invalid() -> Result {
+        let mut error_snapshots = Vec::new();
         for content in [b"".as_slice(), b"   \n".as_slice()] {
             let file = plain_file_with_content(content)?;
             let err = gix_discover::path::from_plain_file(file.path())
                 .expect("file exists")
                 .expect_err("empty paths must be rejected");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(file.path()).to_string_lossy(), "<path-file>")],
+            ));
             assert_eq!(
                 err.kind(),
                 std::io::ErrorKind::InvalidData,
                 "empty plain path files are malformed, just like in Git"
             );
         }
+        insta::assert_debug_snapshot!(error_snapshots, "empty or whitespace only path is invalid", @r#"
+        [
+            Custom {
+                kind: InvalidData,
+                error: "Refusing to read an empty path from '<path-file>'",
+            },
+            Custom {
+                kind: InvalidData,
+                error: "Refusing to read an empty path from '<path-file>'",
+            },
+        ]
+        "#);
         Ok(())
     }
 }
diff --git a/gix-discover/tests/discover/upwards/ceiling_dirs.rs b/gix-discover/tests/discover/upwards/ceiling_dirs.rs
index 426627c50f3..f91086a4cfc 100644
--- a/gix-discover/tests/discover/upwards/ceiling_dirs.rs
+++ b/gix-discover/tests/discover/upwards/ceiling_dirs.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_discover::upwards::Options;
@@ -15,7 +16,7 @@ fn assert_repo_is_current_workdir(path: gix_discover::repository::Path, work_dir
 }
 
 #[test]
-fn git_dir_candidate_within_ceiling_allows_discovery() -> crate::Result {
+fn git_dir_candidate_within_ceiling_allows_discovery() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
     let (repo_path, _trust) = gix_discover::upwards_opts(
@@ -32,7 +33,7 @@ fn git_dir_candidate_within_ceiling_allows_discovery() -> crate::Result {
 }
 
 #[test]
-fn ceiling_dir_is_ignored_if_we_are_standing_on_the_ceiling_and_no_match_is_required() -> crate::Result {
+fn ceiling_dir_is_ignored_if_we_are_standing_on_the_ceiling_and_no_match_is_required() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
     // the ceiling dir is equal to the input dir, which itself doesn't contain a repository.
@@ -53,7 +54,7 @@ fn ceiling_dir_is_ignored_if_we_are_standing_on_the_ceiling_and_no_match_is_requ
 }
 
 #[test]
-fn discovery_fails_if_we_require_a_matching_ceiling_dir_but_are_standing_on_it() -> crate::Result {
+fn discovery_fails_if_we_require_a_matching_ceiling_dir_but_are_standing_on_it() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
     let err = gix_discover::upwards_opts(
@@ -65,16 +66,17 @@ fn discovery_fails_if_we_require_a_matching_ceiling_dir_but_are_standing_on_it()
         },
     )
     .unwrap_err();
+    insta::assert_debug_snapshot!(err, "since standing on the ceiling dir doesn't match it, we get exactly the semantically correct error", @"None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.");
 
     assert!(
-        matches!(err, gix_discover::upwards::Error::NoMatchingCeilingDir),
+        err.is_validation(),
         "since standing on the ceiling dir doesn't match it, we get exactly the semantically correct error"
     );
     Ok(())
 }
 
 #[test]
-fn ceiling_dir_limits_are_respected_and_prevent_discovery() -> crate::Result {
+fn ceiling_dir_limits_are_respected_and_prevent_discovery() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
 
@@ -86,16 +88,14 @@ fn ceiling_dir_limits_are_respected_and_prevent_discovery() -> crate::Result {
         },
     )
     .expect_err("ceiling dir prevents discovery as it ends on level too early, and they are also absolutized");
-    assert!(matches!(
-        err,
-        gix_discover::upwards::Error::NoGitRepositoryWithinCeiling { ceiling_height: 5, .. }
-    ));
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(work_dir).to_string_lossy(), "<repo>")]), "ceiling dir limits are respected and prevent discovery", @"Could not find a git repository in '<repo>/some/very/deeply/nested/subdir' or in any of its parents within ceiling height of 5");
 
     Ok(())
 }
 
 #[test]
-fn no_matching_ceiling_dir_error_can_be_suppressed() -> crate::Result {
+fn no_matching_ceiling_dir_error_can_be_suppressed() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
     let (repo_path, _trust) = gix_discover::upwards_opts(
@@ -118,7 +118,7 @@ fn no_matching_ceiling_dir_error_can_be_suppressed() -> crate::Result {
 }
 
 #[test]
-fn more_restrictive_ceiling_dirs_overrule_less_restrictive_ones() -> crate::Result {
+fn more_restrictive_ceiling_dirs_overrule_less_restrictive_ones() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir");
     let err = gix_discover::upwards_opts(
@@ -129,16 +129,14 @@ fn more_restrictive_ceiling_dirs_overrule_less_restrictive_ones() -> crate::Resu
         },
     )
     .expect_err("more restrictive ceiling dirs overrule less restrictive ones");
-    assert!(matches!(
-        err,
-        gix_discover::upwards::Error::NoGitRepositoryWithinCeiling { ceiling_height: 5, .. }
-    ));
+    assert!(err.is_not_found());
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(work_dir).to_string_lossy(), "<repo>")]), "more restrictive ceiling dirs overrule less restrictive ones", @"Could not find a git repository in '<repo>/some/very/deeply/nested/subdir' or in any of its parents within ceiling height of 5");
 
     Ok(())
 }
 
 #[test]
-fn ceiling_dirs_are_not_processed_differently_than_the_git_dir_candidate() -> crate::Result {
+fn ceiling_dirs_are_not_processed_differently_than_the_git_dir_candidate() -> Result {
     let work_dir = repo_path()?;
     let dir = work_dir.join("some/very/deeply/nested/subdir/../../../../../..");
     let (repo_path, _trust) = gix_discover::upwards_opts(
@@ -161,7 +159,7 @@ fn ceiling_dirs_are_not_processed_differently_than_the_git_dir_candidate() -> cr
 }
 
 #[test]
-fn no_matching_ceiling_dirs_errors_by_default() -> crate::Result {
+fn no_matching_ceiling_dirs_errors_by_default() -> Result {
     let relative_work_dir = repo_path()?;
     let dir = relative_work_dir.join("some");
     let res = gix_discover::upwards_opts(
@@ -172,15 +170,17 @@ fn no_matching_ceiling_dirs_errors_by_default() -> crate::Result {
         },
     );
 
+    let err = res.expect_err("an unrelated ceiling directory cannot match");
+    insta::assert_debug_snapshot!(err, "the canonicalized ceiling dir doesn't have the same root as the git dir candidate, and can never match.", @"None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.");
     assert!(
-        matches!(res, Err(gix_discover::upwards::Error::NoMatchingCeilingDir)),
+        err.is_validation(),
         "the canonicalized ceiling dir doesn't have the same root as the git dir candidate, and can never match."
     );
     Ok(())
 }
 
 #[test]
-fn ceilings_are_adjusted_to_match_search_dir() -> crate::Result {
+fn ceilings_are_adjusted_to_match_search_dir() -> Result {
     let relative_work_dir = repo_path()?;
     let cwd = std::env::current_dir()?;
     let absolute_ceiling_dir = gix_path::realpath_opts(&relative_work_dir, &cwd, 8)?;
@@ -210,7 +210,7 @@ fn ceilings_are_adjusted_to_match_search_dir() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn ceiling_dirs_limit_the_physical_symlink_target() -> crate::Result {
+fn ceiling_dirs_limit_the_physical_symlink_target() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_symlinked_nested_repo.sh")?;
     let search_dir = root.join("lexical-parent/link/real-dir");
     let err = gix_discover::upwards_opts(
@@ -221,9 +221,10 @@ fn ceiling_dirs_limit_the_physical_symlink_target() -> crate::Result {
         },
     )
     .expect_err("the physical ceiling prevents discovery of the repository above it");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(root).to_string_lossy(), "<fixture>")]), "the symlink target matches the ceiling before traversal reaches the repository", @"Could not find a git repository in '<fixture>/lexical-parent/link/real-dir' or in any of its parents within ceiling height of 2");
 
     assert!(
-        matches!(err, gix_discover::upwards::Error::NoGitRepositoryWithinCeiling { .. }),
+        err.is_not_found(),
         "the symlink target matches the ceiling before traversal reaches the repository"
     );
     Ok(())
diff --git a/gix-discover/tests/discover/upwards/mod.rs b/gix-discover/tests/discover/upwards/mod.rs
index 00846def671..f43686293b0 100644
--- a/gix-discover/tests/discover/upwards/mod.rs
+++ b/gix-discover/tests/discover/upwards/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::PathBuf;
 
 use gix_discover::repository::Kind;
@@ -13,7 +14,7 @@ fn expected_trust() -> gix_sec::Trust {
 mod ceiling_dirs;
 
 #[test]
-fn can_override_computed_trust() -> crate::Result {
+fn can_override_computed_trust() -> Result {
     let dir = repo_path()?.join("some/very/deeply/nested/subdir");
     let overridden_trust = match expected_trust() {
         gix_sec::Trust::Full => gix_sec::Trust::Reduced,
@@ -41,7 +42,7 @@ fn can_override_computed_trust() -> crate::Result {
 }
 
 #[test]
-fn from_bare_git_dir() -> crate::Result {
+fn from_bare_git_dir() -> Result {
     let dir = repo_path()?.join("bare.git");
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(path.as_ref(), dir, "the bare .git dir is directly returned");
@@ -51,7 +52,7 @@ fn from_bare_git_dir() -> crate::Result {
 }
 
 #[test]
-fn from_bare_with_index() -> crate::Result {
+fn from_bare_with_index() -> Result {
     let dir = repo_path()?.join("bare-with-index.git");
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(path.as_ref(), dir, "the bare .git dir is directly returned");
@@ -61,7 +62,7 @@ fn from_bare_with_index() -> crate::Result {
 }
 
 #[test]
-fn from_non_bare_without_index() -> crate::Result {
+fn from_non_bare_without_index() -> Result {
     let dir = repo_path()?.join("non-bare-without-index");
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(path.as_ref(), dir, "now we refer to a worktree");
@@ -71,7 +72,7 @@ fn from_non_bare_without_index() -> crate::Result {
 }
 
 #[test]
-fn from_non_bare_repo_with_git_extension() -> crate::Result {
+fn from_non_bare_repo_with_git_extension() -> Result {
     let dir = repo_path()?.join("repo.git");
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(
@@ -85,7 +86,7 @@ fn from_non_bare_repo_with_git_extension() -> crate::Result {
 }
 
 #[test]
-fn from_bare_git_dir_without_config_file() -> crate::Result {
+fn from_bare_git_dir_without_config_file() -> Result {
     for name in ["bare-no-config.git", "bare-no-config-after-init.git"] {
         let dir = repo_path()?.join(name);
         let (path, trust) = gix_discover::upwards(&dir)?;
@@ -97,7 +98,7 @@ fn from_bare_git_dir_without_config_file() -> crate::Result {
 }
 
 #[test]
-fn from_inside_bare_git_dir() -> crate::Result {
+fn from_inside_bare_git_dir() -> Result {
     let git_dir = repo_path()?.join("bare.git");
     let dir = git_dir.join("objects");
     let (path, trust) = gix_discover::upwards(&dir)?;
@@ -112,7 +113,7 @@ fn from_inside_bare_git_dir() -> crate::Result {
 }
 
 #[test]
-fn from_git_dir() -> crate::Result {
+fn from_git_dir() -> Result {
     let dir = repo_path()?.join(".git");
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(path.kind(), Kind::WorkTree { linked_git_dir: None });
@@ -126,7 +127,7 @@ fn from_git_dir() -> crate::Result {
 }
 
 #[test]
-fn from_working_dir() -> crate::Result {
+fn from_working_dir() -> Result {
     let dir = repo_path()?;
     let (path, trust) = gix_discover::upwards(&dir)?;
     assert_eq!(path.as_ref(), dir, "a working tree dir yields the git dir");
@@ -136,7 +137,7 @@ fn from_working_dir() -> crate::Result {
 }
 
 #[test]
-fn from_working_dir_no_config() -> crate::Result {
+fn from_working_dir_no_config() -> Result {
     for name in ["worktree-no-config-after-init", "worktree-no-config"] {
         let dir = repo_path()?.join(name);
         let (path, trust) = gix_discover::upwards(&dir)?;
@@ -148,7 +149,7 @@ fn from_working_dir_no_config() -> crate::Result {
 }
 
 #[test]
-fn from_nested_dir() -> crate::Result {
+fn from_nested_dir() -> Result {
     let working_dir = repo_path()?;
     let dir = working_dir.join("some/very/deeply/nested/subdir");
     let (path, trust) = gix_discover::upwards(&dir)?;
@@ -159,7 +160,7 @@ fn from_nested_dir() -> crate::Result {
 }
 
 #[test]
-fn an_invalid_dot_git_directory_does_not_skip_ancestors() -> crate::Result {
+fn an_invalid_dot_git_directory_does_not_skip_ancestors() -> Result {
     let repo = gix_path::realpath(repo_path()?)?;
     let start = repo.join("non-repo/.git");
 
@@ -174,7 +175,7 @@ fn an_invalid_dot_git_directory_does_not_skip_ancestors() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn from_symlinked_nested_dir_follows_target_ancestors() -> crate::Result {
+fn from_symlinked_nested_dir_follows_target_ancestors() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_symlinked_nested_repo.sh")?;
     let link = root.join("lexical-parent/link");
 
@@ -195,7 +196,7 @@ fn from_symlinked_nested_dir_follows_target_ancestors() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn symlink_is_resolved_before_parent_component() -> crate::Result {
+fn symlink_is_resolved_before_parent_component() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_symlinked_nested_repo.sh")?;
 
     for path in [
@@ -216,7 +217,7 @@ fn symlink_is_resolved_before_parent_component() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn relative_symlinks_use_the_configured_current_dir() -> crate::Result {
+fn relative_symlinks_use_the_configured_current_dir() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_symlinked_nested_repo.sh")?;
     let root = std::env::current_dir()?.join(root);
 
@@ -245,7 +246,7 @@ fn relative_symlinks_use_the_configured_current_dir() -> crate::Result {
 }
 
 #[test]
-fn from_dir_with_dot_dot() -> crate::Result {
+fn from_dir_with_dot_dot() -> Result {
     // This would be neater if we could just change the actual working directory,
     // but Rust tests run in parallel by default so we'd interfere with other tests.
     // Instead ensure it finds the gitoxide repo instead of a test repo if we crawl
@@ -285,7 +286,7 @@ fn from_dir_with_dot_dot() -> crate::Result {
 }
 
 #[test]
-fn from_nested_dir_inside_a_git_dir() -> crate::Result {
+fn from_nested_dir_inside_a_git_dir() -> Result {
     let working_dir = repo_path()?;
     let dir = working_dir.join(".git").join("objects");
     let (path, trust) = gix_discover::upwards(&dir)?;
@@ -333,7 +334,7 @@ fn from_non_existing_worktree_inside_dot_git() {
 }
 
 #[test]
-fn from_existing_worktree() -> crate::Result {
+fn from_existing_worktree() -> Result {
     let top_level_repo = repo_path()?;
     for (discover_path, expected_worktree_path, expected_git_dir) in [
         (top_level_repo.join("worktrees/a"), "worktrees/a", ".git/worktrees/a"),
@@ -364,7 +365,7 @@ fn from_existing_worktree() -> crate::Result {
 }
 
 #[test]
-fn from_existing_worktree_with_relative_linking_files() -> crate::Result {
+fn from_existing_worktree_with_relative_linking_files() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only_needs_archive("make_worktree_relative_linking.sh")?;
     let main = fixture.join("main");
     let linked = fixture.join("linked");
@@ -401,7 +402,7 @@ fn from_existing_worktree_with_relative_linking_files() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn from_symlinked_worktree_with_relative_linking_files() -> crate::Result {
+fn from_symlinked_worktree_with_relative_linking_files() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only_needs_archive("make_worktree_relative_linking.sh")?;
     let main = fixture.join("actual/main");
     let linked_symlink = fixture.join("linked-symlink");
@@ -425,7 +426,7 @@ fn from_symlinked_worktree_with_relative_linking_files() -> crate::Result {
 
 #[cfg(target_os = "macos")]
 #[test]
-fn cross_fs() -> crate::Result {
+fn cross_fs() -> Result {
     use std::process::Command;
 
     use gix_discover::upwards::Options;
@@ -470,10 +471,11 @@ fn cross_fs() -> crate::Result {
 
     let res = gix_discover::upwards(&top_level_repo.path().join("remote"))
         .expect_err("the cross-fs option should prevent us from discovering the repo");
-    assert!(matches!(
-        res,
-        gix_discover::upwards::Error::NoGitRepositoryWithinFs { .. }
-    ));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&res, &[
+        (&top_level_repo.path().canonicalize()?.to_string_lossy(), "<repository>"),
+        (&top_level_repo.path().to_string_lossy(), "<repository>"),
+    ]), "discovery stops at the filesystem boundary", @"Could not find a git repository in '<repository>/remote' or in any of its parents within device limits below '<repository>'");
+    assert!(res.is_not_found());
 
     let (repo_path, _trust) = gix_discover::upwards_opts(
         &top_level_repo.path().join("remote"),
@@ -497,7 +499,7 @@ fn cross_fs() -> crate::Result {
 }
 
 #[test]
-fn do_not_shorten_absolute_paths() -> crate::Result {
+fn do_not_shorten_absolute_paths() -> Result {
     let top_level_repo = repo_path()?.canonicalize().expect("repo path exists");
     let (repo_path, _trust) = gix_discover::upwards(&top_level_repo).expect("we can discover the repo");
 
@@ -513,7 +515,7 @@ fn do_not_shorten_absolute_paths() -> crate::Result {
 
 #[cfg(unix)]
 #[test]
-fn preserves_symlinked_ancestor_of_absolute_paths() -> crate::Result {
+fn preserves_symlinked_ancestor_of_absolute_paths() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_symlinked_nested_repo.sh")?;
     let root = std::env::current_dir()?.join(root);
     let worktree = root.join("linked-parent/repo");
@@ -547,6 +549,7 @@ fn preserves_symlinked_ancestor_of_absolute_paths() -> crate::Result {
 }
 
 mod dot_git_only {
+    use crate::Result;
     use crate::upwards::repo_path;
 
     fn find_dot_git(base: impl AsRef<std::path::Path>) -> gix_discover::repository::Path {
@@ -571,7 +574,7 @@ mod dot_git_only {
     }
 
     #[test]
-    fn succeeds_in_worktree_dir() -> crate::Result {
+    fn succeeds_in_worktree_dir() -> Result {
         let top_level_repo = repo_path()?;
         for base in [
             top_level_repo.join("some/very/deeply/nested/subdir"),
@@ -584,7 +587,7 @@ mod dot_git_only {
     }
 
     #[test]
-    fn succeeds_from_within_dot_git_dir() -> crate::Result {
+    fn succeeds_from_within_dot_git_dir() -> Result {
         let top_level_repo = repo_path()?;
         for inside_git_dir in [top_level_repo.join(".git"), top_level_repo.join(".git").join("refs")] {
             let repo_path = find_dot_git(inside_git_dir);
@@ -594,7 +597,7 @@ mod dot_git_only {
     }
 
     #[test]
-    fn bare_repos_are_ignored() -> crate::Result {
+    fn bare_repos_are_ignored() -> Result {
         let top_level_repo = repo_path()?;
         for bare_dir in [
             top_level_repo.join("bare.git"),
@@ -608,8 +611,10 @@ mod dot_git_only {
 }
 
 mod submodules {
+    use crate::Result;
+
     #[test]
-    fn by_their_worktree_checkout() -> crate::Result {
+    fn by_their_worktree_checkout() -> Result {
         let dir = gix_testtools::scripted_fixture_read_only("make_submodules.sh")?;
         let parent = dir.join("with-submodules");
         let modules = parent.join(".git").join("modules");
@@ -632,7 +637,7 @@ mod submodules {
     }
 
     #[test]
-    fn by_their_module_git_dir() -> crate::Result {
+    fn by_their_module_git_dir() -> Result {
         let dir = gix_testtools::scripted_fixture_read_only("make_submodules.sh")?;
         let modules = dir.join("with-submodules").join(".git").join("modules");
         for module in ["m1", "dir/m1"] {
@@ -647,6 +652,6 @@ mod submodules {
     }
 }
 
-pub(crate) fn repo_path() -> crate::Result<PathBuf> {
+pub(crate) fn repo_path() -> Result<PathBuf> {
     gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")
 }
diff --git a/gix-discover/tests/isolated.rs b/gix-discover/tests/isolated.rs
index 4841c866022..5ce017f3194 100644
--- a/gix-discover/tests/isolated.rs
+++ b/gix-discover/tests/isolated.rs
@@ -97,6 +97,7 @@ fn in_cwd_upwards_nonbare_repo_without_index() -> gix_testtools::Result {
 #[test]
 #[serial]
 fn upwards_with_relative_directories_and_optional_ceiling() -> gix_testtools::Result {
+    let mut error_snapshots = Vec::new();
     let repo = gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")?;
 
     let _keep = gix_testtools::set_current_dir(repo.join("some"))?;
@@ -146,15 +147,24 @@ fn upwards_with_relative_directories_and_optional_ceiling() -> gix_testtools::Re
         .unwrap_err();
 
         if search_dir.parent() == Some(".".as_ref()) || search_dir.parent() == Some("".as_ref()) {
-            assert!(matches!(err, gix_discover::upwards::Error::NoMatchingCeilingDir));
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.is_validation());
         } else {
-            assert!(matches!(
-                err,
-                gix_discover::upwards::Error::NoGitRepositoryWithinCeiling { .. }
-            ));
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.is_not_found());
         }
     }
 
+    insta::assert_debug_snapshot!(error_snapshots, "upwards with relative directories and optional ceiling", @"
+    [
+        None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.,
+        None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.,
+        None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.,
+        None of the passed ceiling directories prefixed the git-dir candidate, making them ineffective.,
+        Could not find a git repository in './././very/deeply/nested/subdir' or in any of its parents within ceiling height of 5,
+        Could not find a git repository in 'very/deeply/nested/subdir' or in any of its parents within ceiling height of 5,
+    ]
+    ");
     Ok(())
 }
 
diff --git a/gix-error/Cargo.toml b/gix-error/Cargo.toml
index 02f1248d4ad..c93239d7cda 100644
--- a/gix-error/Cargo.toml
+++ b/gix-error/Cargo.toml
@@ -35,6 +35,7 @@ anyhow = { version = "1.0.102", optional = true }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
 gix-error = { path = ".", features = ["anyhow"] }
 insta = "1.46.3"
 
diff --git a/gix-error/src/concrete/chain.rs b/gix-error/src/concrete/chain.rs
index 29460364a62..8dcdc44f7ae 100644
--- a/gix-error/src/concrete/chain.rs
+++ b/gix-error/src/concrete/chain.rs
@@ -13,12 +13,7 @@ pub struct ChainedError {
     pub(crate) err: ErrorHandle,
     /// The call site captured when the corresponding error frame was created.
     pub(crate) location: &'static Location<'static>,
-    #[cfg_attr(
-        not(all(feature = "auto-chain-error", not(feature = "tree-error"))),
-        expect(dead_code, reason = "used only by the auto-chain Error representation")
-    )]
-    /// Whether this frame was selected as the probable cause before flattening the error tree, using the root as fallback.
-    pub(crate) is_probable_cause: bool,
+
     #[cfg_attr(
         not(all(feature = "auto-chain-error", not(feature = "tree-error"))),
         expect(dead_code, reason = "used only by the auto-chain Error representation")
@@ -53,7 +48,7 @@ impl std::error::Error for ChainedError {
         self.source
             .as_deref()
             .map(|err| err as &(dyn std::error::Error + 'static))
-            .or_else(|| self.err.error().source())
+            .or_else(|| crate::error::native_source(self.err.error()))
     }
 }
 
@@ -61,17 +56,19 @@ impl std::error::Error for ChainedError {
 ///
 /// Keeping the source-chain root in an [`Arc`] makes every source reachable for the lifetime of the flattened chain.
 /// A handle cannot store both that owner and a reference borrowed from its [`std::error::Error::source()`] chain without
-/// becoming self-referential. Instead, `source_depth` records how many `source()` links lead from `owner` to the error
-/// represented by this handle: zero represents `owner`, one represents `owner.source()`, and so on. [`Self::error()`]
-/// follows that path whenever the borrowed error is needed.
+/// becoming self-referential. Instead, `source_depth` records how many native source links, including I/O payloads,
+/// lead from `owner` to the error represented by this handle. Zero represents `owner`. [`Self::error()`] follows that
+/// path whenever the borrowed error is needed.
 ///
 /// Resolving a handle assumes that an error's source chain remains stable while the owning error is alive, as conventional
 /// [`std::error::Error`] implementations do.
 pub(crate) struct ErrorHandle {
     /// The error that owns the complete native source chain.
     owner: Arc<dyn std::error::Error + Send + Sync + 'static>,
-    /// The number of [`std::error::Error::source()`] links to follow from `owner` to reach this handle's error.
+    /// The number of native source links, including I/O payloads, from `owner` to this handle's error.
     source_depth: usize,
+    /// Whether this error retains its frame's location, directly or through transparent marker sources.
+    has_frame_location: bool,
 }
 
 impl ErrorHandle {
@@ -79,29 +76,31 @@ impl ErrorHandle {
         ErrorHandle {
             owner: error.into(),
             source_depth: 0,
+            has_frame_location: true,
         }
     }
 
     pub(crate) fn error(&self) -> &(dyn std::error::Error + 'static) {
         let mut error: &(dyn std::error::Error + 'static) = self.owner.as_ref();
         for _ in 0..self.source_depth {
-            error = error
-                .source()
+            error = crate::error::native_source(error)
                 .expect("a captured source path remains stable while its owning error is alive");
         }
         error
     }
 
     pub(crate) fn source(&self) -> Option<Self> {
-        self.error().source()?;
+        let error = self.error();
+        crate::error::native_source(error)?;
         Some(ErrorHandle {
             owner: Arc::clone(&self.owner),
             source_depth: self.source_depth + 1,
+            has_frame_location: self.has_frame_location && crate::error::is_transparent_marker(error),
         })
     }
 
     #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
-    pub(crate) fn is_native_source(&self) -> bool {
-        self.source_depth > 0
+    pub(crate) fn has_frame_location(&self) -> bool {
+        self.has_frame_location
     }
 }
diff --git a/gix-error/src/concrete/classify.rs b/gix-error/src/concrete/classify.rs
index 688410a7309..2be3e37b290 100644
--- a/gix-error/src/concrete/classify.rs
+++ b/gix-error/src/concrete/classify.rs
@@ -1,153 +1,94 @@
-use std::borrow::Cow;
-use std::fmt::{Display, Formatter};
-
-use crate::Message;
-
-/// The kind of resource exhaustion which prevented an operation from completing.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[non_exhaustive]
-pub enum ResourceExhaustionKind {
-    /// An application-configured allocation limit was exceeded.
-    AllocationLimit,
-    /// An allocation size could not be represented or memory could not be reserved.
-    AllocationFailure,
-}
-
-/// An error caused by exhausting a finite resource.
-#[derive(Debug)]
-pub struct ResourceExhaustionError {
-    /// The kind of resource exhaustion.
-    pub kind: ResourceExhaustionKind,
-    /// The error message.
-    pub message: Cow<'static, str>,
-}
-
-impl ResourceExhaustionError {
-    /// Create a new instance with `kind` that displays the given `message`.
-    pub fn new(kind: ResourceExhaustionKind, message: impl Into<Cow<'static, str>>) -> Self {
-        ResourceExhaustionError {
-            kind,
-            message: message.into(),
+use std::fmt::{Debug, Display, Formatter};
+
+use crate::Class;
+
+/// A transparent classification marker with an optional owned source and no diagnostic of its own.
+///
+/// Unlike [`Message`](crate::Message), markers only supply classification metadata, never a visible
+/// diagnostic. Use [`Message`](crate::Message) to combine a message, class, and scalar values in one causal error;
+/// use a marker to classify an existing concrete error without changing its diagnostic or recovery payload.
+/// [`Self::with_source()`] adds a classification to an existing error while preserving its concrete type and diagnostic.
+/// The associated constants, such as [`Self::NOT_FOUND`], are owned class-only markers. A custom error can return
+/// `Some(const { &ClassificationMarker::NOT_FOUND })` from its [`source()`](std::error::Error::source)
+/// implementation without defining a static.
+/// [`Self::with_class()`] creates an owned class-only marker, including for [`Class::Io`] with a specific I/O kind.
+///
+/// Diagnostic iterators, downcasts, cause selection, and exception/test reports skip all markers,
+/// retaining their real descendants. [`crate::classify()`] still inspects markers. Raw standard-error sources can still
+/// expose markers. A report with only class-only markers falls back to displaying the root classification.
+/// If cause selection cannot choose a unique real descendant, it can likewise fall back to the stored marker root.
+/// Preserve real [`std::io::Error`] sources: the marker itself has no I/O origin for [`crate::types::Classification::io_kind()`].
+pub struct ClassificationMarker {
+    class: Class,
+    source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+}
+
+impl ClassificationMarker {
+    /// A hidden marker for invalid input.
+    pub const VALIDATION: Self = Self::with_class(Class::Validation);
+    /// A hidden marker for malformed or internally inconsistent data.
+    pub const CORRUPTION: Self = Self::with_class(Class::Corruption);
+    /// A hidden marker for a requested resource that does not exist.
+    pub const NOT_FOUND: Self = Self::with_class(Class::NotFound);
+    /// A hidden marker for an operation which may succeed when retried.
+    pub const RETRYABLE: Self = Self::with_class(Class::Retryable);
+    /// A hidden marker for an application-configured allocation limit being exceeded.
+    pub const ALLOCATION_LIMIT: Self =
+        Self::with_class(Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit));
+    /// A hidden marker for an unrepresentable allocation size or memory that could not be reserved.
+    pub const ALLOCATION_FAILURE: Self =
+        Self::with_class(Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure));
+
+    /// Add `class` to `source`, preserving its concrete type and diagnostic without a visible wrapper.
+    pub fn with_source(class: Class, source: impl std::error::Error + Send + Sync + 'static) -> Self {
+        ClassificationMarker {
+            class,
+            source: Some(Box::new(source)),
         }
     }
 
-    /// Return the kind of resource exhaustion.
-    pub fn kind(&self) -> ResourceExhaustionKind {
-        self.kind
+    /// Create a hidden metadata leaf, suitable for a custom error's static source.
+    /// Prefer the associated constants, such as [`Self::NOT_FOUND`], for fixed classifications.
+    pub const fn with_class(class: Class) -> Self {
+        ClassificationMarker { class, source: None }
     }
-}
 
-impl Display for ResourceExhaustionError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.message.as_ref())
+    /// Return the classification supplied by this marker.
+    pub fn class(&self) -> Class {
+        self.class
     }
 }
 
-impl std::error::Error for ResourceExhaustionError {}
-
-/// An error caused by malformed or internally inconsistent data.
-#[derive(Debug)]
-pub struct CorruptionError {
-    /// The error message.
-    pub message: Cow<'static, str>,
-}
-
-impl CorruptionError {
-    /// Create a new instance that displays the given `message`.
-    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
-        CorruptionError {
-            message: message.into(),
-        }
-    }
-}
-
-impl Display for CorruptionError {
+impl Display for ClassificationMarker {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.message.as_ref())
-    }
-}
-
-impl std::error::Error for CorruptionError {}
-
-impl From<Message> for CorruptionError {
-    fn from(Message(msg): Message) -> Self {
-        CorruptionError::new(msg)
-    }
-}
-
-impl From<String> for CorruptionError {
-    fn from(msg: String) -> Self {
-        CorruptionError::new(msg)
-    }
-}
-
-impl From<&'static str> for CorruptionError {
-    fn from(msg: &'static str) -> Self {
-        CorruptionError::new(msg)
-    }
-}
-
-/// An error indicating that a requested resource does not exist.
-#[derive(Debug)]
-pub struct NotFoundError {
-    /// The error message.
-    pub message: Cow<'static, str>,
-}
-
-impl NotFoundError {
-    /// Create a new instance that displays the given `message`.
-    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
-        NotFoundError {
-            message: message.into(),
+        match &self.source {
+            Some(source) => Display::fmt(source, f),
+            None => Debug::fmt(&self.class, f),
         }
     }
 }
 
-impl Display for NotFoundError {
+impl Debug for ClassificationMarker {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.message.as_ref())
-    }
-}
-
-impl std::error::Error for NotFoundError {}
-
-impl From<Message> for NotFoundError {
-    fn from(Message(msg): Message) -> Self {
-        NotFoundError::new(msg)
-    }
-}
-
-impl From<String> for NotFoundError {
-    fn from(msg: String) -> Self {
-        NotFoundError::new(msg)
-    }
-}
-
-impl From<&'static str> for NotFoundError {
-    fn from(msg: &'static str) -> Self {
-        NotFoundError::new(msg)
-    }
-}
-
-/// A transparent wrapper for dependency-specific errors known to be retryable.
-#[derive(Debug)]
-pub struct RetryableError(Box<dyn std::error::Error + Send + Sync + 'static>);
-
-impl RetryableError {
-    /// Mark `source` as retryable.
-    pub fn new(source: impl std::error::Error + Send + Sync + 'static) -> Self {
-        RetryableError(Box::new(source))
+        match &self.source {
+            Some(source) => Debug::fmt(source, f),
+            None => Display::fmt(self, f),
+        }
     }
 }
 
-impl Display for RetryableError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.0, f)
+impl std::error::Error for ClassificationMarker {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.source.as_deref().map(|source| source as _)
     }
 }
 
-impl std::error::Error for RetryableError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        Some(self.0.as_ref())
-    }
+/// The kind of resource exhaustion which prevented an operation from completing.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum ResourceExhaustionKind {
+    /// An application-configured allocation limit was exceeded.
+    AllocationLimit,
+    /// An allocation size could not be represented or memory could not be reserved.
+    AllocationFailure,
 }
diff --git a/gix-error/src/concrete/message.rs b/gix-error/src/concrete/message.rs
index 796da14de3f..bb4e3b227bc 100644
--- a/gix-error/src/concrete/message.rs
+++ b/gix-error/src/concrete/message.rs
@@ -1,40 +1,4 @@
-use std::borrow::Cow;
-use std::fmt::{Debug, Display, Formatter};
-
-/// An error that is further described in a message.
-#[derive(Debug)]
-pub struct Message(
-    /// The error message.
-    pub(crate) Cow<'static, str>,
-);
-
-/// Lifecycle
-impl Message {
-    /// Create a new instance that displays the given `message`.
-    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
-        Message(message.into())
-    }
-}
-
-impl Display for Message {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.0.as_ref())
-    }
-}
-
-impl std::error::Error for Message {}
-
-impl From<String> for Message {
-    fn from(msg: String) -> Self {
-        Message::new(msg)
-    }
-}
-
-impl From<&'static str> for Message {
-    fn from(msg: &'static str) -> Self {
-        Message::new(msg)
-    }
-}
+use crate::Message;
 
 /// Return a new statically allocated `message`.
 ///
diff --git a/gix-error/src/concrete/metadata.rs b/gix-error/src/concrete/metadata.rs
new file mode 100644
index 00000000000..b6e07e778ba
--- /dev/null
+++ b/gix-error/src/concrete/metadata.rs
@@ -0,0 +1,232 @@
+use std::{borrow::Cow, collections::BTreeMap, fmt, path::PathBuf};
+
+use bstr::BString;
+
+use crate::{Class, ResourceExhaustionKind};
+
+/// An ordered dictionary of named diagnostic values belonging to a single error context.
+///
+/// Functions returning metadata document the keys and their meaning. [`crate::Exn::metadata()`] and
+/// [`crate::Error::metadata()`] yield non-empty dictionaries separately; dictionaries from independent causes
+/// are never merged.
+pub type Metadata = BTreeMap<Cow<'static, str>, MetadataValue>;
+
+/// A diagnostic message with an optional semantic class and named diagnostic values.
+///
+/// Use this instead of chaining message, classification, and scalar-context errors when they describe a single
+/// failure. [`Self::new()`] starts without a class or values; [`Self::with_class()`] and [`Self::with()`] add them.
+/// Class-based constructors such as [`crate::not_found()`] combine the message and class in one step.
+///
+/// Unlike [`ClassificationMarker`](crate::ClassificationMarker), this is a visible diagnostic: it participates in
+/// error iteration, downcasting, reports, and cause selection. A marker only adds a classification to an existing
+/// error without a diagnostic of its own, preserving that error's concrete type. Both are inspected by [`crate::classify()`].
+/// The class itself isn't displayed, and [`crate::types::Classification::error()`] refers to this error, not a synthetic source.
+///
+/// Preserve real callee errors with [`ResultExt::or_raise()`](crate::ResultExt::or_raise) or
+/// [`Exn::raise()`](crate::Exn::raise). Keep concrete error types when recovery requires their specific payloads;
+/// use classification predicates to recognize categories, and document diagnostic keys on the function returning them.
+/// [`Exn::metadata()`](crate::Exn::metadata) and [`crate::Error::metadata()`] yield each message's non-empty value dictionary.
+/// Dictionaries from separate contexts aren't merged. To identify a specific failure without inspecting its values,
+/// use [`Class::Tagged`]; see [matching a specific failure](crate#matching-a-specific-failure).
+///
+/// Debug formatting omits absent classes and empty values. Present classes omit their `Some` wrapper,
+/// and the class and values stay on single lines, even in pretty output.
+pub struct Message {
+    /// The operation or situation described by these values.
+    pub message: Cow<'static, str>,
+    /// The semantic class of this diagnostic, if known.
+    pub class: Option<Class>,
+    /// Diagnostic values, ordered by key. Functions returning metadata document their keys.
+    pub values: Metadata,
+}
+
+impl Message {
+    /// Create a diagnostic with `message`, no classification, and no values.
+    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            message: message.into(),
+            class: None,
+            values: Metadata::new(),
+        }
+    }
+
+    /// Set `class`, replacing any previous classification without adding a cause.
+    pub fn with_class(mut self, class: Class) -> Self {
+        self.class = Some(class);
+        self
+    }
+
+    /// Add `value` under `key`, replacing any previous value in this context.
+    /// Inspect values through [`crate::Exn::metadata()`] after raising, or [`crate::Error::metadata()`] after wrapping.
+    pub fn with(mut self, key: impl Into<Cow<'static, str>>, value: impl Into<MetadataValue>) -> Self {
+        self.values.insert(key.into(), value.into());
+        self
+    }
+}
+
+impl fmt::Debug for Message {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut debug = f.debug_struct("Message");
+        debug.field("message", &self.message);
+        if let Some(class) = self.class {
+            debug.field("class", &format_args!("{class:?}"));
+        }
+        if !self.values.is_empty() {
+            debug.field("values", &format_args!("{:?}", self.values));
+        }
+        debug.finish()
+    }
+}
+
+impl fmt::Display for Message {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.message)?;
+        for (key, value) in &self.values {
+            write!(f, ", {key:?}={value}")?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for Message {}
+
+impl From<Cow<'static, str>> for Message {
+    fn from(message: Cow<'static, str>) -> Self {
+        Self::new(message)
+    }
+}
+
+impl From<String> for Message {
+    fn from(message: String) -> Self {
+        Self::new(message)
+    }
+}
+
+impl From<&'static str> for Message {
+    fn from(message: &'static str) -> Self {
+        Self::new(message)
+    }
+}
+
+/// Create a diagnostic for invalid function or method input, classified as [`Class::Validation`].
+pub fn validation(message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::Validation)
+}
+
+/// Create a diagnostic for malformed or internally inconsistent data, classified as [`Class::Corruption`].
+pub fn corruption(message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::Corruption)
+}
+
+/// Create a diagnostic for a missing resource, classified as [`Class::NotFound`].
+pub fn not_found(message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::NotFound)
+}
+
+/// Create a diagnostic for an operation that may succeed when retried, classified as [`Class::Retryable`].
+pub fn retryable(message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::Retryable)
+}
+
+/// Create a diagnostic for an exhausted resource, classified as [`Class::ResourceExhaustion`] of `kind`.
+pub fn resource_exhaustion(kind: ResourceExhaustionKind, message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::ResourceExhaustion(kind))
+}
+
+/// Create a diagnostic for an exceeded application-configured allocation limit.
+pub fn allocation_limit(message: impl Into<Cow<'static, str>>) -> Message {
+    resource_exhaustion(ResourceExhaustionKind::AllocationLimit, message)
+}
+
+/// Create a diagnostic for an unrepresentable allocation size or memory that could not be reserved.
+pub fn allocation_failure(message: impl Into<Cow<'static, str>>) -> Message {
+    resource_exhaustion(ResourceExhaustionKind::AllocationFailure, message)
+}
+
+/// Create a diagnostic classified as [`Class::Io`] of `kind`, without an original [`std::io::Error`].
+///
+/// This does not supply an I/O origin for [`crate::types::Classification::io_kind()`]. When an actual I/O error is
+/// available, preserve it as a cause with [`ResultExt::or_raise()`](crate::ResultExt::or_raise) instead.
+pub fn io(kind: std::io::ErrorKind, message: impl Into<Cow<'static, str>>) -> Message {
+    Message::new(message).with_class(Class::Io(kind))
+}
+
+/// An owned scalar value in a [`Metadata`] dictionary. Bytes and native paths retain their original representation.
+///
+/// Debug formatting keeps the variant and its value on a single line, even in pretty output.
+#[derive(Clone, PartialEq)]
+#[non_exhaustive]
+pub enum MetadataValue {
+    /// A boolean.
+    Bool(bool),
+    /// A signed integer.
+    I64(i64),
+    /// An unsigned integer.
+    U64(u64),
+    /// A floating-point number.
+    F64(f64),
+    /// UTF-8 text.
+    String(String),
+    /// An arbitrary byte string.
+    Bytes(BString),
+    /// A native filesystem path.
+    Path(PathBuf),
+}
+
+impl fmt::Debug for MetadataValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MetadataValue::Bool(value) => write!(f, "Bool({value:?})"),
+            MetadataValue::I64(value) => write!(f, "I64({value:?})"),
+            MetadataValue::U64(value) => write!(f, "U64({value:?})"),
+            MetadataValue::F64(value) => write!(f, "F64({value:?})"),
+            MetadataValue::String(value) => write!(f, "String({value:?})"),
+            MetadataValue::Bytes(value) => write!(f, "Bytes({value:?})"),
+            MetadataValue::Path(value) => write!(f, "Path({value:?})"),
+        }
+    }
+}
+
+impl fmt::Display for MetadataValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MetadataValue::Bool(value) => fmt::Display::fmt(value, f),
+            MetadataValue::I64(value) => fmt::Display::fmt(value, f),
+            MetadataValue::U64(value) => fmt::Display::fmt(value, f),
+            MetadataValue::F64(value) => fmt::Display::fmt(value, f),
+            MetadataValue::String(value) => fmt::Debug::fmt(value, f),
+            MetadataValue::Bytes(value) => fmt::Debug::fmt(value, f),
+            MetadataValue::Path(value) => fmt::Debug::fmt(value, f),
+        }
+    }
+}
+
+macro_rules! from {
+    ($variant:ident: $($ty:ty),+ $(,)?) => {
+        $(impl From<$ty> for MetadataValue {
+            fn from(value: $ty) -> Self {
+                Self::$variant(value.into())
+            }
+        })+
+    };
+}
+
+from!(Bool: bool);
+from!(I64: i8, i16, i32, i64);
+from!(U64: u8, u16, u32, u64);
+from!(F64: f32, f64);
+from!(String: String, &str);
+from!(Bytes: BString, &bstr::BStr, Vec<u8>, &[u8]);
+from!(Path: PathBuf, &std::path::Path);
+
+impl From<usize> for MetadataValue {
+    fn from(value: usize) -> Self {
+        Self::U64(value as u64)
+    }
+}
+
+impl From<isize> for MetadataValue {
+    fn from(value: isize) -> Self {
+        Self::I64(value as i64)
+    }
+}
diff --git a/gix-error/src/concrete/mod.rs b/gix-error/src/concrete/mod.rs
index 9546d99898d..bf711c6a2d1 100644
--- a/gix-error/src/concrete/mod.rs
+++ b/gix-error/src/concrete/mod.rs
@@ -1,4 +1,4 @@
 pub(super) mod chain;
 pub(super) mod classify;
 pub(super) mod message;
-pub(super) mod validate;
+pub(super) mod metadata;
diff --git a/gix-error/src/concrete/validate.rs b/gix-error/src/concrete/validate.rs
deleted file mode 100644
index 85db7e9f59b..00000000000
--- a/gix-error/src/concrete/validate.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use crate::Message;
-use bstr::BString;
-use std::borrow::Cow;
-use std::fmt::{Debug, Display, Formatter};
-
-/// An error occurred when validating input.
-///
-/// This can happen explicitly, or as part of parsing, for example.
-#[derive(Debug)]
-pub struct ValidationError {
-    /// The error message.
-    pub message: Cow<'static, str>,
-    /// The input or portion of the input that wasn't valid.
-    pub input: Option<BString>,
-}
-
-/// Lifecycle
-impl ValidationError {
-    /// Create a new error with `message` and `input`. The `input` is displayed with debug formatting to not hide whitespace related issues.
-    pub fn new_with_input(message: impl Into<Cow<'static, str>>, input: impl Into<BString>) -> Self {
-        ValidationError {
-            message: message.into(),
-            input: Some(input.into()),
-        }
-    }
-
-    /// Create a new instance that displays the given `message`.
-    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
-        ValidationError {
-            message: message.into(),
-            input: None,
-        }
-    }
-}
-
-impl Display for ValidationError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match &self.input {
-            None => f.write_str(self.message.as_ref()),
-            Some(input) => {
-                write!(f, "{}: {input:?}", self.message)
-            }
-        }
-    }
-}
-
-impl std::error::Error for ValidationError {}
-
-impl From<Message> for ValidationError {
-    fn from(Message(msg): Message) -> Self {
-        ValidationError::new(msg)
-    }
-}
-
-impl From<String> for ValidationError {
-    fn from(msg: String) -> Self {
-        ValidationError::new(msg)
-    }
-}
-
-impl From<&'static str> for ValidationError {
-    fn from(msg: &'static str) -> Self {
-        ValidationError::new(msg)
-    }
-}
diff --git a/gix-error/src/error.rs b/gix-error/src/error.rs
index 0a491620675..b1cba8adef8 100644
--- a/gix-error/src/error.rs
+++ b/gix-error/src/error.rs
@@ -1,9 +1,71 @@
+use crate::Metadata;
+
+// Keep inherent methods on Error and Exn while sharing their implementation and documentation.
+macro_rules! classification_predicates {
+    () => {
+        /// Return `true` if any stored error or native source has an explicit [`crate::Class::Retryable`] classification.
+        ///
+        /// [`crate::Message`] and [`crate::ClassificationMarker`] can supply this classification.
+        /// Nested [`crate::Error`] values are inspected recursively. Unlike [`Self::can_retry()`], this does not infer
+        /// retryability from I/O error kinds.
+        pub fn is_retryable(&self) -> bool {
+            self.classify().is_retryable()
+        }
+
+        /// Return `true` if any stored error or native source reports resource exhaustion.
+        ///
+        /// This recognizes messages or markers with
+        /// [`crate::Class::ResourceExhaustion`], [`std::collections::TryReserveError`], and
+        /// [`std::io::ErrorKind::OutOfMemory`], including within nested
+        /// [`crate::Error`] values.
+        pub fn is_resource_exhausted(&self) -> bool {
+            self.classify().is_resource_exhausted()
+        }
+
+        /// Return `true` if any stored error, or an error in its [`source()`](std::error::Error::source) chain, is:
+        ///
+        /// * classified as [`crate::Class::Retryable`], or
+        /// * classified as [`crate::Class::Io`] with kind `Interrupted` or `TimedOut`.
+        ///
+        /// Nested [`crate::Error`] values are inspected recursively. `false` only means that no known retryable error was
+        /// found; it does not guarantee that retrying cannot succeed.
+        pub fn can_retry(&self) -> bool {
+            self.classify().can_retry()
+        }
+
+        /// Apply [`Self::can_retry()`], also accepting [`std::io::Error`] with kind `UnexpectedEof`, `OutOfMemory`,
+        /// `BrokenPipe`, `AddrInUse`, `ConnectionAborted`, `ConnectionReset`, or `ConnectionRefused`.
+        ///
+        /// This applies a more lenient policy than [`Self::can_retry`]. Nested [`crate::Error`] values are inspected recursively.
+        /// `false` only means that no known retryable error was found; it does not guarantee that retrying cannot succeed.
+        pub fn can_retry_lenient(&self) -> bool {
+            self.classify().can_retry_lenient()
+        }
+
+        /// Return `true` if malformed or internally inconsistent data caused the failure.
+        pub fn is_corrupted(&self) -> bool {
+            self.classify().is_corrupted()
+        }
+
+        /// Return `true` if a requested resource was not found.
+        pub fn is_not_found(&self) -> bool {
+            self.classify().is_not_found()
+        }
+
+        /// Return `true` if invalid input caused the failure.
+        pub fn is_validation(&self) -> bool {
+            self.classify().is_validation()
+        }
+    };
+}
+
 /// A borrowed error together with its optional caller location, intended for diagnostic display.
 ///
-/// Errors owned by a [`crate::Frame`] have the location captured when that frame was created. Native
+/// Errors owned by a [`crate::exn::Frame`] have the location captured when that frame was created. The first real source
+/// beneath transparent classification markers inherits their frame's location. Other native
 /// [`std::error::Error::source()`] values have no location because no caller location was captured for them.
 ///
-/// Unlike [`crate::Frame`], this type neither owns the error nor represents relationships in an error tree. This lets
+/// Unlike [`crate::exn::Frame`], this type neither owns the error nor represents relationships in an error tree. This lets
 /// [`crate::Error::iter_errors_with_locations()`] provide the same lightweight view for the tree-backed and flattened-chain
 /// representations.
 ///
@@ -21,7 +83,7 @@ impl<'a> DisplaySource<'a> {
         self.error
     }
 
-    /// Return the caller location captured for this error frame, or `None` for a native error source.
+    /// Return the captured or inherited caller location, or `None` for an ordinary native error source.
     pub fn location(&self) -> Option<&'static std::panic::Location<'static>> {
         self.location
     }
@@ -40,78 +102,60 @@ impl std::fmt::Display for DisplaySource<'_> {
 }
 
 impl crate::Error {
-    /// Find the first stored error or native source that downcasts to `T` in logical breadth-first order.
-    pub fn downcast_any_ref<T: std::error::Error + 'static>(&self) -> Option<&T> {
-        self.iter_errors().find_map(|error| error.downcast_ref())
-    }
-
-    /// Return all known classifications in the same logical breadth-first order as [`Self::iter_errors()`].
+    /// Lazily visit stored errors and native sources in logical breadth-first order, expanding nested [`crate::Error`] values.
     ///
-    /// Unknown errors are omitted. Classifications aren't deduplicated because distinct errors may independently have
-    /// the same meaning. Each item retains the classified error for downcasting and origin inspection.
-    pub fn classify(&self) -> impl Iterator<Item = Classification<'_>> + '_ {
-        self.iter_errors().filter_map(classify_one)
+    /// The stored error is first unless it is a classification marker. A frame's native source precedes its explicitly
+    /// raised children. Concrete error types remain available for downcasting, except for classification markers,
+    /// which are always transparent to traversal.
+    /// Use [`Self::classify()`] to inspect classifications.
+    pub fn iter_errors(&self) -> impl Iterator<Item = &(dyn std::error::Error + 'static)> + '_ {
+        self.iter_errors_with_locations().map(|source| source.error)
     }
 
-    /// Return `true` if any stored error or native source is explicitly marked with [`crate::RetryableError`].
-    ///
-    /// Nested [`crate::Error`] values are inspected recursively. Unlike [`Self::can_retry()`], this does not infer
-    /// retryability from I/O error kinds.
-    pub fn is_retryable(&self) -> bool {
-        self.classify()
-            .any(|classification| classification.class() == Class::Retryable)
+    /// Visit the same errors as [`Self::iter_errors()`], with caller locations for explicitly raised frames.
+    /// The first real source beneath transparent classification markers inherits their frame's location; other native
+    /// sources have no caller location of their own. [`DisplaySource`] can render either representation.
+    pub fn iter_errors_with_locations(&self) -> impl Iterator<Item = DisplaySource<'_>> + '_ {
+        Errors::new(self.iter_root()).filter(|source| !is_transparent_marker(source.error))
     }
 
-    /// Return `true` if any stored error or native source reports resource exhaustion.
-    ///
-    /// This recognizes [`crate::ResourceExhaustionError`] of any kind, [`std::collections::TryReserveError`], and
-    /// [`std::io::ErrorKind::OutOfMemory`], including within nested [`crate::Error`] values.
-    pub fn is_resource_exhausted(&self) -> bool {
-        self.classify()
-            .any(|classification| matches!(classification.class(), Class::ResourceExhaustion(_)))
+    /// Find the first diagnostic error that downcasts to `T` in logical breadth-first order.
+    /// Classification markers are omitted, as in [`Self::iter_errors()`].
+    pub fn downcast_any_ref<T: std::error::Error + 'static>(&self) -> Option<&T> {
+        self.iter_errors().find_map(|error| error.downcast_ref())
     }
 
-    /// Return `true` if any stored error, or an error in its [`source()`](std::error::Error::source) chain, is:
+    /// Follow the unique causal path to a leaf or aggregate, as in [`crate::exn::Frame::probable_cause()`].
     ///
-    /// * explicitly marked with [`RetryableError`](crate::RetryableError), or
-    /// * an [`std::io::Error`] with kind `Interrupted` or `TimedOut`.
-    ///
-    /// Nested [`crate::Error`] values are inspected recursively. `false` only means that no known retryable error was
-    /// found; it does not guarantee that retrying cannot succeed.
-    pub fn can_retry(&self) -> bool {
-        self.classify()
-            .any(|classification| class_can_retry(classification.class()))
+    /// Classification markers are always transparent to selection. Nested error graphs and explicitly raised children
+    /// both participate, so a selected boundary at a branch is not replaced by one of its nested causes.
+    /// If selection stays at the root, return the stored error, including a classification-only root.
+    pub fn probable_cause(&self) -> &(dyn std::error::Error + 'static) {
+        self.iter_root().probable_cause().unwrap_or_else(|| self.error())
     }
 
-    /// Return `true` if any stored error, or an error in its [`source()`](std::error::Error::source) chain, is:
-    ///
-    /// * explicitly marked with [`RetryableError`](crate::RetryableError), or
-    /// * an [`std::io::Error`] with kind `Interrupted`, `UnexpectedEof`, `OutOfMemory`, `TimedOut`, `BrokenPipe`,
-    ///   `AddrInUse`, `ConnectionAborted`, `ConnectionReset`, or `ConnectionRefused`.
+    /// Visit the non-empty [`Metadata`] dictionaries of [`crate::Message`] contexts in error traversal order.
+    /// Dictionaries remain separate. Functions returning metadata document the keys in each context.
     ///
-    /// This applies a more lenient policy than [`Self::can_retry`]. Nested [`crate::Error`] values are inspected recursively.
-    /// `false` only means that no known retryable error was found; it does not guarantee that retrying cannot succeed.
-    pub fn can_retry_lenient(&self) -> bool {
-        self.classify().any(classification_can_retry_lenient)
+    /// To match a class and values on the same message, use [`Self::classify()`] and
+    /// [`Classification::error()`](crate::types::Classification::error) instead of combining independent classification
+    /// and metadata searches.
+    pub fn metadata(&self) -> impl Iterator<Item = &Metadata> + '_ {
+        self.iter_errors()
+            .filter_map(|error| error.downcast_ref::<crate::Message>())
+            .map(|error| &error.values)
+            .filter(|values| !values.is_empty())
     }
 
-    /// Return `true` if malformed or internally inconsistent data caused the failure.
-    pub fn is_corrupted(&self) -> bool {
-        self.classify()
-            .any(|classification| classification.class() == Class::Corruption)
-    }
-
-    /// Return `true` if a requested resource was not found.
-    pub fn is_not_found(&self) -> bool {
-        self.classify()
-            .any(|classification| classification.class() == Class::NotFound)
+    /// Return all known classifications in the same logical breadth-first order as [`Self::iter_errors()`].
+    ///
+    /// Unknown errors are omitted. Classifications aren't deduplicated because distinct errors may independently have
+    /// the same meaning. Each item retains the classified error for downcasting and origin inspection.
+    pub fn classify(&self) -> Classifications<'_> {
+        classify(self)
     }
 
-    /// Return `true` if invalid input caused the failure.
-    pub fn is_validation(&self) -> bool {
-        self.classify()
-            .any(|classification| classification.class() == Class::Validation)
-    }
+    classification_predicates!();
 }
 
 /// Classification helpers for inspecting an exception without consuming it or losing its typed outer error.
@@ -126,73 +170,11 @@ impl<E: std::error::Error + Send + Sync + 'static> crate::Exn<E> {
     ///
     /// As with [`crate::Error::classify()`], unknown errors are omitted, classifications aren't deduplicated, and each
     /// item retains the classified error for downcasting and origin inspection.
-    pub fn classify(&self) -> impl Iterator<Item = Classification<'_>> + '_ {
-        self.frame()
-            .collect_errors_with_locations()
-            .into_iter()
-            .filter_map(|source| classify_one(source.error()))
+    pub fn classify(&self) -> Classifications<'_> {
+        Classifications(Errors::new(Node::Frame(self.frame())))
     }
 
-    /// Apply the conservative retry policy of [`crate::Error::can_retry()`] without consuming this exception.
-    ///
-    /// This inspects stored errors, native sources, and nested [`crate::Error`] values for explicit retry markers or
-    /// I/O errors with kind `Interrupted` or `TimedOut`. `false` does not guarantee that retrying cannot succeed.
-    pub fn can_retry(&self) -> bool {
-        self.classify()
-            .any(|classification| class_can_retry(classification.class()))
-    }
-
-    /// Apply the broader I/O retry policy of [`crate::Error::can_retry_lenient()`] without consuming this exception.
-    ///
-    /// This inspects stored errors, native sources, and nested [`crate::Error`] values. `false` does not guarantee that
-    /// retrying cannot succeed.
-    pub fn can_retry_lenient(&self) -> bool {
-        self.classify().any(classification_can_retry_lenient)
-    }
-
-    /// Return `true` if any stored error or native source is explicitly marked with [`crate::RetryableError`].
-    ///
-    /// Nested [`crate::Error`] values are inspected recursively. Unlike [`Self::can_retry()`], this does not
-    /// infer retryability from I/O error kinds.
-    pub fn is_retryable(&self) -> bool {
-        self.any_class(|class| class == Class::Retryable)
-    }
-
-    /// Return `true` if any stored error or native source reports a missing resource.
-    ///
-    /// This recognizes [`crate::NotFoundError`] and [`std::io::ErrorKind::NotFound`], including within nested
-    /// [`crate::Error`] values. It does not require the outermost error to have this classification.
-    pub fn is_not_found(&self) -> bool {
-        self.any_class(|class| class == Class::NotFound)
-    }
-
-    /// Return `true` if any stored error or native source is a [`crate::ValidationError`].
-    ///
-    /// Nested [`crate::Error`] values are inspected recursively. It does not require the outermost error to have this
-    /// classification.
-    pub fn is_validation(&self) -> bool {
-        self.any_class(|class| class == Class::Validation)
-    }
-
-    /// Return `true` if any stored error or native source is a [`crate::CorruptionError`].
-    ///
-    /// Nested [`crate::Error`] values are inspected recursively. It does not require the outermost error to have this
-    /// classification.
-    pub fn is_corrupted(&self) -> bool {
-        self.any_class(|class| class == Class::Corruption)
-    }
-
-    /// Return `true` if any stored error or native source reports resource exhaustion.
-    ///
-    /// This recognizes [`crate::ResourceExhaustionError`] of any kind, [`std::collections::TryReserveError`], and
-    /// [`std::io::ErrorKind::OutOfMemory`], including within nested [`crate::Error`] values.
-    pub fn is_resource_exhausted(&self) -> bool {
-        self.any_class(|class| matches!(class, Class::ResourceExhaustion(_)))
-    }
-
-    fn any_class(&self, predicate: impl Fn(Class) -> bool) -> bool {
-        self.classify().any(|classification| predicate(classification.class()))
-    }
+    classification_predicates!();
 }
 
 /// The semantic class of an error.
@@ -211,6 +193,11 @@ pub enum Class {
     ResourceExhaustion(crate::ResourceExhaustionKind),
     /// An I/O failure not normalized to another semantic class.
     Io(std::io::ErrorKind),
+    /// An operation-specific condition identified by a stable, namespaced string.
+    ///
+    /// Functions returning this class document their tags. Tags imply no other classification;
+    /// match them with [`Classifications::has()`] instead of inspecting diagnostic text or metadata.
+    Tagged(&'static str),
 }
 
 /// A semantic class together with the concrete error which established it.
@@ -220,6 +207,76 @@ pub struct Classification<'a> {
     error: &'a (dyn std::error::Error + 'static),
 }
 
+/// Lazily inspect the classifications of any borrowed error, including its native sources, I/O payloads and nested
+/// [`crate::Error`] values. Unknown errors are omitted and distinct causes may yield the same classification.
+///
+/// ```
+/// let error = std::io::Error::other(gix_error::not_found("missing object"));
+/// assert!(gix_error::classify(&error).is_not_found());
+/// ```
+pub fn classify<'a>(err: &'a (dyn std::error::Error + 'static)) -> Classifications<'a> {
+    Classifications(Errors::new(err.downcast_ref::<crate::Error>().map_or(
+        Node::Source {
+            error: err,
+            location: None,
+        },
+        crate::Error::iter_root,
+    )))
+}
+
+/// A lazy iterator over classified causes. Its predicates consume the remaining iterator and stop at the first match.
+pub struct Classifications<'a>(Errors<'a>);
+
+impl<'a> Iterator for Classifications<'a> {
+    type Item = Classification<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.find_map(|source| classify_one(source.error))
+    }
+}
+
+impl Classifications<'_> {
+    /// Return whether any remaining cause is explicitly marked as retryable.
+    pub fn is_retryable(self) -> bool {
+        self.has(Class::Retryable)
+    }
+
+    /// Apply the conservative retry policy of [`crate::Error::can_retry()`] to the remaining causes.
+    pub fn can_retry(mut self) -> bool {
+        self.any(|classification| class_can_retry(classification.class()))
+    }
+
+    /// Apply the broader I/O policy of [`crate::Error::can_retry_lenient()`] to the remaining causes.
+    pub fn can_retry_lenient(mut self) -> bool {
+        self.any(classification_can_retry_lenient)
+    }
+
+    /// Return whether any remaining cause reports a missing resource.
+    pub fn is_not_found(self) -> bool {
+        self.has(Class::NotFound)
+    }
+
+    /// Return whether any remaining cause reports invalid input.
+    pub fn is_validation(self) -> bool {
+        self.has(Class::Validation)
+    }
+
+    /// Return whether any remaining cause reports malformed or inconsistent data.
+    pub fn is_corrupted(self) -> bool {
+        self.has(Class::Corruption)
+    }
+
+    /// Return whether any remaining cause reports resource exhaustion.
+    pub fn is_resource_exhausted(mut self) -> bool {
+        self.any(|classification| matches!(classification.class(), Class::ResourceExhaustion(_)))
+    }
+
+    /// Return whether any remaining cause has exactly `class`, including its tag for [`Class::Tagged`].
+    pub fn has(mut self, class: Class) -> bool {
+        self.any(|classification| classification.class() == class)
+    }
+}
+
 impl<'a> Classification<'a> {
     /// Return the semantic class.
     pub fn class(&self) -> Class {
@@ -238,16 +295,10 @@ impl<'a> Classification<'a> {
 }
 
 fn classify_one<'a>(error: &'a (dyn std::error::Error + 'static)) -> Option<Classification<'a>> {
-    let class = if error.is::<crate::ValidationError>() {
-        Class::Validation
-    } else if error.is::<crate::CorruptionError>() {
-        Class::Corruption
-    } else if error.is::<crate::NotFoundError>() {
-        Class::NotFound
-    } else if error.is::<crate::RetryableError>() {
-        Class::Retryable
-    } else if let Some(error) = error.downcast_ref::<crate::ResourceExhaustionError>() {
-        Class::ResourceExhaustion(error.kind())
+    let class = if let Some(marker) = error.downcast_ref::<crate::ClassificationMarker>() {
+        marker.class()
+    } else if let Some(error) = error.downcast_ref::<crate::Message>() {
+        error.class?
     } else if error.is::<std::collections::TryReserveError>() {
         Class::ResourceExhaustion(crate::ResourceExhaustionKind::AllocationFailure)
     } else {
@@ -287,70 +338,194 @@ fn classification_can_retry_lenient(classification: Classification<'_>) -> bool
         })
 }
 
+#[derive(Clone, Copy)]
+enum Node<'a> {
+    Frame(&'a crate::exn::Frame),
+    Source {
+        error: &'a (dyn std::error::Error + 'static),
+        location: Option<&'static std::panic::Location<'static>>,
+    },
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    Chain {
+        node: &'a crate::types::ChainedError,
+        index: usize,
+        cursor: Option<usize>,
+    },
+}
+
+impl<'a> Node<'a> {
+    fn display(self) -> DisplaySource<'a> {
+        let (error, location) = match self {
+            Node::Frame(frame) => (
+                frame.error() as &(dyn std::error::Error + 'static),
+                Some(frame.location()),
+            ),
+            Node::Source { error, location } => (error, location),
+            #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+            Node::Chain { node, .. } => (node.err.error(), node.err.has_frame_location().then_some(node.location)),
+        };
+        DisplaySource { error, location }
+    }
+
+    fn children(self) -> std::collections::VecDeque<Node<'a>> {
+        // Cause selection follows a path rather than breadth-first order, so each query needs its own chain cursor.
+        #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+        let root = match self {
+            Node::Chain { node, index, .. } => Node::Chain {
+                node,
+                index,
+                cursor: None,
+            },
+            root => root,
+        };
+        #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+        let root = self;
+        let mut traversal = Errors::new(root);
+        traversal.children(root);
+        traversal.pending
+    }
+
+    fn probable_cause(self) -> Option<&'a (dyn std::error::Error + 'static)> {
+        let mut node = self;
+        // Track traversal, not error addresses: a native source can share its owner's address.
+        let mut cause = None;
+        loop {
+            let mut pending = node.children();
+            let mut only_child = None;
+            while let Some(child) = pending.pop_front() {
+                if is_transparent_marker(child.display().error) {
+                    // Marker frames (including nested boundaries storing markers) are transparent, not dead ends.
+                    pending.extend(child.children());
+                } else if only_child.replace(child).is_some() {
+                    return cause;
+                }
+            }
+            node = match only_child {
+                Some(child) => child,
+                None => return cause,
+            };
+            cause = Some(node.display().error);
+        }
+    }
+}
+
+struct Errors<'a> {
+    root: Option<Node<'a>>,
+    previous: Option<Node<'a>>,
+    pending: std::collections::VecDeque<Node<'a>>,
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    chains: Vec<(usize, Option<&'a crate::types::ChainedError>)>,
+}
+
+impl<'a> Errors<'a> {
+    fn new(root: Node<'a>) -> Self {
+        Errors {
+            root: Some(root),
+            previous: None,
+            pending: Default::default(),
+            #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+            chains: Vec::new(),
+        }
+    }
+
+    fn source(
+        &mut self,
+        error: &'a (dyn std::error::Error + 'static),
+        location: Option<&'static std::panic::Location<'static>>,
+    ) {
+        if let Some(error) = error.downcast_ref::<crate::Error>() {
+            self.pending.push_back(error.iter_root());
+        } else if let Some(source) = native_source(error) {
+            self.pending.push_back(Node::Source {
+                error: source,
+                location: location.filter(|_| is_transparent_marker(error)),
+            });
+        }
+    }
+
+    fn children(&mut self, node: Node<'a>) {
+        match node {
+            Node::Frame(frame) => {
+                self.source(frame.error(), Some(frame.location()));
+                self.pending.extend(frame.children().iter().map(Node::Frame));
+            }
+            Node::Source { error, location } => self.source(error, location),
+            #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+            Node::Chain { node, index, cursor } => {
+                if let Some(error) = node.err.error().downcast_ref::<crate::Error>() {
+                    self.pending.push_back(error.iter_root());
+                }
+                let cursor = match cursor {
+                    Some(cursor) => cursor,
+                    None if node.source.is_none() => return,
+                    None => {
+                        self.chains.push((index + 1, node.source.as_deref()));
+                        self.chains.len() - 1
+                    }
+                };
+                // Flattened parents occur in increasing order. One cursor per boundary streams each child once,
+                // even when other error trees are interleaved at their logical breadth-first positions.
+                let (child_index, next) = &mut self.chains[cursor];
+                // A fresh cursor for cause selection can start among siblings belonging to earlier parents.
+                while let Some(child) = next.filter(|child| child.logical_parent.is_some_and(|parent| parent < index)) {
+                    *child_index += 1;
+                    *next = child.source.as_deref();
+                }
+                while let Some(child) = next.filter(|child| child.logical_parent == Some(index)) {
+                    self.pending.push_back(Node::Chain {
+                        node: child,
+                        index: *child_index,
+                        cursor: Some(cursor),
+                    });
+                    *child_index += 1;
+                    *next = child.source.as_deref();
+                }
+            }
+        }
+    }
+}
+
+impl<'a> Iterator for Errors<'a> {
+    type Item = DisplaySource<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Defer expansion until the caller asks for another error, so a match need not inspect any of its causes.
+        if let Some(previous) = self.previous.take() {
+            self.children(previous);
+        }
+        let node = self.root.take().or_else(|| self.pending.pop_front())?;
+        self.previous = Some(node);
+        Some(node.display())
+    }
+}
+
+impl crate::exn::Frame {
+    pub(crate) fn probable_cause_inner(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Node::Frame(self).probable_cause()
+    }
+
+    pub(crate) fn iter_errors_with_locations(&self) -> impl Iterator<Item = DisplaySource<'_>> + '_ {
+        Errors::new(Node::Frame(self)).filter(|source| !is_transparent_marker(source.error))
+    }
+}
+
 #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
 mod _impl {
-    use crate::{DisplaySource, Error, Exn};
+    use crate::{Error, Exn};
     use std::fmt::Formatter;
 
     /// Utilities
     impl Error {
         /// Return the error stored at this error boundary.
         ///
-        /// This is the first error yielded by [`Self::iter_errors()`] and is distinct from
+        /// This can be a classification marker hidden from [`Self::iter_errors()`], and is distinct from
         /// [`Self::probable_cause()`].
         pub fn error(&self) -> &(dyn std::error::Error + 'static) {
             self.inner.frame().error()
         }
 
-        /// Return the error that is most likely the root cause, based on heuristics.
-        /// Note that if there is nothing but this error, i.e. no source or children, this error is returned.
-        pub fn probable_cause(&self) -> &(dyn std::error::Error + 'static) {
-            let root = self.inner.frame();
-            let cause = root.probable_cause().unwrap_or_else(|| root.error());
-            cause.downcast_ref::<Error>().map_or(cause, Error::probable_cause)
-        }
-
-        /// Return the stored error and all frame errors and native sources reachable from it, recursively expanding nested
-        /// [`Error`] values.
-        ///
-        /// The first item is the error stored inside this [`Error`], not this `Error` wrapper. Remaining errors are ordered
-        /// logically breadth-first; a frame's direct native source precedes its explicitly raised child frames.
-        /// These are references to the underlying errors, so their concrete types remain available for *downcasting* and
-        /// their own [`Display`](std::fmt::Display) implementations can be used. Use
-        /// [`Self::iter_errors_with_locations()`] to access caller locations.
-        pub fn iter_errors(&self) -> impl Iterator<Item = &(dyn std::error::Error + 'static)> + '_ {
-            self.collect_errors_with_locations()
-                .into_iter()
-                .map(|source| source.error)
-        }
-
-        /// Return the same errors as [`Self::iter_errors()`], paired with their captured caller locations where available
-        /// and in the same order.
-        pub fn iter_errors_with_locations(&self) -> impl Iterator<Item = DisplaySource<'_>> + '_ {
-            self.collect_errors_with_locations().into_iter()
-        }
-
-        fn collect_errors_with_locations(&self) -> Vec<DisplaySource<'_>> {
-            self.inner.frame().collect_errors_with_locations()
-        }
-    }
-
-    impl crate::Frame {
-        pub(crate) fn collect_errors_with_locations(&self) -> Vec<DisplaySource<'_>> {
-            let mut queue = std::collections::VecDeque::from([crate::exn::ErrorNode::Frame(self)]);
-            let mut out = Vec::new();
-            while let Some(node) = queue.pop_front() {
-                let error = node.error();
-                out.push(DisplaySource {
-                    error,
-                    location: node.captured_location(),
-                });
-                if let Some(error) = error.downcast_ref::<Error>() {
-                    queue.push_back(crate::exn::ErrorNode::Frame(error.inner.frame()));
-                }
-                queue.extend(node.children());
-            }
-            out
+        pub(super) fn iter_root(&self) -> super::Node<'_> {
+            super::Node::Frame(self.inner.frame())
         }
     }
 
@@ -379,7 +554,7 @@ mod _impl {
         /// Create a new instance representing an already boxed `error`.
         #[track_caller]
         pub fn from_boxed(error: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
-            Self::from_error(crate::Untyped::from_boxed(error))
+            Self::from_error(crate::exn::Untyped::from_boxed(error))
         }
     }
 
@@ -408,7 +583,7 @@ mod _impl {
                 Inner::ExnAsError(frame) | Inner::Exn(frame) => {
                     let error = frame.error();
                     (!error.is::<Error>())
-                        .then(|| error.source())
+                        .then(|| super::native_source(error))
                         .flatten()
                         .or_else(|| frame.children().first().map(|frame| frame.error() as _))
                 }
@@ -432,164 +607,25 @@ pub(super) use _impl::Inner;
 
 #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
 mod _impl {
-    use crate::{DisplaySource, Error, Exn};
+    use crate::{Error, Exn};
     use std::fmt::Formatter;
 
-    /// A temporary adjacency-list node used to recover the logical error graph from flattened [`crate::ChainedError`]
-    /// values.
-    ///
-    /// Auto-chain storage is a linked list for compatibility with [`std::error::Error::source()`]. The iteration APIs
-    /// rebuild its retained parent relationships in a `Vec<ErrorGraphNode>` so nested [`Error`] values can join the same
-    /// breadth-first traversal without changing that source-chain representation.
-    struct ErrorGraphNode<'a> {
-        /// The borrowed error and optional frame location yielded for this node.
-        source: DisplaySource<'a>,
-        /// Indices of logical children in the temporary node vector, in traversal order.
-        children: Vec<usize>,
-    }
-
-    /// Expand nested [`Error`] values, then collect the graph's errors and locations breadth-first from `root`.
-    ///
-    /// `nested` pairs each wrapper's index in `graph` with the error whose stored chain still needs to be added.
-    /// Each nested chain's root becomes the wrapper's first child, before its existing children, matching tree-backed
-    /// traversal. Newly discovered nested errors are expanded in turn before collecting the output.
-    ///
-    /// Expanding the graph first lets nested errors participate at their logical depth: simply splicing their flattened
-    /// chains into the output would visit their descendants before shallower errors elsewhere in the graph.
-    fn collect_graph_errors<'a>(
-        mut graph: Vec<ErrorGraphNode<'a>>,
-        root: usize,
-        nested: Vec<(usize, &'a Error)>,
-    ) -> Vec<DisplaySource<'a>> {
-        let mut pending = std::collections::VecDeque::from(nested);
-        while let Some((parent, error)) = pending.pop_front() {
-            let (nested_root, more_nested) = error.append_error_chain(&mut graph);
-            graph[parent].children.insert(0, nested_root);
-            pending.extend(more_nested);
-        }
-
-        let mut queue = std::collections::VecDeque::from([root]);
-        let mut out = Vec::new();
-        while let Some(index) = queue.pop_front() {
-            let node = &graph[index];
-            out.push(node.source);
-            queue.extend(node.children.iter().copied());
-        }
-        out
-    }
-
-    impl crate::Frame {
-        pub(crate) fn collect_errors_with_locations(&self) -> Vec<DisplaySource<'_>> {
-            let mut graph: Vec<ErrorGraphNode<'_>> = Vec::new();
-            let mut nested = Vec::new();
-            let mut queue = std::collections::VecDeque::from([(crate::exn::ErrorNode::Frame(self), None::<usize>)]);
-            while let Some((node, parent)) = queue.pop_front() {
-                let index = graph.len();
-                let error = node.error();
-                graph.push(ErrorGraphNode {
-                    source: DisplaySource {
-                        error,
-                        location: node.captured_location(),
-                    },
-                    children: Vec::new(),
-                });
-                if let Some(parent) = parent {
-                    graph[parent].children.push(index);
-                }
-                if let Some(error) = error.downcast_ref::<Error>() {
-                    nested.push((index, error));
-                }
-                queue.extend(node.children().into_iter().map(|child| (child, Some(index))));
-            }
-            collect_graph_errors(graph, 0, nested)
-        }
-    }
-
     /// Utilities
     impl Error {
         /// Return the error stored at this error boundary.
         ///
-        /// This is the first error yielded by [`Self::iter_errors()`] and is distinct from
+        /// This can be a classification marker hidden from [`Self::iter_errors()`], and is distinct from
         /// [`Self::probable_cause()`].
         pub fn error(&self) -> &(dyn std::error::Error + 'static) {
             self.inner.err.error()
         }
 
-        /// Return the error that is most likely the root cause, based on heuristics.
-        /// Note that if there is nothing but this error, i.e. no source or children, this error is returned.
-        pub fn probable_cause(&self) -> &(dyn std::error::Error + 'static) {
-            let cause = std::iter::successors(Some(&self.inner), |err| err.source.as_deref())
-                .find(|err| err.is_probable_cause)
-                .map_or(self as &(dyn std::error::Error + 'static), |err| err.err.error());
-            cause.downcast_ref::<Error>().map_or(cause, Error::probable_cause)
-        }
-
-        /// Return the stored error and all frame errors and native sources reachable from it, recursively expanding nested
-        /// [`Error`] values.
-        ///
-        /// The first item is the error stored inside this [`Error`], not this `Error` wrapper. Remaining errors retain the
-        /// logical breadth-first order captured while flattening; a frame's direct native source precedes its
-        /// explicitly raised child frames. These are references to the underlying errors, so their concrete types remain
-        /// available for downcasting and their own [`Display`](std::fmt::Display) implementations can be used. Use
-        /// [`Self::iter_errors_with_locations()`] to access caller locations.
-        pub fn iter_errors(&self) -> impl Iterator<Item = &(dyn std::error::Error + 'static)> + '_ {
-            self.collect_errors_with_locations()
-                .into_iter()
-                .map(|source| source.error)
-        }
-
-        /// Return the same errors as [`Self::iter_errors()`], paired with their captured caller locations where available
-        /// and in the same order.
-        ///
-        /// The stored error, rather than this `Error` wrapper, is the first item. Frame errors have the location
-        /// captured when their frame was created; native sources have no caller location of their own. This enables opt-in
-        /// caller traces without making locations part of the underlying errors or their
-        /// [`Display`](std::fmt::Display) implementations. Each [`DisplaySource`] exposes both values for custom rendering,
-        /// and its own [`Display`](std::fmt::Display) implementation appends an available location by default.
-        pub fn iter_errors_with_locations(&self) -> impl Iterator<Item = DisplaySource<'_>> + '_ {
-            self.collect_errors_with_locations().into_iter()
-        }
-
-        fn collect_errors_with_locations(&self) -> Vec<DisplaySource<'_>> {
-            let mut graph = Vec::new();
-            let (root, nested) = self.append_error_chain(&mut graph);
-            collect_graph_errors(graph, root, nested)
-        }
-
-        /// Append this error boundary's flattened chain to `graph` and reconstruct its local parent-child relationships.
-        ///
-        /// The first tuple value is the graph index of the stored error. Each entry in the second value contains the graph
-        /// index of a node whose error is another [`Error`], paired with that nested boundary. The caller appends those
-        /// nested chains iteratively and connects each returned root as the wrapper node's first child, avoiding recursive
-        /// graph construction before the completed graph is traversed breadth-first.
-        fn append_error_chain<'a>(&'a self, graph: &mut Vec<ErrorGraphNode<'a>>) -> (usize, Vec<(usize, &'a Error)>) {
-            let chain = std::iter::successors(Some(&self.inner), |err| err.source.as_deref()).collect::<Vec<_>>();
-            let root = graph.len();
-            graph.extend(chain.iter().map(|chained| ErrorGraphNode {
-                source: DisplaySource {
-                    error: chained.err.error(),
-                    location: (!chained.err.is_native_source()).then_some(chained.location),
-                },
-                children: Vec::new(),
-            }));
-
-            for (index, chained) in chain.iter().enumerate() {
-                if let Some(parent) = chained.logical_parent {
-                    graph[root + parent].children.push(root + index);
-                }
+        pub(super) fn iter_root(&self) -> super::Node<'_> {
+            super::Node::Chain {
+                node: &self.inner,
+                index: 0,
+                cursor: None,
             }
-            let nested = chain
-                .into_iter()
-                .enumerate()
-                .filter_map(|(index, chained)| {
-                    chained
-                        .err
-                        .error()
-                        .downcast_ref::<Error>()
-                        .map(|error| (root + index, error))
-                })
-                .collect();
-            (root, nested)
         }
     }
 
@@ -605,18 +641,28 @@ mod _impl {
         /// Create a new instance representing an already boxed `error`.
         #[track_caller]
         pub fn from_boxed(error: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
-            Self::from_error(crate::Untyped::from_boxed(error))
+            Self::from_error(crate::exn::Untyped::from_boxed(error))
         }
     }
 
     impl std::fmt::Display for Error {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            if super::is_transparent_marker(self.error())
+                && let Some(diagnostic) = self.iter_errors_with_locations().next()
+            {
+                return std::fmt::Display::fmt(&diagnostic, f);
+            }
             std::fmt::Display::fmt(&self.inner, f)
         }
     }
 
     impl std::fmt::Debug for Error {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            if super::is_transparent_marker(self.error())
+                && let Some(diagnostic) = self.iter_errors().next()
+            {
+                return std::fmt::Debug::fmt(diagnostic, f);
+            }
             std::fmt::Debug::fmt(&self.inner, f)
         }
     }
@@ -640,37 +686,19 @@ mod _impl {
     }
 }
 
-/// Return `true` if `err` or any error in its [`source()`](std::error::Error::source) chain is explicitly marked with
-/// [`RetryableError`](crate::RetryableError), or is an [`std::io::Error`] whose kind is `Interrupted` or `TimedOut`.
-///
-/// Nested [`crate::Error`] values are inspected recursively. `false` only means that no known retryable error was found; it
-/// does not guarantee that retrying cannot succeed.
-pub fn can_retry(err: &(dyn std::error::Error + 'static)) -> bool {
-    error_chain(err).any(|err| {
-        if let Some(err) = err.downcast_ref::<crate::Error>() {
-            return err.can_retry();
-        }
-        classify_one(err).is_some_and(|classification| class_can_retry(classification.class()))
-    })
-}
-
-/// Return `true` if `err` or any error in its [`source()`](std::error::Error::source) chain is explicitly marked with
-/// [`RetryableError`](crate::RetryableError), or is an [`std::io::Error`] whose kind is `Interrupted`, `UnexpectedEof`,
-/// `OutOfMemory`, `TimedOut`, `BrokenPipe`, `AddrInUse`, `ConnectionAborted`, `ConnectionReset`, or `ConnectionRefused`.
-///
-/// This applies a more lenient policy than [`can_retry`]. Nested [`crate::Error`] values are inspected recursively.
-/// `false` only means that no known retryable error was found; it does not guarantee that retrying cannot succeed.
-pub fn can_retry_lenient(err: &(dyn std::error::Error + 'static)) -> bool {
-    error_chain(err).any(|err| {
-        if let Some(err) = err.downcast_ref::<crate::Error>() {
-            return err.can_retry_lenient();
-        }
-        classify_one(err).is_some_and(classification_can_retry_lenient)
-    })
+/// Retain I/O payloads, which `std::io::Error::source()` skips even when they carry a classification or an error tree.
+pub(crate) fn native_source<'a>(
+    err: &'a (dyn std::error::Error + 'static),
+) -> Option<&'a (dyn std::error::Error + 'static)> {
+    match err.downcast_ref::<std::io::Error>() {
+        Some(err) => err.get_ref().map(|err| err as _),
+        None => err.source(),
+    }
 }
 
-fn error_chain<'a>(
-    err: &'a (dyn std::error::Error + 'static),
-) -> impl Iterator<Item = &'a (dyn std::error::Error + 'static)> {
-    std::iter::successors(Some(err), |err| err.source())
+pub(crate) fn is_transparent_marker(mut error: &(dyn std::error::Error + 'static)) -> bool {
+    while let Some(nested) = error.downcast_ref::<crate::Error>() {
+        error = nested.error();
+    }
+    error.is::<crate::ClassificationMarker>()
 }
diff --git a/gix-error/src/exn/ext.rs b/gix-error/src/exn/ext.rs
index cc21abf0bb2..e04defd4035 100644
--- a/gix-error/src/exn/ext.rs
+++ b/gix-error/src/exn/ext.rs
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::exn::Exn;
+use crate::{Exn, ExnResult};
 
 /// A trait bound of the supported error type of [`Exn`].
 pub trait ErrorExt: std::error::Error + Send + Sync + 'static {
@@ -75,13 +75,13 @@ pub trait OptionExt {
     type Some;
 
     /// Construct a new [`Exn`] on the `None` variant.
-    fn ok_or_raise<A, F>(self, err: F) -> Result<Self::Some, Exn<A>>
+    fn ok_or_raise<A, F>(self, err: F) -> ExnResult<Self::Some, A>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A;
 
     /// Construct a new [`Exn`] on the `None` variant, with type erasure.
-    fn ok_or_raise_erased<A, F>(self, err: F) -> Result<Self::Some, Exn>
+    fn ok_or_raise_erased<A, F>(self, err: F) -> ExnResult<Self::Some>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A;
@@ -91,7 +91,7 @@ impl<T> OptionExt for Option<T> {
     type Some = T;
 
     #[track_caller]
-    fn ok_or_raise<A, F>(self, err: F) -> Result<T, Exn<A>>
+    fn ok_or_raise<A, F>(self, err: F) -> ExnResult<T, A>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
@@ -103,7 +103,7 @@ impl<T> OptionExt for Option<T> {
     }
 
     #[track_caller]
-    fn ok_or_raise_erased<A, F>(self, err: F) -> Result<T, Exn>
+    fn ok_or_raise_erased<A, F>(self, err: F) -> ExnResult<T>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
@@ -123,7 +123,7 @@ pub trait ResultExt {
     /// Raise a new exception on the [`Exn`] inside the [`Result`].
     ///
     /// Apply [`Exn::raise`] on the `Err` variant, refer to it for more information.
-    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    fn or_raise<A, F>(self, err: F) -> ExnResult<Self::Success, A>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A;
@@ -131,12 +131,12 @@ pub trait ResultExt {
     /// Raise a new exception on the [`Exn`] inside the [`Result`], but erase its type.
     ///
     /// Apply [`Exn::erased`] on the `Err` variant, refer to it for more information.
-    fn or_erased(self) -> Result<Self::Success, Exn>;
+    fn or_erased(self) -> ExnResult<Self::Success>;
 
     /// Raise a new exception on the [`Exn`] inside the [`Result`], and type-erase the result.
     ///
     /// Apply [`Exn::raise`] and [`Exn::erased`] on the `Err` variant, refer to it for more information.
-    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    fn or_raise_erased<A, F>(self, err: F) -> ExnResult<Self::Success>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A;
@@ -150,7 +150,7 @@ where
     type Error = E;
 
     #[track_caller]
-    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    fn or_raise<A, F>(self, err: F) -> ExnResult<Self::Success, A>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
@@ -162,7 +162,7 @@ where
     }
 
     #[track_caller]
-    fn or_erased(self) -> Result<Self::Success, Exn> {
+    fn or_erased(self) -> ExnResult<Self::Success> {
         match self {
             Ok(v) => Ok(v),
             Err(e) => Err(Exn::new(e).erased()),
@@ -170,7 +170,7 @@ where
     }
 
     #[track_caller]
-    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    fn or_raise_erased<A, F>(self, err: F) -> ExnResult<Self::Success>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
@@ -187,22 +187,22 @@ pub trait BoxedResultExt {
     type Success;
 
     /// Type-erase the boxed error inside the [`Result`].
-    fn or_erased(self) -> Result<Self::Success, Exn>;
+    fn or_erased(self) -> ExnResult<Self::Success>;
 }
 
 impl<T> BoxedResultExt for Result<T, Box<dyn std::error::Error + Send + Sync + 'static>> {
     type Success = T;
 
     #[track_caller]
-    fn or_erased(self) -> Result<Self::Success, Exn> {
+    fn or_erased(self) -> ExnResult<Self::Success> {
         match self {
             Ok(v) => Ok(v),
-            Err(e) => Err(Exn::new(crate::Untyped::from_boxed(e))),
+            Err(e) => Err(Exn::new(crate::exn::Untyped::from_boxed(e))),
         }
     }
 }
 
-impl<T, E> ResultExt for Result<T, Exn<E>>
+impl<T, E> ResultExt for ExnResult<T, E>
 where
     E: std::error::Error + Send + Sync + 'static,
 {
@@ -210,7 +210,7 @@ where
     type Error = E;
 
     #[track_caller]
-    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    fn or_raise<A, F>(self, err: F) -> ExnResult<Self::Success, A>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
@@ -222,7 +222,7 @@ where
     }
 
     #[track_caller]
-    fn or_erased(self) -> Result<Self::Success, Exn> {
+    fn or_erased(self) -> ExnResult<Self::Success> {
         match self {
             Ok(v) => Ok(v),
             Err(e) => Err(e.erased()),
@@ -230,7 +230,7 @@ where
     }
 
     #[track_caller]
-    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    fn or_raise_erased<A, F>(self, err: F) -> ExnResult<Self::Success>
     where
         A: std::error::Error + Send + Sync + 'static,
         F: FnOnce() -> A,
diff --git a/gix-error/src/exn/impls.rs b/gix-error/src/exn/impls.rs
index 8f824263d07..a8770224d3b 100644
--- a/gix-error/src/exn/impls.rs
+++ b/gix-error/src/exn/impls.rs
@@ -20,7 +20,61 @@ use std::ops::Deref;
 use std::panic::Location;
 
 use crate::concrete::chain::ErrorHandle;
-use crate::{ChainedError, Exn, write_location};
+use crate::{Metadata, types::ChainedError, write_location};
+
+/// An exception type that can hold an [error tree](Exn::raise_all) and the call site.
+///
+/// While an error chain, a list, is automatically created when [raise](Exn::raise)
+/// and friends are invoked, one can also use [`Exn::raise_all`] to create an error
+/// that has multiple causes.
+///
+/// # Native error sources
+///
+/// Values reached through [`std::error::Error::source()`] remain owned by their original errors and are traversed by
+/// reference, preserving their concrete types. They aren't exception frames and therefore have no captured call site of
+/// their own.
+///
+/// In diagnostic reports, custom [`std::io::Error`] wrappers show their kind instead of repeating the payload's
+/// diagnostic. The payload is reported separately as a cause; both remain available for inspection and classification.
+///
+/// # `Exn` == `Exn<Untyped>`
+///
+/// `Exn` act's like `Box<dyn std::error::Error + Send + Sync + 'static>`, but with the capability
+/// to store a tree of errors along with their *call sites*.
+///
+/// # Visualisation
+///
+/// Linearized trees during display make a list of 3 children indistinguishable from
+/// 3 errors where each is the child of the other.
+///
+/// ## Debug
+///
+/// * locations: ✔️
+/// * error display: Display
+/// * tree mode: linearized
+///
+/// ## Debug + Alternate
+///
+/// * locations: ❌
+/// * error display: Display
+/// * tree mode: linearized
+///
+/// ## Display
+///
+/// * locations: ❌
+/// * error display: Debug
+/// * tree mode: None
+///
+/// ## Display + Alternate
+///
+/// * locations: ❌
+/// * error display: Debug
+/// * tree mode: verbatim
+pub struct Exn<E: std::error::Error + Send + Sync + 'static = Untyped> {
+    // trade one more indirection for less stack size
+    frame: Box<Frame>,
+    phantom: PhantomData<E>,
+}
 
 impl<E: Error + Send + Sync + 'static> From<E> for Exn<E> {
     #[track_caller]
@@ -166,7 +220,7 @@ impl<E: Error + Send + Sync + 'static> Exn<E> {
     /// but retains all type dynamic type information.
     ///
     /// This is useful for inter-op with `anyhow`.
-    pub fn into_chain(self) -> crate::ChainedError {
+    pub fn into_chain(self) -> ChainedError {
         self.into()
     }
 
@@ -181,25 +235,40 @@ impl<E: Error + Send + Sync + 'static> Exn<E> {
         self.frame().iter_frames()
     }
 
+    /// Lazily visit stored errors and native sources in logical breadth-first order, expanding nested [`crate::Error`] values.
+    /// [Classification-only markers](crate::ClassificationMarker) are skipped; other concrete types remain available for downcasting,
+    /// as with [`crate::Error::iter_errors()`].
+    pub fn iter_errors(&self) -> impl Iterator<Item = &(dyn Error + 'static)> + '_ {
+        self.frame.iter_errors_with_locations().map(|source| source.error())
+    }
+
+    /// Visit the non-empty [`Metadata`] dictionaries of [`crate::Message`] contexts in error traversal order.
+    /// Dictionaries remain separate. Functions returning metadata document the keys in each context.
+    ///
+    /// To match a class and values on the same message, use [`Self::classify()`] and
+    /// [`Classification::error()`](crate::types::Classification::error) instead of combining independent classification
+    /// and metadata searches.
+    pub fn metadata(&self) -> impl Iterator<Item = &Metadata> + '_ {
+        self.iter_errors()
+            .filter_map(|error| error.downcast_ref::<crate::Message>())
+            .map(|error| &error.values)
+            .filter(|values| !values.is_empty())
+    }
+
     /// Return the error that is most likely the root cause, based on [`Frame::probable_cause()`].
     ///
-    /// If there is no source or child, return the stored error. A selected nested [`crate::Error`] is inspected
-    /// recursively, matching [`crate::Error::probable_cause()`] without consuming this exception.
+    /// Return the stored error if there is no unique causal child. Nested [`crate::Error`] graphs participate alongside
+    /// native sources and explicit children, matching [`crate::Error::probable_cause()`] without consuming this exception.
     pub fn probable_cause(&self) -> &(dyn Error + 'static) {
-        let cause = self.frame.probable_cause().unwrap_or_else(|| self.frame.error());
-        cause
-            .downcast_ref::<crate::Error>()
-            .map_or(cause, crate::Error::probable_cause)
+        self.frame.probable_cause().unwrap_or_else(|| self.frame.error())
     }
 
-    /// Find the first stored error or native source that downcasts to `T` in logical breadth-first order.
+    /// Find the first diagnostic error that downcasts to `T` in logical breadth-first order.
+    /// Classification-only markers are omitted, as in [`Self::iter_errors()`].
     ///
     /// Nested [`crate::Error`] values are inspected recursively, matching [`crate::Error::downcast_any_ref()`].
     pub fn downcast_any_ref<T: Error + 'static>(&self) -> Option<&T> {
-        self.frame
-            .collect_errors_with_locations()
-            .into_iter()
-            .find_map(|source| source.error().downcast_ref())
+        self.iter_errors().find_map(|error| error.downcast_ref())
     }
 }
 
@@ -227,11 +296,27 @@ impl fmt::Debug for Frame {
 }
 
 #[derive(Copy, Clone)]
-enum ErrorMode {
+pub(crate) enum ErrorMode {
     Display,
     Debug,
 }
 
+impl ErrorMode {
+    pub(crate) fn fmt(self, error: &(dyn Error + 'static), f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(io) = error.downcast_ref::<std::io::Error>()
+            && io.get_ref().is_some()
+        {
+            // The traversal reports the payload separately, so neither Display nor Debug may expand it here.
+            return write!(f, "I/O error ({:?})", io.kind());
+        }
+        // The outer alternate flag controls report layout, not the formatting of individual diagnostics.
+        match self {
+            ErrorMode::Display => write!(f, "{error}"),
+            ErrorMode::Debug => write!(f, "{error:?}"),
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 enum TreeMode {
     Linearize,
@@ -245,6 +330,18 @@ fn write_frame_recursive(
     err_mode: ErrorMode,
     tree_mode: TreeMode,
 ) -> fmt::Result {
+    if crate::error::is_transparent_marker(frame.error()) {
+        let children = ErrorNode::Frame(frame).children();
+        if !children.is_empty() {
+            for (index, child) in children.into_iter().enumerate() {
+                if index != 0 {
+                    writeln!(f)?;
+                }
+                write_error_node_recursive(f, child, prefix, err_mode, tree_mode)?;
+            }
+            return Ok(());
+        }
+    }
     write_error_node_recursive(f, ErrorNode::Frame(frame), prefix, err_mode, tree_mode)
 }
 
@@ -259,10 +356,7 @@ fn write_error_node_recursive(
     while let Some(error) = root_error.downcast_ref::<crate::Error>() {
         root_error = error.error();
     }
-    match err_mode {
-        ErrorMode::Display => fmt::Display::fmt(root_error, f),
-        ErrorMode::Debug => write!(f, "{root_error:?}"),
-    }?;
+    err_mode.fmt(root_error, f)?;
     if !f.alternate() {
         write_location(f, node.location())?;
     }
@@ -279,10 +373,7 @@ fn write_error_node_recursive(
                 continue;
             }
             write!(f, "\n{prefix}|\n{prefix}└─ ")?;
-            match err_mode {
-                ErrorMode::Display => fmt::Display::fmt(source.error(), f),
-                ErrorMode::Debug => write!(f, "{:?}", source.error()),
-            }?;
+            err_mode.fmt(source.error(), f)?;
             if !f.alternate() {
                 write_location(f, source.location().unwrap_or_else(|| node.location()))?;
             }
@@ -348,6 +439,11 @@ impl fmt::Display for Frame {
             // Avoid printing alternate versions of the debug info, keep it in one line, also print the tree.
             write_frame_recursive(f, self, "", ErrorMode::Debug, TreeMode::Verbatim)
         } else {
+            if crate::error::is_transparent_marker(self.error())
+                && let Some(diagnostic) = self.iter_errors_with_locations().next()
+            {
+                return fmt::Display::fmt(diagnostic.error(), f);
+            }
             fmt::Display::fmt(self.error(), f)
         }
     }
@@ -377,12 +473,7 @@ impl Frame {
     }
 
     /// Return the source code location where this exception frame was created.
-    /// Return the frame location used when formatting this node.
-    ///
-    /// A frame returns its own captured location. A native source inherits the location of the frame whose error owns its
-    /// source chain, providing formatting context even though no location was captured for the source itself. In contrast,
-    /// `captured_location()` reports only locations belonging to the node itself.
-    pub fn location(self) -> &'static Location<'static> {
+    pub fn location(&self) -> &'static Location<'static> {
         self.location
     }
 
@@ -407,137 +498,100 @@ pub(crate) enum ErrorNode<'a> {
         error: &'a (dyn Error + 'static),
         location: &'static Location<'static>,
     },
+    /// A source from a nested boundary's already flattened iterator; its descendants are emitted separately.
+    FlatSource {
+        error: &'a (dyn Error + 'static),
+        location: &'static Location<'static>,
+    },
 }
 
 impl<'a> ErrorNode<'a> {
     pub(crate) fn error(self) -> &'a (dyn Error + 'static) {
         match self {
             ErrorNode::Frame(frame) => frame.error(),
-            ErrorNode::Source { error, .. } => error,
+            ErrorNode::Source { error, .. } | ErrorNode::FlatSource { error, .. } => error,
         }
     }
 
     /// Return the frame location used when formatting this node.
     ///
     /// A frame returns its own captured location. A native source inherits the location of the frame whose error owns its
-    /// source chain, providing formatting context even though no location was captured for the source itself. In contrast,
-    /// `captured_location()` reports only locations belonging to the node itself.
+    /// source chain, providing formatting context even though no location was captured for the source itself.
     pub(crate) fn location(self) -> &'static Location<'static> {
         match self {
             ErrorNode::Frame(frame) => frame.location,
-            ErrorNode::Source { location, .. } => location,
-        }
-    }
-
-    /// Return the location captured for this node itself.
-    ///
-    /// This is `Some` for an explicitly created frame and `None` for a native source. Unlike [`Self::location()`], it does
-    /// not return the owning frame's location as inherited formatting context for a source.
-    pub(crate) fn captured_location(self) -> Option<&'static Location<'static>> {
-        match self {
-            ErrorNode::Frame(frame) => Some(frame.location),
-            ErrorNode::Source { .. } => None,
+            ErrorNode::Source { location, .. } | ErrorNode::FlatSource { location, .. } => location,
         }
     }
 
-    /// Return this node's immediate logical children in traversal order.
+    /// Return this node's diagnostic children in traversal order, promoting descendants of classification markers.
     ///
-    /// A direct native [`Error::source()`] is first and inherits this node's formatting location. For a frame, explicitly
-    /// raised child frames follow it in insertion order. The compatibility `source()` of a nested [`crate::Error`] is
+    /// A direct native [`Error::source()`] or I/O payload is first and inherits this node's formatting location.
+    /// For a frame, explicitly raised child frames follow it in insertion order. The compatibility `source()` of a nested [`crate::Error`] is
     /// skipped because that wrapper retains an internal error graph which its own traversal APIs expand separately;
     /// following the compatibility source here would expose only one path and duplicate that expansion.
     pub(crate) fn children(self) -> Vec<ErrorNode<'a>> {
+        if matches!(self, ErrorNode::FlatSource { .. }) {
+            return Vec::new();
+        }
         let error = self.error();
         let location = self.location();
         let mut children = Vec::new();
-        if !error.is::<crate::Error>()
-            && let Some(error) = error.source()
-        {
+        if let Some(nested) = error.downcast_ref::<crate::Error>() {
+            if crate::error::is_transparent_marker(error) {
+                children.extend(
+                    nested
+                        .iter_errors_with_locations()
+                        .filter(|source| !source.error().is::<crate::Error>())
+                        .map(|source| ErrorNode::FlatSource {
+                            error: source.error(),
+                            location: source.location().unwrap_or(location),
+                        }),
+                );
+            }
+        } else if let Some(error) = crate::error::native_source(error) {
             children.push(ErrorNode::Source { error, location });
         }
         if let ErrorNode::Frame(frame) = self {
             children.extend(frame.children.iter().map(ErrorNode::Frame));
         }
-        children
-    }
-
-    fn same(self, other: ErrorNode<'_>) -> bool {
-        // A native source can share its owner's address, for example within a transparent wrapper.
-        match (self, other) {
-            (ErrorNode::Frame(left), ErrorNode::Frame(right)) => std::ptr::eq(left, right),
-            (ErrorNode::Source { error: left, .. }, ErrorNode::Source { error: right, .. }) => {
-                std::ptr::eq(left, right)
+        let mut diagnostics = Vec::new();
+        for child in children {
+            if crate::error::is_transparent_marker(child.error()) {
+                diagnostics.extend(child.children());
+            } else {
+                diagnostics.push(child);
             }
-            _ => false,
         }
+        diagnostics
     }
 }
 
 /// Navigation
 impl Frame {
-    /// Find the best possible cause:
+    /// Follow the unique causal child until reaching a leaf or a branch.
+    ///
+    /// Native [`Error::source()`] values, I/O payloads, nested [`crate::Error`] graphs, and explicitly raised frames all
+    /// participate.
+    ///
+    /// An *aggregate* is the error at a branch that groups two or more diagnostic causes. This is a role in the error
+    /// tree, not a special concrete error type. For example, [`Exn::raise_all`] can attach multiple failed operations
+    /// to a shared `"batch failed"` [`crate::Message`]. That shared message is the aggregate, so selection stops there
+    /// rather than arbitrarily choosing one operation's error:
     ///
-    /// * in a linear chain of a single error each, it's the last-most error
-    /// * in trees, find the deepest-possible error that has the most leafs as children
+    /// ```text
+    /// outer context
+    /// └─ batch failed  (aggregate, selected)
+    ///    ├─ first operation failed
+    ///    └─ second operation failed
+    /// ```
     ///
-    /// Native [`Error::source()`] values participate as borrowed children. Return `None` if there are no children.
+    /// All [`crate::ClassificationMarker`] values are ignored. Their frames, including nested boundaries,
+    /// are transparent: their real descendants count as children of the nearest non-marker parent instead.
+    /// Return `None` if selection stays at this frame, allowing callers to fall back to [`Self::error()`], even for a
+    /// classification-only root.
     pub fn probable_cause(&self) -> Option<&(dyn Error + 'static)> {
-        self.probable_cause_node().map(ErrorNode::error)
-    }
-
-    pub(crate) fn probable_cause_node(&self) -> Option<ErrorNode<'_>> {
-        /// Perform a recursive depth-first, post-order walk to select a probable-cause candidate.
-        ///
-        /// The returned tuple contains the number of leaves below `node`, the depth of the selected candidate, and the
-        /// candidate itself. After visiting all children, the current node competes with the best descendant: the candidate
-        /// representing more leaves wins, with greater depth breaking ties. Exact ties between siblings retain the first
-        /// child in traversal order.
-        fn walk(node: ErrorNode<'_>, depth: usize) -> (usize, usize, ErrorNode<'_>) {
-            let children = node.children();
-            if children.is_empty() {
-                return (1, depth, node);
-            }
-
-            let mut total_leafs = 0;
-            let mut best: Option<(usize, usize, ErrorNode<'_>)> = None;
-
-            for child in children {
-                let (leafs, child_depth, candidate) = walk(child, depth + 1);
-                total_leafs += leafs;
-
-                match best {
-                    None => best = Some((leafs, child_depth, candidate)),
-                    Some((best_leafs, best_depth, _)) => {
-                        if leafs > best_leafs || (leafs == best_leafs && child_depth > best_depth) {
-                            best = Some((leafs, child_depth, candidate));
-                        }
-                    }
-                }
-            }
-
-            let self_candidate = (total_leafs, depth, node);
-            match best {
-                None => self_candidate,
-                Some(best_child) => {
-                    if total_leafs > best_child.0 || (total_leafs == best_child.0 && depth > best_child.1) {
-                        self_candidate
-                    } else {
-                        best_child
-                    }
-                }
-            }
-        }
-
-        let root = ErrorNode::Frame(self);
-        let children = root.children();
-        if children.iter().all(|child| child.children().is_empty())
-            && let Some(last) = children.last()
-        {
-            return Some(*last);
-        }
-
-        let cause = walk(root, 0).2;
-        (!cause.same(root)).then_some(cause)
+        self.probable_cause_inner()
     }
 
     /// Iterate over all explicitly created frames in breadth-first order. The first frame is this instance, followed by
@@ -547,12 +601,6 @@ impl Frame {
         queue.push_back(self);
         BreadthFirstFrames { queue }
     }
-
-    pub(crate) fn iter_error_nodes(&self) -> BreadthFirstErrorNodes<'_> {
-        let mut queue = VecDeque::new();
-        queue.push_back(ErrorNode::Frame(self));
-        BreadthFirstErrorNodes { queue }
-    }
 }
 
 /// Breadth-first iterator over explicitly created `Frame`s.
@@ -572,20 +620,6 @@ impl<'a> Iterator for BreadthFirstFrames<'a> {
     }
 }
 
-pub(crate) struct BreadthFirstErrorNodes<'a> {
-    queue: VecDeque<ErrorNode<'a>>,
-}
-
-impl<'a> Iterator for BreadthFirstErrorNodes<'a> {
-    type Item = ErrorNode<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let node = self.queue.pop_front()?;
-        self.queue.extend(node.children());
-        Some(node)
-    }
-}
-
 impl<E> From<Exn<E>> for Box<Frame>
 where
     E: Error + Send + Sync + 'static,
@@ -664,40 +698,17 @@ impl Error for Untyped {
     }
 }
 
-/// An error that merely says that something is wrong.
-pub struct Something;
-
-impl fmt::Display for Something {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Something went wrong")
-    }
-}
-
-impl fmt::Debug for Something {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self, f)
-    }
-}
-
-impl Error for Something {}
-
 impl<E> From<Exn<E>> for ChainedError
 where
     E: std::error::Error + Send + Sync + 'static,
 {
     fn from(err: Exn<E>) -> Self {
-        let probable_cause = err
-            .frame
-            .probable_cause_node()
-            .and_then(|cause| err.frame.iter_error_nodes().position(|node| node.same(cause)));
         let flattened = flatten_error_nodes(*err.frame);
         let mut source = None;
-        let leaves_to_root = flattened.into_iter().enumerate().rev();
-        for (index, node) in leaves_to_root {
+        for node in flattened.into_iter().rev() {
             source = Some(Box::new(ChainedError {
                 err: node.error,
                 location: node.location,
-                is_probable_cause: probable_cause.map_or(index == 0, |cause| cause == index),
                 logical_parent: node.logical_parent,
                 source,
             }));
diff --git a/gix-error/src/exn/macros.rs b/gix-error/src/exn/macros.rs
index 7bcc1f540d6..b246351e9bd 100644
--- a/gix-error/src/exn/macros.rs
+++ b/gix-error/src/exn/macros.rs
@@ -26,8 +26,8 @@
 /// ```
 /// use std::fs;
 ///
-/// use gix_error::bail;
-/// # fn wrapper() -> Result<(), gix_error::Exn<std::io::Error>> {
+/// use gix_error::{bail, ExnResult};
+/// # fn wrapper() -> ExnResult<(), std::io::Error> {
 /// match fs::read_to_string("/path/to/file") {
 ///     Ok(content) => println!("file contents: {content}"),
 ///     Err(err) => bail!(err),
diff --git a/gix-error/src/exn/mod.rs b/gix-error/src/exn/mod.rs
index 28d9c6103db..31fc49eac97 100644
--- a/gix-error/src/exn/mod.rs
+++ b/gix-error/src/exn/mod.rs
@@ -12,68 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! A context-aware concrete Error type built on `std::error::Error`
+//! Frame inspection and type erasure for [`crate::Exn`].
+//!
+//! The exception type and its extension traits are exported only at the crate root.
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![deny(missing_docs)]
 
-mod ext;
-pub use ext::{BoxedResultExt, ErrorExt, OptionExt, ResultExt};
+pub(super) mod ext;
 
-mod impls;
-pub(crate) use impls::ErrorNode;
-pub use impls::{Frame, Something, Untyped};
+pub(super) mod impls;
+pub use impls::{Frame, Untyped};
 
 mod macros;
-
-/// An exception type that can hold an [error tree](Exn::raise_all) and the call site.
-///
-/// While an error chain, a list, is automatically created when [raise](Exn::raise)
-/// and friends are invoked, one can also use [`Exn::raise_all`] to create an error
-/// that has multiple causes.
-///
-/// # Native error sources
-///
-/// Values reached through [`std::error::Error::source()`] remain owned by their original errors and are traversed by
-/// reference, preserving their concrete types. They aren't exception frames and therefore have no captured call site of
-/// their own.
-///
-/// # `Exn` == `Exn<Untyped>`
-///
-/// `Exn` act's like `Box<dyn std::error::Error + Send + Sync + 'static>`, but with the capability
-/// to store a tree of errors along with their *call sites*.
-///
-/// # Visualisation
-///
-/// Linearized trees during display make a list of 3 children indistinguishable from
-/// 3 errors where each is the child of the other.
-///
-/// ## Debug
-///
-/// * locations: ✔️
-/// * error display: Display
-/// * tree mode: linearized
-///
-/// ## Debug + Alternate
-///
-/// * locations: ❌
-/// * error display: Display
-/// * tree mode: linearized
-///
-/// ## Display
-///
-/// * locations: ❌
-/// * error display: Debug
-/// * tree mode: None
-///
-/// ## Display + Alternate
-///
-/// * locations: ❌
-/// * error display: Debug
-/// * tree mode: verbatim
-pub struct Exn<E: std::error::Error + Send + Sync + 'static = Untyped> {
-    // trade one more indirection for less stack size
-    frame: Box<Frame>,
-    phantom: PhantomData<E>,
-}
-
-use std::marker::PhantomData;
diff --git a/gix-error/src/lib.rs b/gix-error/src/lib.rs
index 3928822da9e..50d1eef5207 100644
--- a/gix-error/src/lib.rs
+++ b/gix-error/src/lib.rs
@@ -4,13 +4,16 @@
 //!
 //! * When there is **no callee error** to track, use *simple* `std::error::Error` implementations directly,
 //!   e.g. `Result<_, Simple>`.
-//!      - If call-site tracking is important, prefer `Result<_, Exn<Simple>>` instead:
+//!      - If call-site tracking is important, prefer `ExnResult<_, Simple>` instead:
 //!        [`Exn`] stores the location where the error was raised, which plain error values do not.
-//! * When there **is callee error to track** *in a `gix-plumbing`*, use e.g. `Result<_, Exn<Simple>>`.
+//! * When there **is callee error to track** *in a `gix-plumbing`*, use e.g. `ExnResult<_, Simple>`.
 //!      - Remember that `Exn<T>` does not implement `std::error::Error` so it's not easy to use outside `gix-` crates.
-//!      - Use the type-erased version in callbacks like [`Exn`] (without type arguments), i.e. `Result<T, Exn>`.
+//!      - Use the type-erased version in callbacks like [`Exn`] (without type arguments), i.e. `ExnResult<T>`.
 //! * When there **is callee error to track** *in the `gix` crate*, convert both `std::error::Error` and `Exn<E>` into [`Error`]
 //!
+//! [`ExnResult<T, E>`](ExnResult) abbreviates a result with an [`Exn<E>`](Exn) error. Its defaults are
+//! `T = ()` and `E = exn::Untyped`, matching bare [`Exn`]. Use `ExnMessageResult<T>` for message contexts.
+//!
 //! # Standard Error Types
 //!
 //! These should always be used if they match the meaning of the error well enough instead of creating an own
@@ -20,25 +23,59 @@
 //!
 //! All these types implement [`Error`](std::error::Error).
 //!
-//! ## [`Message`]
+//! ## [`Message`] and [`ClassificationMarker`]
 //!
-//! The baseline that provides a formatted message.
-//! Formatting can more easily be done with the [`message!`] macro as convenience, roughly equivalent to
+//! [`Message`] combines a diagnostic message, an optional [`Class`], and named scalar values. Use it
+//! instead of a chain of type-bearing errors when those layers only provide the category and details of a single
+//! failure. [`not_found()`], [`validation()`], [`corruption()`], [`retryable()`], [`resource_exhaustion()`],
+//! [`allocation_limit()`], [`allocation_failure()`], and [`io()`] construct classified messages.
+//! [`message()`] and [`Message::new()`] start without a class or values. [`Message::with_class()`] and
+//! [`Message::with()`] add them to the same diagnostic. Use [`message!`] for formatting, equivalent to
 //! [`Message::new(format!("…"))`](Message::new) or `format!("…").into()`.
 //!
-//! ## Specialised types
+//! Classification does not determine which diagnostic values can be attached. For example,
+//! `corruption("Malformed reference").with("input", bytes)` preserves offending bytes in the same
+//! error that describes their corruption. No extra validation error is needed just to store input.
+//! Use explicit classified constructors: converting a string to [`Message`] does not infer a class
+//! from the function's return type.
+//!
+//! | Type | Diagnostic | Classification | Purpose |
+//! |------|------------|----------------|---------|
+//! | [`Message`] | Visible message and optional values | Optional | Describe a failure without a custom error type |
+//! | [`ClassificationMarker`] | Transparent, no diagnostic of its own | Required | Classify an existing error while preserving its concrete type |
 //!
-//! - [`ValidationError`]
-//!    - like [`Message`], but can optionally store the input that caused the failure.
-//!    - For message-only validation failures, use `Into<ValidationError>` conversions instead of spelling out
-//!      [`ValidationError::new()`]:
-//! ```rust,ignore
-//! // All of these produce ValidationError:
-//! return Err(message("eof reading amount of bits").into());
-//! let value = maybe_value.ok_or(message("missing value").into())?;
-//! let header = maybe_header.ok_or("missing header".into())?;
 //! ```
-//!    - Use [`ValidationError::new_with_input()`] when you need to preserve the offending input.
+//! use gix_error::{ErrorExt, Message, MetadataValue};
+//!
+//! let error = gix_error::not_found("Reference does not exist")
+//!     .with("path", std::path::Path::new("HEAD"))
+//!     .raise();
+//! assert!(error.is_not_found());
+//! assert!(error.probable_cause().is::<Message>());
+//! assert_eq!(error.metadata().next().expect("lookup details")["path"], MetadataValue::Path("HEAD".into()));
+//! ```
+//!
+//! Callers should add context using information they already possess and document its keys on the function
+//! that returns it. Preserve real callee errors, especially concrete recovery signals and complex results
+//! discovered by the callee, such as partial outcomes:
+//!
+//! ```
+//! use gix_error::{message, ResultExt, MetadataValue};
+//!
+//! let error = Err::<(), _>(std::io::Error::from(std::io::ErrorKind::NotFound))
+//!     .or_raise(|| message("Could not read reference").with("path", std::path::Path::new("HEAD")))
+//!     .expect_err("the lookup failed");
+//! assert!(error.is_not_found());
+//! assert!(error.probable_cause().is::<std::io::Error>());
+//! assert_eq!(error.error().class, None, "the callee, not the context, supplies the classification");
+//! let values = error.metadata().next().expect("lookup context");
+//! assert_eq!(values["path"], MetadataValue::Path("HEAD".into()));
+//! ```
+//!
+//! [`Exn::metadata()`] and [`Error::metadata()`] yield each message's non-empty [`Metadata`] dictionary in error traversal order.
+//! Each dictionary maps names to [`MetadataValue`]s. Keys are local to their context; dictionaries from independent causes
+//! are never combined. To identify a specific failure without inspecting its values, see
+//! [matching a specific failure](#matching-a-specific-failure).
 //!
 //! # [`Exn<ErrorType>`](Exn) and [`Exn`]
 //!
@@ -46,26 +83,28 @@
 //! via [`ResultExt::or_raise()`] (and sibling methods) as well as location information of the creation site.
 //!
 //! While plumbing functions that need to track causes should always return a distinct type like [`Exn<Message>`](Exn),
-//! if that's not possible, use [`Exn::erased`] to let it return `Result<T, Exn>` instead, allowing any return type.
+//! if that's not possible, use [`Exn::erased`] to let it return `ExnResult<T>` instead, allowing any return type.
 //!
 //! A side effect of this is that any callee that causes errors needs to be annotated with
 //! `.or_raise(|| message!("context information"))` or `.or_raise_erased(|| message!("context information"))`.
 //!
-//! # Using `Exn` (bare) in closure *bounds*
+//! # Using [`ExnResult`] in closure *bounds*
 //!
-//! Callback and closure **bounds** should use `Result<T, Exn>` (bare, without a type parameter)
-//! rather than `Result<T, Exn<Message>>` or any other specific type. This allows callers to
+//! Callback and closure **bounds** should use `ExnResult<T>` (without an explicit error type)
+//! rather than `ExnMessageResult<T>` or any other specific type. This allows callers to
 //! return any error type from their callbacks without being forced into `Message`.
 //!
-//! Note that functions should still return the most specific type possible (usually `Exn<Message>`);
-//! only the *bound* on the callback parameter should use the bare `Exn`.
+//! Functions should still return the most specific type possible (usually `ExnMessageResult<T>`);
+//! only the *bound* on the callback parameter should use the default, erased error type.
 //!
 //! ```rust,ignore
+//! use gix_error::{ExnMessageResult, ExnResult};
+//!
 //! // GOOD — callback bound is flexible, function return is specific:
-//! fn process(cb: impl FnMut() -> Result<(), Exn>) -> Result<(), Exn<Message>> { ... }
+//! fn process(cb: impl FnMut() -> ExnResult) -> ExnMessageResult { ... }
 //!
 //! // BAD — forces caller to construct Message errors in their callback:
-//! fn process(cb: impl FnMut() -> Result<(), Exn<Message>>) -> Result<(), Exn<Message>> { ... }
+//! fn process(cb: impl FnMut() -> ExnMessageResult) -> ExnMessageResult { ... }
 //! ```
 //!
 //! Inside the function, use [`.or_raise()`](ResultExt::or_raise) to convert the bare `Exn` from the
@@ -74,7 +113,7 @@
 //! let entry = callback().or_raise(|| message("context about the callback call"))?;
 //! ```
 //!
-//! Inside a closure that must return bare `Exn`, use [`.or_erased()`](ResultExt::or_erased) to
+//! Inside a closure that must return `ExnResult<T>`, use [`.or_erased()`](ResultExt::or_erased) to
 //! convert a typed `Exn<E>` to `Exn`, or [`raise_erased()`](ErrorExt::raise_erased) for standalone errors:
 //! ```rust,ignore
 //! |stream| {
@@ -101,40 +140,48 @@
 //!
 //! It can also be created directly from any `std::error::Error` via [`Error::from_error()`].
 //!
-//! # Migrating from `thiserror`
+//! # Tests with [`TestResult`]
 //!
-//! This section describes the mechanical translation from `thiserror` error enums to `gix-error`.
-//! In `Cargo.toml`, replace `thiserror = "<version>"` with `gix-error = { version = "^0.1.0", path = "../gix-error" }`.
+//! Return [`TestResult`] from `#[test]` functions to propagate ordinary errors, [`Exn<E>`](Exn), and [`Error`]
+//! directly with `?`. It defaults to `Result<(), TestError>`; helpers returning a value can use `TestResult<T>`.
+//! Accepted errors must convert into `Box<dyn std::error::Error + Send + Sync + 'static>`.
 //!
-//! ## Choosing the replacement type
+//! When a test returns an error, Rust's test harness prints [`TestError`]'s [`Debug`](std::fmt::Debug) output,
+//! including the complete diagnostic tree or chain and captured caller locations.
 //!
-//! There are two decisions: whether to wrap in [`Exn`], and which error type to use.
+//! ```rust,test_harness
+//! use gix_error::{message, ResultExt, TestResult};
 //!
-//! **With or without [`Exn`]:**
+//! #[test]
+//! fn parses_count() -> TestResult {
+//!     let expected: usize = "42".parse()?;
+//!     let actual = "42".parse::<usize>().or_raise(|| message("could not parse count"))?;
+//!     assert_eq!(actual, expected, "context preserves the parsed count");
+//!     Ok(())
+//! }
+//! ```
 //!
-//! | `thiserror` enum shape                                      | Wrap in `Exn`? |
-//! |--------------------------------------------------------------|----------------|
-//! | All variants are simple messages (no `#[from]`/`#[source]`)  | No             |
-//! | Has `#[from]` or `#[source]` (wraps callee errors)           | Yes            |
+//! # Migrating from `thiserror`
 //!
-//! **Which error type** (used directly or as the `E` in `Exn<E>`):
+//! This section describes the mechanical translation from `thiserror` error enums to `gix-error`.
+//! In `Cargo.toml`, replace `thiserror = "<version>"` with `gix-error = { version = "^0.1.0", path = "../gix-error" }`.
+//!
+//! ## Choosing the replacement type
 //!
-//! | Semantics                                                    | Error type            |
-//! |--------------------------------------------------------------|-----------------------|
-//! | General-purpose error messages                                | [`Message`]           |
-//! | Validation/parsing, optionally storing the offending input   | [`ValidationError`]   |
-//! | Malformed or internally inconsistent data                     | [`CorruptionError`]   |
-//! | A requested resource does not exist                            | [`NotFoundError`]     |
+//! Use [`ExnMessageResult`] for diagnostic messages, including validation failures without callee errors.
+//! [`Message`] carries an optional class and named scalar values; [`Exn`] retains the diagnostic context and causes.
+//! Keep a concrete error type in [`ExnResult`] when recovery requires its specific payload.
+//! Use [`Result`] at porcelain boundaries that return [`Error`].
 //!
-//! For example, a validation function with no callee errors returns `Result<_, ValidationError>`,
-//! while a function that wraps I/O errors during parsing could return `Result<_, Exn<ValidationError>>`.
-//! When in doubt, [`Message`] is the default choice.
+//! Use the chosen type directly in signatures, importing it under its canonical name where helpful.
+//! Crate-specific and operation-specific forwarding aliases or renamed error exports are unnecessary.
+//! Facades may re-export the canonical types, as `gix` does with `Error`, `Exn`, `Result`, `ExnResult`, and `ExnMessageResult`.
+//! Always import the result aliases directly and use their bare names in signatures.
 //!
 //! ## Translating variants
 //!
-//! The translation depends on the chosen return type. When the function returns a plain error
-//! type like `Result<_, Message>`, return the error directly. When it returns `Result<_, Exn<_>>`,
-//! use [`.raise()`](ErrorExt::raise) to wrap the error into an [`Exn`].
+//! Use [`.raise()`](ErrorExt::raise) to wrap standalone errors into an [`Exn`], and
+//! [`ResultExt::or_raise()`] to preserve callee errors with additional context.
 //!
 //! **Static message variant:**
 //! ```rust,ignore
@@ -143,9 +190,6 @@
 //! SomethingFailed,
 //! // → Err(Error::SomethingFailed)
 //!
-//! // AFTER (returning Message):
-//! // → Err(message("something went wrong"))
-//!
 //! // AFTER (returning Exn<Message>):
 //! // → Err(message("something went wrong").raise())
 //! ```
@@ -157,9 +201,6 @@
 //! Unsupported { format: Format },
 //! // → Err(Error::Unsupported { format })
 //!
-//! // AFTER (returning Message):
-//! // → Err(message!("unsupported format '{format:?}'"))
-//!
 //! // AFTER (returning Exn<Message>):
 //! // → Err(message!("unsupported format '{format:?}'").raise())
 //! ```
@@ -195,8 +236,8 @@
 //!     return Err(Error::SomethingFailed);
 //! }
 //!
-//! // AFTER (returning ValidationError):
-//! ensure!(condition, ValidationError::new("something went wrong"));
+//! // AFTER (returning Exn<Message>, with a validation class):
+//! ensure!(condition, gix_error::validation("something went wrong"));
 //!
 //! // AFTER (returning Exn<Message>):
 //! ensure!(condition, message("something went wrong"));
@@ -209,17 +250,14 @@
 //! // BEFORE:
 //! fn parse(input: &str) -> Result<Value, Error> { ... }
 //!
-//! // AFTER (no callee errors wrapped):
-//! fn parse(input: &str) -> Result<Value, Message> { ... }
-//!
-//! // AFTER (callee errors wrapped):
-//! use gix_error::{message, ErrorExt, Exn, Message, ResultExt};
-//! fn parse(input: &str) -> Result<Value, Exn<Message>> { ... }
+//! // AFTER:
+//! use gix_error::{message, ErrorExt, ExnMessageResult, ResultExt};
+//! fn parse(input: &str) -> ExnMessageResult<Value> { ... }
 //! ```
 //!
 //! ## Updating tests
 //!
-//! Pattern-matching on enum variants can be replaced with string assertions:
+//! Tests of diagnostic wording can use string assertions:
 //! ```rust,ignore
 //! // BEFORE:
 //! assert!(matches!(result.unwrap_err(), Error::SomethingFailed));
@@ -231,25 +269,93 @@
 //! For semantic checks, both [`Exn`] and [`Error`] provide [`is_retryable()`](Exn::is_retryable),
 //! [`is_not_found()`](Exn::is_not_found), [`is_validation()`](Exn::is_validation),
 //! [`is_corrupted()`](Exn::is_corrupted), and [`is_resource_exhausted()`](Exn::is_resource_exhausted).
-//! These inspect causes as well as the outermost error. `is_retryable()` requires an explicit [`RetryableError`];
+//! These inspect causes as well as the outermost error. `is_retryable()` requires an explicit retry classification;
 //! [`Exn::can_retry()`] and [`Error::can_retry()`] additionally recognize certain I/O error kinds.
-//! Use [`Exn::probable_cause()`] to inspect the likely root cause.
+//! Use [`Exn::probable_cause()`] to inspect the likely root cause. It follows a single causal path, stopping at the
+//! first branch rather than choosing an arbitrary sibling. Classification markers are transparent to this selection.
 //! [`Exn::classify()`] and [`Error::classify()`] expose each known classification together with its original error.
+//! Custom payloads of [`std::io::Error`] are inspected too, including any nested [`Error`] trees.
 //!
-//! To access error-specific metadata (e.g. the `input` field on [`ValidationError`]),
-//! use [`Exn::downcast_any_ref()`] to find a specific error type within the error tree:
-//! ```rust,ignore
-//! // BEFORE:
-//! match result.unwrap_err() {
-//!     Error::InvalidInput { input } => assert_eq!(input, "bad"),
-//!     other => panic!("unexpected: {other}"),
+//! [`Message`] supplies its own diagnostic and optional classification. In contrast, [`ClassificationMarker`]
+//! only supplies classification metadata. Use [`ClassificationMarker::with_source()`] to classify an existing error
+//! while preserving its concrete type:
+//! ```
+//! use gix_error::{Class, ClassificationMarker, ErrorExt};
+//!
+//! let err = ClassificationMarker::with_source(
+//!     Class::Retryable,
+//!     std::io::Error::from(std::io::ErrorKind::AlreadyExists),
+//! ).raise();
+//! assert!(err.is_retryable());
+//! assert!(err.probable_cause().is::<std::io::Error>());
+//! assert!(err.downcast_any_ref::<ClassificationMarker>().is_none());
+//! ```
+//!
+//! Custom error types preserve classifications by exposing their immediate cause as `Some(inner)` from
+//! [`std::error::Error::source()`]. Forwarding to `inner.source()` instead can hide a classification carried by
+//! `inner` itself. A custom leaf error can borrow a constant such as [`ClassificationMarker::NOT_FOUND`]
+//! as its source to preserve its classification without defining a static or adding a generic category to its diagnostic:
+//! ```
+//! use gix_error::{ClassificationMarker, ErrorExt};
+//!
+//! #[derive(Debug)]
+//! struct MissingObject;
+//!
+//! impl std::fmt::Display for MissingObject {
+//!     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//!         f.write_str("the requested object is missing from the object database")
+//!     }
 //! }
 //!
-//! // AFTER:
-//! let err = result.unwrap_err();
-//! let ve = err.downcast_any_ref::<ValidationError>().expect("is a ValidationError");
-//! assert_eq!(ve.input.as_deref(), Some("bad".into()));
+//! impl std::error::Error for MissingObject {
+//!     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+//!         Some(const { &ClassificationMarker::NOT_FOUND })
+//!     }
+//! }
+//!
+//! let err = MissingObject.raise();
+//! assert!(err.is_not_found());
+//! assert!(err.probable_cause().is::<MissingObject>());
+//! ```
+//! Use classification predicates rather than downcasting to [`Message`] just to recognize
+//! a category: diagnostic iterators and downcasts skip all classification markers. Exception and test reports
+//! omit their wrappers too, while raw [`std::error::Error::source()`] chains retain them. Genuine classified errors
+//! remain causal and can still be downcast to inspect their payloads. When storing an [`Exn`] in a custom error, convert it with
+//! [`Exn::into_error()`] so the source can expose its complete tree.
+//!
+//! To access scalar diagnostics such as offending input, inspect the documented [metadata](Exn::metadata()) key:
 //! ```
+//! use gix_error::{ErrorExt, MetadataValue};
+//!
+//! let err = gix_error::validation("invalid input").with("input", b"bad".as_slice()).raise();
+//! let values = err.metadata().find(|values| values.contains_key("input")).expect("input context");
+//! assert_eq!(values["input"], MetadataValue::Bytes("bad".into()));
+//! ```
+//!
+//! ## Matching a specific failure
+//!
+//! Use [`Class::Tagged`] when a broad category such as [`Class::NotFound`] isn't specific enough for recovery.
+//! A single stable, namespaced tag identifies the condition without a custom error type or metadata matching.
+//! Functions returning tagged errors document their tags as part of their recovery contract, independently of
+//! diagnostic wording. A tag implies no other classification. When a general class also applies, chain a
+//! [`ClassificationMarker`] to retain it without adding a visible diagnostic.
+//!
+//! ```
+//! use gix_error::{Class, ClassificationMarker, ErrorExt, message};
+//!
+//! let missing_binary_result = Class::Tagged("gix_merge::tree::missing_binary_merge_result");
+//! let err = message("The binary merge result could not be selected")
+//!     .with_class(missing_binary_result)
+//!     .raise()
+//!     .chain(ClassificationMarker::NOT_FOUND)
+//!     .raise(message("Tree merge failed"));
+//!
+//! assert!(err.classify().has(missing_binary_result));
+//! assert!(err.is_not_found());
+//! ```
+//!
+//! [`types::Classifications::has()`] also finds tagged causes through wrapping contexts and [`Error`] conversion.
+//! Matching one cause does not make other failures in an aggregate ignorable.
 //!
 //! # Common Pitfalls
 //!
@@ -269,7 +375,7 @@
 //! ```
 //!
 //! Only use [`.erased()`](Exn::erased) when you genuinely need a type-erased `Exn` (no type parameter),
-//! e.g. to return different error types from the same function via `Result<T, Exn>`.
+//! e.g. to return different error types from the same function via `ExnResult<T>`.
 //!
 //! ## Don't use `.raise_all()` with a single error
 //!
@@ -292,13 +398,19 @@
 //! [`Exn`] also converts directly into `Box<dyn std::error::Error + Send + Sync>`, so `?` works
 //! without an explicit conversion when that is the receiving result's error type:
 //! ```rust,ignore
-//! // In the porcelain crate's error module:
-//! pub type Error = gix_error::Error;  // not gix_archive::Error (which is Exn<Message>)
-//!
-//! // The conversion happens automatically via From<Exn<E>> for Error,
-//! // so `?` works without explicit .into_error() calls.
+//! fn porcelain_operation() -> Result<(), gix_error::Error> {
+//!     // From<Exn<E>> for Error converts the plumbing error at this boundary.
+//!     plumbing_operation()?;
+//!     Ok(())
+//! }
 //! ```
 //!
+//! # Supporting types
+//!
+//! Frequently used error types, extension traits, result aliases, and constructors are available at the crate root.
+//! Utility types for flattened chains, classification, and diagnostic display live in [`types`]. Exception frames
+//! and the default type-erasure marker live in [`exn`]; [`Exn`] and its extension traits are only exported at the root.
+//!
 //! # Feature Flags
 #![cfg_attr(
     all(doc, feature = "document-features"),
@@ -318,11 +430,14 @@
 //! `exn` is much less optimized, but also costs only a `Box` on the stack,
 //! which in any case is a step up from `thiserror` which exposed a lot of heft to the stack.
 #![deny(missing_docs, unsafe_code)]
-/// A result type to hide the [Exn] error wrapper.
-mod exn;
+pub mod exn;
+pub mod types;
 
 pub use bstr;
-pub use exn::{BoxedResultExt, ErrorExt, Exn, Frame, OptionExt, ResultExt, Something, Untyped};
+pub use exn::{
+    ext::{BoxedResultExt, ErrorExt, OptionExt, ResultExt},
+    impls::Exn,
+};
 
 /// An error type that wraps an inner type-erased boxed `std::error::Error` or an `Exn` frame.
 ///
@@ -336,7 +451,7 @@ pub use exn::{BoxedResultExt, ErrorExt, Exn, Frame, OptionExt, ResultExt, Someth
 ///
 /// # The `auto-chain-error` feature
 ///
-/// If it's enabled, this type is merely a wrapper around [`ChainedError`]. This happens automatically
+/// If it's enabled, this type is merely a wrapper around [`ChainedError`](types::ChainedError). This happens automatically
 /// so applications that require this don't have to go through an extra conversion.
 ///
 /// When both the `tree-error` and `auto-chain-error` features are enabled, the `tree-error`
@@ -345,7 +460,7 @@ pub struct Error {
     #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
     inner: error::Inner,
     #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
-    inner: ChainedError,
+    inner: types::ChainedError,
 }
 
 fn root_error_eq(mut error: &(dyn std::error::Error + 'static), other: &str) -> bool {
@@ -376,20 +491,73 @@ impl PartialEq<String> for Error {
 /// A Result type that uses the [`Error`] type.
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
+/// A result with an [`Exn<E>`](Exn) error, defaulting to unit success and an erased error type.
+///
+/// `ExnResult<T>` uses the same [`exn::Untyped`] marker as bare [`Exn`]. Specify `E` to retain a
+/// concrete error type; [`ExnMessageResult`] is the shorthand for message contexts. All standard result operations and
+/// [`ResultExt`] methods remain available. Use [`ResultExt::or_erased()`] for callbacks accepting
+/// different error types, and `?` to propagate exceptions into [`Error`] at API boundaries.
+///
+/// ```
+/// use gix_error::{message, ErrorExt, ExnMessageResult, ExnResult, ResultExt};
+///
+/// fn parse_count(input: &str) -> ExnMessageResult<u64> {
+///     input.parse::<u64>().or_raise(|| message("could not parse count"))
+/// }
+///
+/// fn process(callback: impl FnOnce() -> ExnResult<u64>) -> ExnMessageResult {
+///     let count = callback().or_raise(|| message("callback failed"))?;
+///     assert_eq!(count, 42, "the callback supplies the parsed count");
+///     Ok(())
+/// }
+///
+/// let done: ExnResult = process(|| parse_count("42").or_erased()).or_erased();
+/// done?;
+///
+/// let io: ExnResult<(), std::io::Error> =
+///     Err(std::io::Error::from(std::io::ErrorKind::NotFound).raise());
+/// assert_eq!(io.expect_err("the I/O operation failed").error().kind(), std::io::ErrorKind::NotFound);
+/// # Ok::<(), gix_error::Error>(())
+/// ```
+pub type ExnResult<T = (), E = exn::Untyped> = std::result::Result<T, Exn<E>>;
+
+/// A result with a [`Message`] exception, defaulting to unit success.
+///
+/// This is [`ExnResult<T, Message>`](ExnResult). Use it for operations that attach message contexts
+/// with [`ResultExt::or_raise()`], or return standalone messages with [`ErrorExt::raise()`].
+/// Use [`ExnResult<T>`](ExnResult) with its erased error type for callback bounds.
+///
+/// ```
+/// use gix_error::{message, ErrorExt, ExnMessageResult};
+///
+/// fn validate(ready: bool) -> ExnMessageResult {
+///     if !ready {
+///         return Err(message("not ready").raise());
+///     }
+///     Ok(())
+/// }
+///
+/// validate(true)?;
+/// assert_eq!(validate(false).expect_err("not ready").error().message, "not ready");
+/// # Ok::<(), gix_error::Error>(())
+/// ```
+pub type ExnMessageResult<T = ()> = ExnResult<T, Message>;
+
 mod test;
 pub use test::{TestError, TestResult};
 
 mod error;
-pub use error::{Class, Classification, DisplaySource, can_retry, can_retry_lenient};
+pub use error::{Class, classify};
 
 /// Various kinds of concrete errors that implement [`std::error::Error`].
 mod concrete;
-pub use concrete::chain::ChainedError;
-pub use concrete::classify::{
-    CorruptionError, NotFoundError, ResourceExhaustionError, ResourceExhaustionKind, RetryableError,
+
+pub use concrete::classify::{ClassificationMarker, ResourceExhaustionKind};
+pub use concrete::message::message;
+pub use concrete::metadata::{
+    Message, Metadata, MetadataValue, allocation_failure, allocation_limit, corruption, io, not_found,
+    resource_exhaustion, retryable, validation,
 };
-pub use concrete::message::{Message, message};
-pub use concrete::validate::ValidationError;
 
 pub(crate) fn write_location(f: &mut std::fmt::Formatter<'_>, location: &std::panic::Location) -> std::fmt::Result {
     write!(f, ", at {}:{}", location.file(), location.line())
diff --git a/gix-error/src/test.rs b/gix-error/src/test.rs
index 13981a478d8..878b87316fe 100644
--- a/gix-error/src/test.rs
+++ b/gix-error/src/test.rs
@@ -4,7 +4,9 @@ use crate::Error;
 ///
 /// Unlike [`Error`], this type deliberately does not implement [`std::error::Error`]. This allows it to accept arbitrary
 /// errors via [`From`] without conflicting with the standard library's identity conversion.
-/// Its [`Debug`](std::fmt::Debug) output includes the complete error tree or chain and all captured caller locations.
+/// Its [`Debug`](std::fmt::Debug) output includes the complete diagnostic tree or chain, omitting classification markers
+/// unless only markers are available. Custom I/O wrappers show their kind, with their payloads reported separately.
+/// Captured caller locations are included unless alternate formatting is used.
 pub struct TestError(Error);
 
 /// A result type for test functions whose errors are reported through [`TestError`]'s complete diagnostics.
@@ -33,19 +35,35 @@ impl From<TestError> for Error {
 impl std::fmt::Debug for TestError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
-        return write!(f, "{:?}", self.0.inner.frame());
+        return std::fmt::Debug::fmt(self.0.inner.frame(), f);
 
         #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
         {
-            let mut errors = self.0.iter_errors_with_locations();
-            if let Some(error) = errors.next() {
-                write!(f, "{error}")?;
-                let mut errors = errors.peekable();
-                if errors.peek().is_some() {
-                    write!(f, "\n\nCaused by:")?;
-                    for (index, error) in errors.enumerate() {
-                        write!(f, "\n    {index}: {error}")?;
+            let write_error =
+                |error: crate::error::DisplaySource<'_>, f: &mut std::fmt::Formatter<'_>| -> std::fmt::Result {
+                    crate::exn::impls::ErrorMode::Display.fmt(error.error(), f)?;
+                    if !f.alternate()
+                        && let Some(location) = error.location()
+                    {
+                        crate::write_location(f, location)?;
                     }
+                    Ok(())
+                };
+            let mut errors = self
+                .0
+                .iter_errors_with_locations()
+                // Boundary contents are emitted separately by the iterator.
+                .filter(|source| !source.error().is::<Error>())
+                .peekable();
+            let Some(error) = errors.next() else {
+                return std::fmt::Display::fmt(&self.0.inner, f);
+            };
+            write_error(error, f)?;
+            if errors.peek().is_some() {
+                write!(f, "\n\nCaused by:")?;
+                for (index, error) in errors.enumerate() {
+                    write!(f, "\n    {index}: ")?;
+                    write_error(error, f)?;
                 }
             }
             Ok(())
diff --git a/gix-error/src/types.rs b/gix-error/src/types.rs
new file mode 100644
index 00000000000..fb9a2d26beb
--- /dev/null
+++ b/gix-error/src/types.rs
@@ -0,0 +1,7 @@
+//! Utility types for error-chain interoperability, classification, and diagnostic display.
+//!
+//! Frequently used error types are exported at the crate root. Exception frames and type erasure live in
+//! [`crate::exn`].
+
+pub use crate::concrete::chain::ChainedError;
+pub use crate::error::{Classification, Classifications, DisplaySource};
diff --git a/gix-error/tests/auto_chain_error.rs b/gix-error/tests/auto_chain_error.rs
index 7fa8efdecea..f9cff54d2bc 100644
--- a/gix-error/tests/auto_chain_error.rs
+++ b/gix-error/tests/auto_chain_error.rs
@@ -1,6 +1,6 @@
-use gix_error::{CorruptionError, Error, ErrorExt, NotFoundError, RetryableError, ValidationError, message};
 #[cfg(not(feature = "tree-error"))]
-use gix_error::{Exn, Message};
+use gix_error::Exn;
+use gix_error::{Class, ClassificationMarker, Error, ErrorExt, Message, corruption, message, not_found, validation};
 use std::error::Error as _;
 
 #[test]
@@ -9,15 +9,34 @@ fn exn_converts_to_boxed_std_error() {
     let err = err
         .downcast_ref::<Error>()
         .expect("conversion retains the gix error boundary type");
-    assert_eq!(err.probable_cause().to_string(), "one");
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "exn converts to boxed std error", @r#"
+        Message {
+            message: "one",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "exn converts to boxed std error", @"one");
+    }
+    insta::assert_debug_snapshot!(format_args!("{}", err.probable_cause()), "boxed errors preserve the selected cause", @"one");
 }
 
 #[test]
 fn erased_validation_error_remains_classified() {
-    let err = ValidationError::new("invalid").raise_erased().into_error();
+    let err = validation("invalid").raise_erased().into_error();
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "the auto-chain Error classifies the original Message retained during ChainedError construction", @r#"
+        Message {
+            message: "invalid",
+            class: Validation,
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "the auto-chain Error classifies the original Message retained during ChainedError construction", @"invalid");
+    }
     assert!(
         err.is_validation(),
-        "the auto-chain Error classifies the original ValidationError retained during ChainedError construction"
+        "the auto-chain Error classifies the original Message retained during ChainedError construction"
     );
 }
 
@@ -25,16 +44,18 @@ fn erased_validation_error_remains_classified() {
 #[test]
 fn from_exn_error() {
     let err = Error::from(message("one").raise());
-    assert_eq!(format!("{err:#}"), "one");
+    insta::assert_debug_snapshot!(format_args!("{err:#}"), "alternate Display exposes the converted root diagnostic", @r#"
+        one
+    "#);
     insta::assert_compact_debug_snapshot!(
         &err,
         "compact Debug exposes the underlying message without caller location",
-        @r#"Message("one")"#
+        @r#"Message { message: "one" }"#
     );
     insta::assert_debug_snapshot!(err, @r#"
-    Message(
-        "one",
-    )
+    Message {
+        message: "one",
+    }
     "#);
     assert_eq!(err.source().map(debug_string), None);
 }
@@ -43,16 +64,18 @@ fn from_exn_error() {
 #[test]
 fn from_exn_error_tree() {
     let err = Error::from(new_tree_error().raise(message("topmost")));
-    assert_eq!(format!("{err:#}").to_string(), "topmost");
+    insta::assert_debug_snapshot!(format_args!("{}", format!("{err:#}")), "alternate Display exposes the aggregate diagnostic", @r#"
+        topmost
+    "#);
     insta::assert_compact_debug_snapshot!(
         err,
         "compact Debug shows only the topmost error after flattening",
-        @r#"Message("topmost")"#
+        @r#"Message { message: "topmost" }"#
     );
     insta::assert_debug_snapshot!(err, "pretty Debug shows only the topmost error after flattening", @r#"
-    Message(
-        "topmost",
-    )
+    Message {
+        message: "topmost",
+    }
     "#);
     insta::assert_debug_snapshot!(
         err.iter_errors().map(|err| fixup_paths(err.to_string())).collect::<Vec<_>>(),
@@ -79,19 +102,19 @@ fn from_exn_error_tree() {
         "error iteration with locations exposes the same errors together with their caller locations",
         @r#"
     [
-        "topmost, at gix-error/tests/auto_chain_error.rs:45",
-        "E6, at gix-error/tests/auto_chain_error.rs:168",
-        "E5, at gix-error/tests/auto_chain_error.rs:160",
-        "E4, at gix-error/tests/auto_chain_error.rs:163",
-        "E8, at gix-error/tests/auto_chain_error.rs:166",
-        "E3, at gix-error/tests/auto_chain_error.rs:152",
-        "E10, at gix-error/tests/auto_chain_error.rs:155",
-        "E12, at gix-error/tests/auto_chain_error.rs:158",
-        "E2, at gix-error/tests/auto_chain_error.rs:162",
-        "E7, at gix-error/tests/auto_chain_error.rs:165",
-        "E1, at gix-error/tests/auto_chain_error.rs:151",
-        "E9, at gix-error/tests/auto_chain_error.rs:154",
-        "E11, at gix-error/tests/auto_chain_error.rs:157",
+        "topmost, at gix-error/tests/auto_chain_error.rs:66",
+        "E6, at gix-error/tests/auto_chain_error.rs:206",
+        "E5, at gix-error/tests/auto_chain_error.rs:198",
+        "E4, at gix-error/tests/auto_chain_error.rs:201",
+        "E8, at gix-error/tests/auto_chain_error.rs:204",
+        "E3, at gix-error/tests/auto_chain_error.rs:190",
+        "E10, at gix-error/tests/auto_chain_error.rs:193",
+        "E12, at gix-error/tests/auto_chain_error.rs:196",
+        "E2, at gix-error/tests/auto_chain_error.rs:200",
+        "E7, at gix-error/tests/auto_chain_error.rs:203",
+        "E1, at gix-error/tests/auto_chain_error.rs:189",
+        "E9, at gix-error/tests/auto_chain_error.rs:192",
+        "E11, at gix-error/tests/auto_chain_error.rs:195",
     ]
     "#
     );
@@ -114,36 +137,51 @@ fn from_exn_error_tree() {
         file!(),
         "errors with locations expose their caller location"
     );
-    assert_eq!(
-        err.source().map(debug_string).as_deref(),
-        Some(r#"Message("E6")"#),
-        "The source is the first child"
-    );
-    assert_eq!(
-        format!("{:#}", err.probable_cause()),
-        "E6",
-        "we get the top-most error that has most causes"
-    );
+    insta::assert_debug_snapshot!(err.source(), "The source is the first child", @r#"
+    Some(
+        Message {
+            message: "E6",
+        },
+    )
+    "#);
+    insta::assert_debug_snapshot!(format_args!("{:#}", err.probable_cause()), "the first causal branch selects its aggregate", @r#"
+        E6
+    "#);
 }
 
 #[test]
 fn from_any_error() {
     let err = Error::from_error(message("one"));
-    assert_eq!(format!("{err:#}"), "one");
-    assert_eq!(debug_string(&err), r#"Message("one")"#);
+    insta::assert_debug_snapshot!(format_args!("{err:#}"), "wrapping a native error preserves its diagnostic", @"one");
+    insta::assert_compact_debug_snapshot!(&err, "wrapping a native error preserves its diagnostic", @r#"Message { message: "one" }"#);
     insta::assert_debug_snapshot!(err, @r#"
-    Message(
-        "one",
-    )
+    Message {
+        message: "one",
+    }
     "#);
     assert_eq!(err.source().map(debug_string), None);
-    assert_eq!(format!("{:#}", err.probable_cause()), "one");
+    insta::assert_debug_snapshot!(format_args!("{:#}", err.probable_cause()), "wrapping a native error preserves its diagnostic", @"one");
 }
 
 #[test]
 fn probable_cause_survives_tree_flattening() {
     let err = Error::from(message("bottom").raise().raise(message("middle")).raise(message("top")));
-    assert_eq!(format!("{:#}", err.probable_cause()), "bottom");
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "probable cause survives tree flattening", @r#"
+        Message {
+            message: "top",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "probable cause survives tree flattening", @"
+        top
+        |
+        └─ middle
+        |
+        └─ bottom
+        ");
+    }
+    insta::assert_debug_snapshot!(format_args!("{:#}", err.probable_cause()), "flattening retains the selected leaf diagnostic", @"bottom");
 }
 
 #[cfg(not(feature = "tree-error"))]
@@ -180,62 +218,161 @@ fn fixup_paths(input: String) -> String {
 fn retryability_is_discovered_in_the_error_chain() {
     let retryable =
         std::io::Error::new(std::io::ErrorKind::TimedOut, "too slow").and_raise(message("network operation failed"));
-    assert!(Error::from(retryable).can_retry());
+    let err = Error::from(retryable);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @r#"
+        Message {
+            message: "network operation failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @"
+        network operation failed
+        |
+        └─ I/O error (TimedOut)
+        |
+        └─ too slow
+        ");
+    }
+    assert!(err.can_retry());
 
-    let dependency_specific =
-        RetryableError::new(message("HTTP/2 stream failed")).and_raise(message("network operation failed"));
-    assert!(Error::from(dependency_specific).can_retry());
+    let dependency_specific = ClassificationMarker::with_source(Class::Retryable, message("HTTP/2 stream failed"))
+        .and_raise(message("network operation failed"));
+    let err = Error::from(dependency_specific);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @r#"
+        Message {
+            message: "network operation failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @"
+        network operation failed
+        |
+        └─ HTTP/2 stream failed
+        ");
+    }
+    assert!(err.can_retry());
 }
 
 #[test]
 fn corruption_is_discovered_in_the_error_chain() {
-    let corrupt = CorruptionError::new("checksum mismatch").and_raise(message("failed to open object database"));
-    assert!(Error::from(corrupt).is_corrupted());
+    let corrupt = corruption("checksum mismatch").and_raise(message("failed to open object database"));
+    let err = Error::from(corrupt);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @r#"
+        Message {
+            message: "failed to open object database",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @"
+        failed to open object database
+        |
+        └─ checksum mismatch
+        ");
+    }
+    assert!(err.is_corrupted());
 }
 
 #[test]
 fn not_found_is_discovered_in_well_known_errors() {
-    let missing = NotFoundError::new("reference does not exist").and_raise(message("failed to resolve HEAD"));
-    assert!(Error::from(missing).is_not_found());
-    assert!(Error::from_error(std::io::Error::new(std::io::ErrorKind::NotFound, "missing")).is_not_found());
-    assert!(
-        Error::from_boxed(Box::new(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "missing object"
-        )))
-        .is_not_found()
-    );
+    let missing = not_found("reference does not exist").and_raise(message("failed to resolve HEAD"));
+    let err = Error::from(missing);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+        Message {
+            message: "failed to resolve HEAD",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @"
+        failed to resolve HEAD
+        |
+        └─ reference does not exist
+        ");
+    }
+    assert!(err.is_not_found());
+    let err = Error::from_error(std::io::Error::new(std::io::ErrorKind::NotFound, "missing"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+    Custom {
+        kind: NotFound,
+        error: "missing",
+    }
+    "#);
+    assert!(err.is_not_found());
+    let err = Error::from_boxed(Box::new(std::io::Error::new(
+        std::io::ErrorKind::NotFound,
+        "missing object",
+    )));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+    Custom {
+        kind: NotFound,
+        error: "missing object",
+    }
+    "#);
+    assert!(err.is_not_found());
 }
 
 #[test]
 fn validation_is_discovered_in_the_error_chain() {
-    assert!(Error::from_error(ValidationError::new("invalid")).is_validation());
-    assert!(Error::from_error(ErrorWithSource(ValidationError::new("invalid"))).is_validation());
+    let err = Error::from_error(validation("invalid"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "validation is discovered in the error chain", @r#"
+    Message {
+        message: "invalid",
+        class: Validation,
+    }
+    "#);
+    assert!(err.is_validation());
+    let err = Error::from_error(ErrorWithSource(validation("invalid")));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "validation is discovered in the error chain", @r#"
+    ErrorWithSource(
+        Message {
+            message: "invalid",
+            class: Validation,
+        },
+    )
+    "#);
+    assert!(err.is_validation());
 
-    let err = Error::from(ValidationError::new("typed").and_raise(message("context")));
+    let err = Error::from(validation("typed").and_raise(message("context")));
     assert!(
-        err.iter_errors().any(<dyn std::error::Error>::is::<ValidationError>),
+        err.iter_errors().any(<dyn std::error::Error>::is::<Message>),
         "iter_errors() exposes the stored error types in chain mode"
     );
     assert!(
         err.iter_errors_with_locations()
-            .any(|source| source.error().is::<ValidationError>()),
+            .any(|source| source.error().is::<Message>()),
         "iter_errors_with_locations() preserves the stored error types alongside their locations"
     );
 }
 
 #[test]
 fn classification_survives_raising_a_converted_error() {
-    let converted = Error::from_error(ErrorWithSource(ValidationError::new("invalid object header")));
+    let converted = Error::from_error(ErrorWithSource(validation("invalid object header")));
     let raised = Error::from(converted.and_raise(message("revision parsing failed")));
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(raised, "classification survives raising a converted error", @r#"
+        Message {
+            message: "revision parsing failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(raised, "classification survives raising a converted error", @"
+        revision parsing failed
+        |
+        └─ invalid object header
+        |
+        └─ invalid object header
+        ");
+    }
     assert!(raised.is_validation());
 }
 
 #[test]
 #[cfg(not(feature = "tree-error"))]
 fn raising_a_converted_error_preserves_stored_types() {
-    let converted =
-        Error::from(ValidationError::new("invalid object header").and_raise(message("object lookup failed")));
+    let converted = Error::from(validation("invalid object header").and_raise(message("object lookup failed")));
     let converted = Error::from_error(converted);
     let raised = converted.and_raise(message("revision parsing failed"));
     insta::assert_debug_snapshot!(
@@ -251,17 +388,22 @@ fn raising_a_converted_error_preserves_stored_types() {
     let raised = Error::from(raised);
 
     assert!(
-        raised.iter_errors().any(<dyn std::error::Error>::is::<ValidationError>),
+        raised.iter_errors().any(<dyn std::error::Error>::is::<Message>),
         "the nested Error retains its typed frames"
     );
     assert!(
         raised
             .iter_errors_with_locations()
-            .any(|source| source.error().is::<ValidationError>()),
+            .any(|source| source.error().is::<Message>()),
         "iter_errors_with_locations() recursively exposes typed errors from nested Error values"
     );
+    insta::assert_debug_snapshot!(raised, "probable_cause() returns the stored error, not a string-backed copy", @r#"
+    Message {
+        message: "revision parsing failed",
+    }
+    "#);
     assert!(
-        raised.probable_cause().is::<ValidationError>(),
+        raised.probable_cause().is::<Message>(),
         "probable_cause() returns the stored error, not a string-backed copy"
     );
 }
diff --git a/gix-error/tests/error/classification.rs b/gix-error/tests/error/classification.rs
index 81efd09b710..f359f7c8c07 100644
--- a/gix-error/tests/error/classification.rs
+++ b/gix-error/tests/error/classification.rs
@@ -1,6 +1,6 @@
 use gix_error::{
-    Class, CorruptionError, Error, ErrorExt, ResourceExhaustionError, ResourceExhaustionKind, RetryableError,
-    ValidationError, can_retry, can_retry_lenient, message,
+    Class, ClassificationMarker, Error, ErrorExt, Message, ResourceExhaustionKind, classify, corruption, message,
+    not_found, resource_exhaustion, validation,
 };
 
 #[test]
@@ -11,14 +11,29 @@ fn classifications_preserve_order_duplicates_and_sources() {
             .expect_err("the maximum capacity cannot be reserved")
     }
     let err = Error::from(
-        RetryableError::new(allocation_failure()).and_raise(CorruptionError::new("corrupt input caused allocation")),
+        ClassificationMarker::with_source(Class::Retryable, allocation_failure())
+            .and_raise(corruption("corrupt input caused allocation")),
     );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "classification retains each independent cause", @r#"
+        Message {
+            message: "corrupt input caused allocation",
+            class: Corruption,
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "classification retains each independent cause", @"
+        corrupt input caused allocation
+        |
+        └─ memory allocation failed because the computed capacity exceeded the collection's maximum
+        ");
+    }
     let classifications = err.classify().collect::<Vec<_>>();
 
     assert_eq!(
         classifications
             .iter()
-            .map(gix_error::Classification::class)
+            .map(gix_error::types::Classification::class)
             .collect::<Vec<_>>(),
         [
             Class::Corruption,
@@ -27,15 +42,25 @@ fn classifications_preserve_order_duplicates_and_sources() {
         ],
         "classification follows the error graph without merging independent meanings"
     );
-    assert!(classifications[0].error().is::<CorruptionError>());
-    assert!(classifications[1].error().is::<RetryableError>());
+    assert!(classifications[0].error().is::<Message>());
+    assert!(classifications[1].error().is::<ClassificationMarker>());
     assert!(classifications[2].error().is::<std::collections::TryReserveError>());
 
-    let duplicate = Error::from(
-        ValidationError::new("first")
-            .raise()
-            .chain(ValidationError::new("second")),
-    );
+    let duplicate = Error::from(validation("first").raise().chain(validation("second")));
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(duplicate, "separate invalid inputs retain separate diagnostics", @r#"
+        Message {
+            message: "first",
+            class: Validation,
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(duplicate, "separate invalid inputs retain separate diagnostics", @"
+        first
+        |
+        └─ second
+        ");
+    }
     assert_eq!(
         duplicate.classify().map(|item| item.class()).collect::<Vec<_>>(),
         [Class::Validation, Class::Validation],
@@ -45,6 +70,7 @@ fn classifications_preserve_order_duplicates_and_sources() {
 
 #[test]
 fn io_errors_are_normalized_without_losing_their_origin() {
+    let mut diagnostics = Vec::new();
     let cases = [
         (std::io::ErrorKind::NotFound, Class::NotFound),
         (
@@ -59,16 +85,30 @@ fn io_errors_are_normalized_without_losing_their_origin() {
 
     for (io_kind, expected_class) in cases {
         let err = Error::from_error(std::io::Error::from(io_kind));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         let classification = err.classify().next().expect("all I/O errors are classified");
         assert_eq!(classification.class(), expected_class);
         assert_eq!(classification.io_kind(), Some(io_kind));
         assert!(classification.error().is::<std::io::Error>());
     }
+    insta::assert_debug_snapshot!(diagnostics, "io errors are normalized without losing their origin", @"
+    [
+        Kind(
+            NotFound,
+        ),
+        Kind(
+            OutOfMemory,
+        ),
+        Kind(
+            PermissionDenied,
+        ),
+    ]
+    ");
 }
 
 #[test]
 fn allocation_limits_are_resources_only() {
-    let err = Error::from_error(ResourceExhaustionError::new(
+    let err = Error::from_error(resource_exhaustion(
         ResourceExhaustionKind::AllocationLimit,
         "configured allocation limit exceeded",
     ));
@@ -77,33 +117,64 @@ fn allocation_limits_are_resources_only() {
         err.classify().map(|item| item.class()).collect::<Vec<_>>(),
         [Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit)]
     );
+    insta::assert_debug_snapshot!(err, "allocation limits are resources only", @r#"
+    Message {
+        message: "configured allocation limit exceeded",
+        class: ResourceExhaustion(AllocationLimit),
+    }
+    "#);
     assert!(!err.is_corrupted());
     assert!(!err.can_retry());
 }
 
 #[test]
-fn global_retry_policy_is_conservative() {
+fn borrowed_retry_policy_is_conservative() {
+    let mut inline_error_diagnostics = Vec::new();
     for kind in [std::io::ErrorKind::Interrupted, std::io::ErrorKind::TimedOut] {
-        assert!(
-            can_retry(&std::io::Error::from(kind)),
-            "{kind:?} can be retried globally"
-        );
+        let err = std::io::Error::from(kind);
+        inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(classify(&err).can_retry(), "{kind:?} can be retried conservatively");
     }
     for kind in [
         std::io::ErrorKind::OutOfMemory,
         std::io::ErrorKind::ConnectionReset,
         std::io::ErrorKind::UnexpectedEof,
     ] {
-        assert!(
-            !can_retry(&std::io::Error::from(kind)),
-            "{kind:?} needs explicit retry policy"
-        );
+        let err = std::io::Error::from(kind);
+        inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(!classify(&err).can_retry(), "{kind:?} needs explicit retry policy");
+    }
+    let err = ClassificationMarker::with_source(Class::Retryable, message("try again"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "borrowed retry policy is conservative", @r#"
+    Message {
+        message: "try again",
     }
-    assert!(can_retry(&RetryableError::new(message("try again"))));
+    "#);
+    assert!(classify(&err).can_retry());
+    insta::assert_debug_snapshot!(inline_error_diagnostics, "borrowed retry policy is conservative", @"
+    [
+        Kind(
+            Interrupted,
+        ),
+        Kind(
+            TimedOut,
+        ),
+        Kind(
+            OutOfMemory,
+        ),
+        Kind(
+            ConnectionReset,
+        ),
+        Kind(
+            UnexpectedEof,
+        ),
+    ]
+    ");
 }
 
 #[test]
 fn lenient_retry_policy_preserves_the_previous_io_kinds() {
+    let mut inline_error_diagnostics = Vec::new();
     for kind in [
         std::io::ErrorKind::Interrupted,
         std::io::ErrorKind::UnexpectedEof,
@@ -115,44 +186,109 @@ fn lenient_retry_policy_preserves_the_previous_io_kinds() {
         std::io::ErrorKind::ConnectionReset,
         std::io::ErrorKind::ConnectionRefused,
     ] {
+        let err = std::io::Error::from(kind);
+        inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert!(
-            can_retry_lenient(&std::io::Error::from(kind)),
+            classify(&err).can_retry_lenient(),
             "{kind:?} is retryable under the lenient policy"
         );
     }
 
+    let err = Error::from_error(std::io::Error::from(std::io::ErrorKind::PermissionDenied));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "the lenient policy still rejects permanent I/O errors", @"
+    Kind(
+        PermissionDenied,
+    )
+    ");
     assert!(
-        !Error::from_error(std::io::Error::from(std::io::ErrorKind::PermissionDenied)).can_retry_lenient(),
+        !err.can_retry_lenient(),
         "the lenient policy still rejects permanent I/O errors"
     );
+    let err = Error::from_error(ClassificationMarker::with_source(
+        Class::Retryable,
+        message("try again"),
+    ));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "the lenient policy includes explicitly retryable errors", @r#"
+    Message {
+        message: "try again",
+    }
+    "#);
     assert!(
-        Error::from_error(RetryableError::new(message("try again"))).can_retry_lenient(),
+        err.can_retry_lenient(),
         "the lenient policy includes explicitly retryable errors"
     );
     let allocation_failure = Vec::<u8>::new()
         .try_reserve(usize::MAX)
         .expect_err("the maximum capacity cannot be reserved");
+    let err = Error::from_error(allocation_failure);
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "only I/O OutOfMemory errors are covered by the historical policy", @"
+    TryReserveError {
+        kind: CapacityOverflow,
+    }
+    ");
     assert!(
-        !Error::from_error(allocation_failure).can_retry_lenient(),
+        !err.can_retry_lenient(),
         "only I/O OutOfMemory errors are covered by the historical policy"
     );
+    insta::assert_debug_snapshot!(inline_error_diagnostics, "lenient retry policy preserves the previous io kinds", @"
+    [
+        Kind(
+            Interrupted,
+        ),
+        Kind(
+            UnexpectedEof,
+        ),
+        Kind(
+            OutOfMemory,
+        ),
+        Kind(
+            TimedOut,
+        ),
+        Kind(
+            BrokenPipe,
+        ),
+        Kind(
+            AddrInUse,
+        ),
+        Kind(
+            ConnectionAborted,
+        ),
+        Kind(
+            ConnectionReset,
+        ),
+        Kind(
+            ConnectionRefused,
+        ),
+    ]
+    ");
 }
 
 #[test]
 fn unknown_errors_are_omitted() {
-    assert_eq!(Error::from_error(message("unknown")).classify().count(), 0);
+    let err = Error::from_error(message("unknown"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "unknown errors are omitted", @r#"
+    Message {
+        message: "unknown",
+    }
+    "#);
+    assert_eq!(err.classify().count(), 0);
 }
 
 #[test]
 fn explicit_retryability_is_distinct_from_io_retry_policy() {
-    let explicit = RetryableError::new(message("try again")).raise();
+    let mut diagnostics = Vec::new();
+    let explicit = ClassificationMarker::with_source(Class::Retryable, message("try again")).raise();
+    insta::assert_debug_snapshot!(explicit, "typed exceptions expose their retry marker", @"try again");
     assert!(explicit.is_retryable(), "typed exceptions expose their retry marker");
 
     let nested = Error::from(
         message("nested operation")
             .raise()
             .chain(message("unrelated cause"))
-            .chain(RetryableError::new(message("try again"))),
+            .chain(ClassificationMarker::with_source(
+                Class::Retryable,
+                message("try again"),
+            )),
     );
     for err in [
         explicit.erased(),
@@ -161,10 +297,11 @@ fn explicit_retryability_is_distinct_from_io_retry_policy() {
             .raise()
             .chain(crate::ErrorWithSource(
                 "native source",
-                RetryableError::new(message("try again")),
+                ClassificationMarker::with_source(Class::Retryable, message("try again")),
             ))
             .erased(),
     ] {
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert!(
             err.is_retryable(),
             "markers survive erasure, branches, and native sources"
@@ -177,18 +314,83 @@ fn explicit_retryability_is_distinct_from_io_retry_policy() {
 
     for kind in [std::io::ErrorKind::Interrupted, std::io::ErrorKind::TimedOut] {
         let err = std::io::Error::from(kind).and_raise(message("I/O failed"));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert!(!err.is_retryable(), "{kind:?} has no explicit retry marker");
         let err = err.into_error();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert!(!err.is_retryable(), "conversion must not add a retry marker");
         assert!(err.can_retry(), "the retry policy still accepts {kind:?}");
     }
     let unknown = message("retryable in name only").raise();
+    insta::assert_debug_snapshot!(unknown, "messages do not establish a classification", @"retryable in name only");
     assert!(!unknown.is_retryable(), "messages do not establish a classification");
     assert!(!unknown.into_error().is_retryable());
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "explicit retryability is distinct from io retry policy", @r#"
+        [
+            try again,
+            outer operation
+            |
+            └─ nested operation
+            |
+            └─ unrelated cause
+            |
+            └─ try again,
+            outer operation
+            |
+            └─ native source
+            |
+            └─ try again,
+            I/O failed
+            |
+            └─ operation interrupted,
+            Message {
+                message: "I/O failed",
+            },
+            I/O failed
+            |
+            └─ timed out,
+            Message {
+                message: "I/O failed",
+            },
+        ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "explicit retryability is distinct from io retry policy", @"
+        [
+            try again,
+            outer operation
+            |
+            └─ nested operation
+            |
+            └─ unrelated cause
+            |
+            └─ try again,
+            outer operation
+            |
+            └─ native source
+            |
+            └─ try again,
+            I/O failed
+            |
+            └─ operation interrupted,
+            I/O failed
+            |
+            └─ operation interrupted,
+            I/O failed
+            |
+            └─ timed out,
+            I/O failed
+            |
+            └─ timed out,
+        ]
+        ");
+    }
 }
 
 #[test]
 fn resource_exhaustion_predicates_normalize_allocation_failures() {
+    let mut diagnostics = Vec::new();
     let allocation = Vec::<u8>::new()
         .try_reserve(usize::MAX)
         .expect_err("the maximum capacity cannot be reserved");
@@ -197,13 +399,14 @@ fn resource_exhaustion_predicates_normalize_allocation_failures() {
         std::io::Error::from(std::io::ErrorKind::OutOfMemory),
     ));
     for cause in [
-        ResourceExhaustionError::new(ResourceExhaustionKind::AllocationLimit, "limit exceeded").raise_erased(),
-        ResourceExhaustionError::new(ResourceExhaustionKind::AllocationFailure, "allocation failed").raise_erased(),
+        resource_exhaustion(ResourceExhaustionKind::AllocationLimit, "limit exceeded").raise_erased(),
+        resource_exhaustion(ResourceExhaustionKind::AllocationFailure, "allocation failed").raise_erased(),
         allocation.raise_erased(),
         std::io::Error::from(std::io::ErrorKind::OutOfMemory).raise_erased(),
         nested.raise_erased(),
     ] {
         let err = cause.raise(message("operation failed"));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert!(
             err.is_resource_exhausted(),
             "all known allocation failures are classified"
@@ -215,8 +418,8 @@ fn resource_exhaustion_predicates_normalize_allocation_failures() {
     }
 
     for err in [
-        ValidationError::new("invalid input").raise_erased(),
-        CorruptionError::new("invalid data").raise_erased(),
+        validation("invalid input").raise_erased(),
+        corruption("invalid data").raise_erased(),
         std::io::Error::from(std::io::ErrorKind::PermissionDenied).raise_erased(),
         message("allocation failed in name only").raise_erased(),
     ] {
@@ -226,19 +429,51 @@ fn resource_exhaustion_predicates_normalize_allocation_failures() {
         );
         assert!(!err.into_error().is_resource_exhausted());
     }
+    insta::assert_debug_snapshot!(diagnostics, "resource exhaustion predicates normalize allocation failures", @"
+    [
+        operation failed
+        |
+        └─ limit exceeded,
+        operation failed
+        |
+        └─ allocation failed,
+        operation failed
+        |
+        └─ memory allocation failed because the computed capacity exceeded the collection's maximum,
+        operation failed
+        |
+        └─ out of memory,
+        operation failed
+        |
+        └─ native allocation failure
+        |
+        └─ out of memory,
+    ]
+    ");
 }
 
 #[test]
 fn exceptions_expose_ordered_classifications_without_conversion() {
     let nested = Error::from(
-        ValidationError::new("nested input")
+        validation("nested input")
             .raise()
             .chain(std::io::Error::from(std::io::ErrorKind::OutOfMemory)),
     );
     let err = crate::ErrorWithSource("root", std::io::Error::from(std::io::ErrorKind::NotFound))
         .raise()
         .chain(nested)
-        .chain(ValidationError::new("sibling input"));
+        .chain(validation("sibling input"));
+    insta::assert_debug_snapshot!(err, "native sources and nested errors retain their diagnostics", @"
+    root
+    |
+    └─ entity not found
+    |
+    └─ nested input
+    |   |
+    |   └─ out of memory
+    |
+    └─ sibling input
+    ");
     let expected = [
         Class::NotFound,
         Class::Validation,
@@ -249,7 +484,7 @@ fn exceptions_expose_ordered_classifications_without_conversion() {
     assert_eq!(
         classifications
             .iter()
-            .map(gix_error::Classification::class)
+            .map(gix_error::types::Classification::class)
             .collect::<Vec<_>>(),
         expected,
         "native sources and nested errors share breadth-first ordering without deduplicating classes"
@@ -264,24 +499,16 @@ fn exceptions_expose_ordered_classifications_without_conversion() {
         Some(std::io::ErrorKind::OutOfMemory),
         "normalizing a nested I/O error to resource exhaustion retains its original I/O kind"
     );
-    assert_eq!(
-        classifications[1]
+    insta::assert_debug_snapshot!(format_args!("{}", classifications[1]
             .error()
-            .downcast_ref::<ValidationError>()
+            .downcast_ref::<Message>()
             .expect("retain the sibling type")
-            .to_string(),
-        "sibling input",
-        "breadth-first classification visits the direct sibling before the nested validation error"
-    );
-    assert_eq!(
-        classifications[2]
+            ), "breadth-first classification visits the direct sibling before the nested validation error", @"sibling input");
+    insta::assert_debug_snapshot!(format_args!("{}", classifications[2]
             .error()
-            .downcast_ref::<ValidationError>()
+            .downcast_ref::<Message>()
             .expect("retain the nested type")
-            .to_string(),
-        "nested input",
-        "nested error boundaries preserve the original validation error and its message"
-    );
+            ), "nested error boundaries preserve the original validation error and its message", @"nested input");
 
     let err = err.erased();
     assert_eq!(
@@ -294,8 +521,10 @@ fn exceptions_expose_ordered_classifications_without_conversion() {
         expected,
         "conversion to Error preserves classification order and duplicate classes"
     );
+    let err = message("unclassified").raise();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "unrecognized errors are omitted from classifications", @"unclassified");
     assert_eq!(
-        message("unclassified").raise().classify().count(),
+        err.classify().count(),
         0,
         "unrecognized errors are omitted from classifications"
     );
@@ -303,6 +532,7 @@ fn exceptions_expose_ordered_classifications_without_conversion() {
 
 #[test]
 fn exceptions_expose_retry_policies_without_conversion() {
+    let mut diagnostics = Vec::new();
     use std::io::ErrorKind::*;
 
     for (kind, conservative, lenient) in [
@@ -320,6 +550,7 @@ fn exceptions_expose_retry_policies_without_conversion() {
     ] {
         let err =
             crate::ErrorWithSource("native wrapper", Error::from_error(std::io::Error::from(kind))).raise_erased();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert_eq!(err.can_retry(), conservative, "the conservative policy for {kind:?}");
         assert_eq!(err.can_retry_lenient(), lenient, "the lenient policy for {kind:?}");
         assert!(
@@ -327,6 +558,7 @@ fn exceptions_expose_retry_policies_without_conversion() {
             "I/O policy must not create an explicit retry marker"
         );
         let err = err.into_error();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
         assert_eq!(
             err.can_retry(),
             conservative,
@@ -339,9 +571,18 @@ fn exceptions_expose_retry_policies_without_conversion() {
         );
     }
 
-    let explicit = Error::from_error(message("context"))
-        .raise()
-        .chain(Error::from_error(RetryableError::new(message("try again"))));
+    let explicit =
+        Error::from_error(message("context"))
+            .raise()
+            .chain(Error::from_error(ClassificationMarker::with_source(
+                Class::Retryable,
+                message("try again"),
+            )));
+    insta::assert_debug_snapshot!(explicit, "both policies accept explicit markers", @"
+    context
+    |
+    └─ try again
+    ");
     assert!(
         explicit.can_retry() && explicit.can_retry_lenient(),
         "both policies accept explicit markers"
@@ -350,10 +591,802 @@ fn exceptions_expose_retry_policies_without_conversion() {
         .try_reserve(usize::MAX)
         .expect_err("the maximum capacity cannot be reserved")
         .raise();
+    insta::assert_debug_snapshot!(allocation, "allocation failures outside I/O retain their non-retryable classification", @"memory allocation failed because the computed capacity exceeded the collection's maximum");
     assert!(
         !allocation.can_retry() && !allocation.can_retry_lenient(),
         "allocation failures outside I/O retain their non-retryable classification"
     );
     let unknown = message("unknown").raise();
+    insta::assert_debug_snapshot!(unknown, "exceptions expose retry policies without conversion", @"unknown");
     assert!(!unknown.can_retry() && !unknown.can_retry_lenient());
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "exceptions expose retry policies without conversion", @r#"
+            [
+                native wrapper
+                |
+                └─ operation interrupted,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        Interrupted,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ timed out,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        TimedOut,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ unexpected end of file,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        UnexpectedEof,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ out of memory,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        OutOfMemory,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ broken pipe,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        BrokenPipe,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ address in use,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        AddrInUse,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ connection aborted,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        ConnectionAborted,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ connection reset,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        ConnectionReset,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ connection refused,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        ConnectionRefused,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ permission denied,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        PermissionDenied,
+                    ),
+                ),
+                native wrapper
+                |
+                └─ entity not found,
+                ErrorWithSource(
+                    "native wrapper",
+                    Kind(
+                        NotFound,
+                    ),
+                ),
+            ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "exceptions expose retry policies without conversion", @"
+        [
+            native wrapper
+            |
+            └─ operation interrupted,
+            native wrapper
+            |
+            └─ operation interrupted,
+            native wrapper
+            |
+            └─ timed out,
+            native wrapper
+            |
+            └─ timed out,
+            native wrapper
+            |
+            └─ unexpected end of file,
+            native wrapper
+            |
+            └─ unexpected end of file,
+            native wrapper
+            |
+            └─ out of memory,
+            native wrapper
+            |
+            └─ out of memory,
+            native wrapper
+            |
+            └─ broken pipe,
+            native wrapper
+            |
+            └─ broken pipe,
+            native wrapper
+            |
+            └─ address in use,
+            native wrapper
+            |
+            └─ address in use,
+            native wrapper
+            |
+            └─ connection aborted,
+            native wrapper
+            |
+            └─ connection aborted,
+            native wrapper
+            |
+            └─ connection reset,
+            native wrapper
+            |
+            └─ connection reset,
+            native wrapper
+            |
+            └─ connection refused,
+            native wrapper
+            |
+            └─ connection refused,
+            native wrapper
+            |
+            └─ permission denied,
+            native wrapper
+            |
+            └─ permission denied,
+            native wrapper
+            |
+            └─ entity not found,
+            native wrapper
+            |
+            └─ entity not found,
+        ]
+        ");
+    }
+}
+
+#[test]
+fn custom_io_payloads_retain_all_classifications() {
+    let mut diagnostics = Vec::new();
+    let cases: [(Box<dyn std::error::Error + Send + Sync>, Class); 5] = [
+        (Box::new(not_found("missing object")), Class::NotFound),
+        (Box::new(validation("invalid input")), Class::Validation),
+        (Box::new(corruption("malformed data")), Class::Corruption),
+        (
+            Box::new(ClassificationMarker::with_source(
+                Class::Retryable,
+                message("try again"),
+            )),
+            Class::Retryable,
+        ),
+        (
+            Box::new(resource_exhaustion(
+                ResourceExhaustionKind::AllocationLimit,
+                "limit exceeded",
+            )),
+            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit),
+        ),
+    ];
+    for (payload, class) in cases {
+        let err = crate::ErrorWithSource("custom backend failed", std::io::Error::other(payload));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert_eq!(classify(&err).is_not_found(), class == Class::NotFound);
+        assert_eq!(classify(&err).is_validation(), class == Class::Validation);
+        assert_eq!(classify(&err).is_corrupted(), class == Class::Corruption);
+        assert_eq!(classify(&err).is_retryable(), class == Class::Retryable);
+        assert_eq!(
+            classify(&err).is_resource_exhausted(),
+            matches!(class, Class::ResourceExhaustion(_)),
+            "all borrowed predicates reach custom errors through their sources"
+        );
+        assert_eq!(
+            classify(&err).can_retry(),
+            class == Class::Retryable,
+            "borrowed retry inspection reaches the I/O payload"
+        );
+        assert_eq!(
+            classify(&err).can_retry_lenient(),
+            class == Class::Retryable,
+            "both retry policies reach the I/O payload"
+        );
+        let err = err.raise();
+        assert_eq!(
+            err.classify().map(|item| item.class()).collect::<Vec<_>>(),
+            [Class::Io(std::io::ErrorKind::Other), class],
+            "the custom wrapper retains both the I/O error and its classified payload"
+        );
+        let err = err.into_error();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert_eq!(err.is_not_found(), class == Class::NotFound);
+        assert_eq!(err.is_validation(), class == Class::Validation);
+        assert_eq!(err.is_corrupted(), class == Class::Corruption);
+        assert_eq!(err.is_retryable(), class == Class::Retryable);
+        assert_eq!(err.can_retry(), class == Class::Retryable);
+        assert_eq!(err.can_retry_lenient(), class == Class::Retryable);
+        assert_eq!(
+            err.is_resource_exhausted(),
+            matches!(class, Class::ResourceExhaustion(_))
+        );
+    }
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "custom io payloads retain all classifications", @r#"
+        [
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "missing object",
+                        class: NotFound,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "missing object",
+                        class: NotFound,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "invalid input",
+                        class: Validation,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "invalid input",
+                        class: Validation,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "malformed data",
+                        class: Corruption,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "malformed data",
+                        class: Corruption,
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "try again",
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "try again",
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "limit exceeded",
+                        class: ResourceExhaustion(AllocationLimit),
+                    },
+                },
+            ),
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "limit exceeded",
+                        class: ResourceExhaustion(AllocationLimit),
+                    },
+                },
+            ),
+        ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "custom io payloads retain all classifications", @r#"
+        [
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "missing object",
+                        class: NotFound,
+                    },
+                },
+            ),
+            custom backend failed
+            |
+            └─ I/O error (Other)
+            |
+            └─ missing object,
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "invalid input",
+                        class: Validation,
+                    },
+                },
+            ),
+            custom backend failed
+            |
+            └─ I/O error (Other)
+            |
+            └─ invalid input,
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "malformed data",
+                        class: Corruption,
+                    },
+                },
+            ),
+            custom backend failed
+            |
+            └─ I/O error (Other)
+            |
+            └─ malformed data,
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "try again",
+                    },
+                },
+            ),
+            custom backend failed
+            |
+            └─ I/O error (Other)
+            |
+            └─ try again,
+            ErrorWithSource(
+                "custom backend failed",
+                Custom {
+                    kind: Other,
+                    error: Message {
+                        message: "limit exceeded",
+                        class: ResourceExhaustion(AllocationLimit),
+                    },
+                },
+            ),
+            custom backend failed
+            |
+            └─ I/O error (Other)
+            |
+            └─ limit exceeded,
+        ]
+        "#);
+    }
+}
+
+#[test]
+fn classification_markers_preserve_categories_and_origins() {
+    let mut diagnostics = Vec::new();
+    for class in [
+        Class::Validation,
+        Class::Corruption,
+        Class::NotFound,
+        Class::Retryable,
+        Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit),
+        Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure),
+        Class::Io(std::io::ErrorKind::TimedOut),
+    ] {
+        let marker = ClassificationMarker::with_class(class);
+        let err = crate::ErrorWithSource("specific diagnostic", marker);
+        let classification = classify(&err).next().expect("the source supplies a classification");
+        assert_eq!(
+            classification.class(),
+            class,
+            "the marker supplies its explicit category"
+        );
+        assert_eq!(
+            classification.io_kind(),
+            None,
+            "a classification marker does not invent an I/O origin"
+        );
+        assert!(
+            std::ptr::eq(
+                classification
+                    .error()
+                    .downcast_ref::<ClassificationMarker>()
+                    .expect("the original marker is retained"),
+                &err.1,
+            ),
+            "classification identifies the original marker rather than a fabricated causal error"
+        );
+
+        let err = err.and_raise(message("outer context")).erased();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert_eq!(
+            err.is_validation(),
+            class == Class::Validation,
+            "validation survives erasure"
+        );
+        assert_eq!(
+            err.is_corrupted(),
+            class == Class::Corruption,
+            "corruption survives erasure"
+        );
+        assert_eq!(err.is_not_found(), class == Class::NotFound, "absence survives erasure");
+        assert_eq!(
+            err.is_retryable(),
+            class == Class::Retryable,
+            "retry markers remain explicit"
+        );
+        assert_eq!(
+            err.is_resource_exhausted(),
+            matches!(class, Class::ResourceExhaustion(_)),
+            "resource classifications preserve their kinds"
+        );
+        assert_eq!(
+            err.can_retry(),
+            matches!(class, Class::Retryable | Class::Io(std::io::ErrorKind::TimedOut)),
+            "retry policies recognize the marker's classification"
+        );
+        for err in [
+            err.into_error(),
+            std::io::Error::other(ClassificationMarker::with_class(class))
+                .raise()
+                .into_error(),
+        ] {
+            assert!(
+                err.downcast_any_ref::<ClassificationMarker>().is_none(),
+                "public downcasts omit markers in converted errors and I/O payloads"
+            );
+            assert_eq!(
+                err.classify().last().expect("the marker is classified").class(),
+                class,
+                "conversion and I/O wrapping preserve classification"
+            );
+        }
+    }
+    insta::assert_debug_snapshot!(diagnostics, "classification markers preserve categories and origins", @"
+    [
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+        outer context
+        |
+        └─ specific diagnostic,
+    ]
+    ");
+}
+
+#[test]
+fn markers_remain_transparent_alongside_classified_errors() {
+    let marker = ClassificationMarker::VALIDATION;
+    assert!(
+        std::error::Error::source(&marker).is_none(),
+        "class-only markers do not fabricate further causes"
+    );
+    let err = crate::ErrorWithSource("specific diagnostic", marker)
+        .and_raise(validation("context with input").with("input", b"bad".as_slice()));
+    let classifications = err.classify().collect::<Vec<_>>();
+    assert_eq!(
+        classifications.len(),
+        2,
+        "real errors and markers are classified independently"
+    );
+    assert!(
+        classifications[0].error().is::<Message>(),
+        "the real error retains its type"
+    );
+    assert!(
+        classifications[1].error().is::<ClassificationMarker>(),
+        "the marker retains its type"
+    );
+    assert_eq!(
+        classifications
+            .iter()
+            .map(gix_error::types::Classification::class)
+            .collect::<Vec<_>>(),
+        [Class::Validation, Class::Validation],
+        "classifications remain ordered and are not deduplicated"
+    );
+    insta::assert_debug_snapshot!(err, "markers supply classifications without becoming diagnostic errors", @r#"
+    context with input, "input"="bad"
+    |
+    └─ specific diagnostic
+    "#);
+    assert!(
+        err.downcast_any_ref::<ClassificationMarker>().is_none(),
+        "markers supply classifications without becoming diagnostic errors"
+    );
+    assert!(
+        err.probable_cause()
+            .is::<crate::ErrorWithSource<ClassificationMarker>>(),
+        "the marker never replaces its typed diagnostic owner"
+    );
+    let err = err.into_error();
+    assert!(
+        err.downcast_any_ref::<ClassificationMarker>().is_none(),
+        "conversion preserves marker transparency"
+    );
+    assert!(
+        err.downcast_any_ref::<Message>().is_some(),
+        "conversion preserves genuine classified errors for downcasting"
+    );
+    assert!(
+        err.probable_cause()
+            .is::<crate::ErrorWithSource<ClassificationMarker>>(),
+        "conversion preserves the typed cause rather than its marker"
+    );
+    insta::assert_debug_snapshot!(err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(), "only real diagnostics remain visible in diagnostic iteration", @r#"
+    [
+        "context with input, \"input\"=\"bad\"",
+        "specific diagnostic",
+    ]
+    "#);
+    #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+    insta::assert_debug_snapshot!(err, @r#"
+    context with input, "input"="bad"
+    |
+    └─ specific diagnostic
+    "#);
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    insta::assert_debug_snapshot!(err, "chain Debug retains the classified message's concrete type", @r#"
+    Message {
+        message: "context with input",
+        class: Validation,
+        values: {"input": Bytes("bad")},
+    }
+    "#);
+}
+
+#[test]
+fn source_markers_hide_the_wrapper_but_preserve_the_original_error() {
+    let source = std::io::Error::from(std::io::ErrorKind::NotFound);
+    let err = ClassificationMarker::with_source(Class::Retryable, source).raise();
+    let expected_classes = [Class::Retryable, Class::NotFound];
+    assert_eq!(
+        err.classify().map(|item| item.class()).collect::<Vec<_>>(),
+        expected_classes,
+        "a source-bearing marker adds a classification without replacing its source's classification"
+    );
+    insta::assert_debug_snapshot!(err, "source-bearing markers are hidden from public downcasts", @"entity not found");
+    assert!(
+        err.downcast_any_ref::<ClassificationMarker>().is_none(),
+        "source-bearing markers are hidden from public downcasts"
+    );
+    assert!(
+        err.downcast_any_ref::<std::io::Error>().is_some(),
+        "the original source remains available for downcasting"
+    );
+    insta::assert_debug_snapshot!(err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(), "only the original error is yielded", @r#"
+    [
+        "entity not found",
+    ]
+    "#);
+    let err = err.into_error();
+    assert!(
+        err.downcast_any_ref::<ClassificationMarker>().is_none(),
+        "conversion retains the wrapper's transparency"
+    );
+    assert!(
+        err.downcast_any_ref::<std::io::Error>().is_some(),
+        "conversion preserves the original source type"
+    );
+    let classifications = err.classify().collect::<Vec<_>>();
+    assert_eq!(
+        classifications
+            .iter()
+            .map(gix_error::types::Classification::class)
+            .collect::<Vec<_>>(),
+        expected_classes,
+        "conversion preserves both classifications"
+    );
+    assert!(
+        classifications[0].error().is::<ClassificationMarker>(),
+        "classification retains the hidden wrapper as the origin of its explicit category"
+    );
+    assert_eq!(
+        classifications[1].io_kind(),
+        Some(std::io::ErrorKind::NotFound),
+        "the source retains its real I/O origin"
+    );
+    #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+    insta::assert_debug_snapshot!(err, @"entity not found");
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    insta::assert_debug_snapshot!(err, "chain Debug exposes the source without its marker", @"
+    Kind(
+        NotFound,
+    )
+    ");
+}
+
+#[test]
+fn io_payloads_retain_custom_errors_and_nested_branches() {
+    let mut diagnostics = Vec::new();
+    for custom_wrapper in [false, true] {
+        let nested = message("nested operation failed")
+            .raise()
+            .chain(validation("invalid input"))
+            .chain(ClassificationMarker::with_source(
+                Class::Retryable,
+                message("try again"),
+            ))
+            .into_error();
+        let payload: Box<dyn std::error::Error + Send + Sync> = if custom_wrapper {
+            Box::new(crate::ErrorWithSource("custom payload", nested))
+        } else {
+            Box::new(nested)
+        };
+        let io = std::io::Error::other(payload);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&io, &[]));
+        assert!(
+            classify(&io).can_retry(),
+            "borrowed inspection reaches every branch in an I/O payload"
+        );
+        assert!(classify(&io).is_validation());
+        let err = Error::from_error(io);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(err.can_retry(), "conversion retains retryable branches");
+        assert!(err.is_validation(), "conversion retains other classifications too");
+        if custom_wrapper {
+            assert!(
+                err.downcast_any_ref::<crate::ErrorWithSource<Error>>().is_some(),
+                "the custom payload remains available for downcasting"
+            );
+        }
+    }
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "io payloads retain custom errors and nested branches", @r#"
+        [
+            Custom {
+                kind: Other,
+                error: Message {
+                    message: "nested operation failed",
+                },
+            },
+            Custom {
+                kind: Other,
+                error: Message {
+                    message: "nested operation failed",
+                },
+            },
+            Custom {
+                kind: Other,
+                error: ErrorWithSource(
+                    "custom payload",
+                    Message {
+                        message: "nested operation failed",
+                    },
+                ),
+            },
+            Custom {
+                kind: Other,
+                error: ErrorWithSource(
+                    "custom payload",
+                    Message {
+                        message: "nested operation failed",
+                    },
+                ),
+            },
+        ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "io payloads retain custom errors and nested branches", @r#"
+        [
+            Custom {
+                kind: Other,
+                error: nested operation failed
+                |
+                └─ invalid input
+                |
+                └─ try again,
+            },
+            Custom {
+                kind: Other,
+                error: nested operation failed
+                |
+                └─ invalid input
+                |
+                └─ try again,
+            },
+            Custom {
+                kind: Other,
+                error: ErrorWithSource(
+                    "custom payload",
+                    nested operation failed
+                    |
+                    └─ invalid input
+                    |
+                    └─ try again,
+                ),
+            },
+            Custom {
+                kind: Other,
+                error: ErrorWithSource(
+                    "custom payload",
+                    nested operation failed
+                    |
+                    └─ invalid input
+                    |
+                    └─ try again,
+                ),
+            },
+        ]
+        "#);
+    }
 }
diff --git a/gix-error/tests/error/error.rs b/gix-error/tests/error/error.rs
index ecb2dacdd1f..2fc20e3c07c 100644
--- a/gix-error/tests/error/error.rs
+++ b/gix-error/tests/error/error.rs
@@ -1,7 +1,7 @@
 use crate::ErrorWithSource;
 #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
 use crate::{debug_string, fixup_paths, new_tree_error};
-use gix_error::{CorruptionError, Error, ErrorExt, Message, NotFoundError, RetryableError, ValidationError, message};
+use gix_error::{Class, ClassificationMarker, Error, ErrorExt, Message, corruption, message, not_found, validation};
 #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
 use std::error::Error as _;
 
@@ -138,16 +138,14 @@ fn from_exn_error_tree() {
         file!(),
         "errors with locations expose their caller location"
     );
-    assert_eq!(
-        err.source().map(debug_string).as_deref(),
-        Some(r#"Message("E6")"#),
-        "The source is the first child"
-    );
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "E6",
-        "we get the top-most error that has most causes"
-    );
+    insta::assert_debug_snapshot!(err.source(), "The source is the first child", @r#"
+    Some(
+        Message {
+            message: "E6",
+        },
+    )
+    "#);
+    insta::assert_debug_snapshot!(format_args!("{}", err.probable_cause()), "the first causal branch selects its aggregate", @"E6");
 }
 
 #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
@@ -155,14 +153,14 @@ fn from_exn_error_tree() {
 fn from_any_error() {
     let err = Error::from_error(message("one"));
     assert_eq!(err, "one");
-    assert_eq!(debug_string(&err), r#"Message("one")"#);
+    insta::assert_compact_debug_snapshot!(&err, "wrapping a native error preserves its diagnostic", @r#"Message { message: "one" }"#);
     insta::assert_debug_snapshot!(err, @r#"
-    Message(
-        "one",
-    )
+    Message {
+        message: "one",
+    }
     "#);
     assert_eq!(err.source().map(debug_string), None);
-    assert_eq!(err.probable_cause().to_string(), "one");
+    insta::assert_debug_snapshot!(format_args!("{}", err.probable_cause()), "wrapping a native error preserves its diagnostic", @"one");
 }
 
 #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
@@ -170,20 +168,22 @@ fn from_any_error() {
 fn from_any_error_with_source() {
     let err = Error::from_error(ErrorWithSource("main", message("one")));
     assert_eq!(err, "main", "display is the error itself");
-    assert_eq!(debug_string(&err), r#"ErrorWithSource("main", Message("one"))"#);
+    insta::assert_compact_debug_snapshot!(&err, "native errors preserve their own Debug representation", @r#"ErrorWithSource("main", Message { message: "one" })"#);
     insta::assert_debug_snapshot!(err, @r#"
     ErrorWithSource(
         "main",
-        Message(
-            "one",
-        ),
+        Message {
+            message: "one",
+        },
+    )
+    "#);
+    insta::assert_debug_snapshot!(err.source(), "The source is provided by the wrapped error", @r#"
+    Some(
+        Message {
+            message: "one",
+        },
     )
     "#);
-    assert_eq!(
-        err.source().map(debug_string).as_deref(),
-        Some(r#"Message("one")"#),
-        "The source is provided by the wrapped error"
-    );
 }
 
 #[test]
@@ -206,6 +206,17 @@ fn native_sources_retain_types_without_claiming_frame_locations() {
         errors[2].is::<Message>(),
         "the native source leaf retains its concrete type"
     );
+    insta::assert_debug_snapshot!(err, "downcast_any_ref() searches native sources as well as stored frames", @r#"
+    ErrorWithSource(
+        "top",
+        ErrorWithSource(
+            "middle",
+            Message {
+                message: "bottom",
+            },
+        ),
+    )
+    "#);
     assert!(
         err.downcast_any_ref::<Middle>().is_some(),
         "downcast_any_ref() searches native sources as well as stored frames"
@@ -236,17 +247,15 @@ fn native_sources_retain_types_without_claiming_frame_locations() {
             .raise()
             .chain(ErrorWithSource("explicit child", message("child source"))),
     );
-    assert_eq!(
-        err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(),
-        [
-            "root",
-            "root source",
-            "explicit child",
-            "root source leaf",
-            "child source",
-        ],
-        "native sources and explicit frames share one logical breadth-first order"
-    );
+    insta::assert_debug_snapshot!(err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(), "native sources and explicit frames share one logical breadth-first order", @r#"
+    [
+        "root",
+        "root source",
+        "explicit child",
+        "root source leaf",
+        "child source",
+    ]
+    "#);
     assert_eq!(
         err.iter_errors_with_locations()
             .map(|source| source.location().is_some())
@@ -285,18 +294,16 @@ fn nested_errors_are_expanded_in_breadth_first_order() {
         }
     }
 
-    let expected = [
+    let expected = err.iter_errors().map(name).collect::<Vec<_>>();
+    insta::assert_debug_snapshot!(expected, "a nested Error's root is queued behind the remaining errors at its wrapper's depth", @r#"
+    [
         "outer root",
-        r#"Message("nested root")"#,
+        "Message { message: \"nested root\" }",
         "outer sibling",
         "nested root",
         "nested child",
-    ];
-    assert_eq!(
-        err.iter_errors().map(name).collect::<Vec<_>>(),
-        expected,
-        "a nested Error's root is queued behind the remaining errors at its wrapper's depth"
-    );
+    ]
+    "#);
     assert_eq!(
         err.iter_errors_with_locations()
             .map(|source| name(source.error()))
@@ -310,151 +317,355 @@ fn nested_errors_are_expanded_in_breadth_first_order() {
 fn classification_survives_raising_a_converted_error() {
     let converted = Error::from_error(ErrorWithSource(
         "object lookup failed",
-        ValidationError::new("invalid object header"),
+        validation("invalid object header"),
     ));
     let err = converted.and_raise(message("revision parsing failed"));
 
+    insta::assert_debug_snapshot!(err, "exceptions inspect validation causes within nested errors", @"
+    revision parsing failed
+    |
+    └─ object lookup failed
+    |
+    └─ invalid object header
+    ");
     assert!(
         err.is_validation(),
         "exceptions inspect validation causes within nested errors"
     );
-    assert!(Error::from(err).is_validation());
-    assert!(ValidationError::new("invalid").raise().is_validation());
+    let err = Error::from(err);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "classification survives raising a converted error", @r#"
+        Message {
+            message: "revision parsing failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "classification survives raising a converted error", @"
+        revision parsing failed
+        |
+        └─ object lookup failed
+        |
+        └─ invalid object header
+        ");
+    }
+    assert!(err.is_validation());
+    let err = validation("invalid").raise();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "classification survives raising a converted error", @"invalid");
+    assert!(err.is_validation());
+    let err = std::io::Error::from(std::io::ErrorKind::InvalidInput).raise();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "an I/O kind does not establish an explicit validation classification", @"invalid input parameter");
     assert!(
-        !std::io::Error::from(std::io::ErrorKind::InvalidInput)
-            .raise()
-            .is_validation(),
+        !err.is_validation(),
         "an I/O kind does not establish an explicit validation classification"
     );
-    assert!(!message("validation failed").raise().is_validation());
+    let err = message("validation failed").raise();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "classification survives raising a converted error", @"validation failed");
+    assert!(!err.is_validation());
 }
 
 #[test]
 fn raising_a_converted_error_preserves_stored_types() {
-    let converted =
-        Error::from(ValidationError::new("invalid object header").and_raise(message("object lookup failed")));
+    let converted = Error::from(validation("invalid object header").and_raise(message("object lookup failed")));
     let converted = Error::from_error(converted);
     let err = Error::from(converted.and_raise(message("revision parsing failed")));
 
     assert!(
-        err.iter_errors().any(<dyn std::error::Error>::is::<ValidationError>),
+        err.iter_errors().any(<dyn std::error::Error>::is::<Message>),
         "the nested Error retains its typed frames"
     );
     assert!(
         err.iter_errors_with_locations()
-            .any(|source| source.error().is::<ValidationError>()),
+            .any(|source| source.error().is::<Message>()),
         "iter_errors_with_locations() recursively exposes typed errors from nested Error values"
     );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "probable_cause() returns the stored error, not a string-backed copy", @r#"
+        Message {
+            message: "revision parsing failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "probable_cause() returns the stored error, not a string-backed copy", @"
+        revision parsing failed
+        |
+        └─ object lookup failed
+        |
+        └─ invalid object header
+        ");
+    }
     assert!(
-        err.probable_cause().is::<ValidationError>(),
+        err.probable_cause().is::<Message>(),
         "probable_cause() returns the stored error, not a string-backed copy"
     );
 }
 
 #[test]
 fn validation_error_displays_input_with_debug_formatting() {
-    let err = ValidationError::new_with_input("invalid input", "hello\n ");
-    assert_eq!(
-        err.to_string(),
-        "invalid input: \"hello\\n \"",
-        "it won't hide whitespace and other special characters"
-    );
-    assert!(Error::from_error(err).is_validation());
-    assert!(Error::from_error(ErrorWithSource("validation failed", ValidationError::new("invalid"))).is_validation());
+    let err = validation("invalid input").with("input", b"hello\n ".as_slice());
+    insta::assert_debug_snapshot!(format_args!("{}", err), "it won't hide whitespace and other special characters", @r#"invalid input, "input"="hello\n ""#);
+    let err = Error::from_error(err);
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "validation error displays input with debug formatting", @r#"
+    Message {
+        message: "invalid input",
+        class: Validation,
+        values: {"input": Bytes("hello\n ")},
+    }
+    "#);
+    assert!(err.is_validation());
+    let err = Error::from_error(ErrorWithSource("validation failed", validation("invalid")));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "validation error displays input with debug formatting", @r#"
+    ErrorWithSource(
+        "validation failed",
+        Message {
+            message: "invalid",
+            class: Validation,
+        },
+    )
+    "#);
+    assert!(err.is_validation());
 }
 
 #[test]
 fn retryability_is_discovered_in_the_error_chain() {
     let retryable =
         std::io::Error::new(std::io::ErrorKind::TimedOut, "too slow").and_raise(message("network operation failed"));
-    assert!(Error::from(retryable).can_retry());
+    let err = Error::from(retryable);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @r#"
+        Message {
+            message: "network operation failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @"
+        network operation failed
+        |
+        └─ I/O error (TimedOut)
+        |
+        └─ too slow
+        ");
+    }
+    assert!(err.can_retry());
 
     let permanent = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "denied")
         .and_raise(message("network operation failed"));
-    assert!(!Error::from(permanent).can_retry());
+    let err = Error::from(permanent);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @r#"
+        Message {
+            message: "network operation failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @"
+        network operation failed
+        |
+        └─ I/O error (PermissionDenied)
+        |
+        └─ denied
+        ");
+    }
+    assert!(!err.can_retry());
 
-    let dependency_specific =
-        RetryableError::new(message("HTTP/2 stream failed")).and_raise(message("network operation failed"));
-    assert!(Error::from(dependency_specific).can_retry());
+    let dependency_specific = ClassificationMarker::with_source(Class::Retryable, message("HTTP/2 stream failed"))
+        .and_raise(message("network operation failed"));
+    let err = Error::from(dependency_specific);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @r#"
+        Message {
+            message: "network operation failed",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "retryability is discovered in the error chain", @"
+        network operation failed
+        |
+        └─ HTTP/2 stream failed
+        ");
+    }
+    assert!(err.can_retry());
 }
 
 #[test]
 fn corruption_is_discovered_in_the_error_chain() {
-    let corrupt = CorruptionError::new("checksum mismatch").and_raise(message("failed to open object database"));
+    let corrupt = corruption("checksum mismatch").and_raise(message("failed to open object database"));
+    insta::assert_debug_snapshot!(corrupt, "exceptions recognize corruption below context", @"
+    failed to open object database
+    |
+    └─ checksum mismatch
+    ");
     assert!(corrupt.is_corrupted(), "exceptions recognize corruption below context");
-    assert!(Error::from(corrupt).is_corrupted());
+    let err = Error::from(corrupt);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @r#"
+        Message {
+            message: "failed to open object database",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @"
+        failed to open object database
+        |
+        └─ checksum mismatch
+        ");
+    }
+    assert!(err.is_corrupted());
 
-    let nested =
-        Error::from_error(ErrorWithSource("invalid stream", CorruptionError::new("bad checksum"))).raise_erased();
+    let nested = Error::from_error(ErrorWithSource("invalid stream", corruption("bad checksum"))).raise_erased();
+    insta::assert_debug_snapshot!(nested, "erased exceptions inspect native sources in nested errors", @"
+    invalid stream
+    |
+    └─ bad checksum
+    ");
     assert!(
         nested.is_corrupted(),
         "erased exceptions inspect native sources in nested errors"
     );
+    let err = std::io::Error::from(std::io::ErrorKind::InvalidData).raise();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "an I/O kind does not establish an explicit corruption classification", @"invalid data");
     assert!(
-        !std::io::Error::from(std::io::ErrorKind::InvalidData)
-            .raise()
-            .is_corrupted(),
+        !err.is_corrupted(),
         "an I/O kind does not establish an explicit corruption classification"
     );
     let unknown = message("repository was not found").raise();
+    insta::assert_debug_snapshot!(unknown, "messages do not establish a classification", @"repository was not found");
     assert!(!unknown.is_corrupted(), "messages do not establish a classification");
-    assert!(!Error::from(unknown).is_corrupted());
+    let err = Error::from(unknown);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @r#"
+        Message {
+            message: "repository was not found",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "corruption is discovered in the error chain", @"repository was not found");
+    }
+    assert!(!err.is_corrupted());
 }
 
 #[test]
 fn from_boxed_does_not_repeat_the_wrapped_error_as_its_source() {
     let err = Error::from_boxed(Box::new(message("boxed error")));
 
-    assert_eq!(
-        format!("{err:#}"),
-        "boxed error",
-        "location-free formatting displays the boxed error as the root"
-    );
+    insta::assert_debug_snapshot!(format_args!("{err:#}"), "location-free formatting displays the boxed error as the root", @"boxed error");
     assert!(
         std::error::Error::source(&err).is_none(),
         "a boxed leaf error must not also appear as its own source"
     );
-    assert_eq!(
-        err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(),
-        ["boxed error"],
-        "error iteration must yield the boxed error only once"
-    );
+    insta::assert_debug_snapshot!(err.iter_errors().map(ToString::to_string).collect::<Vec<_>>(), "error iteration must yield the boxed error only once", @r#"
+    [
+        "boxed error",
+    ]
+    "#);
 }
 
 #[test]
 fn not_found_is_discovered_in_well_known_errors() {
-    let classified = NotFoundError::new("reference does not exist").and_raise(message("failed to resolve HEAD"));
+    let classified = not_found("reference does not exist").and_raise(message("failed to resolve HEAD"));
+    insta::assert_debug_snapshot!(classified, "exceptions recognize missing-resource markers", @"
+    failed to resolve HEAD
+    |
+    └─ reference does not exist
+    ");
     assert!(
         classified.is_not_found(),
         "exceptions recognize missing-resource markers"
     );
-    assert!(Error::from(classified).is_not_found());
+    let err = Error::from(classified);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+        Message {
+            message: "failed to resolve HEAD",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @"
+        failed to resolve HEAD
+        |
+        └─ reference does not exist
+        ");
+    }
+    assert!(err.is_not_found());
 
     let io = std::io::Error::new(std::io::ErrorKind::NotFound, "missing index")
         .and_raise(message("failed to open repository"));
+    insta::assert_debug_snapshot!(io, "exceptions normalize I/O not-found errors", @"
+    failed to open repository
+    |
+    └─ I/O error (NotFound)
+    |
+    └─ missing index
+    ");
     assert!(io.is_not_found(), "exceptions normalize I/O not-found errors");
-    assert!(Error::from(io).is_not_found());
+    let err = Error::from(io);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+        Message {
+            message: "failed to open repository",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @"
+        failed to open repository
+        |
+        └─ I/O error (NotFound)
+        |
+        └─ missing index
+        ");
+    }
+    assert!(err.is_not_found());
 
     let boxed = Box::new(std::io::Error::new(std::io::ErrorKind::NotFound, "missing object"));
-    assert!(Error::from_boxed(boxed).is_not_found());
+    let err = Error::from_boxed(boxed);
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+    Custom {
+        kind: NotFound,
+        error: "missing object",
+    }
+    "#);
+    assert!(err.is_not_found());
 
     let invalid = ErrorWithSource("invalid config", std::io::Error::from(std::io::ErrorKind::NotFound))
-        .and_raise(ValidationError::new("invalid worktree"))
+        .and_raise(validation("invalid worktree"))
         .erased();
+    insta::assert_debug_snapshot!(invalid, "a validation boundary does not hide its missing-resource source", @"
+    invalid worktree
+    |
+    └─ invalid config
+    |
+    └─ entity not found
+    ");
     assert!(
         invalid.is_not_found(),
         "a validation boundary does not hide its missing-resource source"
     );
     let denied = std::io::Error::from(std::io::ErrorKind::PermissionDenied).raise();
+    insta::assert_debug_snapshot!(denied, "other I/O kinds are not missing resources", @"permission denied");
     assert!(!denied.is_not_found(), "other I/O kinds are not missing resources");
     let unknown = message("permission denied").raise();
+    insta::assert_debug_snapshot!(unknown, "messages do not establish a classification", @"permission denied");
     assert!(!unknown.is_not_found(), "messages do not establish a classification");
-    assert!(!Error::from(unknown).is_not_found());
+    let err = Error::from(unknown);
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @r#"
+        Message {
+            message: "permission denied",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "not found is discovered in well known errors", @"permission denied");
+    }
+    assert!(!err.is_not_found());
 }
 
 #[test]
 fn equality_with_strings_uses_the_root_errors_display() {
     let exn = message("cause").raise().raise(message("failure"));
+    insta::assert_debug_snapshot!(exn, "string equality uses the root while diagnostics retain its cause", @"
+    failure
+    |
+    └─ cause
+    ");
     assert_eq!(exn, "failure");
     assert_eq!(exn, String::from("failure"));
     assert_eq!(&exn, "failure");
@@ -467,6 +678,11 @@ fn equality_with_strings_uses_the_root_errors_display() {
     assert_ne!(error, "other");
 
     let nested = Error::from(message("nested cause").raise().raise(message("nested root"))).raise_erased();
+    insta::assert_debug_snapshot!(nested, "nested error boundaries retain their context and cause", @"
+    nested root
+    |
+    └─ nested cause
+    ");
     assert_eq!(nested, "nested root", "nested error boundaries are transparent");
     assert_eq!(Error::from(nested), "nested root");
 }
diff --git a/gix-error/tests/error/exn.rs b/gix-error/tests/error/exn.rs
index e5fd1b68be7..2b7861fe5dd 100644
--- a/gix-error/tests/error/exn.rs
+++ b/gix-error/tests/error/exn.rs
@@ -16,7 +16,7 @@ use crate::{ErrorWithSource, fixup_paths, new_tree_error};
 use gix_error::OptionExt;
 use gix_error::ResultExt;
 use gix_error::{ErrorExt, message};
-use gix_error::{Exn, Message};
+use gix_error::{Exn, ExnMessageResult, Message};
 
 #[test]
 fn raise_chain() {
@@ -61,15 +61,15 @@ fn raise_chain() {
     └─ E1
     ");
     insta::assert_snapshot!(format!("{e:#}"), "alternate display exposes erased message types", @r#"
-    Message("E5")
+    Message { message: "E5" }
     |
-    └─ Message("E4")
+    └─ Message { message: "E4" }
         |
-        └─ Message("E3")
+        └─ Message { message: "E3" }
             |
-            └─ Message("E2")
+            └─ Message { message: "E2" }
                 |
-                └─ Message("E1")
+                └─ Message { message: "E1" }
     "#);
     insta::assert_snapshot!(format!("{e:}"), "standard display shows only the top message", @"E5");
 
@@ -100,30 +100,28 @@ fn raise_chain() {
     ");
 
     insta::assert_snapshot!(format!("{e:#}"), "repeated erasure preserves alternate display", @r#"
-    Message("E5")
+    Message { message: "E5" }
     |
-    └─ Message("E4")
+    └─ Message { message: "E4" }
         |
-        └─ Message("E3")
+        └─ Message { message: "E3" }
             |
-            └─ Message("E2")
+            └─ Message { message: "E2" }
                 |
-                └─ Message("E1")
+                └─ Message { message: "E1" }
     "#);
-    assert_eq!(
-        e.into_error().probable_cause().to_string(),
-        "E1",
-        "linear chains are just followed"
-    );
+    insta::assert_debug_snapshot!(format_args!("{}", e.into_error().probable_cause()), "linear chains are just followed", @"E1");
 }
 
 #[test]
 fn and_raise() {
     let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
     let exn = io_err.and_raise(message("could not read config"));
-    insta::assert_debug_snapshot!(exn, "and_raise links context above its source", @r"
+    insta::assert_debug_snapshot!(exn, "and_raise retains context, the I/O error, and its payload", @"
     could not read config
     |
+    └─ I/O error (NotFound)
+    |
     └─ file not found
     ");
 
@@ -173,35 +171,35 @@ fn raise_all() {
         └─ E4-3
     ");
     insta::assert_compact_debug_snapshot!(&e, "raise_all retains every caller location", @"
-    Top, at gix-error/tests/error/exn.rs:141
+    Top, at gix-error/tests/error/exn.rs:139
     |
-    └─ E1, at gix-error/tests/error/exn.rs:142
+    └─ E1, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E1-0, at gix-error/tests/error/exn.rs:142
+    |   └─ E1-0, at gix-error/tests/error/exn.rs:140
     |
-    └─ E2, at gix-error/tests/error/exn.rs:142
+    └─ E2, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E2-0, at gix-error/tests/error/exn.rs:142
+    |   └─ E2-0, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E2-1, at gix-error/tests/error/exn.rs:142
+    |   └─ E2-1, at gix-error/tests/error/exn.rs:140
     |
-    └─ E3, at gix-error/tests/error/exn.rs:142
+    └─ E3, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E3-0, at gix-error/tests/error/exn.rs:142
+    |   └─ E3-0, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E3-1, at gix-error/tests/error/exn.rs:142
+    |   └─ E3-1, at gix-error/tests/error/exn.rs:140
     |   |
-    |   └─ E3-2, at gix-error/tests/error/exn.rs:142
+    |   └─ E3-2, at gix-error/tests/error/exn.rs:140
     |
-    └─ E4, at gix-error/tests/error/exn.rs:142
+    └─ E4, at gix-error/tests/error/exn.rs:140
         |
-        └─ E4-0, at gix-error/tests/error/exn.rs:142
+        └─ E4-0, at gix-error/tests/error/exn.rs:140
         |
-        └─ E4-1, at gix-error/tests/error/exn.rs:142
+        └─ E4-1, at gix-error/tests/error/exn.rs:140
         |
-        └─ E4-2, at gix-error/tests/error/exn.rs:142
+        └─ E4-2, at gix-error/tests/error/exn.rs:140
         |
-        └─ E4-3, at gix-error/tests/error/exn.rs:142
+        └─ E4-3, at gix-error/tests/error/exn.rs:140
     ");
 
     let e = e.chain_all((1..3).map(|idx| message!("SE{}", idx)));
@@ -242,47 +240,43 @@ fn raise_all() {
     ");
 
     insta::assert_snapshot!(format!("{:#}", e), "alternate display preserves the full error tree", @r#"
-    Message("Top")
+    Message { message: "Top" }
     |
-    └─ Message("E1")
+    └─ Message { message: "E1" }
     |   |
-    |   └─ Message("E1-0")
+    |   └─ Message { message: "E1-0" }
     |
-    └─ Message("E2")
+    └─ Message { message: "E2" }
     |   |
-    |   └─ Message("E2-0")
+    |   └─ Message { message: "E2-0" }
     |   |
-    |   └─ Message("E2-1")
+    |   └─ Message { message: "E2-1" }
     |
-    └─ Message("E3")
+    └─ Message { message: "E3" }
     |   |
-    |   └─ Message("E3-0")
+    |   └─ Message { message: "E3-0" }
     |   |
-    |   └─ Message("E3-1")
+    |   └─ Message { message: "E3-1" }
     |   |
-    |   └─ Message("E3-2")
+    |   └─ Message { message: "E3-2" }
     |
-    └─ Message("E4")
+    └─ Message { message: "E4" }
     |   |
-    |   └─ Message("E4-0")
+    |   └─ Message { message: "E4-0" }
     |   |
-    |   └─ Message("E4-1")
+    |   └─ Message { message: "E4-1" }
     |   |
-    |   └─ Message("E4-2")
+    |   └─ Message { message: "E4-2" }
     |   |
-    |   └─ Message("E4-3")
+    |   └─ Message { message: "E4-3" }
     |
-    └─ Message("SE1")
+    └─ Message { message: "SE1" }
     |
-    └─ Message("SE2")
+    └─ Message { message: "SE2" }
     "#);
     let _this_should_compile = message("Top-untyped").raise_all((1..5).map(|idx| message!("E{}", idx).raise_erased()));
 
-    assert_eq!(
-        e.into_error().probable_cause().to_string(),
-        "Top",
-        "sometimes the cause is too ambiguous"
-    );
+    insta::assert_debug_snapshot!(format_args!("{}", e.into_error().probable_cause()), "sometimes the cause is too ambiguous", @"Top");
 }
 
 #[test]
@@ -304,30 +298,30 @@ fn inverse_error_call_chain() {
     └─ E5
     ");
     insta::assert_compact_debug_snapshot!(&e5, "chain retains caller locations in call order", @"
-    E1, at gix-error/tests/error/exn.rs:290
+    E1, at gix-error/tests/error/exn.rs:284
     |
-    └─ E2, at gix-error/tests/error/exn.rs:291
+    └─ E2, at gix-error/tests/error/exn.rs:285
     |
-    └─ E3, at gix-error/tests/error/exn.rs:292
+    └─ E3, at gix-error/tests/error/exn.rs:286
     |
-    └─ E4, at gix-error/tests/error/exn.rs:293
+    └─ E4, at gix-error/tests/error/exn.rs:287
     |
-    └─ E5, at gix-error/tests/error/exn.rs:294
+    └─ E5, at gix-error/tests/error/exn.rs:288
     ");
 
     insta::assert_snapshot!(format!("{e5:#}"), "alternate display follows chained order", @r#"
-    Message("E1")
+    Message { message: "E1" }
     |
-    └─ Message("E2")
+    └─ Message { message: "E2" }
     |
-    └─ Message("E3")
+    └─ Message { message: "E3" }
     |
-    └─ Message("E4")
+    └─ Message { message: "E4" }
     |
-    └─ Message("E5")
+    └─ Message { message: "E5" }
     "#);
 
-    assert_eq!(e5.into_error().probable_cause().to_string(), "E5");
+    insta::assert_debug_snapshot!(format_args!("{}", e5.into_error().probable_cause()), "branch root", @"E1");
 }
 
 #[test]
@@ -434,9 +428,9 @@ fn result_ext() {
     let result: Result<(), Message> = Err(message("An error"));
     let result = result.or_raise(|| message("Another error"));
     insta::assert_compact_debug_snapshot!(result.unwrap_err(), "or_raise records context and source at the call site", @"
-    Another error, at gix-error/tests/error/exn.rs:435
+    Another error, at gix-error/tests/error/exn.rs:429
     |
-    └─ An error, at gix-error/tests/error/exn.rs:435
+    └─ An error, at gix-error/tests/error/exn.rs:429
     ");
 }
 
@@ -444,18 +438,18 @@ fn result_ext() {
 fn option_ext() {
     let result: Option<()> = None;
     let result = result.ok_or_raise(|| message("An error"));
-    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "ok_or_raise records the failure call site", @"An error, at gix-error/tests/error/exn.rs:446");
+    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "ok_or_raise records the failure call site", @"An error, at gix-error/tests/error/exn.rs:440");
 }
 
 #[test]
 fn from_message() {
-    fn foo() -> Result<(), Exn<Message>> {
+    fn foo() -> ExnMessageResult {
         Err(message("An error"))?;
         Ok(())
     }
 
     let result = foo();
-    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "question-mark conversion records the propagation site", @"An error, at gix-error/tests/error/exn.rs:453");
+    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "question-mark conversion records the propagation site", @"An error, at gix-error/tests/error/exn.rs:447");
 }
 
 #[test]
@@ -470,17 +464,17 @@ fn new_with_source() {
 
 #[test]
 fn bail() {
-    fn foo() -> Result<(), Exn<Message>> {
+    fn foo() -> ExnMessageResult {
         gix_error::bail!(message("An error"));
     }
 
     let result = foo();
-    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "bail records the invocation site", @"An error, at gix-error/tests/error/exn.rs:474");
+    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "bail records the invocation site", @"An error, at gix-error/tests/error/exn.rs:468");
 }
 
 #[test]
 fn ensure_ok() {
-    fn foo() -> Result<(), Exn<Message>> {
+    fn foo() -> ExnMessageResult {
         gix_error::ensure!(true, message("An error"));
         Ok(())
     }
@@ -490,17 +484,17 @@ fn ensure_ok() {
 
 #[test]
 fn ensure_fail() {
-    fn foo() -> Result<(), Exn<Message>> {
+    fn foo() -> ExnMessageResult {
         gix_error::ensure!(false, message("An error"));
         Ok(())
     }
 
     let result = foo();
-    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "ensure failure records the invocation site", @"An error, at gix-error/tests/error/exn.rs:494");
+    insta::assert_compact_debug_snapshot!(result.unwrap_err(), "ensure failure records the invocation site", @"An error, at gix-error/tests/error/exn.rs:488");
 }
 
 #[test]
-fn result_ok() -> Result<(), Exn<Message>> {
+fn result_ok() -> ExnMessageResult {
     Ok(())
 }
 
@@ -534,37 +528,37 @@ fn raise_chain_anyhow() {
 
     // It's a linked list as linked up with the first child, but also has multiple children.
     insta::assert_snapshot!(format!("{root:#}"), "alternate display preserves mixed linear and branched chains", @r#"
-    Message("root")
+    Message { message: "root" }
     |
-    └─ Message("E2")
+    └─ Message { message: "E2" }
         |
-        └─ Message("E1")
+        └─ Message { message: "E1" }
             |
-            └─ Message("E1-2")
+            └─ Message { message: "E1-2" }
             |   |
-            |   └─ Message("E1c1-1")
+            |   └─ Message { message: "E1c1-1" }
             |   |
-            |   └─ Message("E1c1-2")
+            |   └─ Message { message: "E1c1-2" }
             |
-            └─ Message("E1-3")
+            └─ Message { message: "E1-3" }
                 |
-                └─ Message("E1c2-1")
+                └─ Message { message: "E1c2-1" }
                 |
-                └─ Message("E1c2-2")
+                └─ Message { message: "E1c2-2" }
     "#);
 
     insta::assert_snapshot!(remove_stackstrace(format!("{:?}", anyhow::Error::from(root))), "anyhow traverses every error frame in order", @"
-    root, at gix-error/tests/error/exn.rs:533
+    root, at gix-error/tests/error/exn.rs:527
 
     Caused by:
-        0: E2, at gix-error/tests/error/exn.rs:532
-        1: E1, at gix-error/tests/error/exn.rs:529
-        2: E1-2, at gix-error/tests/error/exn.rs:530
-        3: E1-3, at gix-error/tests/error/exn.rs:531
-        4: E1c1-1, at gix-error/tests/error/exn.rs:530
-        5: E1c1-2, at gix-error/tests/error/exn.rs:530
-        6: E1c2-1, at gix-error/tests/error/exn.rs:531
-        7: E1c2-2, at gix-error/tests/error/exn.rs:531
+        0: E2, at gix-error/tests/error/exn.rs:526
+        1: E1, at gix-error/tests/error/exn.rs:523
+        2: E1-2, at gix-error/tests/error/exn.rs:524
+        3: E1-3, at gix-error/tests/error/exn.rs:525
+        4: E1c1-1, at gix-error/tests/error/exn.rs:524
+        5: E1c1-2, at gix-error/tests/error/exn.rs:524
+        6: E1c2-1, at gix-error/tests/error/exn.rs:525
+        7: E1c2-2, at gix-error/tests/error/exn.rs:525
     ");
 }
 
@@ -589,13 +583,13 @@ fn inverse_error_call_chain_anyhow() {
     ");
 
     insta::assert_snapshot!(remove_stackstrace(format!("{:?}", anyhow::Error::from(e5))), "anyhow preserves inverse chain source order", @"
-    E1, at gix-error/tests/error/exn.rs:574
+    E1, at gix-error/tests/error/exn.rs:568
 
     Caused by:
-        0: E2, at gix-error/tests/error/exn.rs:575
-        1: E3, at gix-error/tests/error/exn.rs:576
-        2: E4, at gix-error/tests/error/exn.rs:577
-        3: E5, at gix-error/tests/error/exn.rs:578
+        0: E2, at gix-error/tests/error/exn.rs:569
+        1: E3, at gix-error/tests/error/exn.rs:570
+        2: E4, at gix-error/tests/error/exn.rs:571
+        3: E5, at gix-error/tests/error/exn.rs:572
     ");
 }
 
@@ -613,23 +607,23 @@ fn into_chain() {
     let root = e2.raise(Message::new("root"));
 
     insta::assert_snapshot!(format!("{root:#}"), "alternate display preserves the source tree before flattening", @r#"
-    Message("root")
+    Message { message: "root" }
     |
-    └─ Message("E2")
+    └─ Message { message: "E2" }
         |
-        └─ Message("E1")
+        └─ Message { message: "E1" }
             |
-            └─ Message("E1-2")
+            └─ Message { message: "E1-2" }
             |   |
-            |   └─ Message("E1c1-1")
+            |   └─ Message { message: "E1c1-1" }
             |   |
-            |   └─ Message("E1c1-2")
+            |   └─ Message { message: "E1c1-2" }
             |
-            └─ Message("E1-3")
+            └─ Message { message: "E1-3" }
                 |
-                └─ Message("E1c2-1")
+                └─ Message { message: "E1c2-1" }
                 |
-                └─ Message("E1c2-2")
+                └─ Message { message: "E1c2-2" }
     "#);
 
     // It's a linked list as linked up with the first child, but also has multiple children.
@@ -637,15 +631,15 @@ fn into_chain() {
     // By default, there is paths displayed, just like everywhere.
     insta::assert_debug_snapshot!(causes_display(&root, Style::Normal), "into_chain exposes locations for every source", @r#"
     [
-        "root, at gix-error/tests/error/exn.rs:613",
-        "E2, at gix-error/tests/error/exn.rs:612",
-        "E1, at gix-error/tests/error/exn.rs:609",
-        "E1-2, at gix-error/tests/error/exn.rs:610",
-        "E1-3, at gix-error/tests/error/exn.rs:611",
-        "E1c1-1, at gix-error/tests/error/exn.rs:610",
-        "E1c1-2, at gix-error/tests/error/exn.rs:610",
-        "E1c2-1, at gix-error/tests/error/exn.rs:611",
-        "E1c2-2, at gix-error/tests/error/exn.rs:611",
+        "root, at gix-error/tests/error/exn.rs:607",
+        "E2, at gix-error/tests/error/exn.rs:606",
+        "E1, at gix-error/tests/error/exn.rs:603",
+        "E1-2, at gix-error/tests/error/exn.rs:604",
+        "E1-3, at gix-error/tests/error/exn.rs:605",
+        "E1c1-1, at gix-error/tests/error/exn.rs:604",
+        "E1c1-2, at gix-error/tests/error/exn.rs:604",
+        "E1c2-1, at gix-error/tests/error/exn.rs:605",
+        "E1c2-2, at gix-error/tests/error/exn.rs:605",
     ]
     "#);
 
@@ -667,17 +661,17 @@ fn into_chain() {
     // This should look similar.
     #[cfg(feature = "anyhow")]
     insta::assert_snapshot!(remove_stackstrace(format!("{:?}", anyhow::Error::from(root))), "into_chain matches anyhow source traversal", @"
-    root, at gix-error/tests/error/exn.rs:613
+    root, at gix-error/tests/error/exn.rs:607
 
     Caused by:
-        0: E2, at gix-error/tests/error/exn.rs:612
-        1: E1, at gix-error/tests/error/exn.rs:609
-        2: E1-2, at gix-error/tests/error/exn.rs:610
-        3: E1-3, at gix-error/tests/error/exn.rs:611
-        4: E1c1-1, at gix-error/tests/error/exn.rs:610
-        5: E1c1-2, at gix-error/tests/error/exn.rs:610
-        6: E1c2-1, at gix-error/tests/error/exn.rs:611
-        7: E1c2-2, at gix-error/tests/error/exn.rs:611
+        0: E2, at gix-error/tests/error/exn.rs:606
+        1: E1, at gix-error/tests/error/exn.rs:603
+        2: E1-2, at gix-error/tests/error/exn.rs:604
+        3: E1-3, at gix-error/tests/error/exn.rs:605
+        4: E1c1-1, at gix-error/tests/error/exn.rs:604
+        5: E1c1-2, at gix-error/tests/error/exn.rs:604
+        6: E1c2-1, at gix-error/tests/error/exn.rs:605
+        7: E1c2-2, at gix-error/tests/error/exn.rs:605
     ");
 }
 
@@ -704,23 +698,32 @@ fn causes_display(err: &(dyn std::error::Error + 'static), style: Style) -> Vec<
 #[test]
 fn erased_frames_still_expose_the_original_error() {
     let e = ErrorWithSource("E1", message("E1-source")).raise().erased();
+    insta::assert_debug_snapshot!(e, "erased frames can still be downcast to the original error type", @"
+    E1
+    |
+    └─ E1-source
+    ");
     assert!(
         e.downcast_any_ref::<ErrorWithSource>().is_some(),
         "erased frames can still be downcast to the original error type"
     );
     let frame_error = e.iter().next().expect("there is one frame").error();
+    insta::assert_debug_snapshot!(frame_error, "the frame yields the original error, not the erasure marker", @r#"
+    ErrorWithSource(
+        "E1",
+        Message {
+            message: "E1-source",
+        },
+    )
+    "#);
     assert!(
         frame_error.downcast_ref::<ErrorWithSource>().is_some(),
         "the frame yields the original error, not the erasure marker"
     );
-    assert_eq!(
-        frame_error
+    insta::assert_debug_snapshot!(format_args!("{}", frame_error
             .source()
             .expect("the source is reachable through the erasure")
-            .to_string(),
-        "E1-source",
-        "std-style source chains continue through erased errors"
-    );
+            ), "std-style source chains continue through erased errors", @"E1-source");
 }
 
 /// Mirrors the pattern that broke in https://github.com/GitoxideLabs/gitoxide/issues/2694, where
@@ -738,13 +741,9 @@ fn erased_errors_are_found_by_error_iteration() {
 #[test]
 fn erased_into_inner_preserves_source_chain() {
     let e = ErrorWithSource("E1", message("E1-source")).raise_erased().into_inner();
-    assert_eq!(
-        std::error::Error::source(&e)
+    insta::assert_debug_snapshot!(format_args!("{}", std::error::Error::source(&e)
             .expect("the erased error forwards to the wrapped error's source")
-            .to_string(),
-        "E1-source",
-        "type erasure remains transparent to std-style source traversal"
-    );
+            ), "type erasure remains transparent to std-style source traversal", @"E1-source");
 }
 
 #[test]
@@ -764,14 +763,17 @@ fn native_sources_are_retained_and_traversed_lazily() {
         middle.is::<ErrorWithSource<Message>>(),
         "native traversal preserves the concrete middle-error type"
     );
-    assert_eq!(
-        middle
+    insta::assert_debug_snapshot!(format_args!("{}", middle
             .source()
             .expect("the middle error retains its original source")
-            .to_string(),
-        "bottom",
-        "the retained native source chain reaches its leaf"
-    );
+            ), "the retained native source chain reaches its leaf", @"bottom");
+    insta::assert_debug_snapshot!(e, "Exn downcasting lazily traverses concrete native source types", @"
+    top
+    |
+    └─ middle
+    |
+    └─ bottom
+    ");
     assert!(
         e.downcast_any_ref::<ErrorWithSource<Message>>().is_some(),
         "Exn downcasting lazily traverses concrete native source types"
@@ -783,7 +785,7 @@ fn native_sources_are_retained_and_traversed_lazily() {
 }
 
 #[test]
-fn new_does_not_inspect_native_sources() {
+fn inspection_visits_native_sources_on_demand() {
     #[derive(Debug)]
     struct CountedSource {
         source_calls: std::sync::Arc<std::sync::atomic::AtomicUsize>,
@@ -813,6 +815,12 @@ fn new_does_not_inspect_native_sources() {
         0,
         "constructing an Exn neither traverses nor snapshots native sources"
     );
+    assert!(e.downcast_any_ref::<CountedSource>().is_some());
+    assert_eq!(
+        source_calls.load(std::sync::atomic::Ordering::Relaxed),
+        0,
+        "finding the outer error does not visit its sources"
+    );
 
     assert!(
         e.downcast_any_ref::<Message>().is_some(),
@@ -822,6 +830,52 @@ fn new_does_not_inspect_native_sources() {
         source_calls.load(std::sync::atomic::Ordering::Relaxed) > 0,
         "source-aware operations traverse native sources on demand"
     );
+    insta::assert_debug_snapshot!(e, "inspection renders retained sources after measuring lazy traversal", @"
+    counted
+    |
+    └─ source
+    ");
+
+    let e = e.raise(gix_error::ClassificationMarker::with_source(
+        gix_error::Class::Retryable,
+        message("retry"),
+    ));
+    source_calls.store(0, std::sync::atomic::Ordering::Relaxed);
+    assert!(e.can_retry());
+    assert_eq!(
+        source_calls.load(std::sync::atomic::Ordering::Relaxed),
+        0,
+        "classification stops at the first match"
+    );
+    insta::assert_debug_snapshot!(e, "inspection renders retained sources after measuring lazy traversal", @"
+    retry
+    counted
+    |
+    └─ source
+    ");
+    let e = e.into_error();
+    source_calls.store(0, std::sync::atomic::Ordering::Relaxed);
+    assert!(e.can_retry());
+    assert!(e.iter_errors_with_locations().next().is_some());
+    assert_eq!(
+        source_calls.load(std::sync::atomic::Ordering::Relaxed),
+        0,
+        "porcelain iteration and predicates do not resolve unused sources"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(e, "inspection renders retained sources after measuring lazy traversal", @r#"
+        Message {
+            message: "retry",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(e, "inspection renders retained sources after measuring lazy traversal", @"
+        retry
+        counted
+        |
+        └─ source
+        ");
+    }
 }
 
 #[test]
@@ -830,41 +884,60 @@ fn into_boxed_std_error() {
     let err = err
         .downcast_ref::<gix_error::Error>()
         .expect("conversion retains the gix error boundary type");
-    assert_eq!(err.probable_cause().to_string(), "failure");
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "into boxed std error", @r#"
+        Message {
+            message: "failure",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "into boxed std error", @"failure");
+    }
+    insta::assert_debug_snapshot!(format_args!("{}", err.probable_cause()), "boxed errors preserve the selected cause", @"failure");
 }
 
 #[test]
 fn erased_validation_error_remains_classified() {
-    let err = gix_error::ValidationError::new("invalid").raise_erased().into_error();
+    let err = gix_error::validation("invalid").raise_erased().into_error();
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "the tree-backed Error classifies the original Message exposed by Frame::error() after type erasure", @r#"
+        Message {
+            message: "invalid",
+            class: Validation,
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "the tree-backed Error classifies the original Message exposed by Frame::error() after type erasure", @"invalid");
+    }
     assert!(
         err.is_validation(),
-        "the tree-backed Error classifies the original ValidationError exposed by Frame::error() after type erasure"
+        "the tree-backed Error classifies the original Message exposed by Frame::error() after type erasure"
     );
 }
 
 #[test]
 fn downcasts_cross_nested_error_boundaries_in_breadth_first_order() {
-    use gix_error::{Error, ValidationError};
-
-    fn check<E: std::error::Error + Send + Sync + 'static>(exn: Exn<E>, expected: &str) {
-        assert_eq!(
-            exn.downcast_any_ref::<ValidationError>()
-                .expect("the validation error is reachable without consuming the exception")
-                .to_string(),
-            expected,
-            "borrowed inspection selects the first matching error in logical breadth-first order"
-        );
+    use gix_error::{Error, Message, validation};
+
+    fn check<E: std::error::Error + Send + Sync + 'static>(exn: Exn<E>) -> impl std::fmt::Debug {
+        let report = gix_testtools::redact_debug_snapshot(&exn, &[]);
+        let selected = exn
+            .downcast_any_ref::<Message>()
+            .expect("the message is reachable without consuming the exception")
+            .to_string();
         assert_eq!(
             exn.into_error()
-                .downcast_any_ref::<ValidationError>()
-                .expect("conversion preserves the validation error")
+                .downcast_any_ref::<Message>()
+                .expect("conversion preserves the message")
                 .to_string(),
-            expected,
+            selected,
             "conversion preserves the downcast result"
         );
+        (report, selected)
     }
 
-    let nested = Error::from_error(ValidationError::new("nested")).raise();
+    let nested = Error::from_error(validation("nested")).raise();
+    insta::assert_debug_snapshot!(nested, "downcasting can still find the nested Error wrapper itself", @"nested");
     assert!(
         std::ptr::eq(
             nested.downcast_any_ref::<Error>().expect("the wrapper is reachable"),
@@ -872,56 +945,100 @@ fn downcasts_cross_nested_error_boundaries_in_breadth_first_order() {
         ),
         "downcasting can still find the nested Error wrapper itself"
     );
-    check(nested, "nested");
-    check(
-        ErrorWithSource(
-            "native wrapper",
-            Error::from_error(ValidationError::new("native nested")),
-        )
-        .raise_erased(),
+    insta::assert_debug_snapshot!(check(nested), "breadth-first downcasting selects nested", @r#"
+    (
+        nested,
+        "nested",
+    )
+    "#);
+    insta::assert_debug_snapshot!(check(ErrorWithSource("native wrapper", Error::from_error(validation("native nested"))).raise_erased()), "breadth-first downcasting selects native nested", @r#"
+    (
+        native wrapper
+        |
+        └─ native nested,
         "native nested",
-    );
-    check(
-        message("root")
+    )
+    "#);
+    insta::assert_debug_snapshot!(check(std::io::Error::other("root")
             .raise()
-            .chain(Error::from_error(ValidationError::new("nested")))
-            .chain(ValidationError::new("direct sibling")),
+            .chain(Error::from_error(validation("nested")))
+            .chain(validation("direct sibling"))), "breadth-first downcasting selects direct sibling", @r#"
+    (
+        I/O error (Other)
+        |
+        └─ root
+        |
+        └─ nested
+        |
+        └─ direct sibling,
         "direct sibling",
-    );
-    check(
-        Error::from_error(ValidationError::new("nested root"))
+    )
+    "#);
+    insta::assert_debug_snapshot!(check(Error::from_error(validation("nested root"))
             .raise()
-            .chain(ValidationError::new("explicit child")),
+            .chain(validation("explicit child"))), "breadth-first downcasting selects nested root", @r#"
+    (
+        nested root
+        |
+        └─ explicit child,
         "nested root",
-    );
-    check(
-        message("root")
+    )
+    "#);
+    insta::assert_debug_snapshot!(check(std::io::Error::other("root")
             .raise()
             .chain(Error::from_error(ErrorWithSource(
                 "nested source",
-                ValidationError::new("deeper"),
+                validation("deeper"),
             )))
-            .chain(ErrorWithSource("sibling", ValidationError::new("shallower"))),
+            .chain(ErrorWithSource("sibling", validation("shallower")))), "breadth-first downcasting selects shallower", @r#"
+    (
+        I/O error (Other)
+        |
+        └─ root
+        |
+        └─ nested source
+        |   |
+        |   └─ deeper
+        |
+        └─ sibling
+            |
+            └─ shallower,
         "shallower",
-    );
-    check(
-        ErrorWithSource("root", Error::from_error(ValidationError::new("native boundary")))
+    )
+    "#);
+    insta::assert_debug_snapshot!(check(ErrorWithSource("root", Error::from_error(validation("native boundary")))
             .raise()
-            .chain(Error::from_error(ValidationError::new("explicit boundary"))),
+            .chain(Error::from_error(validation("explicit boundary")))), "breadth-first downcasting selects native boundary", @r#"
+    (
+        root
+        |
+        └─ native boundary
+        |
+        └─ explicit boundary,
         "native boundary",
-    );
+    )
+    "#);
     assert!(
-        Error::from_error(message("unclassified"))
+        Error::from_error(std::io::Error::other("not a message"))
             .raise()
-            .downcast_any_ref::<ValidationError>()
+            .downcast_any_ref::<Message>()
             .is_none(),
         "nested errors without the requested type do not produce a match"
     );
+    insta::assert_debug_snapshot!(check(message("root").raise().chain(validation("child"))), "breadth-first downcasting selects root", @r#"
+    (
+        root
+        |
+        └─ child,
+        "root",
+    )
+    "#);
 }
 
 #[test]
 fn probable_cause_is_available_without_consuming_the_exception() {
-    use gix_error::{Error, ValidationError};
+    let mut diagnostics = Vec::new();
+    use gix_error::{Error, Message, validation};
 
     // A native source may occupy the same address as its owner without being the same error.
     #[derive(Debug)]
@@ -941,27 +1058,22 @@ fn probable_cause_is_available_without_consuming_the_exception() {
     }
 
     let leaf = message("leaf").raise_erased();
+    insta::assert_debug_snapshot!(leaf, "a childless exception returns its stored error even after erasure", @"leaf");
     assert!(
         std::ptr::eq(leaf.probable_cause(), leaf.frame().error()),
         "a childless exception returns its stored error even after erasure"
     );
 
-    for (exn, expected) in [
-        (leaf, "leaf"),
-        (Wrapper(Wrapper(message("native leaf"))).raise_erased(), "native leaf"),
-        (crate::new_tree_error().erased(), "E6"),
-        (
-            Error::from_error(Error::from_error(ValidationError::new("nested cause")))
-                .and_raise(message("context"))
-                .erased(),
-            "nested cause",
-        ),
+    for exn in [
+        leaf,
+        Wrapper(Wrapper(message("native leaf"))).raise_erased(),
+        crate::new_tree_error().erased(),
+        Error::from_error(Error::from_error(validation("nested cause")))
+            .and_raise(message("context"))
+            .erased(),
     ] {
-        assert_eq!(
-            exn.probable_cause().to_string(),
-            expected,
-            "borrowed inspection selects the probable cause and unwraps nested error boundaries"
-        );
+        let expected = exn.probable_cause().to_string();
+        diagnostics.push((gix_testtools::redact_debug_snapshot(&exn, &[]), expected.clone()));
         assert_eq!(
             exn.into_error().probable_cause().to_string(),
             expected,
@@ -969,19 +1081,69 @@ fn probable_cause_is_available_without_consuming_the_exception() {
         );
     }
 
-    let exn = Error::from_error(ValidationError::new("typed cause")).raise();
+    let exn = Error::from_error(validation("typed cause")).raise();
+    insta::assert_debug_snapshot!(exn, "a probable cause within a nested error retains its concrete type", @"typed cause");
     assert!(
-        exn.probable_cause().is::<ValidationError>(),
+        exn.probable_cause().is::<Message>(),
         "a probable cause within a nested error retains its concrete type"
     );
+    insta::assert_debug_snapshot!(diagnostics, "probable cause is available without consuming the exception", @r#"
+    [
+        (
+            leaf,
+            "leaf",
+        ),
+        (
+            wrapper
+            |
+            └─ wrapper
+            |
+            └─ native leaf,
+            "native leaf",
+        ),
+        (
+            E6
+            |
+            └─ E5
+            |   |
+            |   └─ E3
+            |   |   |
+            |   |   └─ E1
+            |   |
+            |   └─ E10
+            |   |   |
+            |   |   └─ E9
+            |   |
+            |   └─ E12
+            |       |
+            |       └─ E11
+            |
+            └─ E4
+            |   |
+            |   └─ E2
+            |
+            └─ E8
+                |
+                └─ E7,
+            "E6",
+        ),
+        (
+            context
+            |
+            └─ nested cause,
+            "nested cause",
+        ),
+    ]
+    "#);
 }
 
 #[test]
 fn drained_children_are_valid_bare_exceptions() {
+    let mut diagnostics = Vec::new();
     let child = || {
         ErrorWithSource("child", message("native source"))
             .raise()
-            .chain(gix_error::ValidationError::new("explicit cause"))
+            .chain(gix_error::validation("explicit cause"))
     };
     let mut parent = message("parent").raise().chain(child()).chain(child().erased());
     let children = parent.drain_children().collect::<Vec<_>>();
@@ -991,40 +1153,36 @@ fn drained_children_are_valid_bare_exceptions() {
     );
 
     for child in children {
-        assert_eq!(
-            child.error().to_string(),
-            "child",
-            "the bare exception has a valid Untyped root"
-        );
-        assert_eq!(
-            (*child).to_string(),
-            "child",
-            "dereferencing a drained exception is valid"
-        );
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", child.error()), "the bare exception has a valid Untyped root", @"child"); };
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", (*child)), "dereferencing a drained exception is valid", @"child"); };
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&child, &[]));
         assert!(
             child.downcast_any_ref::<ErrorWithSource>().is_some(),
             "draining retains the original concrete error"
         );
         assert!(child.is_validation(), "draining retains explicitly raised causes");
-        assert_eq!(
-            std::error::Error::source(child.error())
-                .expect("the original native source is retained")
-                .to_string(),
-            "native source"
-        );
-        assert_eq!(
-            child.into_inner().to_string(),
-            "child",
-            "the erased root can be extracted safely"
-        );
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", std::error::Error::source(child.error())
+        .expect("the original native source is retained")
+        ), "drained exceptions retain their native source diagnostic", @"native source"); };
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", child.into_inner()), "the erased root can be extracted safely", @"child"); };
     }
 
-    let frame = gix_error::Frame::from(message("direct conversion").raise());
-    assert_eq!(
-        Exn::from(frame).into_box().to_string(),
-        "direct conversion",
-        "direct Frame conversion also establishes the bare exception invariant"
-    );
+    let frame = gix_error::exn::Frame::from(message("direct conversion").raise());
+    insta::assert_debug_snapshot!(format_args!("{}", Exn::from(frame).into_box()), "direct Frame conversion also establishes the bare exception invariant", @"direct conversion");
+    insta::assert_debug_snapshot!(diagnostics, "drained children are valid bare exceptions", @"
+    [
+        child
+        |
+        └─ native source
+        |
+        └─ explicit cause,
+        child
+        |
+        └─ native source
+        |
+        └─ explicit cause,
+    ]
+    ");
 }
 
 #[test]
@@ -1057,29 +1215,25 @@ fn nested_error_formatting_prints_each_cause_once() {
         .raise()
         .chain(NativeSource(nested))
         .chain(message("outer-sibling"));
-    assert_eq!(
-        err.to_string(),
-        "outer-root",
-        "normal display shows the outermost error"
-    );
+    insta::assert_debug_snapshot!(format_args!("{}", err), "normal display shows the outermost error", @"outer-root");
 
     insta::assert_snapshot!(
         fixup_paths(format!("{err:?}")),
         "compact Debug expands nested error boundaries once and retains caller locations",
-        @r"
-    outer-root, at gix-error/tests/error/exn.rs:1057
+        @"
+    outer-root, at gix-error/tests/error/exn.rs:1215
     |
-    └─ native-wrapper, at gix-error/tests/error/exn.rs:1058
+    └─ native-wrapper, at gix-error/tests/error/exn.rs:1216
     |   |
-    |   └─ inner-root, at gix-error/tests/error/exn.rs:1058
+    |   └─ inner-root, at gix-error/tests/error/exn.rs:1216
     |   |
-    |   └─ extra-child, at gix-error/tests/error/exn.rs:1055
+    |   └─ extra-child, at gix-error/tests/error/exn.rs:1213
     |   |
-    |   └─ boundary-child, at gix-error/tests/error/exn.rs:1054
+    |   └─ boundary-child, at gix-error/tests/error/exn.rs:1212
     |   |
-    |   └─ inner-child, at gix-error/tests/error/exn.rs:1053
+    |   └─ inner-child, at gix-error/tests/error/exn.rs:1211
     |
-    └─ outer-sibling, at gix-error/tests/error/exn.rs:1059
+    └─ outer-sibling, at gix-error/tests/error/exn.rs:1217
     "
     );
     insta::assert_snapshot!(
@@ -1105,19 +1259,19 @@ fn nested_error_formatting_prints_each_cause_once() {
         format!("{err:#}"),
         "alternate display expands nested error boundaries once with concrete error types",
         @r#"
-    Message("outer-root")
+    Message { message: "outer-root" }
     |
     └─ native-wrapper
     |   |
-    |   └─ Message("inner-root")
+    |   └─ Message { message: "inner-root" }
     |       |
-    |       └─ Message("extra-child")
+    |       └─ Message { message: "extra-child" }
     |       |
-    |       └─ Message("boundary-child")
+    |       └─ Message { message: "boundary-child" }
     |       |
-    |       └─ Message("inner-child")
+    |       └─ Message { message: "inner-child" }
     |
-    └─ Message("outer-sibling")
+    └─ Message { message: "outer-sibling" }
     "#
     );
 
@@ -1139,3 +1293,369 @@ fn nested_error_formatting_prints_each_cause_once() {
         }
     }
 }
+
+pub(super) fn assert_io_payload_report(report: &str, expected: &str, locations: usize, counts: &[(&str, usize)]) {
+    assert_eq!(
+        report.matches(", at ").count(),
+        locations,
+        "only compact Debug includes caller locations: {report}"
+    );
+    for (label, count) in counts {
+        assert_eq!(
+            report.matches(label).count(),
+            *count,
+            "each diagnostic is rendered independently, without deduplicating equal labels: {label}: {report}"
+        );
+    }
+    let without_locations = report
+        .lines()
+        .map(|line| line.split_once(", at ").map_or(line, |(label, _)| label))
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert_eq!(
+        without_locations, expected,
+        "labels and report structure are exact apart from caller locations"
+    );
+}
+
+#[test]
+fn io_payload_direct_validation_retains_metadata_and_types() {
+    use gix_error::{Class, MetadataValue, validation};
+    use std::io::{Error, ErrorKind};
+
+    let err = Error::new(
+        ErrorKind::InvalidData,
+        validation("invalid input").with("input", b"ref\xff".as_slice()),
+    )
+    .raise();
+    let expected_values = err
+        .error()
+        .get_ref()
+        .and_then(|payload| payload.downcast_ref::<Message>())
+        .expect("I/O owns the original validation message")
+        .values
+        .clone();
+    assert_eq!(
+        expected_values["input"],
+        MetadataValue::from(b"ref\xff".as_slice()),
+        "metadata retains non-UTF-8 bytes"
+    );
+    let classes = err.classify().map(|item| item.class()).collect::<Vec<_>>();
+    assert_eq!(
+        classes,
+        [Class::Io(ErrorKind::InvalidData), Class::Validation],
+        "I/O and payload retain separate classifications"
+    );
+    assert!(err.is_validation(), "the payload class is visible before conversion");
+    assert_eq!(
+        err.metadata().collect::<Vec<_>>(),
+        [&expected_values],
+        "metadata is visited once before conversion"
+    );
+    assert_eq!(
+        err.downcast_any_ref::<Error>()
+            .expect("I/O remains downcastable")
+            .kind(),
+        ErrorKind::InvalidData,
+        "rendering must not replace the I/O error"
+    );
+
+    let human = r#"I/O error (InvalidData)
+|
+└─ invalid input, "input"="ref\xff""#;
+    let typed = r#"I/O error (InvalidData)
+|
+└─ Message { message: "invalid input", class: Validation, values: {"input": Bytes("ref\xff")} }"#;
+    let compact = format!("{err:?}");
+    let location = err.frame().location();
+    let at = format!(", at {}:{}", location.file(), location.line());
+    assert_eq!(
+        compact,
+        format!(
+            r#"I/O error (InvalidData){at}
+|
+└─ invalid input, "input"="ref\xff"{at}"#
+        ),
+        "a native payload inherits its owning frame's rendering location"
+    );
+    for (report, expected, locations) in [
+        (compact, human, 2),
+        (format!("{err:#?}"), human, 0),
+        (format!("{err:#}"), typed, 0),
+    ] {
+        assert_io_payload_report(
+            &report,
+            expected,
+            locations,
+            &[("I/O error (InvalidData)", 1), ("invalid input", 1), (r"ref\xff", 1)],
+        );
+    }
+
+    let err = err.into_error();
+    let io = err
+        .downcast_any_ref::<Error>()
+        .expect("conversion retains the I/O error");
+    assert_eq!(io.kind(), ErrorKind::InvalidData, "conversion preserves the I/O kind");
+    let payload = io
+        .get_ref()
+        .and_then(|payload| payload.downcast_ref::<Message>())
+        .expect("conversion preserves the concrete I/O payload");
+    assert!(
+        std::ptr::eq(
+            payload,
+            err.downcast_any_ref::<Message>()
+                .expect("the payload remains downcastable")
+        ),
+        "traversal exposes the actual payload, not a replacement message"
+    );
+    assert!(err.is_validation(), "the payload class is visible after conversion");
+    assert_eq!(
+        err.classify().map(|item| item.class()).collect::<Vec<_>>(),
+        classes,
+        "rendering and conversion preserve classifications"
+    );
+    assert_eq!(
+        err.metadata().collect::<Vec<_>>(),
+        [&expected_values],
+        "rendering and conversion preserve metadata without duplication"
+    );
+}
+
+#[test]
+fn io_payload_nested_wrappers_preserve_branches_and_equal_messages() {
+    use std::io::{Error, ErrorKind};
+
+    let branching = message("batch")
+        .raise()
+        .chain(message("left").raise().chain(message("same")))
+        .chain(message("right").raise().chain(message("same")))
+        .into_error();
+    let err = Error::new(ErrorKind::PermissionDenied, Error::other(branching))
+        .raise()
+        .chain(message("explicit sibling"));
+    let human = "I/O error (PermissionDenied)
+|
+└─ I/O error (Other)
+|   |
+|   └─ batch
+|   |
+|   └─ left
+|   |
+|   └─ right
+|   |
+|   └─ same
+|   |
+|   └─ same
+|
+└─ explicit sibling";
+    let typed = format!(
+        "I/O error (PermissionDenied)
+|
+└─ I/O error (Other)
+|   |
+|   └─ {:?}
+|       |
+|       └─ {:?}
+|       |
+|       └─ {:?}
+|       |
+|       └─ {:?}
+|       |
+|       └─ {:?}
+|
+└─ {:?}",
+        message("batch"),
+        message("left"),
+        message("right"),
+        message("same"),
+        message("same"),
+        message("explicit sibling")
+    );
+    let original_nodes = err.iter_errors().count();
+    assert_eq!(
+        err.frame().children().len(),
+        1,
+        "the explicit sibling is the only owned child frame"
+    );
+    for (report, expected, locations) in [
+        (format!("{err:?}"), human, 8),
+        (format!("{err:#?}"), human, 0),
+        (format!("{err:#}"), typed.as_str(), 0),
+    ] {
+        assert_io_payload_report(
+            &report,
+            expected,
+            locations,
+            &[
+                ("I/O error (PermissionDenied)", 1),
+                ("I/O error (Other)", 1),
+                ("batch", 1),
+                ("left", 1),
+                ("right", 1),
+                ("same", 2),
+                ("explicit sibling", 1),
+            ],
+        );
+    }
+    assert_eq!(
+        err.iter_errors().count(),
+        original_nodes,
+        "rendering does not modify the graph"
+    );
+    let err = err.into_error();
+    assert_eq!(
+        err.iter_errors().count(),
+        original_nodes,
+        "conversion preserves boundary entries and their contents in traversal"
+    );
+    let io = err
+        .downcast_any_ref::<Error>()
+        .expect("the outer I/O wrapper remains accessible");
+    assert_eq!(
+        io.kind(),
+        ErrorKind::PermissionDenied,
+        "the outer wrapper keeps its kind"
+    );
+    let inner = io
+        .get_ref()
+        .and_then(|payload| payload.downcast_ref::<Error>())
+        .expect("the inner I/O wrapper remains the native payload");
+    assert_eq!(inner.kind(), ErrorKind::Other, "the inner wrapper keeps its own kind");
+    assert!(
+        inner
+            .get_ref()
+            .is_some_and(<dyn std::error::Error + Send + Sync>::is::<gix_error::Error>),
+        "the branching error remains the inner I/O payload"
+    );
+    assert_eq!(
+        err.iter_errors()
+            .filter_map(|error| error.downcast_ref::<Message>())
+            .filter(|message| message.to_string() == "same")
+            .count(),
+        2,
+        "equal messages on separate branches remain separate errors"
+    );
+    assert!(
+        err.iter_errors().any(|error| error
+            .downcast_ref::<Message>()
+            .is_some_and(|message| message.to_string() == "explicit sibling")),
+        "the explicit sibling remains in the graph"
+    );
+}
+
+#[test]
+fn io_payload_report_does_not_leak_alternate_into_display_labels() {
+    struct Sensitive(&'static str, Option<Message>);
+
+    impl std::fmt::Display for Sensitive {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            if f.alternate() {
+                write!(f, "LEAKED {}", self.0)
+            } else {
+                f.write_str(self.0)
+            }
+        }
+    }
+
+    impl std::fmt::Debug for Sensitive {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Sensitive({:?})", self.0)
+        }
+    }
+
+    impl std::error::Error for Sensitive {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            self.1.as_ref().map(|source| source as _)
+        }
+    }
+
+    let nested = Sensitive("inner", None)
+        .raise()
+        .chain(Sensitive("child", Some(message("native leaf"))))
+        .into_error();
+    let err = Sensitive("outer", None).raise().chain(nested);
+    let human = "outer
+|
+└─ inner
+|
+└─ child
+|
+└─ native leaf";
+    let typed = r#"Sensitive("outer")
+|
+└─ Sensitive("inner")
+    |
+    └─ Sensitive("child")
+    |
+    └─ Message { message: "native leaf" }"#;
+    let counts = [
+        ("outer", 1),
+        ("inner", 1),
+        ("child", 1),
+        ("native leaf", 1),
+        ("LEAKED", 0),
+    ];
+    for (report, expected, locations) in [
+        (format!("{err:?}"), human, 4),
+        (format!("{err:#?}"), human, 0),
+        (format!("{err:#}"), typed, 0),
+    ] {
+        assert_io_payload_report(&report, expected, locations, &counts);
+    }
+    let err = err.into_error();
+    let child = err
+        .iter_errors()
+        .filter_map(|error| error.downcast_ref::<Sensitive>())
+        .find(|error| error.0 == "child")
+        .expect("the nested concrete error remains downcastable");
+    assert!(
+        std::error::Error::source(child).is_some_and(<dyn std::error::Error>::is::<Message>),
+        "rendering preserves the concrete native source"
+    );
+    assert_eq!(
+        format!("{child:#}"),
+        "LEAKED child",
+        "the custom error's own alternate Display behavior is unchanged"
+    );
+
+    let test_error = gix_error::TestError::from(err);
+    let (expected, locations) = if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        (
+            "outer
+
+Caused by:
+    0: inner
+    1: child
+    2: native leaf",
+            3,
+        )
+    } else {
+        (human, 4)
+    };
+    for (report, locations) in [(format!("{test_error:?}"), locations), (format!("{test_error:#?}"), 0)] {
+        assert_io_payload_report(&report, expected, locations, &counts);
+    }
+}
+
+#[test]
+fn io_payload_free_errors_keep_their_own_labels() {
+    use std::io::{Error, ErrorKind};
+
+    for io in [
+        Error::from(ErrorKind::NotFound),
+        Error::from(ErrorKind::PermissionDenied),
+        Error::from_raw_os_error(2),
+    ] {
+        assert!(io.get_ref().is_none(), "the control case has no custom payload");
+        let human = io.to_string();
+        let typed = format!("{io:?}");
+        let err = io.raise();
+        for (report, expected, locations) in [
+            (format!("{err:?}"), human.as_str(), 1),
+            (format!("{err:#?}"), human.as_str(), 0),
+            (format!("{err:#}"), typed.as_str(), 0),
+        ] {
+            assert_io_payload_report(&report, expected, locations, &[(expected, 1), ("I/O error (", 0)]);
+        }
+    }
+}
diff --git a/gix-error/tests/error/main.rs b/gix-error/tests/error/main.rs
index 7b824b6c3f3..19b09b40216 100644
--- a/gix-error/tests/error/main.rs
+++ b/gix-error/tests/error/main.rs
@@ -51,4 +51,6 @@ mod utils {
 }
 pub use utils::*;
 
+mod metadata;
+mod probable_cause;
 mod test;
diff --git a/gix-error/tests/error/metadata.rs b/gix-error/tests/error/metadata.rs
new file mode 100644
index 00000000000..8b9d235d4b5
--- /dev/null
+++ b/gix-error/tests/error/metadata.rs
@@ -0,0 +1,839 @@
+use std::{borrow::Cow, collections::BTreeMap, path::Path};
+
+use gix_error::{Class, Error, ErrorExt, Message, MetadataValue, ResourceExhaustionKind, ResultExt, not_found};
+
+#[test]
+fn message_debug_keeps_class_and_values_compact() {
+    for (class, expected_class) in [
+        (Class::Validation, "Validation"),
+        (Class::Io(std::io::ErrorKind::PermissionDenied), "Io(PermissionDenied)"),
+        (
+            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit),
+            "ResourceExhaustion(AllocationLimit)",
+        ),
+    ] {
+        let message = Message::new("details")
+            .with_class(class)
+            .with("offset", 42_u64)
+            .with("input", b"bad\xff".as_slice());
+        assert_eq!(
+            format!("{message:?}"),
+            format!(
+                r#"Message {{ message: "details", class: {expected_class}, values: {{"input": Bytes("bad\xff"), "offset": U64(42)}} }}"#
+            ),
+            "compact debug omits Some and preserves ordered, typed values"
+        );
+        assert_eq!(
+            format!("{message:#?}"),
+            format!(
+                r#"Message {{
+    message: "details",
+    class: {expected_class},
+    values: {{"input": Bytes("bad\xff"), "offset": U64(42)}},
+}}"#
+            ),
+            "pretty debug keeps both the class and the entire values map on single lines"
+        );
+    }
+}
+
+#[test]
+fn message_debug_omits_absent_class_and_empty_values() {
+    for (message, compact, pretty) in [
+        (
+            Message::new("details"),
+            r#"Message { message: "details" }"#,
+            r#"Message {
+    message: "details",
+}"#,
+        ),
+        (
+            Message::new("details").with_class(Class::Validation),
+            r#"Message { message: "details", class: Validation }"#,
+            r#"Message {
+    message: "details",
+    class: Validation,
+}"#,
+        ),
+        (
+            Message::new("details").with("offset", 42_u64),
+            r#"Message { message: "details", values: {"offset": U64(42)} }"#,
+            r#"Message {
+    message: "details",
+    values: {"offset": U64(42)},
+}"#,
+        ),
+    ] {
+        assert_eq!(
+            format!("{message:?}"),
+            compact,
+            "compact debug omits absent fields without hiding populated fields"
+        );
+        assert_eq!(
+            format!("{message:#?}"),
+            pretty,
+            "pretty debug omits absent fields without hiding populated fields"
+        );
+    }
+}
+
+#[test]
+fn metadata_value_debug_stays_compact_in_pretty_output() {
+    for (value, expected) in [
+        (MetadataValue::Bool(true), "Bool(true)"),
+        (MetadataValue::I64(i64::MIN), "I64(-9223372036854775808)"),
+        (MetadataValue::U64(u64::MAX), "U64(18446744073709551615)"),
+        (MetadataValue::F64(1.5), "F64(1.5)"),
+        (MetadataValue::String("line\nbreak".into()), r#"String("line\nbreak")"#),
+        (
+            MetadataValue::Bytes(b"ref\xff".as_slice().into()),
+            r#"Bytes("ref\xff")"#,
+        ),
+        (MetadataValue::Path(Path::new("objects").into()), r#"Path("objects")"#),
+    ] {
+        assert_eq!(
+            format!("{value:?}"),
+            expected,
+            "debug retains the variant and escaped payload"
+        );
+        assert_eq!(
+            format!("{value:#?}"),
+            expected,
+            "pretty debug does not expand scalar values"
+        );
+    }
+}
+
+#[test]
+fn scalar_values_are_lossless_and_keys_are_local_to_a_context() {
+    let metadata = Message::new("details")
+        .with("signed", i64::MIN)
+        .with("unsigned", u64::MAX)
+        .with("float", 1.5)
+        .with("bytes", b"ref\xff".as_slice())
+        .with("path", Path::new("objects"))
+        .with("text", "line\nbreak")
+        .with("flag", false)
+        .with("flag", true);
+    assert_eq!(metadata.values["signed"], MetadataValue::I64(i64::MIN));
+    assert_eq!(metadata.values["unsigned"], MetadataValue::U64(u64::MAX));
+    assert_eq!(metadata.values["float"], MetadataValue::F64(1.5));
+    assert_eq!(
+        metadata.values["bytes"],
+        MetadataValue::Bytes(b"ref\xff".as_slice().into())
+    );
+    assert_eq!(
+        metadata.values["path"],
+        MetadataValue::Path(Path::new("objects").into())
+    );
+    assert_eq!(
+        metadata.values["flag"],
+        MetadataValue::Bool(true),
+        "the last value replaces its predecessor"
+    );
+    insta::assert_debug_snapshot!(format_args!("{}", Message::new("details")
+            .with("z", "line\nbreak")
+            .with("a", 2)
+            ), "keys are ordered and text is escaped", @r#"details, "a"=2, "z"="line\nbreak""#);
+    #[cfg(unix)]
+    {
+        use std::os::unix::ffi::OsStringExt;
+        let path = std::path::PathBuf::from(std::ffi::OsString::from_vec(b"ref\xff".to_vec()));
+        assert_eq!(
+            MetadataValue::from(path.as_path()),
+            MetadataValue::Path(path),
+            "paths retain native bytes"
+        );
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStringExt;
+        let path = std::path::PathBuf::from(std::ffi::OsString::from_wide(&[0xd800]));
+        assert_eq!(
+            MetadataValue::from(path.as_path()),
+            MetadataValue::Path(path),
+            "paths retain native code units"
+        );
+    }
+
+    insta::assert_snapshot!(metadata, "validate Display", @r#"details, "bytes"="ref\xff", "flag"=true, "float"=1.5, "path"="objects", "signed"=-9223372036854775808, "text"="line\nbreak", "unsigned"=18446744073709551615"#);
+    insta::assert_debug_snapshot!(metadata, "validate Display", @r#"
+    Message {
+        message: "details",
+        values: {"bytes": Bytes("ref\xff"), "flag": Bool(true), "float": F64(1.5), "path": Path("objects"), "signed": I64(-9223372036854775808), "text": String("line\nbreak"), "unsigned": U64(18446744073709551615)},
+    }
+    "#);
+}
+
+#[test]
+fn metadata_contexts_preserve_causes_and_remain_separate_through_conversion() {
+    let missing = not_found("missing").and_raise(Message::new("lookup").with("path", "first"));
+    let retry =
+        std::io::Error::from(std::io::ErrorKind::TimedOut).and_raise(Message::new("read").with("path", "second"));
+    let err = Error::from_error(super::ErrorWithSource("custom", missing.into_error()))
+        .raise()
+        .chain(retry);
+    let paths = |values: &gix_error::Metadata| values["path"].clone();
+    assert_eq!(
+        err.metadata().map(paths).collect::<Vec<_>>(),
+        [MetadataValue::from("second"), MetadataValue::from("first")],
+        "native sources and explicit child contexts share the existing traversal order"
+    );
+    assert!(err.is_not_found() && err.can_retry());
+
+    insta::assert_snapshot!(format!("{:#}", err.error()), "the stored error's alternate display omits locations", @"custom");
+    insta::assert_debug_snapshot!(err, @r#"
+    custom
+    |
+    └─ lookup, "path"="first"
+    |
+    └─ missing
+    |
+    └─ read, "path"="second"
+    |
+    └─ timed out
+    "#);
+
+    let err = err.into_error();
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(err, "context leaves classifications intact", @r#"
+        ErrorWithSource(
+            "custom",
+            Message {
+                message: "lookup",
+                values: {"path": String("first")},
+            },
+        )
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(err, "context leaves classifications intact", @r#"
+        custom
+        |
+        └─ lookup, "path"="first"
+        |
+        └─ missing
+        |
+        └─ read, "path"="second"
+        |
+        └─ timed out
+        "#);
+    }
+    assert!(
+        err.is_not_found() && err.can_retry(),
+        "context leaves classifications intact"
+    );
+    assert_eq!(
+        err.metadata().map(paths).collect::<Vec<_>>(),
+        [MetadataValue::from("second"), MetadataValue::from("first")]
+    );
+    assert!(
+        err.classify()
+            .find(|class| class.class() == Class::NotFound)
+            .expect("the missing resource is classified")
+            .error()
+            .is::<Message>(),
+        "the concrete cause remains accessible"
+    );
+
+    let ok: Result<(), std::io::Error> = Ok(());
+    assert!(ok.or_raise(|| -> Message { panic!("context must be lazy") }).is_ok());
+}
+
+#[test]
+fn classified_context_preserves_the_real_callee() {
+    let error = std::io::Error::from(std::io::ErrorKind::PermissionDenied)
+        .and_raise(gix_error::retryable("try reading again").with("path", Path::new("HEAD")));
+    insta::assert_debug_snapshot!(error, "the message context supplies explicit retryability", @r#"
+    try reading again, "path"="HEAD"
+    |
+    └─ permission denied
+    "#);
+    assert!(
+        error.is_retryable(),
+        "the message context supplies explicit retryability"
+    );
+    assert!(
+        error.probable_cause().is::<std::io::Error>(),
+        "classified context does not replace the callee"
+    );
+    assert_eq!(
+        error.iter_errors().count(),
+        2,
+        "the context and callee remain distinct diagnostics"
+    );
+    let error = error.into_error();
+    let classifications = error.classify().collect::<Vec<_>>();
+    assert_eq!(
+        classifications
+            .iter()
+            .map(gix_error::types::Classification::class)
+            .collect::<Vec<_>>(),
+        [Class::Retryable, Class::Io(std::io::ErrorKind::PermissionDenied)],
+        "classification visits the message context and its original callee"
+    );
+    assert!(
+        classifications[0].error().is::<Message>(),
+        "the message context establishes its class"
+    );
+    assert_eq!(
+        classifications[0].io_kind(),
+        None,
+        "the context does not impersonate its callee"
+    );
+    assert_eq!(
+        classifications[1].io_kind(),
+        Some(std::io::ErrorKind::PermissionDenied),
+        "the callee retains its native I/O origin"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(error, "conversion retains the real cause", @r#"
+        Message {
+            message: "try reading again",
+            class: Retryable,
+            values: {"path": Path("HEAD")},
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(error, "conversion retains the real cause", @r#"
+        try reading again, "path"="HEAD"
+        |
+        └─ permission denied
+        "#);
+    }
+    assert!(
+        error.probable_cause().is::<std::io::Error>(),
+        "conversion retains the real cause"
+    );
+}
+
+#[test]
+fn message_classifications_survive_markers_native_sources_and_nested_branches() {
+    let nested = gix_error::Exn::raise_all(
+        [
+            gix_error::not_found("first").with("path", "a").raise(),
+            gix_error::not_found("second").with("path", "b").raise(),
+        ],
+        Message::new("lookup"),
+    );
+    let error = gix_error::ClassificationMarker::with_source(
+        Class::Retryable,
+        super::ErrorWithSource("native", std::io::Error::other(nested.into_error())),
+    )
+    .and_raise(Message::new("outer"));
+    let expected = [
+        Class::Retryable,
+        Class::Io(std::io::ErrorKind::Other),
+        Class::NotFound,
+        Class::NotFound,
+    ];
+    assert_eq!(
+        error.classify().map(|item| item.class()).collect::<Vec<_>>(),
+        expected,
+        "unclassified contexts are skipped, while each generic cause retains its classification"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(error, "predicates inspect generic causes and markers together", @r#"
+        outer
+        |
+        └─ native
+        |
+        └─ I/O error (Other)
+        |
+        └─ lookup
+        |
+        └─ first, "path"="a"
+        |
+        └─ second, "path"="b"
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(error, "predicates inspect generic causes and markers together", @r#"
+        outer
+        |
+        └─ native
+        |
+        └─ I/O error (Other)
+        |
+        └─ lookup
+        |
+        └─ first, "path"="a"
+        |
+        └─ second, "path"="b"
+        "#);
+    }
+    assert!(
+        error.is_not_found() && error.is_retryable(),
+        "predicates inspect generic causes and markers together"
+    );
+    insta::assert_debug_snapshot!(format_args!("{}", error.probable_cause()), "a generic aggregate remains a causal boundary", @"lookup");
+    let error = error.erased().into_error();
+    assert_eq!(
+        error.classify().map(|item| item.class()).collect::<Vec<_>>(),
+        expected,
+        "conversion preserves order, duplicate classes, and native sources"
+    );
+    assert_eq!(
+        error.metadata().map(|values| values.get("path")).collect::<Vec<_>>(),
+        [Some(&MetadataValue::from("a")), Some(&MetadataValue::from("b"))],
+        "metadata skips empty dictionaries and markers without merging or reordering contexts"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(error, "classification markers remain transparent", @r#"
+        Message {
+            message: "outer",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(error, "classification markers remain transparent", @r#"
+        outer
+        |
+        └─ native
+        |
+        └─ I/O error (Other)
+        |
+        └─ lookup
+        |
+        └─ first, "path"="a"
+        |
+        └─ second, "path"="b"
+        "#);
+    }
+    assert!(
+        error.downcast_any_ref::<gix_error::ClassificationMarker>().is_none(),
+        "classification markers remain transparent"
+    );
+    assert!(
+        error.probable_cause().is::<Message>(),
+        "the generic aggregate is not transparent"
+    );
+    let classified_messages = error
+        .classify()
+        .filter_map(|item| {
+            item.error()
+                .downcast_ref::<Message>()
+                .map(|error| error.message.as_ref())
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        classified_messages,
+        ["first", "second"],
+        "classification origins are the generic diagnostics themselves"
+    );
+}
+
+#[test]
+fn messages_are_visible_in_reports_unlike_markers() {
+    let error = gix_error::ClassificationMarker::with_source(
+        Class::Retryable,
+        gix_error::not_found("missing reference").with("path", Path::new("HEAD")),
+    )
+    .and_raise(gix_error::message("lookup failed"));
+    insta::assert_debug_snapshot!(error, "the generic diagnostic appears exactly once and its marker remains hidden", @r#"
+    lookup failed
+    |
+    └─ missing reference, "path"="HEAD"
+    "#);
+    assert!(
+        error.probable_cause().is::<Message>(),
+        "generic diagnostics participate in cause selection"
+    );
+}
+
+#[test]
+fn metadata_skips_empty_dictionaries_for_plain_messages() {
+    let err = Message::new("details").raise().raise(gix_error::message("context"));
+    insta::assert_debug_snapshot!(err, "messages without metadata remain visible diagnostics", @"
+    context
+    |
+    └─ details
+    ");
+    assert!(
+        err.metadata().next().is_none(),
+        "messages without values contribute no metadata dictionaries"
+    );
+    assert_eq!(err.iter_errors().count(), 2, "plain messages remain visible errors");
+
+    let err = err.erased();
+    assert!(
+        err.metadata().next().is_none(),
+        "type erasure does not expose empty dictionaries"
+    );
+
+    let err = err.into_error();
+    assert!(
+        err.metadata().next().is_none(),
+        "conversion does not expose empty dictionaries"
+    );
+    assert_eq!(
+        err.iter_errors().count(),
+        2,
+        "conversion preserves messages even when they have no values"
+    );
+}
+
+#[test]
+fn message_builders_preserve_messages_and_replace_the_class() {
+    let error = Message::new("details");
+    assert!(
+        matches!(error.message, Cow::Borrowed("details")),
+        "static messages stay borrowed"
+    );
+    assert_eq!(error.class, None, "new contexts have no implicit classification");
+    assert!(error.values.is_empty(), "values are optional");
+    insta::assert_debug_snapshot!(error, "unclassified contexts are omitted", @r#"
+    Message {
+        message: "details",
+    }
+    "#);
+    assert_eq!(
+        gix_error::classify(&error).count(),
+        0,
+        "unclassified contexts are omitted"
+    );
+
+    let error = error
+        .with_class(Class::Validation)
+        .with("input", b"bad\xff".as_slice())
+        .with_class(Class::Corruption);
+    assert_eq!(
+        error.class,
+        Some(Class::Corruption),
+        "the last class replaces its predecessor"
+    );
+    assert_eq!(
+        error.values["input"],
+        MetadataValue::Bytes(b"bad\xff".as_slice().into()),
+        "class changes retain diagnostic values"
+    );
+    insta::assert_debug_snapshot!(error, "reclassification does not manufacture a causal chain", @r#"
+    Message {
+        message: "details",
+        class: Corruption,
+        values: {"input": Bytes("bad\xff")},
+    }
+    "#);
+    assert_eq!(
+        gix_error::classify(&error).count(),
+        1,
+        "reclassification does not manufacture a causal chain"
+    );
+
+    let error: Message = gix_error::message("missing")
+        .with_class(Class::NotFound)
+        .with("path", Path::new("HEAD"));
+    assert_eq!(
+        error.class,
+        Some(Class::NotFound),
+        "messages can be classified without changing their type"
+    );
+    assert!(
+        matches!(error.message, Cow::Borrowed("missing")),
+        "builders keep borrowed storage"
+    );
+    assert_eq!(
+        error.values["path"],
+        MetadataValue::Path("HEAD".into()),
+        "messages accept metadata"
+    );
+
+    let error: Message = gix_error::message!("object {} is missing", 42)
+        .with("object", 42)
+        .with_class(Class::NotFound);
+    assert!(
+        matches!(error.message, Cow::Owned(_)),
+        "formatted messages retain owned storage"
+    );
+    insta::assert_debug_snapshot!(error, "builders preserve the formatted diagnostic", @r#"
+    Message {
+        message: "object 42 is missing",
+        class: NotFound,
+        values: {"object": I64(42)},
+    }
+    "#);
+    assert_eq!(
+        error.values["object"],
+        MetadataValue::I64(42),
+        "value builders can precede classification"
+    );
+}
+
+#[test]
+fn message_constructors_start_without_a_class_or_values() {
+    for error in [
+        Message::from("details"),
+        Message::from(String::from("details")),
+        Message::from(Cow::Borrowed("details")),
+        Message::new("details"),
+        gix_error::message("details"),
+        gix_error::message!("{}", "details"),
+    ] {
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", error.message), "conversion preserves the diagnostic", @"details"); };
+        assert_eq!(
+            error.class, None,
+            "converting a message does not infer a classification"
+        );
+        assert!(error.values.is_empty(), "conversion does not invent metadata");
+    }
+}
+
+#[test]
+fn class_constructors_create_visible_diagnostics_without_synthetic_sources() {
+    let mut diagnostics = Vec::new();
+    let cases = [
+        (gix_error::validation("details"), Class::Validation),
+        (gix_error::corruption("details"), Class::Corruption),
+        (gix_error::not_found("details"), Class::NotFound),
+        (gix_error::retryable("details"), Class::Retryable),
+        (
+            gix_error::allocation_limit("details"),
+            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit),
+        ),
+        (
+            gix_error::allocation_failure("details"),
+            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure),
+        ),
+        (
+            gix_error::resource_exhaustion(ResourceExhaustionKind::AllocationFailure, "details"),
+            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure),
+        ),
+        (
+            gix_error::io(std::io::ErrorKind::PermissionDenied, String::from("details")),
+            Class::Io(std::io::ErrorKind::PermissionDenied),
+        ),
+    ];
+    for (error, class) in cases {
+        assert_eq!(error.class, Some(class), "each constructor selects its named class");
+        insta::allow_duplicates! { insta::assert_debug_snapshot!(format_args!("{}", error), "classification adds no diagnostic noise", @"details"); };
+        assert!(
+            std::error::Error::source(&error).is_none(),
+            "a class is not a synthetic cause"
+        );
+        let mut classifications = gix_error::classify(&error);
+        let classification = classifications.next().expect("the message supplies its own class");
+        assert_eq!(
+            classification.class(),
+            class,
+            "borrowed classification recognizes the message"
+        );
+        assert_eq!(
+            classification.io_kind(),
+            None,
+            "even Class::Io does not claim a real I/O origin"
+        );
+        assert!(
+            std::ptr::eq(
+                classification
+                    .error()
+                    .downcast_ref::<Message>()
+                    .expect("the original type is retained"),
+                &error,
+            ),
+            "the diagnostic itself establishes the classification"
+        );
+        assert!(classifications.next().is_none(), "each message has at most one class");
+
+        let exn = error.with("path", Path::new("HEAD")).raise();
+        assert_eq!(
+            exn.classify().next().expect("raised errors retain their class").class(),
+            class
+        );
+        assert_eq!(exn.iter_errors().count(), 1, "a classified message is one visible node");
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&exn, &[]));
+        assert!(exn.probable_cause().is::<Message>(), "a message leaf remains the cause");
+        let error = exn.erased().into_error();
+        assert_eq!(
+            error
+                .classify()
+                .next()
+                .expect("converted errors retain their class")
+                .class(),
+            class
+        );
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&error, &[]));
+        assert_eq!(
+            error.is_validation(),
+            class == Class::Validation,
+            "validation predicates inspect messages"
+        );
+        assert_eq!(
+            error.is_corrupted(),
+            class == Class::Corruption,
+            "corruption predicates inspect messages"
+        );
+        assert_eq!(
+            error.is_not_found(),
+            class == Class::NotFound,
+            "not-found predicates inspect messages"
+        );
+        assert_eq!(
+            error.is_retryable(),
+            class == Class::Retryable,
+            "retry predicates inspect messages"
+        );
+        assert_eq!(
+            error.is_resource_exhausted(),
+            matches!(class, Class::ResourceExhaustion(_)),
+            "resource predicates inspect messages"
+        );
+        assert_eq!(
+            error.metadata().next().expect("messages expose their values")["path"],
+            MetadataValue::Path("HEAD".into())
+        );
+        assert!(
+            error.probable_cause().is::<Message>(),
+            "conversion preserves the concrete cause"
+        );
+    }
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "class constructors create visible diagnostics without synthetic sources", @r#"
+        [
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: Validation,
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: Corruption,
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: NotFound,
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: Retryable,
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: ResourceExhaustion(AllocationLimit),
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: ResourceExhaustion(AllocationFailure),
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: ResourceExhaustion(AllocationFailure),
+                values: {"path": Path("HEAD")},
+            },
+            details, "path"="HEAD",
+            Message {
+                message: "details",
+                class: Io(PermissionDenied),
+                values: {"path": Path("HEAD")},
+            },
+        ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "class constructors create visible diagnostics without synthetic sources", @r#"
+        [
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+            details, "path"="HEAD",
+        ]
+        "#);
+    }
+}
+
+#[test]
+fn offending_input_does_not_require_a_validation_class_or_an_extra_cause() {
+    let input = b"ref: invalid\xff\n".as_slice();
+    let error = gix_error::corruption("Malformed reference")
+        .with("input", input)
+        .raise();
+    assert_eq!(error.iter_errors().count(), 1, "class and input describe one failure");
+    let error = error.erased().into_error();
+    assert_eq!(
+        error.classify().map(|class| class.class()).collect::<Vec<_>>(),
+        [Class::Corruption],
+        "attaching input does not invent a validation failure"
+    );
+    assert_eq!(
+        error.metadata().next().expect("the cause retains its input")["input"],
+        MetadataValue::Bytes(input.into()),
+        "type erasure preserves the original bytes"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(error, "the diagnostic remains the cause", @r#"
+        Message {
+            message: "Malformed reference",
+            class: Corruption,
+            values: {"input": Bytes("ref: invalid\xff\n")},
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(error, "the diagnostic remains the cause", @r#"Malformed reference, "input"="ref: invalid\xff\n""#);
+    }
+    assert!(
+        error.probable_cause().is::<Message>(),
+        "the diagnostic remains the cause"
+    );
+}
+
+#[test]
+fn metadata_alias_matches_fields_and_borrowed_iterators() {
+    use gix_error::Metadata;
+
+    let values: BTreeMap<Cow<'static, str>, MetadataValue> =
+        BTreeMap::from([(Cow::Borrowed("path"), MetadataValue::from("HEAD"))]);
+    let values: Metadata = values;
+    let context = Message {
+        values,
+        ..Message::new("context")
+    };
+    let values: &BTreeMap<Cow<'static, str>, MetadataValue> = &context.values;
+    assert_eq!(
+        values["path"],
+        MetadataValue::from("HEAD"),
+        "the public alias and values field are compatible with the underlying map"
+    );
+
+    let exception = context.raise();
+    insta::assert_debug_snapshot!(exception, "metadata inspection borrows the values displayed with the context", @r#"context, "path"="HEAD""#);
+    let dictionary: &Metadata = exception
+        .metadata()
+        .next()
+        .expect("the message context contributes metadata");
+    assert!(
+        std::ptr::eq(dictionary, &exception.error().values),
+        "Exn::metadata() borrows the context's actual values field"
+    );
+
+    let error = exception.into_error();
+    let context = error
+        .downcast_any_ref::<Message>()
+        .expect("conversion retains the message context");
+    let dictionary: &Metadata = error
+        .metadata()
+        .next()
+        .expect("the converted context contributes metadata");
+    assert!(
+        std::ptr::eq(dictionary, &context.values),
+        "Error::metadata() borrows the converted context's actual values field"
+    );
+}
diff --git a/gix-error/tests/error/probable_cause.rs b/gix-error/tests/error/probable_cause.rs
new file mode 100644
index 00000000000..60eedc12702
--- /dev/null
+++ b/gix-error/tests/error/probable_cause.rs
@@ -0,0 +1,1387 @@
+use std::error::Error as StdError;
+
+use gix_error::{
+    Class, ClassificationMarker, Error, ErrorExt, Exn, Message, ResourceExhaustionKind, corruption, message, not_found,
+    resource_exhaustion, validation,
+};
+
+use crate::ErrorWithSource;
+
+const VALIDATION: ClassificationMarker = ClassificationMarker::VALIDATION;
+const NOT_FOUND: ClassificationMarker = ClassificationMarker::NOT_FOUND;
+
+fn check<T: StdError + 'static, E: StdError + Send + Sync + 'static>(exn: Exn<E>) -> impl std::fmt::Debug {
+    let report = gix_testtools::redact_debug_snapshot(&exn, &[]);
+    let expected = format!("{:#}", exn.probable_cause());
+    let assert_cause = |cause: &(dyn StdError + 'static)| {
+        assert!(
+            cause.is::<T>(),
+            "selection retains the expected concrete cause: {cause:#}"
+        );
+        assert_eq!(
+            format!("{cause:#}"),
+            expected,
+            "conversions and added context preserve the selected diagnostic"
+        );
+    };
+    assert_cause(exn.probable_cause());
+    assert_cause(exn.frame().probable_cause().unwrap_or_else(|| exn.frame().error()));
+
+    let exn = exn.erased().erased();
+    assert_cause(exn.probable_cause());
+    let frame: gix_error::exn::Frame = exn.into();
+    assert_cause(frame.probable_cause().unwrap_or_else(|| frame.error()));
+    let exn = Exn::from(frame);
+    assert_cause(exn.probable_cause());
+
+    let error = exn.into_error();
+    assert_cause(error.probable_cause());
+    let error = Error::from_boxed(Box::new(error));
+    assert_cause(error.probable_cause());
+    let contextual = error.and_raise(message("additional context"));
+    assert_cause(contextual.probable_cause());
+    assert_cause(contextual.into_error().probable_cause());
+    (report, expected)
+}
+
+fn aggregate(reverse: bool) -> Exn<Message> {
+    let children = if reverse { ["right", "left"] } else { ["left", "right"] };
+    Exn::raise_all(children.map(|child| message(child).raise()), message("aggregate"))
+}
+
+#[test]
+fn meaningful_native_sources_remain_selectable() {
+    let diagnostics = vec![
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(ErrorWithSource("operation", ErrorWithSource("decoder", message("bad byte"))).raise()),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(ErrorWithSource("decode failed", validation("invalid object header")).raise()),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(ErrorWithSource("lookup failed", not_found("reference is missing")).raise()),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(ErrorWithSource("read failed", corruption("checksum mismatch")).raise()),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                ErrorWithSource(
+                    "allocation failed",
+                    resource_exhaustion(ResourceExhaustionKind::AllocationLimit, "object exceeds limit"),
+                )
+                .raise(),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                ErrorWithSource(
+                    "request failed",
+                    ClassificationMarker::with_source(Class::Retryable, message("connection reset")),
+                )
+                .raise(),
+            ),
+            &[],
+        ),
+    ];
+    insta::assert_debug_snapshot!(diagnostics, "meaningful native sources remain selectable", @r#"
+    [
+        (
+            operation
+            |
+            └─ decoder
+            |
+            └─ bad byte,
+            "bad byte",
+        ),
+        (
+            decode failed
+            |
+            └─ invalid object header,
+            "invalid object header",
+        ),
+        (
+            lookup failed
+            |
+            └─ reference is missing,
+            "reference is missing",
+        ),
+        (
+            read failed
+            |
+            └─ checksum mismatch,
+            "checksum mismatch",
+        ),
+        (
+            allocation failed
+            |
+            └─ object exceeds limit,
+            "object exceeds limit",
+        ),
+        (
+            request failed
+            |
+            └─ connection reset,
+            "connection reset",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn genuine_classified_children_are_not_metadata() {
+    let diagnostics = vec![
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(message("context").raise().chain(validation("invalid input"))),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("aggregate")
+                    .raise()
+                    .chain(validation("invalid input"))
+                    .chain(not_found("missing input")),
+            ),
+            &[],
+        ),
+    ];
+    insta::assert_debug_snapshot!(diagnostics, "genuine classified children are not metadata", @r#"
+    [
+        (
+            context
+            |
+            └─ invalid input,
+            "invalid input",
+        ),
+        (
+            aggregate
+            |
+            └─ invalid input
+            |
+            └─ missing input,
+            "aggregate",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn native_markers_do_not_replace_their_diagnostic_owner() {
+    let diagnostics = vec![
+        gix_testtools::redact_debug_snapshot(
+            &check::<ErrorWithSource<ClassificationMarker>, _>(
+                ErrorWithSource("invalid object 42", VALIDATION).raise(),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<ErrorWithSource<ClassificationMarker>, _>(
+                ErrorWithSource("missing reference HEAD", NOT_FOUND).and_raise(message("resolve revision")),
+            ),
+            &[],
+        ),
+    ];
+    insta::assert_debug_snapshot!(diagnostics, "native markers do not replace their diagnostic owner", @r#"
+    [
+        (
+            invalid object 42,
+            "invalid object 42",
+        ),
+        (
+            resolve revision
+            |
+            └─ missing reference HEAD,
+            "missing reference HEAD",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn explicit_markers_do_not_replace_a_real_cause_or_create_a_branch() {
+    let mut diagnostics = Vec::new();
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(message("specific diagnostic").raise().chain(VALIDATION)),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(
+            message("specific diagnostic")
+                .raise()
+                .chain(VALIDATION)
+                .chain(NOT_FOUND),
+        ),
+        &[],
+    ));
+    for marker_first in [false, true] {
+        let exn = message("context").raise();
+        let exn = if marker_first {
+            exn.chain(VALIDATION).chain(message("real cause"))
+        } else {
+            exn.chain(message("real cause")).chain(VALIDATION)
+        };
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Message, _>(exn), &[]));
+    }
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(
+            ErrorWithSource("decode failed", validation("invalid header"))
+                .raise()
+                .chain(VALIDATION),
+        ),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(
+            ErrorWithSource("context", VALIDATION)
+                .raise()
+                .chain(message("real cause")),
+        ),
+        &[],
+    ));
+    insta::assert_debug_snapshot!(diagnostics, "explicit markers do not replace a real cause or create a branch", @r#"
+    [
+        (
+            specific diagnostic,
+            "specific diagnostic",
+        ),
+        (
+            specific diagnostic,
+            "specific diagnostic",
+        ),
+        (
+            context
+            |
+            └─ real cause,
+            "real cause",
+        ),
+        (
+            context
+            |
+            └─ real cause,
+            "real cause",
+        ),
+        (
+            decode failed
+            |
+            └─ invalid header,
+            "invalid header",
+        ),
+        (
+            context
+            |
+            └─ real cause,
+            "real cause",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn flat_aggregates_are_invariant_under_context_and_sibling_order() {
+    let mut diagnostics = Vec::new();
+    for reverse in [false, true] {
+        for depth in 0..3 {
+            let mut exn = aggregate(reverse);
+            for _ in 0..depth {
+                exn = exn.raise(message("outer context"));
+            }
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Message, _>(exn), &[]));
+        }
+    }
+    insta::assert_debug_snapshot!(diagnostics, "flat aggregates are invariant under context and sibling order", @r#"
+    [
+        (
+            aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ aggregate
+                |
+                └─ left
+                |
+                └─ right,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ outer context
+            |
+            └─ aggregate
+                |
+                └─ left
+                |
+                └─ right,
+            "aggregate",
+        ),
+        (
+            aggregate
+            |
+            └─ right
+            |
+            └─ left,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ aggregate
+                |
+                └─ right
+                |
+                └─ left,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ outer context
+            |
+            └─ aggregate
+                |
+                └─ right
+                |
+                └─ left,
+            "aggregate",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn nested_aggregates_stop_at_the_first_causal_branch() {
+    let mut diagnostics = Vec::new();
+    for reverse in [false, true] {
+        let nested = aggregate(reverse).into_error();
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(nested.and_raise(message("outer context"))),
+            &[],
+        ));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                Exn::raise_all(
+                    [
+                        aggregate(reverse),
+                        message("third cause").raise().raise(message("sibling context")),
+                    ],
+                    message("outer aggregate"),
+                )
+                .raise(message("outer context")),
+            ),
+            &[],
+        ));
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                aggregate(reverse)
+                    .into_error()
+                    .and_raise(message("outer context"))
+                    .chain(VALIDATION),
+            ),
+            &[],
+        ));
+    }
+    insta::assert_debug_snapshot!(diagnostics, "nested aggregates stop at the first causal branch", @r#"
+    [
+        (
+            outer context
+            |
+            └─ aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ outer aggregate
+                |
+                └─ aggregate
+                |   |
+                |   └─ left
+                |   |
+                |   └─ right
+                |
+                └─ sibling context
+                    |
+                    └─ third cause,
+            "outer aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ aggregate
+            |
+            └─ right
+            |
+            └─ left,
+            "aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ outer aggregate
+                |
+                └─ aggregate
+                |   |
+                |   └─ right
+                |   |
+                |   └─ left
+                |
+                └─ sibling context
+                    |
+                    └─ third cause,
+            "outer aggregate",
+        ),
+        (
+            outer context
+            |
+            └─ aggregate
+            |
+            └─ right
+            |
+            └─ left,
+            "aggregate",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn nested_error_boundaries_and_explicit_children_both_count() {
+    let mut diagnostics = Vec::new();
+    for with_context in [false, true] {
+        let nested = aggregate(false).into_error();
+        let exn = nested.raise().chain(message("explicit sibling"));
+        assert!(
+            exn.frame().probable_cause().is_none(),
+            "the stored boundary itself is selected when its nested graph and explicit child form a branch"
+        );
+        assert!(
+            std::ptr::eq(exn.probable_cause(), exn.frame().error()),
+            "selecting a boundary at a branch must not recursively replace it with one nested cause"
+        );
+        if with_context {
+            diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &check::<Error, _>(exn.raise(message("outer context"))),
+                &[],
+            ));
+        } else {
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Error, _>(exn), &[]));
+        }
+    }
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<ErrorWithSource<Error>, _>(
+            ErrorWithSource("native aggregate", aggregate(false).into_error())
+                .raise()
+                .chain(message("explicit sibling")),
+        ),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(
+            Error::from_error(validation("nested real cause"))
+                .raise()
+                .chain(VALIDATION),
+        ),
+        &[],
+    ));
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "nested error boundaries and explicit children both count", @r#"
+            [
+                (
+                    aggregate
+                    |
+                    └─ left
+                    |
+                    └─ right
+                    |
+                    └─ explicit sibling,
+                    "aggregate",
+                ),
+                (
+                    outer context
+                    |
+                    └─ aggregate
+                    |
+                    └─ left
+                    |
+                    └─ right
+                    |
+                    └─ explicit sibling,
+                    "aggregate",
+                ),
+                (
+                    native aggregate
+                    |
+                    └─ aggregate
+                    |   |
+                    |   └─ left
+                    |   |
+                    |   └─ right
+                    |
+                    └─ explicit sibling,
+                    "native aggregate",
+                ),
+                (
+                    nested real cause,
+                    "nested real cause",
+                ),
+            ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "nested error boundaries and explicit children both count", @r#"
+        [
+            (
+                aggregate
+                |
+                └─ left
+                |
+                └─ right
+                |
+                └─ explicit sibling,
+                "Message { message: \"aggregate\" }\n|\n└─ Message { message: \"left\" }\n|\n└─ Message { message: \"right\" }",
+            ),
+            (
+                outer context
+                |
+                └─ aggregate
+                |
+                └─ left
+                |
+                └─ right
+                |
+                └─ explicit sibling,
+                "Message { message: \"aggregate\" }\n|\n└─ Message { message: \"left\" }\n|\n└─ Message { message: \"right\" }",
+            ),
+            (
+                native aggregate
+                |
+                └─ aggregate
+                |   |
+                |   └─ left
+                |   |
+                |   └─ right
+                |
+                └─ explicit sibling,
+                "native aggregate",
+            ),
+            (
+                nested real cause,
+                "nested real cause",
+            ),
+        ]
+        "#);
+    }
+}
+
+#[test]
+fn marker_frames_are_transparent_without_losing_real_descendants() {
+    let diagnostics = vec![
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(VALIDATION.raise().chain(validation("real cause"))),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("context").raise().chain(
+                    VALIDATION
+                        .raise()
+                        .chain(validation("real cause"))
+                        .chain(NOT_FOUND)
+                        .raise(VALIDATION),
+                ),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("aggregate")
+                    .raise()
+                    .chain(VALIDATION.raise().chain(message("left")).chain(message("right"))),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("aggregate")
+                    .raise()
+                    .chain(VALIDATION.raise().chain(message("left")))
+                    .chain(message("right")),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("specific diagnostic")
+                    .raise()
+                    .chain(VALIDATION.raise().chain(NOT_FOUND)),
+            ),
+            &[],
+        ),
+    ];
+    insta::assert_debug_snapshot!(diagnostics, "marker frames are transparent without losing real descendants", @r#"
+    [
+        (
+            real cause,
+            "real cause",
+        ),
+        (
+            context
+            |
+            └─ real cause,
+            "real cause",
+        ),
+        (
+            aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            specific diagnostic,
+            "specific diagnostic",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn nested_marker_boundaries_are_transparent_without_losing_real_descendants() {
+    let diagnostics = vec![
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("specific diagnostic")
+                    .raise()
+                    .chain(Error::from_error(Error::from_error(VALIDATION))),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("context")
+                    .raise()
+                    .chain(VALIDATION.raise().chain(validation("nested real cause")).into_error()),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<Message, _>(
+                message("aggregate").raise().chain(
+                    Error::from_error(VALIDATION)
+                        .raise()
+                        .chain(message("left"))
+                        .chain(message("right")),
+                ),
+            ),
+            &[],
+        ),
+        gix_testtools::redact_debug_snapshot(
+            &check::<ErrorWithSource<Error>, _>(
+                ErrorWithSource("specific diagnostic", Error::from_error(VALIDATION)).raise(),
+            ),
+            &[],
+        ),
+    ];
+    insta::assert_debug_snapshot!(diagnostics, "nested marker boundaries are transparent without losing real descendants", @r#"
+    [
+        (
+            specific diagnostic,
+            "specific diagnostic",
+        ),
+        (
+            context
+            |
+            └─ nested real cause,
+            "nested real cause",
+        ),
+        (
+            aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+        (
+            specific diagnostic,
+            "specific diagnostic",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn io_payloads_participate_in_the_logical_graph() {
+    let mut diagnostics = Vec::new();
+    let io = std::io::Error::from(std::io::ErrorKind::NotFound);
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<std::io::Error, _>(ErrorWithSource("read failed", io).raise()),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(
+            std::io::Error::new(std::io::ErrorKind::InvalidData, validation("invalid I/O payload"))
+                .and_raise(message("read failed")),
+        ),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<ErrorWithSource<ClassificationMarker>, _>(
+            std::io::Error::other(ErrorWithSource("useful I/O payload", VALIDATION)).raise(),
+        ),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<std::io::Error, _>(std::io::Error::other(VALIDATION).raise()),
+        &[],
+    ));
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<Message, _>(std::io::Error::other(aggregate(false).into_error()).and_raise(message("read failed"))),
+        &[],
+    ));
+    let io = std::io::Error::other(aggregate(false).into_error());
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<std::io::Error, _>(io.raise().chain(message("explicit sibling"))),
+        &[],
+    ));
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(diagnostics, "io payloads participate in the logical graph", @r#"
+        [
+            (
+                read failed
+                |
+                └─ entity not found,
+                "entity not found",
+            ),
+            (
+                read failed
+                |
+                └─ I/O error (InvalidData)
+                |
+                └─ invalid I/O payload,
+                "invalid I/O payload",
+            ),
+            (
+                I/O error (Other)
+                |
+                └─ useful I/O payload,
+                "useful I/O payload",
+            ),
+            (
+                I/O error (Other),
+                "Validation",
+            ),
+            (
+                read failed
+                |
+                └─ I/O error (Other)
+                |
+                └─ aggregate
+                |
+                └─ left
+                |
+                └─ right,
+                "aggregate",
+            ),
+            (
+                I/O error (Other)
+                |
+                └─ aggregate
+                |   |
+                |   └─ left
+                |   |
+                |   └─ right
+                |
+                └─ explicit sibling,
+                "aggregate",
+            ),
+        ]
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostics, "io payloads participate in the logical graph", @r#"
+        [
+            (
+                read failed
+                |
+                └─ entity not found,
+                "entity not found",
+            ),
+            (
+                read failed
+                |
+                └─ I/O error (InvalidData)
+                |
+                └─ invalid I/O payload,
+                "invalid I/O payload",
+            ),
+            (
+                I/O error (Other)
+                |
+                └─ useful I/O payload,
+                "useful I/O payload",
+            ),
+            (
+                I/O error (Other),
+                "Validation",
+            ),
+            (
+                read failed
+                |
+                └─ I/O error (Other)
+                |
+                └─ aggregate
+                |
+                └─ left
+                |
+                └─ right,
+                "aggregate",
+            ),
+            (
+                I/O error (Other)
+                |
+                └─ aggregate
+                |   |
+                |   └─ left
+                |   |
+                |   └─ right
+                |
+                └─ explicit sibling,
+                "Message { message: \"aggregate\" }\n|\n└─ Message { message: \"left\" }\n|\n└─ Message { message: \"right\" }",
+            ),
+        ]
+        "#);
+    }
+}
+
+#[test]
+fn root_fallback_retains_the_stored_error() {
+    let mut diagnostics = Vec::new();
+    for exn in [
+        message("standalone").raise_erased(),
+        VALIDATION.raise_erased(),
+        VALIDATION.raise().chain(NOT_FOUND).erased(),
+        VALIDATION
+            .raise()
+            .chain(message("left"))
+            .chain(message("right"))
+            .erased(),
+    ] {
+        assert!(
+            exn.frame().probable_cause().is_none(),
+            "without a unique causal descendant the frame delegates to stored-root fallback"
+        );
+        assert!(
+            std::ptr::eq(exn.probable_cause(), exn.frame().error()),
+            "root fallback preserves the original stored error after erasure"
+        );
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&exn, &[]));
+        let error = exn.into_error();
+        assert!(
+            std::ptr::eq(error.probable_cause(), error.error()),
+            "conversion uses the stored root, not a synthetic wrapper, as fallback"
+        );
+    }
+    insta::assert_debug_snapshot!(diagnostics, "root fallback retains the stored error", @"
+    [
+        standalone,
+        Validation,
+        Validation,
+        left
+        right,
+    ]
+    ");
+}
+
+#[test]
+fn markers_remain_classified_but_are_hidden_from_inspection() {
+    let exn = ErrorWithSource("specific diagnostic", VALIDATION)
+        .raise()
+        .chain(NOT_FOUND);
+    let expected = exn.iter_errors().map(ToString::to_string).collect::<Vec<_>>();
+    insta::assert_debug_snapshot!(expected, "public error iteration omits classification-only markers", @r#"
+    [
+        "specific diagnostic",
+    ]
+    "#);
+    assert!(
+        exn.downcast_any_ref::<ClassificationMarker>().is_none(),
+        "public downcasts omit classification-only markers"
+    );
+    assert!(
+        exn.error()
+            .source()
+            .expect("the diagnostic exposes its marker")
+            .is::<ClassificationMarker>(),
+        "native source access retains classification metadata"
+    );
+    insta::assert_debug_snapshot!(format_args!("{}", exn.probable_cause()), "cause selection retains the specific diagnostic", @"specific diagnostic");
+    assert_eq!(
+        exn.classify()
+            .map(|classification| classification.class())
+            .collect::<Vec<_>>(),
+        [Class::Validation, Class::NotFound],
+        "cause selection does not consume or hide classification evidence"
+    );
+    insta::assert_debug_snapshot!(&exn, "diagnostic formatting omits classification-only leaves", @"specific diagnostic");
+    let error = exn.into_error();
+    assert_eq!(
+        error.iter_errors().map(ToString::to_string).collect::<Vec<_>>(),
+        expected,
+        "conversion preserves diagnostic iteration without classification-only markers"
+    );
+    assert_eq!(
+        error
+            .classify()
+            .map(|classification| classification.class())
+            .collect::<Vec<_>>(),
+        [Class::Validation, Class::NotFound],
+        "both representations retain marker classifications"
+    );
+    assert_eq!(
+        error
+            .iter_errors_with_locations()
+            .map(|source| format!("{source:#}"))
+            .collect::<Vec<_>>(),
+        expected,
+        "display sources omit classification-only markers too"
+    );
+}
+
+#[test]
+fn marker_reports_retain_context_without_classification_noise() {
+    let exn = ErrorWithSource("specific diagnostic", VALIDATION)
+        .and_raise(message("operation failed"))
+        .chain(NOT_FOUND);
+    insta::assert_debug_snapshot!(&exn, "exception reports preserve context and omit classification markers", @"
+    operation failed
+    |
+    └─ specific diagnostic
+    ");
+    let error = gix_error::TestError::from(exn);
+    #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+    insta::assert_debug_snapshot!(error, "test reports show the error tree without locations or classification markers", @"
+    operation failed
+    |
+    └─ specific diagnostic
+    ");
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    insta::assert_debug_snapshot!(error, "test reports show the error chain without locations or classification markers", @"
+    operation failed
+
+    Caused by:
+        0: specific diagnostic
+    ");
+}
+
+#[test]
+fn marker_reports_retain_real_children_and_classified_errors() {
+    insta::allow_duplicates! {
+    for nested in [false, true] {
+        let children = VALIDATION
+            .raise()
+            .chain(validation("invalid input"))
+            .chain(not_found("missing resource"));
+        let exn = message("operation failed").raise();
+        let exn = if nested {
+            exn.chain(children.into_error())
+        } else {
+            exn.chain(children)
+        };
+        insta::assert_debug_snapshot!(&exn, "marker frames promote their real children in order", @"
+        operation failed
+        |
+        └─ invalid input
+        |
+        └─ missing resource
+        ");
+        let error = gix_error::TestError::from(exn);
+        #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+        insta::assert_debug_snapshot!(error, "genuine classified errors remain in test error trees", @"
+        operation failed
+        |
+        └─ invalid input
+        |
+        └─ missing resource
+        ");
+        #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+        insta::assert_debug_snapshot!(error, "genuine classified errors remain in test error chains", @"
+        operation failed
+
+        Caused by:
+            0: invalid input
+            1: missing resource
+        ");
+    }
+    }
+}
+
+#[test]
+fn marker_reports_fall_back_to_the_root_when_no_diagnostic_exists() {
+    let exn = VALIDATION.raise().chain(NOT_FOUND);
+    assert_eq!(
+        exn.iter_errors().count(),
+        0,
+        "markers are hidden even without other errors"
+    );
+    insta::assert_debug_snapshot!(&exn, "a marker-only exception still has a diagnostic", @"Validation");
+    insta::assert_debug_snapshot!(gix_error::TestError::from(exn), "a marker-only test failure still has a diagnostic", @"Validation");
+}
+
+#[test]
+fn marker_reports_do_not_repeat_promoted_native_sources() {
+    let exn = VALIDATION
+        .raise()
+        .chain(ErrorWithSource("specific diagnostic", message("native detail")))
+        .into_error()
+        .and_raise(message("operation failed"));
+    insta::assert_debug_snapshot!(exn, "a promoted nested boundary emits each native source once", @"
+    operation failed
+    |
+    └─ specific diagnostic
+    |
+    └─ native detail
+    ");
+}
+
+#[test]
+fn marker_reports_promote_a_real_cause_above_a_marker_root() {
+    let exn = VALIDATION.raise().chain(validation("invalid input"));
+    insta::assert_debug_snapshot!(&exn, "a marker root is transparent to diagnostic rendering", @"invalid input");
+    insta::assert_debug_snapshot!(gix_error::TestError::from(exn), "test reports preserve a real cause beneath a marker root", @"invalid input");
+}
+
+#[derive(Debug)]
+#[repr(transparent)]
+struct Native<E>(E);
+
+impl<E> std::fmt::Display for Native<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("native wrapper")
+    }
+}
+
+impl<E: StdError + 'static> StdError for Native<E> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&self.0)
+    }
+}
+
+#[test]
+fn native_sources_sharing_their_owners_address_keep_their_origin() {
+    let mut diagnostics = Vec::new();
+    let exn = Native(Native(validation("same-address cause"))).raise();
+    assert_eq!(
+        std::ptr::from_ref(exn.error()).cast::<()>(),
+        std::ptr::from_ref(&exn.error().0.0).cast::<()>(),
+        "the fixture places distinct native sources at their owner's address"
+    );
+    diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Message, _>(exn), &[]));
+    insta::assert_debug_snapshot!(diagnostics, "native sources sharing their owners address keep their origin", @r#"
+    [
+        (
+            native wrapper
+            |
+            └─ native wrapper
+            |
+            └─ same-address cause,
+            "same-address cause",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn selection_does_not_score_descendants_below_a_branch() {
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+
+    #[derive(Debug)]
+    struct CountedSource(Arc<AtomicUsize>);
+
+    impl std::fmt::Display for CountedSource {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str("unneeded descendant")
+        }
+    }
+
+    impl StdError for CountedSource {
+        fn source(&self) -> Option<&(dyn StdError + 'static)> {
+            self.0.fetch_add(1, Ordering::Relaxed);
+            None
+        }
+    }
+
+    let calls = Arc::new(AtomicUsize::new(0));
+    let exn = message("aggregate")
+        .raise()
+        .chain(CountedSource(Arc::clone(&calls)))
+        .chain(message("other cause"));
+    insta::assert_debug_snapshot!(format_args!("{}", exn.probable_cause()), "a branch selects its aggregate", @"aggregate");
+    assert_eq!(
+        calls.load(Ordering::Relaxed),
+        0,
+        "cause selection does not inspect branch descendants"
+    );
+    insta::assert_debug_snapshot!(exn, "the aggregate remains the cause without inspecting its descendants during selection", @"
+    aggregate
+    |
+    └─ unneeded descendant
+    |
+    └─ other cause
+    ");
+    let error = exn.into_error();
+    calls.store(0, Ordering::Relaxed);
+    insta::assert_debug_snapshot!(format_args!("{}", error.probable_cause()), "conversion preserves the branch", @"aggregate");
+    assert_eq!(
+        calls.load(Ordering::Relaxed),
+        0,
+        "converted selection does not inspect branch descendants"
+    );
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_debug_snapshot!(error, "the aggregate remains the cause without inspecting its descendants during selection", @r#"
+        Message {
+            message: "aggregate",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(error, "the aggregate remains the cause without inspecting its descendants during selection", @"
+        aggregate
+        |
+        └─ unneeded descendant
+        |
+        └─ other cause
+        ");
+    }
+}
+
+#[test]
+fn converted_marker_roots_format_their_real_diagnostic() {
+    let exn = VALIDATION.raise();
+    let exn = exn.chain(message("specific diagnostic"));
+    let location = exn.frame().children()[0].location();
+    let expected = if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        format!("specific diagnostic, at {}:{}", location.file(), location.line())
+    } else {
+        "specific diagnostic".into()
+    };
+    let error = exn.into_error();
+    assert_eq!(
+        error.to_string(),
+        expected,
+        "converted display selects the diagnostic and retains its own location"
+    );
+    #[cfg(any(feature = "tree-error", not(feature = "auto-chain-error")))]
+    insta::assert_debug_snapshot!(error, "converted tree Debug promotes the diagnostic above its marker root", @"specific diagnostic");
+    #[cfg(all(feature = "auto-chain-error", not(feature = "tree-error")))]
+    insta::assert_debug_snapshot!(error, "converted chain Debug retains the diagnostic's concrete type", @r#"
+    Message {
+        message: "specific diagnostic",
+    }
+    "#);
+    insta::assert_debug_snapshot!(format_args!("{}", VALIDATION.raise().chain(message("specific diagnostic"))), "exception display also promotes its first real diagnostic", @"specific diagnostic");
+}
+
+#[test]
+fn converted_marker_only_errors_retain_their_root_diagnostic() {
+    let exn = VALIDATION.raise().chain(NOT_FOUND);
+    let location = exn.frame().location();
+    let expected = if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        format!("Validation, at {}:{}", location.file(), location.line())
+    } else {
+        "Validation".into()
+    };
+    let error = exn.into_error();
+    assert_eq!(error.to_string(), expected, "display retains the stored marker root");
+    let expected = if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        format!("{VALIDATION:#?}")
+    } else {
+        "Validation".into()
+    };
+    assert_eq!(
+        format!("{error:#?}"),
+        expected,
+        "Debug retains the stored marker root when no diagnostic exists"
+    );
+}
+
+#[test]
+fn markers_preserve_typed_diagnostics() {
+    let mut diagnostics = Vec::new();
+    let exn = ErrorWithSource("operation interrupted", ClassificationMarker::RETRYABLE)
+        .and_raise(message("verification failed"));
+    insta::assert_debug_snapshot!(&exn, "a class-only marker leaves its typed owner's diagnostic intact", @"
+    verification failed
+    |
+    └─ operation interrupted
+    ");
+    diagnostics.push(gix_testtools::redact_debug_snapshot(
+        &check::<ErrorWithSource<ClassificationMarker>, _>(exn),
+        &[],
+    ));
+
+    let exn = ClassificationMarker::with_source(Class::Retryable, validation("invalid input"))
+        .and_raise(message("verification failed"));
+    assert!(
+        exn.is_retryable() && exn.is_validation(),
+        "the marker adds its classification without replacing the typed error's classification"
+    );
+    insta::assert_debug_snapshot!(&exn, "a source marker exposes the typed diagnostic exactly once", @"
+    verification failed
+    |
+    └─ invalid input
+    ");
+    diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Message, _>(exn), &[]));
+    insta::assert_debug_snapshot!(diagnostics, "markers preserve typed diagnostics", @r#"
+    [
+        (
+            verification failed
+            |
+            └─ operation interrupted,
+            "operation interrupted",
+        ),
+        (
+            verification failed
+            |
+            └─ invalid input,
+            "invalid input",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn source_markers_preserve_nested_aggregates_and_reports() {
+    let mut diagnostics = Vec::new();
+    let exn = ClassificationMarker::with_source(Class::Retryable, aggregate(false).into_error())
+        .and_raise(message("operation failed"));
+    assert!(
+        exn.is_retryable(),
+        "the transparent source wrapper retains its classification"
+    );
+    insta::assert_debug_snapshot!(&exn, "the source's aggregate and both causes remain visible", @"
+    operation failed
+    |
+    └─ aggregate
+    |
+    └─ left
+    |
+    └─ right
+    ");
+    diagnostics.push(gix_testtools::redact_debug_snapshot(&check::<Message, _>(exn), &[]));
+    insta::assert_debug_snapshot!(diagnostics, "source markers preserve nested aggregates and reports", @r#"
+    [
+        (
+            operation failed
+            |
+            └─ aggregate
+            |
+            └─ left
+            |
+            └─ right,
+            "aggregate",
+        ),
+    ]
+    "#);
+}
+
+#[test]
+fn source_marker_test_reports_do_not_repeat_the_wrapped_error() {
+    let marker = ClassificationMarker::with_source(Class::Retryable, message("operation interrupted"));
+    insta::assert_debug_snapshot!(&marker, "direct Debug delegates to the source without classification noise", @r#"
+    Message {
+        message: "operation interrupted",
+    }
+    "#);
+    let exn = marker.raise();
+    insta::assert_debug_snapshot!(&exn, "a source-backed root displays the source without its wrapper", @"operation interrupted");
+    insta::assert_debug_snapshot!(gix_error::TestError::from(exn), "test reports display the wrapped diagnostic once", @"operation interrupted");
+}
+
+#[test]
+fn source_markers_preserve_only_the_first_real_diagnostics_callsite() {
+    let exn = ClassificationMarker::with_source(
+        Class::Retryable,
+        ClassificationMarker::with_source(
+            Class::Validation,
+            ErrorWithSource("visible diagnostic", message("native tail")),
+        ),
+    )
+    .raise();
+    let location = exn.frame().location();
+    insta::assert_compact_debug_snapshot!(exn, "the exception report retains the marker callsite on its first real diagnostic", @"
+    visible diagnostic, at gix-error/tests/error/probable_cause.rs:1344
+    |
+    └─ native tail, at gix-error/tests/error/probable_cause.rs:1344
+    ");
+
+    let error = exn.into_error();
+    {
+        let mut diagnostics = error.iter_errors_with_locations();
+        let first = diagnostics.next().expect("the wrapped diagnostic remains visible");
+        assert!(
+            first.error().is::<ErrorWithSource<Message>>(),
+            "the source marker wrappers are omitted"
+        );
+        assert_eq!(
+            first.location(),
+            Some(location),
+            "the first real diagnostic inherits the callsite through both transparent wrappers"
+        );
+        let tail = diagnostics.next().expect("the native tail remains visible");
+        insta::assert_debug_snapshot!(format_args!("{}", tail.error()), "source traversal is preserved", @"native tail");
+        assert!(
+            tail.location().is_none(),
+            "ordinary native sources do not inherit their diagnostic owner's callsite"
+        );
+        assert!(diagnostics.next().is_none(), "each real diagnostic is yielded once");
+    }
+    if cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))) {
+        insta::assert_compact_debug_snapshot!(gix_error::TestError::from(error), "normal test reports retain the original callsite after conversion", @"
+        visible diagnostic, at gix-error/tests/error/probable_cause.rs:1344
+
+        Caused by:
+            0: native tail
+        ");
+    } else {
+        insta::assert_compact_debug_snapshot!(gix_error::TestError::from(error), "normal test reports retain the original callsite after conversion", @"
+        visible diagnostic, at gix-error/tests/error/probable_cause.rs:1344
+        |
+        └─ native tail, at gix-error/tests/error/probable_cause.rs:1344
+        ");
+    }
+}
diff --git a/gix-error/tests/error/test.rs b/gix-error/tests/error/test.rs
index b9c3a88094f..854fd731c00 100644
--- a/gix-error/tests/error/test.rs
+++ b/gix-error/tests/error/test.rs
@@ -15,7 +15,7 @@ fn debug_output_and_propagation_into_porcelain_errors() {
     let string = test_failure("message").unwrap_err();
     let plumbing = test_failure(message("plumbing").raise()).unwrap_err();
     let porcelain_input = test_failure(gix_error::Error::from(message("porcelain input").raise())).unwrap_err();
-    let boxed: Box<dyn std::error::Error + Send + Sync> = Box::new(std::io::Error::other("boxed"));
+    let boxed: Box<dyn std::error::Error + Send + Sync> = Box::new(message("boxed"));
     let boxed = test_failure(boxed).unwrap_err();
     let porcelain = porcelain().unwrap_err();
     let output = format!(
@@ -62,3 +62,98 @@ fn debug_output_includes_the_complete_error_chain_and_call_sites() {
         2: native source
     ");
 }
+
+#[test]
+fn io_payload_reports_expand_each_payload_once_in_both_backends() {
+    use std::io::{Error, ErrorKind};
+
+    use super::exn::assert_io_payload_report;
+
+    for nested in [false, true] {
+        let payload = gix_error::validation("invalid input").with("input", b"ref\xff".as_slice());
+        let io = if nested {
+            let boundary = payload.raise().chain(message("payload child")).into_error();
+            Error::new(ErrorKind::InvalidData, boundary.raise().into_error())
+        } else {
+            Error::new(ErrorKind::InvalidData, payload)
+        };
+        let mut exn = io.raise();
+        if nested {
+            exn = exn.chain(message("explicit sibling"));
+        }
+        let original_nodes = exn.iter_errors().count();
+        let metadata = exn.metadata().cloned().collect::<Vec<_>>();
+        let error = TestError::from(exn);
+        let (expected, locations) = match (
+            nested,
+            cfg!(all(feature = "auto-chain-error", not(feature = "tree-error"))),
+        ) {
+            (false, false) => (
+                r#"I/O error (InvalidData)
+|
+└─ invalid input, "input"="ref\xff""#,
+                2,
+            ),
+            (false, true) => (
+                r#"I/O error (InvalidData)
+
+Caused by:
+    0: invalid input, "input"="ref\xff""#,
+                1,
+            ),
+            (true, false) => (
+                r#"I/O error (InvalidData)
+|
+└─ invalid input, "input"="ref\xff"
+|   |
+|   └─ payload child
+|
+└─ explicit sibling"#,
+                4,
+            ),
+            (true, true) => (
+                r#"I/O error (InvalidData)
+
+Caused by:
+    0: explicit sibling
+    1: invalid input, "input"="ref\xff"
+    2: payload child"#,
+                4,
+            ),
+        };
+        for (report, locations) in [(format!("{error:?}"), locations), (format!("{error:#?}"), 0)] {
+            assert_io_payload_report(
+                &report,
+                expected,
+                locations,
+                &[
+                    ("I/O error (InvalidData)", 1),
+                    ("invalid input", 1),
+                    (r"ref\xff", 1),
+                    ("payload child", usize::from(nested)),
+                    ("explicit sibling", usize::from(nested)),
+                ],
+            );
+        }
+        let error = gix_error::Error::from(error);
+        assert_eq!(
+            error.iter_errors().count(),
+            original_nodes,
+            "omitting boundary labels does not remove boundary entries from traversal"
+        );
+        assert_eq!(
+            error
+                .downcast_any_ref::<Error>()
+                .expect("TestError retains the I/O wrapper")
+                .kind(),
+            ErrorKind::InvalidData,
+            "TestError reporting preserves the I/O kind"
+        );
+        assert!(error.is_validation(), "TestError retains the payload classification");
+        assert_eq!(
+            error.metadata().cloned().collect::<Vec<_>>(),
+            metadata,
+            "reporting and conversion preserve payload bytes without duplicating metadata"
+        );
+    }
+}
diff --git a/gix-features/Cargo.toml b/gix-features/Cargo.toml
index 2c19c23fd50..15f09c996b6 100644
--- a/gix-features/Cargo.toml
+++ b/gix-features/Cargo.toml
@@ -115,3 +115,7 @@ libc = { version = "0.2.186" }
 [package.metadata.docs.rs]
 all-features = true
 features = ["document-features"]
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
diff --git a/gix-features/tests/parallel/in_parallel_with_slice.rs b/gix-features/tests/parallel/in_parallel_with_slice.rs
index 6e58be0c7eb..f930655373c 100644
--- a/gix-features/tests/parallel/in_parallel_with_slice.rs
+++ b/gix-features/tests/parallel/in_parallel_with_slice.rs
@@ -77,11 +77,8 @@ mod threaded {
             |thread_id| thread_id,
         )
         .expect_err("failing consumers lead to an error");
-        assert_eq!(
-            err, "the cause of the stop",
-            "the causal error wins over errors of threads that merely reacted to the stop, \
-             even though they are joined first"
-        );
+        insta::assert_debug_snapshot!(err, "the causal error wins over errors of threads that merely reacted to the stop, \
+             even though they are joined first", @r#""the cause of the stop""#);
     }
 
     #[test]
@@ -120,9 +117,6 @@ mod threaded {
             |thread_id| thread_id,
         )
         .expect_err("failing consumers lead to an error");
-        assert_eq!(
-            err, "the cause of the stop",
-            "causality is not determined by the stop flag, which may be set by consumers themselves"
-        );
+        insta::assert_debug_snapshot!(err, "causality is not determined by the stop flag, which may be set by consumers themselves", @r#""the cause of the stop""#);
     }
 }
diff --git a/gix-features/tests/pipe.rs b/gix-features/tests/pipe.rs
index 8027a234c91..74384b48dff 100644
--- a/gix-features/tests/pipe.rs
+++ b/gix-features/tests/pipe.rs
@@ -23,10 +23,14 @@ mod io {
     #[test]
     fn lack_of_reader_fails_with_broken_pipe() {
         let (mut writer, _) = io::pipe::unidirectional(0);
-        assert_eq!(
-            writer.write_all(b"must fail").unwrap_err().kind(),
-            ErrorKind::BrokenPipe
-        );
+        let err = writer.write_all(b"must fail").expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "lack of reader fails with broken pipe", @"
+        Custom {
+            kind: BrokenPipe,
+            error: SendError { .. },
+        }
+        ");
+        assert_eq!(err.kind(), ErrorKind::BrokenPipe);
     }
     #[test]
     fn line_reading_one_by_one() {
@@ -62,21 +66,23 @@ mod io {
             .send(Err(std::io::Error::other("the error")))
             .expect("send success");
         let mut buf = [0];
-        assert_eq!(
-            reader.read(&mut buf).unwrap_err().to_string(),
-            "the error",
-            "using Read trait, errors are propagated"
-        );
+        insta::assert_debug_snapshot!(reader.read(&mut buf).expect_err("using Read trait, errors are propagated"), "using Read trait, errors are propagated", @r#"
+        Custom {
+            kind: Other,
+            error: "the error",
+        }
+        "#);
 
         writer
             .channel
             .send(Err(std::io::Error::other("the error")))
             .expect("send success");
-        assert_eq!(
-            reader.fill_buf().unwrap_err().to_string(),
-            "the error",
-            "using BufRead trait, errors are propagated"
-        );
+        insta::assert_debug_snapshot!(reader.fill_buf().expect_err("using BufRead trait, errors are propagated"), "using BufRead trait, errors are propagated", @r#"
+        Custom {
+            kind: Other,
+            error: "the error",
+        }
+        "#);
     }
 
     #[test]
diff --git a/gix-filter/Cargo.toml b/gix-filter/Cargo.toml
index d0c0816020d..6a0a5697028 100644
--- a/gix-filter/Cargo.toml
+++ b/gix-filter/Cargo.toml
@@ -52,11 +52,12 @@ gix-attributes = { version = "^0.35.0", path = "../gix-attributes" }
 
 encoding_rs = "0.8.32"
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
-thiserror = "2.0.18"
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 smallvec = "1.15.1"
 
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-filter = { path = ".", features = ["test-helper"] }
 gix-hash = { path = "../gix-hash", features = ["sha1", "sha256"] }
 gix-quote = { path = "../gix-quote" }
diff --git a/gix-filter/src/driver/apply.rs b/gix-filter/src/driver/apply.rs
index 931e5bf30c1..28b83630002 100644
--- a/gix-filter/src/driver/apply.rs
+++ b/gix-filter/src/driver/apply.rs
@@ -1,10 +1,12 @@
 use std::{collections::HashMap, io::Read, sync::Arc};
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, BString};
 
 use crate::{
     Driver, driver,
-    driver::{Operation, Process, State, process, process::client::invoke},
+    driver::{Operation, Process, State, process},
 };
 
 /// What to do if delay is supported by a process filter.
@@ -23,28 +25,6 @@ pub enum Delay {
     Forbid,
 }
 
-/// The error returned by [State::apply()][super::State::apply()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Init(#[from] driver::init::Error),
-    #[error("Could not write entire object to driver")]
-    WriteSource(#[from] std::io::Error),
-    #[error("Filter process delayed an entry even though that was not requested")]
-    DelayNotAllowed,
-    #[error("Failed to invoke '{command}' command")]
-    ProcessInvoke {
-        source: process::client::invoke::Error,
-        command: String,
-    },
-    #[error("The invoked command '{command}' in process indicated an error: {status:?}")]
-    ProcessStatus {
-        status: driver::process::Status,
-        command: String,
-    },
-}
-
 /// Additional information for use in the [`State::apply()`] method.
 #[derive(Debug, Copy, Clone)]
 pub struct Context<'a, 'b> {
@@ -86,7 +66,7 @@ impl State {
         src: &mut impl std::io::Read,
         operation: Operation,
         ctx: Context<'_, '_>,
-    ) -> Result<Option<Box<dyn std::io::Read + 'a>>, Error> {
+    ) -> ExnResult<Option<Box<dyn std::io::Read + 'a>>> {
         match self.apply_delayed(driver, src, operation, Delay::Forbid, ctx)? {
             Some(MaybeDelayed::Delayed(_)) => {
                 unreachable!("we forbid delaying the entry")
@@ -107,8 +87,13 @@ impl State {
         operation: Operation,
         delay: Delay,
         ctx: Context<'_, '_>,
-    ) -> Result<Option<MaybeDelayed<'a>>, Error> {
-        match self.maybe_launch_process(driver, operation, ctx.rela_path)? {
+    ) -> ExnResult<Option<MaybeDelayed<'a>>> {
+        use gix_error::{ErrorExt, ResultExt, message};
+
+        match self
+            .maybe_launch_process(driver, operation, ctx.rela_path)
+            .or_erased()?
+        {
             Some(Process::SingleFile { mut child, command }) => {
                 // To avoid deadlock when the filter immediately echoes input to output (like `cat`),
                 // we need to write to stdin and read from stdout concurrently. If we write all data
@@ -128,12 +113,14 @@ impl State {
                 // (`convert.c::filter_buffer_or_fd()`), avoiding an input-sized allocation in that
                 // case. Find a way to similarly pump the borrowed reader concurrently.
                 let mut input_data = Vec::new();
-                std::io::copy(src, &mut input_data)?;
+                std::io::copy(src, &mut input_data)
+                    .or_raise_erased(|| message("Could not write entire object to driver"))?;
 
                 let stdin = child.stdin.take().expect("configured");
                 let input_data: Arc<[u8]> = input_data.into();
                 let fallback = (!driver.required).then(|| Arc::clone(&input_data));
-                let write_thread = WriterThread::write_all_in_background(input_data, stdin)?;
+                let write_thread = WriterThread::write_all_in_background(input_data, stdin)
+                    .or_raise_erased(|| message("Could not write entire object to driver"))?;
 
                 Ok(Some(MaybeDelayed::Immediate(Box::new(ReadFilterOutput {
                     inner: child.stdout.take(),
@@ -171,18 +158,19 @@ impl State {
                 let status = match invoke_result {
                     Ok(status) => status,
                     Err(err) => {
-                        let invoke::Error::Io(io_err) = &err;
-                        handle_io_err(io_err, &mut self.running, key.0.as_ref());
-                        return Err(Error::ProcessInvoke {
-                            command: command.into(),
-                            source: err,
-                        });
+                        if let Some(io_err) = err.downcast_any_ref::<std::io::Error>() {
+                            handle_io_err(io_err, &mut self.running, key.0.as_ref());
+                        }
+                        return Err(err.raise(message!("Failed to invoke '{command}' command")).erased());
                     }
                 };
 
                 if status.is_delayed() {
                     if matches!(delay, Delay::Forbid) {
-                        return Err(Error::DelayNotAllowed);
+                        return Err(
+                            message("Filter process delayed an entry even though that was not requested")
+                                .raise_erased(),
+                        );
                     }
                     Ok(Some(MaybeDelayed::Delayed(key)))
                 } else if status.is_success() {
@@ -204,10 +192,10 @@ impl State {
                             client.into_child().kill().ok();
                         }
                     }
-                    Err(Error::ProcessStatus {
-                        command: command.into(),
-                        status,
-                    })
+                    Err(
+                        message!("The invoked command '{command}' in process indicated an error: {status:?}")
+                            .raise_erased(),
+                    )
                 }
             }
             None => Ok(None),
diff --git a/gix-filter/src/driver/delayed.rs b/gix-filter/src/driver/delayed.rs
index c33e1eee114..71fb655c468 100644
--- a/gix-filter/src/driver/delayed.rs
+++ b/gix-filter/src/driver/delayed.rs
@@ -1,50 +1,11 @@
 use bstr::{BStr, BString};
+use gix_error::ExnMessageResult;
 
 use crate::{
     driver,
     driver::{Operation, State, apply::handle_io_err},
 };
 
-///
-pub mod list {
-    use crate::driver;
-
-    /// The error returned by [State::list_delayed_paths()][super::State::list_delayed_paths()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not get process named '{}' which should be running and tracked", wanted.0)]
-        ProcessMissing { wanted: driver::Key },
-        #[error("Failed to run 'list_available_blobs' command")]
-        ProcessInvoke(#[from] driver::process::client::invoke::without_content::Error),
-        #[error("The invoked command 'list_available_blobs' in process indicated an error: {status:?}")]
-        ProcessStatus { status: driver::process::Status },
-    }
-}
-
-///
-pub mod fetch {
-    use crate::driver;
-
-    /// The error returned by [State::fetch_delayed()][super::State::fetch_delayed()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not get process named '{}' which should be running and tracked", wanted.0)]
-        ProcessMissing { wanted: driver::Key },
-        #[error("Failed to run '{command}' command")]
-        ProcessInvoke {
-            command: String,
-            source: driver::process::client::invoke::Error,
-        },
-        #[error("The invoked command '{command}' in process indicated an error: {status:?}")]
-        ProcessStatus {
-            status: driver::process::Status,
-            command: String,
-        },
-    }
-}
-
 /// Operations related to delayed filtering.
 impl State {
     /// Return a list of delayed paths for `process` that can then be obtained with [`fetch_delayed()`][Self::fetch_delayed()].
@@ -57,13 +18,15 @@ impl State {
     ///
     /// Usually if the process sends the "abort" status, we will not use a certain capability again. Here it's unclear what capability
     /// that is and what to do, so we leave the process running and do nothing else (just like `git`).
-    pub fn list_delayed_paths(&mut self, process: &driver::Key) -> Result<Vec<BString>, list::Error> {
-        let client = self
-            .running
-            .get_mut(&process.0)
-            .ok_or_else(|| list::Error::ProcessMissing {
-                wanted: process.clone(),
-            })?;
+    pub fn list_delayed_paths(&mut self, process: &driver::Key) -> ExnMessageResult<Vec<BString>> {
+        use gix_error::{ErrorExt, OptionExt, message};
+
+        let client = self.running.get_mut(&process.0).ok_or_raise(|| {
+            message!(
+                "Could not get process named '{}' which should be running and tracked",
+                process.0
+            )
+        })?;
 
         let mut out = Vec::new();
         let result = client.invoke_without_content("list_available_blobs", &mut None.into_iter(), &mut |line| {
@@ -74,10 +37,10 @@ impl State {
         let status = match result {
             Ok(res) => res,
             Err(err) => {
-                if let driver::process::client::invoke::without_content::Error::Io(err) = &err {
-                    handle_io_err(err, &mut self.running, process.0.as_ref());
+                if let Some(io_err) = err.downcast_any_ref::<std::io::Error>() {
+                    handle_io_err(io_err, &mut self.running, process.0.as_ref());
                 }
-                return Err(err.into());
+                return Err(err.raise(message("Failed to run 'list_available_blobs' command")));
             }
         };
 
@@ -92,7 +55,10 @@ impl State {
                     client.into_child().kill().ok();
                 }
             }
-            Err(list::Error::ProcessStatus { status })
+            Err(
+                message!("The invoked command 'list_available_blobs' in process indicated an error: {status:?}")
+                    .raise(),
+            )
         }
     }
 
@@ -104,13 +70,15 @@ impl State {
         process: &driver::Key,
         path: &BStr,
         operation: Operation,
-    ) -> Result<impl std::io::Read + '_, fetch::Error> {
-        let client = self
-            .running
-            .get_mut(&process.0)
-            .ok_or_else(|| fetch::Error::ProcessMissing {
-                wanted: process.clone(),
-            })?;
+    ) -> ExnMessageResult<impl std::io::Read + '_> {
+        use gix_error::{ErrorExt, OptionExt, message};
+
+        let client = self.running.get_mut(&process.0).ok_or_raise(|| {
+            message!(
+                "Could not get process named '{}' which should be running and tracked",
+                process.0
+            )
+        })?;
 
         let result = client.invoke(
             operation.as_str(),
@@ -120,12 +88,10 @@ impl State {
         let status = match result {
             Ok(status) => status,
             Err(err) => {
-                let driver::process::client::invoke::Error::Io(io_err) = &err;
-                handle_io_err(io_err, &mut self.running, process.0.as_ref());
-                return Err(fetch::Error::ProcessInvoke {
-                    command: operation.as_str().into(),
-                    source: err,
-                });
+                if let Some(io_err) = err.downcast_any_ref::<std::io::Error>() {
+                    handle_io_err(io_err, &mut self.running, process.0.as_ref());
+                }
+                return Err(err.raise(message!("Failed to run '{}' command", operation.as_str())));
             }
         };
         if status.is_success() {
@@ -147,10 +113,11 @@ impl State {
                     client.into_child().kill().ok();
                 }
             }
-            Err(fetch::Error::ProcessStatus {
-                command: operation.as_str().into(),
-                status,
-            })
+            Err(message!(
+                "The invoked command '{}' in process indicated an error: {status:?}",
+                operation.as_str()
+            )
+            .raise())
         }
     }
 }
diff --git a/gix-filter/src/driver/init.rs b/gix-filter/src/driver/init.rs
index eaa11ad5a3b..1bb07097897 100644
--- a/gix-filter/src/driver/init.rs
+++ b/gix-filter/src/driver/init.rs
@@ -1,5 +1,7 @@
 use std::process::Stdio;
 
+use gix_error::ExnMessageResult;
+
 use bstr::{BStr, BString};
 
 use crate::{
@@ -7,22 +9,6 @@ use crate::{
     driver::{Operation, Process, State, process, substitute_f_parameter},
 };
 
-/// The error returned by [State::maybe_launch_process()][super::State::maybe_launch_process()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to spawn driver: {command:?}")]
-    SpawnCommand {
-        source: std::io::Error,
-        command: std::process::Command,
-    },
-    #[error("Process handshake with command {command:?} failed")]
-    ProcessHandshake {
-        source: process::client::handshake::Error,
-        command: std::process::Command,
-    },
-}
-
 /// Lifecycle
 impl State {
     /// Obtain a process as defined in `driver` suitable for a given `operation. `rela_path` may be used to substitute the current
@@ -34,19 +20,16 @@ impl State {
         driver: &Driver,
         operation: Operation,
         rela_path: &BStr,
-    ) -> Result<Option<Process<'_>>, Error> {
+    ) -> ExnMessageResult<Option<Process<'_>>> {
         match driver.process.as_ref() {
             Some(process) => {
                 let client = match self.running.remove(process) {
                     Some(c) => c,
                     None => {
                         let (child, cmd) = spawn_driver(process.clone(), &self.context)?;
-                        process::Client::handshake(child, "git-filter", &[2], &["clean", "smudge", "delay"]).map_err(
-                            |err| Error::ProcessHandshake {
-                                source: err,
-                                command: cmd,
-                            },
-                        )?
+                        use gix_error::{ResultExt, message};
+                        process::Client::handshake(child, "git-filter", &[2], &["clean", "smudge", "delay"])
+                            .or_raise(|| message!("Process handshake with command {cmd:?} failed"))?
                     }
                 };
 
@@ -89,7 +72,7 @@ impl State {
 fn spawn_driver(
     cmd: BString,
     context: &gix_command::Context,
-) -> Result<(std::process::Child, std::process::Command), Error> {
+) -> ExnMessageResult<(std::process::Child, std::process::Command)> {
     let mut cmd: std::process::Command = gix_command::prepare(gix_path::from_bstr(cmd).into_owned())
         .command_may_be_shell_script()
         .with_context(context.clone())
@@ -101,10 +84,8 @@ fn spawn_driver(
     let child = match cmd.spawn() {
         Ok(child) => child,
         Err(err) => {
-            return Err(Error::SpawnCommand {
-                source: err,
-                command: cmd,
-            });
+            use gix_error::ErrorExt;
+            return Err(err.and_raise(gix_error::message!("Failed to spawn driver: {cmd:?}")));
         }
     };
     Ok((child, cmd))
diff --git a/gix-filter/src/driver/process/client.rs b/gix-filter/src/driver/process/client.rs
index 40594770753..6252d9580a3 100644
--- a/gix-filter/src/driver/process/client.rs
+++ b/gix-filter/src/driver/process/client.rs
@@ -1,5 +1,7 @@
 use std::{collections::HashSet, io::Write, str::FromStr};
 
+use gix_error::ExnMessageResult;
+
 use bstr::{BStr, BString, ByteVec};
 use gix_packetline::blocking_io::{StreamingPeekableIter, Writer, encode};
 
@@ -8,53 +10,6 @@ use crate::driver::{
     process::{Capabilities, Client, PacketlineReader},
 };
 
-///
-pub mod handshake {
-    /// The error returned by [Client::handshake()][super::Client::handshake()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to read or write to the process")]
-        Io(#[from] std::io::Error),
-        #[error("{msg} '{actual}'")]
-        Protocol { msg: String, actual: String },
-        #[error("The server sent the '{name}' capability which isn't among the ones we desire can support")]
-        UnsupportedCapability { name: String },
-    }
-}
-
-///
-pub mod invoke {
-    /// The error returned by [Client::invoke()][super::Client::invoke()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to read or write to the process")]
-        Io(#[from] std::io::Error),
-    }
-
-    ///
-    pub mod without_content {
-        /// The error returned by [Client::invoke_without_content()][super::super::Client::invoke_without_content()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Failed to read or write to the process")]
-            Io(#[from] std::io::Error),
-            #[error(transparent)]
-            PacketlineDecode(#[from] gix_packetline::decode::Error),
-        }
-
-        impl From<super::Error> for Error {
-            fn from(value: super::Error) -> Self {
-                match value {
-                    super::Error::Io(err) => Error::Io(err),
-                }
-            }
-        }
-    }
-}
-
 /// Protocol implementation
 impl Client {
     /// Given a spawned `process` as created from `cmd`, use the 'long-running-process' protocol to send `welcome-prefix` and supported
@@ -65,14 +20,19 @@ impl Client {
         welcome_prefix: &str,
         versions: &[usize],
         desired_capabilities: &[&str],
-    ) -> Result<Self, handshake::Error> {
+    ) -> ExnMessageResult<Self> {
+        use gix_error::{ErrorExt, ResultExt, message};
+
         let mut out = Writer::new(process.stdin.take().expect("configured stdin when spawning"));
-        out.write_all(format!("{welcome_prefix}-client").as_bytes())?;
+        out.write_all(format!("{welcome_prefix}-client").as_bytes())
+            .or_raise(|| message("Failed to read or write to the process"))?;
         for version in versions {
-            out.write_all(format!("version={version}").as_bytes())?;
+            out.write_all(format!("version={version}").as_bytes())
+                .or_raise(|| message("Failed to read or write to the process"))?;
         }
-        encode::flush_to_write(out.inner_mut())?;
-        out.flush()?;
+        encode::flush_to_write(out.inner_mut()).or_raise(|| message("Failed to read or write to the process"))?;
+        out.flush()
+            .or_raise(|| message("Failed to read or write to the process"))?;
 
         let mut input = StreamingPeekableIter::new(
             process.stdout.take().expect("configured stdout when spawning"),
@@ -81,56 +41,58 @@ impl Client {
         );
         let mut read = input.as_read();
         let mut buf = String::new();
-        read.read_line_to_string(&mut buf)?;
+        read.read_line_to_string(&mut buf)
+            .or_raise(|| message("Failed to read or write to the process"))?;
         if buf
             .strip_prefix(welcome_prefix)
             .is_none_or(|rest| rest.trim_end() != "-server")
         {
-            return Err(handshake::Error::Protocol {
-                msg: format!("Wanted '{welcome_prefix}-server, got "),
-                actual: buf,
-            });
+            return Err(message!("Wanted '{welcome_prefix}-server, got  '{buf}'").raise());
         }
 
         buf.clear();
-        read.read_line_to_string(&mut buf)?;
+        read.read_line_to_string(&mut buf)
+            .or_raise(|| message("Failed to read or write to the process"))?;
         let chosen_version = match buf
             .strip_prefix("version=")
             .and_then(|version| usize::from_str(version.trim_end()).ok())
         {
             Some(version) => version,
             None => {
-                return Err(handshake::Error::Protocol {
-                    msg: "Needed 'version=<integer>', got ".into(),
-                    actual: buf,
-                });
+                return Err(message!("Needed 'version=<integer>', got  '{buf}'").raise());
             }
         };
 
         if !versions.contains(&chosen_version) {
-            return Err(handshake::Error::Protocol {
-                msg: format!("Server offered {chosen_version}, we only support "),
-                actual: versions.iter().map(ToString::to_string).collect::<Vec<_>>().join(", "),
-            });
+            return Err(message!(
+                "Server offered {chosen_version}, we only support  '{}'",
+                versions.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ")
+            )
+            .raise());
         }
 
-        if read.read_line_to_string(&mut buf)? != 0 {
-            return Err(handshake::Error::Protocol {
-                msg: "expected flush packet, got".into(),
-                actual: buf,
-            });
+        if read
+            .read_line_to_string(&mut buf)
+            .or_raise(|| message("Failed to read or write to the process"))?
+            != 0
+        {
+            return Err(message!("expected flush packet, got '{buf}'").raise());
         }
         for capability in desired_capabilities {
-            out.write_all(format!("capability={capability}").as_bytes())?;
+            out.write_all(format!("capability={capability}").as_bytes())
+                .or_raise(|| message("Failed to read or write to the process"))?;
         }
-        encode::flush_to_write(out.inner_mut())?;
-        out.flush()?;
+        encode::flush_to_write(out.inner_mut()).or_raise(|| message("Failed to read or write to the process"))?;
+        out.flush()
+            .or_raise(|| message("Failed to read or write to the process"))?;
 
         read.reset_with(&[gix_packetline::PacketLineRef::Flush]);
         let mut capabilities = HashSet::new();
         loop {
             buf.clear();
-            let num_read = read.read_line_to_string(&mut buf)?;
+            let num_read = read
+                .read_line_to_string(&mut buf)
+                .or_raise(|| message("Failed to read or write to the process"))?;
             if num_read == 0 {
                 break;
             }
@@ -138,7 +100,10 @@ impl Client {
                 Some(cap) => {
                     let cap = cap.trim_end();
                     if !desired_capabilities.contains(&cap) {
-                        return Err(handshake::Error::UnsupportedCapability { name: cap.into() });
+                        return Err(message!(
+                            "The server sent the '{cap}' capability which isn't among the ones we desire can support"
+                        )
+                        .raise());
                     }
                     capabilities.insert(cap.to_owned());
                 }
@@ -162,12 +127,18 @@ impl Client {
         command: &str,
         meta: &mut dyn Iterator<Item = (&str, BString)>,
         content: &mut dyn std::io::Read,
-    ) -> Result<process::Status, invoke::Error> {
+    ) -> ExnMessageResult<process::Status> {
+        use gix_error::{ResultExt, message};
+
         self.send_command_and_meta(command, meta)?;
-        std::io::copy(content, &mut self.input)?;
-        encode::flush_to_write(self.input.inner_mut())?;
-        self.input.flush()?;
-        Ok(self.read_status()?)
+        std::io::copy(content, &mut self.input).or_raise(|| message("Failed to read or write to the process"))?;
+        encode::flush_to_write(self.input.inner_mut())
+            .or_raise(|| message("Failed to read or write to the process"))?;
+        self.input
+            .flush()
+            .or_raise(|| message("Failed to read or write to the process"))?;
+        self.read_status()
+            .or_raise(|| message("Failed to read or write to the process"))
     }
 
     /// Invoke `command` while passing `meta` data, but don't send any content, and return their status.
@@ -179,16 +150,22 @@ impl Client {
         command: &str,
         meta: &mut dyn Iterator<Item = (&'a str, BString)>,
         inspect_line: &mut dyn FnMut(&BStr),
-    ) -> Result<process::Status, invoke::without_content::Error> {
+    ) -> ExnMessageResult<process::Status> {
+        use gix_error::{ResultExt, message};
+
         self.send_command_and_meta(command, meta)?;
         while let Some(data) = self.out.read_line() {
-            let line = data??;
+            let line = data
+                .or_raise(|| message("Failed to read from the process"))?
+                .or_raise(|| message("Failed to decode a packet line from the process"))?;
             if let Some(line) = line.as_text() {
                 inspect_line(line.as_bstr());
             }
         }
         self.out.reset_with(&[gix_packetline::PacketLineRef::Flush]);
-        let status = self.read_status()?;
+        let status = self
+            .read_status()
+            .or_raise(|| message("Failed to read or write to the process"))?;
         Ok(status)
     }
 
@@ -213,17 +190,24 @@ impl Client {
         &mut self,
         command: &str,
         meta: &mut dyn Iterator<Item = (&str, BString)>,
-    ) -> Result<(), invoke::Error> {
-        self.input.write_all(format!("command={command}").as_bytes())?;
+    ) -> ExnMessageResult {
+        use gix_error::{ResultExt, message};
+
+        self.input
+            .write_all(format!("command={command}").as_bytes())
+            .or_raise(|| message("Failed to read or write to the process"))?;
         let mut buf = BString::default();
         for (key, value) in meta {
             buf.clear();
             buf.push_str(key);
             buf.push(b'=');
             buf.push_str(&value);
-            self.input.write_all(&buf)?;
+            self.input
+                .write_all(&buf)
+                .or_raise(|| message("Failed to read or write to the process"))?;
         }
-        encode::flush_to_write(self.input.inner_mut())?;
+        encode::flush_to_write(self.input.inner_mut())
+            .or_raise(|| message("Failed to read or write to the process"))?;
         Ok(())
     }
 }
diff --git a/gix-filter/src/driver/process/server.rs b/gix-filter/src/driver/process/server.rs
index 1ce68521d6f..6a7582a7a9c 100644
--- a/gix-filter/src/driver/process/server.rs
+++ b/gix-filter/src/driver/process/server.rs
@@ -1,5 +1,7 @@
 use std::{collections::HashSet, io::Write, str::FromStr};
 
+use gix_error::ExnMessageResult;
+
 use bstr::{BString, ByteSlice};
 use gix_packetline::blocking_io::{StreamingPeekableIter, Writer, encode};
 
@@ -14,38 +16,6 @@ pub struct Request<'a> {
     pub meta: Vec<(String, BString)>,
 }
 
-///
-pub mod next_request {
-    use bstr::BString;
-
-    /// The error returned by [Server::next_request()][super::Server::next_request()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to read from the client")]
-        Io(#[from] std::io::Error),
-        #[error("{msg} '{actual}'")]
-        Protocol { msg: String, actual: BString },
-        #[error(transparent)]
-        PacketlineDecode(#[from] gix_packetline::decode::Error),
-    }
-}
-
-///
-pub mod handshake {
-    /// The error returned by [Server::handshake()][super::Server::handshake()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to read or write to the client")]
-        Io(#[from] std::io::Error),
-        #[error("{msg} '{actual}'")]
-        Protocol { msg: String, actual: String },
-        #[error("Could not select supported version from the one sent by the client: {}", actual.iter().map(ToString::to_string).collect::<Vec<_>>().join(", "))]
-        VersionMismatch { actual: Vec<usize> },
-    }
-}
-
 impl Server {
     /// Perform a handshake with the client sending information to our `stdin` and receiving information through our `stdout`
     /// in packetline format.
@@ -63,7 +33,9 @@ impl Server {
         welcome_prefix: &str,
         pick_version: &mut dyn FnMut(&[usize]) -> Option<usize>,
         available_capabilities: &[&str],
-    ) -> Result<Self, handshake::Error> {
+    ) -> ExnMessageResult<Self> {
+        use gix_error::{ErrorExt, OptionExt, ResultExt, message};
+
         let mut input = StreamingPeekableIter::new(
             stdin.lock(),
             &[gix_packetline::PacketLineRef::Flush],
@@ -71,21 +43,21 @@ impl Server {
         );
         let mut read = input.as_read();
         let mut buf = String::new();
-        read.read_line_to_string(&mut buf)?;
+        read.read_line_to_string(&mut buf)
+            .or_raise(|| message("Failed to read or write to the client"))?;
         if buf
             .strip_prefix(welcome_prefix)
             .is_none_or(|rest| rest.trim_end() != "-client")
         {
-            return Err(handshake::Error::Protocol {
-                msg: format!("Expected '{welcome_prefix}-client, got"),
-                actual: buf,
-            });
+            return Err(message!("Expected '{welcome_prefix}-client, got '{buf}'").raise());
         }
 
         let mut versions = Vec::new();
         loop {
             buf.clear();
-            let num_read = read.read_line_to_string(&mut buf)?;
+            let num_read = read
+                .read_line_to_string(&mut buf)
+                .or_raise(|| message("Failed to read or write to the client"))?;
             if num_read == 0 {
                 break;
             }
@@ -96,26 +68,33 @@ impl Server {
                 {
                     Some(version) => version,
                     None => {
-                        return Err(handshake::Error::Protocol {
-                            msg: "Expected 'version=<integer>', got".into(),
-                            actual: buf,
-                        });
+                        return Err(message!("Expected 'version=<integer>', got '{buf}'").raise());
                     }
                 },
             );
         }
-        let version = pick_version(&versions).ok_or(handshake::Error::VersionMismatch { actual: versions })?;
+        let version = pick_version(&versions).ok_or_raise(|| {
+            message!(
+                "Could not select supported version from the one sent by the client: {}",
+                versions.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ")
+            )
+        })?;
         read.reset_with(&[gix_packetline::PacketLineRef::Flush]);
         let mut out = Writer::new(stdout.lock());
-        out.write_all(format!("{welcome_prefix}-server").as_bytes())?;
-        out.write_all(format!("version={version}").as_bytes())?;
-        encode::flush_to_write(out.inner_mut())?;
-        out.flush()?;
+        out.write_all(format!("{welcome_prefix}-server").as_bytes())
+            .or_raise(|| message("Failed to read or write to the client"))?;
+        out.write_all(format!("version={version}").as_bytes())
+            .or_raise(|| message("Failed to read or write to the client"))?;
+        encode::flush_to_write(out.inner_mut()).or_raise(|| message("Failed to read or write to the client"))?;
+        out.flush()
+            .or_raise(|| message("Failed to read or write to the client"))?;
 
         let mut capabilities = HashSet::new();
         loop {
             buf.clear();
-            let num_read = read.read_line_to_string(&mut buf)?;
+            let num_read = read
+                .read_line_to_string(&mut buf)
+                .or_raise(|| message("Failed to read or write to the client"))?;
             if num_read == 0 {
                 break;
             }
@@ -131,10 +110,12 @@ impl Server {
         }
 
         for cap in &capabilities {
-            out.write_all(format!("capability={cap}").as_bytes())?;
+            out.write_all(format!("capability={cap}").as_bytes())
+                .or_raise(|| message("Failed to read or write to the client"))?;
         }
-        encode::flush_to_write(out.inner_mut())?;
-        out.flush()?;
+        encode::flush_to_write(out.inner_mut()).or_raise(|| message("Failed to read or write to the client"))?;
+        out.flush()
+            .or_raise(|| message("Failed to read or write to the client"))?;
 
         drop(read);
         Ok(Server {
@@ -155,43 +136,38 @@ impl Server {
     ///
     /// Note that the process is supposed to shut-down once there are no more requests, and `git` will wait
     /// until it has finished.
-    pub fn next_request(&mut self) -> Result<Option<Request<'_>>, next_request::Error> {
+    pub fn next_request(&mut self) -> ExnMessageResult<Option<Request<'_>>> {
+        use gix_error::{ErrorExt, OptionExt, ResultExt, message};
+
         let mut buf = String::new();
         let mut read = self.input.as_read();
 
         match read.read_line_to_string(&mut buf) {
             Ok(_) => {}
             Err(err) if err.kind() == std::io::ErrorKind::UnexpectedEof => return Ok(None),
-            Err(err) => return Err(err.into()),
+            Err(err) => return Err(err.and_raise(message("Failed to read from the client"))),
         }
         let command = match buf.strip_prefix("command=").map(str::trim_end).map(ToOwned::to_owned) {
             Some(cmd) => cmd,
             None => {
-                return Err(next_request::Error::Protocol {
-                    msg: "Wanted 'command=<name>', got ".into(),
-                    actual: buf.into(),
-                });
+                return Err(message!("Wanted 'command=<name>', got  '{buf}'").raise());
             }
         };
 
         let mut meta = Vec::with_capacity(1);
         while let Some(res) = read.read_data_line() {
-            let line = res??;
+            let line = res
+                .or_raise(|| message("Failed to read from the client"))?
+                .or_raise(|| message("Failed to decode packet line"))?;
             let line = line
                 .as_bstr()
-                .ok_or_else(|| next_request::Error::Protocol {
-                    msg: "expected data line, got ".into(),
-                    actual: format!("{line:?}").into(),
-                })?
+                .ok_or_raise(|| message!("expected data line, got  '{line:?}'"))?
                 .trim();
             let mut tokens = line.splitn(2, |b| *b == b'=');
             let (key, value) = tokens
                 .next()
                 .zip(tokens.next())
-                .ok_or_else(|| next_request::Error::Protocol {
-                    msg: "Expected 'key=value' metadata, got".into(),
-                    actual: line.into(),
-                })?;
+                .ok_or_raise(|| message!("Expected 'key=value' metadata, got '{}'", line.as_bstr()))?;
             assert!(tokens.next().is_none(), "configured to yield at most two tokens");
             meta.push((key.as_bstr().to_string(), value.into()));
         }
diff --git a/gix-filter/src/driver/shutdown.rs b/gix-filter/src/driver/shutdown.rs
index cbb85c12d56..f0d91d9ee40 100644
--- a/gix-filter/src/driver/shutdown.rs
+++ b/gix-filter/src/driver/shutdown.rs
@@ -1,4 +1,6 @@
 use bstr::BString;
+use gix_error::ErrorExt;
+use gix_error::ExnMessageResult;
 
 use crate::driver::State;
 
@@ -9,33 +11,20 @@ pub struct Outcome {
     pub processes: Vec<(BString, Option<std::process::ExitStatus>)>,
 }
 
-/// A filter process that exited unsuccessfully during shutdown.
-#[derive(Debug, thiserror::Error)]
-#[error("Filter process {command:?} failed with {status}")]
-pub struct Error {
-    /// The command that launched the process.
-    pub command: BString,
-    /// Its unsuccessful exit status.
-    pub status: std::process::ExitStatus,
-}
-
 impl Outcome {
     /// Return this outcome if all observed processes exited successfully, or the first failure otherwise.
     ///
     /// This is stricter than Git, which ignores a long-running filter's exit status during shutdown after it has
     /// successfully converted all requested input. Callers that require Git-compatible behavior should inspect or
     /// discard the outcome instead.
-    pub fn into_result(self) -> Result<Self, Error> {
+    pub fn into_result(self) -> ExnMessageResult<Self> {
         if let Some((command, status)) = self.processes.iter().find_map(|(command, status)| {
             status
                 .as_ref()
                 .filter(|status| !status.success())
                 .map(|status| (command, status))
         }) {
-            return Err(Error {
-                command: command.clone(),
-                status: *status,
-            });
+            return Err(gix_error::message!("Filter process {command:?} failed with {status}").raise());
         }
         Ok(self)
     }
diff --git a/gix-filter/src/eol/convert_to_git.rs b/gix-filter/src/eol/convert_to_git.rs
index eb50924a709..21ae91068ba 100644
--- a/gix-filter/src/eol/convert_to_git.rs
+++ b/gix-filter/src/eol/convert_to_git.rs
@@ -1,4 +1,6 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
+
+use gix_error::ExnResult;
 
 /// Additional context for use with [`convert_to_git`][super::convert_to_git()].
 #[derive(Default, Copy, Clone)]
@@ -26,30 +28,18 @@ pub enum RoundTripCheck<'a> {
     },
 }
 
-/// The error returned by [convert_to_git()][super::convert_to_git()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("{msg} in '{}'", path.display())]
-    RoundTrip { msg: &'static str, path: PathBuf },
-    #[error("Could not obtain index object to check line endings for")]
-    FetchObjectFromIndex(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error("Could not allocate buffer")]
-    OutOfMemory(#[from] std::collections::TryReserveError),
-}
-
 /// A function that writes a buffer like `fn(&mut buf)` with by tes of an object in the index that is the one that should be converted.
-pub type IndexObjectFn<'a> =
-    dyn FnMut(&mut Vec<u8>) -> Result<Option<()>, Box<dyn std::error::Error + Send + Sync>> + 'a;
+pub type IndexObjectFn<'a> = dyn FnMut(&mut Vec<u8>) -> ExnResult<Option<()>> + 'a;
 
 pub(crate) mod function {
     use bstr::ByteSlice;
+    use gix_error::ExnMessageResult;
 
     use crate::{
         clear_and_set_capacity,
         eol::{
             AttributesDigest, Stats,
-            convert_to_git::{Error, IndexObjectFn, Options, RoundTripCheck},
+            convert_to_git::{IndexObjectFn, Options, RoundTripCheck},
         },
     };
 
@@ -71,7 +61,9 @@ pub(crate) mod function {
             round_trip_check,
             config,
         }: Options<'_>,
-    ) -> Result<bool, Error> {
+    ) -> ExnMessageResult<bool> {
+        use gix_error::{ErrorExt, ResultExt, message};
+
         if digest == AttributesDigest::Binary || src.is_empty() {
             return Ok(false);
         }
@@ -84,7 +76,9 @@ pub(crate) mod function {
                 return Ok(false);
             }
 
-            if let Some(()) = index_object(buf).map_err(Error::FetchObjectFromIndex)? {
+            if let Some(()) =
+                index_object(buf).or_raise(|| message("Could not obtain index object to check line endings for"))?
+            {
                 let has_crlf_in_index = buf
                     .find_byte(b'\r')
                     .map(|_| Stats::from_bytes(buf))
@@ -112,10 +106,7 @@ pub(crate) mod function {
                 // CRLF would not be restored by checkout
                 match round_trip_check {
                     RoundTripCheck::Fail { rela_path } => {
-                        return Err(Error::RoundTrip {
-                            msg: "CRLF would be replaced by LF",
-                            path: rela_path.to_owned(),
-                        });
+                        return Err(message!("CRLF would be replaced by LF in '{}'", rela_path.display()).raise());
                     }
                     #[allow(unused_variables, reason = "Used when tracing is enabled at compile time.")]
                     RoundTripCheck::Warn { rela_path } => {
@@ -129,10 +120,7 @@ pub(crate) mod function {
                 // CRLF would be added by checkout
                 match round_trip_check {
                     RoundTripCheck::Fail { rela_path } => {
-                        return Err(Error::RoundTrip {
-                            msg: "LF would be replaced by CRLF",
-                            path: rela_path.to_owned(),
-                        });
+                        return Err(message!("LF would be replaced by CRLF in '{}'", rela_path.display()).raise());
                     }
                     #[allow(unused_variables, reason = "Used when tracing is enabled at compile time.")]
                     RoundTripCheck::Warn { rela_path } => {
@@ -149,7 +137,7 @@ pub(crate) mod function {
             return Ok(false);
         }
 
-        clear_and_set_capacity(buf, src.len() - stats.crlf)?;
+        clear_and_set_capacity(buf, src.len() - stats.crlf).or_raise(|| message("Could not allocate buffer"))?;
         if stats.lone_cr == 0 {
             buf.extend(src.iter().filter(|b| **b != b'\r'));
         } else {
diff --git a/gix-filter/src/eol/convert_to_worktree.rs b/gix-filter/src/eol/convert_to_worktree.rs
index 206a4673572..dd7929854cf 100644
--- a/gix-filter/src/eol/convert_to_worktree.rs
+++ b/gix-filter/src/eol/convert_to_worktree.rs
@@ -1,18 +1,11 @@
 use bstr::{ByteSlice, ByteVec};
+use gix_error::ExnMessageResult;
 
 use crate::{
     clear_and_set_capacity,
     eol::{AttributesDigest, Configuration, Mode, Stats},
 };
 
-/// The error produced by [`convert_to_worktree()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not allocate buffer")]
-    OutOfMemory(#[from] std::collections::TryReserveError),
-}
-
 /// Convert all `\n` in `src` to `crlf` if `digest` and `config` indicate it, returning `true` if `buf` holds the result, or `false`
 /// if no change was made after all.
 pub fn convert_to_worktree(
@@ -20,7 +13,9 @@ pub fn convert_to_worktree(
     digest: AttributesDigest,
     buf: &mut Vec<u8>,
     config: Configuration,
-) -> Result<bool, Error> {
+) -> ExnMessageResult<bool> {
+    use gix_error::{ResultExt, message};
+
     if src.is_empty() || digest.to_eol(config) != Some(Mode::CrLf) {
         return Ok(false);
     }
@@ -29,7 +24,7 @@ pub fn convert_to_worktree(
         return Ok(false);
     }
 
-    clear_and_set_capacity(buf, src.len() + stats.lone_lf)?;
+    clear_and_set_capacity(buf, src.len() + stats.lone_lf).or_raise(|| message("Could not allocate buffer"))?;
 
     let mut ofs = 0;
     while let Some(pos) = src[ofs..].find_byteset(b"\r\n") {
diff --git a/gix-filter/src/ident.rs b/gix-filter/src/ident.rs
index 4e0d8573fd9..ef590b6f9fa 100644
--- a/gix-filter/src/ident.rs
+++ b/gix-filter/src/ident.rs
@@ -1,5 +1,7 @@
 use std::ops::Range;
 
+use gix_error::ExnMessageResult;
+
 use bstr::{ByteSlice, ByteVec};
 
 use crate::clear_and_set_capacity;
@@ -40,19 +42,6 @@ pub fn undo(src: &[u8], buf: &mut Vec<u8>) -> Result<bool, std::collections::Try
     Ok(initialized)
 }
 
-///
-pub mod apply {
-    /// The error produced by [`super::apply()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not allocate buffer")]
-        OutOfMemory(#[from] std::collections::TryReserveError),
-        #[error("Could not hash blob")]
-        Hasher(#[from] gix_hash::hasher::Error),
-    }
-}
-
 /// Substitute all occurrences of `$Id$` with `$Id: <hexsha-of-input>$` if present in `src` and write all changes to `buf`,
 /// with `object_hash` being used accordingly. Return `true` if `buf` was written to or `false` if no change was made
 /// (as there was nothing to do).
@@ -61,16 +50,19 @@ pub mod apply {
 ///
 /// `Git` also tries to cleanup 'stray' substituted `$Id: <hex>$`, but we don't do that, sticking exactly to what ought to be done.
 /// The respective code is up to 16 years old and one might assume that `git` by now handles checking and checkout filters correctly.
-pub fn apply(src: &[u8], object_hash: gix_hash::Kind, buf: &mut Vec<u8>) -> Result<bool, apply::Error> {
+pub fn apply(src: &[u8], object_hash: gix_hash::Kind, buf: &mut Vec<u8>) -> ExnMessageResult<bool> {
+    use gix_error::{ResultExt, message};
+
     const HASH_LEN: usize = ": ".len() + gix_hash::Kind::longest().len_in_hex();
     let mut id = None;
     let mut ofs = 0;
     while let Some(pos) = src[ofs..].find(b"$Id$") {
         let id = match id {
             None => {
-                let new_id = gix_object::compute_hash(object_hash, gix_object::Kind::Blob, src)?;
+                let new_id = gix_object::compute_hash(object_hash, gix_object::Kind::Blob, src)
+                    .or_raise(|| message("Could not hash blob"))?;
                 id = new_id.into();
-                clear_and_set_capacity(buf, src.len() + HASH_LEN)?; // pre-allocate for one ID
+                clear_and_set_capacity(buf, src.len() + HASH_LEN).or_raise(|| message("Could not allocate buffer"))?; // pre-allocate for one ID
                 new_id
             }
             Some(id) => id.to_owned(),
diff --git a/gix-filter/src/pipeline/convert.rs b/gix-filter/src/pipeline/convert.rs
index 608aa91b350..52255a2afaf 100644
--- a/gix-filter/src/pipeline/convert.rs
+++ b/gix-filter/src/pipeline/convert.rs
@@ -1,46 +1,16 @@
 use std::{io::Read, path::Path};
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 
 use crate::{Pipeline, driver, eol, ident, pipeline::util::Configuration, worktree};
 
-///
-pub mod configuration {
-    use bstr::BString;
-
-    /// Errors related to the configuration of filter attributes.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The encoding named '{name}' isn't available")]
-        UnknownEncoding { name: BString },
-        #[error("Encodings must be names, like UTF-16, and cannot be booleans.")]
-        InvalidEncoding,
-    }
-}
-
 ///
 pub mod to_git {
+    use gix_error::ExnResult;
     /// A function that fills `buf` `fn(&mut buf)` with the data stored in the index of the file that should be converted.
-    pub type IndexObjectFn<'a> = dyn FnMut(&mut Vec<u8>) -> Result<Option<()>, gix_object::find::Error> + 'a;
-
-    /// The error returned by [Pipeline::convert_to_git()][super::Pipeline::convert_to_git()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Eol(#[from] crate::eol::convert_to_git::Error),
-        #[error(transparent)]
-        Worktree(#[from] crate::worktree::encode_to_git::Error),
-        #[error(transparent)]
-        Driver(#[from] crate::driver::apply::Error),
-        #[error(transparent)]
-        Configuration(#[from] super::configuration::Error),
-        #[error("Copy of driver process output to memory failed")]
-        ReadProcessOutputToBuffer(#[from] std::io::Error),
-        #[error("Could not allocate buffer")]
-        OutOfMemory(#[from] std::collections::TryReserveError),
-    }
+    pub type IndexObjectFn<'a> = dyn FnMut(&mut Vec<u8>) -> ExnResult<Option<()>> + 'a;
 }
 
 ///
@@ -65,22 +35,6 @@ pub mod to_worktree {
         /// Return an error.
         Fail,
     }
-
-    /// The error returned by [Pipeline::convert_to_worktree()][super::Pipeline::convert_to_worktree()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Ident(#[from] crate::ident::apply::Error),
-        #[error(transparent)]
-        Eol(#[from] crate::eol::convert_to_worktree::Error),
-        #[error(transparent)]
-        Worktree(#[from] crate::worktree::encode_to_worktree::Error),
-        #[error(transparent)]
-        Driver(#[from] crate::driver::apply::Error),
-        #[error(transparent)]
-        Configuration(#[from] super::configuration::Error),
-    }
 }
 
 /// Access
@@ -95,10 +49,12 @@ impl Pipeline {
         rela_path: &Path,
         attributes: &mut dyn FnMut(&BStr, &mut gix_attributes::search::Outcome),
         index_object: &mut to_git::IndexObjectFn<'_>,
-    ) -> Result<ToGitOutcome<'_, R>, to_git::Error>
+    ) -> ExnResult<ToGitOutcome<'_, R>>
     where
         R: std::io::Read,
     {
+        use gix_error::{ResultExt, message};
+
         let bstr_rela_path = gix_path::to_unix_separators_on_windows(gix_path::into_bstr(rela_path));
         let Configuration {
             driver,
@@ -113,7 +69,8 @@ impl Pipeline {
             attributes,
             self.options.eol_config,
             false,
-        )?;
+        )
+        .or_erased()?;
 
         let mut in_src_buffer = false;
         // this is just an approximation, but it's as good as it gets without reading the actual input.
@@ -126,7 +83,8 @@ impl Pipeline {
                 round_trip_check: None,
                 config: self.options.eol_config,
             },
-        )?;
+        )
+        .or_erased()?;
 
         if let Some(driver) = driver
             && let Some(mut read) = self.processes.apply(
@@ -143,12 +101,14 @@ impl Pipeline {
                 return Ok(ToGitOutcome::Process(read));
             }
             self.bufs.clear();
-            read.read_to_end(&mut self.bufs.src)?;
+            read.read_to_end(&mut self.bufs.src)
+                .or_raise_erased(|| message("Copy of driver process output to memory failed"))?;
             in_src_buffer = true;
         }
         if !in_src_buffer && (apply_ident_filter || encoding.is_some() || would_convert_eol) {
             self.bufs.clear();
-            src.read_to_end(&mut self.bufs.src)?;
+            src.read_to_end(&mut self.bufs.src)
+                .or_raise_erased(|| message("Copy of driver process output to memory failed"))?;
             in_src_buffer = true;
         }
 
@@ -162,7 +122,8 @@ impl Pipeline {
                 } else {
                     worktree::encode_to_git::RoundTripCheck::Skip
                 },
-            )?;
+            )
+            .or_erased()?;
             self.bufs.swap();
         }
 
@@ -175,11 +136,16 @@ impl Pipeline {
                 round_trip_check: self.options.crlf_roundtrip_check.to_eol_roundtrip_check(rela_path),
                 config: self.options.eol_config,
             },
-        )? {
+        )
+        .or_erased()?
+        {
             self.bufs.swap();
         }
 
-        if apply_ident_filter && ident::undo(&self.bufs.src, &mut self.bufs.dest)? {
+        if apply_ident_filter
+            && ident::undo(&self.bufs.src, &mut self.bufs.dest)
+                .or_raise_erased(|| message("Could not allocate buffer"))?
+        {
             self.bufs.swap();
         }
         Ok(if in_src_buffer {
@@ -205,7 +171,9 @@ impl Pipeline {
             can_delay,
             unknown_encoding,
         }: to_worktree::Options,
-    ) -> Result<ToWorktreeOutcome<'input, '_>, to_worktree::Error> {
+    ) -> ExnResult<ToWorktreeOutcome<'input, '_>> {
+        use gix_error::ResultExt;
+
         let Configuration {
             driver,
             digest,
@@ -219,16 +187,17 @@ impl Pipeline {
             attributes,
             self.options.eol_config,
             unknown_encoding == to_worktree::UnknownEncoding::Ignore,
-        )?;
+        )
+        .or_erased()?;
 
         let mut bufs = self.bufs.use_foreign_src(src);
         let (src, dest) = bufs.src_and_dest();
-        if apply_ident_filter && ident::apply(src, self.options.object_hash, dest)? {
+        if apply_ident_filter && ident::apply(src, self.options.object_hash, dest).or_erased()? {
             bufs.swap();
         }
 
         let (src, dest) = bufs.src_and_dest();
-        if eol::convert_to_worktree(src, digest, dest, self.options.eol_config)? {
+        if eol::convert_to_worktree(src, digest, dest, self.options.eol_config).or_erased()? {
             bufs.swap();
         }
 
@@ -239,7 +208,9 @@ impl Pipeline {
                 Err(_err) if unknown_encoding == to_worktree::UnknownEncoding::Ignore => {
                     gix_trace::warn!(err = %_err, "Ignoring failed worktree encoding");
                 }
-                Err(err) => return Err(err.into()),
+                Err(err) => {
+                    return Err(err.erased());
+                }
             }
         }
 
diff --git a/gix-filter/src/pipeline/util.rs b/gix-filter/src/pipeline/util.rs
index 77860906b38..9452827e5b9 100644
--- a/gix-filter/src/pipeline/util.rs
+++ b/gix-filter/src/pipeline/util.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::path::Path;
 
 use bstr::BStr;
@@ -7,7 +8,7 @@ use smallvec::SmallVec;
 use crate::{
     Driver, driver, eol,
     eol::AttributesDigest,
-    pipeline::{Context, CrlfRoundTripCheck, convert::configuration},
+    pipeline::{Context, CrlfRoundTripCheck},
 };
 
 pub(crate) struct Configuration<'a> {
@@ -29,7 +30,7 @@ impl<'driver> Configuration<'driver> {
         attributes: &mut dyn FnMut(&BStr, &mut gix_attributes::search::Outcome),
         config: eol::Configuration,
         ignore_unknown_encoding: bool,
-    ) -> Result<Configuration<'driver>, configuration::Error> {
+    ) -> ExnMessageResult<Configuration<'driver>> {
         fn extract_driver<'a>(drivers: &'a [Driver], attr: &gix_attributes::search::Match<'_>) -> Option<&'a Driver> {
             if let StateRef::Value(name) = attr.assignment.state {
                 drivers.iter().find(|d| d.name == name.as_bstr())
@@ -41,9 +42,11 @@ impl<'driver> Configuration<'driver> {
         fn extract_encoding(
             attr: &gix_attributes::search::Match<'_>,
             ignore_unknown: bool,
-        ) -> Result<Option<&'static encoding_rs::Encoding>, configuration::Error> {
+        ) -> ExnMessageResult<Option<&'static encoding_rs::Encoding>> {
             match attr.assignment.state {
-                StateRef::Set | StateRef::Unset => Err(configuration::Error::InvalidEncoding),
+                StateRef::Set | StateRef::Unset => {
+                    Err(gix_error::validation("Encodings must be names, like UTF-16, and cannot be booleans.").into())
+                }
                 StateRef::Value(name) => match encoding_rs::Encoding::for_label(name.as_bstr()) {
                     Some(encoding) => Ok({
                         // The working-tree-encoding is the encoding we have to expect in the working tree.
@@ -58,9 +61,11 @@ impl<'driver> Configuration<'driver> {
                         gix_trace::warn!(encoding = %name.as_bstr(), "Ignoring unavailable worktree encoding");
                         Ok(None)
                     }
-                    None => Err(configuration::Error::UnknownEncoding {
-                        name: name.as_bstr().to_owned(),
-                    }),
+                    None => Err(gix_error::validation(format!(
+                        "The encoding named '{}' isn't available",
+                        name.as_bstr()
+                    ))
+                    .into()),
                 },
                 StateRef::Unspecified => Ok(None),
             }
diff --git a/gix-filter/src/worktree/encode_to_git.rs b/gix-filter/src/worktree/encode_to_git.rs
index 3937cbeb373..955ea43d63c 100644
--- a/gix-filter/src/worktree/encode_to_git.rs
+++ b/gix-filter/src/worktree/encode_to_git.rs
@@ -7,25 +7,11 @@ pub enum RoundTripCheck {
     Skip,
 }
 
-/// The error returned by [`encode_to_git()][super::encode_to_git()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Cannot convert input of {input_len} bytes to UTF-8 without overflowing")]
-    Overflow { input_len: usize },
-    #[error("The input was malformed and could not be decoded as '{encoding}'")]
-    Malformed { encoding: &'static str },
-    #[error("Encoding from '{src_encoding}' to '{dest_encoding}' and back is not the same")]
-    RoundTrip {
-        src_encoding: &'static str,
-        dest_encoding: &'static str,
-    },
-}
-
 pub(crate) mod function {
     use encoding_rs::DecoderResult;
+    use gix_error::ExnMessageResult;
 
-    use super::{Error, RoundTripCheck};
+    use super::RoundTripCheck;
 
     /// Decode `src` according to `src_encoding` to `UTF-8` for storage in git and place it in `buf`.
     /// Note that the encoding is always applied, there is no conditional even if `src_encoding` already is `UTF-8`.
@@ -34,11 +20,16 @@ pub(crate) mod function {
         src_encoding: &'static encoding_rs::Encoding,
         buf: &mut Vec<u8>,
         round_trip: RoundTripCheck,
-    ) -> Result<(), Error> {
+    ) -> ExnMessageResult {
         let mut decoder = src_encoding.new_decoder_with_bom_removal();
         let buf_len = decoder
             .max_utf8_buffer_length_without_replacement(src.len())
-            .ok_or(Error::Overflow { input_len: src.len() })?;
+            .ok_or_else(|| {
+                gix_error::validation(format!(
+                    "Cannot convert input of {} bytes to UTF-8 without overflowing",
+                    src.len()
+                ))
+            })?;
         buf.clear();
         buf.resize(buf_len, 0);
         let (res, read, written) = decoder.decode_to_utf8_without_replacement(src, buf, true);
@@ -55,9 +46,11 @@ pub(crate) mod function {
                 unreachable!("we assure that the output buffer is big enough as per the encoder's estimate")
             }
             DecoderResult::Malformed(_, _) => {
-                return Err(Error::Malformed {
-                    encoding: src_encoding.name(),
-                });
+                return Err(gix_error::validation(format!(
+                    "The input was malformed and could not be decoded as '{}'",
+                    src_encoding.name()
+                ))
+                .into());
             }
         }
 
@@ -68,10 +61,11 @@ pub(crate) mod function {
                 let str = unsafe { std::str::from_utf8_unchecked(buf) };
                 let (should_equal_src, _actual_encoding, _had_errors) = src_encoding.encode(str);
                 if should_equal_src != src {
-                    return Err(Error::RoundTrip {
-                        src_encoding: src_encoding.name(),
-                        dest_encoding: "UTF-8",
-                    });
+                    return Err(gix_error::validation(format!(
+                        "Encoding from '{}' to 'UTF-8' and back is not the same",
+                        src_encoding.name()
+                    ))
+                    .into());
                 }
             }
             RoundTripCheck::Skip => {}
diff --git a/gix-filter/src/worktree/encode_to_worktree.rs b/gix-filter/src/worktree/encode_to_worktree.rs
index cd5915c44e1..00a626f177b 100644
--- a/gix-filter/src/worktree/encode_to_worktree.rs
+++ b/gix-filter/src/worktree/encode_to_worktree.rs
@@ -1,22 +1,6 @@
-/// The error returned by [`encode_to_worktree()][super::encode_to_worktree()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Cannot convert input of {input_len} UTF-8 bytes to target encoding without overflowing")]
-    Overflow { input_len: usize },
-    #[error("Input was not UTF-8 encoded")]
-    InputAsUtf8(#[from] std::str::Utf8Error),
-    #[error("The character '{character}' could not be mapped to the {worktree_encoding}")]
-    Unmappable {
-        character: char,
-        worktree_encoding: &'static str,
-    },
-}
-
 pub(crate) mod function {
     use encoding_rs::EncoderResult;
-
-    use super::Error;
+    use gix_error::ExnMessageResult;
 
     /// Encode `src_utf8`, which is assumed to be UTF-8 encoded, according to `worktree_encoding` for placement in the working directory,
     /// and write it to `buf`, possibly resizing it.
@@ -25,16 +9,22 @@ pub(crate) mod function {
         src_utf8: &[u8],
         worktree_encoding: &'static encoding_rs::Encoding,
         buf: &mut Vec<u8>,
-    ) -> Result<(), Error> {
+    ) -> ExnMessageResult {
+        use gix_error::{ErrorExt, ResultExt};
+
         let mut encoder = worktree_encoding.new_encoder();
         let buf_len = encoder
             .max_buffer_length_from_utf8_if_no_unmappables(src_utf8.len())
-            .ok_or(Error::Overflow {
-                input_len: src_utf8.len(),
+            .ok_or_else(|| {
+                gix_error::validation(format!(
+                    "Cannot convert input of {} UTF-8 bytes to target encoding without overflowing",
+                    src_utf8.len()
+                ))
+                .raise()
             })?;
         buf.clear();
         buf.resize(buf_len, 0);
-        let src = std::str::from_utf8(src_utf8)?;
+        let src = std::str::from_utf8(src_utf8).or_raise(|| gix_error::validation("Input was not UTF-8 encoded"))?;
         let (res, read, written) = encoder.encode_from_utf8_without_replacement(src, buf, true);
         match res {
             EncoderResult::InputEmpty => {
@@ -49,10 +39,11 @@ pub(crate) mod function {
                 unreachable!("we assure that the output buffer is big enough as per the encoder's estimate")
             }
             EncoderResult::Unmappable(c) => {
-                return Err(Error::Unmappable {
-                    worktree_encoding: worktree_encoding.name(),
-                    character: c,
-                });
+                return Err(gix_error::validation(format!(
+                    "The character '{c}' could not be mapped to the {}",
+                    worktree_encoding.name()
+                ))
+                .raise());
             }
         }
         Ok(())
diff --git a/gix-filter/src/worktree/encoding.rs b/gix-filter/src/worktree/encoding.rs
index ae1dbc2062a..eff776ac178 100644
--- a/gix-filter/src/worktree/encoding.rs
+++ b/gix-filter/src/worktree/encoding.rs
@@ -1,18 +1,6 @@
 use bstr::BStr;
 use encoding_rs::Encoding;
-
-///
-pub mod for_label {
-    use bstr::BString;
-
-    /// The error returned by [for_label()][super::for_label()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An encoding named '{name}' is not known")]
-        Unknown { name: BString },
-    }
-}
+use gix_error::ExnMessageResult;
 
 /// Try to produce a new `Encoding` for `label` or report an error if it is not known.
 ///
@@ -21,11 +9,12 @@ pub mod for_label {
 /// * There is no special handling of UTF-16LE/BE with checks if data contains a BOM or not, like `git` as we don't expect to have
 ///   data available here.
 /// * Special `-BOM` suffixed versions of `UTF-16` encodings are not supported.
-pub fn for_label<'a>(label: impl Into<&'a BStr>) -> Result<&'static Encoding, for_label::Error> {
+pub fn for_label<'a>(label: impl Into<&'a BStr>) -> ExnMessageResult<&'static Encoding> {
     let mut label = label.into();
     if label == "latin-1" {
         label = "ISO-8859-1".into();
     }
-    let enc = Encoding::for_label(label.as_ref()).ok_or_else(|| for_label::Error::Unknown { name: label.into() })?;
+    let enc = Encoding::for_label(label.as_ref())
+        .ok_or_else(|| gix_error::validation(format!("An encoding named '{label}' is not known")))?;
     Ok(enc)
 }
diff --git a/gix-filter/tests/filter/driver.rs b/gix-filter/tests/filter/driver.rs
index cc5ae421bd4..59784029de5 100644
--- a/gix-filter/tests/filter/driver.rs
+++ b/gix-filter/tests/filter/driver.rs
@@ -1,10 +1,11 @@
 use bstr::{BStr, BString};
 
 mod baseline {
+    use crate::Result;
     use crate::driver::driver_path;
 
     #[test]
-    fn our_implementation_used_by_git() -> crate::Result {
+    fn our_implementation_used_by_git() -> Result {
         let exe = driver_path().to_string();
         gix_testtools::scripted_fixture_read_only_with_args_single_archive("baseline.sh", [exe])?;
         Ok(())
@@ -12,6 +13,7 @@ mod baseline {
 }
 
 mod shutdown {
+    use crate::Result;
     use std::time::Duration;
 
     use bstr::ByteVec;
@@ -30,7 +32,7 @@ mod shutdown {
         }
     }
 
-    fn state_with_waiting_process() -> crate::Result<gix_filter::driver::State> {
+    fn state_with_waiting_process() -> Result<gix_filter::driver::State> {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_with_process();
         let client = extract_client(state.maybe_launch_process(&driver, Operation::Clean, "does not matter".into())?);
@@ -45,7 +47,7 @@ mod shutdown {
     }
 
     #[test]
-    fn explicit_shutdown_waits_for_processes() -> crate::Result {
+    fn explicit_shutdown_waits_for_processes() -> Result {
         let mut state = state_with_waiting_process()?;
 
         let start = std::time::Instant::now();
@@ -72,7 +74,7 @@ mod shutdown {
     }
 
     #[test]
-    fn unsuccessful_process_exit_can_be_turned_into_an_error() -> crate::Result {
+    fn unsuccessful_process_exit_can_be_turned_into_an_error() -> Result {
         let mut state = gix_filter::driver::State::default();
         let mut driver = driver_with_process();
         driver
@@ -89,13 +91,17 @@ mod shutdown {
 
         let outcome = state.shutdown(Mode::WaitForProcesses)?;
         assert_eq!(outcome.processes.len(), 1, "we only launch one process");
+        assert!(
+            outcome.processes[0].1.is_some(),
+            "waiting records the process exit status"
+        );
         let err = outcome.into_result().expect_err("the non-zero exit status is an error");
-        assert!(!err.status.success(), "the failed status is retained");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(env!("CARGO_BIN_EXE_gix-filter-test-arrow"), "<filter-driver>"), ("exit code:", "exit status:")]), "the failed command and status are retained", @r#"Filter process "\'<filter-driver>\' process fail-on-shutdown" failed with exit status: 1"#);
         Ok(())
     }
 
     #[test]
-    fn drop_waits_for_processes() -> crate::Result {
+    fn drop_waits_for_processes() -> Result {
         let state = state_with_waiting_process()?;
 
         let start = std::time::Instant::now();
@@ -109,6 +115,7 @@ mod shutdown {
 }
 
 pub(crate) mod apply {
+    use crate::Result;
     use std::{io::Read, sync::LazyLock};
 
     use crate::driver::{driver_path, shutdown::extract_client};
@@ -140,7 +147,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn missing_driver_means_no_filter_is_applied() -> crate::Result {
+    fn missing_driver_means_no_filter_is_applied() -> Result {
         let mut state = gix_filter::driver::State::default();
         let mut driver = driver_no_process();
         driver.smudge = None;
@@ -170,7 +177,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn a_crashing_process_can_restart_it() -> crate::Result {
+    fn a_crashing_process_can_restart_it() -> Result {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_with_process();
         let err = match state.apply(
@@ -182,10 +189,23 @@ pub(crate) mod apply {
             Ok(_) => panic!("expecting an error as invalid context was passed"),
             Err(err) => err,
         };
+        let io_err = err
+            .downcast_any_ref::<std::io::Error>()
+            .expect("the crashing process retains its pipe error");
         assert!(
-            matches!(err, gix_filter::driver::apply::Error::ProcessInvoke { .. }),
-            "{err:?}: cannot invoke if failure is requested"
+            matches!(
+                io_err.kind(),
+                std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::BrokenPipe
+            ),
+            "a process crash closes either pipe depending on when it exits: {io_err}"
         );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&io_err.to_string(), "<closed process pipe>")]), "cannot invoke if failure is requested", @"
+        Failed to invoke 'smudge' command
+        |
+        └─ Failed to read or write to the process
+        |
+        └─ <closed process pipe>
+        ");
 
         let mut filtered = state
             .apply(
@@ -203,7 +223,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn process_status_abort_disables_capability() -> crate::Result {
+    fn process_status_abort_disables_capability() -> Result {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_with_process();
         let client = extract_client(state.maybe_launch_process(&driver, Operation::Clean, "does not matter".into())?);
@@ -213,9 +233,16 @@ pub(crate) mod apply {
                 .invoke("next-smudge-aborts", &mut None.into_iter(), &mut &b""[..])?
                 .is_success()
         );
-        assert!(
-            matches!(state.apply(&driver, &mut std::io::empty(), Operation::Smudge, context_from_path("any")), Err(driver::apply::Error::ProcessStatus {status: driver::process::Status::Named(name), ..}) if name == "abort")
-        );
+        let err = state
+            .apply(
+                &driver,
+                &mut std::io::empty(),
+                Operation::Smudge,
+                context_from_path("any"),
+            )
+            .err()
+            .expect("the process reports its requested abort status");
+        insta::assert_debug_snapshot!(err, "process status abort disables capability", @r#"The invoked command 'smudge' in process indicated an error: Named("abort")"#);
         assert!(
             state
                 .apply(
@@ -231,7 +258,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn process_status_strange_shuts_down_process() -> crate::Result {
+    fn process_status_strange_shuts_down_process() -> Result {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_with_process();
         let client = extract_client(state.maybe_launch_process(&driver, Operation::Clean, "does not matter".into())?);
@@ -245,9 +272,16 @@ pub(crate) mod apply {
                 )?
                 .is_success()
         );
-        assert!(
-            matches!(state.apply(&driver, &mut std::io::empty(), Operation::Smudge, context_from_path("any")), Err(driver::apply::Error::ProcessStatus {status: driver::process::Status::Named(name), ..}) if name == "send-term-signal")
-        );
+        let err = state
+            .apply(
+                &driver,
+                &mut std::io::empty(),
+                Operation::Smudge,
+                context_from_path("any"),
+            )
+            .err()
+            .expect("the process reports its requested failure status");
+        insta::assert_debug_snapshot!(err, "process status strange shuts down process", @r#"The invoked command 'smudge' in process indicated an error: Named("send-term-signal")"#);
         let mut filtered = state
             .apply(&driver, &mut &b"hi\n"[..], Operation::Smudge, context_from_path("any"))?
             .expect("the process won't fail as it got restarted");
@@ -258,7 +292,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn smudge_and_clean_failure_is_translated_to_observable_error_for_required_drivers() -> crate::Result {
+    fn smudge_and_clean_failure_is_translated_to_observable_error_for_required_drivers() -> Result {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_no_process();
         assert!(driver.required);
@@ -273,13 +307,26 @@ pub(crate) mod apply {
             .expect("filter present");
         let mut buf = Vec::new();
         let err = filtered.read_to_end(&mut buf).unwrap_err();
-        assert!(err.to_string().ends_with(" failed"));
+        #[cfg(not(windows))]
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(env!("CARGO_BIN_EXE_gix-filter-test-arrow"), "<filter-driver>")]), "smudge and clean failure is translated to observable error for required drivers", @r#"
+        Custom {
+            kind: Other,
+            error: "Driver process \"/bin/sh\" \"-c\" \"'<filter-driver>' smudge 'do/fail'\" \"sh\" failed",
+        }
+        "#);
+        #[cfg(windows)]
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(env!("CARGO_BIN_EXE_gix-filter-test-arrow"), "<filter-driver>")]), "smudge and clean failure is translated to observable error for required drivers", @r#"
+        Custom {
+            kind: Other,
+            error: "Driver process \"<filter-driver>\" \"smudge\" \"do/fail\" failed",
+        }
+        "#);
 
         Ok(())
     }
 
     #[test]
-    fn smudge_and_clean_failure_falls_back_to_input_if_required_is_false() -> crate::Result {
+    fn smudge_and_clean_failure_falls_back_to_input_if_required_is_false() -> Result {
         let mut state = gix_filter::driver::State::default();
         let mut driver = driver_no_process();
         driver.required = false;
@@ -304,7 +351,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn successful_non_required_driver_can_close_stdin_early() -> crate::Result {
+    fn successful_non_required_driver_can_close_stdin_early() -> Result {
         let mut state = gix_filter::driver::State::default();
         let mut driver = driver_no_process();
         driver.required = false;
@@ -334,7 +381,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn smudge_and_clean_series() -> crate::Result {
+    fn smudge_and_clean_series() -> Result {
         let mut state = gix_filter::driver::State::default();
         for mut driver in [driver_no_process(), driver_with_process()] {
             assert!(
@@ -388,7 +435,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn smudge_and_clean_delayed() -> crate::Result {
+    fn smudge_and_clean_delayed() -> Result {
         let mut state = gix_filter::driver::State::default();
         let driver = driver_with_process();
         let input = "hello\nthere\n";
@@ -457,7 +504,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn large_file_with_cat_filter_does_not_hang() -> crate::Result {
+    fn large_file_with_cat_filter_does_not_hang() -> Result {
         // This test reproduces issue #2080 where using `cat` as a filter with a large file
         // causes a deadlock. The pipe buffer is typically 64KB on Linux, so we use files
         // larger than that to ensure the buffer fills up.
@@ -509,7 +556,7 @@ pub(crate) mod apply {
     }
 
     #[test]
-    fn large_file_with_cat_filter_early_drop() -> crate::Result {
+    fn large_file_with_cat_filter_early_drop() -> Result {
         // Test that dropping the reader early doesn't cause issues (thread cleanup)
         let mut state = gix_filter::driver::State::default();
 
diff --git a/gix-filter/tests/filter/eol/convert_to_git.rs b/gix-filter/tests/filter/eol/convert_to_git.rs
index 466ab322737..00e4dae68ce 100644
--- a/gix-filter/tests/filter/eol/convert_to_git.rs
+++ b/gix-filter/tests/filter/eol/convert_to_git.rs
@@ -1,5 +1,8 @@
+use crate::Result;
 use std::path::Path;
 
+use gix_error::ExnResult;
+
 use bstr::{ByteSlice, ByteVec};
 use gix_filter::{eol, eol::AttributesDigest};
 
@@ -18,7 +21,7 @@ fn with_binary_attribute_is_never_converted() {
 }
 
 #[test]
-fn no_crlf_means_no_work() -> crate::Result {
+fn no_crlf_means_no_work() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_git(
         b"hi",
@@ -43,7 +46,7 @@ fn no_crlf_means_no_work() -> crate::Result {
 }
 
 #[test]
-fn detected_as_binary() -> crate::Result {
+fn detected_as_binary() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_git(
         b"hi\0zero makes it binary",
@@ -61,7 +64,7 @@ fn detected_as_binary() -> crate::Result {
 }
 
 #[test]
-fn trailing_dos_eof_marker_is_not_detected_as_binary() -> crate::Result {
+fn trailing_dos_eof_marker_is_not_detected_as_binary() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_git(
         b"a\r\nb\r\n\x1a",
@@ -87,7 +90,7 @@ fn trailing_dos_eof_marker_is_not_detected_as_binary() -> crate::Result {
 }
 
 #[test]
-fn fast_conversion_by_stripping_cr() -> crate::Result {
+fn fast_conversion_by_stripping_cr() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_git(
         b"a\r\nb\r\nc",
@@ -103,7 +106,7 @@ fn fast_conversion_by_stripping_cr() -> crate::Result {
 }
 
 #[test]
-fn slower_conversion_due_to_lone_cr() -> crate::Result {
+fn slower_conversion_due_to_lone_cr() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_git(
         b"\r\ra\r\nb\r\nc",
@@ -123,7 +126,7 @@ fn slower_conversion_due_to_lone_cr() -> crate::Result {
 }
 
 #[test]
-fn crlf_in_index_prevents_conversion_to_lf() -> crate::Result {
+fn crlf_in_index_prevents_conversion_to_lf() -> Result {
     let mut buf = Vec::new();
     let mut called = false;
     let changed = eol::convert_to_git(
@@ -148,12 +151,13 @@ fn crlf_in_index_prevents_conversion_to_lf() -> crate::Result {
 }
 
 #[test]
-fn round_trip_check() -> crate::Result {
+fn round_trip_check() -> Result {
+    let mut error_snapshots = Vec::new();
     let mut buf = Vec::new();
-    for (input, expected) in [
-        (&b"lone-nl\nhi\r\nho"[..], "LF would be replaced by CRLF in 'hello.txt'"),
+    for input in [
+        &b"lone-nl\nhi\r\nho"[..],
         // despite trying, I was unable to get into the other branch
-        (b"lone-cr\nhi\r\nho", "LF would be replaced by CRLF in 'hello.txt'"),
+        b"lone-cr\nhi\r\nho",
     ] {
         let err = eol::convert_to_git(
             input,
@@ -168,7 +172,7 @@ fn round_trip_check() -> crate::Result {
             },
         )
         .unwrap_err();
-        assert_eq!(err.to_string(), expected);
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
 
         let changed = eol::convert_to_git(
             input,
@@ -187,13 +191,19 @@ fn round_trip_check() -> crate::Result {
             "in warn mode, we will get a result even though it won't round-trip"
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "round trip check", @"
+    [
+        LF would be replaced by CRLF in 'hello.txt',
+        LF would be replaced by CRLF in 'hello.txt',
+    ]
+    ");
     Ok(())
 }
 
-fn no_call(_buf: &mut Vec<u8>) -> Result<Option<()>, Box<dyn std::error::Error + Send + Sync>> {
+fn no_call(_buf: &mut Vec<u8>) -> ExnResult<Option<()>> {
     unreachable!("index function will not be called")
 }
 
-fn no_object_in_index(_buf: &mut Vec<u8>) -> Result<Option<()>, Box<dyn std::error::Error + Send + Sync>> {
+fn no_object_in_index(_buf: &mut Vec<u8>) -> ExnResult<Option<()>> {
     Ok(None)
 }
diff --git a/gix-filter/tests/filter/eol/convert_to_worktree.rs b/gix-filter/tests/filter/eol/convert_to_worktree.rs
index c3cb9428430..1a6cd270886 100644
--- a/gix-filter/tests/filter/eol/convert_to_worktree.rs
+++ b/gix-filter/tests/filter/eol/convert_to_worktree.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_filter::{
     eol,
@@ -5,7 +6,7 @@ use gix_filter::{
 };
 
 #[test]
-fn no_conversion_if_attribute_digest_does_not_allow_it() -> crate::Result {
+fn no_conversion_if_attribute_digest_does_not_allow_it() -> Result {
     let mut buf = Vec::new();
     for digest in [
         AttributesDigest::Binary,
@@ -19,7 +20,7 @@ fn no_conversion_if_attribute_digest_does_not_allow_it() -> crate::Result {
 }
 
 #[test]
-fn no_conversion_if_configuration_does_not_allow_it() -> crate::Result {
+fn no_conversion_if_configuration_does_not_allow_it() -> Result {
     let mut buf = Vec::new();
     for digest in [AttributesDigest::Text, AttributesDigest::TextAuto] {
         for config in [
@@ -40,7 +41,7 @@ fn no_conversion_if_configuration_does_not_allow_it() -> crate::Result {
 }
 
 #[test]
-fn no_conversion_if_nothing_to_do() -> crate::Result {
+fn no_conversion_if_nothing_to_do() -> Result {
     let mut buf = Vec::new();
     for (input, digest, msg) in [
         (
@@ -71,7 +72,7 @@ fn no_conversion_if_nothing_to_do() -> crate::Result {
 }
 
 #[test]
-fn each_nl_is_replaced_with_crnl() -> crate::Result {
+fn each_nl_is_replaced_with_crnl() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_worktree(
         b"hi\n\nho\nend",
@@ -88,7 +89,7 @@ fn each_nl_is_replaced_with_crnl() -> crate::Result {
 }
 
 #[test]
-fn trailing_dos_eof_marker_is_not_detected_as_binary() -> crate::Result {
+fn trailing_dos_eof_marker_is_not_detected_as_binary() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_worktree(
         b"a\nb\n\x1a",
@@ -110,7 +111,7 @@ fn trailing_dos_eof_marker_is_not_detected_as_binary() -> crate::Result {
 }
 
 #[test]
-fn existing_crnl_are_not_replaced_for_safety_nor_are_lone_cr() -> crate::Result {
+fn existing_crnl_are_not_replaced_for_safety_nor_are_lone_cr() -> Result {
     let mut buf = Vec::new();
     let changed = eol::convert_to_worktree(
         b"hi\r\n\nho\r\nend\r",
diff --git a/gix-filter/tests/filter/ident.rs b/gix-filter/tests/filter/ident.rs
index ae0bbd60c97..575a52c6447 100644
--- a/gix-filter/tests/filter/ident.rs
+++ b/gix-filter/tests/filter/ident.rs
@@ -1,8 +1,9 @@
 mod undo {
+    use crate::Result;
     use bstr::{B, ByteSlice};
 
     #[test]
-    fn no_id_changes_nothing() -> crate::Result {
+    fn no_id_changes_nothing() -> Result {
         let mut buf = Vec::new();
         let changed = gix_filter::ident::undo(B("hello"), &mut buf)?;
         assert!(!changed, "the buffer is not touched");
@@ -11,7 +12,7 @@ mod undo {
     }
 
     #[test]
-    fn empty() -> crate::Result {
+    fn empty() -> Result {
         let mut buf = Vec::new();
         assert!(
             !gix_filter::ident::undo(B(""), &mut buf)?,
@@ -21,7 +22,7 @@ mod undo {
     }
 
     #[test]
-    fn nothing_if_newline_between_dollars() -> crate::Result {
+    fn nothing_if_newline_between_dollars() -> Result {
         let mut buf = Vec::new();
         assert!(!gix_filter::ident::undo(B(" $Id: \n$"), &mut buf)?);
         assert_eq!(buf.len(), 0);
@@ -29,7 +30,7 @@ mod undo {
     }
 
     #[test]
-    fn nothing_if_it_is_not_id() -> crate::Result {
+    fn nothing_if_it_is_not_id() -> Result {
         let mut buf = Vec::new();
         assert!(
             !gix_filter::ident::undo(B(" $id: something$"), &mut buf)?,
@@ -40,7 +41,7 @@ mod undo {
     }
 
     #[test]
-    fn anything_between_dollar_id_dollar() -> crate::Result {
+    fn anything_between_dollar_id_dollar() -> Result {
         let mut buf = Vec::new();
         assert!(gix_filter::ident::undo(B(" $Id: something$\nhello"), &mut buf)?);
         assert_eq!(buf.as_bstr(), " $Id$\nhello");
@@ -48,7 +49,7 @@ mod undo {
     }
 
     #[test]
-    fn multiple() -> crate::Result {
+    fn multiple() -> Result {
         let mut buf = Vec::new();
         assert!(gix_filter::ident::undo(
             B("$Id: a\n$ $Id: something$\nhello$Id: hex$\nlast $Id:other$\n$Id: \n$"),
@@ -66,11 +67,12 @@ mod undo {
 }
 
 mod apply {
+    use crate::Result;
     use bstr::{B, ByteSlice};
     use gix_filter::ident;
 
     #[test]
-    fn no_change() -> crate::Result {
+    fn no_change() -> Result {
         let mut buf = Vec::new();
         for input_no_match in [
             "",
@@ -86,7 +88,7 @@ mod apply {
     }
 
     #[test]
-    fn simple() -> crate::Result {
+    fn simple() -> Result {
         let mut buf = Vec::new();
         assert!(
             ident::apply(B("$Id$"), gix_testtools::object_hash(), &mut buf)?,
@@ -117,7 +119,7 @@ mod apply {
     }
 
     #[test]
-    fn round_trips() -> crate::Result {
+    fn round_trips() -> Result {
         let mut buf = Vec::new();
         for input in [
             "hi\n$Id$\nho\n\t$Id$$Id$$Id$",
diff --git a/gix-filter/tests/filter/pipeline/convert_to_git.rs b/gix-filter/tests/filter/pipeline/convert_to_git.rs
index e9ec68b42f7..220eb2ecd59 100644
--- a/gix-filter/tests/filter/pipeline/convert_to_git.rs
+++ b/gix-filter/tests/filter/pipeline/convert_to_git.rs
@@ -1,5 +1,7 @@
 use std::{io::Read, path::Path};
 
+use gix_error::ExnResult;
+
 use bstr::ByteSlice;
 use gix_filter::{eol, pipeline::CrlfRoundTripCheck};
 
@@ -145,10 +147,10 @@ fn no_filter_means_reader_is_returned_unchanged() -> gix_testtools::Result {
     Ok(())
 }
 
-fn no_call(_buf: &mut Vec<u8>) -> Result<Option<()>, Box<dyn std::error::Error + Send + Sync>> {
+fn no_call(_buf: &mut Vec<u8>) -> ExnResult<Option<()>> {
     unreachable!("index function will not be called")
 }
 
-fn no_object_in_index(_buf: &mut Vec<u8>) -> Result<Option<()>, Box<dyn std::error::Error + Send + Sync>> {
+fn no_object_in_index(_buf: &mut Vec<u8>) -> ExnResult<Option<()>> {
     Ok(None)
 }
diff --git a/gix-filter/tests/filter/pipeline/convert_to_worktree.rs b/gix-filter/tests/filter/pipeline/convert_to_worktree.rs
index 38940492dfe..ed6168ca9f9 100644
--- a/gix-filter/tests/filter/pipeline/convert_to_worktree.rs
+++ b/gix-filter/tests/filter/pipeline/convert_to_worktree.rs
@@ -194,10 +194,7 @@ fn encoding_failure_can_be_an_error() -> gix_testtools::Result {
         )
         .err()
         .expect("unrepresentable characters can be rejected explicitly");
-    assert_eq!(
-        err.to_string(),
-        "The character '😀' could not be mapped to the windows-1252"
-    );
+    insta::assert_debug_snapshot!(err, "encoding failure can be an error", @"The character '😀' could not be mapped to the windows-1252");
     Ok(())
 }
 
@@ -224,6 +221,7 @@ fn unknown_encoding_can_be_an_error() -> gix_testtools::Result {
         )
         .err()
         .expect("unknown encodings can be rejected explicitly");
-    assert_eq!(err.to_string(), "The encoding named 'not-an-encoding' isn't available");
+    insta::assert_debug_snapshot!(err, "unknown encoding can be an error", @"The encoding named 'not-an-encoding' isn't available");
+    assert!(err.is_validation(), "unknown encodings are validation failures");
     Ok(())
 }
diff --git a/gix-filter/tests/filter/pipeline/mod.rs b/gix-filter/tests/filter/pipeline/mod.rs
index 290ad466638..cdd0c093dc5 100644
--- a/gix-filter/tests/filter/pipeline/mod.rs
+++ b/gix-filter/tests/filter/pipeline/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_attributes::glob::pattern::Case;
 use gix_filter::{eol, pipeline::convert::to_worktree};
@@ -6,7 +7,7 @@ mod convert_to_git;
 mod convert_to_worktree;
 
 #[test]
-fn default() -> crate::Result {
+fn default() -> Result {
     let mut filters = gix_filter::Pipeline::default();
     let out = filters.convert_to_worktree(
         b"hi",
diff --git a/gix-filter/tests/filter/worktree.rs b/gix-filter/tests/filter/worktree.rs
index 99762087319..d1112a71323 100644
--- a/gix-filter/tests/filter/worktree.rs
+++ b/gix-filter/tests/filter/worktree.rs
@@ -4,23 +4,27 @@ mod encoding {
 
         #[test]
         fn unknown() {
-            assert_eq!(
-                worktree::encoding::for_label("FOO").unwrap_err().to_string(),
-                "An encoding named 'FOO' is not known"
-            );
+            insta::assert_debug_snapshot!(worktree::encoding::for_label("FOO").expect_err("unknown"), "unknown", @"An encoding named 'FOO' is not known");
         }
 
         #[test]
         fn utf32_is_not_supported() {
+            let mut message_diagnostics = Vec::new();
             for enc in ["UTF-32BE", "UTF-32LE", "UTF-32", "UTF-32LE-BOM", "UTF-32BE-BOM"] {
-                assert!(
-                    matches!(
-                        worktree::encoding::for_label(enc).unwrap_err(),
-                        worktree::encoding::for_label::Error::Unknown { .. }
-                    ),
-                    "it's not needed for the web and this crate is meant for use in firefox"
-                );
+                message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                    &(worktree::encoding::for_label(enc).expect_err("the input must be rejected")),
+                    &[],
+                ));
             }
+            insta::assert_debug_snapshot!(message_diagnostics, "utf32 is not supported", @"
+            [
+                An encoding named 'UTF-32BE' is not known,
+                An encoding named 'UTF-32LE' is not known,
+                An encoding named 'UTF-32' is not known,
+                An encoding named 'UTF-32LE-BOM' is not known,
+                An encoding named 'UTF-32BE-BOM' is not known,
+            ]
+            ");
         }
 
         #[test]
@@ -41,15 +45,19 @@ mod encoding {
 
         #[test]
         fn various_utf_16_with_bom_suffix_are_unsupported() {
+            let mut message_diagnostics = Vec::new();
             for label in ["UTF-16BE-BOM", "UTF-16LE-BOM"] {
-                assert!(
-                    matches!(
-                        worktree::encoding::for_label(label).unwrap_err(),
-                        worktree::encoding::for_label::Error::Unknown { .. }
-                    ),
-                    "git supports these and has special handling, but we have not for now. Git has no tests for that either."
-                );
+                message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                    &(worktree::encoding::for_label(label).expect_err("the input must be rejected")),
+                    &[],
+                ));
             }
+            insta::assert_debug_snapshot!(message_diagnostics, "various utf 16 with bom suffix are unsupported", @"
+            [
+                An encoding named 'UTF-16BE-BOM' is not known,
+                An encoding named 'UTF-16LE-BOM' is not known,
+            ]
+            ");
         }
 
         #[test]
@@ -65,11 +73,12 @@ mod encoding {
 }
 
 mod encode_to_git {
+    use crate::Result;
     use bstr::ByteSlice;
     use gix_filter::{worktree, worktree::encode_to_git::RoundTripCheck};
 
     #[test]
-    fn simple() -> crate::Result {
+    fn simple() -> Result {
         let input = &b"hello"[..];
         for round_trip in [RoundTripCheck::Skip, RoundTripCheck::Fail] {
             let mut buf = Vec::new();
@@ -81,11 +90,12 @@ mod encode_to_git {
 }
 
 mod encode_to_worktree {
+    use crate::Result;
     use bstr::ByteSlice;
     use gix_filter::{worktree, worktree::encode_to_git::RoundTripCheck};
 
     #[test]
-    fn shift_jis() -> crate::Result {
+    fn shift_jis() -> Result {
         let input = "ハローワールド";
         let mut buf = Vec::new();
         worktree::encode_to_worktree(input.as_bytes(), encoding_rs::SHIFT_JIS, &mut buf)?;
diff --git a/gix-filter/tests/helpers/arrow.rs b/gix-filter/tests/helpers/arrow.rs
index 37522e9c45c..3feab639df3 100644
--- a/gix-filter/tests/helpers/arrow.rs
+++ b/gix-filter/tests/helpers/arrow.rs
@@ -9,7 +9,7 @@ use gix_filter::driver::process;
 /// Visible marker used to demonstrate clean/smudge round trips in filter-driver tests.
 static PREFIX: &str = "➡";
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let mut args = std::env::args();
     let sub_command = args.nth(1).ok_or("Need sub-command")?;
     let next_arg = args.next(); // possibly %f
@@ -22,6 +22,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         "process" => {
             let disallow_delay = next_arg.as_deref() == Some("disallow-delay");
             let fail_on_shutdown = next_arg.as_deref() == Some("fail-on-shutdown");
+            let forget_delayed = next_arg.as_deref() == Some("forget-delayed");
             let mut srv = gix_filter::driver::process::Server::handshake(
                 stdin(),
                 stdout(),
@@ -145,7 +146,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             let mut out = request.as_write();
                             let mut last_cmd = None;
                             let mut buf = Vec::<u8>::new();
-                            for (cmd, path, _) in &delayed {
+                            for (cmd, path, _) in delayed.iter().skip(usize::from(forget_delayed)) {
                                 if last_cmd.get_or_insert(*cmd) != cmd {
                                     panic!("the API doesn't support mixing cmds as paths might not be unique anymore")
                                 }
diff --git a/gix-fs/Cargo.toml b/gix-fs/Cargo.toml
index 6ba74f30ec5..9b7f4125f97 100644
--- a/gix-fs/Cargo.toml
+++ b/gix-fs/Cargo.toml
@@ -27,6 +27,8 @@ gix-error = { version = "^0.3.0", path = "../gix-error" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
 crossbeam-channel = "0.5.15"
 is_ci = "1.1.1"
 tempfile = "3.26.0"
diff --git a/gix-fs/src/lib.rs b/gix-fs/src/lib.rs
index fb03491dd72..cf166784088 100644
--- a/gix-fs/src/lib.rs
+++ b/gix-fs/src/lib.rs
@@ -13,7 +13,8 @@
 //!
 //! let components = "src/lib.rs"
 //!     .to_normal_path_components()
-//!     .collect::<Result<Vec<_>, _>>()?;
+//!     .collect::<Result<Vec<_>, _>>()
+//!     .map_err(|err| err.into_error())?;
 //! assert_eq!(
 //!     components
 //!         .into_iter()
diff --git a/gix-fs/src/stack.rs b/gix-fs/src/stack.rs
index b84096d6333..15ec1a9407c 100644
--- a/gix-fs/src/stack.rs
+++ b/gix-fs/src/stack.rs
@@ -4,71 +4,63 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnMessageResult, validation};
 
 use crate::Stack;
 
-///
-pub mod to_normal_path_components {
-    /// The error used in [`ToNormalPathComponents::to_normal_path_components()`](super::ToNormalPathComponents::to_normal_path_components()).
-    pub type Error = gix_error::ValidationError;
-}
-
 /// Obtain an iterator over `OsStr`-components which are normal, none-relative and not absolute.
 pub trait ToNormalPathComponents {
     /// Return an iterator over the normal components of a path, without the separator.
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>>;
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>>;
 }
 
 impl ToNormalPathComponents for &Path {
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
-        self.components().map(|c| component_to_os_str(c, self))
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>> {
+        self.components().map(|c| component_to_os_str(c, self.display()))
     }
 }
 
 impl ToNormalPathComponents for PathBuf {
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
-        self.components().map(|c| component_to_os_str(c, self))
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>> {
+        self.components().map(|c| component_to_os_str(c, self.display()))
     }
 }
 
-fn component_to_os_str<'a>(
-    component: Component<'a>,
-    path_with_component: &Path,
-) -> Result<&'a OsStr, to_normal_path_components::Error> {
+fn component_to_os_str(
+    component: Component<'_>,
+    path_with_component: impl std::fmt::Display,
+) -> ExnMessageResult<&OsStr> {
     match component {
         Component::Normal(os_str) => Ok(os_str),
-        _ => Err(to_normal_path_components::Error::new(format!(
-            "Input path \"{}\" contains relative or absolute components",
-            path_with_component.display()
-        ))),
+        _ => Err(validation(format!(
+            "Input path \"{path_with_component}\" contains relative or absolute components"
+        ))
+        .raise()),
     }
 }
 
 impl ToNormalPathComponents for &BStr {
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>> {
         self.split(|b| *b == b'/')
             .filter_map(|c| bytes_component_to_os_str(c, self))
     }
 }
 
 impl ToNormalPathComponents for &str {
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>> {
         self.split('/')
             .filter_map(|c| bytes_component_to_os_str(c.as_bytes(), (*self).into()))
     }
 }
 
 impl ToNormalPathComponents for &BString {
-    fn to_normal_path_components(&self) -> impl Iterator<Item = Result<&OsStr, to_normal_path_components::Error>> {
+    fn to_normal_path_components(&self) -> impl Iterator<Item = ExnMessageResult<&OsStr>> {
         self.split(|b| *b == b'/')
             .filter_map(|c| bytes_component_to_os_str(c, self.as_bstr()))
     }
 }
 
-fn bytes_component_to_os_str<'a>(
-    component: &'a [u8],
-    path: &BStr,
-) -> Option<Result<&'a OsStr, to_normal_path_components::Error>> {
+fn bytes_component_to_os_str<'a>(component: &'a [u8], path: &BStr) -> Option<ExnMessageResult<&'a OsStr>> {
     if component.is_empty() {
         return None;
     }
@@ -77,10 +69,7 @@ fn bytes_component_to_os_str<'a>(
         Err(err) => return Some(Err(err)),
     };
     let component = component.components().next()?;
-    Some(component_to_os_str(
-        component,
-        gix_path::try_from_byte_slice(path.as_ref()).ok()?,
-    ))
+    Some(component_to_os_str(component, path))
 }
 
 /// Access
@@ -171,7 +160,10 @@ impl Stack {
                         break;
                     }
                 }
-                Err(err) => return Err(std::io::Error::other(format!("{err}"))),
+                Err(_) => {
+                    let err = components.next().expect("just peeked").expect_err("peeked an error");
+                    return Err(std::io::Error::other(err.into_error()));
+                }
             }
         }
 
@@ -205,7 +197,7 @@ impl Stack {
         }
 
         while let Some(comp) = components.next() {
-            let comp = comp.map_err(std::io::Error::other)?;
+            let comp = comp.map_err(|err| std::io::Error::other(err.into_error()))?;
             let is_last_component = components.peek().is_none();
             let parent_is_directory = self.current_is_directory;
             self.current_is_directory = !is_last_component;
diff --git a/gix-fs/tests/fs/dir/create.rs b/gix-fs/tests/fs/dir/create.rs
index da029d2b9b0..e664729e5e6 100644
--- a/gix-fs/tests/fs/dir/create.rs
+++ b/gix-fs/tests/fs/dir/create.rs
@@ -1,8 +1,9 @@
 mod all {
+    use crate::Result;
     use gix_fs::dir::create;
 
     #[test]
-    fn a_deeply_nested_directory() -> crate::Result {
+    fn a_deeply_nested_directory() -> Result {
         let dir = tempfile::tempdir()?;
         let target = &dir.path().join("1").join("2").join("3").join("4").join("5").join("6");
         let dir = create::all(target, Default::default())?;
@@ -11,6 +12,7 @@ mod all {
     }
 }
 mod iter {
+    use crate::Result;
     pub use std::io::ErrorKind::*;
 
     use gix_fs::dir::{
@@ -19,7 +21,7 @@ mod iter {
     };
 
     #[test]
-    fn an_existing_directory_causes_immediate_success() -> crate::Result {
+    fn an_existing_directory_causes_immediate_success() -> Result {
         let dir = tempfile::tempdir()?;
         let mut it = create::Iter::new(dir.path());
         assert_eq!(
@@ -32,7 +34,7 @@ mod iter {
     }
 
     #[test]
-    fn a_single_directory_can_be_created_too() -> crate::Result {
+    fn a_single_directory_can_be_created_too() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("new");
         let mut it = create::Iter::new(&new_dir);
@@ -47,16 +49,36 @@ mod iter {
     }
 
     #[test]
-    fn multiple_intermediate_directories_are_created_automatically() -> crate::Result {
+    fn multiple_intermediate_directories_are_created_automatically() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("s1").join("s2").join("new");
         let mut it = create::Iter::new(&new_dir);
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "dir is not present", @r#"
+        Intermediate {
+            dir: "<target>",
+            kind: NotFound,
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Intermediate{dir, kind: k})) if k == NotFound && dir == new_dir),
+            matches!(failure, Intermediate{dir, kind: k} if k == NotFound && dir == new_dir),
             "dir is not present"
         );
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "parent dir is not present", @r#"
+        Intermediate {
+            dir: "<parent>",
+            kind: NotFound,
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Intermediate{dir, kind:k})) if k == NotFound && dir == new_dir.parent().unwrap()),
+            matches!(failure, Intermediate{dir, kind:k} if k == NotFound && dir == new_dir.parent().unwrap()),
             "parent dir is not present"
         );
         assert_eq!(
@@ -80,7 +102,7 @@ mod iter {
     }
 
     #[test]
-    fn multiple_intermediate_directories_are_created_up_to_retries_limit() -> crate::Result {
+    fn multiple_intermediate_directories_are_created_up_to_retries_limit() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("s1").join("s2").join("new");
         let mut it = create::Iter::new_with_retries(
@@ -90,8 +112,30 @@ mod iter {
                 ..Default::default()
             },
         );
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "parent dir is not present and we run out of attempts", @r#"
+        Permanent {
+            dir: "<target>",
+            err: Kind(
+                NotFound,
+            ),
+            retries_left: Retries {
+                to_create_entire_directory: 5,
+                on_create_directory_failure: 0,
+                on_interrupt: 10,
+            },
+            retries: Retries {
+                to_create_entire_directory: 5,
+                on_create_directory_failure: 1,
+                on_interrupt: 10,
+            },
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Permanent{ retries_left, dir, err, ..})) if retries_left.on_create_directory_failure == 0
+            matches!(failure, Permanent{ retries_left, dir, err, ..} if retries_left.on_create_directory_failure == 0
                                                                     && err.kind() == NotFound
                                                                     && dir == new_dir),
             "parent dir is not present and we run out of attempts"
@@ -102,15 +146,38 @@ mod iter {
     }
 
     #[test]
-    fn an_existing_file_makes_directory_creation_fail_permanently() -> crate::Result {
+    fn an_existing_file_makes_directory_creation_fail_permanently() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("also-file");
         std::fs::write(&new_dir, [42])?;
         assert!(new_dir.is_file());
 
         let mut it = create::Iter::new(&new_dir);
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "a non-directory in the path is reported precisely as NotADirectory", @r#"
+        Permanent {
+            dir: "<target>",
+            err: Custom {
+                kind: NotADirectory,
+                error: AlreadyExists,
+            },
+            retries_left: Retries {
+                to_create_entire_directory: 5,
+                on_create_directory_failure: 25,
+                on_interrupt: 10,
+            },
+            retries: Retries {
+                to_create_entire_directory: 5,
+                on_create_directory_failure: 25,
+                on_interrupt: 10,
+            },
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Permanent{ dir, err, .. })) if err.kind() == NotADirectory
+            matches!(failure, Permanent{ dir, err, .. } if err.kind() == NotADirectory
                                                                     && dir == new_dir),
             "a non-directory in the path is reported precisely as NotADirectory"
         );
@@ -119,7 +186,7 @@ mod iter {
         Ok(())
     }
     #[test]
-    fn racy_directory_creation_with_new_directory_being_deleted_not_enough_retries() -> crate::Result {
+    fn racy_directory_creation_with_new_directory_being_deleted_not_enough_retries() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("a").join("new");
         let parent_dir = new_dir.parent().unwrap();
@@ -146,8 +213,30 @@ mod iter {
         // Someone deletes the new directory, again
         std::fs::remove_dir(parent_dir)?;
 
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "we run out of attempts to retry to combat against raciness", @r#"
+        Permanent {
+            dir: "<target>",
+            err: Kind(
+                NotFound,
+            ),
+            retries_left: Retries {
+                to_create_entire_directory: 0,
+                on_create_directory_failure: 1,
+                on_interrupt: 10,
+            },
+            retries: Retries {
+                to_create_entire_directory: 2,
+                on_create_directory_failure: 2,
+                on_interrupt: 10,
+            },
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Permanent{ retries_left, dir, err, .. })) if retries_left.to_create_entire_directory == 0
+            matches!(failure, Permanent{ retries_left, dir, err, .. } if retries_left.to_create_entire_directory == 0
                                                                     && retries_left.on_create_directory_failure == 1
                                                                     && err.kind() == NotFound
                                                                     && dir == new_dir),
@@ -157,14 +246,24 @@ mod iter {
     }
 
     #[test]
-    fn racy_directory_creation_with_new_directory_being_deleted() -> crate::Result {
+    fn racy_directory_creation_with_new_directory_being_deleted() -> Result {
         let dir = tempfile::tempdir()?;
         let new_dir = dir.path().join("a").join("new");
         let parent_dir = new_dir.parent().unwrap();
         let mut it = create::Iter::new(&new_dir);
 
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "dir is not present, and we go up a level", @r#"
+        Intermediate {
+            dir: "<target>",
+            kind: NotFound,
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Intermediate{dir, kind:k})) if k == NotFound && dir == new_dir),
+            matches!(failure, Intermediate{dir, kind:k} if k == NotFound && dir == new_dir),
             "dir is not present, and we go up a level"
         );
         assert!(
@@ -174,8 +273,18 @@ mod iter {
         // Someone deletes the new directory
         std::fs::remove_dir(parent_dir)?;
 
+        let failure = it
+            .next()
+            .expect("the iterator reports its next creation attempt")
+            .expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&new_dir.to_string_lossy(), "<target>"), (&new_dir.parent().expect("target has a parent").to_string_lossy(), "<parent>")]), "now when it tries the actual dir its not found", @r#"
+        Intermediate {
+            dir: "<target>",
+            kind: NotFound,
+        }
+        "#);
         assert!(
-            matches!(it.next(), Some(Err(Intermediate{dir, kind:k})) if k == NotFound && dir == new_dir),
+            matches!(failure, Intermediate{dir, kind:k} if k == NotFound && dir == new_dir),
             "now when it tries the actual dir its not found"
         );
         assert!(
diff --git a/gix-fs/tests/fs/dir/remove.rs b/gix-fs/tests/fs/dir/remove.rs
index 079cf68342e..88c1f5cf055 100644
--- a/gix-fs/tests/fs/dir/remove.rs
+++ b/gix-fs/tests/fs/dir/remove.rs
@@ -1,22 +1,32 @@
 mod empty_upwards_until_boundary {
+    use crate::Result;
     use std::{io, path::Path};
 
     use gix_fs::dir::remove;
 
     #[test]
-    fn boundary_must_contain_target_dir() -> crate::Result {
+    fn boundary_must_contain_target_dir() -> Result {
         let dir = tempfile::tempdir()?;
         let (target, boundary) = (dir.path().join("a"), dir.path().join("b"));
         std::fs::create_dir(&target)?;
         std::fs::create_dir(&boundary)?;
-        assert!(matches!(remove::empty_upward_until_boundary(&target, &boundary),
-                            Err(err) if err.kind() == io::ErrorKind::InvalidInput));
+        let failure = remove::empty_upward_until_boundary(&target, &boundary).expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&target.to_string_lossy(), "<target>"), (&boundary.to_string_lossy(), "<boundary>")]), "boundary must contain target dir", @r#"
+        Custom {
+            kind: InvalidInput,
+            error: "Removal target '<target>' must be contained in boundary '<boundary>'",
+        }
+        "#);
+        assert!(
+            matches!(failure, err if err.kind() == io::ErrorKind::InvalidInput),
+            "boundary must contain target dir"
+        );
         assert!(target.is_dir());
         assert!(boundary.is_dir());
         Ok(())
     }
     #[test]
-    fn target_directory_non_existing_causes_existing_parents_not_to_be_deleted() -> crate::Result {
+    fn target_directory_non_existing_causes_existing_parents_not_to_be_deleted() -> Result {
         let dir = tempfile::tempdir()?;
         let parent = dir.path().join("a");
         std::fs::create_dir(&parent)?;
@@ -30,7 +40,7 @@ mod empty_upwards_until_boundary {
     }
 
     #[test]
-    fn target_directory_being_a_file_immediately_fails() -> crate::Result {
+    fn target_directory_being_a_file_immediately_fails() -> Result {
         let dir = tempfile::tempdir()?;
         let target = dir.path().join("actually-a-file");
         std::fs::write(&target, [42])?;
@@ -40,14 +50,14 @@ mod empty_upwards_until_boundary {
         Ok(())
     }
     #[test]
-    fn boundary_being_the_target_dir_always_succeeds_and_we_do_nothing() -> crate::Result {
+    fn boundary_being_the_target_dir_always_succeeds_and_we_do_nothing() -> Result {
         let dir = tempfile::tempdir()?;
         assert_eq!(remove::empty_upward_until_boundary(dir.path(), dir.path())?, dir.path());
         assert!(dir.path().is_dir(), "it won't touch the boundary");
         Ok(())
     }
     #[test]
-    fn a_directory_which_doesnt_exist_to_start_with_is_ok() -> crate::Result {
+    fn a_directory_which_doesnt_exist_to_start_with_is_ok() -> Result {
         let dir = tempfile::tempdir()?;
         let target = dir.path().join("does-not-exist");
         assert_eq!(remove::empty_upward_until_boundary(&target, dir.path())?, target);
@@ -55,14 +65,14 @@ mod empty_upwards_until_boundary {
         Ok(())
     }
     #[test]
-    fn boundary_directory_doesnt_have_to_exist_either_if_the_target_doesnt() -> crate::Result {
+    fn boundary_directory_doesnt_have_to_exist_either_if_the_target_doesnt() -> Result {
         let boundary = Path::new("/boundary");
         let target = Path::new("/boundary/target");
         assert_eq!(remove::empty_upward_until_boundary(target, boundary)?, target);
         Ok(())
     }
     #[test]
-    fn nested_directory_deletion_works() -> crate::Result {
+    fn nested_directory_deletion_works() -> Result {
         let dir = tempfile::tempdir()?;
         let nested = dir.path().join("a").join("b").join("to-delete");
         std::fs::create_dir_all(&nested)?;
@@ -79,13 +89,14 @@ mod empty_upwards_until_boundary {
 }
 
 mod empty_depth_first {
+    use crate::Result;
     use std::{
         fs::{create_dir, create_dir_all},
         path::Path,
     };
 
     #[test]
-    fn non_empty_anywhere_and_deletion_fails() -> crate::Result {
+    fn non_empty_anywhere_and_deletion_fails() -> Result {
         let dir = tempfile::TempDir::new()?;
         let touch = |base: &Path, name: &str| create_dir_all(base).and_then(|_| std::fs::write(base.join(name), b""));
 
@@ -123,10 +134,11 @@ mod empty_depth_first {
 /// We assume that all checks above also apply to the iterator, so won't repeat them here
 /// Test outside interference only
 mod iter {
+    use crate::Result;
     use gix_fs::dir::remove;
 
     #[test]
-    fn racy_directory_creation_during_deletion_always_wins_immediately() -> crate::Result {
+    fn racy_directory_creation_during_deletion_always_wins_immediately() -> Result {
         let dir = tempfile::tempdir()?;
         let nested = dir.path().join("a").join("b").join("to-delete");
         std::fs::create_dir_all(&nested)?;
diff --git a/gix-fs/tests/fs/read_dir.rs b/gix-fs/tests/fs/read_dir.rs
index 331ff2ce02b..d25aab86a94 100644
--- a/gix-fs/tests/fs/read_dir.rs
+++ b/gix-fs/tests/fs/read_dir.rs
@@ -1,5 +1,7 @@
+use crate::Result;
+
 #[test]
-fn with_precomposed_unicode() -> crate::Result {
+fn with_precomposed_unicode() -> Result {
     let tmp = tempfile::tempdir()?;
 
     let decomposed = "a\u{308}";
diff --git a/gix-fs/tests/fs/stack.rs b/gix-fs/tests/fs/stack.rs
index fc1c042749b..104ea0d896e 100644
--- a/gix-fs/tests/fs/stack.rs
+++ b/gix-fs/tests/fs/stack.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::join_absolute_paths)]
+use crate::Result;
 use std::path::{Path, PathBuf};
 
 use gix_fs::Stack;
@@ -229,14 +230,19 @@ fn relative_components_are_invalid() {
     let mut s = Stack::new(root.clone());
 
     let mut r = Record::default();
-    let err = s.make_relative_path_current(p("a/.."), &mut r).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        format!(
-            "Input path {input:?} contains relative or absolute components",
-            input = "a/.."
-        )
+    let err = s
+        .make_relative_path_current(p("a/.."), &mut r)
+        .expect_err("parent components are forbidden");
+    assert!(
+        gix_error::classify(&err).is_validation(),
+        "the I/O wrapper retains the cause"
     );
+    insta::assert_debug_snapshot!(err, "relative components are invalid", @r#"
+    Custom {
+        kind: Other,
+        error: Input path "a/.." contains relative or absolute components,
+    }
+    "#);
 
     s.make_relative_path_current(p("a/./b"), &mut r)
         .expect("dot is ignored");
@@ -265,20 +271,34 @@ fn relative_components_are_invalid() {
         },
         "the terminal component is validated again, but its parent stays cached"
     );
+    let err = s
+        .make_relative_path_current(p("a/.."), &mut r)
+        .expect_err("parent components are also forbidden when reusing a path prefix");
+    insta::assert_debug_snapshot!(err, "peeked errors retain their cause too", @r#"
+    Custom {
+        kind: Other,
+        error: Input path "a/.." contains relative or absolute components,
+    }
+    "#);
+    assert!(
+        gix_error::classify(&err).is_validation(),
+        "peeked errors retain their cause too"
+    );
 }
 
 #[test]
-fn absolute_paths_are_invalid() -> crate::Result {
+fn absolute_paths_are_invalid() -> Result {
     let root = PathBuf::from(".");
     let mut s = Stack::new(root.clone());
 
     let mut r = Record::default();
     let err = s.make_relative_path_current(p("/"), &mut r).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        r#"Input path "/" contains relative or absolute components"#,
-        "a leading slash is always considered absolute"
-    );
+    insta::assert_debug_snapshot!(err, "a leading slash is always considered absolute", @r#"
+    Custom {
+        kind: Other,
+        error: Input path "/" contains relative or absolute components,
+    }
+    "#);
     s.make_relative_path_current("/", &mut r)?;
     assert_eq!(
         s.current(),
@@ -287,11 +307,12 @@ fn absolute_paths_are_invalid() -> crate::Result {
     );
 
     let err = s.make_relative_path_current("../breakout", &mut r).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        r#"Input path "../breakout" contains relative or absolute components"#,
-        "otherwise breakout attempts are detected"
-    );
+    insta::assert_debug_snapshot!(err, "otherwise breakout attempts are detected", @r#"
+    Custom {
+        kind: Other,
+        error: Input path "../breakout" contains relative or absolute components,
+    }
+    "#);
     s.make_relative_path_current(p("a/"), &mut r)?;
     assert_eq!(
         s.current(),
@@ -307,26 +328,14 @@ fn absolute_paths_are_invalid() -> crate::Result {
 
     #[cfg(windows)]
     {
+        let mut error_snapshots = Vec::new();
         let err = s.make_relative_path_current(Path::new(r"\"), &mut r).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Input path "\" contains relative or absolute components"#,
-            "on Windows, backslashes are considered absolute and replace the base if it is relative, \
-            hence they are forbidden."
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
 
         let err = s.make_relative_path_current(Path::new("c:"), &mut r).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Input path "c:" contains relative or absolute components"#,
-            "on Windows, drive-letters without trailing backslash or slash are also absolute (even though they ought to be relative)"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         let err = s.make_relative_path_current(Path::new(r"c:\"), &mut r).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Input path "c:\" contains relative or absolute components"#,
-            "on Windows, drive-letters are absolute, which is expected"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
 
         s.make_relative_path_current(Path::new("֍:"), &mut r)?;
         assert_eq!(
@@ -338,26 +347,42 @@ fn absolute_paths_are_invalid() -> crate::Result {
         let err = s
             .make_relative_path_current(Path::new(r"\\localhost\hello"), &mut r)
             .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Input path "\\localhost\hello" contains relative or absolute components"#,
-            "there is UNC paths as well"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
 
         let err = s
             .make_relative_path_current(Path::new(r#"\\?\C:"#), &mut r)
             .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Input path "\\?\C:" contains relative or absolute components"#,
-            "there is UNC paths as well, sometimes they look different"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        insta::assert_debug_snapshot!(error_snapshots, "Windows absolute paths cannot escape the stack root", @r#"
+        [
+            Custom {
+                kind: Other,
+                error: Input path "\" contains relative or absolute components,
+            },
+            Custom {
+                kind: Other,
+                error: Input path "c:" contains relative or absolute components,
+            },
+            Custom {
+                kind: Other,
+                error: Input path "c:\" contains relative or absolute components,
+            },
+            Custom {
+                kind: Other,
+                error: Input path "\\localhost\hello" contains relative or absolute components,
+            },
+            Custom {
+                kind: Other,
+                error: Input path "\\?\C:" contains relative or absolute components,
+            },
+        ]
+        "#);
     }
     Ok(())
 }
 
 #[test]
-fn delegate_calls_are_consistent() -> crate::Result {
+fn delegate_calls_are_consistent() -> Result {
     let root = PathBuf::from(".");
     let mut s = Stack::new(root.clone());
 
@@ -481,12 +506,13 @@ fn delegate_calls_are_consistent() -> crate::Result {
     );
 
     let err = s.make_relative_path_current(p(""), &mut r).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "empty inputs are not allowed",
-        "this is to protect us from double-counting the root path next time a component is pushed, \
-        and besides that really shouldn't happen"
-    );
+    insta::assert_debug_snapshot!(err, "this is to protect us from double-counting the root path next time a component is pushed, \
+        and besides that really shouldn't happen", @r#"
+    Custom {
+        kind: Other,
+        error: "empty inputs are not allowed",
+    }
+    "#);
 
     s.make_relative_path_current("leaf", &mut r)?;
     dirs.drain(1..).count();
@@ -592,7 +618,12 @@ fn failed_directory_to_leaf_transition_does_not_keep_directory_state() -> crate:
     let err = s
         .make_relative_path_current("x/z", &mut r)
         .expect_err("a cached directory must also be validated as a terminal entry");
-    assert_eq!(err.to_string(), "failed to push");
+    insta::assert_debug_snapshot!(err, "failed directory to leaf transition does not keep directory state", @r#"
+    Custom {
+        kind: Other,
+        error: "failed to push",
+    }
+    "#);
     assert_eq!(
         r.directories,
         [PathBuf::from(""), PathBuf::from("x")],
@@ -618,7 +649,12 @@ fn failed_leaf_to_directory_transition_restores_leaf_state() -> crate::Result {
 
     s.make_relative_path_current("x/z", &mut r)?;
     let err = s.make_relative_path_current("x/z/a", &mut r).unwrap_err();
-    assert_eq!(err.to_string(), "failed to push directory");
+    insta::assert_debug_snapshot!(err, "failed leaf to directory transition restores leaf state", @r#"
+    Custom {
+        kind: Other,
+        error: "failed to push directory",
+    }
+    "#);
     assert_eq!(
         s.current_relative(),
         p("x/z"),
@@ -638,10 +674,8 @@ fn failed_leaf_to_directory_transition_restores_leaf_state() -> crate::Result {
 
 #[test]
 fn failed_child_push_after_leaf_to_directory_transition_restores_directory_state() -> crate::Result {
-    for (path_to_fail_on, directory_to_fail_on, expected_error) in [
-        (Some("x/z/a"), None, "failed to push"),
-        (None, Some("x/z/a"), "failed to push directory"),
-    ] {
+    let mut error_snapshots = Vec::new();
+    for (path_to_fail_on, directory_to_fail_on) in [(Some("x/z/a"), None), (None, Some("x/z/a"))] {
         let mut s = Stack::new(PathBuf::from("."));
         let mut r = FailOnce {
             path_to_fail_on: path_to_fail_on.map(PathBuf::from),
@@ -651,7 +685,7 @@ fn failed_child_push_after_leaf_to_directory_transition_restores_directory_state
 
         s.make_relative_path_current("x/z", &mut r)?;
         let err = s.make_relative_path_current("x/z/a/b", &mut r).unwrap_err();
-        assert_eq!(err.to_string(), expected_error);
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         assert_eq!(
             s.current_relative(),
             p("x/z"),
@@ -667,5 +701,17 @@ fn failed_child_push_after_leaf_to_directory_transition_restores_directory_state
             "the successful leaf-to-directory transition remains the next directory state to pop"
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "failed child push after leaf to directory transition restores directory state", @r#"
+    [
+        Custom {
+            kind: Other,
+            error: "failed to push",
+        },
+        Custom {
+            kind: Other,
+            error: "failed to push directory",
+        },
+    ]
+    "#);
     Ok(())
 }
diff --git a/gix-fsck/Cargo.toml b/gix-fsck/Cargo.toml
index f3e00274026..6fe931427a4 100644
--- a/gix-fsck/Cargo.toml
+++ b/gix-fsck/Cargo.toml
@@ -21,6 +21,7 @@ sha1 = ["gix-hash/sha1"]
 sha256 = ["gix-hash/sha256"]
 
 [dependencies]
+gix-error = { version = "^0.3.2", path = "../gix-error" }
 gix-hash = { version = "^0.26.2", path = "../gix-hash" }
 gix-hashtable = { version = "^0.16.0", path = "../gix-hashtable" }
 gix-object = { version = "^0.64.1", path = "../gix-object" }
diff --git a/gix-fsck/src/lib.rs b/gix-fsck/src/lib.rs
index 1317586b18c..382dc0619a4 100644
--- a/gix-fsck/src/lib.rs
+++ b/gix-fsck/src/lib.rs
@@ -3,6 +3,8 @@
 
 use std::collections::VecDeque;
 
+use gix_error::ExnResult;
+
 use gix_hash::ObjectId;
 use gix_hashtable::HashSet;
 use gix_object::{Exists, FindExt, Kind, tree::EntryKind};
@@ -47,7 +49,7 @@ where
     /// Any referenced blobs that are not present in the ODB will result in a call to the  `missing_cb`.
     /// Missing commits or trees will cause an error to be returned.
     ///     - TODO: consider how to handle a missing commit (invoke `missing_cb`, or possibly return a Result?)
-    pub fn check_commit(&mut self, oid: &ObjectId) -> Result<(), gix_object::find::existing_object::Error> {
+    pub fn check_commit(&mut self, oid: &ObjectId) -> ExnResult {
         // Attempt to insert the commit ID in the set, and if already present, return immediately
         if !self.seen.insert(*oid) {
             return Ok(());
diff --git a/gix-hash/Cargo.toml b/gix-hash/Cargo.toml
index dea6b7f2075..938c76dc286 100644
--- a/gix-hash/Cargo.toml
+++ b/gix-hash/Cargo.toml
@@ -39,6 +39,7 @@ sha2 = { version = "0.11.0", optional = true, default-features = false }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-hash = { path = ".", features = ["sha1", "sha256", "bstr"] }
 gix-testtools = { path = "../tests/tools", default-features = false }
 
diff --git a/gix-hash/src/change_id.rs b/gix-hash/src/change_id.rs
index 359ed4f3b71..4a3f42dd5e9 100644
--- a/gix-hash/src/change_id.rs
+++ b/gix-hash/src/change_id.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{borrow::Borrow, ops::Deref, str::FromStr};
 
 use crate::{ChangeId, Kind, ObjectId, oid};
@@ -6,17 +7,15 @@ const REVERSE_HEX: &[u8; 16] = b"zyxwvutsrqponmlk";
 
 impl ChangeId {
     /// Parse a complete SHA-1 or SHA-256 hash written with reverse-hex alphabet.
-    pub fn from_reverse_hex(buffer: &[u8]) -> Result<Self, crate::decode::Error> {
+    pub fn from_reverse_hex(buffer: &[u8]) -> ExnMessageResult<Self> {
         let len = buffer.len();
         if crate::Kind::from_hex_len(len).is_none_or(|kind| kind.len_in_hex() != len) {
-            return Err(crate::decode::Error::new(format!(
-                "A hash sized {len} hexadecimal characters is invalid"
-            )));
+            return Err(gix_error::validation(format!("A hash sized {len} hexadecimal characters is invalid")).into());
         }
 
         let mut hex = Kind::hex_buf();
         reverse_hex_to_hex(buffer, &mut hex[..len])
-            .map_err(|()| crate::decode::Error::new("Invalid character encountered"))?;
+            .map_err(|()| gix_error::validation("Invalid character encountered"))?;
         ObjectId::from_hex(&hex[..len]).map(ChangeId)
     }
 
@@ -39,9 +38,9 @@ pub struct ReverseHexDisplay<'a> {
 }
 
 impl FromStr for ChangeId {
-    type Err = crate::decode::Error;
+    type Err = gix_error::Exn<gix_error::Message>;
 
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
+    fn from_str(value: &str) -> std::result::Result<Self, Self::Err> {
         Self::from_reverse_hex(value.as_bytes())
     }
 }
@@ -121,7 +120,7 @@ impl std::fmt::Display for ReverseHexDisplay<'_> {
     }
 }
 
-pub(crate) fn reverse_hex_to_hex(reverse_hex: &[u8], hex: &mut [u8]) -> Result<(), ()> {
+pub(crate) fn reverse_hex_to_hex(reverse_hex: &[u8], hex: &mut [u8]) -> std::result::Result<(), ()> {
     for (src, dst) in reverse_hex.iter().zip(hex) {
         let nibble = match src {
             b'k'..=b'z' => b'z' - src,
diff --git a/gix-hash/src/hasher.rs b/gix-hash/src/hasher.rs
index 0d0aae7448e..4f656a4df41 100644
--- a/gix-hash/src/hasher.rs
+++ b/gix-hash/src/hasher.rs
@@ -1,8 +1,5 @@
-/// The error returned by [`Hasher::try_finalize()`](crate::Hasher::try_finalize()).
-pub type Error = gix_error::CorruptionError;
-
 pub(super) mod _impl {
-    use crate::hasher::Error;
+    use gix_error::ExnMessageResult;
 
     /// Hash implementations that can be used once.
     #[derive(Clone)]
@@ -48,20 +45,21 @@ pub(super) mod _impl {
 
         /// Finalize the hash and produce an object id.
         ///
-        /// Returns [`Error`] if a collision attack is detected.
+        /// Returns an error classified as [`gix_error::Class::Corruption`] if a collision attack is detected.
         // TODO: Since SHA-256 has an infallible `finalize`, it might be worth investigating
         //       turning the return type into `Result<crate::ObjectId, Infallible>` when this crate is
         //       compiled with SHA-256 support only.
         #[inline]
-        pub fn try_finalize(self) -> Result<crate::ObjectId, Error> {
+        pub fn try_finalize(self) -> ExnMessageResult<crate::ObjectId> {
             match self {
                 #[cfg(feature = "sha1")]
                 Hasher::Sha1(sha1) => match sha1.finalize() {
                     Ok(digest) => Ok(crate::ObjectId::Sha1(digest.into())),
-                    Err(collision) => Err(Error::new(format!(
+                    Err(collision) => Err(gix_error::corruption(format!(
                         "Detected SHA-1 collision attack with digest {}",
                         crate::ObjectId::Sha1(collision.digest().into())
-                    ))),
+                    ))
+                    .into()),
                 },
                 #[cfg(feature = "sha256")]
                 Hasher::Sha256(sha256) => Ok(crate::ObjectId::Sha256(sha2::Digest::finalize(sha256).into())),
diff --git a/gix-hash/src/io.rs b/gix-hash/src/io.rs
index ff584f76b23..a3be4627486 100644
--- a/gix-hash/src/io.rs
+++ b/gix-hash/src/io.rs
@@ -1,26 +1,23 @@
-use crate::hasher;
-use gix_error::{ErrorExt, message};
-
-/// The error type for I/O operations that compute hashes.
-pub type Error = gix_error::Exn;
+use gix_error::{ErrorExt, Exn, Message, message};
 
 /// Convert an I/O error into this module's error type without changing its message.
 // TODO(gix-error): review and attempt to remove the need for this if possible. But don't stress it.
-pub fn from_std_io(source: std::io::Error) -> Error {
+pub fn from_std_io(source: std::io::Error) -> gix_error::Exn {
     source.raise_erased()
 }
 
 /// Convert a hashing error into this module's error type and add operation context.
 // TODO(gix-error): review and attempt to remove the need for this if possible. But don't stress it.
-pub fn from_hasher(source: hasher::Error) -> Error {
-    source.and_raise(message("Failed to hash data")).erased()
+pub fn from_hasher(source: Exn<Message>) -> Exn {
+    source.raise(message("Failed to hash data")).erased()
 }
 
 pub(super) mod _impl {
     use crate::{
         Hasher, hasher,
-        io::{Error, from_hasher, from_std_io},
+        io::{from_hasher, from_std_io},
     };
+    use gix_error::ExnResult;
 
     /// 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`.
@@ -37,7 +34,7 @@ pub(super) mod _impl {
         kind: crate::Kind,
         progress: &mut dyn gix_features::progress::Progress,
         should_interrupt: &std::sync::atomic::AtomicBool,
-    ) -> Result<crate::ObjectId, Error> {
+    ) -> ExnResult<crate::ObjectId> {
         bytes(
             &mut std::fs::File::open(path).map_err(from_std_io)?,
             num_bytes_from_start,
@@ -54,7 +51,7 @@ pub(super) mod _impl {
         kind: crate::Kind,
         progress: &mut dyn gix_features::progress::Progress,
         should_interrupt: &std::sync::atomic::AtomicBool,
-    ) -> Result<crate::ObjectId, Error> {
+    ) -> ExnResult<crate::ObjectId> {
         bytes_with_hasher(read, num_bytes_from_start, hasher(kind), progress, should_interrupt)
     }
 
@@ -65,7 +62,7 @@ pub(super) mod _impl {
         mut hasher: Hasher,
         progress: &mut dyn gix_features::progress::Progress,
         should_interrupt: &std::sync::atomic::AtomicBool,
-    ) -> Result<crate::ObjectId, Error> {
+    ) -> ExnResult<crate::ObjectId> {
         let start = std::time::Instant::now();
         // init progress before the possibility for failure, as convenience in case people want to recover
         progress.init(
diff --git a/gix-hash/src/lib.rs b/gix-hash/src/lib.rs
index 112b8aa7ed0..80d162018e2 100644
--- a/gix-hash/src/lib.rs
+++ b/gix-hash/src/lib.rs
@@ -79,7 +79,7 @@ macro_rules! impl_partial_eq_str {
 
 #[path = "oid.rs"]
 mod borrowed;
-pub use borrowed::{Error, oid};
+pub use borrowed::oid;
 
 /// Hash functions and hash utilities
 pub mod hasher;
diff --git a/gix-hash/src/object_id.rs b/gix-hash/src/object_id.rs
index 1899d199e28..8e920f725b1 100644
--- a/gix-hash/src/object_id.rs
+++ b/gix-hash/src/object_id.rs
@@ -42,10 +42,10 @@ impl Hash for ObjectId {
 
 #[expect(missing_docs)]
 pub mod decode {
+    use gix_error::ExnMessageResult;
     use std::str::FromStr;
 
     use crate::object_id::ObjectId;
-    use gix_error::ValidationError;
 
     #[cfg(feature = "sha1")]
     use crate::{SIZE_OF_SHA1_DIGEST, SIZE_OF_SHA1_HEX_DIGEST};
@@ -53,9 +53,6 @@ pub mod decode {
     #[cfg(feature = "sha256")]
     use crate::{SIZE_OF_SHA256_DIGEST, SIZE_OF_SHA256_HEX_DIGEST};
 
-    /// An error returned by [`ObjectId::from_hex()`][crate::ObjectId::from_hex()]
-    pub type Error = ValidationError;
-
     /// Hash decoding
     impl ObjectId {
         /// Create an instance from a `buffer` of 40 bytes or 64 bytes encoded with hexadecimal
@@ -63,7 +60,7 @@ pub mod decode {
         /// as SHA256 when it is enabled.
         ///
         /// Such a buffer can be obtained using [`oid::write_hex_to(buffer)`][super::oid::write_hex_to()]
-        pub fn from_hex(buffer: &[u8]) -> Result<ObjectId, Error> {
+        pub fn from_hex(buffer: &[u8]) -> ExnMessageResult<ObjectId> {
             match buffer.len() {
                 #[cfg(feature = "sha1")]
                 SIZE_OF_SHA1_HEX_DIGEST => Ok({
@@ -71,7 +68,7 @@ pub mod decode {
                         let mut buf = [0; SIZE_OF_SHA1_DIGEST];
                         faster_hex::hex_decode(buffer, &mut buf).map_err(|err| match err {
                             faster_hex::Error::InvalidChar | faster_hex::Error::Overflow => {
-                                Error::new("Invalid character encountered")
+                                gix_error::validation("Invalid character encountered")
                             }
                             faster_hex::Error::InvalidLength(_) => {
                                 unreachable!("BUG: This is already checked")
@@ -86,7 +83,7 @@ pub mod decode {
                         let mut buf = [0; SIZE_OF_SHA256_DIGEST];
                         faster_hex::hex_decode(buffer, &mut buf).map_err(|err| match err {
                             faster_hex::Error::InvalidChar | faster_hex::Error::Overflow => {
-                                Error::new("Invalid character encountered")
+                                gix_error::validation("Invalid character encountered")
                             }
                             faster_hex::Error::InvalidLength(_) => {
                                 unreachable!("BUG: This is already checked")
@@ -95,17 +92,17 @@ pub mod decode {
                         buf
                     })
                 }),
-                len => Err(Error::new(format!(
-                    "A hash sized {len} hexadecimal characters is invalid"
-                ))),
+                len => {
+                    Err(gix_error::validation(format!("A hash sized {len} hexadecimal characters is invalid")).into())
+                }
             }
         }
     }
 
     impl FromStr for ObjectId {
-        type Err = Error;
+        type Err = gix_error::Exn<gix_error::Message>;
 
-        fn from_str(s: &str) -> Result<Self, Self::Err> {
+        fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
             Self::from_hex(s.as_bytes())
         }
     }
@@ -313,9 +310,9 @@ impl From<&oid> for ObjectId {
 }
 
 impl TryFrom<&[u8]> for ObjectId {
-    type Error = crate::Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
-    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+    fn try_from(bytes: &[u8]) -> std::result::Result<Self, Self::Error> {
         Ok(oid::try_from_bytes(bytes)?.into())
     }
 }
diff --git a/gix-hash/src/oid.rs b/gix-hash/src/oid.rs
index e607051cdc0..b07a744c354 100644
--- a/gix-hash/src/oid.rs
+++ b/gix-hash/src/oid.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{hash, ops::Range};
 
 use crate::{Kind, ObjectId, Prefix};
@@ -82,14 +83,11 @@ impl std::fmt::Debug for oid {
     }
 }
 
-/// The error returned when trying to convert a byte slice to an [`oid`] or [`ObjectId`]
-pub type Error = gix_error::ValidationError;
-
 /// Conversion
 impl oid {
     /// Try to create a shared object id from a slice of bytes representing a hash `digest`
     #[inline]
-    pub fn try_from_bytes(digest: &[u8]) -> Result<&Self, Error> {
+    pub fn try_from_bytes(digest: &[u8]) -> ExnMessageResult<&Self> {
         match digest.len() {
             #[cfg(feature = "sha1")]
             SIZE_OF_SHA1_DIGEST => Ok(
@@ -105,9 +103,9 @@ impl oid {
                     &*(std::ptr::from_ref::<[u8]>(digest) as *const oid)
                 },
             ),
-            len => Err(Error::new(format!(
-                "Cannot instantiate git hash from a digest of length {len}"
-            ))),
+            len => {
+                Err(gix_error::validation(format!("Cannot instantiate git hash from a digest of length {len}")).into())
+            }
         }
     }
 
@@ -296,9 +294,9 @@ impl AsRef<oid> for &oid {
 }
 
 impl<'a> TryFrom<&'a [u8]> for &'a oid {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
-    fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
+    fn try_from(value: &'a [u8]) -> std::result::Result<Self, Self::Error> {
         oid::try_from_bytes(value)
     }
 }
@@ -362,7 +360,7 @@ impl_partial_eq_str!(oid);
 /// Unfortunately the `serde::Deserialize` derive wouldn't work for borrowed arrays.
 #[cfg(feature = "serde")]
 impl<'de: 'a, 'a> serde::Deserialize<'de> for &'a oid {
-    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, <D as serde::Deserializer<'de>>::Error>
     where
         D: serde::Deserializer<'de>,
     {
diff --git a/gix-hash/src/prefix.rs b/gix-hash/src/prefix.rs
index 7ca3835f6f4..a6b698bc067 100644
--- a/gix-hash/src/prefix.rs
+++ b/gix-hash/src/prefix.rs
@@ -1,16 +1,8 @@
+use gix_error::ExnMessageResult;
 use std::cmp::Ordering;
 
 use crate::{ChangeId, ObjectId, Prefix, change_id::ReverseHexDisplay, oid};
 
-/// The error returned by [`Prefix::new()`].
-pub type Error = gix_error::ValidationError;
-
-///
-pub mod from_hex {
-    /// The error returned by [`Prefix::from_hex`][super::Prefix::from_hex()].
-    pub type Error = gix_error::ValidationError;
-}
-
 impl Prefix {
     /// The smallest allowed prefix length below which chances for collisions are too high even in small repositories.
     pub const MIN_HEX_LEN: usize = 4;
@@ -19,18 +11,20 @@ impl Prefix {
     ///
     /// For instance, with `hex_len` of 7 the resulting prefix is 3.5 bytes, or 3 bytes and 4 bits
     /// wide, with all other bytes and bits set to zero.
-    pub fn new(id: &oid, hex_len: usize) -> Result<Self, Error> {
+    pub fn new(id: &oid, hex_len: usize) -> ExnMessageResult<Self> {
         if hex_len > id.kind().len_in_hex() {
-            Err(Error::new(format!(
+            Err(gix_error::validation(format!(
                 "An object of kind {} cannot be larger than {} in hex, but {hex_len} was requested",
                 id.kind(),
                 id.kind().len_in_hex()
-            )))
+            ))
+            .into())
         } else if hex_len < Self::MIN_HEX_LEN {
-            Err(Error::new(format!(
+            Err(gix_error::validation(format!(
                 "The minimum hex length of a short object id is {}, got {hex_len}",
                 Self::MIN_HEX_LEN
-            )))
+            ))
+            .into())
         } else {
             let mut prefix = ObjectId::null(id.kind());
             let b = prefix.as_mut_slice();
@@ -104,32 +98,35 @@ impl Prefix {
 
     /// Create an instance from the given hexadecimal prefix `value`, e.g. `35e77c16` would yield a `Prefix` with `hex_len()` = 8.
     /// Note that the minimum hex length is `4` - use [`Self::from_hex_nonempty()`].
-    pub fn from_hex(value: &str) -> Result<Self, from_hex::Error> {
+    pub fn from_hex(value: &str) -> ExnMessageResult<Self> {
         let hex_len = value.len();
         if hex_len < Self::MIN_HEX_LEN {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "The minimum hex length of a short object id is {}, got {hex_len}",
                 Self::MIN_HEX_LEN
-            )));
+            ))
+            .into());
         }
         Self::from_hex_nonempty(value)
     }
 
     /// Create an instance from the given hexadecimal prefix `value`, e.g. `35e` would yield a `Prefix` with `hex_len()` = 3.
     /// Note that this function supports all non-empty hex input - for a more typical implementation, use [`Self::from_hex()`].
-    pub fn from_hex_nonempty(value: &str) -> Result<Self, from_hex::Error> {
+    pub fn from_hex_nonempty(value: &str) -> ExnMessageResult<Self> {
         let hex_len = value.len();
 
         if hex_len > crate::Kind::longest().len_in_hex() {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "An id cannot be larger than {} chars in hex, but {hex_len} was requested",
                 crate::Kind::longest().len_in_hex()
-            )));
+            ))
+            .into());
         } else if hex_len == 0 {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "The minimum hex length of a short object id is {}, got {hex_len}",
                 Self::MIN_HEX_LEN
-            )));
+            ))
+            .into());
         }
 
         let kind = crate::Kind::from_hex_len(hex_len).expect("hex-len is already checked");
@@ -145,7 +142,7 @@ impl Prefix {
         };
         decode_result.map_err(|e| match e {
             faster_hex::Error::InvalidChar | faster_hex::Error::Overflow => {
-                from_hex::Error::new("Invalid hex character")
+                gix_error::validation("Invalid hex character")
             }
             faster_hex::Error::InvalidLength(_) => panic!("This is already checked"),
         })?;
@@ -154,35 +151,38 @@ impl Prefix {
     }
 
     /// Create an instance from a reverse-hex prefix, requiring at least [`Self::MIN_HEX_LEN`] characters.
-    pub fn from_reverse_hex(value: &str) -> Result<Self, from_hex::Error> {
+    pub fn from_reverse_hex(value: &str) -> ExnMessageResult<Self> {
         let hex_len = value.len();
         if hex_len < Self::MIN_HEX_LEN {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "The minimum hex length of a short object id is {}, got {hex_len}",
                 Self::MIN_HEX_LEN
-            )));
+            ))
+            .into());
         }
         Self::from_reverse_hex_nonempty(value)
     }
 
     /// Create an instance from a non-empty prefix written with JJ's reverse-hex alphabet.
-    pub fn from_reverse_hex_nonempty(value: &str) -> Result<Self, from_hex::Error> {
+    pub fn from_reverse_hex_nonempty(value: &str) -> ExnMessageResult<Self> {
         let hex_len = value.len();
         if hex_len > crate::Kind::longest().len_in_hex() {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "An id cannot be larger than {} chars in hex, but {hex_len} was requested",
                 crate::Kind::longest().len_in_hex()
-            )));
+            ))
+            .into());
         } else if hex_len == 0 {
-            return Err(from_hex::Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "The minimum hex length of a short object id is {}, got {hex_len}",
                 Self::MIN_HEX_LEN
-            )));
+            ))
+            .into());
         }
 
         let mut hex = crate::Kind::hex_buf();
         crate::change_id::reverse_hex_to_hex(value.as_bytes(), &mut hex[..hex_len])
-            .map_err(|()| from_hex::Error::new("Invalid hex character"))?;
+            .map_err(|()| gix_error::validation("Invalid hex character"))?;
         let hex = std::str::from_utf8(&hex[..hex_len]).expect("translated reverse hex is always ASCII");
         Self::from_hex_nonempty(hex)
     }
@@ -196,9 +196,9 @@ impl Prefix {
 /// Create an instance from the given hexadecimal prefix, e.g. `35e77c16` would yield a `Prefix`
 /// with `hex_len()` = 8.
 impl TryFrom<&str> for Prefix {
-    type Error = from_hex::Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
+    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
         Prefix::from_hex(value)
     }
 }
diff --git a/gix-hash/src/verify.rs b/gix-hash/src/verify.rs
index 1e13ef28df1..1d3161ab181 100644
--- a/gix-hash/src/verify.rs
+++ b/gix-hash/src/verify.rs
@@ -1,18 +1,16 @@
 use crate::oid;
-
-/// The error returned by [`oid::verify()`].
-pub type Error = gix_error::CorruptionError;
+use gix_error::ExnMessageResult;
 
 impl oid {
     /// Verify that `self` matches the `expected` object ID.
     ///
-    /// Returns an [`Error`] containing both object IDs if they differ.
+    /// Returns an error classified as [`gix_error::Class::Corruption`] containing both object IDs if they differ.
     #[inline]
-    pub fn verify(&self, expected: &oid) -> Result<(), Error> {
+    pub fn verify(&self, expected: &oid) -> ExnMessageResult {
         if self == expected {
             Ok(())
         } else {
-            Err(Error::new(format!("Hash was {self}, but should have been {expected}")))
+            Err(gix_error::corruption(format!("Hash was {self}, but should have been {expected}")).into())
         }
     }
 }
diff --git a/gix-hash/tests/hash/change_id.rs b/gix-hash/tests/hash/change_id.rs
index dfccc0b6136..7bc196a30b8 100644
--- a/gix-hash/tests/hash/change_id.rs
+++ b/gix-hash/tests/hash/change_id.rs
@@ -66,16 +66,7 @@ fn formats_sha256_with_the_same_jj_algorithm() -> gix_testtools::Result {
 #[test]
 fn rejects_invalid_reverse_hex() {
     let invalid_character = format!("j{}", "z".repeat(39));
-    assert_eq!(
-        ChangeId::from_reverse_hex(invalid_character.as_bytes())
-            .unwrap_err()
-            .to_string(),
-        "Invalid character encountered",
-        "characters outside JJ's k-z alphabet are rejected"
-    );
-    assert_eq!(
-        ChangeId::from_reverse_hex(b"zzy").unwrap_err().to_string(),
-        "A hash sized 3 hexadecimal characters is invalid",
-        "full change IDs require a supported object hash length"
-    );
+    insta::assert_debug_snapshot!(ChangeId::from_reverse_hex(invalid_character.as_bytes())
+            .expect_err("characters outside JJ's k-z alphabet are rejected"), "characters outside JJ's k-z alphabet are rejected", @"Invalid character encountered");
+    insta::assert_debug_snapshot!(ChangeId::from_reverse_hex(b"zzy").expect_err("full change IDs require a supported object hash length"), "full change IDs require a supported object hash length", @"A hash sized 3 hexadecimal characters is invalid");
 }
diff --git a/gix-hash/tests/hash/hasher.rs b/gix-hash/tests/hash/hasher.rs
index 15c64d58b6e..f83355ac458 100644
--- a/gix-hash/tests/hash/hasher.rs
+++ b/gix-hash/tests/hash/hasher.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use gix_hash::{Hasher, ObjectId};
 use gix_testtools::size_ok;
 
@@ -11,6 +12,11 @@ fn interruption_preserves_its_io_error_kind() {
         &std::sync::atomic::AtomicBool::new(true),
     )
     .expect_err("the interrupt flag is observed after reading a chunk");
+    insta::assert_debug_snapshot!(err, "interruption preserves its io error kind", @"
+    I/O error (Interrupted)
+    |
+    └─ Interrupted
+    ");
     assert_eq!(
         err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind),
         Some(std::io::ErrorKind::Interrupted)
@@ -43,21 +49,10 @@ fn size_of_hasher_sha1_and_sha256() {
 }
 
 #[test]
-#[cfg(all(not(feature = "sha256"), feature = "sha1"))]
-fn size_of_try_finalize_return_type_sha1_only() {
-    assert_eq!(
-        std::mem::size_of::<Result<ObjectId, gix_hash::hasher::Error>>(),
-        32,
-        "The size of the return value should remain compact"
-    );
-}
-
-#[test]
-#[cfg(all(feature = "sha256", feature = "sha1"))]
-fn size_of_try_finalize_return_type_sha1_and_sha256() {
-    assert_eq!(
-        std::mem::size_of::<Result<ObjectId, gix_hash::hasher::Error>>(),
-        32 + std::mem::size_of::<usize>(),
-        "The size of the return value should remain compact"
+fn size_of_try_finalize_return_type() {
+    let actual = std::mem::size_of::<ExnMessageResult<ObjectId>>();
+    assert!(
+        size_ok(actual, 40),
+        "The return value should stay within its 40-byte 64-bit baseline: {actual}"
     );
 }
diff --git a/gix-hash/tests/hash/object_id.rs b/gix-hash/tests/hash/object_id.rs
index 0dbe3f78db9..262ce7896c2 100644
--- a/gix-hash/tests/hash/object_id.rs
+++ b/gix-hash/tests/hash/object_id.rs
@@ -21,29 +21,18 @@ mod from_hex {
 
         #[test]
         fn non_hex_characters() {
-            assert_eq!(
-                ObjectId::from_hex(b"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz")
-                    .unwrap_err()
-                    .to_string(),
-                "Invalid character encountered"
-            );
+            insta::assert_debug_snapshot!(ObjectId::from_hex(b"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz")
+                    .expect_err("non hex characters"), "non hex characters", @"Invalid character encountered");
         }
 
         #[test]
         fn too_short() {
-            assert_eq!(
-                ObjectId::from_hex(b"abcd").unwrap_err().to_string(),
-                "A hash sized 4 hexadecimal characters is invalid"
-            );
+            insta::assert_debug_snapshot!(ObjectId::from_hex(b"abcd").expect_err("too short"), "too short", @"A hash sized 4 hexadecimal characters is invalid");
         }
         #[test]
         fn too_long() {
-            assert_eq!(
-                ObjectId::from_hex(b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaf")
-                    .unwrap_err()
-                    .to_string(),
-                "A hash sized 41 hexadecimal characters is invalid"
-            );
+            insta::assert_debug_snapshot!(ObjectId::from_hex(b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaf")
+                    .expect_err("too long"), "too long", @"A hash sized 41 hexadecimal characters is invalid");
         }
     }
 }
@@ -64,11 +53,12 @@ fn from_bytes_or_panic_sha256() {
 
 #[cfg(feature = "sha1")]
 mod sha1 {
+    use gix_error::ExnMessageResult;
     use std::str::FromStr as _;
 
     use gix_hash::{Kind, ObjectId, hasher};
 
-    fn hash_contents(s: &[u8]) -> Result<ObjectId, hasher::Error> {
+    fn hash_contents(s: &[u8]) -> ExnMessageResult<ObjectId> {
         let mut hasher = hasher(Kind::Sha1);
         hasher.update(s);
         hasher.try_finalize()
@@ -126,20 +116,17 @@ mod sha1 {
         let message_b = include_bytes!("../fixtures/shambles/messageB");
         assert_ne!(message_a, message_b);
 
-        let expected =
-            ObjectId::from_str("8ac60ba76f1999a1ab70223f225aefdc78d4ddc0").expect("Shambles digest to be valid");
-
-        let expected = format!("Detected SHA-1 collision attack with digest {expected}");
-        assert_eq!(hash_contents(message_a).unwrap_err().to_string(), expected);
-        assert_eq!(hash_contents(message_b).unwrap_err().to_string(), expected);
+        insta::assert_debug_snapshot!(hash_contents(message_a).expect_err("shambles"), "shambles", @"Detected SHA-1 collision attack with digest 8ac60ba76f1999a1ab70223f225aefdc78d4ddc0");
+        insta::assert_debug_snapshot!(hash_contents(message_b).expect_err("shambles"), "shambles", @"Detected SHA-1 collision attack with digest 8ac60ba76f1999a1ab70223f225aefdc78d4ddc0");
     }
 }
 
 #[cfg(feature = "sha256")]
 mod sha256 {
+    use gix_error::ExnMessageResult;
     use gix_hash::{Kind, ObjectId, hasher};
 
-    fn hash_contents(s: &[u8]) -> Result<ObjectId, hasher::Error> {
+    fn hash_contents(s: &[u8]) -> ExnMessageResult<ObjectId> {
         let mut hasher = hasher(Kind::Sha256);
         hasher.update(s);
         hasher.try_finalize()
diff --git a/gix-hash/tests/hash/prefix.rs b/gix-hash/tests/hash/prefix.rs
index 2c43365c596..2656b6f603a 100644
--- a/gix-hash/tests/hash/prefix.rs
+++ b/gix-hash/tests/hash/prefix.rs
@@ -155,21 +155,14 @@ mod new {
     #[test]
     fn errors_if_hex_len_is_longer_than_oid_len_in_hex() {
         let kind = Kind::Sha1;
-        assert_eq!(
-            gix_hash::Prefix::new(&ObjectId::null(kind), kind.len_in_hex() + 1)
-                .unwrap_err()
-                .to_string(),
-            "An object of kind sha1 cannot be larger than 40 in hex, but 41 was requested"
-        );
+        insta::assert_debug_snapshot!(gix_hash::Prefix::new(&ObjectId::null(kind), kind.len_in_hex() + 1)
+                .expect_err("errors if hex len is longer than oid len in hex"), "errors if hex len is longer than oid len in hex", @"An object of kind sha1 cannot be larger than 40 in hex, but 41 was requested");
     }
 
     #[test]
     fn errors_if_hex_len_is_too_short() {
         let kind = Kind::Sha1;
-        assert_eq!(
-            gix_hash::Prefix::new(&ObjectId::null(kind), 3).unwrap_err().to_string(),
-            "The minimum hex length of a short object id is 4, got 3"
-        );
+        insta::assert_debug_snapshot!(gix_hash::Prefix::new(&ObjectId::null(kind), 3).expect_err("errors if hex len is too short"), "errors if hex len is too short", @"The minimum hex length of a short object id is 4, got 3");
     }
 }
 
@@ -334,24 +327,16 @@ mod reverse_hex {
 
     #[test]
     fn validates_reverse_hex_like_forward_hex() -> gix_testtools::Result {
-        assert_eq!(
-            Prefix::from_reverse_hex("zzy")
-                .expect_err("three digits are below the safe minimum")
-                .to_string(),
-            "The minimum hex length of a short object id is 4, got 3"
-        );
+        insta::assert_debug_snapshot!(Prefix::from_reverse_hex("zzy")
+                .expect_err("three digits are below the safe minimum"), "validates reverse hex like forward hex", @"The minimum hex length of a short object id is 4, got 3");
         let prefix = Prefix::from_reverse_hex("ZZYX")?;
         assert_eq!(
             prefix.to_reverse_hex().to_string(),
             "zzyx",
             "output is canonical lowercase"
         );
-        assert_eq!(
-            Prefix::from_reverse_hex_nonempty("jj")
-                .expect_err("j is outside the reverse alphabet")
-                .to_string(),
-            "Invalid hex character"
-        );
+        insta::assert_debug_snapshot!(Prefix::from_reverse_hex_nonempty("jj")
+                .expect_err("j is outside the reverse alphabet"), "validates reverse hex like forward hex", @"Invalid hex character");
         Ok(())
     }
 }
diff --git a/gix-ignore/tests/ignore/search.rs b/gix-ignore/tests/ignore/search.rs
index 24b338ab72b..f0834da7cf0 100644
--- a/gix-ignore/tests/ignore/search.rs
+++ b/gix-ignore/tests/ignore/search.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::{BStr, ByteSlice};
 use gix_glob::pattern::Case;
 use gix_ignore::search::Match;
@@ -28,7 +29,7 @@ impl<'a> Iterator for Expectations<'a> {
 }
 
 #[test]
-fn baseline_from_git_dir() -> crate::Result {
+fn baseline_from_git_dir() -> Result {
     for repo_name in [
         "repo",
         "slash-and-excludes",
diff --git a/gix-index/Cargo.toml b/gix-index/Cargo.toml
index 459a26150de..a70fb1e5cfd 100644
--- a/gix-index/Cargo.toml
+++ b/gix-index/Cargo.toml
@@ -37,6 +37,7 @@ gix-features = { version = "^0.49.1", path = "../gix-features", features = [
     "progress",
 ] }
 gix-hash = { version = "^0.26.1", path = "../gix-hash" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-bitmap = { version = "^0.4.0", path = "../gix-bitmap" }
 gix-object = { version = "^0.64.0", path = "../gix-object" }
 gix-validate = { version = "^0.11.4", path = "../gix-validate" }
@@ -47,7 +48,6 @@ gix-utils = { version = "^0.3.6", path = "../gix-utils" }
 
 hashbrown = "0.17.1"
 fnv = "1.0.7"
-thiserror = "2.0.18"
 memmap2 = "0.9.11"
 filetime = "0.2.29"
 bstr = { version = "1.12.0", default-features = false }
diff --git a/gix-index/src/decode/entries.rs b/gix-index/src/decode/entries.rs
index 241916df50a..645ae02161a 100644
--- a/gix-index/src/decode/entries.rs
+++ b/gix-index/src/decode/entries.rs
@@ -1,8 +1,10 @@
 use std::ops::Range;
 
+use gix_error::{ExnResult, OptionExt};
+
 use crate::{
     Entry, Version,
-    decode::{self, header},
+    decode::header,
     entry,
     util::{read_u32, split_at_byte_exclusive, var_int},
 };
@@ -97,7 +99,7 @@ pub fn chunk<'a>(
     num_entries: u32,
     object_hash: gix_hash::Kind,
     version: Version,
-) -> Result<(Outcome, &'a [u8]), decode::Error> {
+) -> ExnResult<(Outcome, &'a [u8])> {
     let mut is_sparse = false;
     let has_delta_paths = version == Version::V4;
     let mut prev_path = None;
@@ -111,7 +113,7 @@ pub fn chunk<'a>(
             has_delta_paths,
             prev_path,
         )
-        .ok_or(decode::Error::Entry { index: idx })?;
+        .ok_or_raise_erased(|| gix_error::corruption(format!("Could not parse entry at index {idx}")))?;
 
         data = remaining;
         is_sparse |= entry.mode.is_sparse();
diff --git a/gix-index/src/decode/header.rs b/gix-index/src/decode/header.rs
index 8de157edb01..7b2d07072ba 100644
--- a/gix-index/src/decode/header.rs
+++ b/gix-index/src/decode/header.rs
@@ -1,35 +1,25 @@
+use gix_error::ExnResult;
 pub(crate) const SIZE: usize = 4 /*signature*/ + 4 /*version*/ + 4 /* num entries */;
 
 use crate::{Version, util::from_be_u32};
 
 pub(crate) const SIGNATURE: &[u8] = b"DIRC";
 
-mod error {
+pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> ExnResult<(Version, u32, &[u8])> {
+    use gix_error::ErrorExt;
 
-    /// The error produced when failing to decode an index header.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("{0}")]
-        Corrupt(&'static str),
-        #[error("Index version {0} is not supported")]
-        UnsupportedVersion(u32),
-    }
-}
-pub use error::Error;
-
-pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<(Version, u32, &[u8]), Error> {
     if data.len() < (3 * 4) + object_hash.len_in_bytes() {
-        return Err(Error::Corrupt(
-            "File is too small even for header with zero entries and smallest hash",
-        ));
+        return Err(
+            gix_error::corruption("File is too small even for header with zero entries and smallest hash")
+                .raise_erased(),
+        );
     }
 
     let (signature, data) = data.split_at(4);
     if signature != SIGNATURE {
-        return Err(Error::Corrupt(
-            "Signature mismatch - this doesn't claim to be a header file",
-        ));
+        return Err(
+            gix_error::corruption("Signature mismatch - this doesn't claim to be a header file").raise_erased(),
+        );
     }
 
     let (version, data) = data.split_at(4);
@@ -37,7 +27,9 @@ pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<(Versio
         2 => Version::V2,
         3 => Version::V3,
         4 => Version::V4,
-        unknown => return Err(Error::UnsupportedVersion(unknown)),
+        unknown => {
+            return Err(gix_error::validation(format!("Index version {unknown} is not supported")).raise_erased());
+        }
     };
     let (entries, data) = data.split_at(4);
     let entries = from_be_u32(entries);
diff --git a/gix-index/src/decode/mod.rs b/gix-index/src/decode/mod.rs
index a663c4daca0..a01a3515669 100644
--- a/gix-index/src/decode/mod.rs
+++ b/gix-index/src/decode/mod.rs
@@ -1,4 +1,5 @@
 use filetime::FileTime;
+use gix_error::ExnResult;
 
 use crate::{Entry, State, Version, entry, extension};
 
@@ -6,38 +7,7 @@ mod entries;
 ///
 pub mod header;
 
-mod error {
-    use crate::{decode, extension};
-    use std::collections::TryReserveError;
-
-    /// The error returned by [`State::from_bytes()`][crate::State::from_bytes()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Header(#[from] decode::header::Error),
-        #[error("Could not hash index data")]
-        Hasher(#[source] std::io::Error),
-        #[error("Index data would require more memory than can be reserved")]
-        OutOfMemory,
-        #[error("Could not parse entry at index {index}")]
-        Entry { index: u32 },
-        #[error("Mandatory extension wasn't implemented or malformed.")]
-        Extension(#[from] extension::decode::Error),
-        #[error("Index trailer should have been {expected} bytes long, but was {actual}")]
-        UnexpectedTrailerLength { expected: usize, actual: usize },
-        #[error("Shared index checksum mismatch")]
-        Verify(#[from] gix_hash::verify::Error),
-    }
-
-    impl From<TryReserveError> for Error {
-        #[cold]
-        fn from(_: TryReserveError) -> Self {
-            Self::OutOfMemory
-        }
-    }
-}
-pub use error::Error;
+use gix_error::{ErrorExt, ResourceExhaustionKind, ResultExt, corruption, message, resource_exhaustion};
 use gix_features::parallel::InOrderIter;
 
 use crate::util::read_u32;
@@ -77,14 +47,13 @@ impl State {
             expected_checksum,
             alloc_limit_bytes,
         }: Options,
-    ) -> Result<(Self, Option<gix_hash::ObjectId>), Error> {
+    ) -> ExnResult<(Self, Option<gix_hash::ObjectId>)> {
         let _span = gix_features::trace::detail!("gix_index::State::from_bytes()", options = ?_options);
         let (version, num_entries, post_header_data) = header::decode(data, object_hash)?;
         let start_of_extensions = extension::end_of_index_entry::decode(data, object_hash)
-            .map_err(gix_hash::io::from_hasher)
-            .map_err(|err| Error::Hasher(std::io::Error::other(err.into_error())))?;
+            .or_raise_erased(|| message("Could not hash index data"))?;
         if num_entries as usize > entries::max_entries_possible(data.len(), start_of_extensions, object_hash, version) {
-            return Err(header::Error::Corrupt("Declared entry count exceeds possible entries for file size").into());
+            return Err(corruption("Declared entry count exceeds possible entries for file size").raise_erased());
         }
 
         let mut num_threads = gix_features::parallel::num_threads(thread_limit);
@@ -98,7 +67,7 @@ impl State {
         ensure_in_alloc_limit(
             (num_entries as usize)
                 .checked_mul(std::mem::size_of::<Entry>())
-                .ok_or(Error::OutOfMemory)?,
+                .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?,
             alloc_limit_bytes,
         )?;
         ensure_in_alloc_limit(path_backing_buffer_size, alloc_limit_bytes)?;
@@ -162,7 +131,7 @@ impl State {
                                                 )?;
                                                 is_sparse |= chunk_is_sparse;
                                             }
-                                            Ok::<_, Error>((
+                                            Ok::<_, gix_error::Exn>((
                                                 id,
                                                 EntriesOutcome {
                                                     entries,
@@ -218,7 +187,7 @@ impl State {
                     );
                     (entries_res, ext_res)
                 });
-                let (ext, data) = ext_res?;
+                let (ext, data) = ext_res.or_erased()?;
                 (entries_res?.0, ext, data)
             }
             None | Some(_) => {
@@ -229,22 +198,26 @@ impl State {
                     object_hash,
                     version,
                 )?;
-                let (ext, data) = extension::decode::all(data, object_hash, alloc_limit_bytes)?;
+                let (ext, data) = extension::decode::all(data, object_hash, alloc_limit_bytes).or_erased()?;
                 (entries, ext, data)
             }
         };
 
         if data.len() != object_hash.len_in_bytes() {
-            return Err(Error::UnexpectedTrailerLength {
-                expected: object_hash.len_in_bytes(),
-                actual: data.len(),
-            });
+            return Err(corruption(format!(
+                "Index trailer should have been {} bytes long, but was {}",
+                object_hash.len_in_bytes(),
+                data.len()
+            ))
+            .raise_erased());
         }
 
         let checksum = gix_hash::ObjectId::from_bytes_or_panic(data);
         let checksum = (!checksum.is_null()).then_some(checksum);
         if let Some((expected_checksum, actual_checksum)) = expected_checksum.zip(checksum) {
-            actual_checksum.verify(&expected_checksum)?;
+            actual_checksum
+                .verify(&expected_checksum)
+                .or_raise_erased(|| message("Shared index checksum mismatch"))?;
         }
         let EntriesOutcome {
             entries,
@@ -291,9 +264,10 @@ struct EntriesOutcome {
     pub is_sparse: bool,
 }
 
-fn vec_with_capacity<T>(capacity: usize) -> Result<Vec<T>, Error> {
+fn vec_with_capacity<T>(capacity: usize) -> ExnResult<Vec<T>> {
     let mut vec = Vec::new();
-    vec.try_reserve(capacity).map_err(|_| Error::OutOfMemory)?;
+    vec.try_reserve(capacity)
+        .or_raise_erased(|| message("Index data would require more memory than can be reserved"))?;
     Ok(vec)
 }
 
@@ -303,7 +277,7 @@ fn entries(
     num_entries: u32,
     object_hash: gix_hash::Kind,
     version: Version,
-) -> Result<(EntriesOutcome, &[u8]), Error> {
+) -> ExnResult<(EntriesOutcome, &[u8])> {
     let mut entries = vec_with_capacity(num_entries as usize)?;
     let mut path_backing = vec_with_capacity(path_backing_buffer_size)?;
     entries::chunk(
@@ -356,9 +330,13 @@ pub(crate) fn stat(data: &[u8]) -> Option<(entry::Stat, &[u8])> {
     ))
 }
 
-fn ensure_in_alloc_limit(size: usize, alloc_limit_bytes: Option<usize>) -> Result<(), Error> {
+fn ensure_in_alloc_limit(size: usize, alloc_limit_bytes: Option<usize>) -> ExnResult {
     if alloc_limit_bytes.is_some_and(|limit| size > limit) {
-        return Err(Error::OutOfMemory);
+        return Err(allocation_error(ResourceExhaustionKind::AllocationLimit));
     }
     Ok(())
 }
+
+fn allocation_error(kind: ResourceExhaustionKind) -> gix_error::Exn {
+    resource_exhaustion(kind, "Index data would require more memory than can be reserved").raise_erased()
+}
diff --git a/gix-index/src/extension/decode.rs b/gix-index/src/extension/decode.rs
index 5367373bc30..9fcff9ebf92 100644
--- a/gix-index/src/extension/decode.rs
+++ b/gix-index/src/extension/decode.rs
@@ -1,4 +1,5 @@
 use crate::{extension, extension::Signature, util::from_be_u32};
+use gix_error::ExnMessageResult;
 
 pub(crate) fn header(data: &[u8]) -> (Signature, u32, &[u8]) {
     let (signature, data) = data.split_at(4);
@@ -6,29 +7,13 @@ pub(crate) fn header(data: &[u8]) -> (Signature, u32, &[u8]) {
     (signature.try_into().unwrap(), from_be_u32(size), data)
 }
 
-mod error {
-    use crate::extension;
-
-    /// The error returned when decoding extensions.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(
-            "Encountered mandatory extension '{}' which isn't implemented yet",
-            String::from_utf8_lossy(signature)
-        )]
-        MandatoryUnimplemented { signature: extension::Signature },
-        #[error("Could not parse mandatory link extension")]
-        Link(#[from] extension::link::decode::Error),
-    }
-}
-pub use error::Error;
-
 pub(crate) fn all(
     maybe_beginning_of_extensions: &[u8],
     object_hash: gix_hash::Kind,
     alloc_limit_bytes: Option<usize>,
-) -> Result<(Outcome, &[u8]), Error> {
+) -> ExnMessageResult<(Outcome, &[u8])> {
+    use gix_error::{ErrorExt, ResultExt, message};
+
     let mut ext_iter = match extension::Iter::new_without_checksum(maybe_beginning_of_extensions, object_hash) {
         Some(iter) => iter,
         None => return Ok((Outcome::default(), maybe_beginning_of_extensions)),
@@ -56,15 +41,29 @@ pub(crate) fn all(
                 ext.offset_table = true;
             } // not relevant/obtained already
             mandatory if mandatory[0].is_ascii_lowercase() => match mandatory {
-                extension::link::SIGNATURE => ext.link = extension::link::decode(ext_data, object_hash)?.into(),
+                extension::link::SIGNATURE => {
+                    ext.link = extension::link::decode(ext_data, object_hash)
+                        .or_raise(|| message("Could not parse mandatory link extension"))?
+                        .into();
+                }
                 extension::sparse::SIGNATURE => {
                     if !ext_data.is_empty() {
                         // only used as a marker, if this changes we need this implementation.
-                        return Err(Error::MandatoryUnimplemented { signature: mandatory });
+                        return Err(message!(
+                            "Encountered mandatory extension '{}' which isn't implemented yet",
+                            String::from_utf8_lossy(&mandatory)
+                        )
+                        .raise());
                     }
                     ext.is_sparse = true;
                 }
-                unknown => return Err(Error::MandatoryUnimplemented { signature: unknown }),
+                unknown => {
+                    return Err(message!(
+                        "Encountered mandatory extension '{}' which isn't implemented yet",
+                        String::from_utf8_lossy(&unknown)
+                    )
+                    .raise());
+                }
             },
             _unknown => {} // skip unknown extensions, too
         }
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 a827388f191..5085dd28dab 100644
--- a/gix-index/src/extension/end_of_index_entry/decode.rs
+++ b/gix-index/src/extension/end_of_index_entry/decode.rs
@@ -4,6 +4,7 @@ use crate::{
     extension::end_of_index_entry::{MIN_SIZE, MIN_SIZE_WITH_HEADER, SIGNATURE},
     util::from_be_u32,
 };
+use gix_error::ExnMessageResult;
 
 /// Decode the end of index entry extension, which is no more than a glorified offset to the first byte of all extensions to allow
 /// loading entries and extensions in parallel.
@@ -13,7 +14,7 @@ use crate::{
 /// stored prior to this one to assure they are correct.
 ///
 /// If the checksum wasn't matched, we will ignore this extension entirely.
-pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Option<usize>, gix_hash::hasher::Error> {
+pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> ExnMessageResult<Option<usize>> {
     let hash_len = object_hash.len_in_bytes();
     if data.len() < MIN_SIZE_WITH_HEADER + hash_len {
         return Ok(None);
diff --git a/gix-index/src/extension/end_of_index_entry/write.rs b/gix-index/src/extension/end_of_index_entry/write.rs
index 3adece3dc75..5c85862abd4 100644
--- a/gix-index/src/extension/end_of_index_entry/write.rs
+++ b/gix-index/src/extension/end_of_index_entry/write.rs
@@ -1,4 +1,5 @@
 use crate::extension::{Signature, end_of_index_entry::SIGNATURE};
+use gix_error::ExnResult;
 
 /// Write this extension to out and generate a hash of `object_hash` over all `prior_extensions` which are specified as `(signature, size)`
 /// pair. `one_past_entries` is the offset to the first byte past the entries, which is also the first byte of the signature of the
@@ -11,7 +12,7 @@ pub fn write_to(
     object_hash: gix_hash::Kind,
     offset_to_extensions: u32,
     prior_extensions: impl IntoIterator<Item = (Signature, u32)>,
-) -> Result<(), gix_hash::io::Error> {
+) -> ExnResult {
     out.write_all(&SIGNATURE).map_err(gix_hash::io::from_std_io)?;
     let extension_size: u32 = 4 + object_hash.len_in_bytes() as u32;
     out.write_all(&extension_size.to_be_bytes())
diff --git a/gix-index/src/extension/link.rs b/gix-index/src/extension/link.rs
index 463e37e9f04..92e85ed802d 100644
--- a/gix-index/src/extension/link.rs
+++ b/gix-index/src/extension/link.rs
@@ -1,4 +1,5 @@
 use crate::extension::{Link, Signature};
+use gix_error::{ExnMessageResult, ExnResult};
 
 /// The signature of the link extension.
 pub const SIGNATURE: Signature = *b"link";
@@ -12,35 +13,12 @@ pub struct Bitmaps {
     pub replace: gix_bitmap::ewah::Vec,
 }
 
-///
-pub mod decode {
-
-    /// The error returned when decoding link extensions.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("{0}")]
-        Corrupt(&'static str),
-        #[error("{kind} bitmap corrupt")]
-        BitmapDecode {
-            err: gix_bitmap::ewah::decode::Error,
-            kind: &'static str,
-        },
-    }
-
-    impl From<std::num::TryFromIntError> for Error {
-        fn from(_: std::num::TryFromIntError) -> Self {
-            Self::Corrupt("error in bitmap iteration trying to convert from u64 to usize")
-        }
-    }
-}
+pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> ExnMessageResult<Link> {
+    use gix_error::{ErrorExt, OptionExt, ResultExt};
 
-pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Link, decode::Error> {
     let (id, data) = data
         .split_at_checked(object_hash.len_in_bytes())
-        .ok_or(decode::Error::Corrupt(
-            "link extension too short to read share index checksum",
-        ))
+        .ok_or_raise(|| gix_error::corruption("link extension too short to read share index checksum"))
         .map(|(id, d)| (gix_hash::ObjectId::from_bytes_or_panic(id), d))?;
 
     if data.is_empty() {
@@ -50,13 +28,12 @@ pub(crate) fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Link, d
         });
     }
 
-    let (delete, data) =
-        gix_bitmap::ewah::decode(data).map_err(|err| decode::Error::BitmapDecode { kind: "delete", err })?;
+    let (delete, data) = gix_bitmap::ewah::decode(data).or_raise(|| gix_error::corruption("delete bitmap corrupt"))?;
     let (replace, data) =
-        gix_bitmap::ewah::decode(data).map_err(|err| decode::Error::BitmapDecode { kind: "replace", err })?;
+        gix_bitmap::ewah::decode(data).or_raise(|| gix_error::corruption("replace bitmap corrupt"))?;
 
     if !data.is_empty() {
-        return Err(decode::Error::Corrupt("garbage trailing link extension"));
+        return Err(gix_error::corruption("garbage trailing link extension").raise());
     }
 
     Ok(Link {
@@ -72,7 +49,10 @@ impl Link {
         object_hash: gix_hash::Kind,
         skip_hash: bool,
         options: crate::decode::Options,
-    ) -> Result<(), crate::file::init::Error> {
+    ) -> ExnResult {
+        use gix_error::ErrorExt;
+
+        let corrupt = |message| gix_error::corruption(message).raise_erased();
         let shared_index_path = split_index
             .path
             .parent()
@@ -96,29 +76,29 @@ impl Link {
                 let shared_entry = match shared_index.entries.get_mut(replace_index) {
                     Some(e) => e,
                     None => {
-                        err = decode::Error::Corrupt("replace bitmap length exceeds shared index length - more entries in bitmap than found in shared index").into();
+                        err = Some(corrupt("replace bitmap length exceeds shared index length - more entries in bitmap than found in shared index"));
                         return None
                     }
                 };
 
                 if shared_entry.flags.contains(crate::entry::Flags::REMOVE) {
-                    err = decode::Error::Corrupt("entry is marked as both replace and delete").into();
+                    err = Some(corrupt("entry is marked as both replace and delete"));
                     return None
                 }
 
                 let split_entry = match split_index.entries.get(split_entry_index) {
                     Some(e) => e,
                     None => {
-                        err = decode::Error::Corrupt("replace bitmap length exceeds split index length - more entries in bitmap than found in split index").into();
+                        err = Some(corrupt("replace bitmap length exceeds split index length - more entries in bitmap than found in split index"));
                         return None
                     }
                 };
                 if !split_entry.path.is_empty() {
-                    err = decode::Error::Corrupt("paths in split index entries that are for replacement should be empty").into();
+                    err = Some(corrupt("paths in split index entries that are for replacement should be empty"));
                     return None
                 }
                 if shared_entry.path.is_empty() {
-                    err = decode::Error::Corrupt("paths in shared index entries that are replaced should not be empty").into();
+                    err = Some(corrupt("paths in shared index entries that are replaced should not be empty"));
                     return None
                 }
                 shared_entry.stat = split_entry.stat;
@@ -129,10 +109,10 @@ impl Link {
                 split_entry_index += 1;
                 Some(())
             }).is_none() && err.is_none() {
-                err = decode::Error::Corrupt("replace bitmap is malformed").into();
+                err = Some(corrupt("replace bitmap is malformed"));
             }
             if let Some(err) = err {
-                return Err(err.into());
+                return Err(err);
             }
 
             let split_index_path_backing = std::mem::take(&mut split_index.path_backing);
@@ -152,17 +132,17 @@ impl Link {
                 let shared_entry = match shared_index.entries.get_mut(delete_index) {
                     Some(e) => e,
                     None => {
-                        err = decode::Error::Corrupt("delete bitmap length exceeds shared index length - more entries in bitmap than found in shared index").into();
+                        err = Some(corrupt("delete bitmap length exceeds shared index length - more entries in bitmap than found in shared index"));
                         return None
                     }
                 };
                 shared_entry.flags.insert(crate::entry::Flags::REMOVE);
                 Some(())
             }).is_none() && err.is_none() {
-                err = decode::Error::Corrupt("delete bitmap is malformed").into();
+                err = Some(corrupt("delete bitmap is malformed"));
             }
             if let Some(err) = err {
-                return Err(err.into());
+                return Err(err);
             }
 
             shared_index
diff --git a/gix-index/src/extension/tree/verify.rs b/gix-index/src/extension/tree/verify.rs
index 5ae094a5c75..600f63b86b3 100644
--- a/gix-index/src/extension/tree/verify.rs
+++ b/gix-index/src/extension/tree/verify.rs
@@ -1,105 +1,70 @@
 use std::cmp::Ordering;
 
-use bstr::{BString, ByteSlice};
+use bstr::ByteSlice;
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt};
 use gix_object::FindExt;
 
 use crate::extension::Tree;
 
-/// The error returned by [`Tree::verify()`][crate::extension::Tree::verify()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(
-        "The entry {entry_id} at path '{name}' in parent tree {parent_id} wasn't found in the nodes children, making it incomplete"
-    )]
-    MissingTreeDirectory {
-        parent_id: gix_hash::ObjectId,
-        entry_id: gix_hash::ObjectId,
-        name: BString,
-    },
-    #[error(transparent)]
-    TreeNodeNotFound(#[from] gix_object::find::existing_iter::Error),
-    #[error(
-        "The tree with id {oid} should have {expected_childcount} children, but its cached representation had {actual_childcount} of them"
-    )]
-    TreeNodeChildcountMismatch {
-        oid: gix_hash::ObjectId,
-        expected_childcount: usize,
-        actual_childcount: usize,
-    },
-    #[error("The root tree was named '{name}', even though it should be empty")]
-    RootWithName { name: BString },
-    #[error(
-        "Expected not more than {expected} entries to be reachable from the top-level, but actual count was {actual}"
-    )]
-    EntriesCount { actual: u32, expected: u32 },
-    #[error("The combined TREE entry count exceeds the supported maximum")]
-    EntriesCountOverflow,
-    #[error("TREE entry '{name}' declared {actual} entries, but the index only contains {expected} entries")]
-    EntriesCountExceedsIndex {
-        name: BString,
-        actual: u32,
-        expected: usize,
-    },
-    #[error(
-        "Parent tree '{parent_id}' contained out-of order trees prev = '{previous_path}' and next = '{current_path}'"
-    )]
-    OutOfOrder {
-        parent_id: gix_hash::ObjectId,
-        current_path: BString,
-        previous_path: BString,
-    },
-}
-
 impl Tree {
     /// Validate the correctness of this instance. If `use_objects` is true, then `objects` will be used to access all objects.
-    pub fn verify(&self, use_objects: bool, objects: impl gix_object::Find) -> Result<(), Error> {
+    pub fn verify(&self, use_objects: bool, objects: impl gix_object::Find) -> ExnMessageResult {
         fn verify_recursive(
             parent_id: gix_hash::ObjectId,
             children: &[Tree],
             mut object_buf: Option<&mut Vec<u8>>,
             objects: &impl gix_object::Find,
-        ) -> Result<Option<u32>, Error> {
+        ) -> ExnMessageResult<Option<u32>> {
             if children.is_empty() {
                 return Ok(None);
             }
             let mut entries = 0u32;
             let mut prev = None::<&Tree>;
             for child in children {
-                entries = entries
-                    .checked_add(child.num_entries.unwrap_or(0))
-                    .ok_or(Error::EntriesCountOverflow)?;
+                entries = entries.checked_add(child.num_entries.unwrap_or(0)).ok_or_else(|| {
+                    gix_error::corruption("The combined TREE entry count exceeds the supported maximum").raise()
+                })?;
                 if let Some(prev) = prev
                     && prev.name.cmp(&child.name) != Ordering::Less
                 {
-                    return Err(Error::OutOfOrder {
-                        parent_id,
-                        previous_path: prev.name.as_bstr().into(),
-                        current_path: child.name.as_bstr().into(),
-                    });
+                    return Err(gix_error::corruption(format!(
+                        "Parent tree '{parent_id}' contained out-of order trees prev = '{}' and next = '{}'",
+                        prev.name.as_bstr(),
+                        child.name.as_bstr()
+                    ))
+                    .raise());
                 }
                 prev = Some(child);
             }
             if let Some(buf) = object_buf.as_mut() {
-                let tree_entries = objects.find_tree_iter(&parent_id, buf)?;
+                let tree_entries = objects
+                    .find_tree_iter(&parent_id, buf)
+                    .or_raise(|| gix_error::corruption("Tree node could not be found"))?;
                 let mut num_entries = 0;
-                for entry in tree_entries.filter_map(Result::ok).filter(|e| e.mode.is_tree()) {
+                for entry in tree_entries {
+                    let entry = entry
+                        .or_raise(|| gix_error::corruption(format!("Could not decode an entry in tree {parent_id}")))?;
+                    if !entry.mode.is_tree() {
+                        continue;
+                    }
                     children
                         .binary_search_by(|e| e.name.as_bstr().cmp(entry.filename))
-                        .map_err(|_| Error::MissingTreeDirectory {
-                            parent_id,
-                            entry_id: entry.oid.to_owned(),
-                            name: entry.filename.to_owned(),
+                        .map_err(|position| {
+                            gix_error::corruption(format!(
+                                "The entry {} at path '{}' in parent tree {parent_id} wasn't found at child position {position}, making it incomplete",
+                                entry.oid, entry.filename
+                            ))
+                            .raise()
                         })?;
                     num_entries += 1;
                 }
 
                 if num_entries != children.len() {
-                    return Err(Error::TreeNodeChildcountMismatch {
-                        oid: parent_id,
-                        expected_childcount: num_entries,
-                        actual_childcount: children.len(),
-                    });
+                    return Err(gix_error::corruption(format!(
+                        "The tree with id {parent_id} should have {num_entries} children, but its cached representation had {} of them",
+                        children.len()
+                    ))
+                    .raise());
                 }
             }
             for child in children {
@@ -109,10 +74,10 @@ impl Tree {
                 if let Some((actual, num_entries)) = actual_num_entries.zip(child.num_entries)
                     && actual > num_entries
                 {
-                    return Err(Error::EntriesCount {
-                        actual,
-                        expected: num_entries,
-                    });
+                    return Err(gix_error::corruption(format!(
+                        "Expected not more than {num_entries} entries to be reachable from the top-level, but actual count was {actual}"
+                    ))
+                    .raise());
                 }
             }
             Ok(entries.into())
@@ -120,9 +85,11 @@ impl Tree {
         let _span = gix_features::trace::coarse!("gix_index::extension::Tree::verify()");
 
         if !self.name.is_empty() {
-            return Err(Error::RootWithName {
-                name: self.name.as_bstr().into(),
-            });
+            return Err(gix_error::corruption(format!(
+                "The root tree was named '{}', even though it should be empty",
+                self.name.as_bstr()
+            ))
+            .raise());
         }
 
         let mut buf = Vec::new();
@@ -130,10 +97,10 @@ impl Tree {
         if let Some((actual, num_entries)) = declared_entries.zip(self.num_entries)
             && actual > num_entries
         {
-            return Err(Error::EntriesCount {
-                actual,
-                expected: num_entries,
-            });
+            return Err(gix_error::corruption(format!(
+                "Expected not more than {num_entries} entries to be reachable from the top-level, but actual count was {actual}"
+            ))
+            .raise());
         }
 
         Ok(())
@@ -143,15 +110,15 @@ impl Tree {
     ///
     /// This is a cheap heuristic: it doesn't prove each cached subtree count matches its actual path range,
     /// but no TREE node can describe more entries than the entire index contains.
-    pub(crate) fn verify_entries_count(&self, num_index_entries: usize) -> Result<(), Error> {
+    pub(crate) fn verify_entries_count(&self, num_index_entries: usize) -> ExnMessageResult {
         if let Some(actual) = self.num_entries
             && actual as usize > num_index_entries
         {
-            return Err(Error::EntriesCountExceedsIndex {
-                name: self.name.as_bstr().into(),
-                actual,
-                expected: num_index_entries,
-            });
+            return Err(gix_error::corruption(format!(
+                "TREE entry '{}' declared {actual} entries, but the index only contains {num_index_entries} entries",
+                self.name.as_bstr()
+            ))
+            .raise());
         }
 
         for child in &self.children {
@@ -161,3 +128,49 @@ impl Tree {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Tree;
+    use gix_error::ExnResult;
+
+    struct MalformedTree;
+
+    impl gix_object::Find for MalformedTree {
+        fn try_find<'a>(
+            &self,
+            _id: &gix_hash::oid,
+            _buffer: &'a mut Vec<u8>,
+        ) -> ExnResult<Option<gix_object::Data<'a>>> {
+            Ok(Some(gix_object::Data::new(
+                b"40000 child\0",
+                gix_object::Kind::Tree,
+                gix_hash::Kind::Sha1,
+            )))
+        }
+    }
+
+    #[test]
+    fn malformed_object_tree_entries_are_not_ignored() {
+        let root_id = gix_hash::Kind::Sha1.null();
+        let tree = Tree {
+            name: Default::default(),
+            id: root_id,
+            num_entries: Some(1),
+            children: vec![Tree {
+                name: b"child".as_slice().into(),
+                id: root_id,
+                num_entries: Some(0),
+                children: Vec::new(),
+            }],
+        };
+
+        let err = tree.verify(true, MalformedTree).expect_err("malformed entry must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "malformed object tree entries are not ignored", @"
+        Could not decode an entry in tree Oid(1)
+        |
+        └─ object parsing failed
+        ");
+        assert!(err.is_validation());
+    }
+}
diff --git a/gix-index/src/extension/tree/write.rs b/gix-index/src/extension/tree/write.rs
index 9341cb7e752..d47c80ddbfa 100644
--- a/gix-index/src/extension/tree/write.rs
+++ b/gix-index/src/extension/tree/write.rs
@@ -1,4 +1,5 @@
 use crate::extension::{Tree, tree};
+use gix_error::{ResultExt, corruption};
 
 impl Tree {
     /// Serialize this instance to `out`.
@@ -40,7 +41,8 @@ impl Tree {
         out.write_all(&signature)?;
         out.write_all(
             &u32::try_from(entries.len())
-                .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidData, "tree extension exceeds 4GB"))?
+                .or_raise(|| corruption("tree extension exceeds 4GB"))
+                .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err.into_error()))?
                 .to_be_bytes(),
         )?;
         out.write_all(&entries)?;
diff --git a/gix-index/src/file/init.rs b/gix-index/src/file/init.rs
index 13f58f420ca..ccc535114e3 100644
--- a/gix-index/src/file/init.rs
+++ b/gix-index/src/file/init.rs
@@ -2,24 +2,30 @@
 
 use std::path::{Path, PathBuf};
 
+use gix_error::{ExnResult, ResultExt, message};
+
 use crate::{File, State, decode, extension};
 
-mod error {
+/// A failure to open an index file, retaining its path to distinguish primary and shared indexes.
+#[derive(Debug)]
+pub struct OpenError {
+    /// The index path that could not be opened.
+    pub path: PathBuf,
+    /// The underlying I/O error.
+    pub source: std::io::Error,
+}
 
-    /// The error returned by [File::at()][super::File::at()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An IO error occurred while opening the index")]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        Decode(#[from] crate::decode::Error),
-        #[error(transparent)]
-        LinkExtension(#[from] crate::extension::link::decode::Error),
+impl std::fmt::Display for OpenError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Could not open index file at '{}'", self.path.display())
     }
 }
 
-pub use error::Error;
+impl std::error::Error for OpenError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.source)
+    }
+}
 
 /// Initialization
 impl File {
@@ -27,17 +33,21 @@ impl File {
     /// index that merely exists in memory and is empty. `skip_hash` will increase the performance by a factor of 2, at the cost of
     /// possibly not detecting corruption.
     ///
-    /// Note that the `path` will not be written if it doesn't exist.
+    /// Note that the `path` will not be written if it doesn't exist. A missing shared index remains an error.
     pub fn at_or_default(
         path: impl Into<PathBuf>,
         object_hash: gix_hash::Kind,
         skip_hash: bool,
         options: decode::Options,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         let path = path.into();
         Ok(match Self::at(&path, object_hash, skip_hash, options) {
             Ok(f) => f,
-            Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
+            Err(err)
+                if err
+                    .downcast_any_ref::<OpenError>()
+                    .is_some_and(|err| err.path == path && err.source.kind() == std::io::ErrorKind::NotFound) =>
+            {
                 File::from_state(State::new(object_hash), path)
             }
             Err(err) => return Err(err),
@@ -55,14 +65,20 @@ impl File {
         object_hash: gix_hash::Kind,
         skip_hash: bool,
         options: decode::Options,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         let _span = gix_features::trace::detail!("gix_index::File::at()");
         let path = path.into();
         let (data, mtime) = {
-            let mut file = std::fs::File::open(&path)?;
+            let mut file = std::fs::File::open(&path)
+                .map_err(|source| OpenError {
+                    path: path.clone(),
+                    source,
+                })
+                .or_erased()?;
             // SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.
             #[expect(unsafe_code)]
-            let data = unsafe { memmap2::MmapOptions::new().map_copy_read_only(&file)? };
+            let data = unsafe { memmap2::MmapOptions::new().map_copy_read_only(&file) }
+                .or_raise_erased(|| message("An IO error occurred while opening the index"))?;
 
             // Let the decoder report truncated files before trying to read their checksum.
             if !skip_hash && data.len() >= object_hash.len_in_bytes() {
@@ -74,7 +90,9 @@ impl File {
                     gix_hash::ObjectId::from_bytes_or_panic(&data[data.len() - object_hash.len_in_bytes()..]);
                 if !expected.is_null() {
                     let _span = gix_features::trace::detail!("gix::open_index::hash_index", path = ?path);
-                    let meta = file.metadata()?;
+                    let meta = file
+                        .metadata()
+                        .or_raise_erased(|| message("An IO error occurred while opening the index"))?;
                     let num_bytes_to_hash = meta.len() - object_hash.len_in_bytes() as u64;
                     gix_hash::bytes(
                         &mut file,
@@ -83,18 +101,20 @@ impl File {
                         &mut gix_features::progress::Discard,
                         &Default::default(),
                     )
-                    .map_err(
-                        |err| match err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind) {
-                            Some(kind) => Error::Io(std::io::Error::new(kind, err.into_error())),
-                            None => Error::Decode(decode::Error::Hasher(std::io::Error::other(err.into_error()))),
-                        },
-                    )?
+                    .or_raise_erased(|| message("Could not hash index data"))?
                     .verify(&expected)
-                    .map_err(decode::Error::from)?;
+                    .or_raise_erased(|| message("Shared index checksum mismatch"))?;
                 }
             }
 
-            (data, filetime::FileTime::from_last_modification_time(&file.metadata()?))
+            (
+                data,
+                filetime::FileTime::from_last_modification_time(
+                    &file
+                        .metadata()
+                        .or_raise_erased(|| message("An IO error occurred while opening the index"))?,
+                ),
+            )
         };
 
         let (state, checksum) = State::from_bytes(&data, mtime, object_hash, options)?;
diff --git a/gix-index/src/file/verify.rs b/gix-index/src/file/verify.rs
index 5e1a17a8d7e..b59c003ecd9 100644
--- a/gix-index/src/file/verify.rs
+++ b/gix-index/src/file/verify.rs
@@ -1,33 +1,22 @@
 use std::sync::atomic::AtomicBool;
 
-use crate::File;
-
-mod error {
-    /// The error returned by [File::verify_integrity()][super::File::verify_integrity()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not read index file to generate hash")]
-        Io(#[from] std::io::Error),
-        #[error("Index checksum mismatch")]
-        Verify(#[from] gix_hash::verify::Error),
-    }
-}
-pub use error::Error;
+use gix_error::ExnMessageResult;
 
-impl From<gix_hash::io::Error> for Error {
-    fn from(err: gix_hash::io::Error) -> Self {
-        Error::Io(std::io::Error::other(err.into_error()))
-    }
-}
+use crate::File;
 
 impl File {
     /// Verify the integrity of the index to assure its consistency.
-    pub fn verify_integrity(&self) -> Result<(), Error> {
+    pub fn verify_integrity(&self) -> ExnMessageResult {
+        use gix_error::{ResultExt, message};
+
         let _span = gix_features::trace::coarse!("gix_index::File::verify_integrity()");
         if let Some(checksum) = self.checksum {
-            let num_bytes_to_hash =
-                self.path.metadata().map_err(gix_hash::io::from_std_io)?.len() - checksum.as_bytes().len() as u64;
+            let num_bytes_to_hash = self
+                .path
+                .metadata()
+                .or_raise(|| message("Could not read index file to generate hash"))?
+                .len()
+                - checksum.as_bytes().len() as u64;
             let should_interrupt = AtomicBool::new(false);
             gix_hash::bytes_of_file(
                 &self.path,
@@ -35,8 +24,10 @@ impl File {
                 checksum.kind(),
                 &mut gix_features::progress::Discard,
                 &should_interrupt,
-            )?
-            .verify(&checksum)?;
+            )
+            .or_raise(|| message("Could not read index file to generate hash"))?
+            .verify(&checksum)
+            .or_raise(|| message("Index checksum mismatch"))?;
         }
         Ok(())
     }
diff --git a/gix-index/src/file/write.rs b/gix-index/src/file/write.rs
index c5faaa28e32..9d90caefad4 100644
--- a/gix-index/src/file/write.rs
+++ b/gix-index/src/file/write.rs
@@ -1,22 +1,5 @@
 use crate::{File, Version, write};
-
-/// The error produced by [`File::write()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-    #[error("Could not acquire lock for index file")]
-    AcquireLock(#[source] std::io::Error),
-    #[error("Could not commit lock for index file")]
-    CommitLock(#[from] gix_lock::commit::Error<gix_lock::File>),
-}
-
-impl From<gix_hash::io::Error> for Error {
-    fn from(err: gix_hash::io::Error) -> Self {
-        Error::Io(std::io::Error::other(err.into_error()))
-    }
-}
+use gix_error::{ExnMessageResult, ExnResult};
 
 impl File {
     /// Write the index to `out` with `options`, to be readable by [`File::at()`], returning the version that was actually written
@@ -29,7 +12,7 @@ impl File {
         &self,
         mut out: impl std::io::Write,
         options: write::Options,
-    ) -> Result<(Version, gix_hash::ObjectId), gix_hash::io::Error> {
+    ) -> ExnResult<(Version, gix_hash::ObjectId)> {
         let _span = gix_features::trace::detail!("gix_index::File::write_to()", skip_hash = options.skip_hash);
         let (version, hash) = if options.skip_hash {
             let out: &mut dyn std::io::Write = &mut out;
@@ -70,17 +53,27 @@ impl File {
     /// ```
     ///
     /// [issue #2421]: https://github.com/GitoxideLabs/gitoxide/issues/2421
-    pub fn write(&mut self, options: write::Options) -> Result<(), Error> {
+    pub fn write(&mut self, options: write::Options) -> ExnMessageResult {
+        use gix_error::{ErrorExt, ResultExt, message};
+
         let _span = gix_features::trace::detail!("gix_index::File::write()", path = ?self.path);
         let mut lock = std::io::BufWriter::with_capacity(
             64 * 1024,
             gix_lock::File::acquire_to_update_resource(&self.path, gix_lock::acquire::Fail::Immediately, None)
-                .map_err(|err| Error::AcquireLock(std::io::Error::other(err.into_error())))?,
+                .or_raise(|| message("Could not acquire lock for index file"))?,
         );
-        let (version, digest) = self.write_to(&mut lock, options)?;
+        let (version, digest) = self
+            .write_to(&mut lock, options)
+            .or_raise(|| message("Could not write index"))?;
         match lock.into_inner() {
-            Ok(lock) => lock.commit()?,
-            Err(err) => return Err(Error::Io(err.into_error())),
+            Ok(lock) => lock
+                .commit()
+                .or_raise(|| message("Could not commit lock for index file"))?,
+            Err(err) => {
+                return Err(err
+                    .into_error()
+                    .and_raise(message("Could not flush buffered index data")));
+            }
         };
         self.state.version = version;
         self.checksum = Some(digest);
diff --git a/gix-index/src/init.rs b/gix-index/src/init.rs
index ad52a892aac..7ce85b41eb0 100644
--- a/gix-index/src/init.rs
+++ b/gix-index/src/init.rs
@@ -3,6 +3,7 @@ pub mod from_tree {
     use std::collections::VecDeque;
 
     use bstr::{BStr, BString, ByteSlice, ByteVec};
+    use gix_error::{ErrorExt, ExnResult, ResultExt, message, validation};
     use gix_object::{tree, tree::EntryKind};
     use gix_traverse::tree::{Visit, depthfirst, visit::Action};
 
@@ -11,19 +12,6 @@ pub mod from_tree {
         entry::{Flags, Mode, Stat},
     };
 
-    /// The error returned by [State::from_tree()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The path \"{path}\" is invalid")]
-        InvalidComponent {
-            path: BString,
-            source: gix_validate::path::component::Error,
-        },
-        #[error(transparent)]
-        Traversal(#[from] gix_traverse::tree::depthfirst::Error),
-    }
-
     /// Initialization
     impl State {
         /// Return a new and empty in-memory index assuming the given `object_hash`.
@@ -64,23 +52,20 @@ pub mod from_tree {
             tree: &gix_hash::oid,
             objects: Find,
             validate: gix_validate::path::component::Options,
-        ) -> Result<Self, Error>
+        ) -> ExnResult<Self>
         where
             Find: gix_object::Find,
         {
             let _span = gix_features::trace::coarse!("gix_index::State::from_tree()");
             let mut delegate = CollectEntries::new(validate);
-            match depthfirst(tree.to_owned(), depthfirst::State::default(), &objects, &mut delegate) {
-                Ok(()) => {}
-                Err(gix_traverse::tree::breadthfirst::Error::Cancelled) => {
-                    let (path, err) = delegate
-                        .invalid_path
-                        .take()
-                        .expect("cancellation only happens on validation error");
-                    return Err(Error::InvalidComponent { path, source: err });
-                }
-                Err(err) => return Err(err.into()),
+            let traversal = depthfirst(tree.to_owned(), depthfirst::State::default(), &objects, &mut delegate);
+
+            if let Some((path, err)) = delegate.invalid_path.take() {
+                return Err(err
+                    .and_raise(validation(format!("The path \"{path}\" is invalid")))
+                    .erased());
             }
+            traversal.or_raise_erased(|| message("Tree traversal failed"))?;
 
             let CollectEntries {
                 entries,
@@ -88,13 +73,9 @@ pub mod from_tree {
                 path: _,
                 path_deque: _,
                 validate: _,
-                invalid_path,
+                invalid_path: _,
             } = delegate;
 
-            if let Some((path, err)) = invalid_path {
-                return Err(Error::InvalidComponent { path, source: err });
-            }
-
             Ok(State {
                 object_hash: tree.kind(),
                 timestamp: filetime::FileTime::now(),
diff --git a/gix-index/src/verify.rs b/gix-index/src/verify.rs
index 03be4cbe08c..1a5496deefb 100644
--- a/gix-index/src/verify.rs
+++ b/gix-index/src/verify.rs
@@ -1,57 +1,28 @@
 use std::cmp::Ordering;
 
-use crate::State;
-
-///
-pub mod entries {
-    use bstr::BString;
-
-    /// The error returned by [`State::verify_entries()`][crate::State::verify_entries()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(
-            "Entry '{current_path}' (stage = {current_stage}) at index {current_index} should order after prior entry '{previous_path}' (stage = {previous_stage})"
-        )]
-        OutOfOrder {
-            current_index: usize,
-            current_path: BString,
-            current_stage: u8,
-            previous_path: BString,
-            previous_stage: u8,
-        },
-    }
-}
+use gix_error::ExnMessageResult;
 
-///
-pub mod extensions {
-    use crate::extension;
-
-    /// The error returned by [`State::verify_extensions()`][crate::State::verify_extensions()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Tree(#[from] extension::tree::verify::Error),
-    }
-}
+use crate::State;
 
 impl State {
     /// Assure our entries are consistent.
-    pub fn verify_entries(&self) -> Result<(), entries::Error> {
+    pub fn verify_entries(&self) -> ExnMessageResult {
+        use gix_error::ErrorExt;
+
         let _span = gix_features::trace::coarse!("gix_index::File::verify_entries()");
         let mut previous = None::<&crate::Entry>;
         for (idx, entry) in self.entries.iter().enumerate() {
             if let Some(prev) = previous
                 && prev.cmp(entry, self) != Ordering::Less
             {
-                return Err(entries::Error::OutOfOrder {
-                    current_index: idx,
-                    current_path: entry.path(self).into(),
-                    current_stage: entry.flags.stage() as u8,
-                    previous_path: prev.path(self).into(),
-                    previous_stage: prev.flags.stage() as u8,
-                });
+                return Err(gix_error::corruption(format!(
+                    "Entry '{}' (stage = {}) at index {idx} should order after prior entry '{}' (stage = {})",
+                    entry.path(self),
+                    entry.flags.stage() as u8,
+                    prev.path(self),
+                    prev.flags.stage() as u8
+                ))
+                .raise());
             }
             previous = Some(entry);
         }
@@ -59,7 +30,7 @@ impl State {
     }
 
     /// Note: `objects` cannot be `Option<F>` as we can't call it with a closure then due to the indirection through `Some`.
-    pub fn verify_extensions(&self, use_find: bool, objects: impl gix_object::Find) -> Result<(), extensions::Error> {
+    pub fn verify_extensions(&self, use_find: bool, objects: impl gix_object::Find) -> ExnMessageResult {
         if let Some(tree) = self.tree() {
             tree.verify(use_find, objects)?;
             tree.verify_entries_count(self.entries.len())?;
diff --git a/gix-index/src/write.rs b/gix-index/src/write.rs
index 03c12981d15..810fe65a4d9 100644
--- a/gix-index/src/write.rs
+++ b/gix-index/src/write.rs
@@ -1,5 +1,7 @@
 use std::io::Write;
 
+use gix_error::ExnResult;
+
 use crate::{State, Version, entry, extension, write::util::CountBytes};
 
 /// A way to specify which of the optional extensions to write.
@@ -71,7 +73,7 @@ impl State {
             extensions,
             skip_hash: _,
         }: Options,
-    ) -> Result<Version, gix_hash::io::Error> {
+    ) -> ExnResult<Version> {
         let _span = gix_features::trace::detail!("gix_index::State::write()");
         let version = self.detect_required_version();
 
diff --git a/gix-index/tests/index/file/access.rs b/gix-index/tests/index/file/access.rs
index d7216bf7c59..7d0353bb9b5 100644
--- a/gix-index/tests/index/file/access.rs
+++ b/gix-index/tests/index/file/access.rs
@@ -1,8 +1,9 @@
 mod set_path {
+    use crate::Result;
     use crate::file::read;
 
     #[test]
-    fn future_writes_respect_the_newly_set_path() -> crate::Result {
+    fn future_writes_respect_the_newly_set_path() -> Result {
         let mut file = read::file("v4_more_files_IEOT");
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let new_index_path = tmp.path().join("new-index");
diff --git a/gix-index/tests/index/file/fuzzed.rs b/gix-index/tests/index/file/fuzzed.rs
index 3716843faa8..7cbc6da8fe1 100644
--- a/gix-index/tests/index/file/fuzzed.rs
+++ b/gix-index/tests/index/file/fuzzed.rs
@@ -77,13 +77,8 @@ fn tree_extension_with_large_entry_count_is_reported_without_panicking_while_wri
         Some(547345820),
         "bogus entries are still present"
     );
-    assert_eq!(
-        file.verify_extensions(false, gix_object::find::Never)
-            .unwrap_err()
-            .to_string(),
-        "TREE entry '' declared 547345820 entries, but the index only contains 0 entries",
-        "verifying extension can catch it though."
-    );
+    insta::assert_debug_snapshot!(file.verify_extensions(false, gix_object::find::Never)
+            .expect_err("verifying extension can catch it though."), "verifying extension can catch it though.", @"TREE entry '' declared 547345820 entries, but the index only contains 0 entries");
     let mut out = Vec::new();
     assert!(
         file.write_to(&mut out, Default::default()).is_ok(),
@@ -101,13 +96,9 @@ fn tree_extension_with_overflowing_child_entry_counts_is_rejected_without_panick
     )
     .expect("fuzzed input should decode before verification");
 
-    assert_eq!(
-        state
+    insta::assert_debug_snapshot!(state
             .verify_extensions(false, gix_object::find::Never)
-            .expect_err("overflowing TREE entry counts must be rejected")
-            .to_string(),
-        "The combined TREE entry count exceeds the supported maximum"
-    );
+            .expect_err("overflowing TREE entry counts must be rejected"), "tree extension with overflowing child entry counts is rejected without panicking", @"The combined TREE entry count exceeds the supported maximum");
 }
 
 #[test]
diff --git a/gix-index/tests/index/file/init.rs b/gix-index/tests/index/file/init.rs
index 7c757f8bf5c..66f362d3079 100644
--- a/gix-index/tests/index/file/init.rs
+++ b/gix-index/tests/index/file/init.rs
@@ -1,6 +1,7 @@
 mod at {
     #[test]
     fn shorter_than_checksum() -> gix_testtools::Result {
+        let mut error_snapshots = Vec::new();
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let path = tmp.path().join("index");
         for object_hash in [gix_hash::Kind::Sha1, gix_hash::Kind::Sha256] {
@@ -11,19 +12,23 @@ mod at {
                         .expect_err("an index shorter than its checksum must be rejected without panicking");
                     // Some platforms cannot memory-map an empty file and return an IO error instead.
                     if len != 0 {
+                        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
                         assert!(
-                            matches!(
-                                err,
-                                gix_index::file::init::Error::Decode(gix_index::decode::Error::Header(
-                                    gix_index::decode::header::Error::Corrupt(_)
-                                ))
-                            ),
+                            err.is_corrupted(),
                             "expected a corrupt header for {object_hash:?}, {len} bytes, skip_hash={skip_hash}: {err}"
                         );
                     }
                 }
             }
         }
+        insta::assert_debug_snapshot!(error_snapshots, "shorter than checksum", @"
+        [
+            File is too small even for header with zero entries and smallest hash,
+            File is too small even for header with zero entries and smallest hash,
+            File is too small even for header with zero entries and smallest hash,
+            File is too small even for header with zero entries and smallest hash,
+        ]
+        ");
         Ok(())
     }
 }
@@ -42,6 +47,24 @@ mod at_or_new {
         .expect("file exists and can be opened");
     }
 
+    #[test]
+    fn missing_shared_index_is_an_error() -> gix_testtools::Result {
+        let tmp = gix_testtools::tempfile::TempDir::new()?;
+        let index_path = tmp.path().join("index");
+        // Keep the primary split index, but leave its shared index behind.
+        std::fs::copy(Generated("v2_split_index").to_path(), &index_path)?;
+
+        let err = gix_index::File::at_or_default(index_path, gix_testtools::object_hash(), false, Default::default())
+            .expect_err("a missing shared index must not produce an empty index");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(tmp.path()).to_string_lossy(), "<index-dir>")]), "the missing-file cause is preserved", @"
+        Could not open index file at '<index-dir>/sharedindex.Oid(1)'
+        |
+        └─ NotFound
+        ");
+        assert!(err.is_not_found(), "the missing-file cause is preserved");
+        Ok(())
+    }
+
     #[test]
     fn create_empty_in_memory_state_if_file_does_not_exist() {
         let index = gix_index::File::at_or_default(
diff --git a/gix-index/tests/index/file/read.rs b/gix-index/tests/index/file/read.rs
index 82c12bb5c3e..a8d13cddb06 100644
--- a/gix-index/tests/index/file/read.rs
+++ b/gix-index/tests/index/file/read.rs
@@ -1,5 +1,7 @@
 use std::path::{Path, PathBuf};
 
+use gix_error::ExnResult;
+
 use bstr::ByteSlice;
 use gix_index::{
     Version,
@@ -22,7 +24,7 @@ pub(crate) fn loose_file(name: &str) -> gix_index::File {
     verify(file)
 }
 
-pub(crate) fn try_file(name: &str, needs_archive: bool) -> Result<gix_index::File, gix_index::file::init::Error> {
+pub(crate) fn try_file(name: &str, needs_archive: bool) -> ExnResult<gix_index::File> {
     let path = if needs_archive {
         crate::fixture_index_path_needs_archive(name)
     } else {
@@ -689,10 +691,12 @@ fn v2_split_index() {
 #[test]
 fn v2_split_index_recursion_is_handled_gracefully() {
     let err = try_file("v2_split_index_recursive", false).expect_err("recursion fails gracefully");
-    assert!(matches!(
-        err,
-        gix_index::file::init::Error::Decode(gix_index::decode::Error::Verify(_))
-    ));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "v2 split index recursion is handled gracefully", @"
+    Shared index checksum mismatch
+    |
+    └─ Hash was Oid(1), but should have been Oid(2)
+    ");
+    assert!(err.is_corrupted());
 }
 
 #[test]
diff --git a/gix-index/tests/index/file/write.rs b/gix-index/tests/index/file/write.rs
index d612b82b2b5..3198bdbaf7d 100644
--- a/gix-index/tests/index/file/write.rs
+++ b/gix-index/tests/index/file/write.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use filetime::FileTime;
 use gix_index::{State, Version, entry, extension, write, write::Options};
 
@@ -5,7 +6,7 @@ use crate::Fixture::*;
 
 /// Round-trips should eventually be possible for all files we have, as we write them back exactly as they were read.
 #[test]
-fn roundtrips() -> crate::Result {
+fn roundtrips() -> Result {
     let input = [
         (Loose("extended-flags"), only_tree_ext()),
         (Loose("conflicting-file"), only_tree_ext()),
@@ -48,7 +49,7 @@ fn roundtrips() -> crate::Result {
 }
 
 #[test]
-fn skip_hash() -> crate::Result {
+fn skip_hash() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let path = tmp.path().join("index");
     let mut expected = Loose("conflicting-file").open();
@@ -89,7 +90,7 @@ fn skip_hash() -> crate::Result {
 }
 
 #[test]
-fn roundtrips_sparse_index() -> crate::Result {
+fn roundtrips_sparse_index() -> Result {
     // NOTE: I initially tried putting these fixtures into the main roundtrip test above,
     // but the call to `compare_raw_bytes` panics. It seems like git is using a different
     // ordering when it comes to writing the tree extension. Need to investigate more, hence
@@ -189,7 +190,7 @@ fn state_comparisons_with_various_extension_configurations() {
 }
 
 #[test]
-fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> crate::Result {
+fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> Result {
     let mut expected = Generated("v2").open();
     assert_eq!(expected.version(), Version::V2);
     expected.entries_mut()[0].flags.insert(entry::Flags::EXTENDED);
@@ -202,7 +203,7 @@ fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> crat
 }
 
 #[test]
-fn remove_flag_is_respected() -> crate::Result {
+fn remove_flag_is_respected() -> Result {
     let mut index = Generated("v4_more_files_IEOT").open();
     let total_entries = 10;
     assert_eq!(index.entries().len(), total_entries);
diff --git a/gix-index/tests/index/fs.rs b/gix-index/tests/index/fs.rs
index 77dd8e6678a..1469bd15784 100644
--- a/gix-index/tests/index/fs.rs
+++ b/gix-index/tests/index/fs.rs
@@ -1,8 +1,9 @@
 mod metadata {
+    use crate::Result;
     use gix_index::fs::Metadata;
 
     #[test]
-    fn from_path_no_follow() -> crate::Result {
+    fn from_path_no_follow() -> Result {
         let root = crate::scripted_fixture_read_only("file_metadata.sh")?;
 
         // For now, don't assert on the values of the metadata as these depends on the filesystem,
diff --git a/gix-index/tests/index/fuzzed.rs b/gix-index/tests/index/fuzzed.rs
index 0183c161814..3d87c49e05a 100644
--- a/gix-index/tests/index/fuzzed.rs
+++ b/gix-index/tests/index/fuzzed.rs
@@ -1,7 +1,8 @@
 use filetime::FileTime;
+use gix_error::ExnResult;
 use std::path::PathBuf;
 
-fn decode_fuzzed(data: &[u8]) -> Result<(gix_index::State, Option<gix_hash::ObjectId>), gix_index::decode::Error> {
+fn decode_fuzzed(data: &[u8]) -> ExnResult<(gix_index::State, Option<gix_hash::ObjectId>)> {
     gix_index::State::from_bytes(
         data,
         FileTime::from_unix_time(0, 0),
@@ -29,11 +30,7 @@ fn impossible_v4_entry_count_is_rejected_before_reserving() {
     ))
     .expect_err("fuzzed input must stay rejected");
 
-    assert!(
-        err.to_string()
-            .contains("Declared entry count exceeds possible entries for file size"),
-        "{err:?}"
-    );
+    insta::assert_debug_snapshot!(err, "the entry count cannot fit into the available index bytes", @"Declared entry count exceeds possible entries for file size");
 }
 
 #[test]
@@ -44,8 +41,10 @@ fn malformed_tree_extension_is_ignored_instead_of_panicking() {
         Ok((state, _checksum)) => {
             assert!(state.tree().is_none(), "malformed optional extension must be ignored");
         }
-        Err(gix_index::decode::Error::UnexpectedTrailerLength { .. }) => {}
-        Err(err) => panic!("unexpected decode failure: {err:?}"),
+        Err(err) => {
+            assert!(err.is_corrupted(), "a truncated index trailer is corruption");
+            insta::assert_debug_snapshot!(err, "the fixture can also be rejected for its truncated index trailer", @"Index trailer should have been 20 bytes long, but was 64");
+        }
     }
 }
 
@@ -86,8 +85,10 @@ fn impossible_untracked_cache_directory_counts_are_rejected_before_reserving() {
                 "malformed optional extension must be ignored"
             );
         }
-        Err(gix_index::decode::Error::UnexpectedTrailerLength { .. }) => {}
-        Err(err) => panic!("unexpected decode failure: {err:?}"),
+        Err(err) => {
+            assert!(err.is_corrupted(), "a truncated index trailer is corruption");
+            insta::assert_debug_snapshot!(err, "the fixture can also be rejected for its truncated index trailer", @"Index trailer should have been 20 bytes long, but was 26");
+        }
     }
 }
 
@@ -98,7 +99,8 @@ fn malformed_entry_padding_is_rejected_instead_of_panicking() {
     ))
     .expect_err("fuzzed input must stay rejected");
 
-    assert!(matches!(err, gix_index::decode::Error::Entry { .. }), "{err:?}");
+    assert!(err.is_corrupted(), "invalid entries are corrupt index data");
+    insta::assert_debug_snapshot!(err, "malformed index entries identify the failed parser", @"Could not parse entry at index 1");
 }
 
 #[test]
@@ -112,8 +114,10 @@ fn malformed_untracked_cache_bitmap_is_rejected_instead_of_panicking() {
                 "malformed optional extension must be ignored"
             );
         }
-        Err(gix_index::decode::Error::UnexpectedTrailerLength { .. }) => {}
-        Err(err) => panic!("unexpected decode failure: {err:?}"),
+        Err(err) => {
+            assert!(err.is_corrupted(), "a truncated index trailer is corruption");
+            insta::assert_debug_snapshot!(err, "the fixture can also be rejected for its truncated index trailer", @"Index trailer should have been 20 bytes long, but was 51");
+        }
     }
 }
 
@@ -124,7 +128,8 @@ fn malformed_entry_padding_with_untracked_cache_is_rejected_instead_of_panicking
     ))
     .expect_err("fuzzed input must stay rejected");
 
-    assert!(matches!(err, gix_index::decode::Error::Entry { .. }), "{err:?}");
+    assert!(err.is_corrupted(), "invalid entries are corrupt index data");
+    insta::assert_debug_snapshot!(err, "malformed index entries identify the failed parser", @"Could not parse entry at index 1");
 }
 
 #[test]
@@ -141,7 +146,16 @@ fn alloc_limit_constructor_rejects_oversized_allocations() {
     )
     .expect_err("fixture should exceed tiny allocation limit");
 
-    assert!(matches!(err, gix_index::decode::Error::OutOfMemory), "{err:?}");
+    insta::assert_debug_snapshot!(err, "alloc limit constructor rejects oversized allocations", @"Index data would require more memory than can be reserved");
+    assert!(
+        err.classify().any(|classification| {
+            classification.class()
+                == gix_error::Class::ResourceExhaustion(gix_error::ResourceExhaustionKind::AllocationLimit)
+        }),
+        "configured limits are resource exhaustion, not malformed input"
+    );
+    assert!(!err.is_corrupted(), "configured limits aren't corruption");
+    assert!(!err.can_retry(), "configured limits can't be fixed by retrying");
 }
 
 fn artifact_paths(target: &str) -> Vec<PathBuf> {
diff --git a/gix-index/tests/index/init.rs b/gix-index/tests/index/init.rs
index 0f46a8693c4..b141fd82c51 100644
--- a/gix-index/tests/index/init.rs
+++ b/gix-index/tests/index/init.rs
@@ -1,10 +1,11 @@
-use std::{error::Error, path::Path};
+use crate::Result;
+use std::path::Path;
 
 use crate::{odb_at, scripted_fixture_read_only};
 use gix_index::State;
 
 #[test]
-fn from_tree() -> crate::Result {
+fn from_tree() -> Result {
     let fixtures = [
         "make_index/v2.sh",
         "make_index/v2_more_files.sh",
@@ -33,7 +34,10 @@ fn from_tree() -> crate::Result {
 }
 
 #[test]
-fn from_tree_validation() -> crate::Result {
+fn from_tree_validation() -> Result {
+    let mut error_snapshots = Vec::new();
+    use gix_index::validate::path::component::Error;
+
     let root = scripted_fixture_read_only("make_traverse_literal_separators.sh")?;
     for repo_name in [
         "traverse_dotdot_slashes",
@@ -46,18 +50,40 @@ fn from_tree_validation() -> crate::Result {
         let git_dir = worktree_dir.join(".git");
         let odb = odb_at(git_dir.join("objects"))?;
 
-        let err = State::from_tree(&tree_id, &odb, Default::default()).unwrap_err();
-        assert_eq!(
-            err.source().expect("inner").to_string(),
-            r"Path separators like / or \ are not allowed",
-            r"Note that this effectively tests what would happen on Windows, where \ also isn't allowed"
+        let err = State::from_tree(&tree_id, &odb, Default::default())
+            .expect_err("tree entries with path separators must fail validation");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "invalid path components are validation errors");
+        assert!(
+            matches!(err.downcast_any_ref::<Error>(), Some(Error::PathSeparator)),
+            "the concrete path-separator violation remains available beneath the index context"
+        );
+        assert!(
+            matches!(err.probable_cause().downcast_ref::<Error>(), Some(Error::PathSeparator)),
+            "conversion selects the concrete path violation rather than its classification marker"
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "from tree validation", @r#"
+    [
+        The path "../outside" is invalid
+        |
+        └─ Path separators like / or \ are not allowed,
+        The path ".git/hooks/pre-commit" is invalid
+        |
+        └─ Path separators like / or \ are not allowed,
+        The path ".git\hooks\pre-commit" is invalid
+        |
+        └─ Path separators like / or \ are not allowed,
+        The path "..\outside" is invalid
+        |
+        └─ Path separators like / or \ are not allowed,
+    ]
+    "#);
     Ok(())
 }
 
 #[test]
-fn from_tree_returns_file_directory_conflicts_until_fixed() -> crate::Result {
+fn from_tree_returns_file_directory_conflicts_until_fixed() -> Result {
     let worktree_dir = scripted_fixture_read_only("make_symlink_prefix_reuse_advisory.sh")?;
     let tree_id = tree_id(&worktree_dir);
     let odb = odb_at(worktree_dir.join(".git").join("objects"))?;
diff --git a/gix-lock/Cargo.toml b/gix-lock/Cargo.toml
index 1c4a1af3519..4ffa5d726aa 100644
--- a/gix-lock/Cargo.toml
+++ b/gix-lock/Cargo.toml
@@ -21,4 +21,6 @@ gix-utils = { version = "^0.3.5", default-features = false, path = "../gix-utils
 gix-tempfile = { version = "^24.0.0", default-features = false, path = "../gix-tempfile" }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = { version = "1.46.3", features = ["filters"] }
 tempfile = "3.26.0"
diff --git a/gix-lock/src/acquire.rs b/gix-lock/src/acquire.rs
index a860b66b4a3..fd7d7257a98 100644
--- a/gix-lock/src/acquire.rs
+++ b/gix-lock/src/acquire.rs
@@ -4,7 +4,7 @@ use std::{
     time::Duration,
 };
 
-use gix_error::{ErrorExt, ResultExt, RetryableError, message};
+use gix_error::{Class, ClassificationMarker, ErrorExt, ExnResult, ResultExt, message};
 use gix_tempfile::{AutoRemove, ContainingDirectory};
 
 use crate::{DOT_LOCK_SUFFIX, File, Marker, backoff};
@@ -41,9 +41,6 @@ impl From<Duration> for Fail {
     }
 }
 
-/// The error returned when acquiring a [`File`] or [`Marker`].
-pub type Error = gix_error::Exn;
-
 impl File {
     /// Create a writable lock file with failure `mode` whose content will eventually overwrite the given resource `at_path`.
     ///
@@ -71,7 +68,7 @@ impl File {
         boundary_directory: Option<PathBuf>,
         resolve_resource: Option<&dyn Fn(&Path) -> PathBuf>,
         adjust_permissions: Option<&dyn Fn(std::fs::Permissions) -> std::fs::Permissions>,
-    ) -> Result<File, Error> {
+    ) -> ExnResult<File> {
         let resolve_resource = resolve_resource.unwrap_or(&keep_resource);
         let (resource_path, lock_path, handle) = lock_with_mode(
             at_path.as_ref(),
@@ -106,7 +103,7 @@ impl File {
         at_path: impl AsRef<Path>,
         mode: Fail,
         boundary_directory: Option<PathBuf>,
-    ) -> Result<File, Error> {
+    ) -> ExnResult<File> {
         Self::acquire(at_path, mode, boundary_directory, None, None)
     }
 
@@ -116,7 +113,7 @@ impl File {
         mode: Fail,
         boundary_directory: Option<PathBuf>,
         make_permissions: impl Fn() -> std::fs::Permissions,
-    ) -> Result<File, Error> {
+    ) -> ExnResult<File> {
         let (resource_path, lock_path, handle) = lock_with_mode(
             at_path.as_ref(),
             mode,
@@ -137,7 +134,7 @@ impl File {
         at_path: impl AsRef<Path>,
         mode: Fail,
         boundary_directory: Option<PathBuf>,
-    ) -> Result<File, Error> {
+    ) -> ExnResult<File> {
         Self::acquire(at_path, mode, boundary_directory, Some(&resolve_symlink), None)
     }
 
@@ -148,7 +145,7 @@ impl File {
         mode: Fail,
         boundary_directory: Option<PathBuf>,
         adjust_permissions: impl Fn(std::fs::Permissions) -> std::fs::Permissions,
-    ) -> Result<File, Error> {
+    ) -> ExnResult<File> {
         Self::acquire(
             at_path,
             mode,
@@ -177,7 +174,7 @@ impl Marker {
         at_path: impl AsRef<Path>,
         mode: Fail,
         boundary_directory: Option<PathBuf>,
-    ) -> Result<Marker, Error> {
+    ) -> ExnResult<Marker> {
         let (resource_path, lock_path, handle) = lock_with_mode(
             at_path.as_ref(),
             mode,
@@ -205,7 +202,7 @@ impl Marker {
         mode: Fail,
         boundary_directory: Option<PathBuf>,
         make_permissions: impl Fn() -> std::fs::Permissions,
-    ) -> Result<Marker, Error> {
+    ) -> ExnResult<Marker> {
         let (resource_path, lock_path, handle) = lock_with_mode(
             at_path.as_ref(),
             mode,
@@ -261,7 +258,7 @@ fn lock_with_mode<T>(
     boundary_directory: Option<PathBuf>,
     resolve_resource: &dyn Fn(&Path) -> PathBuf,
     try_lock: &dyn Fn(&Path, ContainingDirectory, AutoRemove) -> std::io::Result<T>,
-) -> Result<(PathBuf, PathBuf, T), Error> {
+) -> ExnResult<(PathBuf, PathBuf, T)> {
     use std::io::ErrorKind::*;
     let io_error = |err: std::io::Error| {
         err.and_raise(message("Another IO error occurred while obtaining the lock"))
@@ -301,7 +298,7 @@ fn lock_with_mode<T>(
         }
     }
     .map_err(|(err, resource_path)| match err.kind() {
-        AlreadyExists => RetryableError::new(err)
+        AlreadyExists => ClassificationMarker::with_source(Class::Retryable, err)
             .and_raise(message!(
                 "The lock for resource '{resource}' could not be obtained {mode} after {attempts} attempt(s). The lockfile at '{resource}{suffix}' might need manual deletion.",
                 resource = resource_path.display(),
diff --git a/gix-lock/tests/all.rs b/gix-lock/tests/all.rs
index 6a4ac2180d7..4f8a6a16513 100644
--- a/gix-lock/tests/all.rs
+++ b/gix-lock/tests/all.rs
@@ -1,3 +1 @@
-type Result<T = ()> = std::result::Result<T, gix_error::TestError>;
-
 mod lock;
diff --git a/gix-lock/tests/lock/file.rs b/gix-lock/tests/lock/file.rs
index 68d16502521..9b0d246f56c 100644
--- a/gix-lock/tests/lock/file.rs
+++ b/gix-lock/tests/lock/file.rs
@@ -5,7 +5,7 @@ mod close {
     use gix_lock::acquire::Fail;
 
     #[test]
-    fn acquire_close_commit_to_existing_file() -> crate::Result {
+    fn acquire_close_commit_to_existing_file() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("resource-existing.ext");
         std::fs::write(&resource, b"old state")?;
@@ -31,7 +31,7 @@ mod commit {
     use gix_lock::acquire::Fail;
 
     #[test]
-    fn failure_to_commit_does_return_a_registered_marker() -> crate::Result {
+    fn failure_to_commit_does_return_a_registered_marker() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("resource-existing.ext");
         std::fs::create_dir(&resource)?;
@@ -53,7 +53,7 @@ mod commit {
     }
 
     #[test]
-    fn failure_to_commit_does_return_a_registered_file() -> crate::Result {
+    fn failure_to_commit_does_return_a_registered_file() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("resource-existing.ext");
         std::fs::create_dir(&resource)?;
@@ -96,7 +96,7 @@ mod acquire {
     }
 
     #[test]
-    fn lock_create_dir_write_commit() -> crate::Result {
+    fn lock_create_dir_write_commit() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("a").join("resource-nonexisting");
         let resource_lock = resource.with_extension("lock");
@@ -127,7 +127,7 @@ mod acquire {
     }
 
     #[test]
-    fn lock_write_drop() -> crate::Result {
+    fn lock_write_drop() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("resource-nonexisting.ext");
         {
@@ -140,7 +140,7 @@ mod acquire {
 
     #[test]
     #[cfg(unix)]
-    fn lock_following_symlinks_writes_their_target() -> crate::Result {
+    fn lock_following_symlinks_writes_their_target() -> gix_error::TestResult {
         use std::os::unix::fs::symlink;
 
         let dir = tempfile::tempdir()?;
@@ -164,7 +164,7 @@ mod acquire {
 
     #[test]
     #[cfg(unix)]
-    fn lock_permissions_can_be_adjusted_after_applying_the_umask() -> crate::Result {
+    fn lock_permissions_can_be_adjusted_after_applying_the_umask() -> gix_error::TestResult {
         use std::{cell::Cell, os::unix::fs::PermissionsExt};
 
         let dir = tempfile::tempdir()?;
@@ -192,7 +192,7 @@ mod acquire {
     }
 
     #[test]
-    fn resource_path_does_not_parse_the_lock_file_name() -> crate::Result {
+    fn resource_path_does_not_parse_the_lock_file_name() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource_dir = dir.path().join("resource");
         std::fs::create_dir(&resource_dir)?;
@@ -208,11 +208,18 @@ mod acquire {
     }
 
     #[test]
-    fn lock_non_existing_dir_fails() -> crate::Result {
+    fn lock_non_existing_dir_fails() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("a").join("resource.ext");
         let err = gix_lock::File::acquire_to_update_resource(&resource, fail_immediately(), None)
             .expect_err("the containing directory does not exist");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&dir.path().join("a").join("resource.ext.lock").to_string_lossy(), "<root>/a/resource.ext.lock")]), "the original I/O error is retained", @r#"
+        Another IO error occurred while obtaining the lock
+        |
+        └─ I/O error (NotFound)
+        |
+        └─ NotFound at path "<root>/a/resource.ext.lock"
+        "#);
         assert_eq!(
             err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind),
             Some(ErrorKind::NotFound),
diff --git a/gix-lock/tests/lock/marker.rs b/gix-lock/tests/lock/marker.rs
index 7da61a3bad3..00f0c13d49d 100644
--- a/gix-lock/tests/lock/marker.rs
+++ b/gix-lock/tests/lock/marker.rs
@@ -4,7 +4,7 @@ mod acquire {
     use gix_lock::acquire::Fail;
 
     #[test]
-    fn fail_mode_immediately_produces_a_descriptive_error() -> crate::Result {
+    fn fail_mode_immediately_produces_a_descriptive_error() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("the-resource");
         let guard = gix_lock::Marker::acquire_to_hold_resource(&resource, Fail::Immediately, None)?;
@@ -12,37 +12,40 @@ mod acquire {
         assert!(guard.resource_path().ends_with("the-resource"));
         let err = gix_lock::Marker::acquire_to_hold_resource(resource, Fail::Immediately, None)
             .expect_err("the lock is taken and there is a failure obtaining it again");
-        assert!(
-            err.downcast_any_ref::<gix_error::RetryableError>().is_some(),
-            "lock contention is retryable"
-        );
-        let err_str = err.to_string();
-
-        assert!(err_str.contains("the-resource' could not be obtained immediately"));
-        assert!(err_str.contains("the-resource.lock"), "it mentions the lockfile itself");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(dir.path()).to_string_lossy(), "<tmp>")]), "lock contention is retryable", @r#"
+        The lock for resource '<tmp>/the-resource' could not be obtained immediately after 1 attempt(s). The lockfile at '<tmp>/the-resource.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<tmp>/the-resource.lock"
+        "#);
+        assert!(err.is_retryable(), "lock contention is retryable");
         Ok(())
     }
 
     #[test]
-    fn fail_mode_after_duration_fails_after_a_given_duration_or_more() -> crate::Result {
+    fn fail_mode_after_duration_fails_after_a_given_duration_or_more() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("the-resource");
         let _guard = gix_lock::Marker::acquire_to_hold_resource(&resource, Fail::Immediately, None)?;
         let start = Instant::now();
         let time_to_wait = Duration::from_millis(50);
-        let err_str =
+        let err =
             gix_lock::Marker::acquire_to_hold_resource(resource, Fail::AfterDurationWithBackoff(time_to_wait), None)
-                .expect_err("the lock is taken and there is a failure obtaining it again after some delay")
-                .to_string();
+                .expect_err("the lock is taken and there is a failure obtaining it again after some delay");
         assert!(
             start.elapsed() >= time_to_wait,
             "it should never wait less than the given wait time"
         );
-        assert!(
-            err_str.contains("could not be obtained after 0.05s"),
-            "it lets us know that we were waiting for some time"
-        );
-        assert!(err_str.contains("the-resource.lock"), "it mentions the lockfile itself");
+        insta::with_settings!({ filters => vec![(r"after \d+ attempt\(s\)", "after <attempts> attempt(s)")] }, {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&dir.path().to_string_lossy(), "<tmp>")]), "lock contention reports the requested wait duration and lockfile", @r#"
+            The lock for resource '<tmp>/the-resource' could not be obtained after 0.05s after <attempts> attempt(s). The lockfile at '<tmp>/the-resource.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<tmp>/the-resource.lock"
+            "#);
+        });
         Ok(())
     }
 }
@@ -71,7 +74,7 @@ mod commit {
     }
 
     #[test]
-    fn fails_for_ordinary_marker_that_was_never_writable() -> crate::Result {
+    fn fails_for_ordinary_marker_that_was_never_writable() -> gix_error::TestResult {
         let dir = tempfile::tempdir()?;
         let resource = dir.path().join("the-resource");
         let mark = gix_lock::Marker::acquire_to_hold_resource(resource, Fail::Immediately, None)?;
@@ -87,10 +90,7 @@ mod commit {
         }
         let err = mark.commit().expect_err("should always fail");
         assert_eq!(err.error.kind(), std::io::ErrorKind::Other);
-        assert_eq!(
-            err.error.get_ref().expect("custom error").to_string(),
-            "refusing to commit marker that was never opened"
-        );
+        insta::assert_debug_snapshot!(err.error.get_ref().expect("custom error"), "fails for ordinary marker that was never writable", @r#""refusing to commit marker that was never opened""#);
         Ok(())
     }
 }
diff --git a/gix-mailmap/Cargo.toml b/gix-mailmap/Cargo.toml
index 06cd2ec74c5..9f84e248b6e 100644
--- a/gix-mailmap/Cargo.toml
+++ b/gix-mailmap/Cargo.toml
@@ -28,7 +28,8 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools" }
+gix-testtools = { path = "../tests/tools", features = ["sha1"] }
+insta = "1.46.3"
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/gix-mailmap/src/lib.rs b/gix-mailmap/src/lib.rs
index d4803159981..ed067dcb8a0 100644
--- a/gix-mailmap/src/lib.rs
+++ b/gix-mailmap/src/lib.rs
@@ -42,6 +42,7 @@ pub mod parse;
 ///
 /// Errors may occur per line, but it's up to the caller to stop iteration when
 /// one is encountered.
+/// Errors include the invalid line or remaining portion as `input` bytes in [metadata](gix_error::Exn::metadata()).
 pub fn parse(buf: &[u8]) -> parse::Lines<'_> {
     parse::Lines::new(buf)
 }
diff --git a/gix-mailmap/src/parse.rs b/gix-mailmap/src/parse.rs
index 8e8f029f896..61de86c1031 100644
--- a/gix-mailmap/src/parse.rs
+++ b/gix-mailmap/src/parse.rs
@@ -1,8 +1,6 @@
-/// The error returned by [`parse()`](crate::parse()).
-pub type Error = gix_error::Exn<gix_error::ValidationError>;
-
 use bstr::{BStr, ByteSlice};
-use gix_error::{ErrorExt, OptionExt, ValidationError};
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, OptionExt, validation};
 
 use crate::Entry;
 
@@ -22,7 +20,7 @@ impl<'a> Lines<'a> {
 }
 
 impl<'a> Iterator for Lines<'a> {
-    type Item = Result<Entry<'a>, Error>;
+    type Item = ExnMessageResult<Entry<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         for line in self.lines.by_ref() {
@@ -42,13 +40,13 @@ impl<'a> Iterator for Lines<'a> {
     }
 }
 
-fn parse_line(line: &BStr, line_number: usize) -> Result<Entry<'_>, Error> {
+fn parse_line(line: &BStr, line_number: usize) -> ExnMessageResult<Entry<'_>> {
     let (name1, email1, rest) = parse_name_and_email(line, line_number, false)?;
     let (name2, email2, _rest) = parse_name_and_email(rest, line_number, true).unwrap_or((None, None, rest));
     if email1.is_none() {
-        return Err(
-            ValidationError::new_with_input(format!("Line {line_number} does not contain an email"), line).raise(),
-        );
+        return Err(validation(format!("Line {line_number} does not contain an email"))
+            .with("input", line)
+            .raise());
     }
     Ok(match (name1, email1, name2, email2) {
         (Some(proper_name), Some(commit_email), None, None) => Entry::change_name_by_email(proper_name, commit_email),
@@ -65,10 +63,10 @@ fn parse_line(line: &BStr, line_number: usize) -> Result<Entry<'_>, Error> {
             Entry::change_email_by_name_and_email(proper_email, commit_name, commit_email)
         }
         _ => {
-            return Err(ValidationError::new_with_input(
-                format!("{line_number}: Emails without a name or email to map to are invalid"),
-                line,
-            )
+            return Err(validation(format!(
+                "{line_number}: Emails without a name or email to map to are invalid"
+            ))
+            .with("input", line)
             .raise());
         }
     })
@@ -78,18 +76,18 @@ fn parse_name_and_email(
     line: &BStr,
     line_number: usize,
     allow_empty_email: bool,
-) -> Result<(Option<&'_ BStr>, Option<&'_ BStr>, &'_ BStr), Error> {
+) -> ExnMessageResult<(Option<&'_ BStr>, Option<&'_ BStr>, &'_ BStr)> {
     match line.find_byte(b'<') {
         Some(start_bracket) => {
             let email = &line[start_bracket + 1..];
             let closing_bracket = email.find_byte(b'>').ok_or_raise(|| {
-                ValidationError::new_with_input(format!("{line_number}: Missing closing bracket '>' in email"), line)
+                validation(format!("{line_number}: Missing closing bracket '>' in email")).with("input", line)
             })?;
             let email = email[..closing_bracket].trim().as_bstr();
             if email.is_empty() && !allow_empty_email {
-                return Err(
-                    ValidationError::new_with_input(format!("{line_number}: Email must not be empty"), line).raise(),
-                );
+                return Err(validation(format!("{line_number}: Email must not be empty"))
+                    .with("input", line)
+                    .raise());
             }
             let name = line[..start_bracket].trim().as_bstr();
             let rest = line[start_bracket + closing_bracket + 2..].as_bstr();
diff --git a/gix-mailmap/tests/parse/mod.rs b/gix-mailmap/tests/parse/mod.rs
index e822f93453d..db5a204d9c2 100644
--- a/gix-mailmap/tests/parse/mod.rs
+++ b/gix-mailmap/tests/parse/mod.rs
@@ -1,4 +1,5 @@
-use gix_mailmap::{Entry, parse};
+use gix_error::ExnMessageResult;
+use gix_mailmap::Entry;
 use gix_testtools::fixture_bytes;
 
 #[test]
@@ -8,12 +9,10 @@ fn line_numbers_are_counted_correctly_in_errors() {
     assert_eq!(actual.len(), 2);
 
     let err = actual.next().expect("two items left").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("3:"), "expected line 3, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "malformed mailmap lines retain their original input and one-based line number", @r#"3: Missing closing bracket '>' in email, "input"="<missing closing brace""#);
 
     let err = actual.next().expect("one item left").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("Line 5"), "expected line 5, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "malformed mailmap lines retain their original input and one-based line number", @r#"Line 5 does not contain an email, "input"="just a name""#);
 }
 
 #[test]
@@ -123,44 +122,35 @@ fn the_second_email_may_be_empty() {
 #[test]
 fn error_if_there_is_just_a_name() {
     let err = try_line("just a name").unwrap_err();
-    let err_str = err.to_string();
-    assert!(
-        err_str.contains("Line 1 does not contain an email"),
-        "expected the missing-email error, got: {err_str}"
-    );
+    insta::assert_debug_snapshot!(err, "a name without an email reports the incomplete identity on line one", @r#"Line 1 does not contain an email, "input"="just a name""#);
 }
 
 #[test]
 fn error_if_there_is_just_an_email() {
     let err = try_line("<email>").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("1:"), "expected line 1, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "an email needs a name or email to map to", @r#"1: Emails without a name or email to map to are invalid, "input"="<email>""#);
 
     let err = try_line("   \t  <email>").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("1:"), "expected line 1, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "an email needs a name or email to map to", @r#"1: Emails without a name or email to map to are invalid, "input"="<email>""#);
 }
 
 #[test]
 fn error_if_email_is_empty() {
     let err = try_line("hello <").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("1:"), "expected line 1, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "an incomplete or empty email identifies the malformed input on line one", @r#"1: Missing closing bracket '>' in email, "input"="hello <""#);
 
     let err = try_line("hello < \t").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("1:"), "expected line 1, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "an incomplete or empty email identifies the malformed input on line one", @r#"1: Missing closing bracket '>' in email, "input"="hello <""#);
 
     let err = try_line("hello < \t\r >").unwrap_err();
-    let err_str = err.to_string();
-    assert!(err_str.contains("1:"), "expected line 1, got: {err_str}");
+    insta::assert_debug_snapshot!(err, "an incomplete or empty email identifies the malformed input on line one", @r#"1: Email must not be empty, "input"="hello < \t\r >""#);
 }
 
 fn line(input: &str) -> Entry<'_> {
     try_line(input).unwrap()
 }
 
-fn try_line(input: &str) -> Result<Entry<'_>, parse::Error> {
+fn try_line(input: &str) -> ExnMessageResult<Entry<'_>> {
     let mut lines = gix_mailmap::parse(input.as_bytes());
     let res = lines.next().expect("single line");
     assert!(lines.next().is_none(), "only one line provided");
diff --git a/gix-merge/Cargo.toml b/gix-merge/Cargo.toml
index a8446a22009..e4b7a55d1fc 100644
--- a/gix-merge/Cargo.toml
+++ b/gix-merge/Cargo.toml
@@ -42,9 +42,9 @@ gix-revision = { version = "^0.49.1", path = "../gix-revision", default-features
 gix-revwalk = { version = "^0.35.0", path = "../gix-revwalk" }
 gix-diff = { version = "^0.67.1", path = "../gix-diff", default-features = false, features = ["blob"] }
 gix-index = { version = "^0.55.0", path = "../gix-index" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 imara-diff = { package = "gix-imara-diff", version = "^0.2.5", path = "../gix-imara-diff" }
 
-thiserror = "2.0.18"
 bstr = { version = "1.12.0", default-features = false }
 nonempty = "0.12.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
@@ -52,6 +52,7 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 criterion = "0.8.2"
 gix-merge = { path = ".", features = ["sha1", "sha256"] }
 gix-testtools = { path = "../tests/tools", features = ["sha1", "sha256"] }
diff --git a/gix-merge/fuzz/Cargo.toml b/gix-merge/fuzz/Cargo.toml
index 736d6d57e7e..ba4117e10fa 100644
--- a/gix-merge/fuzz/Cargo.toml
+++ b/gix-merge/fuzz/Cargo.toml
@@ -14,6 +14,7 @@ libfuzzer-sys = "0.4"
 arbitrary = { version = "1.3.2", features = ["derive"] }
 imara-diff = { package = "gix-imara-diff", version = "0.2.0", path = "../../gix-imara-diff" }
 gix-diff = { path = "../../gix-diff" }
+gix-error = { path = "../../gix-error" }
 gix-filter = { path = "../../gix-filter" }
 gix-hash = { path = "../../gix-hash", features = ["sha1"] }
 gix-merge = { path = "..", features = ["sha1"] }
diff --git a/gix-merge/fuzz/fuzz_targets/tree.rs b/gix-merge/fuzz/fuzz_targets/tree.rs
index 3699ef75862..ca8a2c862d3 100644
--- a/gix-merge/fuzz/fuzz_targets/tree.rs
+++ b/gix-merge/fuzz/fuzz_targets/tree.rs
@@ -3,6 +3,7 @@
 use std::{collections::BTreeMap, path::Path as FsPath};
 
 use gix_diff::Rewrites;
+use gix_error::Class;
 use gix_hash::ObjectId;
 use gix_merge::{
     blob::builtin_driver::binary,
@@ -289,7 +290,13 @@ fn fuzz(data: &[u8]) {
             Ok(outcome) => outcome,
             // Resolving a binary add/add conflict with its absent ancestor cannot
             // produce a resource. This is a valid configuration-dependent error.
-            Err(gix_merge::tree::Error::MergeResourceNotFound) => continue,
+            Err(err)
+                if err
+                    .classify()
+                    .has(Class::Tagged("gix_merge::tree::missing_binary_merge_result")) =>
+            {
+                continue;
+            }
             Err(err) => panic!("generated trees and objects are valid: {err:?}"),
         };
         outcome
diff --git a/gix-merge/src/blob/pipeline.rs b/gix-merge/src/blob/pipeline.rs
index f16bf57a98d..93c5804afb5 100644
--- a/gix-merge/src/blob/pipeline.rs
+++ b/gix-merge/src/blob/pipeline.rs
@@ -3,6 +3,8 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 use gix_filter::{
     driver::apply::{Delay, MaybeDelayed},
@@ -110,36 +112,6 @@ pub enum Data {
     },
 }
 
-///
-pub mod convert_to_mergeable {
-    use std::collections::TryReserveError;
-
-    use bstr::BString;
-    use gix_object::tree::EntryKind;
-
-    /// The error returned by [Pipeline::convert_to_mergeable()](super::Pipeline::convert_to_mergeable()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Entry at '{rela_path}' must be regular file or symlink, but was {actual:?}")]
-        InvalidEntryKind { rela_path: BString, actual: EntryKind },
-        #[error("Entry at '{rela_path}' could not be read as symbolic link")]
-        ReadLink { rela_path: BString, source: std::io::Error },
-        #[error("Entry at '{rela_path}' could not be opened for reading or read from")]
-        OpenOrRead { rela_path: BString, source: std::io::Error },
-        #[error("Entry at '{rela_path}' could not be copied from a filter process to a memory buffer")]
-        StreamCopy { rela_path: BString, source: std::io::Error },
-        #[error(transparent)]
-        FindObject(#[from] gix_object::find::existing_object::Error),
-        #[error(transparent)]
-        ConvertToWorktree(#[from] gix_filter::pipeline::convert::to_worktree::Error),
-        #[error(transparent)]
-        ConvertToGit(#[from] gix_filter::pipeline::convert::to_git::Error),
-        #[error("Memory allocation failed")]
-        OutOfMemory(#[from] TryReserveError),
-    }
-}
-
 /// Conversion
 impl Pipeline {
     /// Convert the object at `id`, `mode`, `rela_path` and `kind`, providing access to `attributes` and `objects`.
@@ -174,12 +146,14 @@ impl Pipeline {
         objects: &dyn gix_object::FindObjectOrHeader,
         convert: Mode,
         out: &mut Vec<u8>,
-    ) -> Result<Option<Data>, convert_to_mergeable::Error> {
+    ) -> ExnResult<Option<Data>> {
+        use gix_error::{ErrorExt, OptionExt, ResultExt, message, not_found};
+
         if !matches!(mode, EntryKind::Blob | EntryKind::BlobExecutable) {
-            return Err(convert_to_mergeable::Error::InvalidEntryKind {
-                rela_path: rela_path.to_owned(),
-                actual: mode,
-            });
+            return Err(gix_error::validation(format!(
+                "Entry at '{rela_path}' must be regular file or symlink, but was {mode:?}"
+            ))
+            .raise_erased());
         }
 
         out.clear();
@@ -190,11 +164,8 @@ impl Pipeline {
                 self.path.push(gix_path::from_bstr(rela_path));
                 let size_in_bytes = (self.options.large_file_threshold_bytes > 0)
                     .then(|| {
-                        none_if_missing(self.path.metadata().map(|md| md.len())).map_err(|err| {
-                            convert_to_mergeable::Error::OpenOrRead {
-                                rela_path: rela_path.to_owned(),
-                                source: err,
-                            }
+                        none_if_missing(self.path.metadata().map(|md| md.len())).or_raise_erased(|| {
+                            message!("Entry at '{rela_path}' could not be opened for reading or read from")
                         })
                     })
                     .transpose()?;
@@ -202,11 +173,8 @@ impl Pipeline {
                     Some(None) => None, // missing as identified by the size check
                     Some(Some(size)) if size > self.options.large_file_threshold_bytes => Some(Data::TooLarge { size }),
                     _ => {
-                        let file = none_if_missing(std::fs::File::open(&self.path)).map_err(|err| {
-                            convert_to_mergeable::Error::OpenOrRead {
-                                rela_path: rela_path.to_owned(),
-                                source: err,
-                            }
+                        let file = none_if_missing(std::fs::File::open(&self.path)).or_raise_erased(|| {
+                            message!("Entry at '{rela_path}' could not be opened for reading or read from")
                         })?;
 
                         if let Some(file) = file {
@@ -227,24 +195,23 @@ impl Pipeline {
 
                                     match res {
                                         ToGitOutcome::Unchanged(mut file) => {
-                                            file.read_to_end(out).map_err(|err| {
-                                                convert_to_mergeable::Error::OpenOrRead {
-                                                    rela_path: rela_path.to_owned(),
-                                                    source: err,
-                                                }
+                                            file.read_to_end(out).or_raise_erased(|| {
+                                                message!(
+                                                    "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                )
                                             })?;
                                         }
                                         ToGitOutcome::Process(mut stream) => {
-                                            stream.read_to_end(out).map_err(|err| {
-                                                convert_to_mergeable::Error::OpenOrRead {
-                                                    rela_path: rela_path.to_owned(),
-                                                    source: err,
-                                                }
+                                            stream.read_to_end(out).or_raise_erased(|| {
+                                                message!(
+                                                    "Entry at '{rela_path}' could not be opened for reading or read from"
+                                                )
                                             })?;
                                         }
                                         ToGitOutcome::Buffer(buf) => {
                                             out.clear();
-                                            out.try_reserve(buf.len())?;
+                                            out.try_reserve(buf.len())
+                                                .or_raise_erased(|| message("Memory allocation failed"))?;
                                             out.extend_from_slice(buf);
                                         }
                                     }
@@ -265,8 +232,8 @@ impl Pipeline {
                 } else {
                     let header = objects
                         .try_header(id)
-                        .map_err(gix_object::find::existing_object::Error::Find)?
-                        .ok_or_else(|| gix_object::find::existing_object::Error::NotFound { oid: id.to_owned() })?;
+                        .or_raise_erased(|| message!("Could not find object header for {id}"))?
+                        .ok_or_raise_erased(|| not_found(format!("An object with id {id} could not be found")))?;
                     let is_binary = self.options.large_file_threshold_bytes > 0
                         && header.size > self.options.large_file_threshold_bytes;
                     let data = if is_binary {
@@ -274,8 +241,8 @@ impl Pipeline {
                     } else {
                         objects
                             .try_find(id, out)
-                            .map_err(gix_object::find::existing_object::Error::Find)?
-                            .ok_or_else(|| gix_object::find::existing_object::Error::NotFound { oid: id.to_owned() })?;
+                            .or_raise_erased(|| message!("Could not find object {id}"))?
+                            .ok_or_raise_erased(|| not_found(format!("An object with id {id} could not be found")))?;
 
                         if convert == Mode::Renormalize {
                             {
@@ -293,15 +260,15 @@ impl Pipeline {
                                     ToWorktreeOutcome::Unchanged(_) => {}
                                     ToWorktreeOutcome::Buffer(src) => {
                                         out.clear();
-                                        out.try_reserve(src.len())?;
+                                        out.try_reserve(src.len())
+                                            .or_raise_erased(|| message("Memory allocation failed"))?;
                                         out.extend_from_slice(src);
                                     }
                                     ToWorktreeOutcome::Process(MaybeDelayed::Immediate(mut stream)) => {
-                                        std::io::copy(&mut stream, out).map_err(|err| {
-                                            convert_to_mergeable::Error::StreamCopy {
-                                                rela_path: rela_path.to_owned(),
-                                                source: err,
-                                            }
+                                        std::io::copy(&mut stream, out).or_raise_erased(|| {
+                                            message!(
+                                                "Entry at '{rela_path}' could not be copied from a filter process to a memory buffer"
+                                            )
                                         })?;
                                     }
                                     ToWorktreeOutcome::Process(MaybeDelayed::Delayed(_)) => {
@@ -320,16 +287,14 @@ impl Pipeline {
                             match res {
                                 ToGitOutcome::Unchanged(_) => {}
                                 ToGitOutcome::Process(mut stream) => {
-                                    stream
-                                        .read_to_end(out)
-                                        .map_err(|err| convert_to_mergeable::Error::OpenOrRead {
-                                            rela_path: rela_path.to_owned(),
-                                            source: err,
-                                        })?;
+                                    stream.read_to_end(out).or_raise_erased(|| {
+                                        message!("Entry at '{rela_path}' could not be opened for reading or read from")
+                                    })?;
                                 }
                                 ToGitOutcome::Buffer(buf) => {
                                     out.clear();
-                                    out.try_reserve(buf.len())?;
+                                    out.try_reserve(buf.len())
+                                        .or_raise_erased(|| message("Memory allocation failed"))?;
                                     out.extend_from_slice(buf);
                                 }
                             }
diff --git a/gix-merge/src/blob/platform/merge.rs b/gix-merge/src/blob/platform/merge.rs
index 2769962c825..36b5992bb3f 100644
--- a/gix-merge/src/blob/platform/merge.rs
+++ b/gix-merge/src/blob/platform/merge.rs
@@ -1,5 +1,7 @@
 use std::{io::Read, path::PathBuf};
 
+use gix_error::ExnMessageResult;
+
 use crate::blob::{PlatformRef, Resolution, builtin_driver};
 
 /// Options for the use in the [`PlatformRef::merge()`] call.
@@ -15,23 +17,6 @@ pub struct Options {
     pub text: builtin_driver::text::Options,
 }
 
-/// The error returned by [`PlatformRef::merge()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    PrepareExternalDriver(#[from] inner::prepare_external_driver::Error),
-    #[error("Failed to launch external merge driver: {cmd}")]
-    SpawnExternalDriver { cmd: String, source: std::io::Error },
-    #[error("External merge driver failed with non-zero exit status {status:?}: {cmd}")]
-    ExternalDriverFailure {
-        status: std::process::ExitStatus,
-        cmd: String,
-    },
-    #[error("IO failed when dealing with merge-driver output")]
-    ExternalDriverIO(#[from] std::io::Error),
-}
-
 /// The product of a [`PlatformRef::prepare_external_driver()`] operation.
 ///
 /// This type allows to creation of [`std::process::Command`], ready to run, with `stderr` and `stdout` set to *inherit*,
@@ -66,6 +51,8 @@ pub(super) mod inner {
             process::Stdio,
         };
 
+        use gix_error::ExnResult;
+
         use bstr::{BString, ByteVec};
         use gix_tempfile::{AutoRemove, ContainingDirectory};
 
@@ -75,30 +62,6 @@ pub(super) mod inner {
             platform::{DriverChoice, merge},
         };
 
-        /// The error returned by [PlatformRef::prepare_external_driver()](PlatformRef::prepare_external_driver()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("The resource of kind {kind:?} was too large to be processed")]
-            ResourceTooLarge { kind: ResourceKind },
-            #[error(
-                "Tempfile to store content of '{rela_path}' ({kind:?}) for passing to external merge command could not be created"
-            )]
-            CreateTempfile {
-                rela_path: BString,
-                kind: ResourceKind,
-                source: std::io::Error,
-            },
-            #[error(
-                "Could not write content of '{rela_path}' ({kind:?}) to tempfile for passing to external merge command"
-            )]
-            WriteTempfile {
-                rela_path: BString,
-                kind: ResourceKind,
-                source: std::io::Error,
-            },
-        }
-
         /// Plumbing
         impl<'parent> PlatformRef<'parent> {
             /// Given `merge_command` and `context`, typically obtained from git-configuration, and the currently set merge-resources,
@@ -124,7 +87,9 @@ pub(super) mod inner {
                     other,
                 }: builtin_driver::text::Labels<'_>,
                 context: gix_command::Context,
-            ) -> Result<merge::Command, Error> {
+            ) -> ExnResult<merge::Command> {
+                use gix_error::{OptionExt, ResultExt, message, validation};
+
                 fn write_data(
                     data: &[u8],
                     directory: &Path,
@@ -139,14 +104,23 @@ pub(super) mod inner {
                     Ok((file, path))
                 }
 
-                let base = self.ancestor.data.as_slice().ok_or(Error::ResourceTooLarge {
-                    kind: ResourceKind::CommonAncestorOrBase,
+                let base = self.ancestor.data.as_slice().ok_or_raise_erased(|| {
+                    validation(format!(
+                        "The resource of kind {:?} was too large to be processed",
+                        ResourceKind::CommonAncestorOrBase
+                    ))
                 })?;
-                let ours = self.current.data.as_slice().ok_or(Error::ResourceTooLarge {
-                    kind: ResourceKind::CurrentOrOurs,
+                let ours = self.current.data.as_slice().ok_or_raise_erased(|| {
+                    validation(format!(
+                        "The resource of kind {:?} was too large to be processed",
+                        ResourceKind::CurrentOrOurs
+                    ))
                 })?;
-                let theirs = self.other.data.as_slice().ok_or(Error::ResourceTooLarge {
-                    kind: ResourceKind::OtherOrTheirs,
+                let theirs = self.other.data.as_slice().ok_or_raise_erased(|| {
+                    validation(format!(
+                        "The resource of kind {:?} was too large to be processed",
+                        ResourceKind::OtherOrTheirs
+                    ))
                 })?;
 
                 let tmp_dir = context
@@ -154,20 +128,26 @@ pub(super) mod inner {
                     .as_deref()
                     .or(context.git_dir.as_deref())
                     .unwrap_or(Path::new(""));
-                let (base_tmp, base_path) = write_data(base, tmp_dir).map_err(|err| Error::CreateTempfile {
-                    rela_path: self.ancestor.rela_path.into(),
-                    kind: ResourceKind::CommonAncestorOrBase,
-                    source: err,
+                let (base_tmp, base_path) = write_data(base, tmp_dir).or_raise_erased(|| {
+                    message!(
+                        "Tempfile to store content of '{}' ({:?}) for passing to external merge command could not be created",
+                        self.ancestor.rela_path,
+                        ResourceKind::CommonAncestorOrBase
+                    )
                 })?;
-                let (ours_tmp, ours_path) = write_data(ours, tmp_dir).map_err(|err| Error::CreateTempfile {
-                    rela_path: self.current.rela_path.into(),
-                    kind: ResourceKind::CurrentOrOurs,
-                    source: err,
+                let (ours_tmp, ours_path) = write_data(ours, tmp_dir).or_raise_erased(|| {
+                    message!(
+                        "Tempfile to store content of '{}' ({:?}) for passing to external merge command could not be created",
+                        self.current.rela_path,
+                        ResourceKind::CurrentOrOurs
+                    )
                 })?;
-                let (theirs_tmp, theirs_path) = write_data(theirs, tmp_dir).map_err(|err| Error::CreateTempfile {
-                    rela_path: self.other.rela_path.into(),
-                    kind: ResourceKind::OtherOrTheirs,
-                    source: err,
+                let (theirs_tmp, theirs_path) = write_data(theirs, tmp_dir).or_raise_erased(|| {
+                    message!(
+                        "Tempfile to store content of '{}' ({:?}) for passing to external merge command could not be created",
+                        self.other.rela_path,
+                        ResourceKind::OtherOrTheirs
+                    )
                 })?;
 
                 let mut cmd = BString::from(Vec::with_capacity(merge_command.len()));
@@ -415,22 +395,29 @@ impl<'parent> PlatformRef<'parent> {
         out: &mut Vec<u8>,
         labels: builtin_driver::text::Labels<'_>,
         context: &gix_command::Context,
-    ) -> Result<(inner::builtin_merge::Pick, Resolution), Error> {
+    ) -> ExnMessageResult<(inner::builtin_merge::Pick, Resolution)> {
+        use gix_error::{ErrorExt, ResultExt, message};
+
         match self.configured_driver() {
             Ok(driver) => {
-                let mut cmd = self.prepare_external_driver(driver.command.clone(), labels, context.clone())?;
-                let status = cmd.status().map_err(|err| Error::SpawnExternalDriver {
-                    cmd: format!("{:?}", cmd.cmd),
-                    source: err,
-                })?;
+                let mut cmd = self
+                    .prepare_external_driver(driver.command.clone(), labels, context.clone())
+                    .or_raise(|| message("Failed to prepare external merge driver"))?;
+                let status = cmd
+                    .status()
+                    .or_raise(|| message!("Failed to launch external merge driver: {:?}", cmd.cmd))?;
                 if !status.success() {
-                    return Err(Error::ExternalDriverFailure {
-                        cmd: format!("{:?}", cmd.cmd),
-                        status,
-                    });
+                    return Err(message!(
+                        "External merge driver failed with non-zero exit status {status:?}: {:?}",
+                        cmd.cmd
+                    )
+                    .raise());
                 }
                 out.clear();
-                cmd.open_result_file()?.read_to_end(out)?;
+                cmd.open_result_file()
+                    .or_raise(|| message("IO failed when dealing with merge-driver output"))?
+                    .read_to_end(out)
+                    .or_raise(|| message("IO failed when dealing with merge-driver output"))?;
                 Ok((inner::builtin_merge::Pick::Buffer, Resolution::Complete))
             }
             Err(builtin) => {
diff --git a/gix-merge/src/blob/platform/prepare_merge.rs b/gix-merge/src/blob/platform/prepare_merge.rs
index 9742b425ca5..a93688a3164 100644
--- a/gix-merge/src/blob/platform/prepare_merge.rs
+++ b/gix-merge/src/blob/platform/prepare_merge.rs
@@ -1,6 +1,7 @@
 use std::{num::NonZeroU8, str::FromStr};
 
-use bstr::{BStr, BString, ByteSlice};
+use bstr::{BStr, ByteSlice};
+use gix_error::{ExnMessageResult, OptionExt, ResultExt, message};
 use gix_filter::attributes;
 
 use crate::blob::{
@@ -9,20 +10,6 @@ use crate::blob::{
     platform::{DriverChoice, ResourceRef, merge},
 };
 
-/// The error returned by [Platform::prepare_merge_state()](Platform::prepare_merge()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("The 'current', 'ancestor' or 'other' resource for the merge operation were not set")]
-    UnsetResource,
-    #[error("Failed to obtain attributes for {kind:?} resource at '{rela_path}'")]
-    Attributes {
-        rela_path: BString,
-        kind: ResourceKind,
-        source: std::io::Error,
-    },
-}
-
 /// Preparation
 impl Platform {
     /// Prepare all state needed for performing a merge, using all [previously set](Self::set_resource()) resources.
@@ -37,18 +24,26 @@ impl Platform {
         &mut self,
         objects: &impl gix_object::Find,
         mut options: merge::Options,
-    ) -> Result<PlatformRef<'_>, Error> {
-        let current = self.current.as_ref().ok_or(Error::UnsetResource)?;
-        let ancestor = self.ancestor.as_ref().ok_or(Error::UnsetResource)?;
-        let other = self.other.as_ref().ok_or(Error::UnsetResource)?;
+    ) -> ExnMessageResult<PlatformRef<'_>> {
+        let current = self.current.as_ref().ok_or_raise(|| {
+            message("The 'current', 'ancestor' or 'other' resource for the merge operation were not set")
+        })?;
+        let ancestor = self.ancestor.as_ref().ok_or_raise(|| {
+            message("The 'current', 'ancestor' or 'other' resource for the merge operation were not set")
+        })?;
+        let other = self.other.as_ref().ok_or_raise(|| {
+            message("The 'current', 'ancestor' or 'other' resource for the merge operation were not set")
+        })?;
 
         let entry = self
             .attr_stack
             .at_entry(current.rela_path.as_bstr(), None, objects)
-            .map_err(|err| Error::Attributes {
-                source: err,
-                kind: ResourceKind::CurrentOrOurs,
-                rela_path: current.rela_path.clone(),
+            .or_raise(|| {
+                message!(
+                    "Failed to obtain attributes for {:?} resource at '{}'",
+                    ResourceKind::CurrentOrOurs,
+                    current.rela_path
+                )
             })?;
         entry.matching_attributes(&mut self.attrs);
         let mut attrs = self.attrs.iter_selected();
diff --git a/gix-merge/src/blob/platform/set_resource.rs b/gix-merge/src/blob/platform/set_resource.rs
index 35706837040..d11e93b7298 100644
--- a/gix-merge/src/blob/platform/set_resource.rs
+++ b/gix-merge/src/blob/platform/set_resource.rs
@@ -1,28 +1,8 @@
-use bstr::{BStr, BString};
+use bstr::BStr;
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, ResultExt, message};
 
-use crate::blob::{Platform, ResourceKind, pipeline, platform::Resource};
-
-/// The error returned by [Platform::set_resource](Platform::set_resource).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Can only diff blobs, not {mode:?}")]
-    InvalidMode { mode: gix_object::tree::EntryKind },
-    #[error("Failed to read {kind:?} worktree data from '{rela_path}'")]
-    Io {
-        rela_path: BString,
-        kind: ResourceKind,
-        source: std::io::Error,
-    },
-    #[error("Failed to obtain attributes for {kind:?} resource at '{rela_path}'")]
-    Attributes {
-        rela_path: BString,
-        kind: ResourceKind,
-        source: std::io::Error,
-    },
-    #[error(transparent)]
-    ConvertToMergeable(#[from] pipeline::convert_to_mergeable::Error),
-}
+use crate::blob::{Platform, ResourceKind, platform::Resource};
 
 /// Preparation
 impl Platform {
@@ -44,21 +24,17 @@ impl Platform {
         rela_path: &BStr,
         kind: ResourceKind,
         objects: &impl gix_object::FindObjectOrHeader,
-    ) -> Result<(), Error> {
+    ) -> ExnMessageResult {
         if !matches!(
             mode,
             gix_object::tree::EntryKind::Blob | gix_object::tree::EntryKind::BlobExecutable
         ) {
-            return Err(Error::InvalidMode { mode });
+            return Err(message!("Can only diff blobs, not {mode:?}").raise());
         }
         let entry = self
             .attr_stack
             .at_entry(rela_path, None, objects)
-            .map_err(|err| Error::Attributes {
-                source: err,
-                kind,
-                rela_path: rela_path.to_owned(),
-            })?;
+            .or_raise(|| message!("Failed to obtain attributes for {kind:?} resource at '{rela_path}'"))?;
 
         let storage = match kind {
             ResourceKind::OtherOrTheirs => &mut self.other,
@@ -67,18 +43,21 @@ impl Platform {
         };
 
         let mut buf_storage = Vec::new();
-        let out = self.filter.convert_to_mergeable(
-            &id,
-            mode,
-            rela_path,
-            kind,
-            &mut |_, out| {
-                let _ = entry.matching_attributes(out);
-            },
-            objects,
-            self.filter_mode,
-            storage.as_mut().map_or(&mut buf_storage, |s| &mut s.buffer),
-        )?;
+        let out = self
+            .filter
+            .convert_to_mergeable(
+                &id,
+                mode,
+                rela_path,
+                kind,
+                &mut |_, out| {
+                    let _ = entry.matching_attributes(out);
+                },
+                objects,
+                self.filter_mode,
+                storage.as_mut().map_or(&mut buf_storage, |s| &mut s.buffer),
+            )
+            .or_raise(|| message("Failed to convert resource to mergeable form"))?;
 
         match storage {
             None => {
diff --git a/gix-merge/src/commit/function.rs b/gix-merge/src/commit/function.rs
index 1cccf582e78..4df35d91f80 100644
--- a/gix-merge/src/commit/function.rs
+++ b/gix-merge/src/commit/function.rs
@@ -1,11 +1,9 @@
 use std::borrow::Cow;
 
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt, message};
 use gix_object::FindExt;
 
-use crate::{
-    blob::builtin_driver,
-    commit::{Error, Options},
-};
+use crate::{blob::builtin_driver, commit::Options};
 
 /// Like [`tree()`](crate::tree()), but it takes only two commits, `our_commit` and `their_commit` to automatically
 /// compute the merge-bases among them.
@@ -52,8 +50,9 @@ pub fn commit<'objects>(
     objects: &'objects (impl gix_object::FindObjectOrHeader + gix_object::Write),
     abbreviate_hash: &mut dyn FnMut(&gix_hash::oid) -> String,
     options: Options,
-) -> Result<super::Outcome<'objects>, Error> {
-    let merge_bases = gix_revision::merge_base(our_commit, &[their_commit], graph)?;
+) -> ExnMessageResult<super::Outcome<'objects>> {
+    let merge_bases = gix_revision::merge_base(our_commit, &[their_commit], graph)
+        .or_raise(|| message("Failed to obtain the merge base between the two commits to be merged"))?;
     let mut virtual_merge_bases = Vec::new();
     let mut state = gix_diff::tree::State::default();
     let mut commit_to_tree =
@@ -61,12 +60,14 @@ pub fn commit<'objects>(
 
     let (merge_base_tree_id, ancestor_name): (_, Cow<'_, str>) = match merge_bases.clone() {
         Some(base_commit) if base_commit.len() == 1 => (
-            commit_to_tree(*base_commit.first())?,
+            commit_to_tree(*base_commit.first())
+                .or_raise(|| message("Could not find ancestor, our or their commit to extract tree from"))?,
             abbreviate_hash(base_commit.first()).into(),
         ),
         Some(base_commits) => {
             let virtual_base_tree = if options.use_first_merge_base {
-                commit_to_tree(*base_commits.first())?
+                commit_to_tree(*base_commits.first())
+                    .or_raise(|| message("Could not find ancestor, our or their commit to extract tree from"))?
             } else {
                 let mut base_commits: Vec<_> = base_commits.into();
                 let first = base_commits.pop().expect("at least two");
@@ -81,7 +82,8 @@ pub fn commit<'objects>(
                     objects,
                     abbreviate_hash,
                     options.tree_merge.clone(),
-                )?;
+                )
+                .or_raise(|| message("Could not create virtual merge base"))?;
                 virtual_merge_bases = Vec::from(out.virtual_merge_bases);
                 out.tree_id
             };
@@ -91,10 +93,7 @@ pub fn commit<'objects>(
             if options.allow_missing_merge_base {
                 (gix_hash::ObjectId::empty_tree(our_commit.kind()), "empty tree".into())
             } else {
-                return Err(Error::NoMergeBase {
-                    our_commit_id: our_commit,
-                    their_commit_id: their_commit,
-                });
+                return Err(message!("No common ancestor between {our_commit} and {their_commit}").raise());
             }
         }
     };
@@ -104,8 +103,14 @@ pub fn commit<'objects>(
         labels.ancestor = Some(ancestor_name.as_ref().into());
     }
 
-    let our_tree_id = objects.find_commit(&our_commit, &mut state.buf1)?.tree();
-    let their_tree_id = objects.find_commit(&their_commit, &mut state.buf1)?.tree();
+    let our_tree_id = objects
+        .find_commit(&our_commit, &mut state.buf1)
+        .or_raise(|| message("Could not find ancestor, our or their commit to extract tree from"))?
+        .tree();
+    let their_tree_id = objects
+        .find_commit(&their_commit, &mut state.buf1)
+        .or_raise(|| message("Could not find ancestor, our or their commit to extract tree from"))?
+        .tree();
 
     let outcome = crate::tree(
         &merge_base_tree_id,
@@ -118,7 +123,8 @@ pub fn commit<'objects>(
         diff_resource_cache,
         blob_merge,
         options.tree_merge,
-    )?;
+    )
+    .or_raise(|| message("Could not merge trees"))?;
 
     Ok(super::Outcome {
         tree_merge: outcome,
diff --git a/gix-merge/src/commit/mod.rs b/gix-merge/src/commit/mod.rs
index 0a32c818ac8..6ac396864eb 100644
--- a/gix-merge/src/commit/mod.rs
+++ b/gix-merge/src/commit/mod.rs
@@ -1,24 +1,3 @@
-/// The error returned by [`commit()`](crate::commit()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to obtain the merge base between the two commits to be merged")]
-    MergeBase(#[from] gix_revision::merge_base::Error),
-    #[error(transparent)]
-    VirtualMergeBase(#[from] virtual_merge_base::Error),
-    #[error(transparent)]
-    MergeTree(#[from] crate::tree::Error),
-    #[error("No common ancestor between {our_commit_id} and {their_commit_id}")]
-    NoMergeBase {
-        /// The commit on our side that was to be merged.
-        our_commit_id: gix_hash::ObjectId,
-        /// The commit on their side that was to be merged.
-        their_commit_id: gix_hash::ObjectId,
-    },
-    #[error("Could not find ancestor, our or their commit to extract tree from")]
-    FindCommit(#[from] gix_object::find::existing_object::Error),
-}
-
 /// A way to configure [`commit()`](crate::commit()).
 #[derive(Default, Debug, Clone)]
 pub struct Options {
diff --git a/gix-merge/src/commit/virtual_merge_base.rs b/gix-merge/src/commit/virtual_merge_base.rs
index 09a08cff473..cc5c18591aa 100644
--- a/gix-merge/src/commit/virtual_merge_base.rs
+++ b/gix-merge/src/commit/virtual_merge_base.rs
@@ -11,28 +11,10 @@ pub struct Outcome {
     pub tree_id: gix_hash::ObjectId,
 }
 
-/// The error returned by [`commit::merge_base()`](crate::commit::virtual_merge_base()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    MergeTree(#[from] crate::tree::Error),
-    #[error("Failed to write tree for merged merge-base or virtual commit")]
-    WriteObject(gix_object::write::Error),
-    #[error("Failed to decode a commit needed to build a virtual merge-base")]
-    DecodeCommit(#[from] gix_object::decode::Error),
-    #[error(
-        "Conflicts occurred when trying to resolve multiple merge-bases by merging them. This is most certainly a bug."
-    )]
-    VirtualMergeBaseConflict,
-    #[error("Could not find commit to use as basis for a virtual commit")]
-    FindCommit(#[from] gix_object::find::existing_object::Error),
-}
-
 pub(super) mod function {
+    use gix_error::{ErrorExt, ExnMessageResult, ResultExt, message};
     use gix_object::FindExt;
 
-    use super::Error;
     use crate::{
         blob::builtin_driver,
         tree::{TreatAsUnresolved, treat_as_unresolved},
@@ -56,7 +38,7 @@ pub(super) mod function {
         objects: &'objects (impl gix_object::FindObjectOrHeader + gix_object::Write),
         abbreviate_hash: &mut dyn FnMut(&gix_hash::oid) -> String,
         mut options: crate::tree::Options,
-    ) -> Result<super::Outcome, crate::commit::Error> {
+    ) -> ExnMessageResult<super::Outcome> {
         let mut merged_commit_id = first_commit;
         others.push(second_commit);
 
@@ -95,13 +77,16 @@ pub(super) mod function {
                 content_merge: treat_as_unresolved::ContentMerge::Markers,
                 tree_merge: treat_as_unresolved::TreeMerge::Undecidable,
             }) {
-                return Err(Error::VirtualMergeBaseConflict.into());
+                return Err(message(
+                    "Conflicts occurred when trying to resolve multiple merge-bases by merging them. This is most certainly a bug.",
+                )
+                .raise());
             }
             let merged_tree_id = out
                 .tree_merge
                 .tree
                 .write(|tree| objects.write(tree))
-                .map_err(Error::WriteObject)?;
+                .or_raise(|| message("Failed to write tree for merged merge-base or virtual commit"))?;
 
             tree_id = Some(merged_tree_id);
             merged_commit_id = create_virtual_commit(objects, merged_commit_id, next_commit_id, merged_tree_id)?;
@@ -114,13 +99,15 @@ pub(super) mod function {
             virtual_merge_bases: nonempty::NonEmpty::from_vec(virtual_merge_bases)
                 .expect("the virtual merge-base process always creates at least one commit"),
             commit_id: merged_commit_id,
-            tree_id: tree_id.map_or_else(
-                || {
-                    let mut buf = Vec::new();
-                    objects.find_commit(&merged_commit_id, &mut buf).map(|c| c.tree())
-                },
-                Ok,
-            )?,
+            tree_id: tree_id
+                .map_or_else(
+                    || {
+                        let mut buf = Vec::new();
+                        objects.find_commit(&merged_commit_id, &mut buf).map(|c| c.tree())
+                    },
+                    Ok,
+                )
+                .or_raise(|| message("Could not find commit to use as basis for a virtual commit"))?,
         })
     }
 
@@ -129,12 +116,18 @@ pub(super) mod function {
         parent_a: gix_hash::ObjectId,
         parent_b: gix_hash::ObjectId,
         tree_id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, Error> {
+    ) -> ExnMessageResult<gix_hash::ObjectId> {
         let mut buf = Vec::new();
-        let commit_ref = objects.find_commit(&parent_a, &mut buf)?;
-        let mut commit = commit_ref.to_owned()?;
+        let commit_ref = objects
+            .find_commit(&parent_a, &mut buf)
+            .or_raise(|| message("Could not find commit to use as basis for a virtual commit"))?;
+        let mut commit = commit_ref
+            .to_owned()
+            .or_raise(|| message("Failed to decode a commit needed to build a virtual merge-base"))?;
         commit.parents = vec![parent_a, parent_b].into();
         commit.tree = tree_id;
-        objects.write(&commit).map_err(Error::WriteObject)
+        objects
+            .write(&commit)
+            .or_raise(|| message("Failed to write tree for merged merge-base or virtual commit"))
     }
 }
diff --git a/gix-merge/src/tree/function/change.rs b/gix-merge/src/tree/function/change.rs
index 8cad4ba0f84..ee86cefe94e 100644
--- a/gix-merge/src/tree/function/change.rs
+++ b/gix-merge/src/tree/function/change.rs
@@ -8,16 +8,13 @@
 //! Semantic conflict resolution and edits to the result tree belong to the
 //! sibling `resolve` module; this module only prepares, indexes, and matches work.
 
-use std::convert::Infallible;
-
 use bstr::{BString, ByteSlice};
 use gix_diff::{tree::recorder::Location, tree_with_rewrites::Change};
+use gix_error::ExnResult;
+use gix_error::ResultExt;
 use gix_object::FindExt;
 
-use crate::tree::{
-    Error,
-    utils::{ChangeList, ChangeListRef, PossibleConflict, TreeNodes, track},
-};
+use crate::tree::utils::{ChangeList, ChangeListRef, PossibleConflict, TreeNodes, track};
 
 pub(super) struct SideState {
     changes: ChangeList,
@@ -103,17 +100,19 @@ pub(super) fn collect(
     diff_resource_cache: &mut gix_diff::blob::Platform,
     diff_state: &mut gix_diff::tree::State,
     rewrites: Option<gix_diff::Rewrites>,
-) -> Result<SideState, Error> {
+) -> ExnResult<SideState> {
     let mut changes = Vec::new();
     if base_tree != side_tree {
-        let side_tree = objects.find_tree_iter(side_tree, side_buf)?;
+        let side_tree = objects
+            .find_tree_iter(side_tree, side_buf)
+            .or_raise_erased(|| gix_error::message("Tree merge failed"))?;
         gix_diff::tree_with_rewrites(
             gix_object::TreeRefIter::from_bytes(base_buf, base_tree.kind()),
             side_tree,
             diff_resource_cache,
             diff_state,
             objects,
-            |change| -> Result<_, Infallible> {
+            |change| -> ExnResult<_> {
                 track(change, &mut changes);
                 Ok(std::ops::ControlFlow::Continue(()))
             },
@@ -121,7 +120,8 @@ pub(super) fn collect(
                 location: Some(Location::Path),
                 rewrites,
             },
-        )?;
+        )
+        .or_raise_erased(|| gix_error::message("Tree merge failed"))?;
     }
     Ok(SideState::from_changes(changes))
 }
diff --git a/gix-merge/src/tree/function/resolve.rs b/gix-merge/src/tree/function/resolve.rs
index cd691d6c22d..7faeadcaf20 100644
--- a/gix-merge/src/tree/function/resolve.rs
+++ b/gix-merge/src/tree/function/resolve.rs
@@ -6,6 +6,7 @@ use std::borrow::Cow;
 
 use bstr::{BString, ByteSlice};
 use gix_diff::tree_with_rewrites::Change;
+use gix_error::{ExnResult, ResultExt};
 use gix_hash::ObjectId;
 use gix_object::{
     FindExt, tree,
@@ -15,7 +16,7 @@ use gix_object::{
 use crate::tree::{
     Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping,
     ConflictMapping::{Original, Swapped},
-    ContentMerge, Error, Options, Outcome, Resolution, ResolutionFailure, ResolveWith,
+    ContentMerge, Options, Outcome, Resolution, ResolutionFailure, ResolveWith,
     utils::{
         ChangeDisposition, ChangeList, PossibleConflict, TrackedChange, apply_change, perform_blob_merge,
         possibly_rewritten_location, rewrite_location_with_renamed_directory, to_components, unique_path_in_tree,
@@ -83,29 +84,34 @@ use super::change::{MatchKind, collect as collect_changes, matching as matching_
 /// which recorded resolutions a caller still considers unresolved, so unresolved conflicts are not limited to content
 /// containing conflict markers.
 ///
+/// ### Errors
+///
+/// Selecting an absent binary merge resource, such as the ancestor in an add/add conflict, is classified as
+/// [`gix_error::Class::Tagged`] with `"gix_merge::tree::missing_binary_merge_result"`.
+/// Missing object headers or data are not tagged this way.
+///
 /// ### Performance
 ///
 /// Note that `objects` *should* have an object cache to greatly accelerate tree-retrieval.
 #[expect(clippy::too_many_arguments)]
-pub fn tree<'objects, E>(
+pub fn tree<'objects>(
     base_tree: &gix_hash::oid,
     our_tree: &gix_hash::oid,
     their_tree: &gix_hash::oid,
     mut labels: crate::blob::builtin_driver::text::Labels<'_>,
     objects: &'objects impl gix_object::FindObjectOrHeader,
-    mut write_blob_to_odb: impl FnMut(&[u8]) -> Result<ObjectId, E>,
+    mut write_blob_to_odb: impl FnMut(&[u8]) -> ExnResult<ObjectId>,
     diff_state: &mut gix_diff::tree::State,
     diff_resource_cache: &mut gix_diff::blob::Platform,
     blob_merge: &mut crate::blob::Platform,
     options: Options,
-) -> Result<Outcome<'objects>, Error>
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
-{
+) -> ExnResult<Outcome<'objects>> {
     let _span = gix_trace::coarse!("gix_merge::tree", ?base_tree, ?our_tree, ?their_tree, ?labels);
     let (mut base_buf, mut side_buf) = (Vec::new(), Vec::new());
     let mut editor = {
-        let ancestor_tree = objects.find_tree(base_tree, &mut base_buf)?;
+        let ancestor_tree = objects
+            .find_tree(base_tree, &mut base_buf)
+            .or_raise_erased(|| gix_error::message("Tree merge failed"))?;
         tree::Editor::new(ancestor_tree.to_owned(), objects, base_tree.kind())
     };
     let resolve_tree_conflicts = options.tree_conflicts;
@@ -2032,7 +2038,7 @@ fn apply_change_and_mark(
     editor: &mut tree::Editor<'_>,
     change: &Change,
     disposition: &mut ChangeDisposition,
-) -> Result<(), tree::editor::Error> {
+) -> ExnResult {
     apply_change(editor, change, None)?;
     *disposition = ChangeDisposition::Applied;
     Ok(())
@@ -2045,12 +2051,12 @@ fn apply_our_resolution(
     editor: &mut gix_object::tree::Editor<'_>,
     local_ours_disposition: &mut ChangeDisposition,
     local_theirs_disposition: &mut ChangeDisposition,
-) -> Result<(), Error> {
+) -> ExnResult {
     let (ours, disposition) = match outer_side {
         Original => (local_ours, local_ours_disposition),
         Swapped => (local_theirs, local_theirs_disposition),
     };
-    Ok(apply_change_and_mark(editor, ours, disposition)?)
+    apply_change_and_mark(editor, ours, disposition)
 }
 
 fn involves_submodule(a: &EntryMode, b: &EntryMode) -> bool {
diff --git a/gix-merge/src/tree/mod.rs b/gix-merge/src/tree/mod.rs
index a9808343416..e2313c2ef5b 100644
--- a/gix-merge/src/tree/mod.rs
+++ b/gix-merge/src/tree/mod.rs
@@ -1,30 +1,6 @@
 use bstr::BString;
 use gix_diff::{Rewrites, tree_with_rewrites::Change};
 
-/// The error returned by [`tree()`](crate::tree()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not find ancestor, our or their tree to get started")]
-    FindTree(#[from] gix_object::find::existing_object::Error),
-    #[error("Could not find ancestor, our or their tree iterator to get started")]
-    FindTreeIter(#[from] gix_object::find::existing_iter::Error),
-    #[error("Failed to diff our side or their side")]
-    DiffTree(#[from] gix_diff::tree_with_rewrites::Error),
-    #[error("Could not apply merge result to base tree")]
-    TreeEdit(#[from] gix_object::tree::editor::Error),
-    #[error("Failed to load resource to prepare for blob merge")]
-    BlobMergeSetResource(#[from] crate::blob::platform::set_resource::Error),
-    #[error(transparent)]
-    BlobMergePrepare(#[from] crate::blob::platform::prepare_merge::Error),
-    #[error(transparent)]
-    BlobMerge(#[from] crate::blob::platform::merge::Error),
-    #[error("Failed to write merged blob content as blob to the object database")]
-    WriteBlobToOdb(Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error("The merge was performed, but the binary merge result couldn't be selected as it wasn't found")]
-    MergeResourceNotFound,
-}
-
 /// The outcome produced by [`tree()`](crate::tree()).
 #[derive(Clone)]
 pub struct Outcome<'a> {
diff --git a/gix-merge/src/tree/utils.rs b/gix-merge/src/tree/utils.rs
index 0b6138652b2..34b0e7769db 100644
--- a/gix-merge/src/tree/utils.rs
+++ b/gix-merge/src/tree/utils.rs
@@ -9,6 +9,7 @@ use std::collections::HashMap;
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
 use gix_diff::tree_with_rewrites::{Change, ChangeRef};
+use gix_error::{Class, ExnResult, OptionExt, ResultExt, message};
 use gix_hash::ObjectId;
 use gix_object::{
     tree,
@@ -18,7 +19,7 @@ use gix_object::{
 use crate::{
     blob::{ResourceKind, builtin_driver::binary::Pick},
     tree::{
-        Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping, Error, Options, Resolution,
+        Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping, Options, Resolution,
         ResolutionFailure,
     },
 };
@@ -76,7 +77,7 @@ pub fn unique_path_in_tree(
     editor: &tree::Editor<'_>,
     tree: &TreeNodes,
     side_name: &BStr,
-) -> Result<BString, Error> {
+) -> ExnResult<BString> {
     let mut qualifier = BString::from("~");
     qualifier.extend(
         side_name
@@ -119,21 +120,18 @@ pub fn unique_path_in_tree(
 
 /// Perform a merge between two blobs and return the result of its object id.
 #[expect(clippy::too_many_arguments)]
-pub fn perform_blob_merge<E>(
+pub fn perform_blob_merge(
     mut labels: crate::blob::builtin_driver::text::Labels<'_>,
     objects: &impl gix_object::FindObjectOrHeader,
     blob_merge: &mut crate::blob::Platform,
     buf: &mut Vec<u8>,
-    write_blob_to_odb: &mut impl FnMut(&[u8]) -> Result<ObjectId, E>,
+    write_blob_to_odb: &mut impl FnMut(&[u8]) -> ExnResult<ObjectId>,
     (our_location, our_id, our_mode): (&BString, ObjectId, EntryMode),
     (their_location, their_id, their_mode): (&BString, ObjectId, EntryMode),
     (previous_location, previous_id, previous_mode): (&BString, ObjectId, EntryMode),
     (extra_markers, outer_side): (u8, ConflictMapping),
     options: &Options,
-) -> Result<(ObjectId, crate::blob::Resolution), Error>
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
-{
+) -> ExnResult<(ObjectId, crate::blob::Resolution)> {
     if our_id == their_id {
         // This can happen if the merge modes are different.
         debug_assert_ne!(
@@ -159,21 +157,27 @@ where
         ConflictMapping::Original => (ResourceKind::CurrentOrOurs, ResourceKind::OtherOrTheirs),
         ConflictMapping::Swapped => (ResourceKind::OtherOrTheirs, ResourceKind::CurrentOrOurs),
     };
-    blob_merge.set_resource(our_id, our_mode.kind(), our_location.as_bstr(), our_kind, objects)?;
-    blob_merge.set_resource(
-        their_id,
-        their_mode.kind(),
-        their_location.as_bstr(),
-        their_kind,
-        objects,
-    )?;
-    blob_merge.set_resource(
-        previous_id,
-        previous_mode.kind(),
-        previous_location.as_bstr(),
-        ResourceKind::CommonAncestorOrBase,
-        objects,
-    )?;
+    blob_merge
+        .set_resource(our_id, our_mode.kind(), our_location.as_bstr(), our_kind, objects)
+        .or_erased()?;
+    blob_merge
+        .set_resource(
+            their_id,
+            their_mode.kind(),
+            their_location.as_bstr(),
+            their_kind,
+            objects,
+        )
+        .or_erased()?;
+    blob_merge
+        .set_resource(
+            previous_id,
+            previous_mode.kind(),
+            previous_location.as_bstr(),
+            ResourceKind::CommonAncestorOrBase,
+            objects,
+        )
+        .or_erased()?;
 
     fn combined(side: &BStr, location: &BString) -> BString {
         let mut buf = side.to_owned();
@@ -202,17 +206,21 @@ where
             other: other.as_ref().map(|n| n.as_bstr()),
         }
     };
-    let mut prep = blob_merge.prepare_merge(objects, options.blob_merge)?;
+    let mut prep = blob_merge.prepare_merge(objects, options.blob_merge).or_erased()?;
     if let crate::blob::builtin_driver::text::Conflict::Keep { marker_size, .. } = &mut prep.options.text.conflict {
         *marker_size =
             marker_size.saturating_add(extra_markers.saturating_add(options.marker_size_multiplier.saturating_mul(2)));
     }
-    let (pick, resolution) = prep.merge(buf, labels, &options.blob_merge_command_ctx)?;
+    let (pick, resolution) = prep.merge(buf, labels, &options.blob_merge_command_ctx).or_erased()?;
 
     let merged_blob_id = prep
         .id_by_pick(pick, buf, write_blob_to_odb)
-        .map_err(|err| Error::WriteBlobToOdb(err.into()))?
-        .ok_or(Error::MergeResourceNotFound)?;
+        .or_raise_erased(|| message("Failed to write merged blob content as blob to the object database"))?
+        .ok_or_raise(|| {
+            message("The merge was performed, but the binary merge result couldn't be selected as it wasn't found")
+                .with_class(Class::Tagged("gix_merge::tree::missing_binary_merge_result"))
+        })
+        .or_raise_erased(|| gix_error::ClassificationMarker::NOT_FOUND)?;
     Ok((merged_blob_id, resolution))
 }
 
@@ -379,7 +387,7 @@ pub fn apply_change(
     editor: &mut tree::Editor<'_>,
     change: &Change,
     alternative_location: Option<&BString>,
-) -> Result<(), tree::editor::Error> {
+) -> ExnResult {
     use to_components_bstring_ref as to_components;
     if change.entry_mode().is_tree() {
         return Ok(());
@@ -751,6 +759,7 @@ impl Conflict {
 #[cfg(test)]
 mod tree_nodes_tests {
     use super::*;
+    use gix_error::ExnResult;
 
     #[test]
     fn removing_an_absent_nested_change_does_not_remove_a_matching_root_suffix() {
@@ -852,7 +861,7 @@ mod tree_nodes_tests {
     }
 
     #[test]
-    fn unique_path_qualifies_a_non_tree_parent_instead_of_looping_over_child_names() -> Result<(), Error> {
+    fn unique_path_qualifies_a_non_tree_parent_instead_of_looping_over_child_names() -> ExnResult {
         let mut tree = TreeNodes::new();
         tree.track_change(
             &Change::Addition {
diff --git a/gix-merge/tests/merge/blob/builtin_driver.rs b/gix-merge/tests/merge/blob/builtin_driver.rs
index f492ea80e48..da26d8adbfc 100644
--- a/gix-merge/tests/merge/blob/builtin_driver.rs
+++ b/gix-merge/tests/merge/blob/builtin_driver.rs
@@ -26,6 +26,7 @@ fn binary() {
 }
 
 mod text {
+    use crate::Result;
     use arbitrary::Arbitrary;
     use bstr::ByteSlice;
     use gix_merge::blob::{
@@ -201,7 +202,7 @@ mod text {
     }
 
     #[test]
-    fn run_baseline() -> crate::Result {
+    fn run_baseline() -> Result {
         let root = gix_testtools::scripted_fixture_read_only("text-baseline.sh")?;
         for (baseline, diverging, expected_percentage) in [
             ("baseline.cases", DIVERGING, 10),
diff --git a/gix-merge/tests/merge/blob/mod.rs b/gix-merge/tests/merge/blob/mod.rs
index b6897671c48..3e87bc546f4 100644
--- a/gix-merge/tests/merge/blob/mod.rs
+++ b/gix-merge/tests/merge/blob/mod.rs
@@ -3,7 +3,8 @@ mod pipeline;
 mod platform;
 
 mod util {
-    use gix_object::{Write, find::Error};
+    use gix_error::ExnResult;
+    use gix_object::Write;
 
     pub type ObjectDb = gix_odb::memory::Proxy<gix_object::find::Never>;
 
@@ -12,7 +13,7 @@ mod util {
     }
 
     /// Insert `data` and return its hash. That can be used to find it again.
-    pub fn insert(db: &ObjectDb, data: &str) -> Result<gix_hash::ObjectId, Error> {
+    pub fn insert(db: &ObjectDb, data: &str) -> ExnResult<gix_hash::ObjectId> {
         db.write_buf(gix_object::Kind::Blob, data.as_bytes())
     }
 }
diff --git a/gix-merge/tests/merge/blob/pipeline.rs b/gix-merge/tests/merge/blob/pipeline.rs
index 6ada5a8045f..6c44c38c954 100644
--- a/gix-merge/tests/merge/blob/pipeline.rs
+++ b/gix-merge/tests/merge/blob/pipeline.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_filter::{eol, eol::AutoCrlf};
 use gix_merge::blob::{
@@ -11,7 +12,8 @@ use crate::blob::util::{insert, object_db};
 const ALL_MODES: [pipeline::Mode; 2] = [pipeline::Mode::ToGit, pipeline::Mode::Renormalize];
 
 #[test]
-fn without_transformation() -> crate::Result {
+fn without_transformation() -> Result {
+    let mut error_snapshots = Vec::new();
     for mode in ALL_MODES {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let mut filter = Pipeline::new(
@@ -56,10 +58,8 @@ fn without_transformation() -> crate::Result {
             )
             .unwrap_err();
 
-        assert!(
-            matches!(err, pipeline::convert_to_mergeable::Error::InvalidEntryKind {rela_path,actual}
-                if rela_path == link_name && actual == EntryKind::Link)
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "an unsupported entry kind is a validation failure");
         assert_eq!(
             buf.len(),
             9,
@@ -114,11 +114,17 @@ fn without_transformation() -> crate::Result {
         assert_eq!(out, None, "the lack of file on disk is fine as well");
     }
 
+    insta::assert_debug_snapshot!(error_snapshots, "without transformation", @"
+    [
+        Entry at 'link' must be regular file or symlink, but was Link,
+        Entry at 'link' must be regular file or symlink, but was Link,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn binary_below_large_file_threshold() -> crate::Result {
+fn binary_below_large_file_threshold() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let mut filter = Pipeline::new(
         WorktreeRoots {
@@ -168,7 +174,7 @@ fn binary_below_large_file_threshold() -> crate::Result {
 }
 
 #[test]
-fn above_large_file_threshold() -> crate::Result {
+fn above_large_file_threshold() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let mut filter = gix_merge::blob::Pipeline::new(
         WorktreeRoots {
@@ -229,7 +235,7 @@ fn above_large_file_threshold() -> crate::Result {
 }
 
 #[test]
-fn non_existing() -> crate::Result {
+fn non_existing() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let mut filter = Pipeline::new(
         WorktreeRoots {
@@ -296,20 +302,16 @@ fn non_existing() -> crate::Result {
             &mut buf,
         )
         .unwrap_err();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "missing object database ids are always an error (even though missing objects on disk are allowed)", @"An object with id Oid(1) could not be found");
     assert!(
-        matches!(
-            err,
-            gix_merge::blob::pipeline::convert_to_mergeable::Error::FindObject(
-                gix_object::find::existing_object::Error::NotFound { .. }
-            ),
-        ),
+        err.is_not_found(),
         "missing object database ids are always an error (even though missing objects on disk are allowed)"
     );
     Ok(())
 }
 
 #[test]
-fn worktree_filter() -> crate::Result {
+fn worktree_filter() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let filter = gix_filter::Pipeline::new(
         Default::default(),
diff --git a/gix-merge/tests/merge/blob/platform.rs b/gix-merge/tests/merge/blob/platform.rs
index 9653192be21..d13017030f8 100644
--- a/gix-merge/tests/merge/blob/platform.rs
+++ b/gix-merge/tests/merge/blob/platform.rs
@@ -2,6 +2,7 @@ use gix_merge::blob::Platform;
 use gix_worktree::stack::state::attributes;
 
 mod merge {
+    use crate::Result;
     use std::{convert::Infallible, path::Path, process::Stdio};
 
     use bstr::{BStr, ByteSlice};
@@ -22,7 +23,7 @@ mod merge {
     };
 
     #[test]
-    fn builtin_text_uses_binary_if_needed() -> crate::Result {
+    fn builtin_text_uses_binary_if_needed() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         platform.set_resource(
             gix_hash::Kind::Sha1.null(),
@@ -72,7 +73,7 @@ mod merge {
     }
 
     #[test]
-    fn same_binaries_do_not_count_as_conflicted() -> crate::Result {
+    fn same_binaries_do_not_count_as_conflicted() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         platform.set_resource(
             gix_hash::Kind::Sha1.null(),
@@ -121,7 +122,7 @@ mod merge {
     }
 
     #[test]
-    fn builtin_with_conflict() -> crate::Result {
+    fn builtin_with_conflict() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         let non_existing_ancestor_id = hex_to_id("ffffffffffffffffffffffffffffffffffffffff");
         platform.set_resource(
@@ -216,7 +217,7 @@ theirs
         );
         assert_eq!(
             platform_ref
-                .id_by_pick(res.0, &buf, |_buf| -> Result<_, Infallible> {
+                .id_by_pick(res.0, &buf, |_buf| -> std::result::Result<_, Infallible> {
                     panic!("no need to write buffer")
                 })
                 .unwrap()
@@ -252,7 +253,7 @@ theirs
 
             assert_eq!(
                 platform_ref
-                    .id_by_pick(res.0, &buf, |_buf| -> Result<_, Infallible> {
+                    .id_by_pick(res.0, &buf, |_buf| -> std::result::Result<_, Infallible> {
                         panic!("no need to write buffer")
                     })
                     .unwrap()
@@ -266,7 +267,7 @@ theirs
     }
 
     #[test]
-    fn with_external() -> crate::Result {
+    fn with_external() -> Result {
         let mut platform = new_platform(
             [gix_merge::blob::Driver {
                 name: "b".into(),
@@ -366,7 +367,7 @@ theirs
     #[test]
     #[cfg(not(windows))] // assertions aren't handling Windows paths, and there is no need.
     /// This test is a complex behavioural test for an external merge driver similar to `mergiraf`.
-    fn with_external_mergiraf_like_driver_uses_worktree_tempfiles_from_context() -> crate::Result {
+    fn with_external_mergiraf_like_driver_uses_worktree_tempfiles_from_context() -> Result {
         let mut platform = new_platform(
             [gix_merge::blob::Driver {
                 name: "b".into(),
@@ -456,7 +457,7 @@ cat "%B" >> "%A""#
     }
 
     #[test]
-    fn missing_buffers_are_empty_buffers() -> crate::Result {
+    fn missing_buffers_are_empty_buffers() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         platform.set_resource(
             gix_hash::Kind::Sha1.null(),
@@ -520,7 +521,7 @@ cat "%B" >> "%A""#
     }
 
     #[test]
-    fn one_buffer_too_large() -> crate::Result {
+    fn one_buffer_too_large() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         platform.filter.options.large_file_threshold_bytes = 9;
         platform.set_resource(
@@ -569,8 +570,9 @@ cat "%B" >> "%A""#
         let err = platform_ref
             .prepare_external_driver("bogus".into(), Default::default(), Default::default())
             .unwrap_err();
+        insta::assert_debug_snapshot!(err, "however, for external drivers, resources can still be too much to handle, until we learn how to stream them", @"The resource of kind OtherOrTheirs was too large to be processed");
         assert!(
-            matches!(err, platform::prepare_external_driver::Error::ResourceTooLarge { .. }),
+            err.is_validation(),
             "however, for external drivers, resources can still be too much to handle, until we learn how to stream them"
         );
         Ok(())
@@ -593,6 +595,7 @@ cat "%B" >> "%A""#
 }
 
 mod prepare_merge {
+    use crate::Result;
     use gix_merge::blob::{
         BuiltinDriver, ResourceKind, builtin_driver, pipeline,
         platform::{DriverChoice, resource},
@@ -602,7 +605,7 @@ mod prepare_merge {
     use crate::blob::platform::new_platform;
 
     #[test]
-    fn ancestor_and_current_and_other_do_not_exist() -> crate::Result {
+    fn ancestor_and_current_and_other_do_not_exist() -> Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
         platform.set_resource(
             gix_hash::Kind::Sha1.null(),
@@ -637,7 +640,7 @@ mod prepare_merge {
     }
 
     #[test]
-    fn driver_selection() -> crate::Result {
+    fn driver_selection() -> Result {
         let mut platform = new_platform(
             [
                 gix_merge::blob::Driver {
@@ -813,10 +816,11 @@ mod set_resource {
 
     #[test]
     fn invalid_resource_types() {
+        let mut error_snapshots = Vec::new();
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
-        for (mode, name) in [(EntryKind::Commit, "Commit"), (EntryKind::Tree, "Tree")] {
-            assert_eq!(
-                platform
+        for mode in [EntryKind::Commit, EntryKind::Tree] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(platform
                     .set_resource(
                         gix_hash::Kind::Sha1.null(),
                         mode,
@@ -824,11 +828,16 @@ mod set_resource {
                         ResourceKind::OtherOrTheirs,
                         &gix_object::find::Never,
                     )
-                    .unwrap_err()
-                    .to_string(),
-                format!("Can only diff blobs, not {name}")
-            );
+                    .unwrap_err()),
+                &[],
+            ));
         }
+        insta::assert_debug_snapshot!(error_snapshots, "invalid resource types", @"
+        [
+            Can only diff blobs, not Commit,
+            Can only diff blobs, not Tree,
+        ]
+        ");
     }
 }
 
diff --git a/gix-merge/tests/merge/tree/cartesian.rs b/gix-merge/tests/merge/tree/cartesian.rs
index 748c94b477d..1ad77f2d334 100644
--- a/gix-merge/tests/merge/tree/cartesian.rs
+++ b/gix-merge/tests/merge/tree/cartesian.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{
     collections::{BTreeMap, BTreeSet},
     fmt::Write as _,
@@ -24,7 +25,7 @@ struct Case {
 }
 
 #[derive(Debug)]
-struct Result {
+struct Outcome {
     tree_id: gix_hash::ObjectId,
     tree: Tree,
     conflicted: bool,
@@ -39,7 +40,7 @@ struct Result {
 /// See `tree-cartesian-baseline.sh` for the model and `cartesian-baseline.txt` for the metrics and
 /// all observed differences. Set `GIX_MERGE_UPDATE_CARTESIAN_BASELINE=1` to accept a new status quo.
 #[test]
-fn records_status_quo_sha1() -> crate::Result {
+fn records_status_quo_sha1() -> Result {
     if gix_testtools::object_hash() != gix_hash::Kind::Sha1 {
         return Ok(());
     }
@@ -153,7 +154,7 @@ fn records_status_quo_sha1() -> crate::Result {
                            ours_label: &str,
                            theirs_label: &str,
                            options: &gix_merge::commit::Options|
-         -> crate::Result<Result> {
+         -> Result<Outcome> {
             let mut outcome = gix_merge::commit(
                 ours,
                 theirs,
@@ -180,7 +181,7 @@ fn records_status_quo_sha1() -> crate::Result {
                 .last()
                 .is_some_and(|conflict| conflict.is_unresolved(git_kind));
             let tree_id = outcome.tree.write(|tree| objects.write(tree))?;
-            Ok(Result {
+            Ok(Outcome {
                 tree_id,
                 tree: flatten_tree(tree_id, &objects)?,
                 conflicted,
@@ -857,7 +858,7 @@ fn records_status_quo_sha1() -> crate::Result {
 /// load the repository behind a submodule today.
 /// TODO: Allow callers to provide a callback with enough submodule-repository context to perform reachability checks.
 #[test]
-fn records_submodule_status_quo_sha1() -> crate::Result {
+fn records_submodule_status_quo_sha1() -> Result {
     if gix_testtools::object_hash() != gix_hash::Kind::Sha1 {
         return Ok(());
     }
@@ -1093,14 +1094,14 @@ fn git_result(
     filename: &str,
     conflicted: bool,
     objects: &gix_odb::memory::Proxy<gix_odb::Handle>,
-) -> crate::Result<Result> {
+) -> Result<Outcome> {
     let data = std::fs::read(repo.join(".git").join(filename))?;
     let hex = data
         .split(|byte| *byte == 0)
         .next()
         .expect("merge-tree always writes a tree");
     let tree_id = gix_hash::ObjectId::from_hex(hex)?;
-    Ok(Result {
+    Ok(Outcome {
         tree_id,
         tree: flatten_tree(tree_id, objects)?,
         conflicted,
@@ -1111,19 +1112,19 @@ fn git_result(
     })
 }
 
-fn flatten_commit(id: gix_hash::ObjectId, objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> crate::Result<Tree> {
+fn flatten_commit(id: gix_hash::ObjectId, objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> Result<Tree> {
     let mut buf = Vec::new();
     let tree_id = objects.find_commit(&id, &mut buf)?.tree();
     flatten_tree(tree_id, objects)
 }
 
-fn flatten_tree(id: gix_hash::ObjectId, objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> crate::Result<Tree> {
+fn flatten_tree(id: gix_hash::ObjectId, objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> Result<Tree> {
     fn recurse(
         id: gix_hash::ObjectId,
         prefix: &str,
         objects: &gix_odb::memory::Proxy<gix_odb::Handle>,
         out: &mut Tree,
-    ) -> crate::Result {
+    ) -> Result {
         let mut buf = Vec::new();
         let entries = objects
             .find_tree(&id, &mut buf)?
@@ -1191,7 +1192,7 @@ fn payload(side: &str, operation: &str) -> Option<String> {
     .then(|| format!("payload-{side}-{operation}"))
 }
 
-fn contains(tree: &Tree, needle: &[u8], objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> crate::Result<bool> {
+fn contains(tree: &Tree, needle: &[u8], objects: &gix_odb::memory::Proxy<gix_odb::Handle>) -> Result<bool> {
     let mut buf = Vec::new();
     for (_, id) in tree.values() {
         let blob = objects.find_blob(id, &mut buf)?;
diff --git a/gix-merge/tests/merge/tree/mod.rs b/gix-merge/tests/merge/tree/mod.rs
index d838a1c6073..fd9b44f962f 100644
--- a/gix-merge/tests/merge/tree/mod.rs
+++ b/gix-merge/tests/merge/tree/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_diff::Rewrites;
@@ -39,7 +40,7 @@ fn assert_no_unknown_conflicts(outcome: &gix_merge::tree::Outcome<'_>, context:
 /// 5. Validate that all tests are still working, and adjust the expected number of cases
 ///    in the assertion that would then fail.
 #[test]
-fn run_baseline() -> crate::Result {
+fn run_baseline() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("tree-baseline.sh")?;
     let cases = std::fs::read_to_string(root.join("baseline.cases"))?;
     let mut actual_cases = 0;
diff --git a/gix-negotiate/Cargo.toml b/gix-negotiate/Cargo.toml
index baaf5c641bc..1958c9168f0 100644
--- a/gix-negotiate/Cargo.toml
+++ b/gix-negotiate/Cargo.toml
@@ -22,6 +22,7 @@ sha1 = ["gix-hash/sha1"]
 sha256 = ["gix-hash/sha256"]
 
 [dependencies]
+gix-error = { version = "^0.3.2", path = "../gix-error" }
 gix-hash = { version = "^0.26.2", path = "../gix-hash" }
 gix-object = { version = "^0.64.1", path = "../gix-object" }
 gix-date = { version = "^0.16.0", path = "../gix-date" }
diff --git a/gix-negotiate/src/consecutive.rs b/gix-negotiate/src/consecutive.rs
index 5fa4b15fae9..faa7288e349 100644
--- a/gix-negotiate/src/consecutive.rs
+++ b/gix-negotiate/src/consecutive.rs
@@ -1,7 +1,8 @@
 use gix_date::SecondsSinceUnixEpoch;
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 
-use crate::{Error, Flags, Negotiator};
+use crate::{Flags, Negotiator};
 
 pub(crate) struct Algorithm {
     revs: gix_revwalk::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
@@ -19,7 +20,7 @@ impl Default for Algorithm {
 
 impl Algorithm {
     /// Add `id` to our priority queue and *add* `flags` to it.
-    fn add_to_queue(&mut self, id: ObjectId, mark: Flags, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn add_to_queue(&mut self, id: ObjectId, mark: Flags, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         let mut is_common = false;
         let mut has_mark = false;
         if let Some(commit) = graph
@@ -44,7 +45,7 @@ impl Algorithm {
         mode: Mark,
         ancestors: Ancestors,
         graph: &mut crate::Graph<'_, '_>,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         let mut is_common = false;
         if let Some(commit) = graph
             .get_or_insert_commit(id, |data| is_common = data.flags.contains(Flags::COMMON))?
@@ -89,7 +90,7 @@ impl Algorithm {
 }
 
 impl Negotiator for Algorithm {
-    fn known_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn known_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         if graph
             .get(&id)
             .is_none_or(|commit| !commit.data.flags.contains(Flags::SEEN))
@@ -100,11 +101,11 @@ impl Negotiator for Algorithm {
         Ok(())
     }
 
-    fn add_tip(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn add_tip(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         self.add_to_queue(id, Flags::SEEN, graph)
     }
 
-    fn next_have(&mut self, graph: &mut crate::Graph<'_, '_>) -> Option<Result<ObjectId, Error>> {
+    fn next_have(&mut self, graph: &mut crate::Graph<'_, '_>) -> Option<ExnResult<ObjectId>> {
         loop {
             let id = self.revs.pop_value().filter(|_| self.non_common_revs != 0)?;
             let commit = graph.get_mut(&id).expect("it was added to the graph by now");
@@ -144,7 +145,7 @@ impl Negotiator for Algorithm {
         }
     }
 
-    fn in_common_with_remote(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<bool, Error> {
+    fn in_common_with_remote(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult<bool> {
         let known_to_be_common = graph
             .get(&id)
             .is_some_and(|commit| commit.data.flags.contains(Flags::COMMON));
diff --git a/gix-negotiate/src/lib.rs b/gix-negotiate/src/lib.rs
index e4f189f4cb7..e481808c187 100644
--- a/gix-negotiate/src/lib.rs
+++ b/gix-negotiate/src/lib.rs
@@ -2,6 +2,7 @@
 //! the pack it sends to only contain what we don't have.
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
+use gix_error::ExnResult;
 mod consecutive;
 mod noop;
 mod skipping;
@@ -125,23 +126,20 @@ pub trait Negotiator {
     /// Mark `id` as common between the remote and us.
     ///
     /// These ids are typically the local tips of remote tracking branches.
-    fn known_common(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> Result<(), Error>;
+    fn known_common(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> ExnResult;
 
     /// Add `id` as starting point of a traversal across commits that aren't necessarily common between the remote and us.
     ///
     /// These tips are usually the commits of local references whose tips should lead to objects that we have in common with the remote.
-    fn add_tip(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> Result<(), Error>;
+    fn add_tip(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> ExnResult;
 
     /// Produce the next id of an object that we want the server to know we have. It's an object we don't know we have in common or not.
     ///
     /// Returns `None` if we have exhausted all options, which might mean we have traversed the entire commit graph.
-    fn next_have(&mut self, graph: &mut Graph<'_, '_>) -> Option<Result<gix_hash::ObjectId, Error>>;
+    fn next_have(&mut self, graph: &mut Graph<'_, '_>) -> Option<ExnResult<gix_hash::ObjectId>>;
 
     /// Mark `id` as being common with the remote (as informed by the remote itself) and return `true` if we knew it was common already.
     ///
     /// We can assume to have already seen `id` as we were the one to inform the remote in a prior `have`.
-    fn in_common_with_remote(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> Result<bool, Error>;
+    fn in_common_with_remote(&mut self, id: gix_hash::ObjectId, graph: &mut Graph<'_, '_>) -> ExnResult<bool>;
 }
-
-/// An error that happened during any of the methods on a [`Negotiator`].
-pub type Error = gix_revwalk::graph::get_or_insert_default::Error;
diff --git a/gix-negotiate/src/noop.rs b/gix-negotiate/src/noop.rs
index 17140f36a25..38972dc6a57 100644
--- a/gix-negotiate/src/noop.rs
+++ b/gix-negotiate/src/noop.rs
@@ -1,23 +1,24 @@
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 
-use crate::{Error, Negotiator};
+use crate::Negotiator;
 
 pub(crate) struct Noop;
 
 impl Negotiator for Noop {
-    fn known_common(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn known_common(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         Ok(())
     }
 
-    fn add_tip(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn add_tip(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         Ok(())
     }
 
-    fn next_have(&mut self, _graph: &mut crate::Graph<'_, '_>) -> Option<Result<ObjectId, Error>> {
+    fn next_have(&mut self, _graph: &mut crate::Graph<'_, '_>) -> Option<ExnResult<ObjectId>> {
         None
     }
 
-    fn in_common_with_remote(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> Result<bool, Error> {
+    fn in_common_with_remote(&mut self, _id: ObjectId, _graph: &mut crate::Graph<'_, '_>) -> ExnResult<bool> {
         Ok(false)
     }
 }
diff --git a/gix-negotiate/src/skipping.rs b/gix-negotiate/src/skipping.rs
index 91e1c3dffb1..09ebca5b393 100644
--- a/gix-negotiate/src/skipping.rs
+++ b/gix-negotiate/src/skipping.rs
@@ -1,7 +1,8 @@
 use gix_date::SecondsSinceUnixEpoch;
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 
-use crate::{Error, Flags, Metadata, Negotiator};
+use crate::{Flags, Metadata, Negotiator};
 
 pub(crate) struct Algorithm {
     revs: gix_revwalk::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
@@ -19,7 +20,7 @@ impl Default for Algorithm {
 
 impl Algorithm {
     /// Add `id` to our priority queue and *add* `flags` to it.
-    fn add_to_queue(&mut self, id: ObjectId, mark: Flags, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn add_to_queue(&mut self, id: ObjectId, mark: Flags, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         let commit = graph.get_or_insert_commit(id, |entry| {
             entry.flags |= mark | Flags::SEEN;
         })?;
@@ -32,7 +33,7 @@ impl Algorithm {
         Ok(())
     }
 
-    fn mark_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn mark_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         let mut is_common = false;
         if let Some(commit) = graph
             .get_or_insert_commit(id, |entry| {
@@ -77,7 +78,7 @@ impl Algorithm {
         entry: Metadata,
         parent_id: ObjectId,
         graph: &mut crate::Graph<'_, '_>,
-    ) -> Result<bool, Error> {
+    ) -> ExnResult<bool> {
         let mut was_seen = false;
         if let Some(parent) = graph
             .get(&parent_id)
@@ -112,7 +113,7 @@ impl Algorithm {
 }
 
 impl Negotiator for Algorithm {
-    fn known_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn known_common(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         if graph
             .get(&id)
             .is_some_and(|commit| commit.data.flags.contains(Flags::SEEN))
@@ -122,7 +123,7 @@ impl Negotiator for Algorithm {
         self.add_to_queue(id, Flags::ADVERTISED, graph)
     }
 
-    fn add_tip(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<(), Error> {
+    fn add_tip(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult {
         if graph
             .get(&id)
             .is_some_and(|commit| commit.data.flags.contains(Flags::SEEN))
@@ -132,7 +133,7 @@ impl Negotiator for Algorithm {
         self.add_to_queue(id, Flags::default(), graph)
     }
 
-    fn next_have(&mut self, graph: &mut crate::Graph<'_, '_>) -> Option<Result<ObjectId, Error>> {
+    fn next_have(&mut self, graph: &mut crate::Graph<'_, '_>) -> Option<ExnResult<ObjectId>> {
         loop {
             let id = self.revs.pop_value().filter(|_| self.non_common_revs != 0)?;
             let commit = graph.get_mut(&id).expect("it was added to the graph by now");
@@ -165,7 +166,7 @@ impl Negotiator for Algorithm {
         }
     }
 
-    fn in_common_with_remote(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> Result<bool, Error> {
+    fn in_common_with_remote(&mut self, id: ObjectId, graph: &mut crate::Graph<'_, '_>) -> ExnResult<bool> {
         let mut was_seen = false;
         let known_to_be_common = graph.get(&id).is_some_and(|commit| {
             was_seen = commit.data.flags.contains(Flags::SEEN);
diff --git a/gix-negotiate/tests/baseline/mod.rs b/gix-negotiate/tests/baseline/mod.rs
index 6e65f6da2c2..6b571977591 100644
--- a/gix-negotiate/tests/baseline/mod.rs
+++ b/gix-negotiate/tests/baseline/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::cell::RefCell;
 
 use gix_negotiate::Algorithm;
@@ -5,7 +6,7 @@ use gix_object::{FindExt, bstr, bstr::ByteSlice};
 use gix_ref::{file::ReferenceExt, store::WriteReflog};
 
 #[test]
-fn run() -> crate::Result {
+fn run() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_repos.sh")?;
     for case in [
         "no_parents",
@@ -74,7 +75,7 @@ fn run() -> crate::Result {
                 for tip in lookup_names(&["HEAD"]).into_iter().chain(
                     refs.iter()?
                         .prefixed(b"refs/heads".try_into().unwrap())?
-                        .filter_map(Result::ok)
+                        .filter_map(std::result::Result::ok)
                         .map(|r| r.target.into_id()),
                 ) {
                     if debug {
diff --git a/gix-note/Cargo.toml b/gix-note/Cargo.toml
index 1d148cb9228..491a9c81d9c 100644
--- a/gix-note/Cargo.toml
+++ b/gix-note/Cargo.toml
@@ -34,6 +34,7 @@ gix-hash = { version = "^0.26.2", path = "../gix-hash" }
 gix-object = { version = "^0.64.1", path = "../gix-object" }
 
 [dev-dependencies]
+insta = "1.46.3"
 criterion = "0.8.2"
 gix-note = { path = ".", features = ["sha1", "sha256"] }
 gix-odb = { path = "../gix-odb" }
diff --git a/gix-note/src/lib.rs b/gix-note/src/lib.rs
index 9120a5e1f1f..1f8ef86461f 100644
--- a/gix-note/src/lib.rs
+++ b/gix-note/src/lib.rs
@@ -2,7 +2,7 @@
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
 
-use gix_error::{CorruptionError, ErrorExt, ResultExt, ValidationError, message};
+use gix_error::{ErrorExt, ExnResult, ResultExt, corruption, message, validation};
 use gix_hash::{ObjectId, oid};
 use gix_object::{
     Find, FindExt, Tree, Write,
@@ -10,9 +10,6 @@ use gix_object::{
     tree::{Editor, Entry, EntryKind, EntryMode},
 };
 
-/// The type-erased error returned by note operations.
-pub type Error = gix_error::Exn;
-
 /// The result of changing one note mapping.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Edit {
@@ -48,7 +45,7 @@ pub struct State {
 
 impl State {
     /// Initialize state from `root_tree_id`, loading only its root tree from `objects`.
-    pub fn new(root_tree_id: ObjectId, objects: &impl Find) -> Result<Self, Error> {
+    pub fn new(root_tree_id: ObjectId, objects: &impl Find) -> ExnResult<Self> {
         let mut root = InternalNode::default();
         let mut non_notes = Vec::new();
         load_subtree(
@@ -90,7 +87,7 @@ impl State {
     /// Fanout subtrees on the lookup path are materialized once and retained for
     /// subsequent operations. Entries that do not conform to Git's notes layout
     /// are ignored.
-    pub fn get(&mut self, annotated_object_id: &oid, objects: &impl Find) -> Result<Option<ObjectId>, Error> {
+    pub fn get(&mut self, annotated_object_id: &oid, objects: &impl Find) -> ExnResult<Option<ObjectId>> {
         validate_annotated_hash_kind(self.root_tree_id.kind(), annotated_object_id)?;
         self.reset_on_error(|state| state.root.get(annotated_object_id, 0, objects, &mut state.non_notes))
     }
@@ -110,7 +107,7 @@ impl State {
         annotated_object_id: ObjectId,
         note_blob_id: ObjectId,
         objects: &(impl Find + Write),
-    ) -> Result<Edit, Error> {
+    ) -> ExnResult<Edit> {
         let previous = self.edit(annotated_object_id, Some(note_blob_id), objects)?;
         Ok(Edit {
             tree: self.write(objects)?,
@@ -124,7 +121,7 @@ impl State {
     /// removed note. This also writes changes staged by [`Self::edit()`].
     ///
     /// If there is no such note and no staged changes, the root is returned unchanged.
-    pub fn remove(&mut self, annotated_object_id: ObjectId, objects: &(impl Find + Write)) -> Result<Edit, Error> {
+    pub fn remove(&mut self, annotated_object_id: ObjectId, objects: &(impl Find + Write)) -> ExnResult<Edit> {
         let previous = self.edit(annotated_object_id, None, objects)?;
         Ok(Edit {
             tree: self.write(objects)?,
@@ -145,7 +142,7 @@ impl State {
         annotated_object_id: ObjectId,
         note_blob_id: Option<ObjectId>,
         objects: &impl Find,
-    ) -> Result<Option<ObjectId>, Error> {
+    ) -> ExnResult<Option<ObjectId>> {
         if let Some(note_blob_id) = note_blob_id {
             validate_replace_hash_kinds(
                 self.root_tree_id.kind(),
@@ -181,7 +178,7 @@ impl State {
     /// progressive fanout and non-note preservation as [`Self::replace()`]. If there are no staged
     /// changes, return the current root without writing any objects. On failure, discard staged edits
     /// and recover from the last successfully written root.
-    pub fn write(&mut self, objects: &(impl Find + Write)) -> Result<ObjectId, Error> {
+    pub fn write(&mut self, objects: &(impl Find + Write)) -> ExnResult<ObjectId> {
         if !self.dirty {
             return Ok(self.root_tree_id);
         }
@@ -194,7 +191,7 @@ impl State {
         })
     }
 
-    fn reset_on_error<T>(&mut self, operation: impl FnOnce(&mut Self) -> Result<T, Error>) -> Result<T, Error> {
+    fn reset_on_error<T>(&mut self, operation: impl FnOnce(&mut Self) -> ExnResult<T>) -> ExnResult<T> {
         let result = operation(self);
         if result.is_err() {
             let root_tree_id = self.root_tree_id;
@@ -216,22 +213,18 @@ fn validate_replace_hash_kinds(
     root: gix_hash::Kind,
     annotated_object: gix_hash::Kind,
     note_blob: gix_hash::Kind,
-) -> Result<(), Error> {
+) -> ExnResult {
     if annotated_object != root || note_blob != root {
         return Err(
-            ValidationError::from("Notes, annotated objects, and their root tree must use the same hash kind")
-                .raise_erased(),
+            validation("Notes, annotated objects, and their root tree must use the same hash kind").raise_erased(),
         );
     }
     Ok(())
 }
 
-fn validate_annotated_hash_kind(root: gix_hash::Kind, annotated_object_id: &oid) -> Result<(), Error> {
+fn validate_annotated_hash_kind(root: gix_hash::Kind, annotated_object_id: &oid) -> ExnResult {
     if annotated_object_id.kind() != root {
-        return Err(
-            ValidationError::from("The annotated object and notes root tree must use the same hash kind")
-                .raise_erased(),
-        );
+        return Err(validation("The annotated object and notes root tree must use the same hash kind").raise_erased());
     }
     Ok(())
 }
@@ -305,7 +298,7 @@ impl InternalNode {
         nibble: usize,
         objects: &impl Find,
         non_notes: &mut Vec<TreeEntry>,
-    ) -> Result<Option<ObjectId>, Error> {
+    ) -> ExnResult<Option<ObjectId>> {
         if self.load_matching_subtree(annotated_object_id, nibble, objects, non_notes)? {
             return self.get(annotated_object_id, nibble, objects, non_notes);
         }
@@ -329,13 +322,7 @@ impl InternalNode {
         }
     }
 
-    fn insert(
-        &mut self,
-        entry: Node,
-        nibble: usize,
-        objects: &impl Find,
-        non_notes: &mut Vec<TreeEntry>,
-    ) -> Result<(), Error> {
+    fn insert(&mut self, entry: Node, nibble: usize, objects: &impl Find, non_notes: &mut Vec<TreeEntry>) -> ExnResult {
         if self.load_matching_subtree(entry.key(), nibble, objects, non_notes)? {
             return self.insert(entry, nibble, objects, non_notes);
         }
@@ -354,11 +341,9 @@ impl InternalNode {
             }
             Node::Note(note) => {
                 if matches!(&entry, Node::Note(incoming) if incoming.annotated_object_id == note.annotated_object_id) {
-                    return Err(CorruptionError::from(format!(
-                        "Multiple notes map to object {}",
-                        note.annotated_object_id
-                    ))
-                    .raise_erased());
+                    return Err(
+                        corruption(format!("Multiple notes map to object {}", note.annotated_object_id)).raise_erased(),
+                    );
                 }
                 if let Node::Subtree(subtree) = &entry
                     && subtree.contains(&note.annotated_object_id)
@@ -387,7 +372,7 @@ impl InternalNode {
         nibble: usize,
         objects: &impl Find,
         non_notes: &mut Vec<TreeEntry>,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         let mut child = InternalNode::default();
         child.insert(existing, nibble + 1, objects, non_notes)?;
         child.insert(entry, nibble + 1, objects, non_notes)?;
@@ -401,7 +386,7 @@ impl InternalNode {
         nibble: usize,
         objects: &impl Find,
         non_notes: &mut Vec<TreeEntry>,
-    ) -> Result<Option<ObjectId>, Error> {
+    ) -> ExnResult<Option<ObjectId>> {
         if self.load_matching_subtree(annotated_object_id, nibble, objects, non_notes)? {
             return self.remove(annotated_object_id, nibble, objects, non_notes);
         }
@@ -442,7 +427,7 @@ impl InternalNode {
         nibble: usize,
         objects: &impl Find,
         non_notes: &mut Vec<TreeEntry>,
-    ) -> Result<bool, Error> {
+    ) -> ExnResult<bool> {
         let is_match = self.children[0]
             .as_deref()
             .is_some_and(|node| matches!(node, Node::Subtree(subtree) if subtree.contains(key)));
@@ -486,7 +471,7 @@ fn load_subtree(
     nibble: usize,
     objects: &impl Find,
     non_notes: &mut Vec<TreeEntry>,
-) -> Result<(), Error> {
+) -> ExnResult {
     let mut buf = Vec::new();
     let tree = objects
         .find_tree(&subtree.tree_id, &mut buf)
@@ -551,7 +536,7 @@ impl InternalNode {
         non_notes: &mut Vec<TreeEntry>,
         hash: gix_hash::Kind,
         objects: &(impl Find + Write),
-    ) -> Result<ObjectId, Error> {
+    ) -> ExnResult<ObjectId> {
         let mut notes = Vec::new();
         self.collect_for_write(0, 0, objects, non_notes, &mut notes)?;
         if non_notes.is_empty() {
@@ -570,7 +555,7 @@ impl InternalNode {
                 .or_raise_erased(|| message("Could not add a note tree entry"))?;
         }
         editor
-            .write(|tree| objects.write(tree).map_err(gix_error::Error::from_boxed))
+            .write(|tree| objects.write(tree))
             .or_raise_erased(|| message("Could not write the notes tree"))
     }
 
@@ -585,7 +570,7 @@ impl InternalNode {
         objects: &impl Find,
         non_notes: &mut Vec<TreeEntry>,
         notes: &mut Vec<TreeEntry>,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         let fanout = if nibble.is_multiple_of(2)
             && nibble <= 2 * fanout
             && self
@@ -636,7 +621,7 @@ impl InternalNode {
 
 /// This is faster than going through the tree editor, whose characteristics are useful enough
 /// to bear worse performance in the uncommon case where non-note entries are present.
-fn write_note_entries(notes: &[TreeEntry], level: usize, objects: &impl Write) -> Result<ObjectId, Error> {
+fn write_note_entries(notes: &[TreeEntry], level: usize, objects: &impl Write) -> ExnResult<ObjectId> {
     let mut entries = Vec::new();
     let mut start = 0;
     while start < notes.len() {
@@ -667,7 +652,6 @@ fn write_note_entries(notes: &[TreeEntry], level: usize, objects: &impl Write) -
 
     objects
         .write(&Tree { entries })
-        .map_err(gix_error::Error::from_boxed)
         .or_raise_erased(|| message("Could not write the notes tree"))
 }
 
diff --git a/gix-note/tests/note.rs b/gix-note/tests/note.rs
index 87b1a49e2ab..faaa8146616 100644
--- a/gix-note/tests/note.rs
+++ b/gix-note/tests/note.rs
@@ -4,6 +4,7 @@ use std::{
     io::{self, Read},
 };
 
+use gix_error::{ErrorExt, ExnResult};
 use gix_hash::{Kind, ObjectId, oid};
 use gix_object::{
     FindExt, Tree, Write,
@@ -15,12 +16,13 @@ type ObjectDb = gix_odb::memory::Proxy<gix_object::find::Never>;
 
 mod one_shot {
     use super::*;
+    use gix_error::ExnResult;
 
     pub fn get(
         root_tree_id: ObjectId,
         annotated_object_id: &oid,
         objects: &impl gix_object::Find,
-    ) -> Result<Option<ObjectId>, gix_note::Error> {
+    ) -> ExnResult<Option<ObjectId>> {
         let mut state = gix_note::State::new(root_tree_id, objects)?;
         state.get(annotated_object_id, objects)
     }
@@ -30,7 +32,7 @@ mod one_shot {
         annotated_object_id: ObjectId,
         note_blob_id: ObjectId,
         objects: &(impl gix_object::Find + Write),
-    ) -> Result<gix_note::Edit, gix_note::Error> {
+    ) -> ExnResult<gix_note::Edit> {
         let mut state = gix_note::State::new(root_tree_id, objects)?;
         state.replace(annotated_object_id, note_blob_id, objects)
     }
@@ -39,7 +41,7 @@ mod one_shot {
         root_tree_id: ObjectId,
         annotated_object_id: ObjectId,
         objects: &(impl gix_object::Find + Write),
-    ) -> Result<gix_note::Edit, gix_note::Error> {
+    ) -> ExnResult<gix_note::Edit> {
         let mut state = gix_note::State::new(root_tree_id, objects)?;
         state.remove(annotated_object_id, objects)
     }
@@ -64,46 +66,32 @@ impl CountingObjectDb {
         }
     }
 
-    fn maybe_fail_write(&self) -> Result<(), gix_object::write::Error> {
+    fn maybe_fail_write(&self) -> ExnResult {
         if self.fail_next_write.replace(false) {
-            return Err(io::Error::other("injected write failure").into());
+            return Err(io::Error::other("injected write failure").raise_erased());
         }
         Ok(())
     }
 }
 
 impl gix_object::Find for CountingObjectDb {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         self.reads.set(self.reads.get() + 1);
         if self.fail_next_read.replace(false) {
-            return Err(io::Error::other("injected read failure").into());
+            return Err(io::Error::other("injected read failure").raise_erased());
         }
         self.inner.try_find(id, buffer)
     }
 }
 
 impl gix_object::Write for CountingObjectDb {
-    fn write_buf_with_known_id(
-        &self,
-        kind: gix_object::Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, gix_object::write::Error> {
+    fn write_buf_with_known_id(&self, kind: gix_object::Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         self.writes.set(self.writes.get() + 1);
         self.maybe_fail_write()?;
         self.inner.write_buf_with_known_id(kind, from, id)
     }
 
-    fn write_stream(
-        &self,
-        kind: gix_object::Kind,
-        size: u64,
-        from: &mut dyn Read,
-    ) -> Result<ObjectId, gix_object::write::Error> {
+    fn write_stream(&self, kind: gix_object::Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         self.writes.set(self.writes.get() + 1);
         self.maybe_fail_write()?;
         self.inner.write_stream(kind, size, from)
@@ -115,7 +103,7 @@ impl gix_object::Write for CountingObjectDb {
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<ObjectId> {
         self.writes.set(self.writes.get() + 1);
         self.maybe_fail_write()?;
         self.inner.write_stream_with_known_id(kind, size, from, id)
@@ -881,35 +869,35 @@ fn mutations_reject_mixed_hash_kinds() -> gix_testtools::Result {
 
     let err =
         one_shot::replace(root, sha256, sha1, &objects).expect_err("the annotated object has the wrong hash kind");
-    let err = err.into_error();
     assert!(
         err.is_validation(),
         "an annotated-object hash mismatch is a validation error"
     );
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "Notes, annotated objects, and their root tree must use the same hash kind",
-        "replace reports an annotated-object hash mismatch"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "replace reports an annotated-object hash mismatch", @r#"
+    Message {
+        message: "Notes, annotated objects, and their root tree must use the same hash kind",
+        class: Validation,
+    }
+    "#);
     let err = one_shot::replace(root, sha1, sha256, &objects).expect_err("the note has the wrong hash kind");
-    let err = err.into_error();
     assert!(err.is_validation(), "a note hash mismatch is a validation error");
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "Notes, annotated objects, and their root tree must use the same hash kind",
-        "replace reports a note hash mismatch"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "replace reports a note hash mismatch", @r#"
+    Message {
+        message: "Notes, annotated objects, and their root tree must use the same hash kind",
+        class: Validation,
+    }
+    "#);
     let err = one_shot::remove(root, sha256, &objects).expect_err("the annotated object has the wrong hash kind");
-    let err = err.into_error();
     assert!(
         err.is_validation(),
         "an annotated-object hash mismatch is a validation error"
     );
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "The annotated object and notes root tree must use the same hash kind",
-        "remove reports an annotated-object hash mismatch"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "remove reports an annotated-object hash mismatch", @r#"
+    Message {
+        message: "The annotated object and notes root tree must use the same hash kind",
+        class: Validation,
+    }
+    "#);
     Ok(())
 }
 
@@ -973,13 +961,13 @@ fn mutations_reject_duplicate_mappings_across_layouts() -> gix_testtools::Result
 
     let err = one_shot::replace(root, other, flat_note, &objects)
         .expect_err("ambiguous existing mappings cannot be rewritten losslessly");
-    let err = err.into_error();
     assert!(err.is_corrupted(), "duplicate mappings indicate a corrupt notes tree");
-    assert_eq!(
-        err.probable_cause().to_string(),
-        format!("Multiple notes map to object {annotated}"),
-        "mutations diagnose duplicate flat and fanout mappings"
-    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err.probable_cause()), &[]), "mutations diagnose duplicate flat and fanout mappings", @r#"
+    Message {
+        message: "Multiple notes map to object Oid(1)",
+        class: Corruption,
+    }
+    "#);
     Ok(())
 }
 
diff --git a/gix-object/Cargo.toml b/gix-object/Cargo.toml
index 0b24abfefdc..94ecbe373ff 100644
--- a/gix-object/Cargo.toml
+++ b/gix-object/Cargo.toml
@@ -52,10 +52,10 @@ gix-date = { version = "^0.16.0", path = "../gix-date" }
 gix-utils = { version = "^0.3.6", path = "../gix-utils" }
 gix-command = { version = "^0.10.1", path = "../gix-command", optional = true }
 gix-path = { version = "^0.12.6", path = "../gix-path", optional = true }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-tempfile = { version = "^24.0.0", path = "../gix-tempfile", optional = true }
 
 itoa = "1.0.17"
-thiserror = "2.0.18"
 bstr = { version = "1.12.0", default-features = false, features = [
     "std",
     "unicode",
diff --git a/gix-object/benches/edit_tree.rs b/gix-object/benches/edit_tree.rs
index a721b1b80a2..b55a834fc64 100644
--- a/gix-object/benches/edit_tree.rs
+++ b/gix-object/benches/edit_tree.rs
@@ -1,5 +1,7 @@
 use std::{hint::black_box, rc::Rc};
 
+use gix_error::ExnResult;
+
 use criterion::{Criterion, Throughput, criterion_group, criterion_main};
 use gix_hash::ObjectId;
 use gix_object::{Tree, Write, tree, tree::EntryKind};
@@ -133,10 +135,7 @@ criterion_main!(benches);
 
 type ObjectDb = Rc<gix_odb::memory::Proxy<gix_object::find::Never>>;
 
-fn new_inmemory_writes() -> (
-    ObjectDb,
-    impl FnMut(&Tree) -> Result<ObjectId, gix_object::write::Error>,
-) {
+fn new_inmemory_writes() -> (ObjectDb, impl FnMut(&Tree) -> ExnResult<ObjectId>) {
     let odb = Rc::new(gix_odb::memory::Proxy::new(
         gix_object::find::Never,
         gix_hash::Kind::Sha1,
diff --git a/gix-object/src/commit/decode.rs b/gix-object/src/commit/decode.rs
index ae3d9750637..6f8ec48dedb 100644
--- a/gix-object/src/commit/decode.rs
+++ b/gix-object/src/commit/decode.rs
@@ -16,7 +16,7 @@ pub fn message<'a>(i: &mut &'a [u8]) -> ParseResult<&'a BStr> {
         *i = &[];
         Ok(rest.as_bstr())
     } else {
-        Err(crate::decode::Error)
+        Err(crate::decode::empty_error().into())
     }
 }
 
@@ -83,7 +83,7 @@ pub fn commit<'a>(i: &mut &'a [u8], object_hash: gix_hash::Kind) -> ParseResult<
 
     let message = message(i)?;
     if !i.is_empty() {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
 
     Ok(CommitRef {
diff --git a/gix-object/src/commit/mod.rs b/gix-object/src/commit/mod.rs
index 43f2df6360d..a81fee0009f 100644
--- a/gix-object/src/commit/mod.rs
+++ b/gix-object/src/commit/mod.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, ByteSlice};
+use gix_error::ExnMessageResult;
 
 use crate::parse::parse_signature;
 use crate::{Commit, CommitRef, TagRef};
@@ -47,7 +48,7 @@ mod write;
 impl<'a> CommitRef<'a> {
     /// Deserialize a commit from the given `data` bytes while avoiding most allocations, using `object_hash` to know
     /// what kind of hash to expect for validation.
-    pub fn from_bytes(mut data: &'a [u8], object_hash: gix_hash::Kind) -> Result<CommitRef<'a>, crate::decode::Error> {
+    pub fn from_bytes(mut data: &'a [u8], object_hash: gix_hash::Kind) -> ExnMessageResult<CommitRef<'a>> {
         let input = &mut data;
         match decode::commit(input, object_hash) {
             Ok(tag) => Ok(tag),
@@ -81,14 +82,14 @@ impl<'a> CommitRef<'a> {
     /// Return the author, with whitespace trimmed.
     ///
     /// This is different from the `author` field which may contain whitespace.
-    pub fn author(&self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {
+    pub fn author(&self) -> ExnMessageResult<gix_actor::SignatureRef<'a>> {
         parse_signature(self.author).map(|signature| signature.trim())
     }
 
     /// Return the committer, with whitespace trimmed.
     ///
     /// This is different from the `committer` field which may contain whitespace.
-    pub fn committer(&self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {
+    pub fn committer(&self) -> ExnMessageResult<gix_actor::SignatureRef<'a>> {
         parse_signature(self.committer).map(|signature| signature.trim())
     }
 
@@ -98,7 +99,7 @@ impl<'a> CommitRef<'a> {
     }
 
     /// Returns the time at which this commit was created, or a default time if it could not be parsed.
-    pub fn time(&self) -> Result<gix_date::Time, crate::decode::Error> {
+    pub fn time(&self) -> ExnMessageResult<gix_date::Time> {
         parse_signature(self.committer).map(|signature| signature.time().unwrap_or_default())
     }
 }
@@ -106,12 +107,12 @@ impl<'a> CommitRef<'a> {
 /// Conversion
 impl CommitRef<'_> {
     /// Copy all fields of this instance into a fully owned commit, consuming this instance.
-    pub fn into_owned(self) -> Result<Commit, crate::decode::Error> {
+    pub fn into_owned(self) -> ExnMessageResult<Commit> {
         self.try_into()
     }
 
     /// Copy all fields of this instance into a fully owned commit, internally cloning this instance.
-    pub fn to_owned(self) -> Result<Commit, crate::decode::Error> {
+    pub fn to_owned(self) -> ExnMessageResult<Commit> {
         self.try_into()
     }
 }
@@ -165,7 +166,7 @@ where
     ///
     /// A merge tag is a tag object embedded within the respective header field of a commit, making
     /// it a child object of sorts.
-    pub fn mergetags(self) -> impl Iterator<Item = Result<TagRef<'a>, crate::decode::Error>> {
+    pub fn mergetags(self) -> impl Iterator<Item = ExnMessageResult<TagRef<'a>>> {
         let hash_kind = self.hash_kind;
         self.find_all("mergetag").map(move |b| TagRef::from_bytes(b, hash_kind))
     }
diff --git a/gix-object/src/commit/ref_iter.rs b/gix-object/src/commit/ref_iter.rs
index 9132e473ada..e38eb494212 100644
--- a/gix-object/src/commit/ref_iter.rs
+++ b/gix-object/src/commit/ref_iter.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{borrow::Cow, ops::Range};
 
 use bstr::BStr;
@@ -53,7 +54,7 @@ impl<'a> CommitRefIter<'a> {
     pub fn signature(
         data: &'a [u8],
         hash_kind: gix_hash::Kind,
-    ) -> Result<Option<(Cow<'a, BStr>, SignedData<'a>)>, crate::decode::Error> {
+    ) -> ExnMessageResult<Option<(Cow<'a, BStr>, SignedData<'a>)>> {
         let mut signature_and_range = None;
 
         let raw_tokens = CommitRefIterRaw {
@@ -84,9 +85,9 @@ impl<'a> CommitRefIter<'a> {
     /// Errors are coerced into options, hiding whether there was an error or not. The caller should assume an error if they
     /// call the method as intended. Such a squelched error cannot be recovered unless the objects data is retrieved and parsed again.
     /// `next()`.
-    pub fn tree_id(&mut self) -> Result<ObjectId, crate::decode::Error> {
+    pub fn tree_id(&mut self) -> ExnMessageResult<ObjectId> {
         let tree_id = self.next().ok_or_else(missing_field)??;
-        Token::try_into_id(tree_id).ok_or_else(missing_field)
+        Ok(Token::try_into_id(tree_id).ok_or_else(missing_field)?)
     }
 
     /// Return all `parent_ids` as iterator.
@@ -112,7 +113,7 @@ impl<'a> CommitRefIter<'a> {
     }
 
     /// Returns the committer signature if there is no decoding error.
-    pub fn committer(mut self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {
+    pub fn committer(mut self) -> ExnMessageResult<gix_actor::SignatureRef<'a>> {
         self.find_map(|t| match t {
             Ok(Token::Committer { signature }) => Some(Ok(signature)),
             Err(err) => Some(Err(err)),
@@ -124,7 +125,7 @@ impl<'a> CommitRefIter<'a> {
     /// Returns the author signature if there is no decoding error.
     ///
     /// It may contain white space surrounding it, and is exactly as parsed.
-    pub fn author(mut self) -> Result<gix_actor::SignatureRef<'a>, crate::decode::Error> {
+    pub fn author(mut self) -> ExnMessageResult<gix_actor::SignatureRef<'a>> {
         self.find_map(|t| match t {
             Ok(Token::Author { signature }) => Some(Ok(signature)),
             Err(err) => Some(Err(err)),
@@ -137,7 +138,7 @@ impl<'a> CommitRefIter<'a> {
     ///
     /// It may contain white space surrounding it, and is exactly as
     //  parsed.
-    pub fn message(mut self) -> Result<&'a BStr, crate::decode::Error> {
+    pub fn message(mut self) -> ExnMessageResult<&'a BStr> {
         self.find_map(|t| match t {
             Ok(Token::Message(msg)) => Some(Ok(msg)),
             Err(err) => Some(Err(err)),
@@ -148,7 +149,7 @@ impl<'a> CommitRefIter<'a> {
     }
 }
 
-fn missing_field() -> crate::decode::Error {
+fn missing_field() -> gix_error::Message {
     crate::decode::empty_error()
 }
 
@@ -158,7 +159,7 @@ impl<'a> CommitRefIter<'a> {
         mut i: &'a [u8],
         state: &mut State,
         hash_kind: gix_hash::Kind,
-    ) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+    ) -> ExnMessageResult<(&'a [u8], Token<'a>)> {
         let input = &mut i;
         match Self::next_inner_(input, state, hash_kind) {
             Ok(token) => Ok((*input, token)),
@@ -166,11 +167,7 @@ impl<'a> CommitRefIter<'a> {
         }
     }
 
-    fn next_inner_(
-        input: &mut &'a [u8],
-        state: &mut State,
-        hash_kind: gix_hash::Kind,
-    ) -> Result<Token<'a>, crate::decode::Error> {
+    fn next_inner_(input: &mut &'a [u8], state: &mut State, hash_kind: gix_hash::Kind) -> ExnMessageResult<Token<'a>> {
         use State::*;
         Ok(match state {
             Tree => {
@@ -250,7 +247,7 @@ impl<'a> CommitRefIter<'a> {
 }
 
 impl<'a> Iterator for CommitRefIter<'a> {
-    type Item = Result<Token<'a>, crate::decode::Error>;
+    type Item = ExnMessageResult<Token<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.data.is_empty() {
@@ -278,7 +275,7 @@ struct CommitRefIterRaw<'a> {
 }
 
 impl<'a> Iterator for CommitRefIterRaw<'a> {
-    type Item = Result<RawToken<'a>, crate::decode::Error>;
+    type Item = ExnMessageResult<RawToken<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.data.is_empty() {
diff --git a/gix-object/src/data.rs b/gix-object/src/data.rs
index 93d9ed352c6..6ee1f1858db 100644
--- a/gix-object/src/data.rs
+++ b/gix-object/src/data.rs
@@ -1,6 +1,7 @@
 //! Contains a borrowed Object bound to a buffer holding its decompressed data.
 
 use crate::{BlobRef, CommitRef, CommitRefIter, Data, Kind, ObjectRef, TagRef, TagRefIter, TreeRef, TreeRefIter};
+use gix_error::ExnMessageResult;
 
 impl<'a> Data<'a> {
     /// Constructs a new data object from `data`, `kind` and `object_hash`.
@@ -16,7 +17,7 @@ impl<'a> Data<'a> {
     ///
     /// **Note** that [mutable, decoded objects][crate::Object] can be created from [`Data`]
     /// using [`crate::ObjectRef::into_owned()`].
-    pub fn decode(&self) -> Result<ObjectRef<'a>, crate::decode::Error> {
+    pub fn decode(&self) -> ExnMessageResult<ObjectRef<'a>> {
         Ok(match self.kind {
             Kind::Tree => ObjectRef::Tree(TreeRef::from_bytes(self.data, self.object_hash)?),
             Kind::Blob => ObjectRef::Blob(BlobRef { data: self.data }),
@@ -55,23 +56,16 @@ impl<'a> Data<'a> {
 
 /// Types supporting object hash verification
 pub mod verify {
-    /// Returned by [`crate::Data::verify_checksum()`]
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to hash object")]
-        Hasher(#[from] gix_hash::hasher::Error),
-        #[error(transparent)]
-        Verify(gix_hash::verify::Error),
-    }
+    use gix_error::{ExnMessageResult, ResultExt, corruption};
 
     impl crate::Data<'_> {
         /// Compute the checksum of `self` and compare it with the `expected` hash.
-        /// If the hashes do not match, an [`Error`] is returned, containing the actual
+        /// If the hashes do not match, an [`gix_error::Exn`] is returned, containing the actual
         /// hash of `self`.
-        pub fn verify_checksum(&self, expected: &gix_hash::oid) -> Result<gix_hash::ObjectId, Error> {
-            let actual = crate::compute_hash(expected.kind(), self.kind, self.data)?;
-            actual.verify(expected).map_err(Error::Verify)?;
+        pub fn verify_checksum(&self, expected: &gix_hash::oid) -> ExnMessageResult<gix_hash::ObjectId> {
+            let actual = crate::compute_hash(expected.kind(), self.kind, self.data)
+                .or_raise(|| corruption("Failed to hash object"))?;
+            actual.verify(expected)?;
             Ok(actual)
         }
     }
diff --git a/gix-object/src/encode.rs b/gix-object/src/encode.rs
index 842fbe87696..8465cdd4005 100644
--- a/gix-object/src/encode.rs
+++ b/gix-object/src/encode.rs
@@ -1,17 +1,7 @@
 //! Encoding utilities
 use std::io::{self, Write};
 
-use bstr::{BString, ByteSlice};
-
-/// An error returned when object encoding fails.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Newlines are not allowed in header values: {value:?}")]
-    NewlineInHeaderValue { value: BString },
-    #[error("Header values must not be empty")]
-    EmptyValue,
-}
+use bstr::ByteSlice;
 
 macro_rules! check {
     ($e: expr) => {
@@ -28,12 +18,6 @@ pub fn loose_header(kind: crate::Kind, size: u64) -> smallvec::SmallVec<[u8; 28]
     v
 }
 
-impl From<Error> for io::Error {
-    fn from(other: Error) -> io::Error {
-        io::Error::other(other)
-    }
-}
-
 pub(crate) fn header_field_multi_line(name: &[u8], value: &[u8], out: &mut dyn io::Write) -> io::Result<()> {
     let mut lines = value.as_bstr().lines_with_terminator();
     out.write_all(name)?;
@@ -80,12 +64,18 @@ pub(crate) fn trusted_header_id(
     out.write_all(NL)
 }
 
+/// Serialize a header field. Values containing newlines are retained as `input` bytes in the I/O error.
+/// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
 pub(crate) fn header_field(name: &[u8], value: &[u8], out: &mut dyn io::Write) -> io::Result<()> {
     if value.is_empty() {
-        return Err(Error::EmptyValue.into());
+        return Err(io::Error::other(gix_error::validation(
+            "Header values must not be empty",
+        )));
     }
     if value.find(NL).is_some() {
-        return Err(Error::NewlineInHeaderValue { value: value.into() }.into());
+        return Err(io::Error::other(
+            gix_error::validation("Newlines are not allowed in header values").with("input", value),
+        ));
     }
     trusted_header_field(name, value, out)
 }
diff --git a/gix-object/src/find.rs b/gix-object/src/find.rs
index 3892883630c..827ed435285 100644
--- a/gix-object/src/find.rs
+++ b/gix-object/src/find.rs
@@ -1,66 +1,4 @@
-/// The error type returned by the [`Find`](crate::Find) trait.
-pub type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
-///
-pub mod existing {
-    use gix_hash::ObjectId;
-
-    /// The error returned by the [`find(…)`][crate::FindExt::find()] trait methods.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Find(crate::find::Error),
-        #[error("An object with id {} could not be found", .oid)]
-        NotFound { oid: ObjectId },
-    }
-}
-
-///
-pub mod existing_object {
-    use gix_hash::ObjectId;
-
-    /// The error returned by the various [`find_*()`][crate::FindExt::find_commit()] trait methods.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Find(crate::find::Error),
-        #[error("Could not decode object at {oid}")]
-        Decode {
-            oid: ObjectId,
-            source: crate::decode::Error,
-        },
-        #[error("An object with id {oid} could not be found")]
-        NotFound { oid: ObjectId },
-        #[error("Expected object of kind {expected} but got {actual} at {oid}")]
-        ObjectKind {
-            oid: ObjectId,
-            actual: crate::Kind,
-            expected: crate::Kind,
-        },
-    }
-}
-
-///
-pub mod existing_iter {
-    use gix_hash::ObjectId;
-
-    /// The error returned by the various [`find_*_iter()`][crate::FindExt::find_commit_iter()] trait methods.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Find(crate::find::Error),
-        #[error("An object with id {oid} could not be found")]
-        NotFound { oid: ObjectId },
-        #[error("Expected object of kind {expected} but got {actual} at {oid}")]
-        ObjectKind {
-            oid: ObjectId,
-            actual: crate::Kind,
-            expected: crate::Kind,
-        },
-    }
-}
+use gix_error::{ExnResult, ResultExt};
 
 /// An implementation of object access traits that stores nothing and finds nothing.
 /// Use [`Never::panic_on_access()`] to panic on object access instead.
@@ -81,13 +19,13 @@ impl Never {
 pub struct PanicAlways;
 
 impl super::FindHeader for PanicAlways {
-    fn try_header(&self, _id: &gix_hash::oid) -> Result<Option<crate::Header>, Error> {
+    fn try_header(&self, _id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
         panic!("object header lookups are forbidden");
     }
 }
 
 impl super::Find for PanicAlways {
-    fn try_find<'a>(&self, _id: &gix_hash::oid, _buffer: &'a mut Vec<u8>) -> Result<Option<crate::Data<'a>>, Error> {
+    fn try_find<'a>(&self, _id: &gix_hash::oid, _buffer: &'a mut Vec<u8>) -> ExnResult<Option<crate::Data<'a>>> {
         panic!("object lookups are forbidden");
     }
 }
@@ -99,7 +37,7 @@ impl super::Exists for PanicAlways {
 }
 
 impl super::Write for PanicAlways {
-    fn write(&self, _object: &dyn crate::WriteTo) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    fn write(&self, _object: &dyn crate::WriteTo) -> ExnResult<gix_hash::ObjectId> {
         panic!("object writes are forbidden");
     }
 
@@ -108,7 +46,7 @@ impl super::Write for PanicAlways {
         _object: crate::Kind,
         _from: &[u8],
         _id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         panic!("object writes are forbidden");
     }
 
@@ -117,7 +55,7 @@ impl super::Write for PanicAlways {
         _kind: crate::Kind,
         _size: u64,
         _from: &mut dyn std::io::Read,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         panic!("object writes are forbidden");
     }
 
@@ -127,19 +65,19 @@ impl super::Write for PanicAlways {
         _size: u64,
         _from: &mut dyn std::io::Read,
         _id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         panic!("object writes are forbidden");
     }
 }
 
 impl super::FindHeader for Never {
-    fn try_header(&self, _id: &gix_hash::oid) -> Result<Option<crate::Header>, Error> {
+    fn try_header(&self, _id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
         Ok(None)
     }
 }
 
 impl super::Find for Never {
-    fn try_find<'a>(&self, _id: &gix_hash::oid, _buffer: &'a mut Vec<u8>) -> Result<Option<crate::Data<'a>>, Error> {
+    fn try_find<'a>(&self, _id: &gix_hash::oid, _buffer: &'a mut Vec<u8>) -> ExnResult<Option<crate::Data<'a>>> {
         Ok(None)
     }
 }
@@ -151,8 +89,8 @@ impl super::Exists for Never {
 }
 
 impl super::Write for Never {
-    fn write_buf(&self, object: crate::Kind, from: &[u8]) -> Result<gix_hash::ObjectId, crate::write::Error> {
-        crate::compute_hash(gix_hash::Kind::default(), object, from).map_err(Into::into)
+    fn write_buf(&self, object: crate::Kind, from: &[u8]) -> ExnResult<gix_hash::ObjectId> {
+        crate::compute_hash(gix_hash::Kind::default(), object, from).or_erased()
     }
 
     fn write_buf_with_known_id(
@@ -160,7 +98,7 @@ impl super::Write for Never {
         _object: crate::Kind,
         _from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         Ok(id)
     }
 
@@ -169,7 +107,7 @@ impl super::Write for Never {
         kind: crate::Kind,
         size: u64,
         from: &mut dyn std::io::Read,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         crate::compute_stream_hash(
             gix_hash::Kind::default(),
             kind,
@@ -178,7 +116,7 @@ impl super::Write for Never {
             &mut gix_features::progress::Discard,
             &std::sync::atomic::AtomicBool::new(false),
         )
-        .map_err(|err| Box::new(err.into_error()) as crate::write::Error)
+        .or_erased()
     }
 
     fn write_stream_with_known_id(
@@ -187,11 +125,11 @@ impl super::Write for Never {
         mut size: u64,
         from: &mut dyn std::io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = [0u8; u16::MAX as usize];
         while size != 0 {
             let bytes = (size as usize).min(buf.len());
-            from.read_exact(&mut buf[..bytes])?;
+            from.read_exact(&mut buf[..bytes]).or_erased()?;
             size -= bytes as u64;
         }
         Ok(id)
diff --git a/gix-object/src/kind.rs b/gix-object/src/kind.rs
index aeef9c4d72a..ae5c1e2ca77 100644
--- a/gix-object/src/kind.rs
+++ b/gix-object/src/kind.rs
@@ -1,25 +1,18 @@
-use std::fmt;
-
 use crate::Kind;
-
-/// The Error used in [`Kind::from_bytes()`].
-#[derive(Debug, Clone, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Unknown object kind: {kind:?}")]
-    InvalidObjectKind { kind: bstr::BString },
-}
+use gix_error::ExnMessageResult;
 
 /// Initialization
 impl Kind {
     /// Parse a `Kind` from its serialized loose git objects.
-    pub fn from_bytes(s: &[u8]) -> Result<Kind, Error> {
+    /// Invalid kind bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
+    pub fn from_bytes(s: &[u8]) -> ExnMessageResult<Kind> {
         Ok(match s {
             b"tree" => Kind::Tree,
             b"blob" => Kind::Blob,
             b"commit" => Kind::Commit,
             b"tag" => Kind::Tag,
-            _ => return Err(Error::InvalidObjectKind { kind: s.into() }),
+            _ => return Err(gix_error::validation("Unknown object kind").with("input", s).into()),
         })
     }
 }
@@ -57,8 +50,8 @@ impl Kind {
     }
 }
 
-impl fmt::Display for Kind {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for Kind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(std::str::from_utf8(self.as_bytes()).expect("Converting Kind name to utf8"))
     }
 }
diff --git a/gix-object/src/lib.rs b/gix-object/src/lib.rs
index efd9cffb8c7..e49c4cee994 100644
--- a/gix-object/src/lib.rs
+++ b/gix-object/src/lib.rs
@@ -37,8 +37,11 @@
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
+use gix_error::ExnMessageResult;
 use std::borrow::Cow;
 
+use gix_error::ExnResult;
+
 /// For convenience to allow using `bstr` without adding it to own cargo manifest.
 pub use bstr;
 use bstr::{BStr, BString, ByteSlice};
@@ -63,12 +66,6 @@ pub mod data;
 ///
 pub mod find;
 
-///
-pub mod write {
-    /// The error type returned by the [`Write`](crate::Write) trait.
-    pub type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
-}
-
 mod traits;
 pub use traits::{Exists, Find, FindExt, FindObjectOrHeader, Header as FindHeader, HeaderExt, Write, WriteTo};
 
@@ -317,61 +314,32 @@ pub struct Header {
 ///
 pub mod decode {
     mod error {
-        pub(crate) fn empty_error() -> Error {
-            Error
-        }
-
-        /// A type to indicate any error occurred during parsing.
-        #[derive(Debug, Clone, Copy, Default)]
-        pub struct Error;
-
-        impl std::fmt::Display for Error {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                f.write_str("object parsing failed")
-            }
+        pub(crate) fn empty_error() -> gix_error::Message {
+            gix_error::validation("object parsing failed")
         }
-
-        impl std::error::Error for Error {}
     }
-    pub use error::Error;
-    pub(crate) use error::empty_error;
 
-    /// Returned by [`loose_header()`]
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum LooseHeaderDecodeError {
-        #[error("{message}: {number:?}")]
-        ParseIntegerError {
-            source: gix_utils::btoi::ParseIntegerError,
-            message: &'static str,
-            number: bstr::BString,
-        },
-        #[error("{message}")]
-        InvalidHeader { message: &'static str },
-        #[error("The object header contained an unknown object kind.")]
-        ObjectHeader(#[from] super::kind::Error),
-    }
+    pub(crate) use error::empty_error;
 
     use bstr::ByteSlice;
+    use gix_error::{ErrorExt, ExnMessageResult, ResultExt, validation};
     /// Decode a loose object header, being `<kind> <size>\0`, returns
     /// ([`kind`](super::Kind), `size`, `consumed bytes`).
     ///
     /// `size` is the uncompressed size of the payload in bytes.
-    pub fn loose_header(input: &[u8]) -> Result<(super::Kind, u64, usize), LooseHeaderDecodeError> {
-        use LooseHeaderDecodeError::*;
-        let kind_end = input.find_byte(0x20).ok_or(InvalidHeader {
-            message: "Expected '<type> <size>'",
-        })?;
-        let kind = super::Kind::from_bytes(&input[..kind_end])?;
-        let size_end = input.find_byte(0x0).ok_or(InvalidHeader {
-            message: "Did not find 0 byte in header",
-        })?;
+    /// Invalid kind or size fields include their bytes as `input` [metadata](gix_error::Exn::metadata()).
+    pub fn loose_header(input: &[u8]) -> ExnMessageResult<(super::Kind, u64, usize)> {
+        let kind_end = input
+            .find_byte(0x20)
+            .ok_or_else(|| validation("Expected '<type> <size>'").raise())?;
+        let kind = super::Kind::from_bytes(&input[..kind_end])
+            .or_raise(|| validation("The object header contained an unknown object kind."))?;
+        let size_end = input
+            .find_byte(0x0)
+            .ok_or_else(|| validation("Did not find 0 byte in header").raise())?;
         let size_bytes = &input[kind_end + 1..size_end];
-        let size = gix_utils::btoi::to_signed(size_bytes).map_err(|source| ParseIntegerError {
-            source,
-            message: "Object size in header could not be parsed",
-            number: size_bytes.into(),
-        })?;
+        let size = gix_utils::btoi::to_signed(size_bytes)
+            .or_raise(|| validation("Object size in header could not be parsed").with("input", size_bytes))?;
         Ok((kind, size, size_end + 1))
     }
 }
@@ -384,11 +352,7 @@ fn object_hasher(hash_kind: gix_hash::Kind, object_kind: Kind, object_size: u64)
 
 /// A function to compute a hash of kind `object_hash` for an object of `object_kind` and its `data`.
 #[doc(alias = "hash_object", alias = "git2")]
-pub fn compute_hash(
-    hash_kind: gix_hash::Kind,
-    object_kind: Kind,
-    data: &[u8],
-) -> Result<gix_hash::ObjectId, gix_hash::hasher::Error> {
+pub fn compute_hash(hash_kind: gix_hash::Kind, object_kind: Kind, data: &[u8]) -> ExnMessageResult<gix_hash::ObjectId> {
     let mut hasher = object_hasher(hash_kind, object_kind, data.len() as u64);
     hasher.update(data);
     hasher.try_finalize()
@@ -406,7 +370,7 @@ pub fn compute_stream_hash(
     stream_len: u64,
     progress: &mut dyn gix_features::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
-) -> Result<gix_hash::ObjectId, gix_hash::io::Error> {
+) -> ExnResult<gix_hash::ObjectId> {
     let hasher = object_hasher(hash_kind, object_kind, stream_len);
     gix_hash::bytes_with_hasher(stream, stream_len, hasher, progress, should_interrupt)
 }
diff --git a/gix-object/src/object/convert.rs b/gix-object/src/object/convert.rs
index 8ee7a1ce0b6..dd71e11479e 100644
--- a/gix-object/src/object/convert.rs
+++ b/gix-object/src/object/convert.rs
@@ -1,12 +1,13 @@
+use gix_error::{Exn, Message};
 use std::convert::TryFrom;
 
 use crate::parse::parse_signature;
 use crate::{Blob, BlobRef, Commit, CommitRef, Object, ObjectRef, Tag, TagRef, Tree, TreeRef, tree};
 
 impl TryFrom<TagRef<'_>> for Tag {
-    type Error = crate::decode::Error;
+    type Error = Exn<Message>;
 
-    fn try_from(other: TagRef<'_>) -> Result<Tag, Self::Error> {
+    fn try_from(other: TagRef<'_>) -> std::result::Result<Tag, Self::Error> {
         let TagRef {
             target,
             name,
@@ -28,9 +29,9 @@ impl TryFrom<TagRef<'_>> for Tag {
 }
 
 impl TryFrom<CommitRef<'_>> for Commit {
-    type Error = crate::decode::Error;
+    type Error = Exn<Message>;
 
-    fn try_from(other: CommitRef<'_>) -> Result<Commit, Self::Error> {
+    fn try_from(other: CommitRef<'_>) -> std::result::Result<Commit, Self::Error> {
         let CommitRef {
             tree,
             parents,
@@ -101,9 +102,9 @@ impl<'a> From<&'a tree::Entry> for tree::EntryRef<'a> {
 }
 
 impl TryFrom<ObjectRef<'_>> for Object {
-    type Error = crate::decode::Error;
+    type Error = Exn<Message>;
 
-    fn try_from(v: ObjectRef<'_>) -> Result<Self, Self::Error> {
+    fn try_from(v: ObjectRef<'_>) -> std::result::Result<Self, Self::Error> {
         Ok(match v {
             ObjectRef::Tree(v) => Object::Tree(v.into()),
             ObjectRef::Blob(v) => Object::Blob(v.into()),
@@ -140,7 +141,7 @@ impl From<Blob> for Object {
 impl TryFrom<Object> for Tag {
     type Error = Object;
 
-    fn try_from(value: Object) -> Result<Self, Self::Error> {
+    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             Object::Tag(v) => v,
             _ => return Err(value),
@@ -151,7 +152,7 @@ impl TryFrom<Object> for Tag {
 impl TryFrom<Object> for Commit {
     type Error = Object;
 
-    fn try_from(value: Object) -> Result<Self, Self::Error> {
+    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             Object::Commit(v) => v,
             _ => return Err(value),
@@ -162,7 +163,7 @@ impl TryFrom<Object> for Commit {
 impl TryFrom<Object> for Tree {
     type Error = Object;
 
-    fn try_from(value: Object) -> Result<Self, Self::Error> {
+    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             Object::Tree(v) => v,
             _ => return Err(value),
@@ -173,7 +174,7 @@ impl TryFrom<Object> for Tree {
 impl TryFrom<Object> for Blob {
     type Error = Object;
 
-    fn try_from(value: Object) -> Result<Self, Self::Error> {
+    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             Object::Blob(v) => v,
             _ => return Err(value),
@@ -208,7 +209,7 @@ impl<'a> From<BlobRef<'a>> for ObjectRef<'a> {
 impl<'a> TryFrom<ObjectRef<'a>> for TagRef<'a> {
     type Error = ObjectRef<'a>;
 
-    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
+    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             ObjectRef::Tag(v) => v,
             _ => return Err(value),
@@ -219,7 +220,7 @@ impl<'a> TryFrom<ObjectRef<'a>> for TagRef<'a> {
 impl<'a> TryFrom<ObjectRef<'a>> for CommitRef<'a> {
     type Error = ObjectRef<'a>;
 
-    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
+    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             ObjectRef::Commit(v) => v,
             _ => return Err(value),
@@ -230,7 +231,7 @@ impl<'a> TryFrom<ObjectRef<'a>> for CommitRef<'a> {
 impl<'a> TryFrom<ObjectRef<'a>> for TreeRef<'a> {
     type Error = ObjectRef<'a>;
 
-    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
+    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             ObjectRef::Tree(v) => v,
             _ => return Err(value),
@@ -241,7 +242,7 @@ impl<'a> TryFrom<ObjectRef<'a>> for TreeRef<'a> {
 impl<'a> TryFrom<ObjectRef<'a>> for BlobRef<'a> {
     type Error = ObjectRef<'a>;
 
-    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
+    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
         Ok(match value {
             ObjectRef::Blob(v) => v,
             _ => return Err(value),
diff --git a/gix-object/src/object/mod.rs b/gix-object/src/object/mod.rs
index cac46323056..a934474acfb 100644
--- a/gix-object/src/object/mod.rs
+++ b/gix-object/src/object/mod.rs
@@ -1,4 +1,5 @@
 use crate::{Blob, Commit, Object, Tag, Tree};
+use gix_error::ExnMessageResult;
 
 mod convert;
 
@@ -99,7 +100,7 @@ impl Object {
         clippy::result_large_err,
         reason = "will be removed once `gix-error` is used consistently"
     )]
-    pub fn try_into_blob(self) -> Result<Blob, Self> {
+    pub fn try_into_blob(self) -> std::result::Result<Blob, Self> {
         match self {
             Object::Blob(v) => Ok(v),
             _ => Err(self),
@@ -117,7 +118,7 @@ impl Object {
         clippy::result_large_err,
         reason = "will be removed once `gix-error` is used consistently"
     )]
-    pub fn try_into_commit(self) -> Result<Commit, Self> {
+    pub fn try_into_commit(self) -> std::result::Result<Commit, Self> {
         match self {
             Object::Commit(v) => Ok(v),
             _ => Err(self),
@@ -128,7 +129,7 @@ impl Object {
         clippy::result_large_err,
         reason = "will be removed once `gix-error` is used consistently"
     )]
-    pub fn try_into_tree(self) -> Result<Tree, Self> {
+    pub fn try_into_tree(self) -> std::result::Result<Tree, Self> {
         match self {
             Object::Tree(v) => Ok(v),
             _ => Err(self),
@@ -139,7 +140,7 @@ impl Object {
         clippy::result_large_err,
         reason = "will be removed once `gix-error` is used consistently"
     )]
-    pub fn try_into_tag(self) -> Result<Tag, Self> {
+    pub fn try_into_tag(self) -> std::result::Result<Tag, Self> {
         match self {
             Object::Tag(v) => Ok(v),
             _ => Err(self),
@@ -185,41 +186,28 @@ impl Object {
     }
 }
 
-use crate::{
-    BlobRef, CommitRef, Kind, ObjectRef, TagRef, TreeRef,
-    decode::{Error as DecodeError, LooseHeaderDecodeError, loose_header},
-};
-
-#[derive(Debug, thiserror::Error)]
-pub enum LooseDecodeError {
-    #[error(transparent)]
-    InvalidHeader(#[from] LooseHeaderDecodeError),
-    #[error(transparent)]
-    InvalidContent(#[from] DecodeError),
-    #[error("Object sized {size} does not fit into memory - this can happen on 32 bit systems")]
-    OutOfMemory { size: u64 },
-}
+use crate::{BlobRef, CommitRef, Kind, ObjectRef, TagRef, TreeRef, decode::loose_header};
+use gix_error::{ErrorExt, ResultExt, validation};
 
 impl<'a> ObjectRef<'a> {
     /// Deserialize an object from a loose serialisation given `data`, parsing with the provided `object_hash`.
-    pub fn from_loose(data: &'a [u8], hash_kind: gix_hash::Kind) -> Result<ObjectRef<'a>, LooseDecodeError> {
+    pub fn from_loose(data: &'a [u8], hash_kind: gix_hash::Kind) -> ExnMessageResult<ObjectRef<'a>> {
         let (kind, size, offset) = loose_header(data)?;
 
+        let size = usize::try_from(size).or_raise(|| {
+            validation(format!(
+                "Object sized {size} does not fit into memory - this can happen on 32 bit systems"
+            ))
+        })?;
         let body = &data[offset..]
-            .get(..size.try_into().map_err(|_| LooseDecodeError::OutOfMemory { size })?)
-            .ok_or(LooseHeaderDecodeError::InvalidHeader {
-                message: "object data was shorter than its size declared in the header",
-            })?;
+            .get(..size)
+            .ok_or_else(|| validation("object data was shorter than its size declared in the header").raise())?;
 
-        Ok(Self::from_bytes(body, kind, hash_kind)?)
+        Self::from_bytes(body, kind, hash_kind)
     }
 
     /// Deserialize an object of `kind` from the given `data`, using `object_hash`.
-    pub fn from_bytes(
-        data: &'a [u8],
-        kind: Kind,
-        hash_kind: gix_hash::Kind,
-    ) -> Result<ObjectRef<'a>, crate::decode::Error> {
+    pub fn from_bytes(data: &'a [u8], kind: Kind, hash_kind: gix_hash::Kind) -> ExnMessageResult<ObjectRef<'a>> {
         Ok(match kind {
             Kind::Tree => ObjectRef::Tree(TreeRef::from_bytes(data, hash_kind)?),
             Kind::Blob => ObjectRef::Blob(BlobRef { data }),
@@ -231,14 +219,14 @@ impl<'a> ObjectRef<'a> {
     /// Convert the immutable object into a mutable version, consuming the source in the process.
     ///
     /// Note that this is an expensive operation.
-    pub fn into_owned(self) -> Result<Object, crate::decode::Error> {
+    pub fn into_owned(self) -> ExnMessageResult<Object> {
         self.try_into()
     }
 
     /// Convert this immutable object into its mutable counterpart.
     ///
     /// Note that this is an expensive operation.
-    pub fn to_owned(&self) -> Result<Object, crate::decode::Error> {
+    pub fn to_owned(&self) -> ExnMessageResult<Object> {
         self.clone().try_into()
     }
 }
diff --git a/gix-object/src/parse.rs b/gix-object/src/parse.rs
index 283c83afd6e..32ebca64ee8 100644
--- a/gix-object/src/parse.rs
+++ b/gix-object/src/parse.rs
@@ -1,11 +1,12 @@
 use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_error::ExnMessageResult;
 
 pub(crate) const NL: &[u8] = b"\n";
 pub(crate) const SPACE: &[u8] = b" ";
 const SPACE_OR_NL: &[u8] = b" \n";
 
 /// The result type shared by object parsers.
-pub(crate) type ParseResult<T> = Result<T, crate::decode::Error>;
+pub(crate) type ParseResult<T> = ExnMessageResult<T>;
 
 /// Parse any multi-line object header field.
 ///
@@ -24,25 +25,25 @@ pub(crate) fn any_header_field_multi_line<'a>(i: &mut &'a [u8]) -> ParseResult<(
     let name_end = c
         .find_byteset(SPACE_OR_NL)
         .filter(|pos| *pos > 0)
-        .ok_or(crate::decode::Error)?;
+        .ok_or_else(crate::decode::empty_error)?;
     if c.get(name_end) != Some(&b' ') {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
 
     c = &c[name_end + 1..];
-    let first_line_end = c.find_byte(b'\n').ok_or(crate::decode::Error)?;
+    let first_line_end = c.find_byte(b'\n').ok_or_else(crate::decode::empty_error)?;
     c = &c[first_line_end + 1..];
 
     let mut continuation_end = name_end + 1 + first_line_end + 1;
     let mut continuation_count = 0usize;
     while c.first() == Some(&b' ') {
-        let line_end = c.find_byte(b'\n').ok_or(crate::decode::Error)?;
+        let line_end = c.find_byte(b'\n').ok_or_else(crate::decode::empty_error)?;
         continuation_end += line_end + 1;
         c = &c[line_end + 1..];
         continuation_count += 1;
     }
     if continuation_count == 0 {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
 
     let bytes = input[name_end + 1..continuation_end].as_bstr();
@@ -72,10 +73,10 @@ pub(crate) fn header_field<'a, T>(
 ) -> ParseResult<T> {
     let c = *i;
     let Some(rest) = c.strip_prefix(name).and_then(|rest| rest.strip_prefix(SPACE)) else {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     };
     let Some(nl) = rest.find_byte(b'\n') else {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     };
     let value = parse_value(&rest[..nl])?;
     *i = &rest[nl + 1..];
@@ -94,9 +95,9 @@ pub(crate) fn any_header_field<'a>(i: &mut &'a [u8]) -> ParseResult<(&'a [u8], &
     let name_end = c
         .find_byteset(SPACE_OR_NL)
         .filter(|pos| *pos > 0)
-        .ok_or(crate::decode::Error)?;
+        .ok_or_else(crate::decode::empty_error)?;
     if c.get(name_end) != Some(&b' ') {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
     c = &c[name_end + 1..];
     if let Some(value_end) = c.find_byte(b'\n') {
@@ -105,7 +106,7 @@ pub(crate) fn any_header_field<'a>(i: &mut &'a [u8]) -> ParseResult<(&'a [u8], &
         *i = rest;
         Ok((&input[..name_end], value))
     } else {
-        Err(crate::decode::Error)
+        Err(crate::decode::empty_error().into())
     }
 }
 
@@ -116,7 +117,7 @@ pub(crate) fn any_header_field<'a>(i: &mut &'a [u8]) -> ParseResult<(&'a [u8], &
 /// match the expected object hash length.
 pub fn hex_hash(i: &[u8], hash_kind: gix_hash::Kind) -> ParseResult<&BStr> {
     if i.len() != hash_kind.len_in_hex() || !i.iter().all(u8::is_ascii_hexdigit) {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
     Ok(i.as_bstr())
 }
@@ -127,11 +128,11 @@ pub fn hex_hash(i: &[u8], hash_kind: gix_hash::Kind) -> ParseResult<&BStr> {
 /// The entire input slice must be consumed by
 /// `gix_actor`'s signature parser; trailing bytes cause an error.
 pub(crate) fn signature(mut i: &[u8]) -> ParseResult<gix_actor::SignatureRef<'_>> {
-    let signature = gix_actor::SignatureRef::from_bytes_consuming(&mut i).map_err(|_| crate::decode::Error)?;
+    let signature = gix_actor::SignatureRef::from_bytes_consuming(&mut i)?;
     if i.is_empty() {
         Ok(signature)
     } else {
-        Err(crate::decode::Error)
+        Err(crate::decode::empty_error().into())
     }
 }
 
@@ -147,6 +148,6 @@ pub(crate) fn signature_raw(i: &[u8]) -> ParseResult<&BStr> {
 ///
 /// This is a convenience wrapper around [`signature`] for callers that already
 /// hold byte-string data.
-pub(crate) fn parse_signature(raw: &BStr) -> Result<gix_actor::SignatureRef<'_>, crate::decode::Error> {
+pub(crate) fn parse_signature(raw: &BStr) -> ExnMessageResult<gix_actor::SignatureRef<'_>> {
     signature(raw.as_ref())
 }
diff --git a/gix-object/src/signature/sign.rs b/gix-object/src/signature/sign.rs
index e3a2a743462..0bdb94266ea 100644
--- a/gix-object/src/signature/sign.rs
+++ b/gix-object/src/signature/sign.rs
@@ -6,6 +6,7 @@ use std::{
 };
 
 use bstr::{BString, ByteSlice};
+use gix_error::{ErrorExt, ExnResult, ResultExt, corruption, message, validation};
 
 use crate::{Commit, CommitRef, Tag, TagRef, WriteTo};
 
@@ -28,52 +29,20 @@ pub struct Options {
     pub environment: Vec<(OsString, OsString)>,
 }
 
-/// The error returned when signing an object.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Decode(#[from] crate::decode::Error),
-    #[error(transparent)]
-    Encode(#[from] std::io::Error),
-    #[error("A signing key is required")]
-    MissingSigningKey,
-    #[error("Could not create or write a temporary signing file")]
-    TemporaryFile(#[source] std::io::Error),
-    #[error("Could not execute signing program {program:?}")]
-    Spawn {
-        program: OsString,
-        #[source]
-        source: std::io::Error,
-    },
-    #[error("Could not communicate with signing program {program:?}")]
-    Communicate {
-        program: OsString,
-        #[source]
-        source: std::io::Error,
-    },
-    #[error("Signing program {program:?} failed: {output}")]
-    Failed { program: OsString, output: BString },
-    #[error("The OpenPGP/X.509 signer did not report SIG_CREATED")]
-    MissingSignatureConfirmation,
-    #[error("The SSH signer produced no signature")]
-    MissingSshSignature(#[source] std::io::Error),
-}
-
 impl CommitRef<'_> {
     /// Return an owned copy of this commit with its active signature replaced by a newly created one.
-    pub fn sign(self, options: Options) -> Result<Commit, Error> {
-        self.into_owned()?.sign(options)
+    pub fn sign(self, options: Options) -> ExnResult<Commit> {
+        self.into_owned().or_erased()?.sign(options)
     }
 }
 
 impl Commit {
     /// Return this commit with its active signature replaced by a newly created one according to `options`.
-    pub fn sign(mut self, options: Options) -> Result<Commit, Error> {
+    pub fn sign(mut self, options: Options) -> ExnResult<Commit> {
         let signature_field = crate::commit::signature_field_name(self.tree.kind());
         self.extra_headers.retain(|(name, _)| name != signature_field);
         let mut payload = Vec::new();
-        self.write_to(&mut payload)?;
+        self.write_to(&mut payload).or_erased()?;
         let signature = sign(&payload, &options)?;
         self.extra_headers.push((signature_field.into(), signature));
         Ok(self)
@@ -83,17 +52,17 @@ impl Commit {
 impl TagRef<'_> {
     /// Return an owned copy of this annotated tag with its in-body signature replaced by a newly created one
     /// according to `options`.
-    pub fn sign(self, options: Options) -> Result<Tag, Error> {
-        self.into_owned()?.sign(options)
+    pub fn sign(self, options: Options) -> ExnResult<Tag> {
+        self.into_owned().or_erased()?.sign(options)
     }
 }
 
 impl Tag {
     /// Return this annotated tag with its in-body signature replaced by a newly created one according to `options`.
-    pub fn sign(mut self, options: Options) -> Result<Tag, Error> {
+    pub fn sign(mut self, options: Options) -> ExnResult<Tag> {
         self.signature = None;
         let mut payload = Vec::new();
-        self.write_to(&mut payload)?;
+        self.write_to(&mut payload).or_erased()?;
         // Tag signatures follow the message in the object body, separated by a newline which is itself signed. This
         // differs from commit signatures, which are inserted as a header after signing the commit without that header.
         payload.push(b'\n');
@@ -102,7 +71,7 @@ impl Tag {
     }
 }
 
-fn sign(payload: &[u8], options: &Options) -> Result<BString, Error> {
+fn sign(payload: &[u8], options: &Options) -> ExnResult<BString> {
     match options.format {
         Format::OpenPgp | Format::X509 => sign_gpg(payload, options),
         Format::Ssh => sign_ssh(payload, options),
@@ -116,9 +85,9 @@ fn command(options: &Options) -> gix_command::Prepare {
     )
 }
 
-fn sign_gpg(payload: &[u8], options: &Options) -> Result<BString, Error> {
+fn sign_gpg(payload: &[u8], options: &Options) -> ExnResult<BString> {
     if options.signing_key.is_empty() {
-        return Err(Error::MissingSigningKey);
+        return Err(validation("A signing key is required").raise_erased());
     }
     let output = run(
         command(options)
@@ -131,24 +100,26 @@ fn sign_gpg(payload: &[u8], options: &Options) -> Result<BString, Error> {
         payload,
     )?;
     if !output.status.success() {
-        return Err(Error::Failed {
-            program: options.program.clone(),
-            output: output.stderr.into(),
-        });
+        return Err(message!(
+            "Signing program {:?} failed: {}",
+            options.program,
+            output.stderr.as_bstr()
+        )
+        .raise_erased());
     }
     if !output
         .stderr
         .lines()
         .any(|line| line.starts_with(b"[GNUPG:] SIG_CREATED "))
     {
-        return Err(Error::MissingSignatureConfirmation);
+        return Err(corruption("The OpenPGP/X.509 signer did not report SIG_CREATED").raise_erased());
     }
     Ok(strip_cr_before_lf(output.stdout).into())
 }
 
-fn sign_ssh(payload: &[u8], options: &Options) -> Result<BString, Error> {
+fn sign_ssh(payload: &[u8], options: &Options) -> ExnResult<BString> {
     if options.signing_key.is_empty() {
-        return Err(Error::MissingSigningKey);
+        return Err(validation("A signing key is required").raise_erased());
     }
     let mut literal_key_file = None;
     let literal_key = options
@@ -183,23 +154,20 @@ fn sign_ssh(payload: &[u8], options: &Options) -> Result<BString, Error> {
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .spawn()
-        .map_err(|source| Error::Spawn {
-            program: options.program.clone(),
-            source,
-        })?
+        .or_raise_erased(|| message!("Could not execute signing program {:?}", options.program))?
         .wait_with_output()
-        .map_err(|source| Error::Communicate {
-            program: options.program.clone(),
-            source,
-        })?;
+        .or_raise_erased(|| message!("Could not communicate with signing program {:?}", options.program))?;
     drop(literal_key_file);
     if !output.status.success() {
-        return Err(Error::Failed {
-            program: options.program.clone(),
-            output: output.stderr.into(),
-        });
+        return Err(message!(
+            "Signing program {:?} failed: {}",
+            options.program,
+            output.stderr.as_bstr()
+        )
+        .raise_erased());
     }
-    let signature = std::fs::read(&signature_path).map_err(Error::MissingSshSignature);
+    let signature =
+        std::fs::read(&signature_path).or_raise_erased(|| corruption("The SSH signer produced no signature"));
     let _ = std::fs::remove_file(signature_path);
     Ok(strip_cr_before_lf(signature?).into())
 }
@@ -214,44 +182,39 @@ pub fn is_literal_ssh_key(key: &[u8]) -> Option<&[u8]> {
 }
 
 /// On Unix, creates a file with 0o600 just like Git.
-fn secure_temporary_file() -> Result<gix_tempfile::Handle<gix_tempfile::handle::Writable>, Error> {
+fn secure_temporary_file() -> ExnResult<gix_tempfile::Handle<gix_tempfile::handle::Writable>> {
     gix_tempfile::new(
         std::env::temp_dir(),
         gix_tempfile::ContainingDirectory::Exists,
         gix_tempfile::AutoRemove::Tempfile,
     )
-    .map_err(Error::TemporaryFile)
+    .or_raise_erased(|| message("Could not create or write a temporary signing file"))
 }
 
-fn write_temporary(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>, data: &[u8]) -> Result<(), Error> {
+fn write_temporary(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>, data: &[u8]) -> ExnResult {
     file.with_mut(|file| file.write_all(data))
-        .map_err(Error::TemporaryFile)?
-        .map_err(Error::TemporaryFile)
+        .or_raise_erased(|| message("Could not create or write a temporary signing file"))?
+        .or_raise_erased(|| message("Could not create or write a temporary signing file"))
 }
 
-fn temporary_path(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>) -> Result<PathBuf, Error> {
+fn temporary_path(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>) -> ExnResult<PathBuf> {
     file.with_mut(|file| file.path().to_owned())
-        .map_err(Error::TemporaryFile)
+        .or_raise_erased(|| message("Could not create or write a temporary signing file"))
 }
 
-fn run(command: gix_command::Prepare, program: &OsStr, input: &[u8]) -> Result<std::process::Output, Error> {
-    let mut child = command.spawn().map_err(|source| Error::Spawn {
-        program: program.to_owned(),
-        source,
-    })?;
+fn run(command: gix_command::Prepare, program: &OsStr, input: &[u8]) -> ExnResult<std::process::Output> {
+    let mut child = command
+        .spawn()
+        .or_raise_erased(|| message!("Could not execute signing program {program:?}"))?;
     child
         .stdin
         .take()
         .expect("configured as piped")
         .write_all(input)
-        .map_err(|source| Error::Communicate {
-            program: program.to_owned(),
-            source,
-        })?;
-    child.wait_with_output().map_err(|source| Error::Communicate {
-        program: program.to_owned(),
-        source,
-    })
+        .or_raise_erased(|| message!("Could not communicate with signing program {program:?}"))?;
+    child
+        .wait_with_output()
+        .or_raise_erased(|| message!("Could not communicate with signing program {program:?}"))
 }
 
 /// Normalize signer-produced CRLF line endings to LF before embedding the signature in an object.
diff --git a/gix-object/src/signature/verify.rs b/gix-object/src/signature/verify.rs
index 9bb4993028f..463924826ff 100644
--- a/gix-object/src/signature/verify.rs
+++ b/gix-object/src/signature/verify.rs
@@ -7,6 +7,7 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt, corruption, message, validation};
 
 use super::SignedData;
 
@@ -160,31 +161,11 @@ impl Outcome {
     }
 }
 
-/// The error returned when verifying an object signature.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("The signature format is unsupported")]
-    UnsupportedFormat,
-    #[error("The configured program format {program_format:?} does not match signature format {signature_format:?}")]
-    FormatMismatch {
-        program_format: Format,
-        signature_format: Format,
-    },
-    #[error("Could not create or write the temporary signature file")]
-    TemporaryFile(#[source] std::io::Error),
-    #[error("Could not execute signature verifier {program:?}")]
-    Spawn { program: OsString, source: std::io::Error },
-    #[error("Could not communicate with signature verifier {program:?}")]
-    Communicate { program: OsString, source: std::io::Error },
-    #[error("Signature time could not be formatted for SSH verification")]
-    CommitTime(#[source] Box<dyn std::error::Error + Send + Sync>),
-}
-
 impl SignedData<'_> {
     /// Verify `signature` over these exact object bytes with fully resolved `options`.
-    pub fn verify(&self, signature: &BStr, options: Options) -> Result<Outcome, Error> {
-        let format = Format::from_signature(signature).ok_or(Error::UnsupportedFormat)?;
+    pub fn verify(&self, signature: &BStr, options: Options) -> ExnResult<Outcome> {
+        let format = Format::from_signature(signature)
+            .ok_or_raise_erased(|| corruption("The signature format is unsupported"))?;
         match options {
             Options::OpenPgp {
                 program,
@@ -230,18 +211,21 @@ impl SignedData<'_> {
                 verify_time,
                 minimum_trust,
             ),
-            Options::OpenPgp { .. } => Err(Error::FormatMismatch {
-                program_format: Format::OpenPgp,
-                signature_format: format,
-            }),
-            Options::X509 { .. } => Err(Error::FormatMismatch {
-                program_format: Format::X509,
-                signature_format: format,
-            }),
-            Options::Ssh { .. } => Err(Error::FormatMismatch {
-                program_format: Format::Ssh,
-                signature_format: format,
-            }),
+            Options::OpenPgp { .. } => Err(validation(format!(
+                "The configured program format {:?} does not match signature format {format:?}",
+                Format::OpenPgp
+            ))
+            .raise_erased()),
+            Options::X509 { .. } => Err(validation(format!(
+                "The configured program format {:?} does not match signature format {format:?}",
+                Format::X509
+            ))
+            .raise_erased()),
+            Options::Ssh { .. } => Err(validation(format!(
+                "The configured program format {:?} does not match signature format {format:?}",
+                Format::Ssh
+            ))
+            .raise_erased()),
         }
     }
 
@@ -253,7 +237,7 @@ impl SignedData<'_> {
         program_arguments: Vec<OsString>,
         environment: Vec<(OsString, OsString)>,
         minimum_trust: TrustLevel,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         let mut signature_file = signature_file(signature)?;
         let path = signature_path(&mut signature_file)?;
         let mut command = prepare(&program, program_arguments, &environment);
@@ -299,10 +283,10 @@ impl SignedData<'_> {
         revocation_file: Option<PathBuf>,
         verify_time: gix_date::Time,
         minimum_trust: TrustLevel,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         let verify_time = verify_time
             .format(gix_date::time::CustomFormat::new("%Y%m%d%H%M%S"))
-            .map_err(|err| Error::CommitTime(Box::new(err)))?;
+            .or_raise_erased(|| message("Signature time could not be formatted for SSH verification"))?;
         let verify_time = format!("-Overify-time={verify_time}");
         let mut signature_file = signature_file(signature)?;
         let signature_path = super::ssh_path_argument(&signature_path(&mut signature_file)?);
@@ -392,35 +376,32 @@ impl SignedData<'_> {
         Ok(outcome)
     }
 
-    fn run(&self, command: gix_command::Prepare, program: &OsStr) -> Result<std::process::Output, Error> {
-        let mut child = command.spawn().map_err(|source| Error::Spawn {
-            program: program.to_owned(),
-            source,
-        })?;
+    fn run(&self, command: gix_command::Prepare, program: &OsStr) -> ExnResult<std::process::Output> {
+        let mut child = command
+            .spawn()
+            .or_raise_erased(|| message!("Could not execute signature verifier {program:?}"))?;
         let mut stdin = child.stdin.take().expect("configured as piped");
         let [before, after] = self.segments();
         if let Err(source) = stdin.write_all(before).and_then(|_| stdin.write_all(after)) {
             // A verifier may reject the invocation and exit without consuming all input. Its status and output are
             // still authoritative, whereas other write failures indicate an actual communication problem.
             if source.kind() != std::io::ErrorKind::BrokenPipe {
-                return Err(Error::Communicate {
-                    program: program.to_owned(),
-                    source,
-                });
+                return Err(source
+                    .and_raise(message!("Could not communicate with signature verifier {program:?}"))
+                    .erased());
             }
         }
         drop(stdin);
-        child.wait_with_output().map_err(|source| Error::Communicate {
-            program: program.to_owned(),
-            source,
-        })
+        child
+            .wait_with_output()
+            .or_raise_erased(|| message!("Could not communicate with signature verifier {program:?}"))
     }
 
     fn run_prepared(
         &self,
         common: (&OsStr, &[OsString], &[(OsString, OsString)]),
         args: impl IntoIterator<Item = OsString>,
-    ) -> Result<std::process::Output, Error> {
+    ) -> ExnResult<std::process::Output> {
         let (program, program_arguments, environment) = common;
         self.run(
             prepare(program, program_arguments.iter().cloned(), environment)
@@ -448,73 +429,62 @@ fn run_prepared(
     common: (&OsStr, &[OsString], &[(OsString, OsString)]),
     args: impl IntoIterator<Item = OsString>,
     input: &[u8],
-) -> Result<std::process::Output, Error> {
+) -> ExnResult<std::process::Output> {
     let (program, program_arguments, environment) = common;
     let command = prepare(program, program_arguments.iter().cloned(), environment)
         .args(args)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
-    let mut child = command.spawn().map_err(|source| Error::Spawn {
-        program: program.to_owned(),
-        source,
-    })?;
+    let mut child = command
+        .spawn()
+        .or_raise_erased(|| message!("Could not execute signature verifier {program:?}"))?;
     child
         .stdin
         .take()
         .expect("configured as piped")
         .write_all(input)
-        .map_err(|source| Error::Communicate {
-            program: program.to_owned(),
-            source,
-        })?;
-    child.wait_with_output().map_err(|source| Error::Communicate {
-        program: program.to_owned(),
-        source,
-    })
+        .or_raise_erased(|| message!("Could not communicate with signature verifier {program:?}"))?;
+    child
+        .wait_with_output()
+        .or_raise_erased(|| message!("Could not communicate with signature verifier {program:?}"))
 }
 
-fn signature_file(signature: &BStr) -> Result<gix_tempfile::Handle<gix_tempfile::handle::Writable>, Error> {
+fn signature_file(signature: &BStr) -> ExnResult<gix_tempfile::Handle<gix_tempfile::handle::Writable>> {
     temporary_file([signature.as_ref()])
 }
 
 fn temporary_file<'a>(
     data: impl IntoIterator<Item = &'a [u8]>,
-) -> Result<gix_tempfile::Handle<gix_tempfile::handle::Writable>, Error> {
+) -> ExnResult<gix_tempfile::Handle<gix_tempfile::handle::Writable>> {
     let mut file = gix_tempfile::new(
         std::env::temp_dir(),
         gix_tempfile::ContainingDirectory::Exists,
         gix_tempfile::AutoRemove::Tempfile,
     )
-    .map_err(Error::TemporaryFile)?;
+    .or_raise_erased(|| message("Could not create or write the temporary signature file"))?;
     file.with_mut(|file| {
         for data in data {
             file.write_all(data)?;
         }
-        Ok(())
+        Ok::<_, std::io::Error>(())
     })
-    .map_err(Error::TemporaryFile)?
-    .map_err(Error::TemporaryFile)?;
+    .or_raise_erased(|| message("Could not create or write the temporary signature file"))?
+    .or_raise_erased(|| message("Could not create or write the temporary signature file"))?;
     Ok(file)
 }
 
-fn signature_path(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>) -> Result<PathBuf, Error> {
+fn signature_path(file: &mut gix_tempfile::Handle<gix_tempfile::handle::Writable>) -> ExnResult<PathBuf> {
     file.with_mut(|file| file.path().to_owned())
-        .map_err(Error::TemporaryFile)
+        .or_raise_erased(|| message("Could not create or write the temporary signature file"))
 }
 
-fn run_without_input(command: gix_command::Prepare, program: &OsStr) -> Result<std::process::Output, Error> {
+fn run_without_input(command: gix_command::Prepare, program: &OsStr) -> ExnResult<std::process::Output> {
     command
         .spawn()
-        .map_err(|source| Error::Spawn {
-            program: program.to_owned(),
-            source,
-        })?
+        .or_raise_erased(|| message!("Could not execute signature verifier {program:?}"))?
         .wait_with_output()
-        .map_err(|source| Error::Communicate {
-            program: program.to_owned(),
-            source,
-        })
+        .or_raise_erased(|| message!("Could not communicate with signature verifier {program:?}"))
 }
 
 fn parse_gpg_output(format: Format, output: BString, raw_output: BString) -> Outcome {
@@ -604,6 +574,7 @@ fn parse_ssh_output(output: BString, signer: Option<BString>, trust_level: Trust
 #[cfg(test)]
 mod tests {
     use super::*;
+    use gix_error::ExnResult;
 
     #[test]
     fn parses_gpg_status() {
@@ -681,7 +652,7 @@ mod tests {
     }
 
     #[test]
-    fn rejects_good_ssh_output_from_a_failed_verifier() -> Result<(), Error> {
+    fn rejects_good_ssh_output_from_a_failed_verifier() -> ExnResult {
         let signed = SignedData::new(b"payloadsignature", 7..16);
         let outcome = signed.verify(
             BStr::new(b"-----BEGIN SSH SIGNATURE-----\n"),
@@ -754,19 +725,49 @@ mod tests {
             environment: Vec::new(),
             minimum_trust: TrustLevel::Undefined,
         };
-        assert!(matches!(
-            signed.verify(BStr::new(b"not a signature"), options.clone()),
-            Err(Error::UnsupportedFormat)
-        ));
+        let unsupported = signed
+            .verify(BStr::new(b"not a signature"), options.clone())
+            .expect_err("the unsupported signature is rejected");
+        insta::assert_debug_snapshot!(unsupported, "unsupported signature data is rejected before running a verifier", @"The signature format is unsupported");
         assert!(
-            matches!(
-                signed.verify(BStr::new(b"-----BEGIN SSH SIGNATURE-----\n"), options),
-                Err(Error::FormatMismatch {
-                    program_format: Format::X509,
-                    signature_format: Format::Ssh,
-                })
-            ),
-            "the mismatch identifies both the configured program and detected signature formats"
+            unsupported.is_corrupted(),
+            "an unrecognized object signature is corrupt"
+        );
+        let mismatch = signed
+            .verify(BStr::new(b"-----BEGIN SSH SIGNATURE-----\n"), options)
+            .expect_err("the mismatched signature is rejected");
+        assert!(
+            mismatch.is_validation(),
+            "a configured verifier which cannot handle the signature is invalid"
         );
+        insta::assert_debug_snapshot!(mismatch, "a format mismatch identifies the configured verifier and detected signature", @"The configured program format X509 does not match signature format Ssh");
+    }
+
+    #[test]
+    fn commit_time_keeps_the_formatting_error() {
+        let signed = SignedData::new(b"payloadsignature", 7..16);
+        let err = signed
+            .verify(
+                BStr::new(b"-----BEGIN SSH SIGNATURE-----\n"),
+                Options::Ssh {
+                    program: "must-not-run".into(),
+                    program_arguments: Vec::new(),
+                    environment: Vec::new(),
+                    allowed_signers: "unused".into(),
+                    revocation_file: None,
+                    verify_time: gix_date::Time {
+                        seconds: i64::MAX,
+                        offset: 0,
+                    },
+                    minimum_trust: TrustLevel::Undefined,
+                },
+            )
+            .expect_err("the timestamp is outside jiff's supported range");
+        insta::assert_debug_snapshot!(err, "commit time keeps the formatting error", @"
+        Signature time could not be formatted for SSH verification
+        |
+        └─ parameter 'Unix timestamp seconds' is not in the required range of -377705023201..=253402207200
+        ");
+        assert!(err.iter().count() > 1, "the concrete formatting error is retained");
     }
 }
diff --git a/gix-object/src/tag/decode.rs b/gix-object/src/tag/decode.rs
index 1c9a9e6eca7..85ad9ca01fc 100644
--- a/gix-object/src/tag/decode.rs
+++ b/gix-object/src/tag/decode.rs
@@ -22,7 +22,7 @@ pub fn git_tag<'a>(i: &mut &'a [u8], hash_kind: gix_hash::Kind) -> ParseResult<T
 
     let (message, signature) = message(i)?;
     if !i.is_empty() {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     }
 
     Ok(TagRef {
@@ -49,9 +49,7 @@ pub(crate) fn target<'a>(i: &mut &'a [u8], hash_kind: gix_hash::Kind) -> ParseRe
 /// Typical inputs are `type commit\n`, `type tree\n`, `type blob\n`, and
 /// `type tag\n`. On success, `i` is advanced past the entire header line.
 pub(crate) fn kind(i: &mut &[u8]) -> ParseResult<Kind> {
-    parse::header_field(i, b"type", |value| {
-        Kind::from_bytes(value).map_err(|_| crate::decode::Error)
-    })
+    parse::header_field(i, b"type", Kind::from_bytes)
 }
 
 /// Parse the `tag <name>\n` header and return the tag name.
@@ -61,7 +59,9 @@ pub(crate) fn kind(i: &mut &[u8]) -> ParseResult<Kind> {
 /// `i` is advanced past the entire header line.
 pub(crate) fn name<'a>(i: &mut &'a [u8]) -> ParseResult<&'a BStr> {
     parse::header_field(i, b"tag", |value| {
-        (!value.is_empty()).then(|| value.as_bstr()).ok_or(crate::decode::Error)
+        Ok((!value.is_empty())
+            .then(|| value.as_bstr())
+            .ok_or_else(crate::decode::empty_error)?)
     })
 }
 
@@ -77,7 +77,7 @@ pub(crate) fn tagger_raw<'a>(i: &mut &'a [u8]) -> ParseResult<Option<&'a BStr>>
     }
     parse::header_field(i, b"tagger", |raw| {
         let mut sig = raw;
-        gix_actor::SignatureRef::from_bytes_consuming(&mut sig).map_err(|_| crate::decode::Error)?;
+        gix_actor::SignatureRef::from_bytes_consuming(&mut sig)?;
         Ok(raw.as_bstr())
     })
     .map(Some)
@@ -95,7 +95,7 @@ pub(crate) fn tagger<'a>(i: &mut &'a [u8]) -> ParseResult<Option<gix_actor::Sign
     }
     parse::header_field(i, b"tagger", |i| {
         let mut sig = i;
-        let signature = gix_actor::SignatureRef::from_bytes_consuming(&mut sig).map_err(|_| crate::decode::Error)?;
+        let signature = gix_actor::SignatureRef::from_bytes_consuming(&mut sig)?;
         Ok(signature)
     })
     .map(Some)
@@ -120,7 +120,7 @@ pub fn message<'a>(i: &mut &'a [u8]) -> ParseResult<(&'a BStr, Option<&'a BStr>)
     }
 
     let Some(rest) = i.strip_prefix(parse::NL) else {
-        return Err(crate::decode::Error);
+        return Err(crate::decode::empty_error().into());
     };
 
     *i = &[];
diff --git a/gix-object/src/tag/mod.rs b/gix-object/src/tag/mod.rs
index 84da2abd316..e489421e363 100644
--- a/gix-object/src/tag/mod.rs
+++ b/gix-object/src/tag/mod.rs
@@ -1,4 +1,5 @@
 use bstr::ByteSlice;
+use gix_error::ExnMessageResult;
 
 use crate::parse::parse_signature;
 use crate::{Tag, TagRef};
@@ -13,7 +14,7 @@ pub mod ref_iter;
 
 impl<'a> TagRef<'a> {
     /// Deserialize a tag from `data`.
-    pub fn from_bytes(mut data: &'a [u8], hash_kind: gix_hash::Kind) -> Result<TagRef<'a>, crate::decode::Error> {
+    pub fn from_bytes(mut data: &'a [u8], hash_kind: gix_hash::Kind) -> ExnMessageResult<TagRef<'a>> {
         let input = &mut data;
         match decode::git_tag(input, hash_kind) {
             Ok(tag) => Ok(tag),
@@ -26,7 +27,7 @@ impl<'a> TagRef<'a> {
     }
 
     /// Return the tagger, if present.
-    pub fn tagger(&self) -> Result<Option<gix_actor::SignatureRef<'a>>, crate::decode::Error> {
+    pub fn tagger(&self) -> ExnMessageResult<Option<gix_actor::SignatureRef<'a>>> {
         Ok(self
             .tagger
             .map(parse_signature)
@@ -42,7 +43,7 @@ impl<'a> TagRef<'a> {
     }
 
     /// Copy all data into a fully-owned instance.
-    pub fn into_owned(self) -> Result<crate::Tag, crate::decode::Error> {
+    pub fn into_owned(self) -> ExnMessageResult<crate::Tag> {
         self.try_into()
     }
 }
diff --git a/gix-object/src/tag/ref_iter.rs b/gix-object/src/tag/ref_iter.rs
index 1e1cdc04b34..f92bcf68958 100644
--- a/gix-object/src/tag/ref_iter.rs
+++ b/gix-object/src/tag/ref_iter.rs
@@ -1,4 +1,5 @@
 use bstr::BStr;
+use gix_error::ExnMessageResult;
 use gix_hash::{ObjectId, oid};
 
 use crate::{Kind, TagRefIter, bstr::ByteSlice, tag::decode};
@@ -47,14 +48,14 @@ impl<'a> TagRefIter<'a> {
     /// Errors are coerced into options, hiding whether there was an error or not. The caller should assume an error if they
     /// call the method as intended. Such a squelched error cannot be recovered unless the objects data is retrieved and parsed again.
     /// `next()`.
-    pub fn target_id(mut self) -> Result<ObjectId, crate::decode::Error> {
+    pub fn target_id(mut self) -> ExnMessageResult<ObjectId> {
         let token = self.next().ok_or_else(missing_field)??;
-        Token::into_id(token).ok_or_else(missing_field)
+        Ok(Token::into_id(token).ok_or_else(missing_field)?)
     }
 
     /// Returns the taggers signature if there is no decoding error, and if this field exists.
     /// Errors are coerced into options, hiding whether there was an error or not. The caller knows if there was an error or not.
-    pub fn tagger(mut self) -> Result<Option<gix_actor::SignatureRef<'a>>, crate::decode::Error> {
+    pub fn tagger(mut self) -> ExnMessageResult<Option<gix_actor::SignatureRef<'a>>> {
         self.find_map(|t| match t {
             Ok(Token::Tagger(signature)) => Some(Ok(signature)),
             Err(err) => Some(Err(err)),
@@ -64,7 +65,7 @@ impl<'a> TagRefIter<'a> {
     }
 }
 
-fn missing_field() -> crate::decode::Error {
+fn missing_field() -> gix_error::Message {
     crate::decode::empty_error()
 }
 
@@ -74,7 +75,7 @@ impl<'a> TagRefIter<'a> {
         mut i: &'a [u8],
         state: &mut State,
         hash_kind: gix_hash::Kind,
-    ) -> Result<(&'a [u8], Token<'a>), crate::decode::Error> {
+    ) -> ExnMessageResult<(&'a [u8], Token<'a>)> {
         let input = &mut i;
         match Self::next_inner_(input, state, hash_kind) {
             Ok(token) => Ok((*input, token)),
@@ -82,11 +83,7 @@ impl<'a> TagRefIter<'a> {
         }
     }
 
-    fn next_inner_(
-        input: &mut &'a [u8],
-        state: &mut State,
-        hash_kind: gix_hash::Kind,
-    ) -> Result<Token<'a>, crate::decode::Error> {
+    fn next_inner_(input: &mut &'a [u8], state: &mut State, hash_kind: gix_hash::Kind) -> ExnMessageResult<Token<'a>> {
         use State::*;
         Ok(match state {
             Target => {
@@ -124,7 +121,7 @@ impl<'a> TagRefIter<'a> {
 }
 
 impl<'a> Iterator for TagRefIter<'a> {
-    type Item = Result<Token<'a>, crate::decode::Error>;
+    type Item = ExnMessageResult<Token<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.data.is_empty() {
diff --git a/gix-object/src/tag/write.rs b/gix-object/src/tag/write.rs
index 6eb6654b8d5..51f62cfc47a 100644
--- a/gix-object/src/tag/write.rs
+++ b/gix-object/src/tag/write.rs
@@ -2,30 +2,19 @@ use std::io;
 
 use bstr::BStr;
 use gix_date::parse::TimeBuf;
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt, validation};
 
 use crate::{Kind, Tag, TagRef, encode, encode::NL};
 
-/// An Error used in [`Tag::write_to()`][crate::WriteTo::write_to()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Tags must not start with a dash: '-'")]
-    StartsWithDash,
-    #[error("The tag name was no valid reference name")]
-    InvalidRefName(#[from] gix_validate::tag::name::Error),
-}
-
-impl From<Error> for io::Error {
-    fn from(err: Error) -> Self {
-        io::Error::other(err)
-    }
-}
-
 impl crate::WriteTo for Tag {
     fn write_to(&self, out: &mut dyn io::Write) -> io::Result<()> {
         encode::trusted_header_id(b"object", &self.target, out)?;
         encode::trusted_header_field(b"type", self.target_kind.as_bytes(), out)?;
-        encode::header_field(b"tag", validated_name(self.name.as_ref())?, out)?;
+        encode::header_field(
+            b"tag",
+            validated_name(self.name.as_ref()).map_err(|err| io::Error::other(err.into_error()))?,
+            out,
+        )?;
         if let Some(tagger) = &self.tagger {
             let mut buf = TimeBuf::default();
             encode::trusted_header_signature(b"tagger", &tagger.to_ref(&mut buf), out)?;
@@ -63,7 +52,11 @@ impl crate::WriteTo for TagRef<'_> {
     fn write_to(&self, mut out: &mut dyn io::Write) -> io::Result<()> {
         encode::trusted_header_field(b"object", self.target, &mut out)?;
         encode::trusted_header_field(b"type", self.target_kind.as_bytes(), &mut out)?;
-        encode::header_field(b"tag", validated_name(self.name)?, &mut out)?;
+        encode::header_field(
+            b"tag",
+            validated_name(self.name).map_err(|err| io::Error::other(err.into_error()))?,
+            &mut out,
+        )?;
         if let Some(tagger) = self.tagger {
             encode::trusted_header_field(b"tagger", tagger.as_ref(), &mut out)?;
         }
@@ -95,10 +88,10 @@ impl crate::WriteTo for TagRef<'_> {
     }
 }
 
-fn validated_name(name: &BStr) -> Result<&BStr, Error> {
-    gix_validate::tag::name(name)?;
+fn validated_name(name: &BStr) -> ExnMessageResult<&BStr> {
+    gix_validate::tag::name(name).or_raise(|| validation("The tag name was no valid reference name"))?;
     if name[0] == b'-' {
-        return Err(Error::StartsWithDash);
+        return Err(validation("Tags must not start with a dash: '-'").raise());
     }
     Ok(name)
 }
diff --git a/gix-object/src/traits/_impls.rs b/gix-object/src/traits/_impls.rs
index e887b4e8bd1..43e364bfd18 100644
--- a/gix-object/src/traits/_impls.rs
+++ b/gix-object/src/traits/_impls.rs
@@ -1,5 +1,7 @@
 use std::{io::Read, ops::Deref, rc::Rc, sync::Arc};
 
+use gix_error::ExnResult;
+
 use gix_hash::ObjectId;
 
 use crate::{Kind, WriteTo};
@@ -8,24 +10,19 @@ impl<T> crate::Write for &T
 where
     T: crate::Write,
 {
-    fn write(&self, object: &dyn WriteTo) -> Result<ObjectId, crate::write::Error> {
+    fn write(&self, object: &dyn WriteTo) -> ExnResult<ObjectId> {
         (*self).write(object)
     }
 
-    fn write_buf(&self, object: Kind, from: &[u8]) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf(&self, object: Kind, from: &[u8]) -> ExnResult<ObjectId> {
         (*self).write_buf(object, from)
     }
 
-    fn write_buf_with_known_id(
-        &self,
-        object: Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf_with_known_id(&self, object: Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         (*self).write_buf_with_known_id(object, from, id)
     }
 
-    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> Result<ObjectId, crate::write::Error> {
+    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         (*self).write_stream(kind, size, from)
     }
 
@@ -35,7 +32,7 @@ where
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    ) -> ExnResult<ObjectId> {
         (*self).write_stream_with_known_id(kind, size, from, id)
     }
 }
@@ -44,24 +41,19 @@ impl<T> crate::Write for Arc<T>
 where
     T: crate::Write,
 {
-    fn write(&self, object: &dyn WriteTo) -> Result<ObjectId, crate::write::Error> {
+    fn write(&self, object: &dyn WriteTo) -> ExnResult<ObjectId> {
         self.deref().write(object)
     }
 
-    fn write_buf(&self, object: Kind, from: &[u8]) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf(&self, object: Kind, from: &[u8]) -> ExnResult<ObjectId> {
         self.deref().write_buf(object, from)
     }
 
-    fn write_buf_with_known_id(
-        &self,
-        object: Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf_with_known_id(&self, object: Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         self.deref().write_buf_with_known_id(object, from, id)
     }
 
-    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> Result<ObjectId, crate::write::Error> {
+    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         self.deref().write_stream(kind, size, from)
     }
 
@@ -71,7 +63,7 @@ where
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    ) -> ExnResult<ObjectId> {
         self.deref().write_stream_with_known_id(kind, size, from, id)
     }
 }
@@ -80,24 +72,19 @@ impl<T> crate::Write for Rc<T>
 where
     T: crate::Write,
 {
-    fn write(&self, object: &dyn WriteTo) -> Result<ObjectId, crate::write::Error> {
+    fn write(&self, object: &dyn WriteTo) -> ExnResult<ObjectId> {
         self.deref().write(object)
     }
 
-    fn write_buf(&self, object: Kind, from: &[u8]) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf(&self, object: Kind, from: &[u8]) -> ExnResult<ObjectId> {
         self.deref().write_buf(object, from)
     }
 
-    fn write_buf_with_known_id(
-        &self,
-        object: Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    fn write_buf_with_known_id(&self, object: Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         self.deref().write_buf_with_known_id(object, from, id)
     }
 
-    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> Result<ObjectId, crate::write::Error> {
+    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         self.deref().write_stream(kind, size, from)
     }
 
@@ -107,7 +94,7 @@ where
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, crate::write::Error> {
+    ) -> ExnResult<ObjectId> {
         self.deref().write_stream_with_known_id(kind, size, from, id)
     }
 }
diff --git a/gix-object/src/traits/find.rs b/gix-object/src/traits/find.rs
index 0ab898d4540..61a60fc6a77 100644
--- a/gix-object/src/traits/find.rs
+++ b/gix-object/src/traits/find.rs
@@ -1,5 +1,4 @@
-use crate::find;
-
+use gix_error::ExnResult;
 /// Check if an object is present in an object store.
 pub trait Exists {
     /// Returns `true` if the object exists in the database.
@@ -19,8 +18,7 @@ pub trait Find {
     ///
     /// Returns `Some` object if it was present in the database, or the error that occurred during lookup or object
     /// retrieval.
-    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>)
-    -> Result<Option<crate::Data<'a>>, find::Error>;
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<crate::Data<'a>>>;
 }
 
 /// Find the header of an object in the object store.
@@ -28,7 +26,7 @@ pub trait Header {
     /// Find the header of the object matching `id` in the database.
     ///
     /// Returns `Some` header if it was present, or the error that occurred during lookup.
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<crate::Header>, find::Error>;
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<crate::Header>>;
 }
 
 /// A combination of [`Find`] and [`Header`] traits to help with `dyn` trait objects.
@@ -37,6 +35,8 @@ pub trait FindObjectOrHeader: Find + Header {}
 mod _impls {
     use std::{ops::Deref, rc::Rc, sync::Arc};
 
+    use gix_error::ExnResult;
+
     use gix_hash::oid;
 
     use crate::Data;
@@ -56,7 +56,7 @@ mod _impls {
     where
         T: crate::Find,
     {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, crate::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             (*self).try_find(id, buffer)
         }
     }
@@ -65,7 +65,7 @@ mod _impls {
     where
         T: crate::FindHeader,
     {
-        fn try_header(&self, id: &gix_hash::oid) -> Result<Option<crate::Header>, crate::find::Error> {
+        fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
             (*self).try_header(id)
         }
     }
@@ -92,7 +92,7 @@ mod _impls {
     where
         T: crate::Find,
     {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, crate::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             self.deref().try_find(id, buffer)
         }
     }
@@ -101,7 +101,7 @@ mod _impls {
     where
         T: crate::FindHeader,
     {
-        fn try_header(&self, id: &gix_hash::oid) -> Result<Option<crate::Header>, crate::find::Error> {
+        fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
             self.deref().try_header(id)
         }
     }
@@ -110,7 +110,7 @@ mod _impls {
     where
         T: crate::Find,
     {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, crate::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             self.deref().try_find(id, buffer)
         }
     }
@@ -119,7 +119,7 @@ mod _impls {
     where
         T: crate::FindHeader,
     {
-        fn try_header(&self, id: &gix_hash::oid) -> Result<Option<crate::Header>, crate::find::Error> {
+        fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
             self.deref().try_header(id)
         }
     }
@@ -137,7 +137,7 @@ mod _impls {
     where
         T: crate::Find,
     {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, crate::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             self.deref().try_find(id, buffer)
         }
     }
@@ -146,42 +146,39 @@ mod _impls {
     where
         T: crate::FindHeader,
     {
-        fn try_header(&self, id: &gix_hash::oid) -> Result<Option<crate::Header>, crate::find::Error> {
+        fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<crate::Header>> {
             self.deref().try_header(id)
         }
     }
 }
 
 mod ext {
-    use crate::{BlobRef, CommitRef, CommitRefIter, Kind, ObjectRef, TagRef, TagRefIter, TreeRef, TreeRefIter, find};
+    use gix_error::{ErrorExt, ExnResult, ResultExt, corruption, validation};
+
+    use crate::{BlobRef, CommitRef, CommitRefIter, Kind, ObjectRef, TagRef, TagRefIter, TreeRef, TreeRefIter};
+
+    fn not_found(id: &gix_hash::oid) -> gix_error::Exn {
+        gix_error::not_found(format!("An object with id {id} could not be found")).raise_erased()
+    }
+
+    fn wrong_kind(id: &gix_hash::oid, actual: Kind, expected: Kind) -> gix_error::Exn {
+        validation(format!("Expected object of kind {expected} but got {actual} at {id}")).raise_erased()
+    }
 
     macro_rules! make_obj_lookup {
         ($method:ident, $object_variant:path, $object_kind:path, $object_type:ty) => {
             /// Like [`find(…)`][Self::find()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error
             /// while returning the desired object type.
-            fn $method<'a>(
-                &self,
-                id: &gix_hash::oid,
-                buffer: &'a mut Vec<u8>,
-            ) -> Result<$object_type, find::existing_object::Error> {
-                self.try_find(id, buffer)
-                    .map_err(find::existing_object::Error::Find)?
-                    .ok_or_else(|| find::existing_object::Error::NotFound {
-                        oid: id.as_ref().to_owned(),
-                    })
+            fn $method<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<$object_type> {
+                self.try_find(id, buffer)?
+                    .ok_or_else(|| not_found(id))
                     .and_then(|o| {
-                        o.decode().map_err(|err| find::existing_object::Error::Decode {
-                            source: err,
-                            oid: id.as_ref().to_owned(),
-                        })
+                        o.decode()
+                            .or_raise_erased(|| corruption(format!("Could not decode object at {id}")))
                     })
                     .and_then(|o| match o {
                         $object_variant(o) => return Ok(o),
-                        o => Err(find::existing_object::Error::ObjectKind {
-                            oid: id.as_ref().to_owned(),
-                            actual: o.kind(),
-                            expected: $object_kind,
-                        }),
+                        o => Err(wrong_kind(id, o.kind(), $object_kind)),
                     })
             }
         };
@@ -191,24 +188,10 @@ mod ext {
         ($method:ident, $object_kind:path, $object_type:ty, $into_iter:tt) => {
             /// Like [`find(…)`][Self::find()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error
             /// while returning the desired iterator type.
-            fn $method<'a>(
-                &self,
-                id: &gix_hash::oid,
-                buffer: &'a mut Vec<u8>,
-            ) -> Result<$object_type, find::existing_iter::Error> {
-                self.try_find(id, buffer)
-                    .map_err(find::existing_iter::Error::Find)?
-                    .ok_or_else(|| find::existing_iter::Error::NotFound {
-                        oid: id.as_ref().to_owned(),
-                    })
-                    .and_then(|o| {
-                        o.$into_iter()
-                            .ok_or_else(|| find::existing_iter::Error::ObjectKind {
-                                oid: id.as_ref().to_owned(),
-                                actual: o.kind,
-                                expected: $object_kind,
-                            })
-                    })
+            fn $method<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<$object_type> {
+                self.try_find(id, buffer)?
+                    .ok_or_else(|| not_found(id))
+                    .and_then(|o| o.$into_iter().ok_or_else(|| wrong_kind(id, o.kind, $object_kind)))
             }
         };
     }
@@ -216,85 +199,51 @@ mod ext {
     /// An extension trait with convenience functions.
     pub trait HeaderExt: super::Header {
         /// Like [`try_header(…)`](super::Header::try_header()), but flattens the `Result<Option<_>>` into a single `Result` making a non-existing header an error.
-        fn header(&self, id: &gix_hash::oid) -> Result<crate::Header, find::existing::Error> {
-            self.try_header(id)
-                .map_err(find::existing::Error::Find)?
-                .ok_or_else(|| find::existing::Error::NotFound { oid: id.to_owned() })
+        fn header(&self, id: &gix_hash::oid) -> ExnResult<crate::Header> {
+            self.try_header(id)?.ok_or_else(|| not_found(id))
         }
     }
 
     /// An extension trait with convenience functions.
     pub trait FindExt: super::Find {
         /// Like [`try_find(…)`](super::Find::try_find()), but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error.
-        fn find<'a>(
-            &self,
-            id: &gix_hash::oid,
-            buffer: &'a mut Vec<u8>,
-        ) -> Result<crate::Data<'a>, find::existing::Error> {
-            self.try_find(id, buffer)
-                .map_err(find::existing::Error::Find)?
-                .ok_or_else(|| find::existing::Error::NotFound { oid: id.to_owned() })
+        fn find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<crate::Data<'a>> {
+            self.try_find(id, buffer)?.ok_or_else(|| not_found(id))
         }
 
         /// Like [`find(…)`][Self::find()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error
         /// while returning the desired object type.
-        fn find_blob<'a>(
-            &self,
-            id: &gix_hash::oid,
-            buffer: &'a mut Vec<u8>,
-        ) -> Result<BlobRef<'a>, find::existing_object::Error> {
+        fn find_blob<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<BlobRef<'a>> {
             if id == gix_hash::ObjectId::empty_blob(id.kind()) {
                 return Ok(BlobRef { data: &[] });
             }
-            self.try_find(id, buffer)
-                .map_err(find::existing_object::Error::Find)?
-                .ok_or_else(|| find::existing_object::Error::NotFound {
-                    oid: id.as_ref().to_owned(),
-                })
+            self.try_find(id, buffer)?
+                .ok_or_else(|| not_found(id))
                 .and_then(|o| {
-                    o.decode().map_err(|err| find::existing_object::Error::Decode {
-                        source: err,
-                        oid: id.as_ref().to_owned(),
-                    })
+                    o.decode()
+                        .or_raise_erased(|| corruption(format!("Could not decode object at {id}")))
                 })
                 .and_then(|o| match o {
                     ObjectRef::Blob(o) => Ok(o),
-                    o => Err(find::existing_object::Error::ObjectKind {
-                        oid: id.as_ref().to_owned(),
-                        actual: o.kind(),
-                        expected: Kind::Blob,
-                    }),
+                    o => Err(wrong_kind(id, o.kind(), Kind::Blob)),
                 })
         }
 
         /// Like [`find(…)`][Self::find()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error
         /// while returning the desired object type.
-        fn find_tree<'a>(
-            &self,
-            id: &gix_hash::oid,
-            buffer: &'a mut Vec<u8>,
-        ) -> Result<TreeRef<'a>, find::existing_object::Error> {
+        fn find_tree<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<TreeRef<'a>> {
             if id == gix_hash::ObjectId::empty_tree(id.kind()) {
                 return Ok(TreeRef { entries: Vec::new() });
             }
-            self.try_find(id, buffer)
-                .map_err(find::existing_object::Error::Find)?
-                .ok_or_else(|| find::existing_object::Error::NotFound {
-                    oid: id.as_ref().to_owned(),
-                })
+            self.try_find(id, buffer)?
+                .ok_or_else(|| not_found(id))
                 .and_then(|o| {
-                    o.decode().map_err(|err| find::existing_object::Error::Decode {
-                        source: err,
-                        oid: id.as_ref().to_owned(),
-                    })
+                    o.decode()
+                        .or_raise_erased(|| corruption(format!("Could not decode object at {id}")))
                 })
                 .and_then(|o| match o {
                     ObjectRef::Tree(o) => Ok(o),
-                    o => Err(find::existing_object::Error::ObjectKind {
-                        oid: id.as_ref().to_owned(),
-                        actual: o.kind(),
-                        expected: Kind::Tree,
-                    }),
+                    o => Err(wrong_kind(id, o.kind(), Kind::Tree)),
                 })
         }
 
diff --git a/gix-object/src/traits/mod.rs b/gix-object/src/traits/mod.rs
index 66aa0bc44fa..f2942cf5544 100644
--- a/gix-object/src/traits/mod.rs
+++ b/gix-object/src/traits/mod.rs
@@ -1,18 +1,20 @@
 use std::io;
 
+use gix_error::{ExnResult, ResultExt};
+
 use crate::Kind;
 
 /// Describe the capability to write git objects into an object store.
 pub trait Write {
     /// Write objects using the intrinsic kind of [`hash`](gix_hash::Kind) into the database,
     /// returning id to reference it in subsequent reads.
-    fn write(&self, object: &dyn WriteTo) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    fn write(&self, object: &dyn WriteTo) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = Vec::with_capacity(2048);
-        object.write_to(&mut buf)?;
+        object.write_to(&mut buf).or_erased()?;
         self.write_stream(object.kind(), buf.len() as u64, &mut buf.as_slice())
     }
     /// As [`write`](Write::write), but takes an [`object` kind](Kind) along with its encoded bytes.
-    fn write_buf(&self, object: crate::Kind, mut from: &[u8]) -> Result<gix_hash::ObjectId, crate::write::Error> {
+    fn write_buf(&self, object: crate::Kind, mut from: &[u8]) -> ExnResult<gix_hash::ObjectId> {
         self.write_stream(object, from.len() as u64, &mut from)
     }
     /// As [`write_buf`](Write::write_buf), but the object `id` has already been computed by the caller.
@@ -24,15 +26,10 @@ pub trait Write {
         object: crate::Kind,
         from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error>;
+    ) -> ExnResult<gix_hash::ObjectId>;
     /// As [`write`](Write::write), but takes an input stream.
     /// This is commonly used for writing blobs directly without reading them to memory first.
-    fn write_stream(
-        &self,
-        kind: crate::Kind,
-        size: u64,
-        from: &mut dyn io::Read,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error>;
+    fn write_stream(&self, kind: crate::Kind, size: u64, from: &mut dyn io::Read) -> ExnResult<gix_hash::ObjectId>;
     /// As [`write_stream`](Write::write_stream), but the object `id` has already been computed by the caller.
     ///
     /// Implementations may trust the given `id` and avoid computing it again. Callers must make sure `id` matches
@@ -43,7 +40,7 @@ pub trait Write {
         size: u64,
         from: &mut dyn io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, crate::write::Error>;
+    ) -> ExnResult<gix_hash::ObjectId>;
 }
 
 /// Writing of objects to a `Write` implementation
diff --git a/gix-object/src/tree/editor.rs b/gix-object/src/tree/editor.rs
index edd31adfdda..9e9f311b21a 100644
--- a/gix-object/src/tree/editor.rs
+++ b/gix-object/src/tree/editor.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_error::{ErrorExt, ExnResult, validation};
 use gix_hash::ObjectId;
 
 use crate::{
@@ -31,18 +32,6 @@ impl std::fmt::Debug for Editor<'_> {
     }
 }
 
-/// The error returned by [Editor] or [Cursor] edit operation.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Empty path components are not allowed")]
-    EmptyPathComponent,
-    #[error(transparent)]
-    FindExistingObject(#[from] crate::find::existing_object::Error),
-    #[error("Cannot remove '{rela_path}' as leaf entry because it is a tree")]
-    CannotRemoveNonLeaf { rela_path: BString },
-}
-
 /// Lifecycle
 impl<'a> Editor<'a> {
     /// Create a new editor that uses `root` as base for all edits. Use `find` to lookup existing
@@ -87,7 +76,7 @@ impl Editor<'_> {
 
     /// Remove the entry at `rela_path`, loading all trees on the path accordingly.
     /// It's no error if the entry doesn't exist, or if `rela_path` doesn't lead to an existing entry at all.
-    pub fn remove<I, C>(&mut self, rela_path: I) -> Result<&mut Self, Error>
+    pub fn remove<I, C>(&mut self, rela_path: I) -> ExnResult<&mut Self>
     where
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
@@ -102,7 +91,7 @@ impl Editor<'_> {
     /// Return an error if the entry exists and is a tree, as that would otherwise also remove all entries below it.
     /// Empty path components are rejected if reached while loading the path. This is useful to not unintentionally
     /// remove a directory.
-    pub fn remove_leaf<I, C>(&mut self, rela_path: I) -> Result<&mut Self, Error>
+    pub fn remove_leaf<I, C>(&mut self, rela_path: I) -> ExnResult<&mut Self>
     where
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
@@ -139,7 +128,7 @@ impl Editor<'_> {
     ///
     /// `id` can also be an empty tree, along with [the respective `kind`](EntryKind::Tree), even though that's normally not allowed
     /// in Git trees.
-    pub fn upsert<I, C>(&mut self, rela_path: I, kind: EntryKind, id: ObjectId) -> Result<&mut Self, Error>
+    pub fn upsert<I, C>(&mut self, rela_path: I, kind: EntryKind, id: ObjectId) -> ExnResult<&mut Self>
     where
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
@@ -266,7 +255,7 @@ impl Editor<'_> {
         unreachable!("we exit as soon as everything is consumed")
     }
 
-    fn upsert_or_remove_at_pathbuf<I, C>(&mut self, rela_path: I, edit: EditMode) -> Result<&mut Self, Error>
+    fn upsert_or_remove_at_pathbuf<I, C>(&mut self, rela_path: I, edit: EditMode) -> ExnResult<&mut Self>
     where
         I: IntoIterator<Item = C>,
         C: AsRef<BStr>,
@@ -278,7 +267,7 @@ impl Editor<'_> {
         while let Some(name) = rela_path.next() {
             let name = name.as_ref();
             if name.is_empty() {
-                return Err(Error::EmptyPathComponent);
+                return Err(validation("Empty path components are not allowed").raise_erased());
             }
             let is_last = rela_path.peek().is_none();
             let mut needs_sorting = false;
@@ -304,9 +293,11 @@ impl Editor<'_> {
                         EditMode::Remove(mode) => {
                             if is_last {
                                 if mode == RemoveMode::LeafOnly && cursor.entries[idx].mode.is_tree() {
-                                    return Err(Error::CannotRemoveNonLeaf {
-                                        rela_path: path_with_component(path_buf.as_bstr(), name),
-                                    });
+                                    let rela_path = path_with_component(path_buf.as_bstr(), name);
+                                    return Err(validation(format!(
+                                        "Cannot remove '{rela_path}' as leaf entry because it is a tree"
+                                    ))
+                                    .raise_erased());
                                 }
                                 cursor.entries.remove(idx);
                                 break;
@@ -394,6 +385,7 @@ impl Editor<'_> {
 
 mod cursor {
     use bstr::{BStr, BString};
+    use gix_error::ExnResult;
     use gix_hash::ObjectId;
 
     use crate::{
@@ -420,7 +412,7 @@ mod cursor {
         ///
         /// The returned cursor will then allow applying edits to the tree at `rela_path` as root.
         /// If `rela_path` is a single empty string, it is equivalent to using the current instance itself.
-        pub fn cursor_at<I, C>(&mut self, rela_path: I) -> Result<Cursor<'_, 'a>, super::Error>
+        pub fn cursor_at<I, C>(&mut self, rela_path: I) -> ExnResult<Cursor<'_, 'a>>
         where
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
@@ -454,7 +446,7 @@ mod cursor {
         }
 
         /// Like [`Editor::upsert()`], but with the constraint of only editing in this cursor's tree.
-        pub fn upsert<I, C>(&mut self, rela_path: I, kind: EntryKind, id: ObjectId) -> Result<&mut Self, super::Error>
+        pub fn upsert<I, C>(&mut self, rela_path: I, kind: EntryKind, id: ObjectId) -> ExnResult<&mut Self>
         where
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
@@ -466,7 +458,7 @@ mod cursor {
         }
 
         /// Like [`Editor::remove()`], but with the constraint of only editing in this cursor's tree.
-        pub fn remove<I, C>(&mut self, rela_path: I) -> Result<&mut Self, super::Error>
+        pub fn remove<I, C>(&mut self, rela_path: I) -> ExnResult<&mut Self>
         where
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
@@ -478,7 +470,7 @@ mod cursor {
         }
 
         /// Like [`Editor::remove_leaf()`], but with the constraint of only editing in this cursor's tree.
-        pub fn remove_leaf<I, C>(&mut self, rela_path: I) -> Result<&mut Self, super::Error>
+        pub fn remove_leaf<I, C>(&mut self, rela_path: I) -> ExnResult<&mut Self>
         where
             I: IntoIterator<Item = C>,
             C: AsRef<BStr>,
diff --git a/gix-object/src/tree/ref_iter.rs b/gix-object/src/tree/ref_iter.rs
index 17c54d1c9c7..549b71662af 100644
--- a/gix-object/src/tree/ref_iter.rs
+++ b/gix-object/src/tree/ref_iter.rs
@@ -1,5 +1,8 @@
+use gix_error::ExnMessageResult;
 use std::ops::ControlFlow;
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 
 use crate::{TreeRef, TreeRefIter, tree, tree::EntryRef};
@@ -39,7 +42,7 @@ where
     };
 
     let Some(entry) = TreeRefIter::from_bytes(tree.data, tree.object_hash)
-        .filter_map(Result::ok)
+        .filter_map(std::result::Result::ok)
         .find(|entry| component.eq(entry.filename))
     else {
         return ControlFlow::Break(None);
@@ -71,7 +74,7 @@ impl<'a> TreeRefIter<'a> {
         odb: impl crate::Find,
         buffer: &'a mut Vec<u8>,
         path: I,
-    ) -> Result<Option<tree::Entry>, crate::find::Error>
+    ) -> ExnResult<Option<tree::Entry>>
     where
         I: IntoIterator<Item = P>,
         P: PartialEq<BStr>,
@@ -108,7 +111,7 @@ impl<'a> TreeRefIter<'a> {
         odb: impl crate::Find,
         buffer: &'a mut Vec<u8>,
         relative_path: impl AsRef<std::path::Path>,
-    ) -> Result<Option<tree::Entry>, crate::find::Error> {
+    ) -> ExnResult<Option<tree::Entry>> {
         self.lookup_entry(
             odb,
             buffer,
@@ -122,7 +125,7 @@ impl<'a> TreeRefIter<'a> {
 
 impl<'a> TreeRef<'a> {
     /// Deserialize a Tree from `data`, assuming `object_hash` to determine how the object ids are encoded in this particular tree.
-    pub fn from_bytes(data: &'a [u8], hash_kind: gix_hash::Kind) -> Result<TreeRef<'a>, crate::decode::Error> {
+    pub fn from_bytes(data: &'a [u8], hash_kind: gix_hash::Kind) -> ExnMessageResult<TreeRef<'a>> {
         decode::tree(data, hash_kind.len_in_bytes())
     }
 
@@ -146,7 +149,7 @@ impl<'a> TreeRef<'a> {
 
 impl<'a> TreeRefIter<'a> {
     /// Consume self and return all parsed entries.
-    pub fn entries(self) -> Result<Vec<EntryRef<'a>>, crate::decode::Error> {
+    pub fn entries(self) -> ExnMessageResult<Vec<EntryRef<'a>>> {
         self.collect()
     }
 
@@ -167,7 +170,7 @@ impl<'a> TreeRefIter<'a> {
 }
 
 impl<'a> Iterator for TreeRefIter<'a> {
-    type Item = Result<EntryRef<'a>, crate::decode::Error>;
+    type Item = ExnMessageResult<EntryRef<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.data.is_empty() {
@@ -180,7 +183,7 @@ impl<'a> Iterator for TreeRefIter<'a> {
             }
             None => {
                 self.data = &[];
-                Some(Err(crate::decode::Error))
+                Some(Err(crate::decode::empty_error().into()))
             }
         }
     }
@@ -189,13 +192,14 @@ impl<'a> Iterator for TreeRefIter<'a> {
 impl<'a> TryFrom<&'a [u8]> for tree::EntryMode {
     type Error = &'a [u8];
 
-    fn try_from(mode: &'a [u8]) -> Result<Self, Self::Error> {
+    fn try_from(mode: &'a [u8]) -> std::result::Result<Self, Self::Error> {
         tree::EntryMode::from_bytes(mode).ok_or(mode)
     }
 }
 
 mod decode {
     use bstr::ByteSlice;
+    use gix_error::ExnMessageResult;
 
     use crate::{TreeRef, tree, tree::EntryRef};
 
@@ -218,7 +222,7 @@ mod decode {
         ))
     }
 
-    pub fn tree(data: &[u8], hash_len: usize) -> Result<TreeRef<'_>, crate::decode::Error> {
+    pub fn tree(data: &[u8], hash_len: usize) -> ExnMessageResult<TreeRef<'_>> {
         let mut i = data;
 
         // Calculate an estimate of the amount of entries to reduce
@@ -234,7 +238,7 @@ mod decode {
 
         while !i.is_empty() {
             let Some((rest, entry)) = fast_entry(i, hash_len) else {
-                return Err(crate::decode::Error);
+                return Err(crate::decode::empty_error().into());
             };
             i = rest;
             out.push(entry);
diff --git a/gix-object/src/tree/write.rs b/gix-object/src/tree/write.rs
index 540eaa856ef..77f087ef086 100644
--- a/gix-object/src/tree/write.rs
+++ b/gix-object/src/tree/write.rs
@@ -1,6 +1,6 @@
 use std::io;
 
-use bstr::{BString, ByteSlice};
+use bstr::ByteSlice;
 
 use crate::{
     Kind, Tree, TreeRef,
@@ -8,23 +8,11 @@ use crate::{
     tree::{Entry, EntryRef},
 };
 
-/// The Error used in [`Tree::write_to()`][crate::WriteTo::write_to()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Nullbytes are invalid in file paths as they are separators: {name:?}")]
-    NullbyteInFilename { name: BString },
-}
-
-impl From<Error> for io::Error {
-    fn from(err: Error) -> Self {
-        io::Error::other(err)
-    }
-}
-
 /// Serialization
 impl crate::WriteTo for Tree {
     /// Serialize this tree to `out` in the git internal format.
+    /// Invalid filename bytes are retained as `input` in the I/O error.
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     fn write_to(&self, out: &mut dyn io::Write) -> io::Result<()> {
         debug_assert_eq!(
             &self.entries,
@@ -41,10 +29,10 @@ impl crate::WriteTo for Tree {
             out.write_all(SPACE)?;
 
             if filename.find_byte(0).is_some() {
-                return Err(Error::NullbyteInFilename {
-                    name: (*filename).to_owned(),
-                }
-                .into());
+                return Err(io::Error::other(
+                    gix_error::validation("Nullbytes are invalid in file paths as they are separators")
+                        .with("input", filename.as_bstr()),
+                ));
             }
             out.write_all(filename)?;
             out.write_all(b"\0")?;
@@ -72,6 +60,8 @@ impl crate::WriteTo for Tree {
 /// Serialization
 impl crate::WriteTo for TreeRef<'_> {
     /// Serialize this tree to `out` in the git internal format.
+    /// Invalid filename bytes are retained as `input` in the I/O error.
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     fn write_to(&self, out: &mut dyn io::Write) -> io::Result<()> {
         debug_assert_eq!(
             &{
@@ -88,10 +78,10 @@ impl crate::WriteTo for TreeRef<'_> {
             out.write_all(SPACE)?;
 
             if filename.find_byte(0).is_some() {
-                return Err(Error::NullbyteInFilename {
-                    name: (*filename).to_owned(),
-                }
-                .into());
+                return Err(io::Error::other(
+                    gix_error::validation("Nullbytes are invalid in file paths as they are separators")
+                        .with("input", *filename),
+                ));
             }
             out.write_all(filename)?;
             out.write_all(b"\0")?;
diff --git a/gix-object/tests/object/commit/from_bytes.rs b/gix-object/tests/object/commit/from_bytes.rs
index 2ac9bda60a6..62016fc05b8 100644
--- a/gix-object/tests/object/commit/from_bytes.rs
+++ b/gix-object/tests/object/commit/from_bytes.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_actor::SignatureRef;
 use gix_object::{
     CommitRef, CommitRefIter, WriteTo, bstr::ByteSlice, commit::message::body::TrailerRef, commit::ref_iter::Token,
@@ -28,7 +29,7 @@ fn invalid_timestsamp() {
 }
 
 #[test]
-fn sha256_with_all_fields_and_signature() -> crate::Result {
+fn sha256_with_all_fields_and_signature() -> Result {
     let input = b"tree 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
 parent 1111111111111111111111111111111111111111111111111111111111111111
 parent 2222222222222222222222222222222222222222222222222222222222222222
@@ -79,7 +80,8 @@ U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgZXhhbXBsZS1zaGEyNTY=
     assert_eq!(commit.extra_headers().mergetags().count(), 1);
     assert_eq!(commit.message, b"sha256 subject\n\nsha256 body\n".as_bstr());
 
-    let tokens = CommitRefIter::from_bytes(input, gix_hash::Kind::Sha256).collect::<Result<Vec<_>, _>>()?;
+    let tokens =
+        CommitRefIter::from_bytes(input, gix_hash::Kind::Sha256).collect::<std::result::Result<Vec<_>, _>>()?;
     assert!(matches!(tokens[0], Token::Tree { ref id } if id.kind() == gix_hash::Kind::Sha256));
     assert_eq!(
         tokens
@@ -96,7 +98,7 @@ U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgZXhhbXBsZS1zaGEyNTY=
 }
 
 #[test]
-fn uppercase_tree_id() -> crate::Result {
+fn uppercase_tree_id() -> Result {
     let input = b"tree 7989DFB2EC2F41914611A22FB30BBC2B3849DF9A
 author Name <name@example.com> 1312735823 +0518
 committer Name <name@example.com> 1312735823 +0518
@@ -109,7 +111,7 @@ message";
 }
 
 #[test]
-fn invalid_email_of_committer() -> crate::Result {
+fn invalid_email_of_committer() -> Result {
     let actor = gix_actor::SignatureRef {
         name: b"Gregor Hartmann".as_bstr(),
         email: b"gh <Gregor Hartmann<gh@openoffice.org".as_bstr(),
@@ -145,7 +147,7 @@ fn invalid_email_of_committer() -> crate::Result {
 }
 
 #[test]
-fn unsigned() -> crate::Result {
+fn unsigned() -> Result {
     let tree = fixture_oid_hex("1b2dfb4ac5e42080b682fc676e9738c94ce6d54d");
     assert_eq!(
         CommitRef::from_bytes(&commit_fixture("unsigned.txt")?, crate::fixture_hash_kind())?,
@@ -163,7 +165,7 @@ fn unsigned() -> crate::Result {
 }
 
 #[test]
-fn whitespace() -> crate::Result {
+fn whitespace() -> Result {
     let tree = fixture_oid_hex("9bed6275068a0575243ba8409253e61af81ab2ff");
     let parent = fixture_oid_hex("26b4df046d1776c123ac69d918f5aec247b58cc6");
     assert_eq!(
@@ -182,7 +184,7 @@ fn whitespace() -> crate::Result {
 }
 
 #[test]
-fn signed_singleline() -> crate::Result {
+fn signed_singleline() -> Result {
     let tree = fixture_oid_hex("00fc39317701176e326974ce44f5bd545a32ec0b");
     let parent = fixture_oid_hex("09d8d3a12e161a7f6afb522dbe8900a9c09bce06");
     assert_eq!(
@@ -201,7 +203,7 @@ fn signed_singleline() -> crate::Result {
 }
 
 #[test]
-fn mergetag() -> crate::Result {
+fn mergetag() -> Result {
     let fixture = commit_fixture("mergetag.txt")?;
     let tree = fixture_oid_hex("1c61918031bf2c7fab9e17dde3c52a6a9884fcb5");
     let parent_a = fixture_oid_hex("44ebe016df3aad96e3be8f95ec52397728dd7701");
@@ -228,7 +230,7 @@ fn mergetag() -> crate::Result {
 }
 
 #[test]
-fn signed() -> crate::Result {
+fn signed() -> Result {
     let tree = fixture_oid_hex("00fc39317701176e326974ce44f5bd545a32ec0b");
     let parent = fixture_oid_hex("09d8d3a12e161a7f6afb522dbe8900a9c09bce06");
     assert_eq!(
@@ -247,7 +249,7 @@ fn signed() -> crate::Result {
 }
 
 #[test]
-fn signed_with_encoding() -> crate::Result {
+fn signed_with_encoding() -> Result {
     let tree = fixture_oid_hex("1973afa74d87b2bb73fa884aaaa8752aec43ea88");
     let parent = fixture_oid_hex("79c51cc86923e2b8ca0ee5c4eb75e48027133f9a");
     assert_eq!(
@@ -266,7 +268,7 @@ fn signed_with_encoding() -> crate::Result {
 }
 
 #[test]
-fn with_encoding() -> crate::Result {
+fn with_encoding() -> Result {
     let tree = fixture_oid_hex("4a1c03029e7407c0afe9fc0320b3258e188b115e");
     let parent = fixture_oid_hex("7ca98aad461a5c302cb4c9e3acaaa6053cc67a62");
     assert_eq!(
@@ -285,7 +287,7 @@ fn with_encoding() -> crate::Result {
 }
 
 #[test]
-fn pre_epoch() -> crate::Result {
+fn pre_epoch() -> Result {
     let tree = fixture_oid_hex("71cdd4015386b764b178005cad4c88966bc9d61a");
     assert_eq!(
         CommitRef::from_bytes(&commit_fixture("pre-epoch.txt")?, crate::fixture_hash_kind())?,
@@ -303,7 +305,7 @@ fn pre_epoch() -> crate::Result {
 }
 
 #[test]
-fn double_dash_special_time_offset() -> crate::Result {
+fn double_dash_special_time_offset() -> Result {
     assert_eq!(
         CommitRef::from_bytes(
             &fixture_name("commit", "double-dash-date-offset.txt"),
@@ -323,7 +325,7 @@ fn double_dash_special_time_offset() -> crate::Result {
 }
 
 #[test]
-fn with_trailer() -> crate::Result {
+fn with_trailer() -> Result {
     let kim = SignatureRef {
         name: "Kim Altintop".into(),
         email: "kim@eagain.st".into(),
@@ -411,7 +413,7 @@ instead of depending directly on the lower-level crates.
 }
 
 #[test]
-fn merge() -> crate::Result {
+fn merge() -> Result {
     let tree = fixture_oid_hex("0cf16ce8e229b59a761198975f0c0263229faf82");
     let parent_a = fixture_oid_hex("6a6054db4ce3c1e4e6a37f8c4d7acb63a4d6ad71");
     let parent_b = fixture_oid_hex("c91d592913d47ac4e4a76daf16fd649b276e211e");
@@ -431,7 +433,7 @@ fn merge() -> crate::Result {
 }
 
 #[test]
-fn newline_right_after_signature_multiline_header_sha1() -> crate::Result {
+fn newline_right_after_signature_multiline_header_sha1() -> Result {
     let fixture = commit_fixture("signed-whitespace.txt")?;
     let commit = CommitRef::from_bytes(&fixture, crate::fixture_hash_kind())?;
     let pgp_sig = crate::commit::OTHER_SIGNATURE.as_bstr();
@@ -453,7 +455,7 @@ fn newline_right_after_signature_multiline_header_sha1() -> crate::Result {
 
 #[test]
 #[cfg(feature = "sha256")]
-fn sha256_commits_use_their_own_signature_header() -> crate::Result {
+fn sha256_commits_use_their_own_signature_header() -> Result {
     let data = b"tree 0000000000000000000000000000000000000000000000000000000000000000\n\
 author A <a@example.com> 0 +0000\n\
 committer A <a@example.com> 0 +0000\n\
@@ -466,7 +468,7 @@ gpgsig-sha256 signature\n\
 }
 
 #[test]
-fn bogus_multi_gpgsig_header_sha1() -> crate::Result {
+fn bogus_multi_gpgsig_header_sha1() -> Result {
     let fixture = commit_fixture("bogus-gpgsig-lines-in-git.git.txt")?;
     let commit = CommitRef::from_bytes(&fixture, crate::fixture_hash_kind())?;
     let pgp_sig = b"-----BEGIN PGP SIGNATURE-----".as_bstr();
@@ -491,7 +493,7 @@ fn bogus_multi_gpgsig_header_sha1() -> crate::Result {
     Ok(())
 }
 
-fn commit_fixture(path: &str) -> crate::Result<Vec<u8>> {
+fn commit_fixture(path: &str) -> Result<Vec<u8>> {
     crate::object_fixture(&format!("commit/{path}"))
 }
 
diff --git a/gix-object/tests/object/commit/iter.rs b/gix-object/tests/object/commit/iter.rs
index cf68a376380..f8087c40164 100644
--- a/gix-object/tests/object/commit/iter.rs
+++ b/gix-object/tests/object/commit/iter.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_object::{CommitRefIter, bstr::ByteSlice, commit::ref_iter::Token};
 
 use crate::{
@@ -6,9 +7,9 @@ use crate::{
 };
 
 #[test]
-fn newline_right_after_signature_multiline_header() -> crate::Result {
+fn newline_right_after_signature_multiline_header() -> Result {
     let data = fixture_name("commit", "signed-whitespace.txt");
-    let tokens = CommitRefIter::from_bytes(&data, gix_hash::Kind::Sha1).collect::<Result<Vec<_>, _>>()?;
+    let tokens = CommitRefIter::from_bytes(&data, gix_hash::Kind::Sha1).collect::<std::result::Result<Vec<_>, _>>()?;
     assert_eq!(tokens.len(), 7, "mainly a parsing exercise");
     match tokens.last().expect("there are tokens") {
         Token::Message(msg) => {
@@ -20,11 +21,11 @@ fn newline_right_after_signature_multiline_header() -> crate::Result {
 }
 
 #[test]
-fn signed_with_encoding() -> crate::Result {
+fn signed_with_encoding() -> Result {
     let input = fixture_name("commit", "signed-with-encoding.txt");
     let iter = CommitRefIter::from_bytes(&input, gix_hash::Kind::Sha1);
     assert_eq!(
-        iter.collect::<Result<Vec<_>, _>>()?,
+        iter.collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             Token::Tree {
                 id: hex_to_id("1973afa74d87b2bb73fa884aaaa8752aec43ea88")
@@ -50,10 +51,10 @@ fn signed_with_encoding() -> crate::Result {
 }
 
 #[test]
-fn whitespace() -> crate::Result {
+fn whitespace() -> Result {
     assert_eq!(
         CommitRefIter::from_bytes(&fixture_name("commit", "whitespace.txt"), gix_hash::Kind::Sha1)
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             Token::Tree {
                 id: hex_to_id("9bed6275068a0575243ba8409253e61af81ab2ff")
@@ -74,10 +75,10 @@ fn whitespace() -> crate::Result {
 }
 
 #[test]
-fn unsigned() -> crate::Result {
+fn unsigned() -> Result {
     assert_eq!(
         CommitRefIter::from_bytes(&fixture_name("commit", "unsigned.txt"), gix_hash::Kind::Sha1)
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             Token::Tree {
                 id: hex_to_id("1b2dfb4ac5e42080b682fc676e9738c94ce6d54d")
@@ -95,10 +96,10 @@ fn unsigned() -> crate::Result {
 }
 
 #[test]
-fn signed_singleline() -> crate::Result {
+fn signed_singleline() -> Result {
     assert_eq!(
         CommitRefIter::from_bytes(&fixture_name("commit", "signed-singleline.txt"), gix_hash::Kind::Sha1)
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             Token::Tree {
                 id: hex_to_id("00fc39317701176e326974ce44f5bd545a32ec0b")
@@ -126,7 +127,7 @@ fn signed_singleline() -> crate::Result {
 }
 
 #[test]
-fn error_handling() -> crate::Result {
+fn error_handling() -> Result {
     let data = fixture_name("commit", "unsigned.txt");
     let iter = CommitRefIter::from_bytes(&data[..data.len() / 2], gix_hash::Kind::Sha1);
     let tokens = iter.collect::<Vec<_>>();
@@ -138,11 +139,11 @@ fn error_handling() -> crate::Result {
 }
 
 #[test]
-fn mergetag() -> crate::Result {
+fn mergetag() -> Result {
     let input = fixture_name("commit", "mergetag.txt");
     let iter = CommitRefIter::from_bytes(&input, gix_hash::Kind::Sha1);
     assert_eq!(
-        iter.collect::<Result<Vec<_>, _>>()?,
+        iter.collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             Token::Tree {
                 id: hex_to_id("1c61918031bf2c7fab9e17dde3c52a6a9884fcb5")
@@ -175,12 +176,13 @@ fn mergetag() -> crate::Result {
 }
 
 mod method {
+    use crate::Result;
     use gix_object::CommitRefIter;
 
     use crate::{fixture_name, hex_to_id, signature};
 
     #[test]
-    fn tree_id() -> crate::Result {
+    fn tree_id() -> Result {
         let input = fixture_name("commit", "unsigned.txt");
         let iter = CommitRefIter::from_bytes(&input, gix_hash::Kind::Sha1);
         assert_eq!(
@@ -196,7 +198,7 @@ mod method {
     }
 
     #[test]
-    fn signatures() -> crate::Result {
+    fn signatures() -> Result {
         let input = fixture_name("commit", "unsigned.txt");
         let iter = CommitRefIter::from_bytes(&input, gix_hash::Kind::Sha1);
         assert_eq!(
@@ -214,6 +216,7 @@ mod method {
     }
 
     mod signature {
+        use crate::Result;
         use bstr::{BStr, BString, ByteSlice};
         use gix_object::CommitRefIter;
 
@@ -226,7 +229,7 @@ mod method {
             fixture: &str,
             expected_signature: impl Into<&'a BStr>,
             signature_lines: std::ops::RangeInclusive<usize>,
-        ) -> crate::Result {
+        ) -> Result {
             let expected_signature = expected_signature.into();
             let fixture_data = fixture_name("commit", fixture);
 
@@ -245,27 +248,27 @@ mod method {
         }
 
         #[test]
-        fn single_line() -> crate::Result {
+        fn single_line() -> Result {
             validate("signed-singleline.txt", b"magic:signature", 4..=4)
         }
 
         #[test]
-        fn signed() -> crate::Result {
+        fn signed() -> Result {
             validate("signed.txt", 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", 4..=14)
         }
 
         #[test]
-        fn with_encoding() -> crate::Result {
+        fn with_encoding() -> Result {
             validate("signed-with-encoding.txt", SIGNATURE, 5..=15)
         }
 
         #[test]
-        fn msg_footer() -> crate::Result {
+        fn msg_footer() -> Result {
             validate("message-with-footer.txt", b"-----BEGIN PGP SIGNATURE-----\n\niHUEABYIAB0WIQSuZwcGWSQItmusNgR5URpSUCnwXQUCYT7xpAAKCRB5URpSUCnw\nXWB3AP9q323HlxnI8MyqszNOeYDwa7Y3yEZaUM2y/IRjz+z4YQEAq0yr1Syt3mrK\nOSFCqL2vDm3uStP+vF31f6FnzayhNg0=\n=Mhpp\n-----END PGP SIGNATURE-----\n", 4..=10)
         }
 
         #[test]
-        fn whitespace() -> crate::Result {
+        fn whitespace() -> Result {
             validate("signed-whitespace.txt", OTHER_SIGNATURE, 5..=15)
         }
     }
diff --git a/gix-object/tests/object/commit/mod.rs b/gix-object/tests/object/commit/mod.rs
index d2dcda4d236..5c3b58ac49f 100644
--- a/gix-object/tests/object/commit/mod.rs
+++ b/gix-object/tests/object/commit/mod.rs
@@ -153,13 +153,14 @@ iyBBl69jASy41Ug/BlFJbw4+ItkShpXwkJKuBBV/JExChmvbxYWaS7QnyYC9UO0=
 ";
 
 mod method {
+    use crate::Result;
     use gix_object::CommitRef;
     use pretty_assertions::assert_eq;
 
     use crate::{fixture_name, signature};
 
     #[test]
-    fn tree() -> crate::Result {
+    fn tree() -> Result {
         let fixture = fixture_name("commit", "unsigned.txt");
         let commit = CommitRef::from_bytes(&fixture, gix_hash::Kind::Sha1)?;
         assert_eq!(commit.tree(), "1b2dfb4ac5e42080b682fc676e9738c94ce6d54d");
@@ -168,7 +169,7 @@ mod method {
     }
 
     #[test]
-    fn author_and_committer_trims_signature() -> crate::Result {
+    fn author_and_committer_trims_signature() -> Result {
         let backing = fixture_name("commit", "email-with-space.txt");
         let commit = CommitRef::from_bytes(&backing, gix_hash::Kind::Sha1)?;
         std::assert_eq!(commit.author()?, signature("1592437401 +0800"));
@@ -184,7 +185,7 @@ fn invalid() {
     assert!(CommitRef::from_bytes(partial_commit, gix_hash::Kind::Sha1).is_err());
     assert_eq!(
         CommitRefIter::from_bytes(partial_commit, gix_hash::Kind::Sha1)
-            .take_while(Result::is_ok)
+            .take_while(std::result::Result::is_ok)
             .count(),
         1,
         "we can decode some fields before failing"
diff --git a/gix-object/tests/object/commit/signature.rs b/gix-object/tests/object/commit/signature.rs
index e8453467a8b..d8a3d15e2d1 100644
--- a/gix-object/tests/object/commit/signature.rs
+++ b/gix-object/tests/object/commit/signature.rs
@@ -87,7 +87,7 @@ fn x509() -> Result {
     )?;
     assert!(
         outcome.is_valid(),
-        "the plumbing verifier accepts the generated X.509 signature: {outcome:?}"
+        "the plumbing verifier accepts the generated X.509 signature"
     );
     Ok(())
 }
diff --git a/gix-object/tests/object/encode.rs b/gix-object/tests/object/encode.rs
index c4b534e6ff1..586bb48edba 100644
--- a/gix-object/tests/object/encode.rs
+++ b/gix-object/tests/object/encode.rs
@@ -1,9 +1,5 @@
-/// Because the `TryFrom` implementations don't return proper errors
-/// on failure
-#[derive(Debug, thiserror::Error)]
-enum Error {
-    #[error("")]
-    TryFromError,
+fn try_from_error() -> std::io::Error {
+    std::io::Error::other("object type conversion failed")
 }
 
 /// Needed for roundtripping object types that take a `object_hash` parameter.
@@ -54,7 +50,7 @@ macro_rules! round_trip_with_hash_kind {
                     w.write_all(&item.loose_header())?;
                     item.write_to(w)?;
                     let parsed = ObjectRef::from_loose(&output, hash_kind)?;
-                    let item2 = <$borrowed>::try_from(parsed).or(Err(super::Error::TryFromError))?;
+                    let item2 = <$borrowed>::try_from(parsed).map_err(|_| super::try_from_error())?;
                     assert_eq!(item2, item, "object-ref loose: {input_name} {:?}\n{:?}", output.as_bstr(), input.as_bstr());
                 }
 
@@ -65,8 +61,8 @@ macro_rules! round_trip_with_hash_kind {
                 w.write_all(&item.loose_header())?;
                 item.write_to(w)?;
                 let parsed = ObjectRef::from_loose(&output, hash_kind)?;
-                let parsed_borrowed = <$borrowed>::try_from(parsed).or(Err(super::Error::TryFromError))?;
-                let item2: $owned = parsed_borrowed.try_into().or(Err(super::Error::TryFromError))?;
+                let parsed_borrowed = <$borrowed>::try_from(parsed).map_err(|_| super::try_from_error())?;
+                let item2: $owned = parsed_borrowed.try_into().map_err(|_| super::try_from_error())?;
                 assert_eq!(item2, item, "object-ref loose owned: {input_name} {:?}\n{:?}", output.as_bstr(), input.as_bstr());
             }
             Ok(())
@@ -137,10 +133,16 @@ mod tree {
             oid: hash_kind.null(),
         });
         let err = tree.write_to(&mut std::io::sink()).unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            r#"Nullbytes are invalid in file paths as they are separators: "hi\0ho""#
-        );
+        insta::assert_debug_snapshot!(err, "write to does not allow separator", @r#"
+        Custom {
+            kind: Other,
+            error: Message {
+                message: "Nullbytes are invalid in file paths as they are separators",
+                class: Validation,
+                values: {"input": Bytes("hi\0ho")},
+            },
+        }
+        "#);
     }
 
     round_trip_with_hash_kind!(gix_object::Tree, gix_object::TreeRef, "tree/everything.tree");
@@ -187,7 +189,7 @@ mod blob {
             w.write_all(&item.loose_header())?;
             item.write_to(w)?;
             let parsed = ObjectRef::from_loose(&output, gix_testtools::object_hash())?;
-            let item2 = BlobRef::try_from(parsed).or(Err(super::Error::TryFromError))?;
+            let item2 = BlobRef::try_from(parsed).map_err(|_| super::try_from_error())?;
             assert_eq!(
                 item2,
                 item,
@@ -203,7 +205,7 @@ mod blob {
         w.write_all(&item.loose_header())?;
         item.write_to(w)?;
         let parsed = ObjectRef::from_loose(&output, gix_testtools::object_hash())?;
-        let parsed_borrowed = BlobRef::try_from(parsed).or(Err(super::Error::TryFromError))?;
+        let parsed_borrowed = BlobRef::try_from(parsed).map_err(|_| super::try_from_error())?;
         let item2: Blob = parsed_borrowed.into();
         assert_eq!(
             item2,
@@ -222,7 +224,7 @@ mod loose_header {
     use gix_object::{Kind, decode, encode};
 
     #[test]
-    fn round_trip() -> Result<(), Box<dyn std::error::Error>> {
+    fn round_trip() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         for (kind, size, expected) in &[
             (Kind::Tree, 1234, "tree 1234\0".as_bytes()),
             (Kind::Blob, 0, b"blob 0\0"),
diff --git a/gix-object/tests/object/object_ref.rs b/gix-object/tests/object/object_ref.rs
index 605442ef52f..20758340660 100644
--- a/gix-object/tests/object/object_ref.rs
+++ b/gix-object/tests/object/object_ref.rs
@@ -3,11 +3,7 @@ mod from_loose {
 
     #[test]
     fn shorter_than_advertised() {
-        assert_eq!(
-            ObjectRef::from_loose(b"tree 1000\x00", gix_testtools::object_hash(),)
-                .unwrap_err()
-                .to_string(),
-            "object data was shorter than its size declared in the header"
-        );
+        insta::assert_debug_snapshot!(ObjectRef::from_loose(b"tree 1000\x00", gix_testtools::object_hash(),)
+                .expect_err("shorter than advertised"), "shorter than advertised", @"object data was shorter than its size declared in the header");
     }
 }
diff --git a/gix-object/tests/object/tag/mod.rs b/gix-object/tests/object/tag/mod.rs
index 8653de6defb..5fa00281ce9 100644
--- a/gix-object/tests/object/tag/mod.rs
+++ b/gix-object/tests/object/tag/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use crate::signature;
 use gix_object::{Kind, TagRef, TagRefIter, bstr::ByteSlice};
 
@@ -131,7 +132,7 @@ message\n"
 }
 
 #[test]
-fn sha256_with_all_fields_and_signature() -> crate::Result {
+fn sha256_with_all_fields_and_signature() -> Result {
     let input = b"object abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789
 type commit
 tag v2.0.0-sha256
@@ -173,7 +174,7 @@ sha256-tag-signature
         )
     );
 
-    let tokens = TagRefIter::from_bytes(input, gix_hash::Kind::Sha256).collect::<Result<Vec<_>, _>>()?;
+    let tokens = TagRefIter::from_bytes(input, gix_hash::Kind::Sha256).collect::<std::result::Result<Vec<_>, _>>()?;
     assert!(matches!(
         tokens.first(),
         Some(gix_object::tag::ref_iter::Token::Target { id }) if id.kind() == gix_hash::Kind::Sha256
@@ -186,7 +187,7 @@ sha256-tag-signature
 }
 
 #[test]
-fn target() -> crate::Result {
+fn target() -> Result {
     let fixture = fixture_name("tag", "signed.txt");
     let tag_ref = TagRef::from_bytes(&fixture, gix_hash::Kind::Sha1)?;
     assert_eq!(tag_ref.target(), "ffa700b4aca13b80cb6b98a078e7c96804f8e0ec");
@@ -211,7 +212,7 @@ fn target() -> crate::Result {
 }
 
 #[test]
-fn tagger() -> crate::Result {
+fn tagger() -> Result {
     let fixture = fixture_name("tag", "tagger-with-whitespace.txt");
     let tag = TagRef::from_bytes(&fixture, gix_hash::Kind::Sha1)?;
     std::assert_eq!(tag.tagger()?, Some(signature("1592381636 +0800")));
@@ -219,18 +220,19 @@ fn tagger() -> crate::Result {
 }
 
 mod iter {
+    use crate::Result;
     use gix_object::{Kind, TagRefIter, bstr::ByteSlice, tag::ref_iter::Token};
 
     use crate::{fixture_name, hex_to_id, signature};
 
     #[test]
-    fn empty() -> crate::Result {
+    fn empty() -> Result {
         let tag = fixture_name("tag", "empty.txt");
         let tag_iter = TagRefIter::from_bytes(&tag, gix_hash::Kind::Sha1);
         let target_id = hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
         let tagger = Some(signature("1592381636 +0800"));
         assert_eq!(
-            tag_iter.collect::<Result<Vec<_>, _>>()?,
+            tag_iter.collect::<std::result::Result<Vec<_>, _>>()?,
             vec![
                 Token::Target { id: target_id },
                 Token::TargetKind(Kind::Commit),
@@ -248,10 +250,10 @@ mod iter {
     }
 
     #[test]
-    fn no_tagger() -> crate::Result {
+    fn no_tagger() -> Result {
         assert_eq!(
             TagRefIter::from_bytes(&fixture_name("tag", "no-tagger.txt"), gix_hash::Kind::Sha1)
-                .collect::<Result<Vec<_>, _>>()?,
+                .collect::<std::result::Result<Vec<_>, _>>()?,
             vec![
                 Token::Target {
                     id: hex_to_id("c39ae07f393806ccf406ef966e9a15afc43cc36a")
@@ -285,10 +287,10 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn whitespace() -> crate::Result {
+    fn whitespace() -> Result {
         assert_eq!(
             TagRefIter::from_bytes(&fixture_name("tag", "whitespace.txt"), gix_hash::Kind::Sha1)
-                .collect::<Result<Vec<_>, _>>()?,
+                .collect::<std::result::Result<Vec<_>, _>>()?,
             vec![
                 Token::Target {
                     id: hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc")
@@ -306,10 +308,10 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn pgp_begin_marker_not_at_line_start_is_message() -> crate::Result {
+    fn pgp_begin_marker_not_at_line_start_is_message() -> Result {
         assert_eq!(
             TagRefIter::from_bytes(super::PGP_BEGIN_NOT_AT_LINE_START, gix_hash::Kind::Sha1)
-                .collect::<Result<Vec<_>, _>>()?,
+                .collect::<std::result::Result<Vec<_>, _>>()?,
             vec![
                 Token::Target {
                     id: hex_to_id("ffa700b4aca13b80cb6b98a078e7c96804f8e0ec")
@@ -327,7 +329,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn error_handling() -> crate::Result {
+    fn error_handling() -> Result {
         let data = fixture_name("tag", "empty.txt");
         let iter = TagRefIter::from_bytes(&data[..data.len() / 3], gix_hash::Kind::Sha1);
         let tokens = iter.collect::<Vec<_>>();
@@ -346,7 +348,7 @@ fn invalid() {
     assert!(TagRef::from_bytes(partial_tag, gix_hash::Kind::Sha1).is_err());
     assert_eq!(
         TagRefIter::from_bytes(partial_tag, gix_hash::Kind::Sha1)
-            .take_while(Result::is_ok)
+            .take_while(std::result::Result::is_ok)
             .count(),
         3,
         "we can decode some fields before failing"
@@ -354,7 +356,7 @@ fn invalid() {
 }
 
 #[test]
-fn uppercase_target_id() -> crate::Result {
+fn uppercase_target_id() -> Result {
     let input = b"object FFA700B4ACA13B80CB6B98A078E7C96804F8E0EC
 type commit
 tag uppercase-target
@@ -380,12 +382,13 @@ fn invalid_target_id_length() {
 }
 
 mod from_bytes {
+    use crate::Result;
     use gix_object::{Kind, TagRef, WriteTo, bstr::ByteSlice};
 
     use crate::{fixture_name, fixture_oid, object_fixture};
 
     #[test]
-    fn signed() -> crate::Result {
+    fn signed() -> Result {
         let fixture = tag_fixture("signed.txt")?;
         let target = fixture_oid_hex("ffa700b4aca13b80cb6b98a078e7c96804f8e0ec");
         assert_eq!(
@@ -422,7 +425,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn empty() -> crate::Result {
+    fn empty() -> Result {
         let fixture = tag_fixture("empty.txt")?;
         let target = fixture_oid_hex("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
         let tag_ref = TagRef::from_bytes(&fixture, crate::fixture_hash_kind())?;
@@ -442,7 +445,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn empty_missing_nl() -> crate::Result {
+    fn empty_missing_nl() -> Result {
         let fixture = tag_fixture("empty_missing_nl.txt")?;
         let target = fixture_oid_hex("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
         let tag_ref = TagRef::from_bytes(&fixture, crate::fixture_hash_kind())?;
@@ -462,7 +465,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn with_newlines() -> crate::Result {
+    fn with_newlines() -> Result {
         let target = fixture_oid_hex("ebdf205038b66108c0331aa590388431427493b7");
         assert_eq!(
             TagRef::from_bytes(&tag_fixture("with-newlines.txt")?, crate::fixture_hash_kind())?,
@@ -479,7 +482,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn no_tagger() -> crate::Result {
+    fn no_tagger() -> Result {
         let target = fixture_oid_hex("c39ae07f393806ccf406ef966e9a15afc43cc36a");
         assert_eq!(
             TagRef::from_bytes(&tag_fixture("no-tagger.txt")?, crate::fixture_hash_kind())?,
@@ -512,7 +515,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn pgp_begin_marker_not_at_line_start_is_message() -> crate::Result {
+    fn pgp_begin_marker_not_at_line_start_is_message() -> Result {
         let tag = TagRef::from_bytes(super::PGP_BEGIN_NOT_AT_LINE_START, gix_hash::Kind::Sha1)?;
         assert_eq!(tag.message, super::PGP_BEGIN_NOT_AT_LINE_START_MESSAGE.as_bstr());
         assert_eq!(tag.signature, None, "it doesn't parse this as PGP signature");
@@ -521,7 +524,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn trailing_text_after_pgp_end_marker_is_signature() -> crate::Result {
+    fn trailing_text_after_pgp_end_marker_is_signature() -> Result {
         let tag = TagRef::from_bytes(super::PGP_SIGNATURE_WITH_TRAILING_TEXT, gix_hash::Kind::Sha1)?;
         assert_eq!(tag.message, b"message text".as_bstr());
         assert_eq!(
@@ -533,7 +536,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn pgp_begin_marker_without_end_marker_starts_signature() -> crate::Result {
+    fn pgp_begin_marker_without_end_marker_starts_signature() -> Result {
         let tag = TagRef::from_bytes(super::PGP_SIGNATURE_WITHOUT_END_MARKER, gix_hash::Kind::Sha1)?;
         assert_eq!(tag.message, b"message text".as_bstr());
         assert_eq!(
@@ -545,7 +548,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn pgp_begin_marker_at_body_start_is_signature() -> crate::Result {
+    fn pgp_begin_marker_at_body_start_is_signature() -> Result {
         let tag = TagRef::from_bytes(super::PGP_SIGNATURE_AT_BODY_START, gix_hash::Kind::Sha1)?;
         assert_eq!(tag.message, b"".as_bstr());
         assert_eq!(
@@ -557,7 +560,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn whitespace() -> crate::Result {
+    fn whitespace() -> Result {
         let target = fixture_oid_hex("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
         assert_eq!(
             TagRef::from_bytes(&tag_fixture("whitespace.txt")?, crate::fixture_hash_kind())?,
@@ -574,7 +577,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 
     #[test]
-    fn tagger_without_timestamp() -> crate::Result {
+    fn tagger_without_timestamp() -> Result {
         assert_eq!(
             TagRef::from_bytes(
                 &fixture_name("tag", "tagger-without-timestamp.txt"),
@@ -592,7 +595,7 @@ KLMHist5yj0sw1E4hDTyQa0=
         Ok(())
     }
 
-    fn assert_roundtrip(input: &[u8]) -> crate::Result {
+    fn assert_roundtrip(input: &[u8]) -> Result {
         let tag = TagRef::from_bytes(input, gix_hash::Kind::Sha1)?;
         let mut out = Vec::new();
         tag.write_to(&mut out)?;
@@ -600,7 +603,7 @@ KLMHist5yj0sw1E4hDTyQa0=
         Ok(())
     }
 
-    fn tag_fixture(path: &str) -> crate::Result<Vec<u8>> {
+    fn tag_fixture(path: &str) -> Result<Vec<u8>> {
         object_fixture(&format!("tag/{path}"))
     }
 
diff --git a/gix-object/tests/object/tag/signature.rs b/gix-object/tests/object/tag/signature.rs
index 0974bf447b1..a312bb3bf1d 100644
--- a/gix-object/tests/object/tag/signature.rs
+++ b/gix-object/tests/object/tag/signature.rs
@@ -88,10 +88,7 @@ fn x509() -> Result {
             minimum_trust: TrustLevel::Undefined,
         },
     )?;
-    assert!(
-        outcome.is_valid(),
-        "the generated X.509 signature is valid: {outcome:?}"
-    );
+    assert!(outcome.is_valid(), "the generated X.509 signature is valid");
     Ok(())
 }
 
diff --git a/gix-object/tests/object/tree/editor.rs b/gix-object/tests/object/tree/editor.rs
index 597f22e5115..dbc5b40574a 100644
--- a/gix-object/tests/object/tree/editor.rs
+++ b/gix-object/tests/object/tree/editor.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_object::{
     Tree,
     tree::{Entry, EntryKind},
@@ -12,7 +13,7 @@ fn null_id() -> gix_hash::ObjectId {
 }
 
 #[test]
-fn from_empty_cursor() -> crate::Result {
+fn from_empty_cursor() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -141,7 +142,7 @@ fn from_empty_cursor() -> crate::Result {
     Ok(())
 }
 #[test]
-fn from_existing_cursor() -> crate::Result {
+fn from_existing_cursor() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new_with_odb(storage.clone(), tree_odb()?);
     let root_tree_id = crate::generated_tree_root_id()?;
@@ -222,7 +223,7 @@ fn from_existing_cursor() -> crate::Result {
     Ok(())
 }
 #[test]
-fn from_empty_removal() -> crate::Result {
+fn from_empty_removal() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -308,7 +309,7 @@ fn from_empty_removal() -> crate::Result {
 }
 
 #[test]
-fn from_empty_remove_accepts_empty_segments_after_unreachable_paths() -> crate::Result {
+fn from_empty_remove_accepts_empty_segments_after_unreachable_paths() -> Result {
     let (storage, mut write, _num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -335,7 +336,7 @@ fn from_empty_remove_accepts_empty_segments_after_unreachable_paths() -> crate::
 }
 
 #[test]
-fn from_empty_remove_leaf_rejects_tree_entries() -> crate::Result {
+fn from_empty_remove_leaf_rejects_tree_entries() -> Result {
     let (storage, mut write, _num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -343,11 +344,7 @@ fn from_empty_remove_leaf_rejects_tree_entries() -> crate::Result {
     edit.upsert(["A", "one"], EntryKind::Blob, any_blob())?;
 
     let err = edit.remove_leaf(Some("A")).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "Cannot remove 'A' as leaf entry because it is a tree",
-        "leaf-only removal must reject non-leaf entries"
-    );
+    insta::assert_debug_snapshot!(err, "leaf-only removal must reject non-leaf entries", @"Cannot remove 'A' as leaf entry because it is a tree");
 
     edit.remove_leaf(["A", "one"])?;
     let actual = edit.write(&mut write)?;
@@ -387,7 +384,7 @@ fn from_empty_remove_leaf_rejects_tree_entries() -> crate::Result {
 }
 
 #[test]
-fn from_existing_remove() -> crate::Result {
+fn from_existing_remove() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new_with_odb(storage.clone(), tree_odb()?);
     let root_tree_id = crate::generated_tree_root_id()?;
@@ -451,7 +448,7 @@ fn from_existing_remove() -> crate::Result {
     Ok(())
 }
 #[test]
-fn from_empty_invalid_write() -> crate::Result {
+fn from_empty_invalid_write() -> Result {
     let (storage, mut write, _num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -471,18 +468,23 @@ fn from_empty_invalid_write() -> crate::Result {
         .upsert(Some("with\0null"), EntryKind::Blob, any_blob())?
         .write(&mut write)
         .unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        r#"Nullbytes are invalid in file paths as they are separators: "with\0null""#
-    );
+    insta::assert_debug_snapshot!(err, "from empty invalid write", @r#"
+    Custom {
+        kind: Other,
+        error: Message {
+            message: "Nullbytes are invalid in file paths as they are separators",
+            class: Validation,
+            values: {"input": Bytes("with\0null")},
+        },
+    }
+    "#);
 
     let err = edit.upsert(Some(""), EntryKind::Blob, any_blob()).unwrap_err();
-    let expected_msg = "Empty path components are not allowed";
-    assert_eq!(err.to_string(), expected_msg);
+    insta::assert_debug_snapshot!(err, "from empty invalid write", @"Empty path components are not allowed");
     let err = edit
         .upsert(["fine", "", "previous is not fine"], EntryKind::Blob, any_blob())
         .unwrap_err();
-    assert_eq!(err.to_string(), expected_msg);
+    insta::assert_debug_snapshot!(err, "from empty invalid write", @"Empty path components are not allowed");
 
     let actual = edit
         .remove(Some("a"))?
@@ -500,7 +502,7 @@ fn from_empty_invalid_write() -> crate::Result {
     Ok(())
 }
 #[test]
-fn from_empty_add() -> crate::Result {
+fn from_empty_add() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new(storage.clone());
     let mut edit = gix_object::tree::Editor::new(Tree::default(), &odb, hash_kind());
@@ -703,7 +705,7 @@ fn from_empty_add() -> crate::Result {
     Ok(())
 }
 #[test]
-fn from_existing_add() -> crate::Result {
+fn from_existing_add() -> Result {
     let (storage, mut write, num_writes_and_clear) = new_inmemory_writes();
     let odb = StorageOdb::new_with_odb(storage.clone(), tree_odb()?);
     let root_tree_id = crate::generated_tree_root_id()?;
@@ -868,6 +870,8 @@ mod utils {
         rc::Rc,
     };
 
+    use gix_error::ExnResult;
+
     use bstr::{BStr, ByteSlice};
     use gix_hash::ObjectId;
     use gix_object::{Tree, WriteTo};
@@ -932,11 +936,7 @@ mod utils {
     }
 
     impl gix_object::Find for StorageOdb {
-        fn try_find<'a>(
-            &self,
-            id: &gix_hash::oid,
-            buffer: &'a mut Vec<u8>,
-        ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
             let borrow = self.0.borrow();
             let old = self.2.get();
             self.2.set(old + 1);
diff --git a/gix-object/tests/object/tree/entries.rs b/gix-object/tests/object/tree/entries.rs
index c355a0c062b..743f3cba35b 100644
--- a/gix-object/tests/object/tree/entries.rs
+++ b/gix-object/tests/object/tree/entries.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_object::{Tree, TreeRef};
 
 #[test]
@@ -24,7 +25,7 @@ fn name_order_accounts_for_the_implicit_tree_separator() {
 }
 
 #[test]
-fn sort_order_is_correct() -> crate::Result {
+fn sort_order_is_correct() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_trees.sh")?;
     let input = std::fs::read(root.join("tree.baseline"))?;
 
diff --git a/gix-object/tests/object/tree/from_bytes.rs b/gix-object/tests/object/tree/from_bytes.rs
index a85cb13312d..c7a61160afc 100644
--- a/gix-object/tests/object/tree/from_bytes.rs
+++ b/gix-object/tests/object/tree/from_bytes.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use gix_object::{Tree, TreeRef, TreeRefIter, WriteTo, bstr::ByteSlice, tree, tree::EntryRef};
 
 use crate::{fixture_oid, tree_fixture};
 
 #[test]
-fn empty() -> crate::Result {
+fn empty() -> Result {
     let tree_ref = TreeRef::from_bytes(&[], gix_testtools::object_hash())?;
     assert_eq!(
         tree_ref,
@@ -22,7 +23,7 @@ fn empty() -> crate::Result {
 }
 
 #[test]
-fn everything() -> crate::Result {
+fn everything() -> Result {
     let fixture = tree_fixture("everything.tree")?;
     let hash_kind = crate::fixture_hash_kind();
     let tree_ref = TreeRef::from_bytes(&fixture, hash_kind)?;
@@ -69,7 +70,7 @@ fn invalid() {
     assert!(TreeRef::from_bytes(partial_tree, hash_kind).is_err());
     assert!(
         TreeRefIter::from_bytes(partial_tree, hash_kind)
-            .take_while(Result::is_ok)
+            .take_while(std::result::Result::is_ok)
             .count()
             > 0,
         "we can decode some entries before failing"
@@ -94,7 +95,7 @@ fn fuzz_artifact_inputs_can_be_parsed_without_panicking() {
 }
 
 #[test]
-fn special_trees() -> crate::Result {
+fn special_trees() -> Result {
     let hash_kind = crate::fixture_hash_kind();
     for (name, expected_entry_count) in [
         ("maybe-special", 160),
@@ -109,7 +110,9 @@ fn special_trees() -> crate::Result {
         let actual = TreeRef::from_bytes(&fixture, hash_kind)?;
         assert_eq!(actual.entries.len(), expected_entry_count, "{name}");
         assert_eq!(
-            TreeRefIter::from_bytes(&fixture, hash_kind).map(Result::unwrap).count(),
+            TreeRefIter::from_bytes(&fixture, hash_kind)
+                .map(std::result::Result::unwrap)
+                .count(),
             expected_entry_count,
             "{name}"
         );
diff --git a/gix-object/tests/object/tree/iter.rs b/gix-object/tests/object/tree/iter.rs
index 3a1973000fa..0d858a8c4a7 100644
--- a/gix-object/tests/object/tree/iter.rs
+++ b/gix-object/tests/object/tree/iter.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_object::{
     TreeRefIter,
     bstr::ByteSlice,
@@ -47,10 +48,10 @@ fn offset_to_next_entry() {
 }
 
 #[test]
-fn everything() -> crate::Result {
+fn everything() -> Result {
     assert_eq!(
         TreeRefIter::from_bytes(&tree_fixture("everything.tree")?, fixture_hash_kind())
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             EntryRef {
                 mode: tree::EntryKind::BlobExecutable.into(),
@@ -83,13 +84,13 @@ fn everything() -> crate::Result {
 }
 
 #[test]
-fn leading_space_in_tree_name() -> crate::Result {
+fn leading_space_in_tree_name() -> Result {
     let oid = fixture_oid("4d5fcadc293a348e88f777dc0920f11e7d71441c");
     let mut buf = b"40000  leading space\0".to_vec();
     buf.extend_from_slice(oid.as_bytes());
 
     assert_eq!(
-        TreeRefIter::from_bytes(&buf, fixture_hash_kind()).collect::<Result<Vec<_>, _>>()?,
+        TreeRefIter::from_bytes(&buf, fixture_hash_kind()).collect::<std::result::Result<Vec<_>, _>>()?,
         vec![EntryRef {
             mode: tree::EntryKind::Tree.into(),
             filename: b" leading space".as_bstr(),
@@ -100,13 +101,14 @@ fn leading_space_in_tree_name() -> crate::Result {
 }
 
 mod lookup_entry {
+    use crate::Result;
     use gix_object::tree::EntryKind;
     use utils::entry;
 
     use crate::fixture_hash_kind;
 
     #[test]
-    fn top_level_directory() -> crate::Result {
+    fn top_level_directory() -> Result {
         assert_eq!(
             utils::lookup_entry_by_path("bin")?,
             entry("bin", EntryKind::Blob, fixture_hash_kind().empty_blob())
@@ -115,7 +117,7 @@ mod lookup_entry {
     }
 
     #[test]
-    fn nested_file() -> crate::Result {
+    fn nested_file() -> Result {
         assert_eq!(
             utils::lookup_entry_by_path("file/a")?,
             entry("a", EntryKind::Blob, fixture_hash_kind().empty_blob())
@@ -124,7 +126,7 @@ mod lookup_entry {
     }
 
     #[test]
-    fn non_existing_nested_file() -> crate::Result {
+    fn non_existing_nested_file() -> Result {
         for path in ["file/does-not-exist", "non-existing", "file/a/through-file"] {
             let actual = utils::lookup_entry_by_path(path)?;
             assert_eq!(actual, None);
@@ -158,7 +160,7 @@ mod lookup_entry {
             let root_tree = odb.find_tree_iter(&root_tree_id, &mut buf)?;
 
             let mut buf = Vec::new();
-            root_tree.lookup_entry_by_path(&odb, &mut buf, path)
+            Ok(root_tree.lookup_entry_by_path(&odb, &mut buf, path)?)
         }
     }
 }
diff --git a/gix-odb/Cargo.toml b/gix-odb/Cargo.toml
index 179395cf791..92426cd8e3f 100644
--- a/gix-odb/Cargo.toml
+++ b/gix-odb/Cargo.toml
@@ -39,7 +39,6 @@ gix-fs = { version = "^0.22.1", path = "../gix-fs" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 tempfile = "3.26.0"
-thiserror = "2.0.18"
 parking_lot = { version = "0.12.4" }
 arc-swap = "1.9.0"
 memmap2 = "0.9.11"
@@ -47,6 +46,7 @@ memmap2 = "0.9.11"
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-odb = { path = ".", features = ["sha1", "sha256"] }
 gix-hash = { path = "../gix-hash" }
 gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1", "sha256"] }
diff --git a/gix-odb/src/alternate/mod.rs b/gix-odb/src/alternate/mod.rs
index d10086b06c0..a1ab00179cc 100644
--- a/gix-odb/src/alternate/mod.rs
+++ b/gix-odb/src/alternate/mod.rs
@@ -18,24 +18,33 @@
 //! Based on the [canonical implementation](https://github.com/git/git/blob/master/sha1-file.c#L598:L609).
 use std::{fs, io, path::PathBuf};
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt};
 use gix_path::realpath::MAX_SYMLINKS;
 
-///
-pub mod parse;
-pub use parse::function::parse;
+mod parse;
+pub use parse::parse;
 
-/// Returned by [`resolve()`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Realpath(#[from] gix_path::realpath::Error),
-    #[error(transparent)]
-    Parse(#[from] parse::Error),
-    #[error("Alternates form a cycle: {} -> {}", .0.iter().map(|p| format!("'{}'", p.display())).collect::<Vec<_>>().join(" -> "), .0.first().expect("more than one directories").display())]
-    Cycle(Vec<PathBuf>),
+/// An alternate object directory points back into the chain being resolved.
+#[derive(Debug)]
+pub struct Cycle {
+    /// Canonical object directories in traversal order, with an implicit link from the last to the first.
+    pub paths: Vec<PathBuf>,
+}
+
+impl std::fmt::Display for Cycle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Alternates form a cycle")?;
+        for path in &self.paths {
+            write!(f, " -> {}", path.display())?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for Cycle {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::CORRUPTION })
+    }
 }
 
 /// Given an `objects_directory`, try to resolve alternate object directories possibly located in the
@@ -44,7 +53,9 @@ pub enum Error {
 /// if there are no alternates).
 /// An object directory that was resolved before is skipped, and it is an error if an alternate points back
 /// into the chain of directories that is currently being followed, as that would form a cycle.
-pub fn resolve(objects_directory: PathBuf, current_dir: &std::path::Path) -> Result<Vec<PathBuf>, Error> {
+/// Read and parse failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the alternates file.
+/// Cycles retain their canonical directory chain in [`Cycle`].
+pub fn resolve(objects_directory: PathBuf, current_dir: &std::path::Path) -> ExnResult<Vec<PathBuf>> {
     let mut dirs = vec![(None, objects_directory.clone())];
     let mut out = Vec::new();
     let mut seen = Vec::new();
@@ -60,20 +71,29 @@ pub fn resolve(objects_directory: PathBuf, current_dir: &std::path::Path) -> Res
                     .collect();
                 cycle.push(seen[seen_idx].0.clone());
                 cycle.reverse();
-                return Err(Error::Cycle(cycle));
+                return Err(Cycle { paths: cycle }.raise_erased());
             }
             continue;
         }
         let idx = seen.len();
         seen.push((dir_canonicalized, parent_idx));
-        match fs::read(dir.join("info").join("alternates")) {
+        let path = dir.join("info").join("alternates");
+        match fs::read(&path) {
             Ok(input) => {
-                for path in parse(&input)?.into_iter().rev() {
+                for path in parse(&input)
+                    .or_raise_erased(|| Message::new("Could not parse alternates").with("path", path))?
+                    .into_iter()
+                    .rev()
+                {
                     dirs.push((Some(idx), objects_directory.join(path)));
                 }
             }
             Err(err) if err.kind() == io::ErrorKind::NotFound => {}
-            Err(err) => return Err(err.into()),
+            Err(err) => {
+                return Err(err
+                    .and_raise(Message::new("Could not read alternates").with("path", path))
+                    .erased());
+            }
         }
         if parent_idx.is_some() {
             out.push(dir);
diff --git a/gix-odb/src/alternate/parse.rs b/gix-odb/src/alternate/parse.rs
index b710a0b22ab..366285e4bb3 100644
--- a/gix-odb/src/alternate/parse.rs
+++ b/gix-odb/src/alternate/parse.rs
@@ -1,51 +1,43 @@
-/// Returned as part of [`crate::alternate::Error::Parse`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not obtain an object path for the alternate directory '{}'", String::from_utf8_lossy(.0))]
-    PathConversion(Vec<u8>),
-}
-
-pub(super) mod function {
-    use super::Error;
-    use std::{borrow::Cow, path::PathBuf};
+use gix_error::{ExnMessageResult, Message, ResultExt};
+use std::{borrow::Cow, path::PathBuf};
 
-    use gix_object::bstr::ByteSlice;
+use gix_object::bstr::ByteSlice;
 
-    /// Parse the raw contents of an `objects/info/alternates` file from `input` into paths.
-    ///
-    /// Empty entries and comments are ignored. Entries beginning with `"` use Git's C-style quoting,
-    /// which permits literal newlines in paths. Invalid quoting falls back to the raw entry.
-    pub fn parse(mut input: &[u8]) -> Result<Vec<PathBuf>, Error> {
-        let mut out = Vec::new();
-        while !input.is_empty() {
-            let entry = input.as_bstr();
-            let end_of_line = || entry.find_byte(b'\n').unwrap_or(entry.len());
-            let (path, consumed) = if entry.starts_with(b"#") {
-                (None, end_of_line())
-            } else {
-                // Like Git, try unquoting before treating a newline as the next separator.
-                match entry.starts_with(b"\"").then(|| gix_quote::ansi_c::undo(entry)) {
-                    Some(Ok((unquoted, consumed))) => (Some(unquoted), consumed),
-                    _ => {
-                        let consumed = end_of_line();
-                        (Some(Cow::Borrowed(entry[..consumed].as_bstr())), consumed)
-                    }
+/// Parse the raw contents of an `objects/info/alternates` file from `input` into paths.
+///
+/// Empty entries and comments are ignored. Entries beginning with `"` use Git's C-style quoting,
+/// which permits literal newlines in paths. Invalid quoting falls back to the raw entry.
+/// Path conversion failures include [metadata](gix_error::Exn::metadata()) `input` (bytes), the original alternates
+/// entry.
+pub fn parse(mut input: &[u8]) -> ExnMessageResult<Vec<PathBuf>> {
+    let mut out = Vec::new();
+    while !input.is_empty() {
+        let entry = input.as_bstr();
+        let end_of_line = || entry.find_byte(b'\n').unwrap_or(entry.len());
+        let (path, consumed) = if entry.starts_with(b"#") {
+            (None, end_of_line())
+        } else {
+            // Like Git, try unquoting before treating a newline as the next separator.
+            match entry.starts_with(b"\"").then(|| gix_quote::ansi_c::undo(entry)) {
+                Some(Ok((unquoted, consumed))) => (Some(unquoted), consumed),
+                _ => {
+                    let consumed = end_of_line();
+                    (Some(Cow::Borrowed(entry[..consumed].as_bstr())), consumed)
                 }
-            };
-            let original = &entry[..consumed];
-            let maybe_nl = usize::from(consumed < input.len());
-            input = &input[consumed + maybe_nl..];
+            }
+        };
+        let original = &entry[..consumed];
+        let maybe_nl = usize::from(consumed < input.len());
+        input = &input[consumed + maybe_nl..];
 
-            let Some(path) = path.filter(|path| !path.is_empty()) else {
-                continue;
-            };
-            out.push(
-                gix_path::try_from_bstr(path)
-                    .map_err(|_| Error::PathConversion(original.to_vec()))?
-                    .into_owned(),
-            );
-        }
-        Ok(out)
+        let Some(path) = path.filter(|path| !path.is_empty()) else {
+            continue;
+        };
+        out.push(
+            gix_path::try_from_bstr(path)
+                .or_raise(|| Message::new("Could not obtain an alternate object directory").with("input", original))?
+                .into_owned(),
+        );
     }
+    Ok(out)
 }
diff --git a/gix-odb/src/cache.rs b/gix-odb/src/cache.rs
index ac2d90e8631..9d9bd11769d 100644
--- a/gix-odb/src/cache.rs
+++ b/gix-odb/src/cache.rs
@@ -135,6 +135,8 @@ impl<S> DerefMut for Cache<S> {
 mod impls {
     use std::{cell::RefCell, io::Read, ops::DerefMut};
 
+    use gix_error::ExnResult;
+
     use gix_hash::{ObjectId, oid};
     use gix_object::{Data, Kind};
     use gix_pack::cache::Object;
@@ -145,21 +147,11 @@ mod impls {
     where
         S: gix_object::Write,
     {
-        fn write_stream(
-            &self,
-            kind: Kind,
-            size: u64,
-            from: &mut dyn Read,
-        ) -> Result<ObjectId, gix_object::write::Error> {
+        fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
             self.inner.write_stream(kind, size, from)
         }
 
-        fn write_buf_with_known_id(
-            &self,
-            kind: Kind,
-            from: &[u8],
-            id: ObjectId,
-        ) -> Result<ObjectId, gix_object::write::Error> {
+        fn write_buf_with_known_id(&self, kind: Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
             self.inner.write_buf_with_known_id(kind, from, id)
         }
 
@@ -169,7 +161,7 @@ mod impls {
             size: u64,
             from: &mut dyn Read,
             id: ObjectId,
-        ) -> Result<ObjectId, gix_object::write::Error> {
+        ) -> ExnResult<ObjectId> {
             self.inner.write_stream_with_known_id(kind, size, from, id)
         }
     }
@@ -178,7 +170,7 @@ mod impls {
     where
         S: gix_pack::Find,
     {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             gix_pack::Find::try_find(self, id, buffer).map(|t| t.map(|t| t.0))
         }
     }
@@ -196,7 +188,7 @@ mod impls {
     where
         S: crate::Header,
     {
-        fn try_header(&self, id: &oid) -> Result<Option<Header>, gix_object::find::Error> {
+        fn try_header(&self, id: &oid) -> ExnResult<Option<Header>> {
             self.inner.try_header(id)
         }
     }
@@ -205,7 +197,7 @@ mod impls {
     where
         S: gix_object::FindHeader,
     {
-        fn try_header(&self, id: &oid) -> Result<Option<gix_object::Header>, gix_object::find::Error> {
+        fn try_header(&self, id: &oid) -> ExnResult<Option<gix_object::Header>> {
             self.inner.try_header(id)
         }
     }
@@ -218,11 +210,7 @@ mod impls {
             self.inner.contains(id)
         }
 
-        fn try_find<'a>(
-            &self,
-            id: &oid,
-            buffer: &'a mut Vec<u8>,
-        ) -> Result<Option<(Data<'a>, Option<Location>)>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<(Data<'a>, Option<Location>)>> {
             match self.pack_cache.as_ref().map(RefCell::borrow_mut) {
                 Some(mut pack_cache) => self.try_find_cached(id, buffer, pack_cache.deref_mut()),
                 None => self.try_find_cached(id, buffer, &mut gix_pack::cache::Never),
@@ -234,7 +222,7 @@ mod impls {
             id: &oid,
             buffer: &'a mut Vec<u8>,
             pack_cache: &mut dyn gix_pack::cache::DecodeEntry,
-        ) -> Result<Option<(Data<'a>, Option<gix_pack::data::entry::Location>)>, gix_object::find::Error> {
+        ) -> ExnResult<Option<(Data<'a>, Option<gix_pack::data::entry::Location>)>> {
             if let Some(mut obj_cache) = self.object_cache.as_ref().map(RefCell::borrow_mut)
                 && let Some(kind) = obj_cache.get(&id.as_ref().to_owned(), buffer)
             {
diff --git a/gix-odb/src/lib.rs b/gix-odb/src/lib.rs
index 88b27d9296f..e5d9eaf5c16 100644
--- a/gix-odb/src/lib.rs
+++ b/gix-odb/src/lib.rs
@@ -8,6 +8,18 @@
 //! * access to packed objects
 //! * multiple loose objects and pack locations as gathered from `alternates` files.
 //!
+//! Errors preserve their original sources and classifications through [`gix_error::Exn`] and [`gix_error::Error`].
+//! [`gix_error::Message`] contexts carry diagnostic details such as native paths, object IDs as hex text,
+//! and unsigned sizes or limits. Functions creating these contexts document their keys and value types.
+//! Use [`gix_error::Exn::metadata()`] or [`gix_error::Error::metadata()`] to inspect each dictionary,
+//! skipping empty ones. Synthetic failures combine their message, class, and values
+//! in one diagnostic; real callee errors remain separate causes.
+//! Alternate cycles retain their directory chain in [`alternate::Cycle`] and expose a classification-only
+//! [`gix_error::ClassificationMarker`] source. Use [`gix_error::classify()`] or `is_corrupted()` on [`gix_error::Exn`]
+//! and [`gix_error::Error`] without depending on the concrete diagnostic type.
+//! Retryable verification diagnostics use [`gix_error::retryable()`]. Interrupted verification retains its original
+//! I/O error and uses [`gix_error::ClassificationMarker`] with [`gix_error::Class::Retryable`].
+//!
 //! ## Write And Read Loose Objects
 //!
 //! ```
diff --git a/gix-odb/src/memory.rs b/gix-odb/src/memory.rs
index 9e6b9b21ec9..dfac2c3164b 100644
--- a/gix-odb/src/memory.rs
+++ b/gix-odb/src/memory.rs
@@ -5,6 +5,7 @@ use std::{
     sync::Arc,
 };
 
+use gix_error::{ExnResult, ResultExt};
 use gix_object::Data;
 
 use crate::{Cache, find::Header};
@@ -140,11 +141,7 @@ impl<T> gix_object::Find for Proxy<T>
 where
     T: gix_object::Find,
 {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
         if let Some(map) = self.memory.as_ref() {
             let map = map.borrow();
             if let Some((kind, data)) = map.get(id) {
@@ -174,7 +171,7 @@ impl<T> crate::Header for Proxy<T>
 where
     T: crate::Header,
 {
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<Header>, gix_object::find::Error> {
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<Header>> {
         if let Some(map) = self.memory.as_ref() {
             let map = map.borrow();
             if let Some((kind, data)) = map.get(id) {
@@ -192,7 +189,7 @@ impl<T> gix_object::FindHeader for Proxy<T>
 where
     T: gix_object::FindHeader,
 {
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<gix_object::Header>, gix_object::find::Error> {
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<gix_object::Header>> {
         if let Some(map) = self.memory.as_ref() {
             let map = map.borrow();
             if let Some((kind, data)) = map.get(id) {
@@ -210,15 +207,15 @@ impl<T> gix_object::Write for Proxy<T>
 where
     T: gix_object::Write,
 {
-    fn write(&self, object: &dyn gix_object::WriteTo) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    fn write(&self, object: &dyn gix_object::WriteTo) -> ExnResult<gix_hash::ObjectId> {
         let Some(map) = self.memory.as_ref() else {
             return self.inner.write(object);
         };
 
         let mut buf = Vec::with_capacity(2048);
-        object.write_to(&mut buf)?;
+        object.write_to(&mut buf).or_erased()?;
         let kind = object.kind();
-        let id = gix_object::compute_hash(self.object_hash, kind, &buf)?;
+        let id = gix_object::compute_hash(self.object_hash, kind, &buf).or_erased()?;
         map.borrow_mut().entry(id).or_insert((kind, buf));
         Ok(id)
     }
@@ -228,15 +225,15 @@ where
         kind: gix_object::Kind,
         size: u64,
         from: &mut dyn std::io::Read,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let Some(map) = self.memory.as_ref() else {
             return self.inner.write_stream(kind, size, from);
         };
 
         let mut buf = Vec::new();
-        from.read_to_end(&mut buf)?;
+        from.read_to_end(&mut buf).or_erased()?;
 
-        let id = gix_object::compute_hash(self.object_hash, kind, &buf)?;
+        let id = gix_object::compute_hash(self.object_hash, kind, &buf).or_erased()?;
         map.borrow_mut().entry(id).or_insert((kind, buf));
         Ok(id)
     }
@@ -246,7 +243,7 @@ where
         kind: gix_object::Kind,
         from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let Some(map) = self.memory.as_ref() else {
             return self.inner.write_buf_with_known_id(kind, from, id);
         };
@@ -261,13 +258,13 @@ where
         size: u64,
         from: &mut dyn std::io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let Some(map) = self.memory.as_ref() else {
             return self.inner.write_stream_with_known_id(kind, size, from, id);
         };
 
         let mut buf = Vec::new();
-        from.read_to_end(&mut buf)?;
+        from.read_to_end(&mut buf).or_erased()?;
 
         map.borrow_mut().entry(id).or_insert((kind, buf));
         Ok(id)
diff --git a/gix-odb/src/sink.rs b/gix-odb/src/sink.rs
index 9fb395274d6..214a2b16582 100644
--- a/gix-odb/src/sink.rs
+++ b/gix-odb/src/sink.rs
@@ -3,6 +3,7 @@ use std::{
     io::{self, Write},
 };
 
+use gix_error::{ExnResult, ResultExt};
 use gix_zlib::stream::deflate;
 
 use crate::Sink;
@@ -21,7 +22,7 @@ impl gix_object::Write for Sink {
         kind: gix_object::Kind,
         mut from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         self.write_stream_with_known_id(kind, from.len() as u64, &mut from, id)
     }
 
@@ -30,7 +31,7 @@ impl gix_object::Write for Sink {
         kind: gix_object::Kind,
         mut size: u64,
         from: &mut dyn io::Read,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = [0u8; u16::MAX as usize];
         let header = gix_object::encode::loose_header(kind, size);
 
@@ -43,22 +44,22 @@ impl gix_object::Write for Sink {
 
         let mut hasher = gix_hash::hasher(self.object_hash);
         hasher.update(&header);
-        possibly_compress(&header).map_err(Box::new)?;
+        possibly_compress(&header).or_erased()?;
 
         while size != 0 {
             let bytes = (size as usize).min(buf.len());
-            from.read_exact(&mut buf[..bytes]).map_err(Box::new)?;
+            from.read_exact(&mut buf[..bytes]).or_erased()?;
             hasher.update(&buf[..bytes]);
-            possibly_compress(&buf[..bytes]).map_err(Box::new)?;
+            possibly_compress(&buf[..bytes]).or_erased()?;
             size -= bytes as u64;
         }
         if let Some(compressor) = self.compressor.as_ref() {
             let mut c = compressor.borrow_mut();
-            c.flush().map_err(Box::new)?;
+            c.flush().or_erased()?;
             c.reset();
         }
 
-        Ok(hasher.try_finalize()?)
+        hasher.try_finalize().or_erased()
     }
 
     fn write_stream_with_known_id(
@@ -67,7 +68,7 @@ impl gix_object::Write for Sink {
         mut size: u64,
         from: &mut dyn io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = [0u8; u16::MAX as usize];
         let header = gix_object::encode::loose_header(kind, size);
 
@@ -78,17 +79,17 @@ impl gix_object::Write for Sink {
             Ok(())
         };
 
-        possibly_compress(&header).map_err(Box::new)?;
+        possibly_compress(&header).or_erased()?;
 
         while size != 0 {
             let bytes = (size as usize).min(buf.len());
-            from.read_exact(&mut buf[..bytes]).map_err(Box::new)?;
-            possibly_compress(&buf[..bytes]).map_err(Box::new)?;
+            from.read_exact(&mut buf[..bytes]).or_erased()?;
+            possibly_compress(&buf[..bytes]).or_erased()?;
             size -= bytes as u64;
         }
         if let Some(compressor) = self.compressor.as_ref() {
             let mut c = compressor.borrow_mut();
-            c.flush().map_err(Box::new)?;
+            c.flush().or_erased()?;
             c.reset();
         }
 
diff --git a/gix-odb/src/store_impls/dynamic/find.rs b/gix-odb/src/store_impls/dynamic/find.rs
index ac5de05dea6..9e41dbd1e17 100644
--- a/gix-odb/src/store_impls/dynamic/find.rs
+++ b/gix-odb/src/store_impls/dynamic/find.rs
@@ -1,89 +1,53 @@
 use std::ops::Deref;
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, not_found};
 use gix_pack::cache::DecodeEntry;
 
 use crate::store::{handle, load_index};
 
-pub(crate) mod error {
-    use crate::{loose, pack};
-
-    /// Returned by [`Handle::try_find()`][gix_pack::Find::try_find()]
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An error occurred while obtaining an object from the loose object store")]
-        Loose(#[from] loose::find::Error),
-        #[error("An error occurred while obtaining an object from the packed object store")]
-        Pack(#[from] pack::data::decode::Error),
-        #[error(transparent)]
-        LoadIndex(#[from] crate::store::load_index::Error),
-        #[error(transparent)]
-        LoadPack(#[from] std::io::Error),
-        #[error(transparent)]
-        EntryType(#[from] gix_pack::data::entry::decode::Error),
-        #[error("Reached recursion limit of {} while resolving ref delta bases for {}", .max_depth, .id)]
-        DeltaBaseRecursionLimit {
-            /// the maximum recursion depth we encountered.
-            max_depth: usize,
-            /// The original object to lookup
-            id: gix_hash::ObjectId,
-        },
-        #[error("The base object {} could not be found but is required to decode {}", .base_id, .id)]
-        DeltaBaseMissing {
-            /// the id of the base object which failed to lookup
-            base_id: gix_hash::ObjectId,
-            /// The original object to lookup
-            id: gix_hash::ObjectId,
-        },
-        #[error("An error occurred when looking up a ref delta base object {} to decode {}", .base_id, .id)]
-        DeltaBaseLookup {
-            #[source]
-            err: Box<Self>,
-            /// the id of the base object which failed to lookup
-            base_id: gix_hash::ObjectId,
-            /// The original object to lookup
-            id: gix_hash::ObjectId,
-        },
-    }
-
-    #[derive(Copy, Clone)]
-    pub(crate) struct DeltaBaseRecursion<'a> {
-        pub depth: usize,
-        pub original_id: &'a gix_hash::oid,
-    }
+#[derive(Copy, Clone)]
+pub(crate) struct DeltaBaseRecursion<'a> {
+    pub depth: usize,
+    pub original_id: &'a gix_hash::oid,
+}
 
-    impl<'a> DeltaBaseRecursion<'a> {
-        pub fn new(id: &'a gix_hash::oid) -> Self {
-            Self {
-                original_id: id,
-                depth: 0,
-            }
-        }
-        pub fn inc_depth(mut self) -> Self {
-            self.depth += 1;
-            self
+impl<'a> DeltaBaseRecursion<'a> {
+    pub fn new(id: &'a gix_hash::oid) -> Self {
+        Self {
+            original_id: id,
+            depth: 0,
         }
     }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-
-        #[test]
-        fn error_size() {
-            let actual = std::mem::size_of::<Error>();
-            assert!(actual <= 88, "{actual} <= 88: should not grow without us noticing");
-        }
+    pub fn inc_depth(mut self) -> Self {
+        self.depth += 1;
+        self
     }
 }
-pub use error::Error;
 
 use crate::store::types::PackId;
 
+/// The raised error's [metadata](gix_error::Exn::metadata()) `max_depth` (unsigned) and `object_id` (hex text) identify
+/// the recursion limit and original object.
+pub(super) fn delta_base_recursion_limit_error(max_depth: usize, object_id: &gix_hash::oid) -> Message {
+    Message::new("Reached recursion limit while resolving ref delta bases")
+        .with("max_depth", max_depth)
+        .with("object_id", object_id.to_string())
+}
+
+/// The raised error's [metadata](gix_error::Exn::metadata()) `base_id` and `object_id` (hex text) identify the delta
+/// base and object being resolved.
+pub(super) fn delta_base_lookup_error(base_id: &gix_hash::oid, object_id: &gix_hash::oid) -> Message {
+    Message::new("Could not resolve delta base object")
+        .with("base_id", base_id.to_string())
+        .with("object_id", object_id.to_string())
+}
+
 impl<S> super::Handle<S>
 where
     S: Deref<Target = super::Store> + Clone,
 {
+    /// Delta resolution failures include [metadata](gix_error::Exn::metadata()) `object_id` and `base_id` (hex text).
+    /// Recursion limits include `object_id` (hex text) and `max_depth` (unsigned).
     fn try_find_cached_inner<'a, 'b>(
         &'b self,
         mut id: &'b gix_hash::oid,
@@ -91,14 +55,11 @@ where
         inflate: &mut gix_zlib::Inflate,
         pack_cache: &mut dyn DecodeEntry,
         snapshot: &mut load_index::Snapshot,
-        recursion: Option<error::DeltaBaseRecursion<'_>>,
-    ) -> Result<Option<(gix_object::Data<'a>, Option<gix_pack::data::entry::Location>)>, Error> {
+        recursion: Option<DeltaBaseRecursion<'_>>,
+    ) -> ExnResult<Option<(gix_object::Data<'a>, Option<gix_pack::data::entry::Location>)>> {
         if let Some(r) = recursion {
             if r.depth >= self.max_recursion_depth {
-                return Err(Error::DeltaBaseRecursionLimit {
-                    max_depth: self.max_recursion_depth,
-                    id: r.original_id.to_owned(),
-                });
+                return Err(delta_base_recursion_limit_error(self.max_recursion_depth, r.original_id).raise_erased());
             }
         } else if !self.ignore_replacements
             && let Ok(pos) = self
@@ -121,7 +82,7 @@ where
                     {
                         let pack = match possibly_pack {
                             Some(pack) => pack,
-                            None => match self.store.load_pack(pack_id, marker)? {
+                            None => match self.store.load_pack(pack_id, marker).or_erased()? {
                                 Some(pack) => {
                                     *possibly_pack = Some(pack);
                                     possibly_pack.as_deref().expect("just put it in")
@@ -144,7 +105,7 @@ where
                                 }
                             },
                         };
-                        let entry = pack.entry(pack_offset)?;
+                        let entry = pack.entry(pack_offset).or_erased()?;
                         let header_size = entry.header_size();
                         let res = pack.decode_entry(
                             entry,
@@ -171,7 +132,13 @@ where
                                     entry_size: r.compressed_size + header_size,
                                 }),
                             )),
-                            Err(gix_pack::data::decode::Error::DeltaBaseUnresolved(base_id)) => {
+                            Err(err) => {
+                                let Some(base_id) = err
+                                    .downcast_any_ref::<gix_pack::data::decode::DeltaBaseUnresolved>()
+                                    .map(|err| err.0)
+                                else {
+                                    return Err(err);
+                                };
                                 // Only with multi-pack indices it's allowed to jump to refer to other packs within this
                                 // multi-pack. Otherwise this would constitute a thin pack which is only allowed in transit.
                                 // However, if we somehow end up with that, we will resolve it safely, even though we could
@@ -184,6 +151,7 @@ where
                                 // The whole ordeal isn't as efficient as it could be due to memory allocation and
                                 // later mem-copying when trying again.
                                 let mut buf = Vec::new();
+                                let context = || delta_base_lookup_error(&base_id, id);
                                 let obj_kind = self
                                     .try_find_cached_inner(
                                         &base_id,
@@ -192,17 +160,15 @@ where
                                         pack_cache,
                                         snapshot,
                                         recursion
-                                            .map(error::DeltaBaseRecursion::inc_depth)
-                                            .or_else(|| error::DeltaBaseRecursion::new(id).into()),
+                                            .map(DeltaBaseRecursion::inc_depth)
+                                            .or_else(|| DeltaBaseRecursion::new(id).into()),
                                     )
-                                    .map_err(|err| Error::DeltaBaseLookup {
-                                        err: Box::new(err),
-                                        base_id,
-                                        id: id.to_owned(),
-                                    })?
-                                    .ok_or_else(|| Error::DeltaBaseMissing {
-                                        base_id,
-                                        id: id.to_owned(),
+                                    .or_raise_erased(context)?
+                                    .ok_or_else(|| {
+                                        not_found("Could not resolve delta base object: delta base object is missing")
+                                            .with("base_id", base_id.to_string())
+                                            .with("object_id", id.to_string())
+                                            .raise_erased()
                                     })?
                                     .0
                                     .kind;
@@ -233,7 +199,7 @@ where
                                 let pack = possibly_pack
                                     .as_ref()
                                     .expect("pack to still be available like just now");
-                                let entry = pack.entry(pack_offset)?;
+                                let entry = pack.entry(pack_offset).or_erased()?;
                                 let header_size = entry.header_size();
                                 pack.decode_entry(
                                     entry,
@@ -275,7 +241,6 @@ where
                                     )
                                 })
                             }
-                            Err(err) => Err(err),
                         }?;
 
                         if idx != 0 {
@@ -289,10 +254,7 @@ where
             for lodb in snapshot.loose_dbs.iter() {
                 // TODO: remove this double-lookup once the borrow checker allows it.
                 if lodb.contains(id) {
-                    return lodb
-                        .try_find(id, buffer)
-                        .map(|obj| obj.map(|obj| (obj, None)))
-                        .map_err(Into::into);
+                    return lodb.try_find(id, buffer).map(|obj| obj.map(|obj| (obj, None)));
                 }
             }
 
@@ -315,7 +277,7 @@ impl<S> gix_pack::Find for super::Handle<S>
 where
     S: Deref<Target = super::Store> + Clone,
 {
-    // TODO: probably make this method fallible, but that would mean its own error type.
+    // TODO: make this method fallible to propagate index loading failures.
     fn contains(&self, id: &gix_hash::oid) -> bool {
         let mut snapshot = self.snapshot.borrow_mut();
         loop {
@@ -350,11 +312,10 @@ where
         id: &gix_hash::oid,
         buffer: &'a mut Vec<u8>,
         pack_cache: &mut dyn DecodeEntry,
-    ) -> Result<Option<(gix_object::Data<'a>, Option<gix_pack::data::entry::Location>)>, gix_object::find::Error> {
+    ) -> ExnResult<Option<(gix_object::Data<'a>, Option<gix_pack::data::entry::Location>)>> {
         let mut snapshot = self.snapshot.borrow_mut();
         let mut inflate = self.inflate.borrow_mut();
         self.try_find_cached_inner(id, buffer, &mut inflate, pack_cache, &mut snapshot, None)
-            .map_err(|err| Box::new(err) as _)
     }
 
     fn location_by_oid(&self, id: &gix_hash::oid, buf: &mut Vec<u8>) -> Option<gix_pack::data::entry::Location> {
@@ -511,11 +472,7 @@ where
     S: Deref<Target = super::Store> + Clone,
     Self: gix_pack::Find,
 {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         gix_pack::Find::try_find(self, id, buffer).map(|t| t.map(|t| t.0))
     }
 }
@@ -524,7 +481,7 @@ impl<S> gix_object::FindHeader for super::Handle<S>
 where
     S: Deref<Target = super::Store> + Clone,
 {
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<gix_object::Header>, gix_object::find::Error> {
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<gix_object::Header>> {
         let mut snapshot = self.snapshot.borrow_mut();
         let mut inflate = self.inflate.borrow_mut();
         self.try_header_inner(id, &mut inflate, &mut snapshot, None)
@@ -534,7 +491,7 @@ where
                     size: hdr.size(),
                 })
             })
-            .map_err(|err| Box::new(err) as _)
+            .or_erased()
     }
 }
 
diff --git a/gix-odb/src/store_impls/dynamic/header.rs b/gix-odb/src/store_impls/dynamic/header.rs
index 8e568bd624f..2965aa1f62d 100644
--- a/gix-odb/src/store_impls/dynamic/header.rs
+++ b/gix-odb/src/store_impls/dynamic/header.rs
@@ -1,30 +1,32 @@
 use std::ops::Deref;
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, not_found};
 use gix_hash::oid;
 
-use super::find::Error;
 use crate::{
     find::Header,
-    store::{find::error::DeltaBaseRecursion, handle, load_index},
+    store::{
+        find::{DeltaBaseRecursion, delta_base_lookup_error, delta_base_recursion_limit_error},
+        handle, load_index,
+    },
 };
 
 impl<S> super::Handle<S>
 where
     S: Deref<Target = super::Store> + Clone,
 {
+    /// Delta resolution failures include [metadata](gix_error::Exn::metadata()) `object_id` and `base_id` (hex text).
+    /// Recursion limits include `object_id` (hex text) and `max_depth` (unsigned).
     pub(crate) fn try_header_inner<'b>(
         &'b self,
         mut id: &'b gix_hash::oid,
         inflate: &mut gix_zlib::Inflate,
         snapshot: &mut load_index::Snapshot,
         recursion: Option<DeltaBaseRecursion<'_>>,
-    ) -> Result<Option<Header>, Error> {
+    ) -> ExnResult<Option<Header>> {
         if let Some(r) = recursion {
             if r.depth >= self.max_recursion_depth {
-                return Err(Error::DeltaBaseRecursionLimit {
-                    max_depth: self.max_recursion_depth,
-                    id: r.original_id.to_owned(),
-                });
+                return Err(delta_base_recursion_limit_error(self.max_recursion_depth, r.original_id).raise_erased());
             }
         } else if !self.ignore_replacements
             && let Ok(pos) = self
@@ -47,7 +49,7 @@ where
                     {
                         let pack = match possibly_pack {
                             Some(pack) => pack,
-                            None => match self.store.load_pack(pack_id, marker)? {
+                            None => match self.store.load_pack(pack_id, marker).or_erased()? {
                                 Some(pack) => {
                                     *possibly_pack = Some(pack);
                                     possibly_pack.as_deref().expect("just put it in")
@@ -70,7 +72,7 @@ where
                                 }
                             },
                         };
-                        let entry = pack.entry(pack_offset)?;
+                        let entry = pack.entry(pack_offset).or_erased()?;
                         let res = match pack.decode_header(entry, inflate, &|id| {
                             index_file.pack_offset_by_id(id).and_then(|pack_offset| {
                                 pack.entry(pack_offset)
@@ -79,11 +81,18 @@ where
                             })
                         }) {
                             Ok(header) => Ok(header.into()),
-                            Err(gix_pack::data::decode::Error::DeltaBaseUnresolved(base_id)) => {
+                            Err(err) => {
+                                let Some(base_id) = err
+                                    .downcast_any_ref::<gix_pack::data::decode::DeltaBaseUnresolved>()
+                                    .map(|err| err.0)
+                                else {
+                                    return Err(err);
+                                };
                                 // Only with multi-pack indices it's allowed to jump to refer to other packs within this
                                 // multi-pack. Otherwise this would constitute a thin pack which is only allowed in transit.
                                 // However, if we somehow end up with that, we will resolve it safely, even though we could
                                 // avoid handling this case and error instead.
+                                let context = || delta_base_lookup_error(&base_id, id);
                                 let hdr = self
                                     .try_header_inner(
                                         &base_id,
@@ -93,14 +102,12 @@ where
                                             .map(DeltaBaseRecursion::inc_depth)
                                             .or_else(|| DeltaBaseRecursion::new(id).into()),
                                     )
-                                    .map_err(|err| Error::DeltaBaseLookup {
-                                        err: Box::new(err),
-                                        base_id,
-                                        id: id.to_owned(),
-                                    })?
-                                    .ok_or_else(|| Error::DeltaBaseMissing {
-                                        base_id,
-                                        id: id.to_owned(),
+                                    .or_raise_erased(context)?
+                                    .ok_or_else(|| {
+                                        not_found("Could not resolve delta base object: delta base object is missing")
+                                            .with("base_id", base_id.to_string())
+                                            .with("object_id", id.to_string())
+                                            .raise_erased()
                                     })?;
                                 let handle::index_lookup::Outcome {
                                     object_index:
@@ -129,7 +136,7 @@ where
                                 let pack = possibly_pack
                                     .as_ref()
                                     .expect("pack to still be available like just now");
-                                let entry = pack.entry(pack_offset)?;
+                                let entry = pack.entry(pack_offset).or_erased()?;
                                 pack.decode_header(entry, inflate, &|id| {
                                     index_file
                                         .pack_offset_by_id(id)
@@ -149,7 +156,6 @@ where
                                 })
                                 .map(Into::into)
                             }
-                            Err(err) => Err(err),
                         }?;
 
                         if idx != 0 {
@@ -163,7 +169,7 @@ where
             for lodb in snapshot.loose_dbs.iter() {
                 // TODO: remove this double-lookup once the borrow checker allows it.
                 if lodb.contains(id) {
-                    return lodb.try_header(id).map(|opt| opt.map(Into::into)).map_err(Into::into);
+                    return lodb.try_header(id).map(|opt| opt.map(Into::into));
                 }
             }
 
@@ -182,10 +188,9 @@ impl<S> crate::Header for super::Handle<S>
 where
     S: Deref<Target = super::Store> + Clone,
 {
-    fn try_header(&self, id: &oid) -> Result<Option<Header>, gix_object::find::Error> {
+    fn try_header(&self, id: &oid) -> ExnResult<Option<Header>> {
         let mut snapshot = self.snapshot.borrow_mut();
         let mut inflate = self.inflate.borrow_mut();
         self.try_header_inner(id, &mut inflate, &mut snapshot, None)
-            .map_err(|err| Box::new(err) as _)
     }
 }
diff --git a/gix-odb/src/store_impls/dynamic/init.rs b/gix-odb/src/store_impls/dynamic/init.rs
index 87fa34d2630..146e1534869 100644
--- a/gix-odb/src/store_impls/dynamic/init.rs
+++ b/gix-odb/src/store_impls/dynamic/init.rs
@@ -108,11 +108,11 @@ impl Store {
             Slots::Given(n) => n as usize,
             Slots::AsNeededByDiskState { multiplier, minimum } => {
                 let mut db_paths =
-                    crate::alternate::resolve(objects_dir.clone(), &current_dir).map_err(std::io::Error::other)?;
+                    crate::alternate::resolve(objects_dir.clone(), &current_dir).map_err(super::exn_to_io)?;
                 db_paths.insert(0, objects_dir.clone());
                 let num_slots =
                     Store::collect_indices_and_mtime_sorted_by_size(db_paths, None, None, alloc_limit_bytes)
-                        .map_err(std::io::Error::other)?
+                        .map_err(super::exn_to_io)?
                         .len();
 
                 let candidate = ((num_slots as f32 * multiplier) as usize).max(minimum);
diff --git a/gix-odb/src/store_impls/dynamic/iter.rs b/gix-odb/src/store_impls/dynamic/iter.rs
index 7b2428f4eee..21adf01b40f 100644
--- a/gix-odb/src/store_impls/dynamic/iter.rs
+++ b/gix-odb/src/store_impls/dynamic/iter.rs
@@ -1,5 +1,7 @@
 use std::{ops::Deref, option::Option::None, sync::Arc, vec::IntoIter};
 
+use gix_error::ExnResult;
+
 use gix_hash::ObjectId;
 
 use crate::{
@@ -75,7 +77,7 @@ impl AllObjects {
 
 impl AllObjects {
     /// Create a new iterator from a dynamic store, which will be forced to load all indices eagerly and in the current thread.
-    pub fn new(db: &dynamic::Store) -> Result<Self, crate::store::load_index::Error> {
+    pub fn new(db: &dynamic::Store) -> ExnResult<Self> {
         let snapshot = db.load_all_indices()?;
 
         let packed_objects = snapshot
@@ -222,14 +224,14 @@ where
 {
     /// Return an iterator over all, _possibly duplicate_, objects, first the ones in all packs of all linked databases (via alternates),
     /// followed by all loose objects.
-    pub fn iter(&self) -> Result<AllObjects, dynamic::load_index::Error> {
+    pub fn iter(&self) -> ExnResult<AllObjects> {
         AllObjects::new(self.store_ref())
     }
 }
 
 impl dynamic::Store {
     /// Like [`Handle::iter()`][super::Handle::iter()], but accessible directly on the store.
-    pub fn iter(&self) -> Result<AllObjects, dynamic::load_index::Error> {
+    pub fn iter(&self) -> ExnResult<AllObjects> {
         AllObjects::new(self)
     }
 }
diff --git a/gix-odb/src/store_impls/dynamic/load_index.rs b/gix-odb/src/store_impls/dynamic/load_index.rs
index bf26c1e85fb..48356ba6d71 100644
--- a/gix-odb/src/store_impls/dynamic/load_index.rs
+++ b/gix-odb/src/store_impls/dynamic/load_index.rs
@@ -10,6 +10,8 @@ use std::{
     time::SystemTime,
 };
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt};
+
 use crate::store::{IndexCtx, RefreshMode, handle, types};
 
 pub(crate) struct Snapshot {
@@ -21,49 +23,11 @@ pub(crate) struct Snapshot {
     pub(crate) marker: types::SlotIndexMarker,
 }
 
-mod error {
-    use std::path::PathBuf;
-
-    use gix_pack::multi_index::PackIndex;
-
-    /// Returned by [`crate::at_opts()`]
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The objects directory at '{0}' is not an accessible directory")]
-        Inaccessible(PathBuf),
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        Alternate(#[from] crate::alternate::Error),
-        #[error("The slotmap turned out to be too small with {} entries, would need {} more", .current, .needed)]
-        InsufficientSlots { current: usize, needed: usize },
-        /// The problem here is that some logic assumes that more recent generations are higher than previous ones. If we would overflow,
-        /// we would break that invariant which can lead to the wrong object from being returned. It would probably be super rare, but…
-        /// let's not risk it.
-        #[error(
-            "Would have overflown amount of max possible generations of {}",
-            super::Generation::MAX
-        )]
-        GenerationOverflow,
-        #[error(
-            "Cannot numerically handle more than {limit} packs in a single multi-pack index, got {actual} in file {index_path:?}"
-        )]
-        TooManyPacksInMultiIndex {
-            actual: PackIndex,
-            limit: PackIndex,
-            index_path: PathBuf,
-        },
-    }
-}
-
-pub use error::Error;
-
 use crate::store::types::{Generation, IndexAndPacks, MutableIndexAndPack, PackId, SlotMapIndex};
 
 impl super::Store {
     /// Load all indices, refreshing from disk only if needed.
-    pub(crate) fn load_all_indices(&self) -> Result<Snapshot, Error> {
+    pub(crate) fn load_all_indices(&self) -> ExnResult<Snapshot> {
         let mut snapshot = self.collect_snapshot();
         while let Some(new_snapshot) = self.load_one_index(IndexCtx {
             refresh_mode: RefreshMode::Never,
@@ -84,7 +48,7 @@ impl super::Store {
             marker,
             loose_compression,
         }: IndexCtx,
-    ) -> Result<Option<Snapshot>, Error> {
+    ) -> ExnResult<Option<Snapshot>> {
         let index = self.index.load();
         if !index.is_initialized() {
             return self.consolidate_with_disk_state(
@@ -198,12 +162,15 @@ impl super::Store {
 
     /// refresh and possibly clear out our existing data structures, causing all pack ids to be invalidated.
     /// `load_new_index` is an optimization to at least provide one newly loaded pack after refreshing the slot map.
+    /// Capacity failures include [metadata](gix_error::Exn::metadata()) `current` (unsigned slot count), `needed`
+    /// (unsigned additional slots),
+    /// or `limit` (unsigned maximum generation).
     pub(crate) fn consolidate_with_disk_state(
         &self,
         needs_init: bool,
         load_new_index: bool,
         loose_compression: gix_zlib::Compression,
-    ) -> Result<Option<Snapshot>, Error> {
+    ) -> ExnResult<Option<Snapshot>> {
         let index = self.index.load();
         let previous_index_state = Arc::as_ptr(&index) as usize;
 
@@ -327,10 +294,10 @@ impl super::Store {
         while let Some((mut index_info, mtime, move_from_slot_idx)) = index_paths_to_add.pop_front() {
             'increment_slot_index: loop {
                 if num_indices_checked == self.files.len() {
-                    return Err(Error::InsufficientSlots {
-                        current: self.files.len(),
-                        needed: index_paths_to_add.len() + 1, /*the one currently popped off*/
-                    });
+                    return Err(Message::new("The object database has too few index slots")
+                        .with("current", self.files.len())
+                        .with("needed", index_paths_to_add.len() + 1) // include the index just popped off
+                        .raise_erased());
                 }
                 // Don't allow duplicate indicates, we need a 1:1 mapping.
                 if new_slot_map_indices.contains(&next_possibly_free_index) {
@@ -399,7 +366,12 @@ impl super::Store {
         );
 
         let generation = if needs_generation_change {
-            index.generation.checked_add(1).ok_or(Error::GenerationOverflow)?
+            index.generation.checked_add(1).ok_or_else(|| {
+                // A wrapped generation could return an object from the wrong pack.
+                Message::new("Cannot advance the object database generation")
+                    .with("limit", Generation::MAX)
+                    .raise_erased()
+            })?
         } else {
             index.generation
         };
@@ -466,19 +438,26 @@ impl super::Store {
         })
     }
 
+    /// Read failures include [metadata](gix_error::Exn::metadata()) `path` (native directory or index path). Multi-pack
+    /// capacity failures
+    /// also include `actual` and `limit` (unsigned pack counts).
     pub(crate) fn collect_indices_and_mtime_sorted_by_size(
         db_paths: Vec<PathBuf>,
         initial_capacity: Option<usize>,
         multi_pack_index_object_hash: Option<gix_hash::Kind>,
         alloc_limit_bytes: Option<usize>,
-    ) -> Result<Vec<(Either, SystemTime, u64)>, Error> {
+    ) -> ExnResult<Vec<(Either, SystemTime, u64)>> {
         let mut indices_by_modification_time = Vec::with_capacity(initial_capacity.unwrap_or_default());
         for db_path in db_paths {
             let packs = db_path.join("pack");
-            let entries = match std::fs::read_dir(packs) {
+            let entries = match std::fs::read_dir(&packs) {
                 Ok(e) => e,
                 Err(err) if err.kind() == std::io::ErrorKind::NotFound => continue,
-                Err(err) => return Err(err.into()),
+                Err(err) => {
+                    return Err(err
+                        .and_raise(Message::new("Could not read pack directory").with("path", packs))
+                        .erased());
+                }
             };
             let indices = entries
                 .filter_map(Result::ok)
@@ -489,8 +468,13 @@ impl super::Store {
                     (ext == Some(OsStr::new("idx")) && p.with_extension("pack").is_file())
                         || (multi_pack_index_object_hash.is_some() && ext.is_none() && is_multipack_index(p))
                 })
-                .map(|(p, md)| md.modified().map_err(Error::from).map(|mtime| (p, mtime, md.len())))
-                .collect::<Result<Vec<_>, _>>()?;
+                .map(|(p, md)| {
+                    let mtime = md.modified().or_raise_erased(|| {
+                        Message::new("Could not read index modification time").with("path", p.as_path())
+                    })?;
+                    Ok((p, mtime, md.len()))
+                })
+                .collect::<ExnResult<Vec<_>>>()?;
 
             let multi_index_info = multi_pack_index_object_hash
                 .and_then(|hash| {
@@ -506,11 +490,11 @@ impl super::Store {
                             .flatten()
                             .map(|t| {
                                 if t.0.num_indices() > PackId::max_packs_in_multi_index() {
-                                    Err(Error::TooManyPacksInMultiIndex {
-                                        index_path: p.to_owned(),
-                                        actual: t.0.num_indices(),
-                                        limit: PackId::max_packs_in_multi_index(),
-                                    })
+                                    Err(Message::new("Too many packs in a single multi-pack index")
+                                        .with("path", p.as_path())
+                                        .with("actual", t.0.num_indices())
+                                        .with("limit", PackId::max_packs_in_multi_index())
+                                        .raise_erased())
                                 } else {
                                     Ok(t)
                                 }
diff --git a/gix-odb/src/store_impls/dynamic/load_one.rs b/gix-odb/src/store_impls/dynamic/load_one.rs
index 9ef6969697c..5ca625be86e 100644
--- a/gix-odb/src/store_impls/dynamic/load_one.rs
+++ b/gix-odb/src/store_impls/dynamic/load_one.rs
@@ -32,10 +32,7 @@ impl super::Store {
                     pack.id = id.to_intrinsic_pack_id();
                     Arc::new(pack)
                 })
-                .map_err(|err| match err {
-                    gix_pack::data::header::decode::Error::Io { source, .. } => source,
-                    other => std::io::Error::other(other),
-                })
+                .map_err(super::exn_to_io)
         }
 
         let slot = &self.files[id.index];
diff --git a/gix-odb/src/store_impls/dynamic/mod.rs b/gix-odb/src/store_impls/dynamic/mod.rs
index 25ff75d88b5..11e9eab41b4 100644
--- a/gix-odb/src/store_impls/dynamic/mod.rs
+++ b/gix-odb/src/store_impls/dynamic/mod.rs
@@ -3,6 +3,13 @@ use std::{cell::RefCell, ops::Deref};
 
 use crate::Store;
 
+fn exn_to_io(err: gix_error::Exn) -> std::io::Error {
+    let kind = err
+        .downcast_any_ref::<std::io::Error>()
+        .map_or(std::io::ErrorKind::Other, std::io::Error::kind);
+    std::io::Error::new(kind, err.into_error())
+}
+
 /// This effectively acts like a handle but exists to be usable from the actual `crate::Handle` implementation which adds caches on top.
 /// Each store is quickly cloned and contains thread-local state for shared packs.
 pub struct Handle<S>
@@ -64,8 +71,7 @@ impl RefreshMode {
     }
 }
 
-///
-pub mod find;
+mod find;
 
 ///
 pub mod prefix;
@@ -75,8 +81,7 @@ mod header;
 ///
 pub mod iter;
 
-///
-pub mod write;
+mod write;
 
 ///
 pub mod init;
@@ -86,8 +91,7 @@ pub use types::Metrics;
 
 pub(crate) mod handle;
 
-///
-pub mod load_index;
+mod load_index;
 
 ///
 pub mod verify;
diff --git a/gix-odb/src/store_impls/dynamic/prefix.rs b/gix-odb/src/store_impls/dynamic/prefix.rs
index 4c2172530fa..0763be8dae7 100644
--- a/gix-odb/src/store_impls/dynamic/prefix.rs
+++ b/gix-odb/src/store_impls/dynamic/prefix.rs
@@ -1,30 +1,21 @@
 use std::{collections::HashSet, ops::Deref};
 
+use gix_error::{ExnResult, ResultExt, message};
 use gix_object::Exists;
 
-use crate::store::{Handle, load_index};
+use crate::store::Handle;
 
 ///
 pub mod lookup {
-    use crate::loose;
-
-    /// Returned by [`Handle::lookup_prefix()`][crate::store::Handle::lookup_prefix()]
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An error occurred looking up a prefix which requires iteration")]
-        LooseWalkDir(#[from] loose::iter::Error),
-        #[error(transparent)]
-        LoadIndex(#[from] crate::store::load_index::Error),
-    }
-
     /// A way to indicate if a lookup, despite successful, was ambiguous or yielded exactly
     /// one result in the particular index.
-    pub type Outcome = Result<gix_hash::ObjectId, ()>;
+    pub type Outcome = std::result::Result<gix_hash::ObjectId, ()>;
 }
 
 ///
 pub mod disambiguate {
+    use gix_error::ExnMessageResult;
+
     /// A potentially ambiguous prefix for use with `Handle::disambiguate_prefix()`.
     #[derive(Debug, Copy, Clone)]
     pub struct Candidate {
@@ -37,7 +28,7 @@ pub mod disambiguate {
         ///
         /// It is considered ambiguous until it's disambiguated by validating that there is only a single object
         /// matching this prefix.
-        pub fn new(id: impl Into<gix_hash::ObjectId>, hex_len: usize) -> Result<Self, gix_hash::prefix::Error> {
+        pub fn new(id: impl Into<gix_hash::ObjectId>, hex_len: usize) -> ExnMessageResult<Self> {
             let id = id.into();
             gix_hash::Prefix::new(&id, hex_len)?;
             Ok(Candidate { id, hex_len })
@@ -61,16 +52,6 @@ pub mod disambiguate {
             self.hex_len
         }
     }
-
-    /// Returned by [`Handle::disambiguate_prefix()`][crate::store::Handle::disambiguate_prefix()]
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An error occurred while trying to determine if a full hash contained in the object database")]
-        Contains(#[from] crate::store::find::Error),
-        #[error(transparent)]
-        Lookup(#[from] super::lookup::Error),
-    }
 }
 
 impl<S> Handle<S>
@@ -79,7 +60,7 @@ where
 {
     /// Return the exact number of packed objects after loading all currently available indices
     /// as last seen on disk.
-    pub fn packed_object_count(&self) -> Result<u64, load_index::Error> {
+    pub fn packed_object_count(&self) -> ExnResult<u64> {
         let mut count = self.packed_object_count.borrow_mut();
         match *count {
             Some(count) => Ok(count),
@@ -100,10 +81,7 @@ where
     /// Given a prefix `candidate` with an object id and an initial `hex_len`, check if it only matches a single
     /// object within the entire object database and increment its `hex_len` by one until it is unambiguous.
     /// Return `Ok(None)` if no object with that prefix exists.
-    pub fn disambiguate_prefix(
-        &self,
-        mut candidate: disambiguate::Candidate,
-    ) -> Result<Option<gix_hash::Prefix>, disambiguate::Error> {
+    pub fn disambiguate_prefix(&self, mut candidate: disambiguate::Candidate) -> ExnResult<Option<gix_hash::Prefix>> {
         let max_hex_len = candidate.id().kind().len_in_hex();
         if candidate.hex_len() == max_hex_len {
             return Ok(self.exists(candidate.id()).then(|| candidate.to_prefix()));
@@ -143,7 +121,7 @@ where
         &self,
         prefix: gix_hash::Prefix,
         mut candidates: Option<&mut HashSet<gix_hash::ObjectId>>,
-    ) -> Result<Option<lookup::Outcome>, lookup::Error> {
+    ) -> ExnResult<Option<lookup::Outcome>> {
         let mut candidate: Option<gix_hash::ObjectId> = None;
         loop {
             let snapshot = self.snapshot.borrow();
@@ -157,7 +135,9 @@ where
 
             for lodb in snapshot.loose_dbs.iter() {
                 // needed as it's the equivalent of a reborrow.
-                let lookup_result = lodb.lookup_prefix(prefix, candidates.as_deref_mut())?;
+                let lookup_result = lodb
+                    .lookup_prefix(prefix, candidates.as_deref_mut())
+                    .or_raise_erased(|| message("Could not enumerate loose objects for prefix lookup"))?;
                 if candidates.is_none() && !check_candidate(lookup_result, &mut candidate) {
                     return Ok(Some(Err(())));
                 }
diff --git a/gix-odb/src/store_impls/dynamic/structure.rs b/gix-odb/src/store_impls/dynamic/structure.rs
index ec8e18b1f42..a20f3cf3f6f 100644
--- a/gix-odb/src/store_impls/dynamic/structure.rs
+++ b/gix-odb/src/store_impls/dynamic/structure.rs
@@ -1,6 +1,8 @@
 use std::path::PathBuf;
 
-use crate::{Store, store::load_index, types::IndexAndPacks};
+use gix_error::ExnResult;
+
+use crate::{Store, types::IndexAndPacks};
 
 /// A record of a structural element of an object database.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -51,7 +53,7 @@ impl Store {
     /// Note that it may change as we collect information due to the highly volatile nature of the
     /// implementation. The likelihood of actual changes is low though as these still depend on something
     /// changing on disk and somebody reading at the same time.
-    pub fn structure(&self) -> Result<Vec<Record>, load_index::Error> {
+    pub fn structure(&self) -> ExnResult<Vec<Record>> {
         let _span = gix_features::trace::detail!("gix_odb::Store::structure()");
         let index = self.index.load();
         if !index.is_initialized() {
@@ -100,7 +102,7 @@ impl Store {
     /// This list might be empty if there are no alternates.
     ///
     /// Read more about alternates in the documentation of the [`resolve`][crate::alternate::resolve()] function.
-    pub fn alternate_db_paths(&self) -> Result<Vec<PathBuf>, load_index::Error> {
+    pub fn alternate_db_paths(&self) -> ExnResult<Vec<PathBuf>> {
         let index = self.index.load();
         if !index.is_initialized() {
             self.consolidate_with_disk_state(true, false /*load one new index*/, self.loose_compression)?;
diff --git a/gix-odb/src/store_impls/dynamic/types.rs b/gix-odb/src/store_impls/dynamic/types.rs
index d6ed872b0f3..8fa42f4d59d 100644
--- a/gix-odb/src/store_impls/dynamic/types.rs
+++ b/gix-odb/src/store_impls/dynamic/types.rs
@@ -320,19 +320,13 @@ impl IndexAndPacks {
             IndexAndPacks::Index(bundle) => bundle.index.load_strict(|path| {
                 gix_pack::index::File::at(path, object_hash)
                     .map(Arc::new)
-                    .map_err(|err| match err {
-                        gix_pack::index::init::Error::Io { source, .. } => source,
-                        err => std::io::Error::other(err),
-                    })
+                    .map_err(super::exn_to_io)
             }),
             IndexAndPacks::MultiIndex(bundle) => {
                 bundle.multi_index.load_strict(|path| {
                     gix_pack::multi_index::File::at(path, alloc_limit_bytes)
                         .map(Arc::new)
-                        .map_err(|err| match err {
-                            gix_pack::multi_index::init::Error::Io { source, .. } => source,
-                            err => std::io::Error::other(err),
-                        })
+                        .map_err(super::exn_to_io)
                 })?;
                 if let Some(multi_index) = bundle.multi_index.loaded() {
                     bundle.data = Self::index_names_to_pack_paths(multi_index);
diff --git a/gix-odb/src/store_impls/dynamic/verify.rs b/gix-odb/src/store_impls/dynamic/verify.rs
index e58a503d6d4..413bc7a4979 100644
--- a/gix-odb/src/store_impls/dynamic/verify.rs
+++ b/gix-odb/src/store_impls/dynamic/verify.rs
@@ -4,6 +4,8 @@ use std::{
     time::Instant,
 };
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, retryable};
+
 use gix_features::progress::{DynNestedProgress, MessageLevel, Progress};
 
 use crate::{
@@ -21,28 +23,6 @@ pub mod integrity {
     /// Options for use in [`Store::verify_integrity()`][crate::Store::verify_integrity()].
     pub type Options<F> = pack::index::verify::integrity::Options<F>;
 
-    /// Returned by [`Store::verify_integrity()`][crate::Store::verify_integrity()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        MultiIndexIntegrity(#[from] pack::index::traverse::Error<pack::multi_index::verify::integrity::Error>),
-        #[error(transparent)]
-        IndexIntegrity(#[from] pack::index::traverse::Error<pack::index::verify::integrity::Error>),
-        #[error(transparent)]
-        IndexOpen(#[from] pack::index::init::Error),
-        #[error(transparent)]
-        LooseObjectStoreIntegrity(#[from] crate::loose::verify::integrity::Error),
-        #[error(transparent)]
-        MultiIndexOpen(#[from] pack::multi_index::init::Error),
-        #[error(transparent)]
-        PackOpen(#[from] pack::data::init::Error),
-        #[error(transparent)]
-        InitializeODB(#[from] crate::store::load_index::Error),
-        #[error("The disk on state changed while performing the operation, and we observed the change.")]
-        NeedsRetryDueToChangeOnDisk,
-    }
-
     #[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd, Clone)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     /// Integrity information about loose object databases
@@ -56,7 +36,7 @@ pub mod integrity {
     #[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd, Clone)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     /// Traversal statistics of packs governed by single indices or multi-pack indices.
-    #[expect(missing_docs)]
+    #[allow(missing_docs)]
     pub enum SingleOrMultiStatistics {
         Single(pack::index::traverse::Statistics),
         Multi(Vec<(PathBuf, pack::index::traverse::Statistics)>),
@@ -109,16 +89,19 @@ impl super::Store {
     ///
     /// Note that this will not force loading all indices or packs permanently, as we will only use the momentarily loaded disk state.
     /// This does, however, include all alternates.
+    /// Verification failures include [metadata](gix_error::Exn::metadata()) `path` (native index, pack, or loose object
+    /// directory path).
     pub fn verify_integrity<C, F>(
         &self,
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
         options: integrity::Options<F>,
-    ) -> Result<integrity::Outcome, integrity::Error>
+    ) -> ExnResult<integrity::Outcome>
     where
         C: pack::cache::DecodeEntry,
         F: Fn() -> C + Send + Clone,
     {
+        let changed = || retryable("The object database changed during verification").raise_erased();
         let _span = gix_features::trace::coarse!("gix_odb:Store::verify_integrity()");
         let mut index = self.index.load();
         if !index.is_initialized() {
@@ -146,10 +129,10 @@ impl super::Store {
             for slot_index in &index.slot_indices {
                 let slot = &self.files[*slot_index];
                 if slot.generation.load(Ordering::SeqCst) != index.generation {
-                    return Err(integrity::Error::NeedsRetryDueToChangeOnDisk);
+                    return Err(changed());
                 }
                 let files = slot.files.load();
-                let files = Option::as_ref(&files).ok_or(integrity::Error::NeedsRetryDueToChangeOnDisk)?;
+                let files = Option::as_ref(&files).ok_or_else(changed)?;
 
                 let start = Instant::now();
                 let (mut child_progress, num_objects, index_path) = match files {
@@ -158,7 +141,12 @@ impl super::Store {
                         let index = match bundle.index.loaded() {
                             Some(index) => index.deref(),
                             None => {
-                                index = pack::index::File::at(bundle.index.path(), self.object_hash)?;
+                                index = pack::index::File::at(bundle.index.path(), self.object_hash).or_raise_erased(
+                                    || {
+                                        Message::new("Could not open pack index for verification")
+                                            .with("path", bundle.index.path())
+                                    },
+                                )?;
                                 &index
                             }
                         };
@@ -166,7 +154,11 @@ impl super::Store {
                         let data = match bundle.data.loaded() {
                             Some(pack) => pack.deref(),
                             None => {
-                                pack = pack::data::File::at(bundle.data.path(), self.object_hash)?
+                                pack = pack::data::File::at(bundle.data.path(), self.object_hash)
+                                    .or_raise_erased(|| {
+                                        Message::new("Could not open pack for verification")
+                                            .with("path", bundle.data.path())
+                                    })?
                                     .with_alloc_limit_bytes(self.alloc_limit_bytes);
                                 &pack
                             }
@@ -175,14 +167,18 @@ impl super::Store {
                             "verify index".into(),
                             integrity::ProgressId::VerifyIndex(Default::default()).into(),
                         );
-                        let outcome = index.verify_integrity(
-                            Some(pack::index::verify::PackContext {
-                                data,
-                                options: options.clone(),
-                            }),
-                            &mut child_progress,
-                            should_interrupt,
-                        )?;
+                        let outcome = index
+                            .verify_integrity(
+                                Some(pack::index::verify::PackContext {
+                                    data,
+                                    options: options.clone(),
+                                }),
+                                &mut child_progress,
+                                should_interrupt,
+                            )
+                            .or_raise_erased(|| {
+                                Message::new("Could not verify pack index").with("path", index.path())
+                            })?;
                         statistics.push(IndexStatistics {
                             path: bundle.index.path().to_owned(),
                             statistics: SingleOrMultiStatistics::Single(
@@ -198,7 +194,11 @@ impl super::Store {
                         let index = match bundle.multi_index.loaded() {
                             Some(index) => index.deref(),
                             None => {
-                                index = pack::multi_index::File::at(bundle.multi_index.path(), self.alloc_limit_bytes)?;
+                                index = pack::multi_index::File::at(bundle.multi_index.path(), self.alloc_limit_bytes)
+                                    .or_raise_erased(|| {
+                                        Message::new("Could not open multi-pack index for verification")
+                                            .with("path", bundle.multi_index.path())
+                                    })?;
                                 &index
                             }
                         };
@@ -206,7 +206,11 @@ impl super::Store {
                             "verify multi-index".into(),
                             integrity::ProgressId::VerifyMultiIndex(Default::default()).into(),
                         );
-                        let outcome = index.verify_integrity(&mut child_progress, should_interrupt, options.clone())?;
+                        let outcome = index
+                            .verify_integrity(&mut child_progress, should_interrupt, options.clone())
+                            .or_raise_erased(|| {
+                                Message::new("Could not verify multi-pack index").with("path", index.path())
+                            })?;
 
                         let index_dir = bundle.multi_index.path().parent().expect("file in a directory");
                         statistics.push(IndexStatistics {
@@ -241,26 +245,27 @@ impl super::Store {
             gix_features::progress::count("loose object stores"),
         );
         let mut loose_object_stores = Vec::new();
-        gix_features::trace::detail!("verify loose ODBs").into_scope(
-            || -> Result<_, crate::loose::verify::integrity::Error> {
-                for loose_db in &*index.loose_dbs {
-                    let out = loose_db
-                        .verify_integrity(
-                            &mut progress.add_child_with_id(
-                                loose_db.path().display().to_string(),
-                                integrity::ProgressId::VerifyLooseObjectDbPath.into(),
-                            ),
-                            should_interrupt,
-                        )
-                        .map(|statistics| integrity::LooseObjectStatistics {
-                            path: loose_db.path().to_owned(),
-                            statistics,
-                        })?;
-                    loose_object_stores.push(out);
-                }
-                Ok(())
-            },
-        )?;
+        gix_features::trace::detail!("verify loose ODBs").into_scope(|| -> ExnResult<_> {
+            for loose_db in &*index.loose_dbs {
+                let out = loose_db
+                    .verify_integrity(
+                        &mut progress.add_child_with_id(
+                            loose_db.path().display().to_string(),
+                            integrity::ProgressId::VerifyLooseObjectDbPath.into(),
+                        ),
+                        should_interrupt,
+                    )
+                    .or_raise_erased(|| {
+                        Message::new("Could not verify loose object database").with("path", loose_db.path())
+                    })
+                    .map(|statistics| integrity::LooseObjectStatistics {
+                        path: loose_db.path().to_owned(),
+                        statistics,
+                    })?;
+                loose_object_stores.push(out);
+            }
+            Ok(())
+        })?;
 
         Ok(integrity::Outcome {
             loose_object_stores,
diff --git a/gix-odb/src/store_impls/dynamic/write.rs b/gix-odb/src/store_impls/dynamic/write.rs
index b2ab84f2d4e..6e992567e33 100644
--- a/gix-odb/src/store_impls/dynamic/write.rs
+++ b/gix-odb/src/store_impls/dynamic/write.rs
@@ -1,68 +1,45 @@
 use std::{io::Read, ops::Deref};
 
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 use gix_object::Kind;
 
 use crate::store;
 
-mod error {
-    use crate::{loose, store};
-
-    /// The error returned by the [dynamic Store's][crate::Store] [`Write`](gix_object::Write) implementation.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        LoadIndex(#[from] store::load_index::Error),
-        #[error(transparent)]
-        LooseWrite(#[from] loose::write::Error),
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-    }
-}
-pub use error::Error;
-
 use crate::store_impls::dynamic;
 
 impl<S> gix_object::Write for store::Handle<S>
 where
     S: Deref<Target = dynamic::Store> + Clone,
 {
-    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> Result<ObjectId, gix_object::write::Error> {
+    fn write_stream(&self, kind: Kind, size: u64, from: &mut dyn Read) -> ExnResult<ObjectId> {
         let mut snapshot = self.snapshot.borrow_mut();
-        Ok(match snapshot.loose_dbs.first() {
-            Some(ldb) => ldb.write_stream(kind, size, from)?,
+        match snapshot.loose_dbs.first() {
+            Some(ldb) => ldb.write_stream(kind, size, from),
             None => {
                 let new_snapshot = self
                     .store
-                    .load_one_index(self.index_ctx(snapshot.marker))
-                    .map_err(Box::new)?
+                    .load_one_index(self.index_ctx(snapshot.marker))?
                     .expect("there is always at least one ODB, and this code runs only once for initialization");
                 *snapshot = new_snapshot;
-                snapshot.loose_dbs[0].write_stream(kind, size, from)?
+                snapshot.loose_dbs[0].write_stream(kind, size, from)
             }
-        })
+        }
     }
 
-    fn write_buf_with_known_id(
-        &self,
-        kind: Kind,
-        from: &[u8],
-        id: ObjectId,
-    ) -> Result<ObjectId, gix_object::write::Error> {
+    fn write_buf_with_known_id(&self, kind: Kind, from: &[u8], id: ObjectId) -> ExnResult<ObjectId> {
         let mut snapshot = self.snapshot.borrow_mut();
-        Ok(match snapshot.loose_dbs.first() {
-            Some(ldb) => ldb.write_buf_with_known_id(kind, from, id)?,
+        match snapshot.loose_dbs.first() {
+            Some(ldb) => ldb.write_buf_with_known_id(kind, from, id),
             None => {
                 let new_snapshot = self
                     .store
-                    .load_one_index(self.index_ctx(snapshot.marker))
-                    .map_err(Box::new)?
+                    .load_one_index(self.index_ctx(snapshot.marker))?
                     .expect("there is always at least one ODB, and this code runs only once for initialization");
                 *snapshot = new_snapshot;
-                snapshot.loose_dbs[0].write_buf_with_known_id(kind, from, id)?
+                snapshot.loose_dbs[0].write_buf_with_known_id(kind, from, id)
             }
-        })
+        }
     }
 
     fn write_stream_with_known_id(
@@ -71,19 +48,18 @@ where
         size: u64,
         from: &mut dyn Read,
         id: ObjectId,
-    ) -> Result<ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<ObjectId> {
         let mut snapshot = self.snapshot.borrow_mut();
-        Ok(match snapshot.loose_dbs.first() {
-            Some(ldb) => ldb.write_stream_with_known_id(kind, size, from, id)?,
+        match snapshot.loose_dbs.first() {
+            Some(ldb) => ldb.write_stream_with_known_id(kind, size, from, id),
             None => {
                 let new_snapshot = self
                     .store
-                    .load_one_index(self.index_ctx(snapshot.marker))
-                    .map_err(Box::new)?
+                    .load_one_index(self.index_ctx(snapshot.marker))?
                     .expect("there is always at least one ODB, and this code runs only once for initialization");
                 *snapshot = new_snapshot;
-                snapshot.loose_dbs[0].write_stream_with_known_id(kind, size, from, id)?
+                snapshot.loose_dbs[0].write_stream_with_known_id(kind, size, from, id)
             }
-        })
+        }
     }
 }
diff --git a/gix-odb/src/store_impls/loose/find.rs b/gix-odb/src/store_impls/loose/find.rs
index 3f09ac6733d..70a146f6ba5 100644
--- a/gix-odb/src/store_impls/loose/find.rs
+++ b/gix-odb/src/store_impls/loose/find.rs
@@ -1,33 +1,11 @@
-use std::{cmp::Ordering, collections::HashSet, io, path::PathBuf};
+use std::{cmp::Ordering, collections::HashSet};
 
-use gix_error::{CorruptionError, Error as GixError};
+use gix_error::{ErrorExt, Exn, ExnResult, Message, ResultExt, allocation_failure, allocation_limit, corruption};
 
 use crate::store_impls::loose::{HEADER_MAX_SIZE, Store, hash_path};
 
-/// Returned by [`Store::try_find()`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("decompression of loose object at '{path}' failed")]
-    DecompressFile { source: GixError, path: PathBuf },
-    #[error("file at '{path}' showed invalid size of inflated data, expected {expected}, got {actual}")]
-    SizeMismatch { actual: u64, expected: u64, path: PathBuf },
-    #[error(transparent)]
-    Decode(#[from] gix_object::decode::LooseHeaderDecodeError),
-    #[error("Cannot store {size} in memory as it's not representable")]
-    OutOfMemory { size: u64 },
-    #[error("Could not {action} data at '{path}'")]
-    Io {
-        source: std::io::Error,
-        action: &'static str,
-        path: PathBuf,
-    },
-}
-
 /// Object lookup
 impl Store {
-    const OPEN_OR_MAP_ACTION: &'static str = "open or map";
-
     /// Returns true if the given id is contained in our repository.
     pub fn contains(&self, id: &gix_hash::oid) -> bool {
         debug_assert_eq!(self.object_hash, id.kind());
@@ -102,44 +80,43 @@ impl Store {
     ///
     /// Returns `Err` if there was an error locating or reading the object. Returns `Ok<None>` if
     /// there was no such object.
-    pub fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        out: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, Error> {
+    /// Failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the loose object file.
+    pub fn try_find<'a>(&self, id: &gix_hash::oid, out: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         debug_assert_eq!(self.object_hash, id.kind());
         self.find_inner(id, out)
+            .or_raise_erased(|| Message::new("Could not read loose object").with("path", self.object_path(id)))
     }
 
     /// Return only the decompressed size of the object and its kind without fully reading it into memory as tuple of `(size, kind)`.
     /// Returns `None` if `id` does not exist in the database.
-    pub fn try_header(&self, id: &gix_hash::oid) -> Result<Option<(u64, gix_object::Kind)>, Error> {
+    /// Failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the loose object file.
+    pub fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<(u64, gix_object::Kind)>> {
         let path = hash_path(id, self.path.clone());
-        let map = match self.map_loose_object(&path)? {
+        let context = || Message::new("Could not read loose object header").with("path", path.as_path());
+        let map = match self.map_loose_object(&path).or_raise_erased(context)? {
             Some(map) => map,
             None => return Ok(None),
         };
         let mut header = [0_u8; HEADER_MAX_SIZE];
         let mut inflate = gix_zlib::Inflate::default();
-        let (status, _consumed_in, consumed_out) =
-            inflate.once(&map, &mut header).map_err(|e| Error::DecompressFile {
-                source: e.into_error(),
-                path: path.to_owned(),
-            })?;
+        let (status, _consumed_in, consumed_out) = inflate.once(&map, &mut header).or_raise_erased(context)?;
 
         if status == gix_zlib::Status::BufError {
-            return Err(Error::DecompressFile {
-                source: GixError::from_error(CorruptionError::new(
-                    "The zlib status indicated an error, status was 'BufError'",
-                )),
-                path,
-            });
+            return Err(corruption(
+                "Could not read loose object header: the zlib status indicated an error, status was 'BufError'",
+            )
+            .with("path", path.as_path())
+            .raise_erased());
         }
-        let (kind, size, _header_size) = gix_object::decode::loose_header(&header[..consumed_out])?;
+        let (kind, size, _header_size) =
+            gix_object::decode::loose_header(&header[..consumed_out]).or_raise_erased(context)?;
         Ok(Some((size, kind)))
     }
 
-    fn find_inner<'a>(&self, id: &gix_hash::oid, out: &'a mut Vec<u8>) -> Result<Option<gix_object::Data<'a>>, Error> {
+    /// Decode and allocation failures retain [metadata](gix_error::Exn::metadata()) `size` (requested bytes) or
+    /// `actual` and `expected`
+    /// (inflated bytes); allocation limits also report `limit`. All counts are unsigned.
+    fn find_inner<'a>(&self, id: &gix_hash::oid, out: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         let path = hash_path(id, self.path.clone());
         let map = match self.map_loose_object(&path)? {
             Some(map) => map,
@@ -148,49 +125,33 @@ impl Store {
         let mut header = [0_u8; HEADER_MAX_SIZE];
 
         let mut inflate = gix_zlib::Inflate::default();
-        let (status, consumed_in, consumed_out) =
-            inflate.once(&map, &mut header).map_err(|e| Error::DecompressFile {
-                source: e.into_error(),
-                path: path.to_owned(),
-            })?;
+        let (status, consumed_in, consumed_out) = inflate.once(&map, &mut header).or_erased()?;
         if status == gix_zlib::Status::BufError {
-            return Err(Error::DecompressFile {
-                source: GixError::from_error(CorruptionError::new(
-                    "The zlib status indicated an error, status was 'BufError'",
-                )),
-                path,
-            });
+            return Err(corruption("The zlib status indicated an error, status was 'BufError'").raise_erased());
         }
 
-        let (kind, size, header_size) = gix_object::decode::loose_header(&header[..consumed_out])?;
+        let (kind, size, header_size) = gix_object::decode::loose_header(&header[..consumed_out]).or_erased()?;
         self.ensure_in_alloc_limit(size)?;
-        let size_usize = usize::try_from(size).map_err(|_| Error::OutOfMemory { size })?;
-        let decompressed_body_prefix_len = consumed_out.checked_sub(header_size).ok_or(Error::SizeMismatch {
-            actual: consumed_out as u64,
-            expected: header_size as u64,
-            path: path.clone(),
+        let allocation = || allocation_error(size);
+        let size_usize = usize::try_from(size).or_raise_erased(|| {
+            allocation_failure("Cannot store loose object in memory: the object size cannot be represented in memory")
+                .with("size", size)
         })?;
-
-        if decompressed_body_prefix_len > size_usize {
-            return Err(Error::SizeMismatch {
-                expected: size,
-                actual: decompressed_body_prefix_len as u64,
-                path,
-            });
+        let decompressed_body_prefix_len = consumed_out
+            .checked_sub(header_size)
+            .ok_or_else(|| size_mismatch(consumed_out as u64, header_size as u64).erased())?;
+
+        if decompressed_body_prefix_len > size_usize
+            || (status == gix_zlib::Status::StreamEnd && decompressed_body_prefix_len != size_usize)
+        {
+            return Err(size_mismatch(decompressed_body_prefix_len as u64, size).erased());
         }
 
         // If the first inflate already reached the end of the stream, the fixed-size `header` buffer
-        // contains the complete decompressed object. In that case we can avoid allocating the full
-        // output buffer and a second streaming inflate pass.
+        // contains the complete decompressed object, so we can skip a second streaming inflate pass.
         out.clear();
+        out.try_reserve(size_usize).or_raise_erased(allocation)?;
         if status == gix_zlib::Status::StreamEnd {
-            if consumed_out as u64 != size + header_size as u64 {
-                return Err(Error::SizeMismatch {
-                    expected: size + header_size as u64,
-                    actual: consumed_out as u64,
-                    path,
-                });
-            }
             out.extend_from_slice(&header[header_size..consumed_out]);
         } else {
             out.resize(size_usize, 0);
@@ -202,18 +163,14 @@ impl Store {
                 &mut inflate.state,
                 &mut out[decompressed_body_prefix_len..],
             )
-            .map_err(|e| Error::Io {
-                source: e,
-                action: "inflate",
-                path: path.to_owned(),
-            })?;
+            .or_erased()?;
 
             if num_decompressed_bytes as u64 + decompressed_body_prefix_len as u64 != size {
-                return Err(Error::SizeMismatch {
-                    expected: size,
-                    actual: num_decompressed_bytes as u64 + decompressed_body_prefix_len as u64,
-                    path,
-                });
+                return Err(size_mismatch(
+                    num_decompressed_bytes as u64 + decompressed_body_prefix_len as u64,
+                    size,
+                )
+                .erased());
             }
         }
         Ok(Some(gix_object::Data {
@@ -223,32 +180,28 @@ impl Store {
         }))
     }
 
-    fn ensure_in_alloc_limit(&self, size: u64) -> Result<(), Error> {
-        if self.alloc_limit_bytes.is_some_and(|limit| size > limit as u64) {
-            return Err(Error::OutOfMemory { size });
+    /// Allocation-limit failures include [metadata](gix_error::Exn::metadata()) `size` and `limit` (unsigned byte
+    /// counts).
+    fn ensure_in_alloc_limit(&self, size: u64) -> ExnResult {
+        if let Some(limit) = self.alloc_limit_bytes.filter(|limit| size > *limit as u64) {
+            return Err(allocation_limit(
+                "Cannot store loose object in memory: the object exceeds the configured allocation limit",
+            )
+            .with("size", size)
+            .with("limit", limit)
+            .raise_erased());
         }
         Ok(())
     }
 
-    fn map_loose_object(&self, path: &std::path::Path) -> Result<Option<memmap2::Mmap>, Error> {
+    fn map_loose_object(&self, path: &std::path::Path) -> ExnResult<Option<memmap2::Mmap>> {
         let map = match mmap::read_only(path) {
             Ok(map) => map,
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-            Err(err) => {
-                return Err(Error::Io {
-                    action: Self::OPEN_OR_MAP_ACTION,
-                    source: err,
-                    path: path.to_owned(),
-                });
-            }
+            Err(err) => return Err(err.raise_erased()),
         };
-
         if map.is_empty() {
-            return Err(Error::Io {
-                source: io::Error::other("empty loose object file"),
-                action: Self::OPEN_OR_MAP_ACTION,
-                path: path.to_owned(),
-            });
+            return Err(gix_error::corruption("Empty loose object file").raise_erased());
         }
         Ok(Some(map))
     }
@@ -260,9 +213,24 @@ mod mmap {
     pub fn read_only(path: &Path) -> std::io::Result<memmap2::Mmap> {
         let file = std::fs::File::open(path)?;
         // SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.
-        #[expect(unsafe_code)]
+        #[allow(unsafe_code)]
         unsafe {
             memmap2::MmapOptions::new().map_copy_read_only(&file)
         }
     }
 }
+
+/// The raised error's [metadata](gix_error::Exn::metadata()) `size` (unsigned bytes) identifies the requested
+/// loose-object allocation.
+fn allocation_error(size: u64) -> Message {
+    Message::new("Cannot store loose object in memory").with("size", size)
+}
+
+/// Report invalid inflation sizes in [metadata](gix_error::Exn::metadata()) `actual` and `expected` (unsigned byte
+/// counts).
+fn size_mismatch(actual: u64, expected: u64) -> Exn<Message> {
+    corruption("Loose object size mismatch: invalid size of inflated loose object")
+        .with("actual", actual)
+        .with("expected", expected)
+        .raise()
+}
diff --git a/gix-odb/src/store_impls/loose/mod.rs b/gix-odb/src/store_impls/loose/mod.rs
index 28fba9b9812..e98d1300648 100644
--- a/gix-odb/src/store_impls/loose/mod.rs
+++ b/gix-odb/src/store_impls/loose/mod.rs
@@ -92,8 +92,7 @@ fn hash_path(id: &gix_hash::oid, mut root: PathBuf) -> PathBuf {
     root
 }
 
-///
-pub mod find;
+mod find;
 ///
 pub mod iter;
 ///
@@ -105,5 +104,4 @@ pub struct Iter {
     hash_hex_len: usize,
 }
 
-///
-pub mod write;
+mod write;
diff --git a/gix-odb/src/store_impls/loose/verify.rs b/gix-odb/src/store_impls/loose/verify.rs
index 03292091432..a287898b2f7 100644
--- a/gix-odb/src/store_impls/loose/verify.rs
+++ b/gix-odb/src/store_impls/loose/verify.rs
@@ -3,41 +3,14 @@ use std::{
     time::Instant,
 };
 
+use gix_error::{Class, ClassificationMarker, ErrorExt, ExnResult, Message, ResultExt, message, retryable};
+
 use gix_features::progress::{Count, DynNestedProgress, Progress};
 
 use crate::loose::Store;
 
 ///
 pub mod integrity {
-    /// The error returned by [`verify_integrity()`][super::Store::verify_integrity()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("{kind} object {id} could not be decoded")]
-        ObjectDecode {
-            source: gix_object::decode::Error,
-            kind: gix_object::Kind,
-            id: gix_hash::ObjectId,
-        },
-        #[error("{kind} object {expected} could not be hashed")]
-        ObjectHasher {
-            #[source]
-            source: gix_hash::hasher::Error,
-            kind: gix_object::Kind,
-            expected: gix_hash::ObjectId,
-        },
-        #[error("{kind} object wasn't re-encoded without change")]
-        ObjectEncodeMismatch {
-            #[source]
-            source: gix_hash::verify::Error,
-            kind: gix_object::Kind,
-        },
-        #[error("Objects were deleted during iteration - try again")]
-        Retry,
-        #[error("Interrupted")]
-        Interrupted,
-    }
-
     /// The outcome returned by [`verify_integrity()`][super::Store::verify_integrity()].
     #[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd, Clone)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -66,45 +39,45 @@ pub mod integrity {
 
 impl Store {
     /// Check all loose objects for their integrity checking their hash matches the actual data and by decoding them fully.
+    /// Verification failures include [metadata](gix_error::Exn::metadata()) `object_id` (hex text), plus `kind` (object
+    /// kind text) after lookup.
     pub fn verify_integrity(
         &self,
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
-    ) -> Result<integrity::Statistics, integrity::Error> {
-        use gix_object::Write;
+    ) -> ExnResult<integrity::Statistics> {
         let mut buf = Vec::new();
-        let sink = crate::sink(self.object_hash);
 
         let mut num_objects = 0;
         let start = Instant::now();
         let mut progress = progress.add_child_with_id("Validating".into(), integrity::ProgressId::LooseObjects.into());
         progress.init(None, gix_features::progress::count("loose objects"));
-        for id in self.iter().filter_map(Result::ok) {
+        for id in self.iter() {
+            let id = id.or_raise_erased(|| message("Could not enumerate loose objects"))?;
             let object = self
                 .try_find(&id, &mut buf)
-                .map_err(|_| integrity::Error::Retry)?
-                .ok_or(integrity::Error::Retry)?;
-            sink.write_buf(object.kind, object.data)
-                .map_err(|err| integrity::Error::ObjectHasher {
-                    source: *err.downcast().expect("sink can only fail in hasher"),
-                    kind: object.kind,
-                    expected: id,
+                .or_raise_erased(|| {
+                    Message::new("Could not read loose object during verification").with("object_id", id.to_string())
                 })?
-                .verify(&id)
-                .map_err(|err| integrity::Error::ObjectEncodeMismatch {
-                    source: err,
-                    kind: object.kind,
-                })?;
-            object.decode().map_err(|err| integrity::Error::ObjectDecode {
-                source: err,
-                kind: object.kind,
-                id,
-            })?;
+                .ok_or_else(|| retryable("Objects were deleted during iteration - try again").raise_erased())?;
+            let context = || {
+                Message::new("Could not verify loose object")
+                    .with("object_id", id.to_string())
+                    .with("kind", object.kind.to_string())
+            };
+            gix_object::compute_hash(self.object_hash, object.kind, object.data)
+                .and_then(|actual| actual.verify(&id))
+                .or_raise_erased(context)?;
+            object.decode().or_raise_erased(context)?;
 
             progress.inc();
             num_objects += 1;
             if should_interrupt.load(Ordering::SeqCst) {
-                return Err(integrity::Error::Interrupted);
+                return Err(ClassificationMarker::with_source(
+                    Class::Retryable,
+                    std::io::Error::from(std::io::ErrorKind::Interrupted),
+                )
+                .raise_erased());
             }
         }
         progress.show_throughput(start);
diff --git a/gix-odb/src/store_impls/loose/write.rs b/gix-odb/src/store_impls/loose/write.rs
index 2a8a96fe50a..3e0e5cd6c93 100644
--- a/gix-odb/src/store_impls/loose/write.rs
+++ b/gix-odb/src/store_impls/loose/write.rs
@@ -1,5 +1,10 @@
-use std::{fs, io, io::Write, path::PathBuf};
+use std::{
+    fs, io,
+    io::Write,
+    path::{Path, PathBuf},
+};
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt};
 use gix_object::WriteTo;
 use gix_zlib::stream::deflate;
 use tempfile::NamedTempFile;
@@ -7,138 +12,88 @@ use tempfile::NamedTempFile;
 use super::Store;
 use crate::store_impls::loose;
 
-/// Returned by the [`gix_object::Write`] trait implementation of [`Store`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not {message} '{path}'")]
-    Io {
-        source: std::io::Error,
-        message: &'static str,
-        path: PathBuf,
-    },
-    #[error("An IO error occurred while writing an object")]
-    IoRaw(#[from] io::Error),
-    #[error("Could not turn temporary file into persisted file at '{target}'")]
-    Persist {
-        source: tempfile::PersistError,
-        target: PathBuf,
-    },
-}
-
 impl gix_object::Write for Store {
-    fn write(&self, object: &dyn WriteTo) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    /// Write failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
+    fn write(&self, object: &dyn WriteTo) -> ExnResult<gix_hash::ObjectId> {
         let mut to = self.dest()?;
-        to.write_all(&object.loose_header()).map_err(|err| Error::Io {
-            source: err,
-            message: "write header to tempfile in",
-            path: self.path.to_owned(),
-        })?;
-        object.write_to(&mut to).map_err(|err| Error::Io {
-            source: err,
-            message: "stream all data into tempfile in",
-            path: self.path.to_owned(),
-        })?;
-        to.flush().map_err(Box::new)?;
-        Ok(self.finalize_object(to).map_err(Box::new)?)
+        to.write_all(&object.loose_header())
+            .or_raise_erased(|| write_header_error(&self.path))?;
+        object
+            .write_to(&mut to)
+            .or_raise_erased(|| stream_data_error(&self.path))?;
+        to.flush().or_erased()?;
+        self.finalize_object(to)
     }
 
     /// Write the given buffer in `from` to disk in one syscall at best.
     ///
     /// This will cost at least 4 IO operations.
-    fn write_buf(&self, kind: gix_object::Kind, from: &[u8]) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let mut to = self.dest().map_err(Box::new)?;
+    /// Write failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
+    fn write_buf(&self, kind: gix_object::Kind, from: &[u8]) -> ExnResult<gix_hash::ObjectId> {
+        let mut to = self.dest()?;
         to.write_all(&gix_object::encode::loose_header(kind, from.len() as u64))
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "write header to tempfile in",
-                path: self.path.to_owned(),
-            })?;
+            .or_raise_erased(|| write_header_error(&self.path))?;
 
-        to.write_all(from).map_err(|err| Error::Io {
-            source: err,
-            message: "stream all data into tempfile in",
-            path: self.path.to_owned(),
-        })?;
-        to.flush()?;
-        Ok(self.finalize_object(to)?)
+        to.write_all(from).or_raise_erased(|| stream_data_error(&self.path))?;
+        to.flush().or_erased()?;
+        self.finalize_object(to)
     }
 
+    /// Write failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
     fn write_buf_with_known_id(
         &self,
         kind: gix_object::Kind,
         from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let mut to = self.compressed_tempfile().map_err(Box::new)?;
+    ) -> ExnResult<gix_hash::ObjectId> {
+        let mut to = self.compressed_tempfile()?;
         to.write_all(&gix_object::encode::loose_header(kind, from.len() as u64))
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "write header to tempfile in",
-                path: self.path.to_owned(),
-            })?;
+            .or_raise_erased(|| write_header_error(&self.path))?;
 
-        to.write_all(from).map_err(|err| Error::Io {
-            source: err,
-            message: "stream all data into tempfile in",
-            path: self.path.to_owned(),
-        })?;
-        to.flush()?;
-        Ok(self.finalize_object_at(id, to)?)
+        to.write_all(from).or_raise_erased(|| stream_data_error(&self.path))?;
+        to.flush().or_erased()?;
+        self.finalize_object_at(id, to)
     }
 
     /// Write the given stream in `from` to disk with at least one syscall.
     ///
     /// This will cost at least 4 IO operations.
+    /// Write failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
     fn write_stream(
         &self,
         kind: gix_object::Kind,
         size: u64,
         mut from: &mut dyn io::Read,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let mut to = self.dest().map_err(Box::new)?;
+    ) -> ExnResult<gix_hash::ObjectId> {
+        let mut to = self.dest()?;
         to.write_all(&gix_object::encode::loose_header(kind, size))
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "write header to tempfile in",
-                path: self.path.to_owned(),
-            })?;
+            .or_raise_erased(|| write_header_error(&self.path))?;
 
-        io::copy(&mut from, &mut to)
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "stream all data into tempfile in",
-                path: self.path.to_owned(),
-            })
-            .map_err(Box::new)?;
-        to.flush().map_err(Box::new)?;
-        Ok(self.finalize_object(to)?)
+        io::copy(&mut from, &mut to).or_raise_erased(|| stream_data_error(&self.path))?;
+        to.flush().or_erased()?;
+        self.finalize_object(to)
     }
 
+    /// Write failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
     fn write_stream_with_known_id(
         &self,
         kind: gix_object::Kind,
         size: u64,
         mut from: &mut dyn io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let mut to = self.compressed_tempfile().map_err(Box::new)?;
+    ) -> ExnResult<gix_hash::ObjectId> {
+        let mut to = self.compressed_tempfile()?;
         to.write_all(&gix_object::encode::loose_header(kind, size))
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "write header to tempfile in",
-                path: self.path.to_owned(),
-            })?;
+            .or_raise_erased(|| write_header_error(&self.path))?;
 
-        io::copy(&mut from, &mut to)
-            .map_err(|err| Error::Io {
-                source: err,
-                message: "stream all data into tempfile in",
-                path: self.path.to_owned(),
-            })
-            .map_err(Box::new)?;
-        to.flush().map_err(Box::new)?;
-        Ok(self.finalize_object_at(id, to)?)
+        io::copy(&mut from, &mut to).or_raise_erased(|| stream_data_error(&self.path))?;
+        to.flush().or_erased()?;
+        self.finalize_object_at(id, to)
     }
 }
 
@@ -156,12 +111,14 @@ impl Store {
 
 impl Store {
     /// A compressed tempfile, with auto-hashing.
-    fn dest(&self) -> Result<gix_hash::io::Write<CompressedTempfile>, Error> {
+    fn dest(&self) -> ExnResult<gix_hash::io::Write<CompressedTempfile>> {
         Ok(gix_hash::io::Write::new(self.compressed_tempfile()?, self.object_hash))
     }
 
     /// A compressed tempfile, without hasher.
-    fn compressed_tempfile(&self) -> Result<CompressedTempfile, Error> {
+    /// Creation failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
+    fn compressed_tempfile(&self) -> ExnResult<CompressedTempfile> {
         #[cfg_attr(not(unix), allow(unused_mut))]
         let mut builder = tempfile::Builder::new();
         #[cfg(unix)]
@@ -171,32 +128,31 @@ impl Store {
             builder.permissions(perms);
         }
         Ok(deflate::Write::new(
-            builder.tempfile_in(&self.path).map_err(|err| Error::Io {
-                source: err,
-                message: "create named temp file in",
-                path: self.path.to_owned(),
+            builder.tempfile_in(&self.path).or_raise_erased(|| {
+                Message::new("Could not create temporary object file").with("path", self.path.as_path())
             })?,
             self.compression,
         ))
     }
 
+    /// Hashing failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the temporary object
+    /// directory.
     fn finalize_object(
         &self,
         gix_hash::io::Write { hash, inner: file }: gix_hash::io::Write<CompressedTempfile>,
-    ) -> Result<gix_hash::ObjectId, Error> {
-        let id = hash.try_finalize().map_err(|err| Error::Io {
-            source: std::io::Error::other(gix_hash::io::from_hasher(err).into_error()),
-            message: "hash tempfile in",
-            path: self.path.to_owned(),
-        })?;
+    ) -> ExnResult<gix_hash::ObjectId> {
+        let id = hash
+            .try_finalize()
+            .map_err(gix_hash::io::from_hasher)
+            .or_raise_erased(|| {
+                Message::new("Could not hash temporary object file").with("path", self.path.as_path())
+            })?;
         self.finalize_object_at(id, file)
     }
 
-    fn finalize_object_at(
-        &self,
-        id: gix_hash::ObjectId,
-        file: CompressedTempfile,
-    ) -> Result<gix_hash::ObjectId, Error> {
+    /// Publication failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the object directory
+    /// or destination file.
+    fn finalize_object_at(&self, id: gix_hash::ObjectId, file: CompressedTempfile) -> ExnResult<gix_hash::ObjectId> {
         let object_path = loose::hash_path(&id, self.path.clone());
         let object_dir = object_path
             .parent()
@@ -204,7 +160,11 @@ impl Store {
         if let Err(err) = fs::create_dir(object_dir) {
             match err.kind() {
                 io::ErrorKind::AlreadyExists => {}
-                _ => return Err(err.into()),
+                _ => {
+                    return Err(err
+                        .and_raise(Message::new("Could not create object directory").with("path", object_dir))
+                        .erased());
+                }
             }
         }
         let file = file.into_inner();
@@ -219,10 +179,19 @@ impl Store {
                 return Ok(id);
             }
         }
-        res.map_err(|err| Error::Persist {
-            source: err,
-            target: object_path,
-        })?;
+        res.or_raise_erased(|| Message::new("Could not persist loose object").with("path", object_path))?;
         Ok(id)
     }
 }
+
+/// The raised error's [metadata](gix_error::Exn::metadata()) `path` (native path) identifies the temporary object
+/// directory for a header-write failure.
+fn write_header_error(path: &Path) -> Message {
+    Message::new("Could not write loose object header").with("path", path)
+}
+
+/// The raised error's [metadata](gix_error::Exn::metadata()) `path` (native path) identifies the temporary object
+/// directory for a data-streaming failure.
+fn stream_data_error(path: &Path) -> Message {
+    Message::new("Could not stream loose object data").with("path", path)
+}
diff --git a/gix-odb/src/traits.rs b/gix-odb/src/traits.rs
index f3e5cec6403..c83e9b65245 100644
--- a/gix-odb/src/traits.rs
+++ b/gix-odb/src/traits.rs
@@ -1,14 +1,17 @@
 use crate::find;
+use gix_error::ExnResult;
 
 /// A way to obtain object properties without fully decoding it.
 pub trait Header {
     /// Try to read the header of the object associated with `id` or return `None` if it could not be found.
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<find::Header>, gix_object::find::Error>;
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<find::Header>>;
 }
 
 mod _impls {
     use std::{ops::Deref, rc::Rc, sync::Arc};
 
+    use gix_error::ExnResult;
+
     use gix_hash::oid;
 
     use crate::find::Header;
@@ -17,7 +20,7 @@ mod _impls {
     where
         T: crate::Header,
     {
-        fn try_header(&self, id: &oid) -> Result<Option<Header>, gix_object::find::Error> {
+        fn try_header(&self, id: &oid) -> ExnResult<Option<Header>> {
             (*self).try_header(id)
         }
     }
@@ -26,7 +29,7 @@ mod _impls {
     where
         T: crate::Header,
     {
-        fn try_header(&self, id: &oid) -> Result<Option<Header>, gix_object::find::Error> {
+        fn try_header(&self, id: &oid) -> ExnResult<Option<Header>> {
             self.deref().try_header(id)
         }
     }
@@ -35,22 +38,25 @@ mod _impls {
     where
         T: crate::Header,
     {
-        fn try_header(&self, id: &oid) -> Result<Option<Header>, gix_object::find::Error> {
+        fn try_header(&self, id: &oid) -> ExnResult<Option<Header>> {
             self.deref().try_header(id)
         }
     }
 }
 
 mod ext {
+    use gix_error::ErrorExt;
+    use gix_error::ExnResult;
+
     use crate::find;
     /// An extension trait with convenience functions.
     pub trait HeaderExt: super::Header {
         /// Like [`try_header(…)`][super::Header::try_header()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error.
-        fn header(&self, id: impl AsRef<gix_hash::oid>) -> Result<find::Header, gix_object::find::existing::Error> {
+        fn header(&self, id: impl AsRef<gix_hash::oid>) -> ExnResult<find::Header> {
             let id = id.as_ref();
-            self.try_header(id)
-                .map_err(gix_object::find::existing::Error::Find)?
-                .ok_or_else(|| gix_object::find::existing::Error::NotFound { oid: id.to_owned() })
+            self.try_header(id)?.ok_or_else(|| {
+                gix_error::not_found(format!("An object with id {id} could not be found")).raise_erased()
+            })
         }
     }
 
diff --git a/gix-odb/tests/odb/alternate.rs b/gix-odb/tests/odb/alternate.rs
index 26c89c98617..06c85fd34eb 100644
--- a/gix-odb/tests/odb/alternate.rs
+++ b/gix-odb/tests/odb/alternate.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{
     fs, io,
     path::{Path, PathBuf},
@@ -39,7 +40,7 @@ mod parse {
 pub fn alternate(
     objects_at: impl Into<PathBuf>,
     objects_to: impl Into<PathBuf>,
-) -> Result<(PathBuf, PathBuf), io::Error> {
+) -> std::result::Result<(PathBuf, PathBuf), io::Error> {
     alternate_with(objects_at, objects_to, None)
 }
 
@@ -47,7 +48,7 @@ fn alternate_with(
     objects_at: impl Into<PathBuf>,
     objects_to: impl Into<PathBuf>,
     content_before_to: Option<&str>,
-) -> Result<(PathBuf, PathBuf), io::Error> {
+) -> std::result::Result<(PathBuf, PathBuf), io::Error> {
     let objects_to = objects_to.into();
     alternate_with_content(
         objects_at,
@@ -62,7 +63,7 @@ fn alternate_with_content(
     objects_to: impl Into<PathBuf>,
     to_content: Vec<u8>,
     content_before_to: Option<&str>,
-) -> Result<(PathBuf, PathBuf), io::Error> {
+) -> std::result::Result<(PathBuf, PathBuf), io::Error> {
     let at = objects_at.into();
     let to = objects_to.into();
     let at_info = at.join("info");
@@ -81,7 +82,7 @@ fn alternate_with_content(
 }
 
 #[test]
-fn circular_alternates_are_detected_with_relative_paths() -> crate::Result {
+fn circular_alternates_are_detected_with_relative_paths() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let tmp = tmp.path().join("sub-dir");
     std::fs::create_dir(&tmp)?;
@@ -98,23 +99,29 @@ fn circular_alternates_are_detected_with_relative_paths() -> crate::Result {
         None,
     )?;
 
-    match alternate::resolve(from, &std::env::current_dir()?) {
-        Err(alternate::Error::Cycle(chain)) => {
-            assert_eq!(
-                chain
-                    .into_iter()
-                    .map(|p| p.file_name().expect("non-root").to_str().expect("utf8").to_owned())
-                    .collect::<Vec<_>>(),
-                vec!["a", "b"]
-            );
-        }
-        res => unreachable!("should be a specific kind of error: {:?}", res),
-    }
+    let err = alternate::resolve(from, &std::env::current_dir()?)
+        .expect_err("the relative alternate points back to its ancestor");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&gix_path::realpath(&tmp)?.to_string_lossy(), "<root>")]), "alternate cycles are malformed configuration", @"Alternates form a cycle -> <root>/a -> <root>/b");
+    assert!(err.is_corrupted(), "alternate cycles are malformed configuration");
+    assert!(
+        err.probable_cause().is::<alternate::Cycle>(),
+        "the alternate cycle, not its classification marker, is the probable cause"
+    );
+    assert_eq!(
+        err.downcast_any_ref::<alternate::Cycle>()
+            .expect("the discovered cycle is retained")
+            .paths
+            .iter()
+            .map(|path| path.file_name().expect("non-root").to_str().expect("utf8"))
+            .collect::<Vec<_>>(),
+        ["a", "b"],
+        "the cycle retains the ordered directory chain"
+    );
     Ok(())
 }
 
 #[test]
-fn alternates_reachable_on_multiple_paths_are_not_a_cycle() -> crate::Result {
+fn alternates_reachable_on_multiple_paths_are_not_a_cycle() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let tmp = tmp.path();
     let (a, shared) = alternate(tmp.join("a"), tmp.join("shared"))?;
@@ -139,7 +146,7 @@ fn alternates_reachable_on_multiple_paths_are_not_a_cycle() -> crate::Result {
 }
 
 #[test]
-fn cycles_between_alternates_also_listed_by_the_root_are_detected() -> crate::Result {
+fn cycles_between_alternates_also_listed_by_the_root_are_detected() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let tmp = tmp.path();
     let (a, b) = alternate(tmp.join("a"), tmp.join("b"))?;
@@ -153,22 +160,23 @@ fn cycles_between_alternates_also_listed_by_the_root_are_detected() -> crate::Re
         None,
     )?;
 
-    match alternate::resolve(from, &std::env::current_dir()?) {
-        Err(alternate::Error::Cycle(chain)) => assert_eq!(
-            chain
-                .into_iter()
-                .map(|p| p.file_name().expect("non-root").to_str().expect("utf8").to_owned())
-                .collect::<Vec<_>>(),
-            vec!["a", "b"],
-            "the traversed A -> B -> A edges form a cycle even when A and B were first seen as siblings"
-        ),
-        res => unreachable!("should be a cycle error: {res:?}"),
-    }
+    let err = alternate::resolve(from, &std::env::current_dir()?).expect_err("the alternate chain is cyclic");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&gix_path::realpath(tmp)?.to_string_lossy(), "<root>")]), "cycles reached from sibling roots retain the traversed directories", @"Alternates form a cycle -> <root>/a -> <root>/b");
+    assert_eq!(
+        err.downcast_any_ref::<alternate::Cycle>()
+            .expect("the discovered cycle is retained")
+            .paths
+            .iter()
+            .map(|p| p.file_name().expect("non-root").to_str().expect("utf8"))
+            .collect::<Vec<_>>(),
+        ["a", "b"],
+        "the traversed A -> B -> A edges form a cycle even when A and B were first seen as siblings"
+    );
     Ok(())
 }
 
 #[test]
-fn single_link_with_comment_before_path_and_ansi_c_escape() -> crate::Result {
+fn single_link_with_comment_before_path_and_ansi_c_escape() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let non_alternate = tmp.path().join("actual");
 
@@ -180,7 +188,7 @@ fn single_link_with_comment_before_path_and_ansi_c_escape() -> crate::Result {
 }
 
 #[test]
-fn no_alternate_in_first_objects_dir() -> crate::Result {
+fn no_alternate_in_first_objects_dir() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     assert!(alternate::resolve(tmp.path().to_owned(), &std::env::current_dir()?)?.is_empty());
     Ok(())
diff --git a/gix-odb/tests/odb/error.rs b/gix-odb/tests/odb/error.rs
new file mode 100644
index 00000000000..d183d937479
--- /dev/null
+++ b/gix-odb/tests/odb/error.rs
@@ -0,0 +1,449 @@
+use crate::Result;
+use std::io;
+
+use gix_error::{Class, ClassificationMarker, Message, MetadataValue};
+use gix_object::{Kind, Write};
+
+#[test]
+fn write_failures_preserve_custom_sources_and_metadata() -> Result {
+    let mut error_snapshots = Vec::new();
+    #[derive(Debug)]
+    struct ReadFailure(ClassificationMarker);
+
+    impl std::fmt::Display for ReadFailure {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str("custom reader failed")
+        }
+    }
+
+    impl std::error::Error for ReadFailure {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(&self.0)
+        }
+    }
+
+    struct FailingRead;
+    impl io::Read for FailingRead {
+        fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
+            Err(io::Error::other(ReadFailure(ClassificationMarker::with_source(
+                Class::Retryable,
+                gix_error::not_found("temporarily missing input"),
+            ))))
+        }
+    }
+
+    let dir = gix_testtools::tempfile::tempdir()?;
+    let loose = gix_odb::loose::Store::at(dir.path(), gix_testtools::object_hash());
+    let dynamic = crate::odb_at(dir.path())?;
+    for store in [&loose as &dyn Write, &dynamic] {
+        for err in [
+            store
+                .write_stream(Kind::Blob, 1, &mut FailingRead)
+                .expect_err("the input reader failed"),
+            store
+                .write_stream_with_known_id(
+                    Kind::Blob,
+                    1,
+                    &mut FailingRead,
+                    gix_testtools::object_hash().empty_blob(),
+                )
+                .expect_err("a known object ID does not mask input failures"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(dir.path()).to_string_lossy(), "<objects>")],
+            ));
+            assert!(
+                err.is_not_found() && err.can_retry(),
+                "custom sources retain both predicates"
+            );
+            assert!(
+                err.downcast_any_ref::<ReadFailure>().is_some(),
+                "the custom cause remains accessible"
+            );
+            assert_eq!(
+                err.downcast_any_ref::<io::Error>()
+                    .expect("the reader's I/O error remains accessible")
+                    .kind(),
+                io::ErrorKind::Other,
+                "context does not replace the reader's I/O error"
+            );
+            assert!(
+                gix_error::classify(err.probable_cause()).is_not_found(),
+                "the original not-found cause remains available"
+            );
+            let context = err.metadata().next().expect("the write adds context");
+            let diagnostic = err.downcast_any_ref::<Message>().expect("write context");
+            assert_eq!(
+                *context,
+                maplit::btreemap! { "path".into() => MetadataValue::from(dir.path()) },
+                "the schema retains only the native object directory"
+            );
+            assert_eq!(
+                diagnostic.class, None,
+                "write context does not reclassify the reader's failure"
+            );
+            assert_eq!(
+                err.metadata().count(),
+                1,
+                "only the write context contributes a nonempty dictionary"
+            );
+        }
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "write failures preserve custom sources and metadata", @r#"
+    [
+        Could not stream loose object data, "path"="<objects>"
+        |
+        └─ I/O error (Other)
+        |
+        └─ custom reader failed
+        |
+        └─ temporarily missing input,
+        Could not stream loose object data, "path"="<objects>"
+        |
+        └─ I/O error (Other)
+        |
+        └─ custom reader failed
+        |
+        └─ temporarily missing input,
+        Could not stream loose object data, "path"="<objects>"
+        |
+        └─ I/O error (Other)
+        |
+        └─ custom reader failed
+        |
+        └─ temporarily missing input,
+        Could not stream loose object data, "path"="<objects>"
+        |
+        └─ I/O error (Other)
+        |
+        └─ custom reader failed
+        |
+        └─ temporarily missing input,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn delta_lookup_distinguishes_missing_bases_from_recursion_limits() -> Result {
+    let mut error_snapshots = Vec::new();
+    use std::io::Write;
+
+    use gix_object::Find;
+    use gix_pack::data;
+
+    let dir = gix_testtools::tempfile::tempdir()?;
+    let pack_dir = dir.path().join("pack");
+    std::fs::create_dir(&pack_dir)?;
+    let object_hash = gix_testtools::object_hash();
+    let blob_id = object_hash.empty_blob();
+    let base_id = object_hash.null();
+
+    // A single ref-delta would produce an empty blob, but its base is absent.
+    let mut pack = data::header::encode(data::Version::V2, 1).to_vec();
+    data::entry::Header::RefDelta { base_id }.write_to(2, &mut pack)?;
+    let mut compressed = gix_zlib::stream::deflate::Write::new(Vec::new(), gix_zlib::Compression::DEFAULT);
+    compressed.write_all(&[0, 0])?;
+    compressed.flush()?;
+    pack.extend(compressed.into_inner());
+    let mut hasher = gix_hash::hasher(object_hash);
+    hasher.update(&pack);
+    let pack_id = hasher.try_finalize()?;
+    pack.extend_from_slice(pack_id.as_slice());
+
+    // A v1 index names the unresolved object without needing to decode it first.
+    let mut index = Vec::new();
+    for first_byte in 0..=255 {
+        index.extend_from_slice(&u32::from(first_byte >= blob_id.first_byte()).to_be_bytes());
+    }
+    index.extend_from_slice(&(data::header::SIZE as u32).to_be_bytes());
+    index.extend_from_slice(blob_id.as_slice());
+    index.extend_from_slice(pack_id.as_slice());
+    let mut hasher = gix_hash::hasher(object_hash);
+    hasher.update(&index);
+    index.extend_from_slice(hasher.try_finalize()?.as_slice());
+    std::fs::write(pack_dir.join(format!("pack-{pack_id}.pack")), pack)?;
+    std::fs::write(pack_dir.join(format!("pack-{pack_id}.idx")), index)?;
+
+    for max_depth in [8, 0] {
+        let mut store = crate::odb_at(dir.path())?;
+        store.max_recursion_depth = max_depth;
+        for err in [
+            store
+                .try_find(&blob_id, &mut Vec::new())
+                .expect_err("the delta cannot be resolved"),
+            gix_odb::Header::try_header(&store, &blob_id).expect_err("the base kind is unavailable"),
+        ] {
+            let num_nodes = if max_depth == 0 { 2 } else { 1 };
+            assert_eq!(
+                err.iter_errors().count(),
+                num_nodes,
+                "only missing bases collapse the synthetic cause and its context"
+            );
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(dir.path()).to_string_lossy(), "<objects>")],
+            ));
+            assert_eq!(err.is_not_found(), max_depth != 0, "only an absent base is not found");
+            assert_eq!(
+                err.is_not_found(),
+                max_depth != 0,
+                "hitting a limit does not establish absence, even after conversion"
+            );
+            assert!(
+                !err.is_corrupted() && !err.can_retry(),
+                "neither absence nor a recursion limit establishes corruption or retryability"
+            );
+            assert_eq!(
+                err.metadata().count(),
+                num_nodes,
+                "each generic context keeps its own values"
+            );
+            let context = err.metadata().next().expect("the failed lookup carries context");
+            let diagnostic = err.downcast_any_ref::<Message>().expect("delta resolution diagnostic");
+            assert_eq!(
+                *context,
+                maplit::btreemap! {
+                    "base_id".into() => MetadataValue::from(base_id.to_string()),
+                    "object_id".into() => MetadataValue::from(blob_id.to_string()),
+                },
+                "delta-resolution metadata retains both object IDs as hex text"
+            );
+            if max_depth == 0 {
+                assert_eq!(
+                    diagnostic.class, None,
+                    "lookup context must not classify recursion failures as missing"
+                );
+                assert_eq!(err.classify().count(), 0, "a recursion limit has no inferred class");
+                let limit = err
+                    .iter_errors()
+                    .filter_map(|error| error.downcast_ref::<Message>())
+                    .find(|context| context.values.contains_key("max_depth"))
+                    .expect("the nested recursion failure retains its limit");
+                assert_eq!(
+                    limit.values,
+                    maplit::btreemap! {
+                        "max_depth".into() => MetadataValue::U64(0),
+                        "object_id".into() => MetadataValue::from(blob_id.to_string()),
+                    },
+                    "recursion-limit metadata retains the original object and unsigned limit"
+                );
+            } else {
+                assert_eq!(
+                    diagnostic.class,
+                    Some(Class::NotFound),
+                    "the missing-base diagnostic supplies its own class"
+                );
+                assert!(
+                    err.probable_cause().is::<Message>(),
+                    "the combined diagnostic is the cause"
+                );
+                let classification = err.classify().next().expect("the missing base is classified");
+                assert!(
+                    classification.error().is::<Message>(),
+                    "there is no synthetic not-found source"
+                );
+            }
+        }
+    }
+
+    let loose = gix_odb::loose::Store::at(dir.path(), object_hash);
+    let base_path = loose.object_path(&base_id);
+    std::fs::create_dir(base_path.parent().expect("loose objects have a parent directory"))?;
+    // These bases exist, but zlib rejects them: invalid data and a stream requiring a preset dictionary.
+    for (input, class) in [
+        (b"invalid zlib".as_slice(), Class::Corruption),
+        ([0x78, 0x20, 0, 0, 0, 0].as_slice(), Class::Validation),
+    ] {
+        std::fs::write(&base_path, input)?;
+        let store = crate::odb_at(dir.path())?;
+        for err in [
+            store
+                .try_find(&blob_id, &mut Vec::new())
+                .expect_err("the base cannot be decoded"),
+            gix_odb::Header::try_header(&store, &blob_id).expect_err("the base header cannot be decoded"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&base_path.to_string_lossy(), "<base-object-path>")],
+            ));
+            assert!(!err.is_not_found(), "a failed lookup does not establish absence");
+            assert_eq!(
+                err.classify()
+                    .map(|classification| classification.class())
+                    .collect::<Vec<_>>(),
+                [class],
+                "delta resolution retains the actual callee's class"
+            );
+            let context = err.metadata().next().expect("delta resolution supplies context");
+            assert_eq!(
+                err.downcast_any_ref::<Message>()
+                    .expect("delta resolution context")
+                    .class,
+                None,
+                "only the None branch adds a not-found class"
+            );
+            assert_eq!(
+                context["object_id"],
+                MetadataValue::from(blob_id.to_string()),
+                "the requested object is retained"
+            );
+            assert_eq!(
+                context["base_id"],
+                MetadataValue::from(base_id.to_string()),
+                "the failing base is retained"
+            );
+            assert_eq!(
+                err.metadata().nth(1).expect("the loose lookup supplies its path")["path"],
+                MetadataValue::from(base_path.as_path()),
+                "the callee's metadata remains separate from delta context"
+            );
+            assert!(
+                gix_error::classify(err.probable_cause()).any(|classification| classification.class() == class),
+                "the original zlib error retains its classification"
+            );
+        }
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "delta lookup distinguishes missing bases from recursion limits", @r#"
+    [
+        Could not resolve delta base object: delta base object is missing, "base_id"="Oid(1)", "object_id"="Oid(2)",
+        Could not resolve delta base object: delta base object is missing, "base_id"="Oid(1)", "object_id"="Oid(2)",
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Reached recursion limit while resolving ref delta bases, "max_depth"=0, "object_id"="Oid(2)",
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Reached recursion limit while resolving ref delta bases, "max_depth"=0, "object_id"="Oid(2)",
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Could not read loose object, "path"="<base-object-path>"
+        |
+        └─ Could not decode zip stream
+        |
+        └─ Invalid input data,
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Could not read loose object header, "path"="<base-object-path>"
+        |
+        └─ Could not decode zip stream
+        |
+        └─ Invalid input data,
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Could not read loose object, "path"="<base-object-path>"
+        |
+        └─ Could not decode zip stream
+        |
+        └─ Decompressing this input requires a dictionary,
+        Could not resolve delta base object, "base_id"="Oid(1)", "object_id"="Oid(2)"
+        |
+        └─ Could not read loose object header, "path"="<base-object-path>"
+        |
+        └─ Could not decode zip stream
+        |
+        └─ Decompressing this input requires a dictionary,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+fn disappearing_loose_objects_keep_retryable_diagnostics() -> Result {
+    let mut diagnostics = Vec::new();
+    use std::{os::unix::fs::symlink, sync::atomic::AtomicBool};
+
+    let dir = gix_testtools::tempfile::tempdir()?;
+    let object_hash = gix_testtools::object_hash();
+    let loose = gix_odb::loose::Store::at(dir.path(), object_hash);
+    let blob_id = object_hash.empty_blob();
+    let path = loose.object_path(&blob_id);
+    std::fs::create_dir(path.parent().expect("loose objects have a parent directory"))?;
+    // A dangling link is enumerated but cannot be read, reproducing disappearance without a race.
+    symlink(dir.path().join("deleted-object"), &path)?;
+    assert_eq!(
+        loose.iter().collect::<std::result::Result<Vec<_>, _>>()?,
+        [blob_id],
+        "the object path must be visible to iteration before lookup finds it missing"
+    );
+    let dynamic = crate::odb_at(dir.path())?;
+    for (err, num_nodes) in [
+        (
+            loose
+                .verify_integrity(&mut gix_features::progress::Discard, &AtomicBool::new(false))
+                .expect_err("the enumerated object is missing"),
+            1,
+        ),
+        (
+            dynamic
+                .store_ref()
+                .verify_integrity(
+                    &mut gix_features::progress::Discard,
+                    &AtomicBool::new(false),
+                    Default::default(),
+                )
+                .err()
+                .expect("dynamic verification also observes the missing loose object"),
+            2,
+        ),
+    ] {
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &err,
+            &[(&dir.path().to_string_lossy(), "<objects>")],
+        ));
+        assert!(
+            err.is_retryable() && err.can_retry(),
+            "verification can retry after objects disappear"
+        );
+        assert_eq!(
+            err.iter_errors().count(),
+            num_nodes,
+            "retry classification adds no synthetic diagnostic"
+        );
+        assert_eq!(
+            err.metadata().count(),
+            num_nodes - 1,
+            "metadata skips the retry diagnostic's empty dictionary"
+        );
+        assert_eq!(
+            err.classify()
+                .map(|classification| classification.class())
+                .collect::<Vec<_>>(),
+            [Class::Retryable],
+            "a disappearing object is retryable without adding a not-found class"
+        );
+        let cause = err
+            .probable_cause()
+            .downcast_ref::<Message>()
+            .expect("the message itself carries retryability");
+        assert_eq!(
+            cause.class,
+            Some(Class::Retryable),
+            "no marker is needed for a synthetic retry diagnostic"
+        );
+        assert!(cause.values.is_empty(), "retry-only diagnostics need no scalar values");
+        if num_nodes == 2 {
+            let context = err.metadata().next().expect("dynamic verification adds path context");
+            assert_eq!(
+                err.downcast_any_ref::<Message>().expect("verification context").class,
+                None,
+                "the caller does not reclassify the failure"
+            );
+            assert_eq!(
+                context["path"],
+                MetadataValue::from(dir.path()),
+                "the object directory remains available"
+            );
+        }
+    }
+    insta::assert_debug_snapshot!(diagnostics, "disappearing loose objects keep retryable diagnostics", @r#"
+    [
+        Objects were deleted during iteration - try again,
+        Could not verify loose object database, "path"="<objects>"
+        |
+        └─ Objects were deleted during iteration - try again,
+    ]
+    "#);
+    Ok(())
+}
diff --git a/gix-odb/tests/odb/main.rs b/gix-odb/tests/odb/main.rs
index 2cb674ff1d1..1642d7738b7 100644
--- a/gix-odb/tests/odb/main.rs
+++ b/gix-odb/tests/odb/main.rs
@@ -31,6 +31,7 @@ fn db_small_packs() -> gix_odb::Handle {
 }
 
 pub mod alternate;
+mod error;
 pub mod find;
 pub mod header;
 pub mod memory;
diff --git a/gix-odb/tests/odb/memory.rs b/gix-odb/tests/odb/memory.rs
index 981d6afeeb2..d3ed6955271 100644
--- a/gix-odb/tests/odb/memory.rs
+++ b/gix-odb/tests/odb/memory.rs
@@ -1,10 +1,11 @@
+use crate::Result;
 use gix_object::{Exists, FindExt, Write, tree};
 use gix_testtools::tempfile::TempDir;
 
 use crate::hex_to_id_for_hash;
 
 #[test]
-fn without_memory() -> crate::Result {
+fn without_memory() -> Result {
     use gix_odb::HeaderExt;
     let (mut odb, _tmp) = db_rw()?;
     let mut buf = Vec::new();
@@ -48,7 +49,7 @@ fn without_memory() -> crate::Result {
 }
 
 #[test]
-fn with_memory() -> crate::Result {
+fn with_memory() -> Result {
     use gix_object::FindHeader;
     let mut odb = db()?;
     assert_eq!(
@@ -120,7 +121,7 @@ fn with_memory() -> crate::Result {
 }
 
 #[test]
-fn with_memory_trusts_known_id() -> crate::Result {
+fn with_memory_trusts_known_id() -> Result {
     let odb = db()?;
     let kind = gix_object::Kind::Blob;
     let bytes = b"content";
@@ -150,7 +151,7 @@ fn with_memory_trusts_known_id() -> crate::Result {
 }
 
 #[test]
-fn without_memory_forwards_known_id_writes() -> crate::Result {
+fn without_memory_forwards_known_id_writes() -> Result {
     let (mut odb, _tmp) = db_rw()?;
     odb.take_object_memory().expect("it starts out with memory set");
 
@@ -179,12 +180,12 @@ fn without_memory_forwards_known_id_writes() -> crate::Result {
     Ok(())
 }
 
-fn db() -> crate::Result<gix_odb::memory::Proxy<gix_odb::Handle>> {
+fn db() -> Result<gix_odb::memory::Proxy<gix_odb::Handle>> {
     let odb = crate::odb_at(crate::scripted_fixture_read_only("repo_with_loose_objects.sh")?.join(".git/objects"))?;
     Ok(gix_odb::memory::Proxy::new(odb, gix_testtools::object_hash()))
 }
 
-fn db_rw() -> crate::Result<(gix_odb::memory::Proxy<gix_odb::Handle>, TempDir)> {
+fn db_rw() -> Result<(gix_odb::memory::Proxy<gix_odb::Handle>, TempDir)> {
     let tmp = crate::scripted_fixture_writable("repo_with_loose_objects.sh")?;
     let odb = crate::odb_at(tmp.path().join(".git/objects"))?;
     Ok((gix_odb::memory::Proxy::new(odb, gix_testtools::object_hash()), tmp))
diff --git a/gix-odb/tests/odb/regression.rs b/gix-odb/tests/odb/regression.rs
index b345b38574a..15fd3e4907d 100644
--- a/gix-odb/tests/odb/regression.rs
+++ b/gix-odb/tests/odb/regression.rs
@@ -1,10 +1,11 @@
 mod repo_with_small_packs {
+    use crate::Result;
     use gix_object::Find;
 
     use crate::{db_small_packs, hex_to_id};
 
     #[test]
-    fn all_packed_objects_can_be_found() -> crate::Result {
+    fn all_packed_objects_can_be_found() -> Result {
         let store = db_small_packs();
         let mut buf = Vec::new();
         assert!(
@@ -18,7 +19,7 @@ mod repo_with_small_packs {
 
     #[test]
     #[cfg(feature = "parallel")]
-    fn multi_threaded_access_will_not_panic() -> crate::Result {
+    fn multi_threaded_access_will_not_panic() -> Result {
         for arg in ["no", "without-multi-index"] {
             let base = crate::scripted_fixture_read_only_with_args("make_repo_multi_index.sh", Some(arg))?
                 .join(".git")
@@ -29,7 +30,7 @@ mod repo_with_small_packs {
                 std::thread::spawn({
                     let store = store.clone();
                     let barrier = barrier.clone();
-                    move || -> Result<usize, Box<dyn std::error::Error + Send + Sync>> {
+                    move || -> std::result::Result<usize, Box<dyn std::error::Error + Send + Sync>> {
                         barrier.recv().ok();
                         let mut buf = Vec::new();
                         let mut count = 0;
diff --git a/gix-odb/tests/odb/sink.rs b/gix-odb/tests/odb/sink.rs
index 44abcae5f80..08c6840252a 100644
--- a/gix-odb/tests/odb/sink.rs
+++ b/gix-odb/tests/odb/sink.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use gix_object::Write;
 
 use crate::store::loose::{locate_oid, object_ids};
 
 #[test]
-fn write() -> crate::Result {
+fn write() -> Result {
     let mut buf = Vec::new();
     for oid in object_ids() {
         let obj = locate_oid(oid, &mut buf);
diff --git a/gix-odb/tests/odb/store/dynamic.rs b/gix-odb/tests/odb/store/dynamic.rs
index 0bfb4191995..347908e1894 100644
--- a/gix-odb/tests/odb/store/dynamic.rs
+++ b/gix-odb/tests/odb/store/dynamic.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_hash::ObjectId;
 use gix_object::{Exists, FindExt, Write};
 use gix_odb::{Header, store, store::iter::Ordering};
@@ -24,7 +25,7 @@ struct PackMetrics {
     packs: usize,
 }
 
-fn expected_pack_metrics(repo_dir: &std::path::Path) -> crate::Result<PackMetrics> {
+fn expected_pack_metrics(repo_dir: &std::path::Path) -> Result<PackMetrics> {
     let expected = std::fs::read_to_string(repo_dir.join("expected-count-objects"))?;
     let mut loose = None;
     let mut in_pack = None;
@@ -47,7 +48,7 @@ fn expected_pack_metrics(repo_dir: &std::path::Path) -> crate::Result<PackMetric
 }
 
 /// indices, multi-pack-index, loose odb
-fn db_with_all_object_sources() -> crate::Result<(gix_odb::Handle, gix_testtools::tempfile::TempDir)> {
+fn db_with_all_object_sources() -> Result<(gix_odb::Handle, gix_testtools::tempfile::TempDir)> {
     let objects_dir = gix_testtools::tempfile::tempdir()?;
     gix_testtools::copy_recursively_into_existing_dir(fixture_path("objects"), &objects_dir)?;
 
@@ -71,7 +72,7 @@ fn db_with_all_object_sources() -> crate::Result<(gix_odb::Handle, gix_testtools
 }
 
 #[test]
-fn multi_index_access() -> crate::Result {
+fn multi_index_access() -> Result {
     let dir = crate::scripted_fixture_writable("make_repo_multi_index.sh")?;
     let expected = expected_pack_metrics(dir.path())?;
     let handle = crate::odb_at(dir.path().join(".git/objects"))?;
@@ -178,7 +179,7 @@ fn multi_index_access() -> crate::Result {
 }
 
 #[test]
-fn multi_index_alloc_limit_bytes_falls_back_to_plain_indices() -> crate::Result {
+fn multi_index_alloc_limit_bytes_falls_back_to_plain_indices() -> Result {
     let dir = crate::scripted_fixture_writable("make_repo_multi_index.sh")?;
     let expected = expected_pack_metrics(dir.path())?;
     let handle = gix_odb::at_opts(
@@ -211,7 +212,7 @@ fn multi_index_alloc_limit_bytes_falls_back_to_plain_indices() -> crate::Result
 }
 
 #[test]
-fn multi_index_keep_open() -> crate::Result {
+fn multi_index_keep_open() -> Result {
     let dir = crate::scripted_fixture_writable("make_repo_multi_index.sh")?;
     let expected = expected_pack_metrics(dir.path())?;
     let (stable_handle, handle) = {
@@ -277,7 +278,7 @@ fn multi_index_keep_open() -> crate::Result {
 }
 
 #[test]
-fn an_object_in_a_pack_moved_by_an_external_process_can_be_found_from_a_stale_handle() -> crate::Result {
+fn an_object_in_a_pack_moved_by_an_external_process_can_be_found_from_a_stale_handle() -> Result {
     let tmp = gix_testtools::tempfile::tempdir()?;
     let pack_dir = tmp.path().join("objects/pack");
     std::fs::create_dir_all(&pack_dir)?;
@@ -332,7 +333,7 @@ fn an_object_in_a_pack_moved_by_an_external_process_can_be_found_from_a_stale_ha
 }
 
 #[test]
-fn write() -> crate::Result {
+fn write() -> Result {
     let dir = gix_testtools::tempfile::tempdir()?;
     let mut handle = odb_at(dir.path())?;
     // It should refresh once even if the refresh mode is never, just to initialize the index
@@ -350,7 +351,7 @@ fn write() -> crate::Result {
 }
 
 #[test]
-fn alternate_dbs_query() -> crate::Result {
+fn alternate_dbs_query() -> Result {
     let dir = crate::scripted_fixture_read_only("make_alternates_odb.sh")?;
     let handle = crate::odb_at(dir.join(".git/objects"))?;
 
@@ -370,7 +371,7 @@ fn alternate_dbs_query() -> crate::Result {
 }
 
 #[test]
-fn object_replacement() -> crate::Result {
+fn object_replacement() -> Result {
     let dir = crate::scripted_fixture_read_only("make_replaced_history.sh")?;
     let handle = crate::odb_at(dir.join(".git/objects"))?;
     let mut buf = Vec::new();
@@ -674,6 +675,7 @@ fn packed_object_count_causes_all_indices_to_be_loaded() {
 }
 
 mod disambiguate_prefix {
+    use crate::Result;
     use std::cmp::Ordering;
 
     use gix_odb::store::prefix::disambiguate::Candidate;
@@ -685,13 +687,18 @@ mod disambiguate_prefix {
     };
 
     #[test]
-    fn unambiguous_hex_lengths_yield_prefixes_of_exactly_the_given_length() -> crate::Result {
+    fn unambiguous_hex_lengths_yield_prefixes_of_exactly_the_given_length() -> Result {
         let (mut handle, _tmp) = db_with_all_object_sources()?;
         handle.refresh.never();
 
         let hex_lengths = &[5, 7, 40];
         for order in all_orderings() {
-            for (index, oid) in handle.iter()?.with_ordering(order).map(Result::unwrap).enumerate() {
+            for (index, oid) in handle
+                .iter()?
+                .with_ordering(order)
+                .map(std::result::Result::unwrap)
+                .enumerate()
+            {
                 let hex_len = hex_lengths[index % hex_lengths.len()];
                 let prefix = handle
                     .disambiguate_prefix(Candidate::new(oid, hex_len)?)?
@@ -762,6 +769,7 @@ mod disambiguate_prefix {
 }
 
 mod iter {
+    use crate::Result;
     use gix_odb::store::iter::Ordering;
 
     use crate::{
@@ -770,19 +778,19 @@ mod iter {
     };
 
     #[test]
-    fn iteration_ordering_is_effective() -> crate::Result {
+    fn iteration_ordering_is_effective() -> Result {
         assert_eq!(all_orderings().len(), 2, "new orderings cause this test to be reviewed");
         for (handle, _tmp) in [db_with_all_object_sources().map(|(a, b)| (a, Some(b)))?, (db(), None)] {
             let (mut a, mut b): (Vec<_>, Vec<_>) = (
                 handle
                     .iter()?
                     .with_ordering(Ordering::PackLexicographicalThenLooseLexicographical)
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .collect(),
                 handle
                     .iter()?
                     .with_ordering(Ordering::PackAscendingOffsetThenLooseLexicographical)
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .collect(),
             );
             assert_eq!(a.len(), b.len(), "count isn't affected by ordering");
@@ -797,6 +805,7 @@ mod iter {
 }
 
 mod lookup_prefix {
+    use crate::Result;
     use std::collections::HashSet;
 
     use maplit::hashset;
@@ -847,13 +856,18 @@ mod lookup_prefix {
     }
 
     #[test]
-    fn iterable_objects_can_be_looked_up_with_varying_prefix_lengths() -> crate::Result {
+    fn iterable_objects_can_be_looked_up_with_varying_prefix_lengths() -> Result {
         let (mut handle, _tmp) = db_with_all_object_sources()?;
         handle.refresh.never();
 
         let hex_lengths = &[5, 7, 40];
         for order in all_orderings() {
-            for (index, oid) in handle.iter()?.with_ordering(order).map(Result::unwrap).enumerate() {
+            for (index, oid) in handle
+                .iter()?
+                .with_ordering(order)
+                .map(std::result::Result::unwrap)
+                .enumerate()
+            {
                 for mut candidates in [None, Some(HashSet::default())] {
                     let hex_len = hex_lengths[index % hex_lengths.len()];
                     let prefix = gix_hash::Prefix::new(&oid, hex_len)?;
@@ -919,7 +933,7 @@ fn missing_objects_triggers_everything_is_loaded() {
 }
 
 #[test]
-fn iterate_over_a_bunch_of_loose_and_packed_objects() -> crate::Result {
+fn iterate_over_a_bunch_of_loose_and_packed_objects() -> Result {
     let (db, _tmp) = db_with_all_object_sources()?;
     for order in all_orderings() {
         let iter = db.iter()?.with_ordering(order);
@@ -937,7 +951,7 @@ fn iterate_over_a_bunch_of_loose_and_packed_objects() -> crate::Result {
 }
 
 #[test]
-fn auto_refresh_with_and_without_id_stability() -> crate::Result {
+fn auto_refresh_with_and_without_id_stability() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     assert!(
         gix_testtools::git_command(tmp.path())
diff --git a/gix-odb/tests/odb/store/linked.rs b/gix-odb/tests/odb/store/linked.rs
index d358f515d99..6d09221329f 100644
--- a/gix-odb/tests/odb/store/linked.rs
+++ b/gix-odb/tests/odb/store/linked.rs
@@ -2,13 +2,14 @@
 //! to be sure we don't loose coverage. This might, however, be overlapping with much more thorough
 //! tests o the general store itself, so they can possibly be removed at some point.
 mod iter {
+    use crate::Result;
     use gix_odb::Header;
     use gix_pack::Find;
 
     use crate::db;
 
     #[test]
-    fn a_bunch_of_loose_and_packed_objects() -> crate::Result {
+    fn a_bunch_of_loose_and_packed_objects() -> Result {
         let db = db();
         let iter = db.iter()?;
         assert_eq!(
@@ -55,13 +56,14 @@ mod locate {
 }
 
 mod init {
+    use crate::Result;
     use gix_hash::ObjectId;
     use gix_object::Exists;
 
     use crate::{alternate::alternate, db, odb_at};
 
     #[test]
-    fn multiple_linked_repositories_via_alternates() -> crate::Result {
+    fn multiple_linked_repositories_via_alternates() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let (object_path, _linked_object_path) = alternate(tmp.path().join("a"), tmp.path().join("b"))?;
         let db = odb_at(object_path.clone())?;
@@ -74,7 +76,7 @@ mod init {
     }
 
     #[test]
-    fn a_db_without_alternates() -> crate::Result {
+    fn a_db_without_alternates() -> Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;
         let db = odb_at(tmp.path())?;
         db.exists(&ObjectId::null(gix_testtools::object_hash())); // trigger load
diff --git a/gix-odb/tests/odb/store/loose.rs b/gix-odb/tests/odb/store/loose.rs
index 36065f3744d..001207f99e0 100644
--- a/gix-odb/tests/odb/store/loose.rs
+++ b/gix-odb/tests/odb/store/loose.rs
@@ -44,7 +44,7 @@ pub fn object_ids() -> Vec<gix_hash::ObjectId> {
 
 #[test]
 fn iter() {
-    let mut oids = ldb().iter().map(Result::unwrap).collect::<Vec<_>>();
+    let mut oids = ldb().iter().map(std::result::Result::unwrap).collect::<Vec<_>>();
     oids.sort();
     assert_eq!(oids, object_ids());
 }
@@ -57,18 +57,62 @@ fn verify_integrity() {
     let db = ldb();
     let outcome = db
         .verify_integrity(&mut progress::Discard, &AtomicBool::new(false))
-        .unwrap();
-    assert_eq!(outcome.num_objects, 7);
+        .expect("fixture objects pass integrity checks");
+    assert_eq!(outcome.num_objects, 7, "all loose fixture objects were verified");
+    let err = db
+        .verify_integrity(&mut progress::Discard, &AtomicBool::new(true))
+        .expect_err("verification was interrupted")
+        .into_error();
+    assert!(
+        err.is_retryable() && err.can_retry(),
+        "interrupted verification can be retried"
+    );
+    let io_error = err
+        .downcast_any_ref::<std::io::Error>()
+        .expect("verification preserves the typed I/O interruption");
+    insta::assert_debug_snapshot!(io_error, "verification retains the interruption kind", @"
+    Kind(
+        Interrupted,
+    )
+    ");
+    assert_eq!(
+        io_error.kind(),
+        std::io::ErrorKind::Interrupted,
+        "verification retains the interruption kind"
+    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "verification retains the original I/O diagnostic", @"
+    Kind(
+        Interrupted,
+    )
+    ");
+    assert!(
+        err.downcast_any_ref::<gix_error::ClassificationMarker>().is_none(),
+        "classification markers are not diagnostic errors"
+    );
+    assert_eq!(
+        err.iter_errors().count(),
+        1,
+        "the I/O interruption is the only diagnostic"
+    );
+    assert_eq!(err.metadata().count(), 0, "real I/O errors need no generic replacement");
+    assert!(
+        err.classify().any(|classification| {
+            classification.class() == gix_error::Class::Retryable
+                && classification.error().is::<gix_error::ClassificationMarker>()
+        }),
+        "a marker still supplies retryability around the real I/O error"
+    );
 }
 
 mod write {
+    use crate::Result;
     use gix_object::Write;
     use gix_odb::loose;
 
     use crate::store::loose::{ldb_at, ldb_at_opts, locate_oid, object_ids};
 
     #[test]
-    fn compression_level_is_respected() -> crate::Result {
+    fn compression_level_is_respected() -> Result {
         use gix_zlib::Compression;
         let data: Vec<u8> = (0..64 * 1024).map(|i| (i % 100) as u8).collect();
         let mut sizes = Vec::new();
@@ -100,7 +144,7 @@ mod write {
     }
 
     #[test]
-    fn read_and_write() -> crate::Result {
+    fn read_and_write() -> Result {
         let dir = gix_testtools::tempfile::tempdir()?;
         let db = ldb_at(dir.path());
         let mut buf = Vec::new();
@@ -139,7 +183,7 @@ mod write {
 
     #[test]
     #[cfg(unix)]
-    fn it_writes_objects_with_similar_permissions() -> crate::Result {
+    fn it_writes_objects_with_similar_permissions() -> Result {
         let object_hash = gix_testtools::object_hash();
         let git_store = loose::Store::at(
             crate::scripted_fixture_read_only("repo_with_loose_objects.sh")?.join(".git/objects"),
@@ -162,7 +206,7 @@ mod write {
     }
 
     #[test]
-    fn collisions_do_not_cause_failure() -> crate::Result {
+    fn collisions_do_not_cause_failure() -> Result {
         let dir = gix_testtools::tempfile::tempdir()?;
 
         fn write_empty_trees(dir: &std::path::Path) {
@@ -197,7 +241,7 @@ mod contains {
     #[test]
     fn iterable_objects_are_contained() {
         let store = ldb();
-        for oid in store.iter().map(Result::unwrap) {
+        for oid in store.iter().map(std::result::Result::unwrap) {
             assert!(store.contains(&oid));
         }
     }
@@ -266,7 +310,7 @@ mod lookup_prefix {
     fn iterable_objects_can_be_looked_up_with_varying_prefix_lengths() {
         let store = ldb();
         let hex_lengths = &[4, 7, 40];
-        for (index, oid) in store.iter().map(Result::unwrap).enumerate() {
+        for (index, oid) in store.iter().map(std::result::Result::unwrap).enumerate() {
             for mut candidates in [None, Some(HashSet::default())] {
                 let hex_len = hex_lengths[index % hex_lengths.len()];
                 let prefix = gix_hash::Prefix::new(&oid, hex_len).unwrap();
@@ -287,8 +331,9 @@ mod lookup_prefix {
 }
 
 mod find {
+    use crate::Result;
+    use gix_error::{Class, Message, MetadataValue, ResourceExhaustionKind};
     use gix_object::{BlobRef, CommitRef, Kind, TagRef, TreeRef, bstr::ByteSlice, tree::EntryKind};
-    use gix_odb::loose;
 
     use crate::{
         hex_to_id, hex_to_id_for_hash,
@@ -300,7 +345,7 @@ mod find {
     }
 
     #[test]
-    fn invalid_object_does_not_trigger_panics() -> crate::Result {
+    fn invalid_object_does_not_trigger_panics() -> Result {
         let tmp = gix_testtools::tempfile::tempdir()?;
         let base = tmp.path().join("aa");
         std::fs::create_dir(&base)?;
@@ -321,12 +366,120 @@ mod find {
         );
         assert!(db.try_find(&id, &mut buf).is_err(), "it must not panic");
         assert!(db.try_header(&id).is_err(), "it must not panic");
+        let err = db
+            .verify_integrity(
+                &mut gix_features::progress::Discard,
+                &std::sync::atomic::AtomicBool::new(false),
+            )
+            .expect_err("verification must report the invalid object");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&db.object_path(&id).to_string_lossy(), "<object-path>")]), "corrupt objects do not become valid when retried", @r#"
+        Could not read loose object during verification, "object_id"="Oid(1)"
+        |
+        └─ Could not read loose object, "path"="<object-path>"
+        |
+        └─ Empty loose object file
+        "#);
+        assert!(!err.can_retry(), "corrupt objects do not become valid when retried");
+        assert!(err.is_corrupted(), "verification preserves the original lookup error");
 
         Ok(())
     }
 
     #[test]
-    fn tag() -> Result<(), Box<dyn std::error::Error>> {
+    fn completed_object_size_is_validated_before_allocation() -> Result {
+        let mut error_snapshots = Vec::new();
+        use std::io::Write;
+
+        let tmp = gix_testtools::tempfile::tempdir()?;
+        let object_hash = gix_testtools::object_hash();
+        let db = ldb_at_opts(tmp.path(), object_hash);
+        let blob_id = object_hash.empty_blob();
+        let path = db.object_path(&blob_id);
+        std::fs::create_dir(path.parent().expect("loose objects have a parent directory"))?;
+
+        for size in [1048576, usize::MAX] {
+            let mut writer = gix_zlib::stream::deflate::Write::new(Vec::new(), gix_zlib::Compression::DEFAULT);
+            write!(writer, "blob {size}\0")?;
+            writer.flush()?;
+            std::fs::write(&path, writer.into_inner())?;
+
+            let mut buf = Vec::new();
+            let err = db
+                .try_find(&blob_id, &mut buf)
+                .expect_err("the completed stream contains no body despite its advertised size");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[
+                    (&path.to_string_lossy(), "<object-path>"),
+                    (&usize::MAX.to_string(), "<usize::MAX>"),
+                ],
+            ));
+            assert!(
+                err.is_corrupted(),
+                "a completed object with an oversized header is corrupt: {err}"
+            );
+            let sizes = err
+                .metadata()
+                .find(|context| context.contains_key("expected"))
+                .expect("the mismatch records both sizes");
+            let diagnostic = err
+                .iter_errors()
+                .filter_map(|error| error.downcast_ref::<Message>())
+                .find(|diagnostic| diagnostic.values.contains_key("expected"))
+                .expect("the size mismatch has a diagnostic");
+            assert_eq!(
+                sizes["expected"],
+                MetadataValue::from(size),
+                "the advertised size is retained"
+            );
+            assert_eq!(
+                sizes["actual"],
+                MetadataValue::U64(0),
+                "the completed stream has no body"
+            );
+            assert_eq!(
+                diagnostic.class,
+                Some(Class::Corruption),
+                "the size diagnostic supplies the class"
+            );
+            assert_eq!(
+                err.iter_errors().count(),
+                2,
+                "the mismatch and path context are the only nodes"
+            );
+            assert!(
+                err.probable_cause().is::<Message>(),
+                "no synthetic corruption source remains"
+            );
+            assert_eq!(
+                err.metadata().next().expect("the lookup records its path")["path"],
+                MetadataValue::from(path.as_path()),
+                "the native object path is retained separately from the size mismatch"
+            );
+            assert_eq!(
+                err.classify()
+                    .map(|classification| classification.class())
+                    .collect::<Vec<_>>(),
+                [Class::Corruption],
+                "the mismatch supplies exactly one corruption classification"
+            );
+            assert_eq!(buf.capacity(), 0, "invalid sizes must be rejected before allocation");
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "completed object size is validated before allocation", @r#"
+        [
+            Could not read loose object, "path"="<object-path>"
+            |
+            └─ Loose object size mismatch: invalid size of inflated loose object, "actual"=0, "expected"=1048576,
+            Could not read loose object, "path"="<object-path>"
+            |
+            └─ Loose object size mismatch: invalid size of inflated loose object, "actual"=0, "expected"=<usize::MAX>,
+        ]
+        "#);
+        Ok(())
+    }
+
+    #[test]
+    fn tag() -> Result {
         let mut buf = Vec::new();
         let o = find("722fe60ad4f0276d5a8121970b5bb9dccdad4ef9", &mut buf);
         assert_eq!(o.kind, Kind::Tag);
@@ -364,7 +517,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn commit() -> Result<(), Box<dyn std::error::Error>> {
+    fn commit() -> Result {
         let mut buf = Vec::new();
         let o = find("ffa700b4aca13b80cb6b98a078e7c96804f8e0ec", &mut buf);
         assert_eq!(o.kind, Kind::Commit);
@@ -384,7 +537,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn blob_data() -> Result<(), Box<dyn std::error::Error>> {
+    fn blob_data() -> Result {
         let mut buf = Vec::new();
         let o = find("37d4e6c5c48ba0d245164c4e10d5f41140cab980", &mut buf);
         assert_eq!(o.data.as_bstr(), b"hi there\n".as_bstr());
@@ -392,7 +545,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn blob() -> Result<(), Box<dyn std::error::Error>> {
+    fn blob() -> Result {
         let mut buf = Vec::new();
         let o = find("37d4e6c5c48ba0d245164c4e10d5f41140cab980", &mut buf);
         assert_eq!(
@@ -412,7 +565,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn blob_big() -> Result<(), Box<dyn std::error::Error>> {
+    fn blob_big() -> Result {
         let mut buf = Vec::new();
         let o = find("a706d7cd20fc8ce71489f34b50cf01011c104193", &mut buf);
         assert_eq!(
@@ -424,7 +577,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn blob_big_respects_alloc_limit_bytes() -> crate::Result {
+    fn blob_big_respects_alloc_limit_bytes() -> Result {
         let id = hex_to_id("a706d7cd20fc8ce71489f34b50cf01011c104193");
         let db = limited_ldb(1);
         let mut buf = Vec::new();
@@ -434,10 +587,162 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
             (56915, Kind::Blob),
             "header-only reads remain available"
         );
-        assert!(matches!(
-            db.try_find(&id, &mut buf),
-            Err(loose::find::Error::OutOfMemory { size: 56915 })
-        ));
+        let err = db
+            .try_find(&id, &mut buf)
+            .expect_err("the object exceeds the configured allocation limit");
+        let allocation = err
+            .metadata()
+            .find(|context| context.contains_key("size"))
+            .expect("the allocation limit retains its byte counts");
+        let diagnostic = err
+            .iter_errors()
+            .filter_map(|error| error.downcast_ref::<Message>())
+            .find(|diagnostic| diagnostic.values.contains_key("size"))
+            .expect("the allocation limit has a diagnostic");
+        assert_eq!(
+            *allocation,
+            maplit::btreemap! {
+                "limit".into() => MetadataValue::U64(1),
+                "size".into() => MetadataValue::U64(56915),
+            },
+            "allocation limits add the unsigned byte limit to the requested size"
+        );
+        assert_eq!(
+            diagnostic.class,
+            Some(Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit)),
+            "the context itself supplies the allocation-limit class"
+        );
+        assert_eq!(
+            err.iter_errors().count(),
+            2,
+            "the allocation diagnostic and lookup context are the only nodes"
+        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&db.object_path(&id).to_string_lossy(), "<object-path>")]), "the allocation limit retains the lookup context and requested byte count", @r#"
+        Could not read loose object, "path"="<object-path>"
+        |
+        └─ Cannot store loose object in memory: the object exceeds the configured allocation limit, "limit"=1, "size"=56915
+        "#);
+        assert!(
+            err.probable_cause().is::<Message>(),
+            "no synthetic resource-exhaustion cause remains"
+        );
+        assert_eq!(
+            err.metadata().next().expect("the lookup records its path")["path"],
+            MetadataValue::from(db.object_path(&id)),
+            "the native object path remains separate from allocation details"
+        );
+        assert_eq!(
+            err.classify()
+                .map(|classification| classification.class())
+                .collect::<Vec<_>>(),
+            [gix_error::Class::ResourceExhaustion(
+                gix_error::ResourceExhaustionKind::AllocationLimit
+            )],
+            "configured limits are classified only as resource exhaustion"
+        );
+        assert!(!err.is_corrupted(), "an allocation limit does not establish corruption");
+        assert!(!err.can_retry(), "retrying does not change the configured limit");
+        Ok(())
+    }
+
+    #[test]
+    fn unrepresentable_allocation_preserves_the_original_cause() -> Result {
+        use std::io::Write;
+
+        let tmp = gix_testtools::tempfile::tempdir()?;
+        let object_hash = gix_testtools::object_hash();
+        let db = ldb_at_opts(tmp.path(), object_hash);
+        let blob_id = object_hash.empty_blob();
+        let path = db.object_path(&blob_id);
+        std::fs::create_dir(path.parent().expect("loose objects have a parent directory"))?;
+        let size = u64::MAX;
+        let mut writer = gix_zlib::stream::deflate::Write::new(Vec::new(), gix_zlib::Compression::DEFAULT);
+        write!(writer, "blob {size}\0")?;
+        // Fill the initial header buffer so inflation is incomplete and allocation is attempted.
+        // The size fails usize conversion on 32-bit targets and Vec capacity checks on 64-bit targets.
+        writer.write_all(&[0; 64])?;
+        writer.flush()?;
+        std::fs::write(&path, writer.into_inner())?;
+
+        let mut buf = Vec::new();
+        let err = db
+            .try_find(&blob_id, &mut buf)
+            .expect_err("the advertised allocation cannot be represented");
+        assert!(
+            err.is_resource_exhausted(),
+            "unrepresentable allocations are resource exhaustion"
+        );
+        assert_eq!(
+            err.iter_errors().count(),
+            3,
+            "only path context, allocation context, and the real cause remain"
+        );
+        assert_eq!(
+            err.classify()
+                .map(|classification| classification.class())
+                .collect::<Vec<_>>(),
+            [Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure)],
+            "both integer conversion and reservation failures retain their allocation-failure class"
+        );
+        let allocation = err
+            .metadata()
+            .find(|context| context.contains_key("size"))
+            .expect("the failed allocation records its requested size");
+        let diagnostic = err
+            .iter_errors()
+            .filter_map(|error| error.downcast_ref::<Message>())
+            .find(|diagnostic| diagnostic.values.contains_key("size"))
+            .expect("the failed allocation has a diagnostic");
+        assert_eq!(
+            allocation["size"],
+            MetadataValue::U64(size),
+            "the full unrepresentable size is retained"
+        );
+        if usize::try_from(size).is_err() {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&path.to_string_lossy(), "<object-path>")]), "unrepresentable sizes retain the failed integer conversion", @r#"
+            Could not read loose object, "path"="<object-path>"
+            |
+            └─ Cannot store loose object in memory: the object size cannot be represented in memory, "size"=18446744073709551615
+            |
+            └─ out of range integral type conversion attempted
+            "#);
+            assert!(
+                err.probable_cause().is::<std::num::TryFromIntError>(),
+                "the actual integer-conversion error remains the cause"
+            );
+            assert_eq!(
+                diagnostic.class,
+                Some(Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure)),
+                "the generic context classifies the unrepresentable object size"
+            );
+        } else {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&path.to_string_lossy(), "<object-path>")]), "impossible allocations retain the failed capacity reservation", @r#"
+            Could not read loose object, "path"="<object-path>"
+            |
+            └─ Cannot store loose object in memory, "size"=18446744073709551615
+            |
+            └─ memory allocation failed because the computed capacity exceeded the collection's maximum
+            "#);
+            assert!(
+                err.probable_cause().is::<std::collections::TryReserveError>(),
+                "the actual capacity error remains the cause"
+            );
+            assert_eq!(
+                diagnostic.class, None,
+                "the real reservation error supplies its own classification"
+            );
+        }
+        assert_eq!(
+            err.metadata().next().expect("the lookup records its path")["path"],
+            MetadataValue::from(path.as_path()),
+            "the object path is retained separately from allocation details"
+        );
+        assert_eq!(err.metadata().count(), 2, "only the two caller contexts carry metadata");
+        assert!(
+            !err.is_corrupted() && !err.can_retry(),
+            "an unrepresentable allocation cannot be repaired by retrying"
+        );
+        assert_eq!(buf.capacity(), 0, "the test must not attempt an actual huge allocation");
         Ok(())
     }
 
@@ -450,7 +755,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     #[test]
-    fn tree() -> Result<(), Box<dyn std::error::Error>> {
+    fn tree() -> Result {
         let mut buf = Vec::new();
         let o = find("6ba2a0ded519f737fd5b8d5ccfb141125ef3176f", &mut buf);
         assert_eq!(o.kind, Kind::Tree);
@@ -479,10 +784,11 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 
     mod header {
+        use crate::Result;
         use crate::{hex_to_id, store::loose::ldb};
 
         #[test]
-        fn existing() -> crate::Result {
+        fn existing() -> Result {
             let db = ldb();
             assert_eq!(
                 db.try_header(&hex_to_id("a706d7cd20fc8ce71489f34b50cf01011c104193"))?
@@ -493,7 +799,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
         }
 
         #[test]
-        fn non_existing() -> crate::Result {
+        fn non_existing() -> Result {
             let db = ldb();
             assert_eq!(
                 db.try_header(&hex_to_id("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))?,
@@ -504,7 +810,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
         }
 
         #[test]
-        fn all() -> crate::Result {
+        fn all() -> Result {
             let db = ldb();
             let mut buf = Vec::new();
             for id in db.iter() {
diff --git a/gix-pack/Cargo.toml b/gix-pack/Cargo.toml
index 309520da6fe..742300bae7f 100644
--- a/gix-pack/Cargo.toml
+++ b/gix-pack/Cargo.toml
@@ -61,7 +61,6 @@ gix-diff = { version = "^0.67.1", path = "../gix-diff", default-features = false
 memmap2 = "0.9.11"
 smallvec = "1.15.1"
 parking_lot = { version = "0.12.4", default-features = false, optional = true }
-thiserror = "2.0.18"
 crossbeam-deque = { version = "0.8.6", optional = true }
 
 # for caching
diff --git a/gix-pack/src/bundle/find.rs b/gix-pack/src/bundle/find.rs
index d8f38f321e9..f1cdbd0fdd6 100644
--- a/gix-pack/src/bundle/find.rs
+++ b/gix-pack/src/bundle/find.rs
@@ -1,3 +1,5 @@
+use gix_error::{ExnResult, ResultExt};
+
 impl crate::Bundle {
     /// Find an object with the given [`ObjectId`](gix_hash::ObjectId) and place its data into `out`.
     /// `inflate` is used to decompress objects, and will be reset before first use, but not after the last use.
@@ -12,7 +14,7 @@ impl crate::Bundle {
         out: &'a mut Vec<u8>,
         inflate: &mut gix_zlib::Inflate,
         cache: &mut dyn crate::cache::DecodeEntry,
-    ) -> Result<Option<(gix_object::Data<'a>, crate::data::entry::Location)>, crate::data::decode::Error> {
+    ) -> ExnResult<Option<(gix_object::Data<'a>, crate::data::entry::Location)>> {
         let idx = match self.index.lookup(id) {
             Some(idx) => idx,
             None => return Ok(None),
@@ -33,9 +35,9 @@ impl crate::Bundle {
         out: &'a mut Vec<u8>,
         inflate: &mut gix_zlib::Inflate,
         cache: &mut dyn crate::cache::DecodeEntry,
-    ) -> Result<(gix_object::Data<'a>, crate::data::entry::Location), crate::data::decode::Error> {
+    ) -> ExnResult<(gix_object::Data<'a>, crate::data::entry::Location)> {
         let ofs = self.index.pack_offset_at_index(idx);
-        let pack_entry = self.pack.entry(ofs)?;
+        let pack_entry = self.pack.entry(ofs).or_erased()?;
         let header_size = pack_entry.header_size();
         self.pack
             .decode_entry(
diff --git a/gix-pack/src/bundle/init.rs b/gix-pack/src/bundle/init.rs
index a06c9e0d32b..0fb92da94c9 100644
--- a/gix-pack/src/bundle/init.rs
+++ b/gix-pack/src/bundle/init.rs
@@ -1,18 +1,8 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
-use crate::Bundle;
+use gix_error::{ErrorExt, ExnResult, OptionExt};
 
-/// Returned by [`Bundle::at()`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("An 'idx' extension is expected of an index file: '{0}'")]
-    InvalidPath(PathBuf),
-    #[error(transparent)]
-    Pack(#[from] crate::data::header::decode::Error),
-    #[error(transparent)]
-    Index(#[from] crate::index::init::Error),
-}
+use crate::Bundle;
 
 /// Initialization
 impl Bundle {
@@ -22,15 +12,20 @@ impl Bundle {
     ///
     /// The `object_hash` is a way to read (and write) the same file format with different hashes, as the hash kind
     /// isn't stored within the file format itself.
-    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         Self::at_inner(path.as_ref(), object_hash)
     }
 
-    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         let ext = path
             .extension()
             .and_then(std::ffi::OsStr::to_str)
-            .ok_or_else(|| Error::InvalidPath(path.to_owned()))?;
+            .ok_or_raise_erased(|| {
+                gix_error::validation(format!(
+                    "An 'idx' extension is expected of an index file: '{}'",
+                    path.display()
+                ))
+            })?;
         Ok(match ext {
             "idx" => Self {
                 index: crate::index::File::at(path, object_hash)?,
@@ -40,7 +35,13 @@ impl Bundle {
                 pack: crate::data::File::at(path, object_hash)?,
                 index: crate::index::File::at(path.with_extension("idx"), object_hash)?,
             },
-            _ => return Err(Error::InvalidPath(path.to_owned())),
+            _ => {
+                return Err(gix_error::validation(format!(
+                    "An 'idx' extension is expected of an index file: '{}'",
+                    path.display()
+                ))
+                .raise_erased());
+            }
         })
     }
 }
diff --git a/gix-pack/src/bundle/mod.rs b/gix-pack/src/bundle/mod.rs
index d8ef1107d70..f7108d0cd72 100644
--- a/gix-pack/src/bundle/mod.rs
+++ b/gix-pack/src/bundle/mod.rs
@@ -10,6 +10,8 @@ pub mod write;
 pub mod verify {
     use std::sync::atomic::AtomicBool;
 
+    use gix_error::ExnResult;
+
     use gix_features::progress::DynNestedProgress;
 
     ///
@@ -33,7 +35,7 @@ pub mod verify {
             progress: &mut dyn DynNestedProgress,
             should_interrupt: &AtomicBool,
             options: crate::index::verify::integrity::Options<F>,
-        ) -> Result<integrity::Outcome, crate::index::traverse::Error<crate::index::verify::integrity::Error>>
+        ) -> ExnResult<integrity::Outcome>
         where
             C: crate::cache::DecodeEntry,
             F: Fn() -> C + Send + Clone,
diff --git a/gix-pack/src/bundle/write/error.rs b/gix-pack/src/bundle/write/error.rs
deleted file mode 100644
index da44181bb4f..00000000000
--- a/gix-pack/src/bundle/write/error.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use std::io;
-
-use gix_tempfile::handle::Writable;
-
-/// The error returned by [`Bundle::write_to_directory()`][crate::Bundle::write_to_directory()]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("An IO error occurred when reading the pack or creating a temporary file")]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    PackIter(#[from] crate::data::input::Error),
-    #[error("Could not move a temporary file into its desired place")]
-    Persist(#[from] gix_tempfile::handle::persist::Error<Writable>),
-    #[error(transparent)]
-    IndexWrite(#[from] crate::index::write::Error),
-}
diff --git a/gix-pack/src/bundle/write/mod.rs b/gix-pack/src/bundle/write/mod.rs
index a50da98b3df..3a81d7fc2b7 100644
--- a/gix-pack/src/bundle/write/mod.rs
+++ b/gix-pack/src/bundle/write/mod.rs
@@ -6,13 +6,12 @@ use std::{
     sync::{Arc, atomic::AtomicBool},
 };
 
+use gix_error::{ExnResult, ResultExt, message};
 use gix_features::{interrupt, progress, progress::Progress};
 use gix_tempfile::{AutoRemove, ContainingDirectory};
 
 use crate::data;
 
-mod error;
-pub use error::Error;
 use gix_features::progress::prodash::DynNestedProgress;
 
 mod types;
@@ -68,7 +67,7 @@ impl crate::Bundle {
         thin_pack_base_object_lookup: Option<impl gix_object::Find>,
         object_hash: gix_hash::Kind,
         options: Options,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         let _span = gix_features::trace::coarse!("gix_pack::Bundle::write_to_directory()");
         let mut read_progress = progress.add_child_with_id("read pack".into(), ProgressId::ReadPackBytes.into());
         read_progress.init(None, progress::bytes());
@@ -80,64 +79,64 @@ impl crate::Bundle {
         let data_file = Arc::new(parking_lot::Mutex::new(io::BufWriter::with_capacity(
             64 * 1024,
             match directory.as_ref() {
-                Some(directory) => gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)?,
-                None => gix_tempfile::new(std::env::temp_dir(), ContainingDirectory::Exists, AutoRemove::Tempfile)?,
+                Some(directory) => gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)
+                    .or_raise_erased(|| message("Could not create temporary pack file"))?,
+                None => gix_tempfile::new(std::env::temp_dir(), ContainingDirectory::Exists, AutoRemove::Tempfile)
+                    .or_raise_erased(|| message("Could not create temporary pack file"))?,
             },
         )));
-        let (pack_entries_iter, pack_version): (
-            Box<dyn Iterator<Item = Result<data::input::Entry, data::input::Error>>>,
-            _,
-        ) = match thin_pack_base_object_lookup {
-            Some(thin_pack_lookup) => {
-                let pack = interrupt::Read {
-                    inner: pack,
-                    should_interrupt,
-                };
-                let buffered_pack = io::BufReader::new(pack);
-                let pack_entries_iter = data::input::LookupRefDeltaObjectsIter::new(
-                    data::input::BytesToEntriesIter::new_from_header(
+        let (pack_entries_iter, pack_version): (Box<dyn Iterator<Item = ExnResult<data::input::Entry>>>, _) =
+            match thin_pack_base_object_lookup {
+                Some(thin_pack_lookup) => {
+                    let pack = interrupt::Read {
+                        inner: pack,
+                        should_interrupt,
+                    };
+                    let buffered_pack = io::BufReader::new(pack);
+                    let pack_entries_iter = data::input::LookupRefDeltaObjectsIter::new(
+                        data::input::BytesToEntriesIter::new_from_header(
+                            buffered_pack,
+                            options.iteration_mode,
+                            data::input::EntryDataMode::KeepAndCrc32,
+                            object_hash,
+                        )?,
+                        thin_pack_lookup,
+                        options.compression,
+                    );
+                    let pack_version = pack_entries_iter.inner.version();
+                    let pack_entries_iter = data::input::EntriesToBytesIter::new(
+                        pack_entries_iter,
+                        LockWriter {
+                            writer: data_file.clone(),
+                        },
+                        pack_version,
+                        object_hash,
+                    );
+                    (Box::new(pack_entries_iter), pack_version)
+                }
+                None => {
+                    let pack = PassThrough {
+                        reader: interrupt::Read {
+                            inner: pack,
+                            should_interrupt,
+                        },
+                        writer: Some(data_file.clone()),
+                    };
+                    // This buf-reader is required to assure we call 'read()' in order to fill the (extra) buffer. Otherwise all the counting
+                    // we do with the wrapped pack reader doesn't work as it does not expect anyone to call BufRead functions directly.
+                    // However, this is exactly what's happening in the ZipReader implementation that is eventually used.
+                    // The performance impact of this is probably negligible, compared to all the other work that is done anyway :D.
+                    let buffered_pack = io::BufReader::new(pack);
+                    let pack_entries_iter = data::input::BytesToEntriesIter::new_from_header(
                         buffered_pack,
                         options.iteration_mode,
-                        data::input::EntryDataMode::KeepAndCrc32,
+                        data::input::EntryDataMode::Crc32,
                         object_hash,
-                    )?,
-                    thin_pack_lookup,
-                    options.compression,
-                );
-                let pack_version = pack_entries_iter.inner.version();
-                let pack_entries_iter = data::input::EntriesToBytesIter::new(
-                    pack_entries_iter,
-                    LockWriter {
-                        writer: data_file.clone(),
-                    },
-                    pack_version,
-                    object_hash,
-                );
-                (Box::new(pack_entries_iter), pack_version)
-            }
-            None => {
-                let pack = PassThrough {
-                    reader: interrupt::Read {
-                        inner: pack,
-                        should_interrupt,
-                    },
-                    writer: Some(data_file.clone()),
-                };
-                // This buf-reader is required to assure we call 'read()' in order to fill the (extra) buffer. Otherwise all the counting
-                // we do with the wrapped pack reader doesn't work as it does not expect anyone to call BufRead functions directly.
-                // However, this is exactly what's happening in the ZipReader implementation that is eventually used.
-                // The performance impact of this is probably negligible, compared to all the other work that is done anyway :D.
-                let buffered_pack = io::BufReader::new(pack);
-                let pack_entries_iter = data::input::BytesToEntriesIter::new_from_header(
-                    buffered_pack,
-                    options.iteration_mode,
-                    data::input::EntryDataMode::Crc32,
-                    object_hash,
-                )?;
-                let pack_version = pack_entries_iter.version();
-                (Box::new(pack_entries_iter), pack_version)
-            }
-        };
+                    )?;
+                    let pack_version = pack_entries_iter.version();
+                    (Box::new(pack_entries_iter), pack_version)
+                }
+            };
         let WriteOutcome {
             outcome,
             data_path,
@@ -181,7 +180,7 @@ impl crate::Bundle {
         thin_pack_base_object_lookup: Option<impl gix_object::Find + Send + 'static>,
         object_hash: gix_hash::Kind,
         options: Options,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         let _span = gix_features::trace::coarse!("gix_pack::Bundle::write_to_directory_eagerly()");
         let mut read_progress = progress.add_child_with_id("read pack".into(), ProgressId::ReadPackBytes.into()); /* Bundle Write Read pack Bytes*/
         read_progress.init(pack_size.map(|s| s as usize), progress::bytes());
@@ -191,12 +190,14 @@ impl crate::Bundle {
         };
 
         let data_file = Arc::new(parking_lot::Mutex::new(io::BufWriter::new(match directory.as_ref() {
-            Some(directory) => gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)?,
-            None => gix_tempfile::new(std::env::temp_dir(), ContainingDirectory::Exists, AutoRemove::Tempfile)?,
+            Some(directory) => gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)
+                .or_raise_erased(|| message("Could not create temporary pack file"))?,
+            None => gix_tempfile::new(std::env::temp_dir(), ContainingDirectory::Exists, AutoRemove::Tempfile)
+                .or_raise_erased(|| message("Could not create temporary pack file"))?,
         })));
         let eight_pages = 4096 * 8;
         let (pack_entries_iter, pack_version): (
-            Box<dyn Iterator<Item = Result<data::input::Entry, data::input::Error>> + Send + 'static>,
+            Box<dyn Iterator<Item = ExnResult<data::input::Entry>> + Send + 'static>,
             _,
         ) = match thin_pack_base_object_lookup {
             Some(thin_pack_lookup) => {
@@ -280,10 +281,10 @@ impl crate::Bundle {
             compression: _,
         }: Options,
         data_file: SharedTempFile,
-        mut pack_entries_iter: Box<dyn Iterator<Item = Result<data::input::Entry, data::input::Error>> + 'a>,
+        mut pack_entries_iter: Box<dyn Iterator<Item = ExnResult<data::input::Entry>> + 'a>,
         should_interrupt: &AtomicBool,
         pack_version: data::Version,
-    ) -> Result<WriteOutcome, Error> {
+    ) -> ExnResult<WriteOutcome> {
         let mut indexing_progress = progress.add_child_with_id(
             "create index file".into(),
             ProgressId::IndexingSteps(Default::default()).into(),
@@ -291,7 +292,8 @@ impl crate::Bundle {
         Ok(match directory {
             Some(directory) => {
                 let directory = directory.as_ref();
-                let mut index_file = gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)?;
+                let mut index_file = gix_tempfile::new(directory, ContainingDirectory::Exists, AutoRemove::Tempfile)
+                    .or_raise_erased(|| message("Could not create temporary index file"))?;
 
                 let outcome = crate::index::write_data_iter_to_stream(
                     index_kind,
@@ -327,13 +329,15 @@ impl crate::Bundle {
                     } else {
                         let keep_path = data_path.with_extension("keep");
 
-                        std::fs::write(&keep_path, b"")?;
+                        std::fs::write(&keep_path, b"")
+                            .or_raise_erased(|| message("Could not create pack keep file"))?;
                         Arc::try_unwrap(data_file)
                             .expect("only one handle left after pack was consumed")
                             .into_inner()
                             .into_inner()
-                            .map_err(|err| Error::from(err.into_error()))?
-                            .persist(&data_path)?;
+                            .or_erased()?
+                            .persist(&data_path)
+                            .or_raise_erased(|| message("Could not persist pack file"))?;
                         Some(keep_path)
                     };
                     if !index_path.is_file() {
@@ -341,7 +345,8 @@ impl crate::Bundle {
                             .persist(&index_path)
                             .inspect_err(|_err| {
                                 gix_features::trace::warn!("pack file at \"{}\" is retained despite failing to move the index file into place. You can use plumbing to make it usable.",data_path.display());
-                            })?;
+                            })
+                            .or_raise_erased(|| message("Could not persist pack index"))?;
                     }
                     WriteOutcome {
                         outcome,
diff --git a/gix-pack/src/bundle/write/types.rs b/gix-pack/src/bundle/write/types.rs
index 0f9ac285489..b19b995a5b8 100644
--- a/gix-pack/src/bundle/write/types.rs
+++ b/gix-pack/src/bundle/write/types.rs
@@ -1,5 +1,7 @@
 use std::{hash::Hash, io, io::SeekFrom, path::PathBuf, sync::Arc};
 
+use gix_error::ExnResult;
+
 use gix_tempfile::handle::Writable;
 
 /// Configuration for [`write_to_directory`][crate::Bundle::write_to_directory()] or
@@ -64,7 +66,7 @@ pub struct Outcome {
 
 impl Outcome {
     /// Instantiate a bundle from the newly written index and data file that are represented by this `Outcome`
-    pub fn to_bundle(&self) -> Option<Result<crate::Bundle, crate::bundle::init::Error>> {
+    pub fn to_bundle(&self) -> Option<ExnResult<crate::Bundle>> {
         self.index_path
             .as_ref()
             .map(|path| crate::Bundle::at(path, self.object_hash))
diff --git a/gix-pack/src/cache/delta/from_offsets.rs b/gix-pack/src/cache/delta/from_offsets.rs
index 773fa3994c2..b7956cdeede 100644
--- a/gix-pack/src/cache/delta/from_offsets.rs
+++ b/gix-pack/src/cache/delta/from_offsets.rs
@@ -5,26 +5,11 @@ use std::{
     time::Instant,
 };
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message, retryable};
 use gix_features::progress::{self, Progress};
 
 use crate::{cache::delta::Tree, data};
 
-/// Returned by [`Tree::from_offsets_in_pack()`]
-#[derive(thiserror::Error, Debug)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("{message}")]
-    Io { source: io::Error, message: &'static str },
-    #[error(transparent)]
-    Header(#[from] crate::data::header::decode::Error),
-    #[error("Could find object with id {id} in this pack. Thin packs are not supported")]
-    UnresolvedRefDelta { id: gix_hash::ObjectId },
-    #[error(transparent)]
-    Tree(#[from] crate::cache::delta::Error),
-    #[error("Interrupted")]
-    Interrupted,
-}
-
 /// Generate tree from certain input
 impl<T> Tree<T> {
     /// Create a new `Tree` from any data sorted by offset, ascending as returned by the `data_sorted_by_offsets` iterator.
@@ -46,13 +31,10 @@ impl<T> Tree<T> {
         progress: &mut dyn Progress,
         should_interrupt: &AtomicBool,
         object_hash: gix_hash::Kind,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         let mut r = io::BufReader::with_capacity(
             8192 * 8, // this value directly corresponds to performance, 8k (default) is about 4x slower than 64k
-            fs::File::open(pack_path).map_err(|err| Error::Io {
-                source: err,
-                message: "open pack path",
-            })?,
+            fs::File::open(pack_path).or_raise_erased(|| message("open pack path"))?,
         );
 
         let anticipated_num_objects = data_sorted_by_offsets
@@ -67,9 +49,8 @@ impl<T> Tree<T> {
         {
             // safety check - assure ourselves it's a pack we can handle
             let mut buf = [0u8; data::header::SIZE];
-            r.read_exact(&mut buf).map_err(|err| Error::Io {
-                source: err,
-                message: "reading header buffer with at least 12 bytes failed - pack file truncated?",
+            r.read_exact(&mut buf).or_raise_erased(|| {
+                message("reading header buffer with at least 12 bytes failed - pack file truncated?")
             })?;
             crate::data::header::decode(&buf)?;
         }
@@ -84,10 +65,8 @@ impl<T> Tree<T> {
             if let Some(previous_offset) = previous_cursor_position {
                 Self::advance_cursor_to_pack_offset(&mut r, pack_offset, previous_offset)?;
             }
-            let entry = crate::data::Entry::from_read(&mut r, pack_offset, hash_len).map_err(|err| Error::Io {
-                source: err,
-                message: "EOF while parsing header",
-            })?;
+            let entry = crate::data::Entry::from_read(&mut r, pack_offset, hash_len)
+                .or_raise_erased(|| message("EOF while parsing header"))?;
             previous_cursor_position = Some(pack_offset + entry.header_size() as u64);
 
             use crate::data::entry::Header::*;
@@ -96,32 +75,29 @@ impl<T> Tree<T> {
                     tree.add_root(pack_offset, data)?;
                 }
                 RefDelta { base_id } => {
-                    resolve_in_pack_id(base_id.as_ref())
-                        .ok_or(Error::UnresolvedRefDelta { id: base_id })
-                        .and_then(|base_pack_offset| {
-                            tree.add_child(base_pack_offset, pack_offset, data).map_err(Into::into)
-                        })?;
+                    let base_pack_offset = resolve_in_pack_id(base_id.as_ref()).ok_or_else(|| {
+                        gix_error::not_found(format!(
+                            "Could find object with id {base_id} in this pack. Thin packs are not supported"
+                        ))
+                        .raise_erased()
+                    })?;
+                    tree.add_child(base_pack_offset, pack_offset, data)?;
                 }
                 OfsDelta { base_distance } => {
                     let Some(base_pack_offset) =
                         crate::data::entry::Header::verified_base_pack_offset(pack_offset, base_distance)
                     else {
-                        return Err(Error::Io {
-                            source: io::Error::new(
-                                io::ErrorKind::InvalidData,
-                                format!(
-                                    "OFS_DELTA base distance {base_distance} is invalid for pack offset {pack_offset}"
-                                ),
-                            ),
-                            message: "invalid OFS_DELTA base distance",
-                        });
+                        return Err(gix_error::corruption(format!(
+                            "OFS_DELTA base distance {base_distance} is invalid for pack offset {pack_offset}"
+                        ))
+                        .raise_erased());
                     };
                     tree.add_child(base_pack_offset, pack_offset, data)?;
                 }
             }
             progress.inc();
             if idx % 10_000 == 0 && should_interrupt.load(Ordering::SeqCst) {
-                return Err(Error::Interrupted);
+                return Err(retryable("Interrupted").raise_erased());
             }
         }
 
@@ -133,36 +109,30 @@ impl<T> Tree<T> {
         r: &mut io::BufReader<fs::File>,
         pack_offset: u64,
         previous_offset: u64,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         let bytes_to_skip: u64 = pack_offset
             .checked_sub(previous_offset)
             .expect("continuously ascending pack offsets");
         if bytes_to_skip == 0 {
             return Ok(());
         }
-        let buf = r.fill_buf().map_err(|err| Error::Io {
-            source: err,
-            message: "skip bytes",
-        })?;
+        let buf = r.fill_buf().or_raise_erased(|| message("skip bytes"))?;
         if buf.is_empty() {
             // This means we have reached the end of file and can't make progress anymore, before we have satisfied our need
             // for more
-            return Err(Error::Io {
-                source: io::Error::new(
-                    io::ErrorKind::UnexpectedEof,
-                    "ran out of bytes before reading desired amount of bytes",
-                ),
-                message: "index file is damaged or corrupt",
-            });
+            return Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "ran out of bytes before reading desired amount of bytes",
+            )
+            .and_raise(message("index file is damaged or corrupt"))
+            .erased());
         }
         if bytes_to_skip <= u64::try_from(buf.len()).expect("sensible buffer size") {
             // SAFETY: bytes_to_skip <= buf.len() <= usize::MAX
             r.consume(bytes_to_skip as usize);
         } else {
-            r.seek(SeekFrom::Start(pack_offset)).map_err(|err| Error::Io {
-                source: err,
-                message: "seek to next entry",
-            })?;
+            r.seek(SeekFrom::Start(pack_offset))
+                .or_raise_erased(|| message("seek to next entry"))?;
         }
         Ok(())
     }
diff --git a/gix-pack/src/cache/delta/mod.rs b/gix-pack/src/cache/delta/mod.rs
index 2d43846f557..ddff48657a2 100644
--- a/gix-pack/src/cache/delta/mod.rs
+++ b/gix-pack/src/cache/delta/mod.rs
@@ -1,25 +1,3 @@
-/// Returned when using various methods on a [`Tree`]
-#[derive(thiserror::Error, Debug)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("The pack delta tree is too large to fit in memory")]
-    OutOfMemory,
-    #[error(
-        "Pack offsets must only increment. The previous pack offset was {last_pack_offset}, the current one is {pack_offset}"
-    )]
-    InvariantIncreasingPackOffset {
-        /// The last seen pack offset
-        last_pack_offset: crate::data::Offset,
-        /// The invariant violating offset
-        pack_offset: crate::data::Offset,
-    },
-}
-
-impl From<std::collections::TryReserveError> for Error {
-    fn from(_: std::collections::TryReserveError) -> Self {
-        Error::OutOfMemory
-    }
-}
 ///
 /// A tree that allows one-time iteration over all nodes and their children, consuming it in the process,
 /// while being shareable among threads without a lock.
diff --git a/gix-pack/src/cache/delta/traverse/mod.rs b/gix-pack/src/cache/delta/traverse/mod.rs
index c41b9043202..e66f458210f 100644
--- a/gix-pack/src/cache/delta/traverse/mod.rs
+++ b/gix-pack/src/cache/delta/traverse/mod.rs
@@ -1,5 +1,6 @@
-use std::{collections::TryReserveError, sync::atomic::AtomicBool};
+use std::sync::atomic::AtomicBool;
 
+use gix_error::{ErrorExt, ExnResult, retryable};
 use gix_features::{
     progress::{self, DynNestedProgress, Progress},
     threading,
@@ -17,50 +18,13 @@ pub(crate) mod util;
 /// Shared access to ref-delta child indices awaiting a resolved base, keyed by its object ID.
 pub(super) type SharedRefDeltaChildren = OwnShared<Mutable<super::tree::RefDeltaChildren>>;
 
-/// Returned by [`Tree::traverse()`]
-#[derive(thiserror::Error, Debug)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("{message}")]
-    ZlibInflate {
-        source: gix_error::Error,
-        message: &'static str,
-    },
-    #[error("The resolver failed to obtain the pack entry bytes for the entry at {pack_offset}")]
-    ResolveFailed { pack_offset: u64 },
-    #[error(transparent)]
-    EntryType(#[from] crate::data::entry::decode::Error),
-    #[error("One of the object inspectors failed")]
-    Inspect(#[from] Box<dyn std::error::Error + Send + Sync>),
-    #[error("Interrupted")]
-    Interrupted,
-    #[error("Entry too large to fit in memory")]
-    OutOfMemory,
-    #[error(
-        "The base at {base_pack_offset} was referred to by a ref-delta, but it was never added to the tree as if the pack was still thin."
-    )]
-    OutOfPackRefDelta {
-        /// The base's offset which was from a resolved ref-delta that didn't actually get added to the tree
-        base_pack_offset: crate::data::Offset,
-    },
-    #[error("The ref-delta base object {base_id} could not be found")]
-    UnresolvedRefDelta {
-        /// The id named by one or more unresolved ref-delta entries.
-        base_id: gix_hash::ObjectId,
-    },
-    #[error("Failed to hash an object while resolving in-pack ref-deltas")]
-    ObjectHash(#[from] gix_hash::hasher::Error),
-    #[error("Failed to spawn thread when switching to work-stealing mode")]
-    SpawnThread(#[from] std::io::Error),
-    #[error(transparent)]
-    Delta(#[from] crate::data::delta::apply::Error),
+#[cold]
+pub(super) fn allocation_error(kind: gix_error::ResourceExhaustionKind) -> gix_error::Exn {
+    gix_error::resource_exhaustion(kind, "Entry too large to fit in memory").raise_erased()
 }
 
-impl From<TryReserveError> for Error {
-    #[cold]
-    fn from(_: TryReserveError) -> Self {
-        Self::OutOfMemory
-    }
+pub(super) fn interrupted() -> gix_error::Exn {
+    retryable("Interrupted").raise_erased()
 }
 
 /// Additional context passed to the `inspect_object(…)` function of the [`Tree::traverse()`] method.
@@ -124,7 +88,7 @@ where
     /// This method returns a vector of all tree items, along with their potentially modified custom node data.
     ///
     /// _Note_ that this method consumed the Tree to assure safe parallel traversal with mutation support.
-    pub fn traverse<F, MBFN, E, R>(
+    pub fn traverse<F, MBFN, R>(
         mut self,
         resolve: F,
         resolve_data: &R,
@@ -138,12 +102,11 @@ where
             object_hash,
             alloc_limit_bytes,
         }: Options<'_, '_>,
-    ) -> Result<Outcome<T>, Error>
+    ) -> ExnResult<Outcome<T>>
     where
         F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send + Clone,
         R: Send + Sync,
-        MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send + Clone,
-        E: std::error::Error + Send + Sync + 'static,
+        MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send + Clone,
     {
         self.set_pack_entries_end_and_resolve_ref_offsets(pack_entries_end)?;
 
@@ -186,7 +149,9 @@ where
         if let Some(ref_delta_children) = ref_delta_children
             && let Some((base_id, _children)) = threading::lock(&ref_delta_children).first_key_value()
         {
-            return Err(Error::UnresolvedRefDelta { base_id: *base_id });
+            return Err(
+                gix_error::not_found(format!("The ref-delta base object {base_id} could not be found")).raise_erased(),
+            );
         }
 
         object_progress.show_throughput(start);
diff --git a/gix-pack/src/cache/delta/traverse/resolve.rs b/gix-pack/src/cache/delta/traverse/resolve.rs
index e0b83a2d20e..0d54cf1df26 100644
--- a/gix-pack/src/cache/delta/traverse/resolve.rs
+++ b/gix-pack/src/cache/delta/traverse/resolve.rs
@@ -1,5 +1,6 @@
 use std::sync::atomic::{AtomicBool, Ordering};
 
+use gix_error::{ErrorExt, ExnResult, ResourceExhaustionKind, ResultExt, message};
 use gix_features::{
     progress::Progress,
     threading::{self, OwnShared},
@@ -7,7 +8,7 @@ use gix_features::{
 
 use crate::{
     cache::delta::{
-        traverse::{Context, Error, util::ItemSliceSync},
+        traverse::{Context, allocation_error, interrupted, util::ItemSliceSync},
         tree::Item,
     },
     data,
@@ -74,7 +75,7 @@ fn attach_ref_delta_children<T: Send>(
     decompressed: &[u8],
     ref_delta_children: Option<&super::SharedRefDeltaChildren>,
     object_hash: gix_hash::Kind,
-) -> Result<(), Error> {
+) -> ExnResult {
     let Some(ref_delta_children) = ref_delta_children else {
         return Ok(());
     };
@@ -84,7 +85,8 @@ fn attach_ref_delta_children<T: Send>(
     }
 
     let kind = entry.header.as_kind().expect("a fully resolved object has a base kind");
-    let id = gix_object::compute_hash(object_hash, kind, decompressed)?;
+    let id = gix_object::compute_hash(object_hash, kind, decompressed)
+        .or_raise_erased(|| message("Failed to hash an object while resolving in-pack ref-deltas"))?;
     if let Some(children) = threading::lock(ref_delta_children).remove(&id) {
         node.add_children(children);
     }
@@ -127,7 +129,7 @@ struct WorkItem<'a, T: Send> {
 /// SAFETY: `items` and `child_items` must originate from the same [`crate::cache::delta::Tree`].
 #[expect(clippy::too_many_arguments, unsafe_code)]
 #[deny(unsafe_op_in_unsafe_fn)]
-pub(super) unsafe fn all<T, F, MBFN, E, R>(
+pub(super) unsafe fn all<T, F, MBFN, R>(
     items: &mut [Item<T>],
     child_items: &ItemSliceSync<'_, Item<T>>,
     thread_limit: Option<usize>,
@@ -142,13 +144,12 @@ pub(super) unsafe fn all<T, F, MBFN, E, R>(
     object_hash: gix_hash::Kind,
     alloc_limit_bytes: Option<usize>,
     should_interrupt: &AtomicBool,
-) -> Result<(), Error>
+) -> ExnResult
 where
     T: Send,
     R: Send + Sync,
     F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send + Clone,
-    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send + Clone,
-    E: std::error::Error + Send + Sync + 'static,
+    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send + Clone,
 {
     let work = items
         .iter_mut()
@@ -209,7 +210,7 @@ where
 /// node run before roots that were already waiting.
 #[cfg(not(feature = "parallel"))]
 #[expect(clippy::too_many_arguments)]
-fn resolve_serial<T, F, MBFN, E, R>(
+fn resolve_serial<T, F, MBFN, R>(
     mut work: Vec<WorkItem<'_, T>>,
     objects: gix_features::progress::StepShared,
     size: gix_features::progress::StepShared,
@@ -221,20 +222,19 @@ fn resolve_serial<T, F, MBFN, E, R>(
     object_hash: gix_hash::Kind,
     alloc_limit_bytes: Option<usize>,
     should_interrupt: &AtomicBool,
-) -> Result<(), Error>
+) -> ExnResult
 where
     T: Send,
     R: Send + Sync,
     F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send + Clone,
-    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send + Clone,
-    E: std::error::Error + Send + Sync + 'static,
+    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send + Clone,
 {
     let mut delta_bytes = Vec::new();
     let mut fully_resolved_delta_bytes = Vec::new();
     let mut inflate = gix_zlib::Inflate::default();
     while let Some(task) = work.pop() {
         if should_interrupt.load(Ordering::Relaxed) {
-            return Err(Error::Interrupted);
+            return Err(interrupted());
         }
         resolve_task(
             task,
@@ -266,7 +266,7 @@ where
 /// more descendants, and exits only when no work remains.
 #[cfg(feature = "parallel")]
 #[expect(clippy::too_many_arguments)]
-fn resolve_parallel<T, F, MBFN, E, R>(
+fn resolve_parallel<T, F, MBFN, R>(
     num_threads: usize,
     work: Vec<WorkItem<'_, T>>,
     objects: gix_features::progress::StepShared,
@@ -279,13 +279,12 @@ fn resolve_parallel<T, F, MBFN, E, R>(
     object_hash: gix_hash::Kind,
     alloc_limit_bytes: Option<usize>,
     should_interrupt: &AtomicBool,
-) -> Result<(), Error>
+) -> ExnResult
 where
     T: Send,
     R: Send + Sync,
     F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send + Clone,
-    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send + Clone,
-    E: std::error::Error + Send + Sync + 'static,
+    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send + Clone,
 {
     use std::sync::atomic::AtomicUsize;
 
@@ -328,7 +327,7 @@ where
                                 }
                                 if should_interrupt.load(Ordering::Relaxed) {
                                     abort.store(true, Ordering::Relaxed);
-                                    return Err(Error::Interrupted);
+                                    return Err(interrupted());
                                 }
                                 let Some(task) = steal(&worker, stealers, roots) else {
                                     if remaining.load(Ordering::Acquire) == 0 {
@@ -379,7 +378,9 @@ where
                             std::panic::resume_unwind(payload);
                         }
                     }
-                    return Err(Error::SpawnThread(err));
+                    return Err(err
+                        .and_raise(message("Failed to spawn thread when switching to work-stealing mode"))
+                        .erased());
                 }
             }
         }
@@ -442,7 +443,7 @@ fn steal<T>(
 /// serial traversal pushes that item onto its `Vec`, while parallel traversal pushes it onto the current worker's deque
 /// and updates the shared count of unfinished work.
 #[expect(clippy::too_many_arguments)]
-fn resolve_task<'a, T, F, MBFN, E, R>(
+fn resolve_task<'a, T, F, MBFN, R>(
     WorkItem {
         level,
         mut node,
@@ -461,13 +462,12 @@ fn resolve_task<'a, T, F, MBFN, E, R>(
     objects: &gix_features::progress::StepShared,
     size: &gix_features::progress::StepShared,
     mut push: impl FnMut(WorkItem<'a, T>),
-) -> Result<(), Error>
+) -> ExnResult
 where
     T: Send,
     R: Send + Sync,
     F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send,
-    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send,
-    E: std::error::Error + Send + Sync + 'static,
+    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send,
 {
     let is_root = parent.is_none();
     // Root buffers either become shared bases or are dropped after inspection. Keeping leaf-root allocations out of
@@ -483,22 +483,24 @@ where
             object_hash,
             alloc_limit_bytes,
         )?;
-        let (base_size, consumed) = data::delta::decode_header_size(delta_bytes)?;
+        let (base_size, consumed) = data::delta::decode_header_size(delta_bytes).or_erased()?;
         let base_size = decoded_size_limited(base_size, alloc_limit_bytes)?;
         if parent.bytes.len() != base_size {
-            return Err(data::delta::apply::Error::Corrupt {
-                message: "delta base size does not match base object size",
-            }
-            .into());
+            return Err(
+                gix_error::corruption("Corrupt delta data: delta base size does not match base object size")
+                    .raise_erased(),
+            );
         }
-        let (result_size, result_header_size) = data::delta::decode_header_size(&delta_bytes[consumed..])?;
+        let (result_size, result_header_size) =
+            data::delta::decode_header_size(&delta_bytes[consumed..]).or_erased()?;
         let result_size = decoded_size_limited(result_size, alloc_limit_bytes)?;
         resize_with_limit(fully_resolved_delta_bytes, result_size, alloc_limit_bytes)?;
         data::delta::apply(
             &parent.bytes,
             fully_resolved_delta_bytes,
             &delta_bytes[consumed + result_header_size..],
-        )?;
+        )
+        .or_erased()?;
         entry.header = parent.entry.header;
         (entry, entry_end)
     } else {
@@ -568,8 +570,8 @@ where
 ///
 /// `modify_base` receives mutable access to the node's associated data and a [`Context`] containing the parsed entry,
 /// its end offset, the resolved object bytes, and its delta-tree level. Only a successful inspection increments the
-/// object counter and the total number of resolved bytes; inspector errors abort traversal as [`Error::Inspect`].
-fn inspect<T, MBFN, E>(
+/// object counter and the total number of resolved bytes; inspector errors abort traversal.
+fn inspect<T, MBFN>(
     node: &mut Node<'_, T>,
     level: u16,
     resolved: &ResolvedBase,
@@ -577,11 +579,10 @@ fn inspect<T, MBFN, E>(
     modify_base: &mut MBFN,
     objects: &gix_features::progress::StepShared,
     size: &gix_features::progress::StepShared,
-) -> Result<(), Error>
+) -> ExnResult
 where
     T: Send,
-    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> Result<(), E> + Send,
-    E: std::error::Error + Send + Sync + 'static,
+    MBFN: FnMut(&mut T, &dyn Progress, Context<'_>) -> ExnResult + Send,
 {
     modify_base(
         node.data(),
@@ -593,7 +594,7 @@ where
             level,
         },
     )
-    .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
+    .or_raise_erased(|| message("One of the object inspectors failed"))?;
     objects.fetch_add(1, Ordering::Relaxed);
     size.fetch_add(resolved.bytes.len(), Ordering::Relaxed);
     Ok(())
@@ -611,14 +612,18 @@ fn decompress_from_resolver<F, R>(
     resolve_data: &R,
     object_hash: gix_hash::Kind,
     alloc_limit_bytes: Option<usize>,
-) -> Result<(data::Entry, u64), Error>
+) -> ExnResult<(data::Entry, u64)>
 where
     F: for<'r> Fn(EntryRange, &'r R) -> Option<&'r [u8]> + Send,
 {
-    let bytes = resolve(slice.clone(), resolve_data).ok_or(Error::ResolveFailed {
-        pack_offset: slice.start,
+    let bytes = resolve(slice.clone(), resolve_data).ok_or_else(|| {
+        gix_error::message!(
+            "The resolver failed to obtain the pack entry bytes for the entry at {}",
+            slice.start
+        )
+        .raise_erased()
     })?;
-    let entry = data::Entry::from_bytes(bytes, slice.start, object_hash)?;
+    let entry = data::Entry::from_bytes(bytes, slice.start, object_hash).or_erased()?;
     let compressed = &bytes[entry.header_size()..];
     let decompressed_len = decoded_size_limited(entry.decompressed_size, alloc_limit_bytes)?;
     decompress_all_at_once_with(inflate, compressed, decompressed_len, out, alloc_limit_bytes)?;
@@ -631,29 +636,31 @@ fn decompress_all_at_once_with(
     decompressed_len: usize,
     out: &mut Vec<u8>,
     alloc_limit_bytes: Option<usize>,
-) -> Result<(), Error> {
+) -> ExnResult {
     resize_with_limit(out, decompressed_len, alloc_limit_bytes)?;
     inflate.reset();
-    inflate.once(b, out).map_err(|err| Error::ZlibInflate {
-        source: err.into_error(),
-        message: "Failed to decompress entry",
-    })?;
+    inflate
+        .once(b, out)
+        .or_raise_erased(|| message("Failed to decompress entry"))?;
     Ok(())
 }
 
-fn decoded_size_limited(size: u64, alloc_limit_bytes: Option<usize>) -> Result<usize, Error> {
-    let size: usize = size.try_into().map_err(|_| Error::OutOfMemory)?;
+fn decoded_size_limited(size: u64, alloc_limit_bytes: Option<usize>) -> ExnResult<usize> {
+    let size: usize = size
+        .try_into()
+        .map_err(|err| allocation_error(ResourceExhaustionKind::AllocationFailure).chain(err))?;
     if alloc_limit_bytes.is_some_and(|limit| size > limit) {
-        return Err(Error::OutOfMemory);
+        return Err(allocation_error(ResourceExhaustionKind::AllocationLimit));
     }
     Ok(size)
 }
 
-fn resize_with_limit(out: &mut Vec<u8>, len: usize, alloc_limit_bytes: Option<usize>) -> Result<(), Error> {
+fn resize_with_limit(out: &mut Vec<u8>, len: usize, alloc_limit_bytes: Option<usize>) -> ExnResult {
     if alloc_limit_bytes.is_some_and(|limit| len > limit) {
-        return Err(Error::OutOfMemory);
+        return Err(allocation_error(ResourceExhaustionKind::AllocationLimit));
     }
-    out.try_reserve(len.saturating_sub(out.len()))?;
+    out.try_reserve(len.saturating_sub(out.len()))
+        .or_raise_erased(|| message("Entry too large to fit in memory"))?;
     out.resize(len, 0);
     Ok(())
 }
@@ -666,6 +673,8 @@ mod tests {
         time::Duration,
     };
 
+    use gix_error::ExnResult;
+
     use gix_features::progress;
 
     use crate::{
@@ -708,7 +717,7 @@ mod tests {
                 if context.level == 1 {
                     calls_at_first_child.fetch_min(resolve_calls.load(Ordering::Relaxed), Ordering::Relaxed);
                 }
-                Ok::<_, std::io::Error>(())
+                Ok::<_, gix_error::Exn>(())
             },
         )
         .expect("valid delta tree");
@@ -750,7 +759,7 @@ mod tests {
                     std::thread::sleep(Duration::from_millis(20));
                     active.fetch_sub(1, Ordering::Relaxed);
                 }
-                Ok::<_, std::io::Error>(())
+                Ok::<_, gix_error::Exn>(())
             },
         )
         .expect("valid delta tree");
@@ -771,10 +780,7 @@ mod tests {
 
         let err = traverse_with_limit(tree, &pack).expect_err("entry size exceeds the allocation cap");
 
-        assert!(
-            matches!(err, traverse::Error::OutOfMemory),
-            "declared decompressed sizes above the cap must be rejected before allocation"
-        );
+        insta::assert_debug_snapshot!(err, "declared decompressed sizes above the cap must be rejected before allocation", @"Entry too large to fit in memory");
     }
 
     #[test]
@@ -800,10 +806,7 @@ mod tests {
 
         let err = traverse_with_limit(tree, &pack).expect_err("delta base size exceeds the allocation cap");
 
-        assert!(
-            matches!(err, traverse::Error::OutOfMemory),
-            "delta base sizes above the cap must be rejected before comparing them with the decoded base"
-        );
+        insta::assert_debug_snapshot!(err, "delta base sizes above the cap must be rejected before comparing them with the decoded base", @"Entry too large to fit in memory");
     }
 
     #[test]
@@ -829,20 +832,17 @@ mod tests {
 
         let err = traverse_with_limit(tree, &pack).expect_err("delta result size exceeds the allocation cap");
 
-        assert!(
-            matches!(err, traverse::Error::OutOfMemory),
-            "delta result sizes above the cap must be rejected before resizing the output buffer"
-        );
+        insta::assert_debug_snapshot!(err, "delta result sizes above the cap must be rejected before resizing the output buffer", @"Entry too large to fit in memory");
     }
 
-    fn traverse_with_limit(tree: Tree<()>, pack: &Vec<u8>) -> Result<(), traverse::Error> {
+    fn traverse_with_limit(tree: Tree<()>, pack: &Vec<u8>) -> ExnResult {
         traverse(
             tree,
             pack,
             Some(1),
             Some(0),
             |slice, pack| pack.get(slice.start as usize..slice.end as usize),
-            |(), _progress, _context| Ok::<_, std::io::Error>(()),
+            |(), _progress, _context| Ok::<_, gix_error::Exn>(()),
         )
     }
 
@@ -853,11 +853,10 @@ mod tests {
         alloc_limit_bytes: Option<usize>,
         resolve: F,
         inspect: MBFN,
-    ) -> Result<(), traverse::Error>
+    ) -> ExnResult
     where
         F: for<'r> Fn(data::EntryRange, &'r Vec<u8>) -> Option<&'r [u8]> + Send + Clone,
-        MBFN:
-            FnMut(&mut (), &dyn progress::Progress, traverse::Context<'_>) -> Result<(), std::io::Error> + Send + Clone,
+        MBFN: FnMut(&mut (), &dyn progress::Progress, traverse::Context<'_>) -> ExnResult + Send + Clone,
     {
         let should_interrupt = AtomicBool::new(false);
         let mut size_progress = progress::Discard;
diff --git a/gix-pack/src/cache/delta/tree.rs b/gix-pack/src/cache/delta/tree.rs
index 07f3497e58d..84abb1a2bc9 100644
--- a/gix-pack/src/cache/delta/tree.rs
+++ b/gix-pack/src/cache/delta/tree.rs
@@ -1,6 +1,8 @@
 use std::collections::BTreeMap;
 
-use super::{Error, Tree, traverse};
+use gix_error::{ErrorExt, ExnResult, Message, ResourceExhaustionKind, ResultExt};
+
+use super::Tree;
 
 /// Maps each referenced base object ID to indices in `Tree::child_items` of ref-deltas waiting for it.
 pub(super) type RefDeltaChildren = BTreeMap<gix_hash::ObjectId, Vec<u32>>;
@@ -45,21 +47,29 @@ pub(super) enum NodeKind {
     Child,
 }
 
+fn allocation_error(kind: ResourceExhaustionKind) -> Message {
+    gix_error::resource_exhaustion(kind, "The pack delta tree is too large to fit in memory")
+}
+
 impl<T> Tree<T> {
     /// Instantiate a empty tree capable of storing `num_objects` amounts of items.
-    pub(crate) fn with_capacity(num_objects: usize, alloc_limit_bytes: Option<usize>) -> Result<Self, Error> {
+    pub(crate) fn with_capacity(num_objects: usize, alloc_limit_bytes: Option<usize>) -> ExnResult<Self> {
         let capacity = num_objects / 2;
         let allocation_bytes = capacity
             .checked_mul(std::mem::size_of::<Item<T>>())
-            .ok_or(Error::OutOfMemory)?;
+            .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure).raise_erased())?;
         if alloc_limit_bytes.is_some_and(|limit| allocation_bytes > limit) {
-            return Err(Error::OutOfMemory);
+            return Err(allocation_error(ResourceExhaustionKind::AllocationLimit).raise_erased());
         }
 
         let mut root_items = Vec::new();
-        root_items.try_reserve_exact(capacity)?;
+        root_items
+            .try_reserve_exact(capacity)
+            .or_raise_erased(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?;
         let mut child_items = Vec::new();
-        child_items.try_reserve_exact(capacity)?;
+        child_items
+            .try_reserve_exact(capacity)
+            .or_raise_erased(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?;
         Ok(Tree {
             root_items,
             child_items,
@@ -80,10 +90,7 @@ impl<T> Tree<T> {
         (self.root_items, self.child_items, self.ref_child_indices)
     }
 
-    pub(super) fn assert_is_incrementing_and_update_next_offset(
-        &mut self,
-        offset: crate::data::Offset,
-    ) -> Result<(), Error> {
+    pub(super) fn assert_is_incrementing_and_update_next_offset(&mut self, offset: crate::data::Offset) -> ExnResult {
         let items = match &self.last_seen {
             Some(NodeKind::Root) => &mut self.root_items,
             Some(NodeKind::Child) => &mut self.child_items,
@@ -91,10 +98,11 @@ impl<T> Tree<T> {
         };
         let item = &mut items.last_mut().expect("last seen won't lie");
         if offset <= item.offset {
-            return Err(Error::InvariantIncreasingPackOffset {
-                last_pack_offset: item.offset,
-                pack_offset: offset,
-            });
+            return Err(gix_error::corruption(format!(
+                "Pack offsets must only increment. The previous pack offset was {}, the current one is {offset}",
+                item.offset
+            ))
+            .raise_erased());
         }
         item.next_offset = offset;
         Ok(())
@@ -103,7 +111,7 @@ impl<T> Tree<T> {
     pub(super) fn set_pack_entries_end_and_resolve_ref_offsets(
         &mut self,
         pack_entries_end: crate::data::Offset,
-    ) -> Result<(), traverse::Error> {
+    ) -> ExnResult {
         if !self.future_child_offsets.is_empty() {
             for (parent_offset, child_index) in self.future_child_offsets.drain(..) {
                 // SAFETY invariants upheld:
@@ -117,9 +125,10 @@ impl<T> Tree<T> {
                 } else if let Ok(i) = self.root_items.binary_search_by_key(&parent_offset, |i| i.offset) {
                     self.root_items[i].children.push(child_index as u32);
                 } else {
-                    return Err(traverse::Error::OutOfPackRefDelta {
-                        base_pack_offset: parent_offset,
-                    });
+                    return Err(gix_error::message!(
+                        "The base at {parent_offset} was referred to by a ref-delta, but it was never added to the tree as if the pack was still thin."
+                    )
+                    .raise_erased());
                 }
             }
         }
@@ -131,7 +140,7 @@ impl<T> Tree<T> {
 
     /// Add a new root node, one that only has children but is not a child itself, at the given pack `offset` and associate
     /// custom `data` with it.
-    pub(crate) fn add_root(&mut self, offset: crate::data::Offset, data: T) -> Result<(), Error> {
+    pub(crate) fn add_root(&mut self, offset: crate::data::Offset, data: T) -> ExnResult {
         self.assert_is_incrementing_and_update_next_offset(offset)?;
         self.last_seen = NodeKind::Root.into();
         self.root_items.push(Item {
@@ -150,7 +159,7 @@ impl<T> Tree<T> {
         base_offset: crate::data::Offset,
         offset: crate::data::Offset,
         data: T,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         self.assert_is_incrementing_and_update_next_offset(offset)?;
 
         let next_child_index = self.child_items.len();
@@ -193,7 +202,7 @@ impl<T> Tree<T> {
         base_id: gix_hash::ObjectId,
         offset: crate::data::Offset,
         data: T,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         self.assert_is_incrementing_and_update_next_offset(offset)?;
 
         let child_index = self.child_items.len() as u32;
@@ -213,17 +222,28 @@ impl<T> Tree<T> {
 mod tests {
     #[test]
     fn allocation_failure_is_reported() {
-        let result = super::Tree::<()>::with_capacity(usize::MAX, None);
-        assert!(
-            matches!(result, Err(super::Error::OutOfMemory)),
-            "an impossible attacker-controlled capacity must return an allocation error"
+        let err = super::Tree::<()>::with_capacity(usize::MAX, None)
+            .err()
+            .expect("an impossible attacker-controlled capacity must return an allocation error");
+        insta::assert_debug_snapshot!(err, "allocation failure is reported", @"The pack delta tree is too large to fit in memory");
+        assert_eq!(
+            err.classify().find_map(|classification| match classification.class() {
+                gix_error::Class::ResourceExhaustion(kind) => Some(kind),
+                _ => None,
+            }),
+            Some(gix_error::ResourceExhaustionKind::AllocationFailure)
         );
-        assert!(
-            matches!(
-                super::Tree::<()>::with_capacity(2, Some(0)),
-                Err(super::Error::OutOfMemory)
-            ),
-            "the configured allocation limit must apply to delta-tree storage"
+
+        let err = super::Tree::<()>::with_capacity(2, Some(0))
+            .err()
+            .expect("the configured allocation limit must apply to delta-tree storage");
+        insta::assert_debug_snapshot!(err, "allocation failure is reported", @"The pack delta tree is too large to fit in memory");
+        assert_eq!(
+            err.classify().find_map(|classification| match classification.class() {
+                gix_error::Class::ResourceExhaustion(kind) => Some(kind),
+                _ => None,
+            }),
+            Some(gix_error::ResourceExhaustionKind::AllocationLimit)
         );
     }
 
@@ -241,17 +261,17 @@ mod tests {
         use gix_testtools::fixture_path;
 
         #[test]
-        fn v1() -> Result<(), Box<dyn std::error::Error>> {
+        fn v1() -> gix_testtools::Result {
             tree(INDEX_V1, PACK_FOR_INDEX_V1)
         }
 
         #[test]
-        fn v2() -> Result<(), Box<dyn std::error::Error>> {
+        fn v2() -> gix_testtools::Result {
             tree(SMALL_PACK_INDEX, SMALL_PACK)
         }
 
         #[test]
-        fn invalid_ofs_delta_base_distance_is_reported() -> Result<(), Box<dyn std::error::Error>> {
+        fn invalid_ofs_delta_base_distance_is_reported() -> gix_testtools::Result {
             let first_entry_offset = pack::data::header::SIZE as pack::data::Offset;
             let pack_file = gix_testtools::tempfile::NamedTempFile::new()?;
             let mut pack_data = pack::data::header::encode(pack::data::Version::V2, 1).to_vec();
@@ -275,7 +295,7 @@ mod tests {
             Ok(())
         }
 
-        fn tree(index_path: &str, pack_path: &str) -> Result<(), Box<dyn std::error::Error>> {
+        fn tree(index_path: &str, pack_path: &str) -> gix_testtools::Result {
             let idx = pack::index::File::at(fixture_path(index_path), gix_hash::Kind::Sha1)?;
             crate::cache::delta::Tree::from_offsets_in_pack(
                 &fixture_path(pack_path),
diff --git a/gix-pack/src/cache/mod.rs b/gix-pack/src/cache/mod.rs
index 4fb4dbdbbb6..68289f642ee 100644
--- a/gix-pack/src/cache/mod.rs
+++ b/gix-pack/src/cache/mod.rs
@@ -60,13 +60,14 @@ pub mod object;
 /// [`delta::traverse::Options`] configure the traversal.
 ///
 /// ```no_run
+/// use gix_error::ExnResult;
 /// use gix_pack::cache::delta::Tree;
 /// use std::sync::atomic::AtomicBool;
 ///
 /// # fn build_index_less(
 /// #     pack_path: &std::path::Path,
 /// #     offsets: Vec<gix_pack::data::Offset>,
-/// # ) -> Result<(), Box<dyn std::error::Error>> {
+/// # ) -> ExnResult {
 /// // Build the delta tree straight from the pack — no `.idx` required:
 /// let tree = Tree::from_offsets_in_pack(
 ///     pack_path,
diff --git a/gix-pack/src/data/delta.rs b/gix-pack/src/data/delta.rs
index fb01e928d7f..acc58954f2f 100644
--- a/gix-pack/src/data/delta.rs
+++ b/gix-pack/src/data/delta.rs
@@ -1,31 +1,18 @@
-///
-pub mod apply {
-    /// Returned when failing to apply deltas.
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Corrupt delta data: {message}")]
-        Corrupt { message: &'static str },
-        #[error("Encountered unsupported command code: 0")]
-        UnsupportedCommandCode,
-        #[error("Delta copy from base: byte slices must match")]
-        DeltaCopyBaseSliceMismatch,
-        #[error("Delta copy data: byte slices must match")]
-        DeltaCopyDataSliceMismatch,
-    }
+use gix_error::ExnMessageResult;
+
+fn corrupt(message: &'static str) -> gix_error::Message {
+    gix_error::corruption(format!("Corrupt delta data: {message}"))
 }
 
 /// Given the decompressed pack delta `d`, decode a size in bytes (either the base object size or the result object size)
 /// Equivalent to [this canonical git function](https://github.com/git/git/blob/311531c9de557d25ac087c1637818bd2aad6eb3a/delta.h#L89)
-pub(crate) fn decode_header_size(d: &[u8]) -> Result<(u64, usize), apply::Error> {
+pub(crate) fn decode_header_size(d: &[u8]) -> ExnMessageResult<(u64, usize)> {
     let mut shift = 0;
     let mut size = 0u64;
     let mut consumed = 0;
     for cmd in d.iter() {
         if shift >= u64::BITS {
-            return Err(apply::Error::Corrupt {
-                message: "delta header size uses more bits than fit into u64",
-            });
+            return Err(corrupt("delta header size uses more bits than fit into u64").into());
         }
         consumed += 1;
         size |= (u64::from(*cmd) & 0x7f) << shift;
@@ -34,16 +21,14 @@ pub(crate) fn decode_header_size(d: &[u8]) -> Result<(u64, usize), apply::Error>
             return Ok((size, consumed));
         }
     }
-    Err(apply::Error::Corrupt {
-        message: "delta header size is truncated",
-    })
+    Err(corrupt("delta header size is truncated").into())
 }
 
-pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(), apply::Error> {
-    fn next_byte(data: &[u8], i: &mut usize) -> Result<u8, apply::Error> {
-        let byte = *data.get(*i).ok_or(apply::Error::Corrupt {
-            message: "delta copy instruction is truncated",
-        })?;
+pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> ExnMessageResult {
+    fn next_byte(data: &[u8], i: &mut usize) -> ExnMessageResult<u8> {
+        let byte = *data
+            .get(*i)
+            .ok_or_else(|| corrupt("delta copy instruction is truncated"))?;
         *i += 1;
         Ok(byte)
     }
@@ -51,7 +36,7 @@ pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(
     let mut i = 0;
     while let Some(cmd) = data.get(i) {
         i += 1;
-        match cmd {
+        let bytes = match cmd {
             cmd if cmd & 0b1000_0000 != 0 => {
                 let (mut ofs, mut size): (u32, u32) = (0, 0);
                 if cmd & 0b0000_0001 != 0 {
@@ -79,36 +64,31 @@ pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(
                     size = 0x10000; // 65536
                 }
                 let ofs = ofs as usize;
-                let end = ofs.checked_add(size as usize).ok_or(apply::Error::Corrupt {
-                    message: "delta copy range overflows",
-                })?;
-                std::io::Write::write(
-                    &mut target,
-                    base.get(ofs..end).ok_or(apply::Error::Corrupt {
-                        message: "delta copy range exceeds base object size",
-                    })?,
-                )
-                .map_err(|_e| apply::Error::DeltaCopyBaseSliceMismatch)?;
+                let end = ofs
+                    .checked_add(size as usize)
+                    .ok_or_else(|| corrupt("delta copy range overflows"))?;
+                base.get(ofs..end)
+                    .ok_or_else(|| corrupt("delta copy range exceeds base object size"))?
             }
             0 => {
-                return Err(apply::Error::Corrupt {
-                    message: "delta command 0 is reserved and invalid",
-                });
+                return Err(corrupt("delta command 0 is reserved and invalid").into());
             }
             size => {
-                let end = i.checked_add(*size as usize).ok_or(apply::Error::Corrupt {
-                    message: "delta insert range overflows",
-                })?;
-                std::io::Write::write(
-                    &mut target,
-                    data.get(i..end).ok_or(apply::Error::Corrupt {
-                        message: "delta insert data is truncated",
-                    })?,
-                )
-                .map_err(|_e| apply::Error::DeltaCopyDataSliceMismatch)?;
+                let end = i
+                    .checked_add(*size as usize)
+                    .ok_or_else(|| corrupt("delta insert range overflows"))?;
+                let bytes = data
+                    .get(i..end)
+                    .ok_or_else(|| corrupt("delta insert data is truncated"))?;
                 i = end;
+                bytes
             }
-        }
+        };
+        let (out, rest) = target
+            .split_at_mut_checked(bytes.len())
+            .ok_or_else(|| corrupt("delta instructions produced more bytes than promised"))?;
+        out.copy_from_slice(bytes);
+        target = rest;
     }
     debug_assert_eq!(
         i,
@@ -116,10 +96,27 @@ pub(crate) fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) -> Result<(
         "delta instructions were not consumed completely, should be impossible"
     );
     if !target.is_empty() {
-        return Err(apply::Error::Corrupt {
-            message: "delta instructions produced fewer bytes than promised",
-        });
+        return Err(corrupt("delta instructions produced fewer bytes than promised").into());
     }
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn instructions_cannot_exceed_the_declared_result_size() {
+        let mut error_snapshots = Vec::new();
+        for instructions in [b"\x90\x02".as_slice(), b"\x02ab".as_slice()] {
+            let err = super::apply(b"ab", &mut [0], instructions)
+                .expect_err("neither copying nor inserting may truncate the result");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "instructions cannot exceed the declared result size", @"
+        [
+            Corrupt delta data: delta instructions produced more bytes than promised,
+            Corrupt delta data: delta instructions produced more bytes than promised,
+        ]
+        ");
+    }
+}
diff --git a/gix-pack/src/data/entry/decode.rs b/gix-pack/src/data/entry/decode.rs
index ccd4f130bc1..0aa90f347de 100644
--- a/gix-pack/src/data/entry/decode.rs
+++ b/gix-pack/src/data/entry/decode.rs
@@ -1,3 +1,4 @@
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt};
 use std::io;
 
 use gix_features::decode::leb64_from_read;
@@ -5,22 +6,18 @@ use gix_features::decode::leb64_from_read;
 use super::{BLOB, COMMIT, OFS_DELTA, REF_DELTA, TAG, TREE};
 use crate::data;
 
-/// The error returned by [data::Entry::from_bytes()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Object type {type_id} is unsupported")]
-    UnsupportedType { type_id: u8 },
-    #[error("Pack entry is truncated: {message}")]
-    Corrupt { message: &'static str },
-    #[error("Pack entry header value overflowed while decoding")]
-    Overflow,
+fn corrupt(message: &'static str) -> gix_error::Message {
+    gix_error::corruption(format!("Pack entry is truncated: {message}"))
 }
 
 /// Decoding
 impl data::Entry {
     /// Decode an entry from the given entry data `d`, providing the `pack_offset` to allow tracking the start of the entry data section.
-    pub fn from_bytes(d: &[u8], pack_offset: data::Offset, object_hash: gix_hash::Kind) -> Result<data::Entry, Error> {
+    pub fn from_bytes(
+        d: &[u8],
+        pack_offset: data::Offset,
+        object_hash: gix_hash::Kind,
+    ) -> ExnMessageResult<data::Entry> {
         let (type_id, size, mut consumed) = parse_header_info(d)?;
         let hash_len = object_hash.len_in_bytes();
 
@@ -38,13 +35,10 @@ impl data::Entry {
                 let hash = d
                     .get(consumed..)
                     .and_then(|d| d.get(..hash_len))
-                    .ok_or(Error::Corrupt {
-                        message: "ref-delta base object id",
-                    })?;
+                    .ok_or_else(|| corrupt("ref-delta base object id"))?;
                 let delta = RefDelta {
-                    base_id: gix_hash::ObjectId::try_from(hash).map_err(|_| Error::Corrupt {
-                        message: "unsupported object hash length",
-                    })?,
+                    base_id: gix_hash::ObjectId::try_from(hash)
+                        .or_raise(|| corrupt("unsupported object hash length"))?,
                 };
                 consumed += hash_len;
                 delta
@@ -53,7 +47,9 @@ impl data::Entry {
             TREE => Tree,
             COMMIT => Commit,
             TAG => Tag,
-            other => return Err(Error::UnsupportedType { type_id: other }),
+            other => {
+                return Err(gix_error::corruption(format!("Object type {other} is unsupported")).raise());
+            }
         };
         Ok(data::Entry {
             header: object,
@@ -81,6 +77,7 @@ impl data::Entry {
                 let mut buf = gix_hash::Kind::buf();
                 let hash = &mut buf[..hash_len];
                 r.read_exact(hash)?;
+                #[allow(clippy::redundant_slicing)]
                 let delta = RefDelta {
                     base_id: gix_hash::ObjectId::from_bytes_or_panic(&hash[..]),
                 };
@@ -98,19 +95,17 @@ impl data::Entry {
             decompressed_size: size,
             data_offset: pack_offset + consumed as u64,
             encoded_header_size: encoded_header_size(consumed)
-                .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?,
+                .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err.into_error()))?,
         })
     }
 }
 
-fn encoded_header_size(consumed: usize) -> Result<u16, Error> {
-    consumed.try_into().map_err(|_| Error::Corrupt {
-        message: "entry header size does not fit into u16",
-    })
+fn encoded_header_size(consumed: usize) -> ExnMessageResult<u16> {
+    u16::try_from(consumed).or_raise(|| corrupt("entry header size does not fit into u16"))
 }
 
 #[inline]
-fn streaming_parse_header_info(read: &mut dyn io::Read) -> Result<(u8, u64, usize), io::Error> {
+fn streaming_parse_header_info(read: &mut dyn io::Read) -> std::result::Result<(u8, u64, usize), io::Error> {
     let mut byte = [0u8; 1];
     read.read_exact(&mut byte)?;
     let mut c = byte[0];
@@ -135,43 +130,45 @@ fn streaming_parse_header_info(read: &mut dyn io::Read) -> Result<(u8, u64, usiz
 
 /// Parses the header of a pack-entry, yielding object type id, decompressed object size, and consumed bytes
 #[inline]
-fn parse_header_info(data: &[u8]) -> Result<(u8, u64, usize), Error> {
-    let mut c = *data.first().ok_or(Error::Corrupt {
-        message: "need a pack entry header, got empty input",
-    })?;
+fn parse_header_info(data: &[u8]) -> ExnMessageResult<(u8, u64, usize)> {
+    let mut c = *data
+        .first()
+        .ok_or_else(|| corrupt("need a pack entry header, got empty input"))?;
     let mut i = 1;
     let type_id = (c >> 4) & 0b0000_0111;
     let mut size = u64::from(c) & 0b0000_1111;
     let mut shift = 4u32;
     while c & 0b1000_0000 != 0 {
-        c = *data.get(i).ok_or(Error::Corrupt {
-            message: "pack entry header continuation byte",
-        })?;
+        c = *data
+            .get(i)
+            .ok_or_else(|| corrupt("pack entry header continuation byte"))?;
         i += 1;
-        let component = u64::from(c & 0b0111_1111).checked_shl(shift).ok_or(Error::Overflow)?;
-        size = size.checked_add(component).ok_or(Error::Overflow)?;
+        let component = u64::from(c & 0b0111_1111)
+            .checked_shl(shift)
+            .ok_or_else(|| gix_error::corruption("Pack entry header value overflowed while decoding"))?;
+        size = size
+            .checked_add(component)
+            .ok_or_else(|| gix_error::corruption("Pack entry header value overflowed while decoding"))?;
         shift += 7;
     }
     Ok((type_id, size, i))
 }
 
-fn parse_leb64(data: &[u8]) -> Result<(u64, usize), Error> {
+fn parse_leb64(data: &[u8]) -> ExnMessageResult<(u64, usize)> {
     let mut i = 0;
-    let mut c = *data.first().ok_or(Error::Corrupt {
-        message: "an ofs-delta base distance",
-    })?;
+    let mut c = *data.first().ok_or_else(|| corrupt("an ofs-delta base distance"))?;
     i += 1;
     let mut value = u64::from(c) & 0x7f;
     while c & 0x80 != 0 {
-        c = *data.get(i).ok_or(Error::Corrupt {
-            message: "an ofs-delta base distance continuation byte",
-        })?;
+        c = *data
+            .get(i)
+            .ok_or_else(|| corrupt("an ofs-delta base distance continuation byte"))?;
         i += 1;
         value = value
             .checked_add(1)
             .and_then(|value| value.checked_shl(7))
             .and_then(|value| value.checked_add(u64::from(c) & 0x7f))
-            .ok_or(Error::Overflow)?;
+            .ok_or_else(|| gix_error::corruption("Pack entry header value overflowed while decoding"))?;
     }
     Ok((value, i))
 }
@@ -242,12 +239,16 @@ mod tests {
 
     #[test]
     fn oversized_encoded_header_size_is_rejected() {
+        let err = encoded_header_size(usize::from(u16::MAX) + 1).expect_err("the encoded size exceeds u16");
+        assert!(err.is_corrupted());
         assert!(
-            matches!(
-                encoded_header_size(usize::from(u16::MAX) + 1),
-                Err(Error::Corrupt { message }) if message == "entry header size does not fit into u16"
-            ),
-            "entry header lengths that cannot be stored in the Entry metadata must be rejected"
+            err.downcast_any_ref::<std::num::TryFromIntError>().is_some(),
+            "the integer conversion failure remains available"
         );
+        insta::assert_debug_snapshot!(err, "entry header lengths that cannot be stored in the Entry metadata must be rejected", @"
+        Pack entry is truncated: entry header size does not fit into u16
+        |
+        └─ out of range integral type conversion attempted
+        ");
     }
 }
diff --git a/gix-pack/src/data/file/decode/entry.rs b/gix-pack/src/data/file/decode/entry.rs
index 9c5043bd5bc..aab1326d7eb 100644
--- a/gix-pack/src/data/file/decode/entry.rs
+++ b/gix-pack/src/data/file/decode/entry.rs
@@ -1,9 +1,14 @@
 use smallvec::SmallVec;
 use std::ops::Range;
 
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, ResourceExhaustionKind, ResultExt, message};
+
 use crate::{
     cache, data,
-    data::{File, delta, file::decode::Error},
+    data::{
+        File, delta,
+        file::decode::{DeltaBaseUnresolved, allocation_error},
+    },
 };
 
 /// A return value of a resolve function, which given an [`ObjectId`][gix_hash::ObjectId] determines where an object can be found.
@@ -75,7 +80,7 @@ impl<T> File<T>
 where
     T: crate::FileData,
 {
-    fn decoded_object_size(&self, size: u64) -> Result<usize, Error> {
+    fn decoded_object_size(&self, size: u64) -> ExnResult<usize> {
         decoded_object_size(size, self.alloc_limit_bytes)
     }
 
@@ -89,10 +94,13 @@ where
         entry: &data::Entry,
         inflate: &mut gix_zlib::Inflate,
         out: &mut [u8],
-    ) -> Result<usize, Error> {
-        let size: usize = entry.decompressed_size.try_into().map_err(|_| Error::OutOfMemory)?;
+    ) -> ExnResult<usize> {
+        let size: usize = entry
+            .decompressed_size
+            .try_into()
+            .map_err(|err| allocation_error(ResourceExhaustionKind::AllocationFailure).chain(err))?;
         if out.len() < size {
-            return Err(Error::OutOfMemory);
+            return Err(gix_error::validation("Output buffer is too small for the decompressed entry").raise_erased());
         }
         self.decompress_entry_from_data_offset(entry.data_offset, inflate, &mut out[..size])
     }
@@ -100,12 +108,12 @@ where
     /// Obtain the [`Entry`][crate::data::Entry] at the given `offset` into the pack.
     ///
     /// The `offset` is typically obtained from the pack index file.
-    pub fn entry(&self, offset: data::Offset) -> Result<data::Entry, data::entry::decode::Error> {
+    pub fn entry(&self, offset: data::Offset) -> ExnMessageResult<data::Entry> {
         let pack_offset: usize = offset.try_into().expect("offset representable by machine");
         if pack_offset > self.data.len() {
-            return Err(data::entry::decode::Error::Corrupt {
-                message: "an entry offset pointing beyond pack data",
-            });
+            return Err(
+                gix_error::corruption("Pack entry is truncated: an entry offset pointing beyond pack data").raise(),
+            );
         }
 
         let object_data = &self.data[pack_offset..];
@@ -122,7 +130,7 @@ where
         data_offset: data::Offset,
         inflate: &mut gix_zlib::Inflate,
         out: &mut [u8],
-    ) -> Result<usize, Error> {
+    ) -> ExnResult<usize> {
         let (consumed_in, _consumed_out) =
             self.decompress_complete_entry_from_data_offset(data_offset, inflate, out)?;
         Ok(consumed_in)
@@ -140,14 +148,14 @@ where
         data_offset: data::Offset,
         inflate: &mut gix_zlib::Inflate,
         out: &mut [u8],
-    ) -> Result<(usize, usize), Error> {
+    ) -> ExnResult<(usize, usize)> {
         let (status, consumed_in, consumed_out) =
             self.decompress_entry_from_data_offset_unchecked(data_offset, inflate, out)?;
         if status != gix_zlib::Status::StreamEnd || consumed_out != out.len() {
-            return Err(data::entry::decode::Error::Corrupt {
-                message: "pack entry decompressed size does not match entry header",
-            }
-            .into());
+            return Err(gix_error::corruption(
+                "Pack entry is truncated: pack entry decompressed size does not match entry header",
+            )
+            .raise_erased());
         }
         Ok((consumed_in, consumed_out))
     }
@@ -161,19 +169,19 @@ where
         data_offset: data::Offset,
         inflate: &mut gix_zlib::Inflate,
         out: &mut [u8],
-    ) -> Result<(gix_zlib::Status, usize, usize), Error> {
+    ) -> ExnResult<(gix_zlib::Status, usize, usize)> {
         let offset: usize = data_offset.try_into().expect("offset representable by machine");
         if offset >= self.data.len() {
-            return Err(data::entry::decode::Error::Corrupt {
-                message: "an entry data offset pointing beyond pack data",
-            }
-            .into());
+            return Err(gix_error::corruption(
+                "Pack entry is truncated: an entry data offset pointing beyond pack data",
+            )
+            .raise_erased());
         }
 
         inflate.reset();
         inflate
             .once(&self.data[offset..], out)
-            .map_err(|err| Error::ZlibInflate(err.into_error()))
+            .or_raise_erased(|| message("Failed to decompress pack entry"))
     }
 
     /// Decode an entry, resolving delta's as needed, while growing the `out` vector if there is not enough
@@ -194,13 +202,14 @@ where
         inflate: &mut gix_zlib::Inflate,
         resolve: &dyn Fn(&gix_hash::oid, &mut Vec<u8>) -> Option<ResolvedBase>,
         delta_cache: &mut dyn cache::DecodeEntry,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         use crate::data::entry::Header::*;
         match entry.header {
             Tree | Blob | Commit | Tag => {
                 let size = self.decoded_object_size(entry.decompressed_size)?;
                 if let Some(additional) = size.checked_sub(out.len()) {
-                    out.try_reserve(additional)?;
+                    out.try_reserve(additional)
+                        .or_raise_erased(|| message("Entry too large to fit in memory"))?;
                 }
                 out.resize(size, 0);
                 self.decompress_entry(&entry, inflate, out.as_mut_slice())
@@ -226,7 +235,7 @@ where
         inflate: &mut gix_zlib::Inflate,
         out: &mut Vec<u8>,
         cache: &mut dyn cache::DecodeEntry,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         // all deltas, from the one that produces the desired object (first) to the oldest at the end of the chain
         let mut chain = SmallVec::<[Delta; 10]>::default();
         let first_entry = last.clone();
@@ -252,12 +261,12 @@ where
             // TODO: is this assumption actually true?
             total_delta_data_size = total_delta_data_size
                 .checked_add(cursor.decompressed_size)
-                .ok_or(Error::OutOfMemory)?;
+                .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?;
             if self
                 .alloc_limit_bytes
                 .is_some_and(|limit| total_delta_data_size > limit as u64)
             {
-                return Err(Error::OutOfMemory);
+                return Err(allocation_error(ResourceExhaustionKind::AllocationLimit));
             }
             let decompressed_size = self.decoded_object_size(cursor.decompressed_size)?;
             chain.push(Delta {
@@ -273,11 +282,15 @@ where
             use crate::data::entry::Header;
             cursor = match cursor.header {
                 Header::OfsDelta { base_distance } => {
-                    self.entry(cursor.checked_base_pack_offset(base_distance).ok_or(
-                        crate::data::entry::decode::Error::Corrupt {
-                            message: "an ofs-delta base distance pointing before pack start",
-                        },
-                    )?)?
+                    let offset = cursor
+                        .checked_base_pack_offset(base_distance)
+                        .ok_or_else(|| {
+                            gix_error::corruption(
+                                "Pack entry is truncated: an ofs-delta base distance pointing before pack start",
+                            )
+                        })
+                        .or_erased()?;
+                    self.entry(offset).or_erased()?
                 }
                 Header::RefDelta { base_id } => match resolve(base_id.as_ref(), out) {
                     Some(ResolvedBase::InPack(entry)) => entry,
@@ -286,7 +299,7 @@ where
                         object_kind = Some(kind);
                         break;
                     }
-                    None => return Err(Error::DeltaBaseUnresolved(base_id)),
+                    None => return Err(DeltaBaseUnresolved(base_id).raise_erased()),
                 },
                 _ => unreachable!("cursor.is_delta() only allows deltas here"),
             };
@@ -305,7 +318,9 @@ where
         // First pass will decompress all delta data and keep it in our output buffer
         // [<possibly resolved base object>]<delta-1..delta-n>...
         // so that we can find the biggest result size.
-        let total_delta_data_size: usize = total_delta_data_size.try_into().map_err(|_| Error::OutOfMemory)?;
+        let total_delta_data_size: usize = total_delta_data_size
+            .try_into()
+            .map_err(|err| allocation_error(ResourceExhaustionKind::AllocationFailure).chain(err))?;
 
         let chain_len = chain.len();
         let actual_base_size = match base_buffer_size {
@@ -319,9 +334,10 @@ where
                 start: delta_start,
                 end: delta_start
                     .checked_add(total_delta_data_size)
-                    .ok_or(Error::OutOfMemory)?,
+                    .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?,
             };
-            out.try_reserve(delta_range.end.saturating_sub(out.len()))?;
+            out.try_reserve(delta_range.end.saturating_sub(out.len()))
+                .or_raise_erased(|| message("Entry too large to fit in memory"))?;
             out.resize(delta_range.end, 0);
 
             let mut instructions = &mut out[delta_range.clone()];
@@ -340,18 +356,18 @@ where
                 }
 
                 let current_delta = &instructions[..consumed_out];
-                let (base_size, offset) = delta::decode_header_size(current_delta)?;
+                let (base_size, offset) = delta::decode_header_size(current_delta).or_erased()?;
                 let mut bytes_consumed_by_header = offset;
                 delta.base_size = self.decoded_object_size(base_size)?;
                 if delta.base_size != expected_base_size {
-                    return Err(delta::apply::Error::Corrupt {
-                        message: "delta base size does not match base object size",
-                    }
-                    .into());
+                    return Err(gix_error::corruption(
+                        "Corrupt delta data: delta base size does not match base object size",
+                    )
+                    .raise_erased());
                 }
                 biggest_result_size = biggest_result_size.max(base_size);
 
-                let (result_size, offset) = delta::decode_header_size(&current_delta[offset..])?;
+                let (result_size, offset) = delta::decode_header_size(&current_delta[offset..]).or_erased()?;
                 bytes_consumed_by_header += offset;
                 biggest_result_size = biggest_result_size.max(result_size);
                 delta.result_size = self.decoded_object_size(result_size)?;
@@ -377,8 +393,9 @@ where
             let out_size = first_buffer_size
                 .checked_add(second_buffer_size)
                 .and_then(|size| size.checked_add(total_delta_data_size))
-                .ok_or(Error::OutOfMemory)?;
-            out.try_reserve(out_size.saturating_sub(out.len()))?;
+                .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?;
+            out.try_reserve(out_size.saturating_sub(out.len()))
+                .or_raise_erased(|| message("Entry too large to fit in memory"))?;
             out.resize(out_size, 0);
 
             // Now 'rescue' the deltas, because in the next step we possibly overwrite that portion
@@ -386,7 +403,7 @@ where
             let second_buffer_end = {
                 let end = first_buffer_size
                     .checked_add(second_buffer_size)
-                    .ok_or(Error::OutOfMemory)?;
+                    .ok_or_else(|| allocation_error(ResourceExhaustionKind::AllocationFailure))?;
                 // Move the decompressed delta instructions behind the two work buffers so they remain intact
                 // while we repurpose the front of `out` for base-object materialization and delta application.
                 out.copy_within(delta_range, end);
@@ -430,7 +447,7 @@ where
             if delta_idx + 1 == chain_len {
                 last_result_size = Some(result_size);
             }
-            delta::apply(&source_buf[..base_size], &mut target_buf[..result_size], data)?;
+            delta::apply(&source_buf[..base_size], &mut target_buf[..result_size], data).or_erased()?;
             // use the target as source for the next delta
             std::mem::swap(&mut source_buf, &mut target_buf);
         }
@@ -474,10 +491,12 @@ where
 }
 
 /// Convert user-controlled sizes from pack data into allocation sizes while enforcing the configured allocation cap.
-fn decoded_object_size(size: u64, alloc_limit_bytes: Option<usize>) -> Result<usize, Error> {
-    let size: usize = size.try_into().map_err(|_| Error::OutOfMemory)?;
+fn decoded_object_size(size: u64, alloc_limit_bytes: Option<usize>) -> ExnResult<usize> {
+    let size: usize = size
+        .try_into()
+        .map_err(|err| allocation_error(ResourceExhaustionKind::AllocationFailure).chain(err))?;
     if alloc_limit_bytes.is_some_and(|limit| size > limit) {
-        return Err(Error::OutOfMemory);
+        return Err(allocation_error(ResourceExhaustionKind::AllocationLimit));
     }
     Ok(size)
 }
diff --git a/gix-pack/src/data/file/decode/header.rs b/gix-pack/src/data/file/decode/header.rs
index c8f8d86c56b..0fc1cf276bb 100644
--- a/gix-pack/src/data/file/decode/header.rs
+++ b/gix-pack/src/data/file/decode/header.rs
@@ -1,6 +1,8 @@
+use gix_error::{ErrorExt, ExnResult, ResultExt};
+
 use crate::{
     data,
-    data::{File, delta, file::decode::Error},
+    data::{File, delta, file::decode::DeltaBaseUnresolved},
 };
 
 /// A return value of a resolve function, which given an [`ObjectId`][gix_hash::ObjectId] determines where an object can be found.
@@ -55,7 +57,7 @@ where
         mut entry: data::Entry,
         inflate: &mut gix_zlib::Inflate,
         resolve: &dyn Fn(&gix_hash::oid) -> Option<ResolvedBase>,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         use crate::data::entry::Header::*;
         let mut num_deltas = 0;
         let mut first_delta_decompressed_size = None::<u64>;
@@ -73,11 +75,15 @@ where
                     if first_delta_decompressed_size.is_none() {
                         first_delta_decompressed_size = Some(self.decode_delta_object_size(inflate, &entry)?);
                     }
-                    entry = self.entry(entry.checked_base_pack_offset(base_distance).ok_or(
-                        crate::data::entry::decode::Error::Corrupt {
-                            message: "an ofs-delta base distance pointing before pack start",
-                        },
-                    )?)?;
+                    let offset = entry
+                        .checked_base_pack_offset(base_distance)
+                        .ok_or_else(|| {
+                            gix_error::corruption(
+                                "Pack entry is truncated: an ofs-delta base distance pointing before pack start",
+                            )
+                        })
+                        .or_erased()?;
+                    entry = self.entry(offset).or_erased()?;
                 }
                 RefDelta { base_id } => {
                     num_deltas += 1;
@@ -96,7 +102,7 @@ where
                                 num_deltas: origin_num_deltas.unwrap_or_default() + num_deltas,
                             });
                         }
-                        None => return Err(Error::DeltaBaseUnresolved(base_id)),
+                        None => return Err(DeltaBaseUnresolved(base_id).raise_erased()),
                     }
                 }
             }
@@ -113,27 +119,27 @@ where
     /// decompression through `decode_entry()` must still validate that the stream length matches
     /// the pack entry header.
     #[inline]
-    fn decode_delta_object_size(&self, inflate: &mut gix_zlib::Inflate, entry: &data::Entry) -> Result<u64, Error> {
+    fn decode_delta_object_size(&self, inflate: &mut gix_zlib::Inflate, entry: &data::Entry) -> ExnResult<u64> {
         let mut buf = [0_u8; 20];
         let max_size = entry.decompressed_size.min(buf.len() as u64) as usize;
         let (status, _consumed_in, consumed_out) =
             self.decompress_entry_from_data_offset_unchecked(entry.data_offset, inflate, &mut buf[..max_size])?;
         if status == gix_zlib::Status::StreamEnd {
             if consumed_out as u64 != entry.decompressed_size {
-                return Err(data::entry::decode::Error::Corrupt {
-                    message: "pack entry decompressed to fewer bytes than declared in the entry header",
-                }
-                .into());
+                return Err(gix_error::corruption(
+                    "Pack entry is truncated: pack entry decompressed to fewer bytes than declared in the entry header",
+                )
+                .raise_erased());
             }
         } else if entry.decompressed_size == max_size as u64 {
-            return Err(data::entry::decode::Error::Corrupt {
-                message: "pack entry decompressed to more bytes than declared in the entry header",
-            }
-            .into());
+            return Err(gix_error::corruption(
+                "Pack entry is truncated: pack entry decompressed to more bytes than declared in the entry header",
+            )
+            .raise_erased());
         }
         let buf = &buf[..consumed_out];
-        let (_base_size, offset) = delta::decode_header_size(buf)?;
-        let (result_size, _offset) = delta::decode_header_size(&buf[offset..])?;
+        let (_base_size, offset) = delta::decode_header_size(buf).or_erased()?;
+        let (result_size, _offset) = delta::decode_header_size(&buf[offset..]).or_erased()?;
         Ok(result_size)
     }
 }
diff --git a/gix-pack/src/data/file/decode/mod.rs b/gix-pack/src/data/file/decode/mod.rs
index 3ce41c3e287..eeed0ccd477 100644
--- a/gix-pack/src/data/file/decode/mod.rs
+++ b/gix-pack/src/data/file/decode/mod.rs
@@ -1,31 +1,37 @@
-use std::collections::TryReserveError;
-
 ///
 pub mod entry;
 ///
 pub mod header;
 
-/// Returned by [`File::decode_header()`][crate::data::File::decode_header()],
-/// [`File::decode_entry()`][crate::data::File::decode_entry()] and .
-/// [`File::decompress_entry()`][crate::data::File::decompress_entry()]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to decompress pack entry")]
-    ZlibInflate(#[source] gix_error::Error),
-    #[error("A delta chain could not be followed as the ref base with id {0} could not be found")]
-    DeltaBaseUnresolved(gix_hash::ObjectId),
-    #[error(transparent)]
-    EntryType(#[from] crate::data::entry::decode::Error),
-    #[error("Entry too large to fit in memory")]
-    OutOfMemory,
-    #[error(transparent)]
-    Delta(#[from] crate::data::delta::apply::Error),
+/// A ref-delta base that could not be resolved.
+///
+/// Its source is a classification-only [`gix_error::ClassificationMarker`].
+/// Use [`gix_error::classify()`] or `is_not_found()` on [`gix_error::Exn`] and [`gix_error::Error`] to check the
+/// classification, without depending on the concrete diagnostic type. Downcast to this type for the base object ID.
+#[derive(Debug)]
+pub struct DeltaBaseUnresolved(
+    /// The object ID named by the ref-delta.
+    pub gix_hash::ObjectId,
+);
+
+impl std::fmt::Display for DeltaBaseUnresolved {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "A delta chain could not be followed as the ref base with id {} could not be found",
+            self.0
+        )
+    }
 }
 
-impl From<TryReserveError> for Error {
-    #[cold]
-    fn from(_: TryReserveError) -> Self {
-        Self::OutOfMemory
+impl std::error::Error for DeltaBaseUnresolved {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::NOT_FOUND })
     }
 }
+
+#[cold]
+pub(super) fn allocation_error(kind: gix_error::ResourceExhaustionKind) -> gix_error::Exn {
+    use gix_error::ErrorExt;
+    gix_error::resource_exhaustion(kind, "Entry too large to fit in memory").raise_erased()
+}
diff --git a/gix-pack/src/data/file/init.rs b/gix-pack/src/data/file/init.rs
index 561e68b3e89..95542081631 100644
--- a/gix-pack/src/data/file/init.rs
+++ b/gix-pack/src/data/file/init.rs
@@ -1,5 +1,7 @@
 use std::path::{Path, PathBuf};
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
+
 use crate::data;
 
 /// Instantiation
@@ -12,15 +14,13 @@ impl data::File<crate::MMap> {
     /// This constructor leaves allocation limiting disabled, allowing allocations of any size dictated by pack data.
     /// Use [`Self::from_data()`] together with [`File::with_alloc_limit_bytes()`][crate::data::File::with_alloc_limit_bytes()]
     /// when working with untrusted input.
-    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> Result<Self, data::header::decode::Error> {
+    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         Self::at_inner(path.as_ref(), object_hash)
     }
 
-    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> Result<Self, data::header::decode::Error> {
-        let data = crate::mmap::read_only(path).map_err(|e| data::header::decode::Error::Io {
-            source: e,
-            path: path.to_owned(),
-        })?;
+    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> ExnResult<Self> {
+        let data = crate::mmap::read_only(path)
+            .or_raise_erased(|| message!("Could not open pack data file at '{}'", path.display()))?;
         Self::from_data(data, path.to_owned(), object_hash)
     }
 }
@@ -33,14 +33,15 @@ where
     ///
     /// This constructor leaves allocation limiting disabled, allowing allocations of any size dictated by pack data.
     /// Call [`File::with_alloc_limit_bytes()`][crate::data::File::with_alloc_limit_bytes()] before decoding entries from untrusted input.
-    pub fn from_data(data: T, path: PathBuf, object_hash: gix_hash::Kind) -> Result<Self, data::header::decode::Error> {
+    pub fn from_data(data: T, path: PathBuf, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         let hash_len = object_hash.len_in_bytes();
         let pack_len = data.len();
         let id = gix_features::hash::crc32(path.as_os_str().to_string_lossy().as_bytes());
         if pack_len < data::header::SIZE + hash_len {
-            return Err(data::header::decode::Error::Corrupt(format!(
+            return Err(gix_error::corruption(format!(
                 "Pack data of size {pack_len} is too small for even an empty pack with shortest hash"
-            )));
+            ))
+            .raise_erased());
         }
         let (kind, num_objects) = data::header::decode(
             &data[..data::header::SIZE]
diff --git a/gix-pack/src/data/file/verify.rs b/gix-pack/src/data/file/verify.rs
index a01fa7110ce..639341a14a0 100644
--- a/gix-pack/src/data/file/verify.rs
+++ b/gix-pack/src/data/file/verify.rs
@@ -1,15 +1,11 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_error::ExnResult;
+
 use gix_features::progress::Progress;
 
 use crate::data::File;
 
-///
-pub mod checksum {
-    /// Returned by [`data::File::verify_checksum()`][crate::data::File::verify_checksum()].
-    pub type Error = crate::verify::checksum::Error;
-}
-
 /// Checksums and verify checksums
 impl<T> File<T>
 where
@@ -32,7 +28,7 @@ where
         &self,
         progress: &mut dyn Progress,
         should_interrupt: &AtomicBool,
-    ) -> Result<gix_hash::ObjectId, checksum::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         crate::verify::checksum_on_disk_or_mmap(
             self.path(),
             &self.data,
diff --git a/gix-pack/src/data/header.rs b/gix-pack/src/data/header.rs
index fae3f31ab7a..9bc33f9d14f 100644
--- a/gix-pack/src/data/header.rs
+++ b/gix-pack/src/data/header.rs
@@ -1,4 +1,6 @@
 use crate::data;
+use gix_error::ErrorExt;
+use gix_error::ExnResult;
 
 pub(crate) const N32_SIZE: usize = std::mem::size_of::<u32>();
 
@@ -6,16 +8,16 @@ pub(crate) const N32_SIZE: usize = std::mem::size_of::<u32>();
 pub const SIZE: usize = b"PACK".len() + N32_SIZE * 2;
 
 /// Parses the first 12 bytes of a pack file, returning the pack version as well as the number of objects contained in the pack.
-pub fn decode(data: &[u8; SIZE]) -> Result<(data::Version, u32), decode::Error> {
+pub fn decode(data: &[u8; SIZE]) -> ExnResult<(data::Version, u32)> {
     let mut ofs = 0;
     if &data[ofs..ofs + b"PACK".len()] != b"PACK" {
-        return Err(decode::Error::Corrupt("Pack data type not recognized".into()));
+        return Err(gix_error::corruption("Pack data type not recognized").raise_erased());
     }
     ofs += N32_SIZE;
     let kind = match crate::read_u32(&data[ofs..ofs + N32_SIZE]) {
         2 => data::Version::V2,
         3 => data::Version::V3,
-        v => return Err(decode::Error::UnsupportedVersion(v)),
+        v => return Err(gix_error::validation(format!("Unsupported pack version: {v}")).raise_erased()),
     };
     ofs += N32_SIZE;
     let num_objects = crate::read_u32(&data[ofs..ofs + N32_SIZE]);
@@ -38,21 +40,3 @@ pub fn encode(version: data::Version, num_objects: u32) -> [u8; SIZE] {
     buf[8..].copy_from_slice(&num_objects.to_be_bytes()[..]);
     buf
 }
-
-///
-pub mod decode {
-    /// Returned by [`decode()`][super::decode()].
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not open pack file at '{path}'")]
-        Io {
-            source: std::io::Error,
-            path: std::path::PathBuf,
-        },
-        #[error("{0}")]
-        Corrupt(String),
-        #[error("Unsupported pack version: {0}")]
-        UnsupportedVersion(u32),
-    }
-}
diff --git a/gix-pack/src/data/input/bytes_to_entries.rs b/gix-pack/src/data/input/bytes_to_entries.rs
index 7fed68ef0fd..1785318f988 100644
--- a/gix-pack/src/data/input/bytes_to_entries.rs
+++ b/gix-pack/src/data/input/bytes_to_entries.rs
@@ -1,5 +1,6 @@
 use std::{fs, io};
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 use gix_hash::{Hasher, ObjectId};
 use gix_zlib::Decompress;
 
@@ -50,9 +51,9 @@ where
         mode: input::Mode,
         compressed: input::EntryDataMode,
         object_hash: gix_hash::Kind,
-    ) -> Result<BytesToEntriesIter<BR>, input::Error> {
+    ) -> ExnResult<BytesToEntriesIter<BR>> {
         let mut header_data = [0u8; crate::data::header::SIZE];
-        read.read_exact(&mut header_data).map_err(gix_hash::io::from_std_io)?;
+        read.read_exact(&mut header_data).map_err(io_error)?;
 
         let (version, num_objects) = crate::data::header::decode(&header_data)?;
         Ok(BytesToEntriesIter {
@@ -75,7 +76,7 @@ where
         })
     }
 
-    fn next_inner(&mut self) -> Result<input::Entry, input::Error> {
+    fn next_inner(&mut self) -> ExnResult<input::Entry> {
         self.objects_left -= 1; // even an error counts as objects
 
         // Read header
@@ -92,7 +93,7 @@ where
             }
             None => crate::data::Entry::from_read(&mut self.read, self.offset, self.hash_len),
         }
-        .map_err(gix_hash::io::from_std_io)?;
+        .map_err(io_error)?;
 
         // Decompress object to learn its compressed bytes
         let compressed_buf = self.compressed_buf.take().unwrap_or_else(|| Vec::with_capacity(4096));
@@ -112,12 +113,13 @@ where
             decompressor: &mut self.decompressor,
         };
 
-        let bytes_copied = io::copy(&mut decompressed_reader, &mut io::sink()).map_err(gix_hash::io::from_std_io)?;
+        let bytes_copied = io::copy(&mut decompressed_reader, &mut io::sink()).map_err(io_error)?;
         if bytes_copied != entry.decompressed_size {
-            return Err(input::Error::IncompletePack {
-                actual: bytes_copied,
-                expected: entry.decompressed_size,
-            });
+            return Err(gix_error::corruption(format!(
+                "pack is incomplete: it was decompressed into {bytes_copied} bytes but {} bytes where expected.",
+                entry.decompressed_size
+            ))
+            .raise_erased());
         }
 
         let pack_offset = self.offset;
@@ -139,7 +141,7 @@ where
             let header_len = entry
                 .header
                 .write_to(bytes_copied, &mut header_buf.as_mut())
-                .map_err(gix_hash::io::from_std_io)?;
+                .map_err(io_error)?;
             let state = gix_features::hash::crc32_update(0, &header_buf[..header_len]);
             Some(gix_features::hash::crc32_update(state, &compressed))
         } else {
@@ -168,27 +170,36 @@ where
         })
     }
 
-    fn try_read_trailer(&mut self) -> Result<Option<ObjectId>, input::Error> {
+    fn try_read_trailer(&mut self) -> ExnResult<Option<ObjectId>> {
         Ok(if self.objects_left == 0 {
             let mut id = gix_hash::ObjectId::null(self.object_hash);
             if let Err(err) = self.read.read_exact(id.as_mut_slice())
                 && self.mode != input::Mode::Restore
             {
-                return Err(input::Error::Io(err));
+                return Err(io_error(err));
             }
 
             if let Some(hash) = self.hash.take() {
-                let actual_id = hash.try_finalize().map_err(gix_hash::io::from_hasher)?;
+                let actual_id = hash
+                    .try_finalize()
+                    .map_err(gix_hash::io::from_hasher)
+                    .map_err(hash_io_error)?;
                 if self.mode == input::Mode::Restore {
                     id = actual_id;
                 } else {
-                    actual_id.verify(&id)?;
+                    actual_id
+                        .verify(&id)
+                        .or_raise_erased(|| message("Failed to verify pack checksum in trailer"))?;
                 }
             }
             Some(id)
         } else if self.mode == input::Mode::Restore {
             let hash = self.hash.clone().expect("in restore mode a hash is set");
-            Some(hash.try_finalize().map_err(gix_hash::io::from_hasher)?)
+            Some(
+                hash.try_finalize()
+                    .map_err(gix_hash::io::from_hasher)
+                    .map_err(hash_io_error)?,
+            )
         } else {
             None
         })
@@ -203,7 +214,7 @@ impl<R> Iterator for BytesToEntriesIter<R>
 where
     R: io::BufRead,
 {
-    type Item = Result<input::Entry, input::Error>;
+    type Item = ExnResult<input::Entry>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.had_error || self.objects_left == 0 {
@@ -272,9 +283,8 @@ where
     T: crate::FileData,
 {
     /// Returns an iterator over [`Entries`][crate::data::input::Entry], without making use of the memory mapping.
-    pub fn streaming_iter(&self) -> Result<BytesToEntriesIter<impl io::BufRead>, input::Error> {
-        let reader =
-            io::BufReader::with_capacity(4096 * 8, fs::File::open(&self.path).map_err(gix_hash::io::from_std_io)?);
+    pub fn streaming_iter(&self) -> ExnResult<BytesToEntriesIter<impl io::BufRead>> {
+        let reader = io::BufReader::with_capacity(4096 * 8, fs::File::open(&self.path).map_err(io_error)?);
         BytesToEntriesIter::new_from_header(
             reader,
             input::Mode::Verify,
@@ -284,6 +294,16 @@ where
     }
 }
 
+fn io_error(err: io::Error) -> gix_error::Exn {
+    err.and_raise(message("An IO operation failed while streaming an entry"))
+        .erased()
+}
+
+fn hash_io_error(err: gix_error::Exn) -> gix_error::Exn {
+    err.raise(message("An IO operation failed while streaming an entry"))
+        .erased()
+}
+
 /// The boxed variant is faster for what we do (moving the decompressor in and out a lot)
 pub struct DecompressRead<'a, R> {
     /// The reader from which bytes should be decompressed.
diff --git a/gix-pack/src/data/input/entries_to_bytes.rs b/gix-pack/src/data/input/entries_to_bytes.rs
index 67774661268..5d1b1285ac0 100644
--- a/gix-pack/src/data/input/entries_to_bytes.rs
+++ b/gix-pack/src/data/input/entries_to_bytes.rs
@@ -1,5 +1,7 @@
 use std::iter::Peekable;
 
+use gix_error::{ExnResult, message};
+
 use crate::data::input;
 
 /// An implementation of [`Iterator`] to write [encoded entries][input::Entry] to an inner implementation each time
@@ -27,7 +29,7 @@ pub struct EntriesToBytesIter<I: Iterator, W> {
 
 impl<I, W> EntriesToBytesIter<I, W>
 where
-    I: Iterator<Item = Result<input::Entry, input::Error>>,
+    I: Iterator<Item = ExnResult<input::Entry>>,
     W: std::io::Read + std::io::Write + std::io::Seek,
 {
     /// Create a new instance reading [entries][input::Entry] from an `input` iterator and write pack data bytes to
@@ -52,7 +54,7 @@ where
         self.trailer
     }
 
-    fn next_inner(&mut self, entry: input::Entry) -> Result<input::Entry, gix_hash::io::Error> {
+    fn next_inner(&mut self, entry: input::Entry) -> ExnResult<input::Entry> {
         if self.num_entries == 0 {
             let header_bytes = crate::data::header::encode(self.data_version, 0);
             self.output
@@ -75,7 +77,7 @@ where
         Ok(entry)
     }
 
-    fn write_header_and_digest(&mut self, last_entry: Option<&mut input::Entry>) -> Result<(), gix_hash::io::Error> {
+    fn write_header_and_digest(&mut self, last_entry: Option<&mut input::Entry>) -> ExnResult {
         let header_bytes = crate::data::header::encode(self.data_version, self.num_entries);
         let num_bytes_written = if last_entry.is_some() {
             self.output.stream_position().map_err(gix_hash::io::from_std_io)?
@@ -113,11 +115,11 @@ where
 
 impl<I, W> Iterator for EntriesToBytesIter<I, W>
 where
-    I: Iterator<Item = Result<input::Entry, input::Error>>,
+    I: Iterator<Item = ExnResult<input::Entry>>,
     W: std::io::Read + std::io::Write + std::io::Seek,
 {
     /// The amount of bytes written to `out` if `Ok` or the error `E` received from the input.
-    type Item = Result<input::Entry, input::Error>;
+    type Item = ExnResult<input::Entry>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.is_done {
@@ -135,7 +137,7 @@ where
                             Ok(entry)
                         }
                     })
-                    .map_err(input::Error::from),
+                    .map_err(hash_io_error),
                 Err(err) => {
                     self.is_done = true;
                     Err(err)
@@ -143,7 +145,7 @@ where
             }),
             None => match self.write_header_and_digest(None) {
                 Ok(_) => None,
-                Err(err) => Some(Err(err.into())),
+                Err(err) => Some(Err(hash_io_error(err))),
             },
         }
     }
@@ -152,3 +154,8 @@ where
         self.input.size_hint()
     }
 }
+
+fn hash_io_error(err: gix_error::Exn) -> gix_error::Exn {
+    err.raise(message("An IO operation failed while streaming an entry"))
+        .erased()
+}
diff --git a/gix-pack/src/data/input/entry.rs b/gix-pack/src/data/input/entry.rs
index f5b3ea3e462..f2d43cc1382 100644
--- a/gix-pack/src/data/input/entry.rs
+++ b/gix-pack/src/data/input/entry.rs
@@ -1,5 +1,7 @@
 use std::io::Write;
 
+use gix_error::{ErrorExt, ExnResult, message};
+
 use crate::data::{entry::Header, input};
 
 impl input::Entry {
@@ -11,7 +13,7 @@ impl input::Entry {
         obj: &gix_object::Data<'_>,
         pack_offset: u64,
         compression: gix_zlib::Compression,
-    ) -> Result<Self, input::Error> {
+    ) -> ExnResult<Self> {
         let header = to_header(obj.kind);
         let compressed = compress_data(obj, compression)?;
         let compressed_size = compressed.len() as u64;
@@ -55,11 +57,15 @@ fn to_header(kind: gix_object::Kind) -> Header {
     }
 }
 
-fn compress_data(obj: &gix_object::Data<'_>, compression: gix_zlib::Compression) -> Result<Vec<u8>, input::Error> {
+fn compress_data(obj: &gix_object::Data<'_>, compression: gix_zlib::Compression) -> ExnResult<Vec<u8>> {
     let mut out = gix_zlib::stream::deflate::Write::new(Vec::new(), compression);
     if let Err(err) = std::io::copy(&mut &*obj.data, &mut out) {
         match err.kind() {
-            std::io::ErrorKind::Other => return Err(input::Error::Io(err)),
+            std::io::ErrorKind::Other => {
+                return Err(err
+                    .and_raise(message("An IO operation failed while streaming an entry"))
+                    .erased());
+            }
             err => {
                 unreachable!("Should never see other errors than zlib, but got {:?}", err)
             }
diff --git a/gix-pack/src/data/input/lookup_ref_delta_objects.rs b/gix-pack/src/data/input/lookup_ref_delta_objects.rs
index 21e88748dc7..34c2a6cbf4a 100644
--- a/gix-pack/src/data/input/lookup_ref_delta_objects.rs
+++ b/gix-pack/src/data/input/lookup_ref_delta_objects.rs
@@ -1,3 +1,5 @@
+use gix_error::ErrorExt;
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 
 use crate::data::{entry::Header, input};
@@ -21,7 +23,7 @@ pub struct LookupRefDeltaObjectsIter<I, Find> {
 
 impl<I, Find> LookupRefDeltaObjectsIter<I, Find>
 where
-    I: Iterator<Item = Result<input::Entry, input::Error>>,
+    I: Iterator<Item = ExnResult<input::Entry>>,
     Find: gix_object::Find,
 {
     /// Create a new instance wrapping `iter` and using `lookup` as function to retrieve objects that will serve as bases
@@ -75,10 +77,10 @@ where
 
 impl<I, Find> Iterator for LookupRefDeltaObjectsIter<I, Find>
 where
-    I: Iterator<Item = Result<input::Entry, input::Error>>,
+    I: Iterator<Item = ExnResult<input::Entry>>,
     Find: gix_object::Find,
 {
-    type Item = Result<input::Entry, input::Error>;
+    type Item = ExnResult<input::Entry>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(delta) = self.next_delta.take() {
@@ -133,10 +135,11 @@ where
                             let Some(base_pack_offset) =
                                 Header::verified_base_pack_offset(entry.pack_offset, base_distance)
                             else {
-                                return Some(Err(input::Error::InvalidBaseDistance {
-                                    pack_offset: entry.pack_offset,
-                                    distance: base_distance,
-                                }));
+                                return Some(Err(gix_error::corruption(format!(
+                                    "The OFS_DELTA base distance {base_distance} is invalid for pack offset {}",
+                                    entry.pack_offset
+                                ))
+                                .raise_erased()));
                             };
                             match self
                                 .inserted_entry_length_at_offset
diff --git a/gix-pack/src/data/input/mod.rs b/gix-pack/src/data/input/mod.rs
index a6476fd7a9a..dc9378901f9 100644
--- a/gix-pack/src/data/input/mod.rs
+++ b/gix-pack/src/data/input/mod.rs
@@ -29,7 +29,7 @@ pub struct Entry {
 mod entry;
 
 mod types;
-pub use types::{EntryDataMode, Error, Mode};
+pub use types::{EntryDataMode, Mode};
 
 mod bytes_to_entries;
 pub use bytes_to_entries::BytesToEntriesIter;
diff --git a/gix-pack/src/data/input/types.rs b/gix-pack/src/data/input/types.rs
index 4c7a7ba2168..35d4594a4d5 100644
--- a/gix-pack/src/data/input/types.rs
+++ b/gix-pack/src/data/input/types.rs
@@ -1,28 +1,3 @@
-/// Returned by [`BytesToEntriesIter::new_from_header()`][crate::data::input::BytesToEntriesIter::new_from_header()] and as part
-/// of `Item` of [`BytesToEntriesIter`][crate::data::input::BytesToEntriesIter].
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("An IO operation failed while streaming an entry")]
-    Io(#[from] std::io::Error),
-    #[error(transparent)]
-    PackParse(#[from] crate::data::header::decode::Error),
-    #[error("Failed to verify pack checksum in trailer")]
-    Verify(#[from] gix_hash::verify::Error),
-    #[error("pack is incomplete: it was decompressed into {actual} bytes but {expected} bytes where expected.")]
-    IncompletePack { actual: u64, expected: u64 },
-    #[error("The object {object_id} could not be decoded or wasn't found")]
-    NotFound { object_id: gix_hash::ObjectId },
-    #[error("The OFS_DELTA base distance {distance} is invalid for pack offset {pack_offset}")]
-    InvalidBaseDistance { pack_offset: u64, distance: u64 },
-}
-
-impl From<gix_hash::io::Error> for Error {
-    fn from(err: gix_hash::io::Error) -> Self {
-        Error::Io(std::io::Error::other(err.into_error()))
-    }
-}
-
 /// Iteration Mode
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/gix-pack/src/data/mod.rs b/gix-pack/src/data/mod.rs
index ffb37535a20..9268864da16 100644
--- a/gix-pack/src/data/mod.rs
+++ b/gix-pack/src/data/mod.rs
@@ -44,11 +44,6 @@ pub use file::{Header, decode, verify};
 ///
 pub mod header;
 
-///
-pub mod init {
-    pub use super::header::decode::Error;
-}
-
 ///
 pub mod entry;
 
diff --git a/gix-pack/src/data/output/bytes.rs b/gix-pack/src/data/output/bytes.rs
index 51f338980e2..776b4e0e34d 100644
--- a/gix-pack/src/data/output/bytes.rs
+++ b/gix-pack/src/data/output/bytes.rs
@@ -1,28 +1,8 @@
 use std::io::Write;
 
-use crate::{data::output, exact_vec};
-
-/// The error returned by `next()` in the [`FromEntriesIter`] iterator.
-#[expect(missing_docs)]
-#[derive(Debug, thiserror::Error)]
-pub enum Error<E>
-where
-    E: std::error::Error + 'static,
-{
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-    #[error(transparent)]
-    Input(E),
-}
+use gix_error::{ExnResult, ResultExt, message};
 
-impl<E> From<gix_hash::io::Error> for Error<E>
-where
-    E: std::error::Error + 'static,
-{
-    fn from(err: gix_hash::io::Error) -> Self {
-        Error::Io(std::io::Error::other(err.into_error()))
-    }
-}
+use crate::{data::output, exact_vec};
 
 /// An implementation of [`Iterator`] to write [encoded entries][output::Entry] to an inner implementation each time
 /// `next()` is called.
@@ -48,11 +28,10 @@ pub struct FromEntriesIter<I, W> {
     is_done: bool,
 }
 
-impl<I, W, E> FromEntriesIter<I, W>
+impl<I, W> FromEntriesIter<I, W>
 where
-    I: Iterator<Item = Result<Vec<output::Entry>, E>>,
+    I: Iterator<Item = ExnResult<Vec<output::Entry>>>,
     W: std::io::Write,
-    E: std::error::Error + 'static,
 {
     /// Create a new instance reading [entries][output::Entry] from an `input` iterator and write pack data bytes to
     /// `output` writer, resembling a pack of `version` with exactly `num_entries` amount of objects contained in it.
@@ -92,7 +71,7 @@ where
         self.trailer
     }
 
-    fn next_inner(&mut self) -> Result<u64, Error<E>> {
+    fn next_inner(&mut self) -> ExnResult<u64> {
         let previous_written = self.written;
         if let Some((version, num_entries)) = self.header_info.take() {
             let header_bytes = crate::data::header::encode(version, num_entries);
@@ -103,7 +82,7 @@ where
         }
         match self.input.next() {
             Some(entries) => {
-                for entry in entries.map_err(Error::Input)? {
+                for entry in entries.or_raise_erased(|| message("Pack entry input iterator failed"))? {
                     if entry.is_invalid() {
                         self.pack_offsets_and_validity.push((0, false));
                         continue;
@@ -144,14 +123,13 @@ where
     }
 }
 
-impl<I, W, E> Iterator for FromEntriesIter<I, W>
+impl<I, W> Iterator for FromEntriesIter<I, W>
 where
-    I: Iterator<Item = Result<Vec<output::Entry>, E>>,
+    I: Iterator<Item = ExnResult<Vec<output::Entry>>>,
     W: std::io::Write,
-    E: std::error::Error + 'static,
 {
     /// The amount of bytes written to `out` if `Ok` or the error `E` received from the input.
-    type Item = Result<u64, Error<E>>;
+    type Item = ExnResult<u64>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.is_done {
diff --git a/gix-pack/src/data/output/count/mod.rs b/gix-pack/src/data/output/count/mod.rs
index 481ff65d3c3..44cb1d572c7 100644
--- a/gix-pack/src/data/output/count/mod.rs
+++ b/gix-pack/src/data/output/count/mod.rs
@@ -45,5 +45,5 @@ pub use objects_impl::{objects, objects_unthreaded};
 
 ///
 pub mod objects {
-    pub use super::objects_impl::{Error, ObjectExpansion, Options, Outcome};
+    pub use super::objects_impl::{ObjectExpansion, Options, Outcome};
 }
diff --git a/gix-pack/src/data/output/count/objects/mod.rs b/gix-pack/src/data/output/count/objects/mod.rs
index 8d91e7b151e..0b972852e51 100644
--- a/gix-pack/src/data/output/count/objects/mod.rs
+++ b/gix-pack/src/data/output/count/objects/mod.rs
@@ -1,5 +1,7 @@
 use std::{cell::RefCell, sync::atomic::AtomicBool};
 
+use gix_error::ExnResult;
+
 use gix_features::parallel;
 use gix_hash::ObjectId;
 
@@ -9,7 +11,7 @@ pub(in crate::data::output::count::objects_impl) mod reduce;
 mod util;
 
 mod types;
-pub use types::{Error, ObjectExpansion, Options, Outcome};
+pub use types::{ObjectExpansion, Options, Outcome};
 
 mod tree;
 
@@ -31,7 +33,7 @@ mod tree;
 ///   * more configuration
 pub fn objects<Find>(
     db: Find,
-    objects_ids: Box<dyn Iterator<Item = Result<ObjectId, Box<dyn std::error::Error + Send + Sync + 'static>>> + Send>,
+    objects_ids: Box<dyn Iterator<Item = ExnResult<ObjectId>> + Send>,
     objects: &dyn gix_features::progress::Count,
     should_interrupt: &AtomicBool,
     Options {
@@ -39,7 +41,7 @@ pub fn objects<Find>(
         input_object_expansion,
         chunk_size,
     }: Options,
-) -> Result<(Vec<output::Count>, Outcome), Error>
+) -> ExnResult<(Vec<output::Count>, Outcome)>
 where
     Find: crate::Find + Send + Clone,
 {
@@ -92,11 +94,11 @@ where
 /// Like [`objects()`] but using a single thread only to mostly save on the otherwise required overhead.
 pub fn objects_unthreaded(
     db: &dyn crate::Find,
-    object_ids: &mut dyn Iterator<Item = Result<ObjectId, Box<dyn std::error::Error + Send + Sync + 'static>>>,
+    object_ids: &mut dyn Iterator<Item = ExnResult<ObjectId>>,
     objects: &dyn gix_features::progress::Count,
     should_interrupt: &AtomicBool,
     input_object_expansion: ObjectExpansion,
-) -> Result<(Vec<output::Count>, Outcome), Error> {
+) -> ExnResult<(Vec<output::Count>, Outcome)> {
     let seen_objs = RefCell::new(gix_hashtable::HashSet::default());
 
     let (mut buf1, mut buf2) = (Vec::new(), Vec::new());
@@ -119,12 +121,13 @@ mod expand {
         sync::atomic::{AtomicBool, Ordering},
     };
 
+    use gix_error::{ErrorExt, ExnResult, ResultExt, message, retryable};
     use gix_hash::{ObjectId, oid};
     use gix_object::{CommitRefIter, Data, TagRefIter};
 
     use super::{
         tree,
-        types::{Error, ObjectExpansion, Outcome},
+        types::{ObjectExpansion, Outcome},
         util,
     };
     use crate::{
@@ -137,13 +140,13 @@ mod expand {
         db: &dyn crate::Find,
         input_object_expansion: ObjectExpansion,
         seen_objs: &impl util::InsertImmutable,
-        oids: &mut dyn Iterator<Item = Result<ObjectId, Box<dyn std::error::Error + Send + Sync + 'static>>>,
+        oids: &mut dyn Iterator<Item = ExnResult<ObjectId>>,
         buf1: &mut Vec<u8>,
         buf2: &mut Vec<u8>,
         objects: &gix_features::progress::AtomicStep,
         should_interrupt: &AtomicBool,
         allow_pack_lookups: bool,
-    ) -> Result<(Vec<output::Count>, Outcome), Error> {
+    ) -> ExnResult<(Vec<output::Count>, Outcome)> {
         use ObjectExpansion::*;
 
         let mut out = Vec::new();
@@ -157,10 +160,10 @@ mod expand {
         let stats = &mut outcome;
         for id in oids {
             if should_interrupt.load(Ordering::Relaxed) {
-                return Err(Error::Interrupted);
+                return Err(retryable("Operation interrupted").raise_erased());
             }
 
-            let id = id.map_err(Error::InputIteration)?;
+            let id = id.or_raise_erased(|| message("Could not iterate input objects"))?;
             let (obj, location) = db.find(&id, buf1)?;
             stats.input_objects += 1;
             match input_object_expansion {
@@ -197,7 +200,7 @@ mod expand {
                                                 parent_commit_ids.push(id);
                                             }
                                             Ok(_) => break,
-                                            Err(err) => return Err(Error::CommitDecode(err)),
+                                            Err(err) => return Err(err.erased()),
                                         }
                                     }
                                     let (obj, location) = db.find(&tree_id, buf1)?;
@@ -215,8 +218,7 @@ mod expand {
                                         &mut tree_traversal_state,
                                         &objects,
                                         &mut traverse_delegate,
-                                    )
-                                    .map_err(Error::TreeTraverse)?;
+                                    )?;
                                     out = objects.dissolve(stats);
                                     &traverse_delegate.non_trees
                                 } else {
@@ -260,7 +262,7 @@ mod expand {
                                             &objects,
                                             &mut changes_delegate,
                                         )
-                                        .map_err(Error::TreeChanges)?;
+                                        .or_raise_erased(|| message("Could not compare trees while generating pack"))?;
                                         stats.decoded_objects += objects.into_count();
                                     }
                                     &changes_delegate.objects
@@ -289,8 +291,7 @@ mod expand {
                                         &mut tree_traversal_state,
                                         &objects,
                                         &mut traverse_delegate,
-                                    )
-                                    .map_err(Error::TreeTraverse)?;
+                                    )?;
                                     out = objects.dissolve(stats);
                                 }
                                 for id in &traverse_delegate.non_trees {
@@ -386,7 +387,7 @@ mod expand {
     }
 
     impl gix_object::Find for CountingObjects<'_> {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             let res = Ok(self.objects.try_find(id, buffer)?.map(|t| t.0));
             *self.decoded_objects.borrow_mut() += 1;
             res
@@ -424,7 +425,7 @@ mod expand {
     }
 
     impl gix_object::Find for ExpandedCountingObjects<'_> {
-        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             let maybe_obj = self.objects.try_find(id, buffer)?;
             *self.decoded_objects.borrow_mut() += 1;
             match maybe_obj {
diff --git a/gix-pack/src/data/output/count/objects/types.rs b/gix-pack/src/data/output/count/objects/types.rs
index 117a22ccd6d..6e0ee712d7a 100644
--- a/gix-pack/src/data/output/count/objects/types.rs
+++ b/gix-pack/src/data/output/count/objects/types.rs
@@ -76,21 +76,3 @@ impl Default for Options {
         }
     }
 }
-
-/// The error returned by the pack generation iterator [`bytes::FromEntriesIter`][crate::data::output::bytes::FromEntriesIter].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    CommitDecode(gix_object::decode::Error),
-    #[error(transparent)]
-    FindExisting(#[from] gix_object::find::existing::Error),
-    #[error(transparent)]
-    InputIteration(Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error(transparent)]
-    TreeTraverse(gix_traverse::tree::breadthfirst::Error),
-    #[error(transparent)]
-    TreeChanges(gix_diff::tree::Error),
-    #[error("Operation interrupted")]
-    Interrupted,
-}
diff --git a/gix-pack/src/data/output/entry/iter_from_counts.rs b/gix-pack/src/data/output/entry/iter_from_counts.rs
index 2147e755c4b..8fe810e9ab0 100644
--- a/gix-pack/src/data/output/entry/iter_from_counts.rs
+++ b/gix-pack/src/data/output/entry/iter_from_counts.rs
@@ -1,6 +1,7 @@
 pub(crate) mod function {
     use std::{cmp::Ordering, sync::Arc};
 
+    use gix_error::{ExnResult, ResultExt, message};
     use gix_features::{
         parallel,
         parallel::SequenceId,
@@ -10,7 +11,7 @@ pub(crate) mod function {
         },
     };
 
-    use super::{Error, Mode, Options, Outcome, ProgressId, reduce, util};
+    use super::{Mode, Options, Outcome, ProgressId, reduce, util};
     use crate::data::output;
 
     /// Given a known list of object `counts`, calculate entries ready to be put into a data pack.
@@ -54,8 +55,8 @@ pub(crate) mod function {
             chunk_size,
             compression,
         }: Options,
-    ) -> impl Iterator<Item = Result<(SequenceId, Vec<output::Entry>), Error>>
-    + parallel::reduce::Finalize<Reduce = reduce::Statistics<Error>>
+    ) -> impl Iterator<Item = ExnResult<(SequenceId, Vec<output::Entry>)>>
+    + parallel::reduce::Finalize<Reduce = reduce::Statistics<gix_error::Exn>>
     where
         Find: crate::Find + Send + Clone + 'static,
     {
@@ -208,19 +209,26 @@ pub(crate) mod function {
                                         stats.objects_copied_from_pack += 1;
                                         entry
                                     }
-                                    None => match db.try_find(&count.id, buf).map_err(Error::Find)? {
-                                        Some((obj, _location)) => {
-                                            stats.decoded_and_recompressed_objects += 1;
-                                            output::Entry::from_data(count, &obj, compression)
+                                    None => {
+                                        match db.try_find(&count.id, buf).or_raise_erased(|| {
+                                            message("Could not find object while generating pack")
+                                        })? {
+                                            Some((obj, _location)) => {
+                                                stats.decoded_and_recompressed_objects += 1;
+                                                output::Entry::from_data(count, &obj, compression)
+                                            }
+                                            None => {
+                                                stats.missing_objects += 1;
+                                                Ok(output::Entry::invalid())
+                                            }
                                         }
-                                        None => {
-                                            stats.missing_objects += 1;
-                                            Ok(output::Entry::invalid())
-                                        }
-                                    },
+                                    }
                                 }
                             }
-                            None => match db.try_find(&count.id, buf).map_err(Error::Find)? {
+                            None => match db
+                                .try_find(&count.id, buf)
+                                .or_raise_erased(|| message("Could not find object while generating pack"))?
+                            {
                                 Some((obj, _location)) => {
                                     stats.decoded_and_recompressed_objects += 1;
                                     output::Entry::from_data(count, &obj, compression)
@@ -317,8 +325,6 @@ mod reduce {
 }
 
 mod types {
-    use crate::data::output::entry;
-
     /// Information gathered during the run of [`iter_from_counts()`][crate::data::output::entry::iter_from_counts()].
     #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -404,16 +410,6 @@ mod types {
         }
     }
 
-    /// The error returned by the pack generation function [`iter_from_counts()`][crate::data::output::entry::iter_from_counts()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Find(gix_object::find::Error),
-        #[error(transparent)]
-        NewEntry(#[from] entry::Error),
-    }
-
     /// The progress ids used in [`write_to_directory()`][crate::Bundle::write_to_directory()].
     ///
     /// Use this information to selectively extract the progress of interest in case the parent application has custom visualization.
@@ -434,4 +430,4 @@ mod types {
         }
     }
 }
-pub use types::{Error, Mode, Options, Outcome, ProgressId};
+pub use types::{Mode, Options, Outcome, ProgressId};
diff --git a/gix-pack/src/data/output/entry/mod.rs b/gix-pack/src/data/output/entry/mod.rs
index 647e02a97a2..5b158760c37 100644
--- a/gix-pack/src/data/output/entry/mod.rs
+++ b/gix-pack/src/data/output/entry/mod.rs
@@ -1,5 +1,6 @@
 use std::io::Write;
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 use gix_hash::ObjectId;
 
 use crate::{data, data::output, find};
@@ -31,16 +32,6 @@ pub enum Kind {
     },
 }
 
-/// The error returned by [`output::Entry::from_data()`].
-#[expect(missing_docs)]
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("{0}")]
-    ZlibDeflate(#[from] std::io::Error),
-    #[error(transparent)]
-    EntryType(#[from] crate::data::entry::decode::Error),
-}
-
 impl output::Entry {
     /// An object which can be identified as invalid easily which happens if objects didn't exist even if they were referred to.
     pub fn invalid() -> output::Entry {
@@ -70,7 +61,7 @@ impl output::Entry {
         bases_index_offset: usize,
         pack_offset_to_oid: Option<impl FnMut(u32, u64) -> Option<ObjectId>>,
         target_version: data::Version,
-    ) -> Option<Result<Self, Error>> {
+    ) -> Option<ExnResult<Self>> {
         if entry.version != target_version {
             return None;
         }
@@ -78,7 +69,7 @@ impl output::Entry {
         let pack_offset_must_be_zero = 0;
         let pack_entry = match data::Entry::from_bytes(&entry.data, pack_offset_must_be_zero, count.id.kind()) {
             Ok(e) => e,
-            Err(err) => return Some(Err(err.into())),
+            Err(err) => return Some(Err(err.erased())),
         };
 
         use crate::data::entry::Header::*;
@@ -92,10 +83,10 @@ impl output::Entry {
                 let Some(base_offset) =
                     crate::data::entry::Header::verified_base_pack_offset(pack_location.pack_offset, base_distance)
                 else {
-                    return Some(Err(crate::data::entry::decode::Error::Corrupt {
-                        message: "an ofs-delta base distance pointing before pack start",
-                    }
-                    .into()));
+                    return Some(Err(gix_error::corruption(
+                        "an ofs-delta base distance pointing before pack start",
+                    )
+                    .raise_erased()));
                 };
                 potential_bases
                     .binary_search_by(|e| {
@@ -144,7 +135,7 @@ impl output::Entry {
         count: &output::Count,
         obj: &gix_object::Data<'_>,
         compression: gix_zlib::Compression,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         Ok(output::Entry {
             id: count.id.to_owned(),
             kind: Kind::Base(obj.kind),
@@ -153,11 +144,14 @@ impl output::Entry {
                 let mut out = gix_zlib::stream::deflate::Write::new(Vec::new(), compression);
                 if let Err(err) = std::io::copy(&mut &*obj.data, &mut out) {
                     match err.kind() {
-                        std::io::ErrorKind::Other => return Err(Error::ZlibDeflate(err)),
+                        std::io::ErrorKind::Other => {
+                            return Err(err.and_raise(message("Failed to compress pack entry")).erased());
+                        }
                         err => unreachable!("Should never see other errors than zlib, but got {:?}", err),
                     }
                 }
-                out.flush()?;
+                out.flush()
+                    .or_raise_erased(|| message("Failed to finish compressing pack entry"))?;
                 out.into_inner()
             },
         })
diff --git a/gix-pack/src/find_traits.rs b/gix-pack/src/find_traits.rs
index 787ed5b635e..4d3cec06024 100644
--- a/gix-pack/src/find_traits.rs
+++ b/gix-pack/src/find_traits.rs
@@ -1,4 +1,5 @@
 use crate::{data, find};
+use gix_error::ExnResult;
 
 /// Describe how object can be located in an object store with built-in facilities to supports packs specifically.
 ///
@@ -25,7 +26,7 @@ pub trait Find {
         &self,
         id: &gix_hash::oid,
         buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error> {
+    ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>> {
         self.try_find_cached(id, buffer, &mut crate::cache::Never)
     }
 
@@ -40,7 +41,7 @@ pub trait Find {
         id: &gix_hash::oid,
         buffer: &'a mut Vec<u8>,
         pack_cache: &mut dyn crate::cache::DecodeEntry,
-    ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error>;
+    ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>>;
 
     /// Find the packs location where an object with `id` can be found in the database, or `None` if there is no pack
     /// holding the object.
@@ -64,8 +65,17 @@ pub trait Find {
 }
 
 mod ext {
+    use gix_error::{ErrorExt, ExnResult, ResultExt};
     use gix_object::{BlobRef, CommitRef, CommitRefIter, Kind, ObjectRef, TagRef, TagRefIter, TreeRef, TreeRefIter};
 
+    fn not_found(id: &gix_hash::oid) -> gix_error::Exn {
+        gix_error::not_found(format!("An object with id {id} could not be found")).raise_erased()
+    }
+
+    fn wrong_kind(id: &gix_hash::oid, actual: Kind, expected: Kind) -> gix_error::Exn {
+        gix_error::validation(format!("Expected object of kind {expected} but got {actual} at {id}")).raise_erased()
+    }
+
     macro_rules! make_obj_lookup {
         ($method:ident, $object_variant:path, $object_kind:path, $object_type:ty) => {
             /// Like [`find(…)`][Self::find()], but flattens the `Result<Option<_>>` into a single `Result` making a non-existing object an error
@@ -74,29 +84,18 @@ mod ext {
                 &self,
                 id: &gix_hash::oid,
                 buffer: &'a mut Vec<u8>,
-            ) -> Result<($object_type, Option<crate::data::entry::Location>), gix_object::find::existing_object::Error>
-            {
+            ) -> ExnResult<($object_type, Option<crate::data::entry::Location>)> {
                 let id = id.as_ref();
-                self.try_find(id, buffer)
-                    .map_err(gix_object::find::existing_object::Error::Find)?
-                    .ok_or_else(|| gix_object::find::existing_object::Error::NotFound {
-                        oid: id.as_ref().to_owned(),
-                    })
+                self.try_find(id, buffer)?
+                    .ok_or_else(|| not_found(id))
                     .and_then(|(o, l)| {
                         o.decode()
-                            .map_err(|err| gix_object::find::existing_object::Error::Decode {
-                                source: err,
-                                oid: id.to_owned(),
-                            })
+                            .or_raise_erased(|| gix_error::corruption(format!("Could not decode object at {id}")))
                             .map(|o| (o, l))
                     })
                     .and_then(|(o, l)| match o {
                         $object_variant(o) => return Ok((o, l)),
-                        o => Err(gix_object::find::existing_object::Error::ObjectKind {
-                            oid: id.to_owned(),
-                            actual: o.kind(),
-                            expected: $object_kind,
-                        }),
+                        o => Err(wrong_kind(id, o.kind(), $object_kind)),
                     })
             }
         };
@@ -110,20 +109,13 @@ mod ext {
                 &self,
                 id: &gix_hash::oid,
                 buffer: &'a mut Vec<u8>,
-            ) -> Result<($object_type, Option<crate::data::entry::Location>), gix_object::find::existing_iter::Error> {
+            ) -> ExnResult<($object_type, Option<crate::data::entry::Location>)> {
                 let id = id.as_ref();
-                self.try_find(id, buffer)
-                    .map_err(gix_object::find::existing_iter::Error::Find)?
-                    .ok_or_else(|| gix_object::find::existing_iter::Error::NotFound {
-                        oid: id.as_ref().to_owned(),
-                    })
+                self.try_find(id, buffer)?
+                    .ok_or_else(|| not_found(id))
                     .and_then(|(o, l)| {
                         o.$into_iter()
-                            .ok_or_else(|| gix_object::find::existing_iter::Error::ObjectKind {
-                                oid: id.to_owned(),
-                                actual: o.kind,
-                                expected: $object_kind,
-                            })
+                            .ok_or_else(|| wrong_kind(id, o.kind, $object_kind))
                             .map(|i| (i, l))
                     })
             }
@@ -137,13 +129,8 @@ mod ext {
             &self,
             id: &gix_hash::oid,
             buffer: &'a mut Vec<u8>,
-        ) -> Result<(gix_object::Data<'a>, Option<crate::data::entry::Location>), gix_object::find::existing::Error>
-        {
-            self.try_find(id, buffer)
-                .map_err(gix_object::find::existing::Error::Find)?
-                .ok_or_else(|| gix_object::find::existing::Error::NotFound {
-                    oid: id.as_ref().to_owned(),
-                })
+        ) -> ExnResult<(gix_object::Data<'a>, Option<crate::data::entry::Location>)> {
+            self.try_find(id, buffer)?.ok_or_else(|| not_found(id))
         }
 
         make_obj_lookup!(find_commit, ObjectRef::Commit, Kind::Commit, CommitRef<'a>);
@@ -162,6 +149,8 @@ pub use ext::FindExt;
 mod find_impls {
     use std::{ops::Deref, rc::Rc};
 
+    use gix_error::ExnResult;
+
     use gix_hash::oid;
 
     use crate::{data, find};
@@ -179,7 +168,7 @@ mod find_impls {
             id: &oid,
             buffer: &'a mut Vec<u8>,
             pack_cache: &mut dyn crate::cache::DecodeEntry,
-        ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error> {
+        ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>> {
             (*self).try_find_cached(id, buffer, pack_cache)
         }
 
@@ -209,7 +198,7 @@ mod find_impls {
             id: &oid,
             buffer: &'a mut Vec<u8>,
             pack_cache: &mut dyn crate::cache::DecodeEntry,
-        ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error> {
+        ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>> {
             self.deref().try_find_cached(id, buffer, pack_cache)
         }
 
@@ -239,7 +228,7 @@ mod find_impls {
             id: &oid,
             buffer: &'a mut Vec<u8>,
             pack_cache: &mut dyn crate::cache::DecodeEntry,
-        ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error> {
+        ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>> {
             self.deref().try_find_cached(id, buffer, pack_cache)
         }
 
@@ -269,7 +258,7 @@ mod find_impls {
             id: &oid,
             buffer: &'a mut Vec<u8>,
             pack_cache: &mut dyn crate::cache::DecodeEntry,
-        ) -> Result<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>, gix_object::find::Error> {
+        ) -> ExnResult<Option<(gix_object::Data<'a>, Option<data::entry::Location>)>> {
             self.deref().try_find_cached(id, buffer, pack_cache)
         }
 
diff --git a/gix-pack/src/index/encode.rs b/gix-pack/src/index/encode.rs
index 583c1818664..af864ff94aa 100644
--- a/gix-pack/src/index/encode.rs
+++ b/gix-pack/src/index/encode.rs
@@ -36,6 +36,8 @@ pub(crate) fn fanout(iter: &mut dyn ExactSizeIterator<Item = u8>) -> [u32; 256]
 mod function {
     use std::io;
 
+    use gix_error::ExnResult;
+
     use gix_features::progress::{self, DynNestedProgress};
 
     use super::{HIGH_BIT, LARGE_OFFSET_THRESHOLD, fanout};
@@ -74,7 +76,7 @@ mod function {
         kind: crate::index::Version,
         object_hash: gix_hash::Kind,
         progress: &mut dyn DynNestedProgress,
-    ) -> Result<gix_hash::ObjectId, gix_hash::io::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         use io::Write;
         assert_eq!(kind, crate::index::Version::V2, "Can only write V2 packs right now");
         assert!(
diff --git a/gix-pack/src/index/init.rs b/gix-pack/src/index/init.rs
index aa1b01318e4..c5da16ee70c 100644
--- a/gix-pack/src/index/init.rs
+++ b/gix-pack/src/index/init.rs
@@ -1,23 +1,15 @@
 use std::{
+    borrow::Cow,
     mem::size_of,
     path::{Path, PathBuf},
 };
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
+
 use crate::index::{self, FAN_LEN, V2_SIGNATURE, Version};
 
-/// Returned by [`index::File::at()`].
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not open pack index file at '{path}'")]
-    Io {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error("{message}")]
-    Corrupt { message: String },
-    #[error("Unsupported index version: {version})")]
-    UnsupportedVersion { version: u32 },
+fn corrupt(message: impl Into<Cow<'static, str>>) -> gix_error::Exn {
+    gix_error::corruption(message).raise_erased()
 }
 
 const N32_SIZE: usize = size_of::<u32>();
@@ -28,15 +20,13 @@ impl index::File<crate::MMap> {
     ///
     /// The `object_hash` is a way to read (and write) the same file format with different hashes, as the hash kind
     /// isn't stored within the file format itself.
-    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    pub fn at(path: impl AsRef<Path>, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         Self::at_inner(path.as_ref(), object_hash)
     }
 
-    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> Result<Self, Error> {
-        let data = crate::mmap::read_only(path).map_err(|source| Error::Io {
-            source,
-            path: path.to_owned(),
-        })?;
+    fn at_inner(path: &Path, object_hash: gix_hash::Kind) -> ExnResult<Self> {
+        let data = crate::mmap::read_only(path)
+            .or_raise_erased(|| message!("Could not open pack index file at '{}'", path.display()))?;
         Self::from_data(data, path.to_owned(), object_hash)
     }
 }
@@ -46,15 +36,15 @@ where
     T: crate::FileData,
 {
     /// Instantiate an index file from `data` as assumed to be read or memory-mapped from `path`.
-    pub fn from_data(data: T, path: PathBuf, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    pub fn from_data(data: T, path: PathBuf, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         let idx_len = data.len();
         let hash_len = object_hash.len_in_bytes();
 
         let footer_size = hash_len * 2;
         if idx_len < FAN_LEN * N32_SIZE + footer_size {
-            return Err(Error::Corrupt {
-                message: format!("Pack index of size {idx_len} is too small for even an empty index"),
-            });
+            return Err(corrupt(format!(
+                "Pack index of size {idx_len} is too small for even an empty index"
+            )));
         }
         let (kind, fan, num_objects) = {
             let (kind, d) = {
@@ -70,7 +60,9 @@ where
                     let (vd, dr) = d.split_at(N32_SIZE);
                     let version = crate::read_u32(vd);
                     if version != Version::V2 as u32 {
-                        return Err(Error::UnsupportedVersion { version });
+                        return Err(
+                            gix_error::validation(format!("Unsupported index version: {version})")).raise_erased()
+                        );
                     }
                     dr
                 } else {
@@ -107,16 +99,14 @@ fn read_fan(d: &[u8]) -> ([u32; FAN_LEN], usize) {
     (fan, FAN_LEN * N32_SIZE)
 }
 
-fn validate_fan(fan: &[u32; FAN_LEN]) -> Result<(), Error> {
+fn validate_fan(fan: &[u32; FAN_LEN]) -> ExnResult {
     if !crate::fan_is_monotonically_increasing(fan) {
-        return Err(Error::Corrupt {
-            message: "Pack index fan-out table must be monotonically increasing".into(),
-        });
+        return Err(corrupt("Pack index fan-out table must be monotonically increasing"));
     }
     Ok(())
 }
 
-fn validate_size(data: &[u8], kind: Version, num_objects: u32, hash_len: usize) -> Result<(), Error> {
+fn validate_size(data: &[u8], kind: Version, num_objects: u32, hash_len: usize) -> ExnResult {
     let num_objects = num_objects as usize;
     let footer_size = hash_len * 2;
     let expected_size = match kind {
@@ -124,34 +114,28 @@ fn validate_size(data: &[u8], kind: Version, num_objects: u32, hash_len: usize)
             .checked_mul(N32_SIZE)
             .and_then(|size| size.checked_add(num_objects.checked_mul(N32_SIZE + hash_len)?))
             .and_then(|size| size.checked_add(footer_size))
-            .ok_or_else(|| Error::Corrupt {
-                message: "Pack index size overflowed while validating version 1 layout".into(),
-            })?,
+            .ok_or_else(|| corrupt("Pack index size overflowed while validating version 1 layout"))?,
         Version::V2 => {
             let v2_header_size = V2_SIGNATURE.len() + N32_SIZE + FAN_LEN * N32_SIZE;
-            let oid_bytes = num_objects.checked_mul(hash_len).ok_or_else(|| Error::Corrupt {
-                message: "Pack index size overflowed while validating object ids".into(),
-            })?;
-            let table_bytes = num_objects.checked_mul(N32_SIZE).ok_or_else(|| Error::Corrupt {
-                message: "Pack index size overflowed while validating 32-bit tables".into(),
-            })?;
+            let oid_bytes = num_objects
+                .checked_mul(hash_len)
+                .ok_or_else(|| corrupt("Pack index size overflowed while validating object ids"))?;
+            let table_bytes = num_objects
+                .checked_mul(N32_SIZE)
+                .ok_or_else(|| corrupt("Pack index size overflowed while validating 32-bit tables"))?;
             let offset32_start = v2_header_size
                 .checked_add(oid_bytes)
                 .and_then(|size| size.checked_add(table_bytes))
-                .ok_or_else(|| Error::Corrupt {
-                    message: "Pack index size overflowed while locating 32-bit offsets".into(),
-                })?;
-            let offset32_end = offset32_start.checked_add(table_bytes).ok_or_else(|| Error::Corrupt {
-                message: "Pack index size overflowed while locating 32-bit offsets".into(),
-            })?;
+                .ok_or_else(|| corrupt("Pack index size overflowed while locating 32-bit offsets"))?;
+            let offset32_end = offset32_start
+                .checked_add(table_bytes)
+                .ok_or_else(|| corrupt("Pack index size overflowed while locating 32-bit offsets"))?;
             if offset32_end > data.len() {
-                return Err(Error::Corrupt {
-                    message: format!(
-                        "Pack index of size {} is too small for {} objects in version 2",
-                        data.len(),
-                        num_objects
-                    ),
-                });
+                return Err(corrupt(format!(
+                    "Pack index of size {} is too small for {} objects in version 2",
+                    data.len(),
+                    num_objects
+                )));
             }
             let (large_offsets, max_large_offset_index) = data[offset32_start..offset32_end]
                 .as_chunks::<N32_SIZE>()
@@ -170,16 +154,12 @@ fn validate_size(data: &[u8], kind: Version, num_objects: u32, hash_len: usize)
                 .and_then(|size| size.checked_add(table_bytes))
                 .and_then(|size| size.checked_add(large_offsets.checked_mul(size_of::<u64>())?))
                 .and_then(|size| size.checked_add(footer_size))
-                .ok_or_else(|| Error::Corrupt {
-                    message: "Pack index size overflowed while validating version 2 layout".into(),
-                })
+                .ok_or_else(|| corrupt("Pack index size overflowed while validating version 2 layout"))
                 .and_then(|expected_size| {
                     if large_offsets > 0 && max_large_offset_index >= large_offsets {
-                        return Err(Error::Corrupt {
-                            message: format!(
+                        return Err(corrupt(format!(
                                 "Pack index references large offset {max_large_offset_index}, but only {large_offsets} large offsets are present"
-                            ),
-                        });
+                            )));
                     }
                     Ok(expected_size)
                 })?
@@ -188,12 +168,10 @@ fn validate_size(data: &[u8], kind: Version, num_objects: u32, hash_len: usize)
     if data.len() != expected_size {
         // Aborting here is needed for protection against malformed inputs, or the offset access done later can panic
         // as it's done without explicit error handling.
-        return Err(Error::Corrupt {
-            message: format!(
-                "Pack index size is incorrect, expected {expected_size} bytes for {num_objects} objects in version {kind:?}, but got {} bytes",
-                data.len()
-            ),
-        });
+        return Err(corrupt(format!(
+            "Pack index size is incorrect, expected {expected_size} bytes for {num_objects} objects in version {kind:?}, but got {} bytes",
+            data.len()
+        )));
     }
     Ok(())
 }
diff --git a/gix-pack/src/index/traverse/error.rs b/gix-pack/src/index/traverse/error.rs
deleted file mode 100644
index b64b9a1a211..00000000000
--- a/gix-pack/src/index/traverse/error.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use crate::index;
-
-/// Returned by [`index::File::traverse_with_index()`] and [`index::File::traverse_with_lookup`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error<E: std::error::Error + Send + Sync + 'static> {
-    #[error("One of the traversal processors failed")]
-    Processor(#[source] E),
-    #[error("Failed to verify index file checksum")]
-    IndexVerify(#[source] index::verify::checksum::Error),
-    #[error("The pack delta tree index could not be built")]
-    Tree(#[from] crate::cache::delta::from_offsets::Error),
-    #[error("The tree traversal failed")]
-    TreeTraversal(#[from] crate::cache::delta::traverse::Error),
-    #[error(transparent)]
-    EntryType(#[from] crate::data::entry::decode::Error),
-    #[error("Object {id} at offset {offset} could not be decoded")]
-    PackDecode {
-        id: gix_hash::ObjectId,
-        offset: u64,
-        source: crate::data::decode::Error,
-    },
-    #[error("The packfiles checksum didn't match the index file checksum")]
-    PackMismatch(#[source] gix_hash::verify::Error),
-    #[error("Failed to verify pack file checksum")]
-    PackVerify(#[source] crate::verify::checksum::Error),
-    #[error("Error verifying object at offset {offset} against checksum in the index file")]
-    PackObjectVerify {
-        offset: u64,
-        #[source]
-        source: gix_object::data::verify::Error,
-    },
-    #[error(
-        "The CRC32 of {kind} object at offset {offset} didn't match the checksum in the index file: expected {expected}, got {actual}"
-    )]
-    Crc32Mismatch {
-        expected: u32,
-        actual: u32,
-        offset: u64,
-        kind: gix_object::Kind,
-    },
-    #[error("Interrupted")]
-    Interrupted,
-}
diff --git a/gix-pack/src/index/traverse/mod.rs b/gix-pack/src/index/traverse/mod.rs
index 4450b76803b..7ad925c4a2a 100644
--- a/gix-pack/src/index/traverse/mod.rs
+++ b/gix-pack/src/index/traverse/mod.rs
@@ -1,5 +1,6 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 use gix_features::{parallel, progress::Progress};
 
 use crate::index;
@@ -11,8 +12,6 @@ pub mod with_index;
 pub mod with_lookup;
 use reduce::Reducer;
 
-mod error;
-pub use error::Error;
 use gix_features::progress::DynNestedProgress;
 
 mod types;
@@ -80,7 +79,7 @@ where
     ///
     /// Use [`thread_limit`][Options::thread_limit] to further control parallelism and [`check`][SafetyCheck] to define how much the passed
     /// objects shall be verified beforehand.
-    pub fn traverse<C, Processor, E, F, D>(
+    pub fn traverse<C, Processor, F, D>(
         &self,
         pack: &crate::data::File<D>,
         progress: &mut dyn DynNestedProgress,
@@ -93,11 +92,10 @@ where
             alloc_limit_bytes,
             make_pack_lookup_cache,
         }: Options<F>,
-    ) -> Result<Outcome, Error<E>>
+    ) -> ExnResult<Outcome>
     where
         C: crate::cache::DecodeEntry,
-        E: std::error::Error + Send + Sync + 'static,
-        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> Result<(), E> + Send + Clone,
+        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> ExnResult + Send + Clone,
         F: Fn() -> C + Send + Clone,
         D: crate::FileData + Send + Sync,
     {
@@ -127,35 +125,34 @@ where
         }
     }
 
-    fn possibly_verify<E, D>(
+    fn possibly_verify<D>(
         &self,
         pack: &crate::data::File<D>,
         check: SafetyCheck,
         pack_progress: &mut dyn Progress,
         index_progress: &mut dyn Progress,
         should_interrupt: &AtomicBool,
-    ) -> Result<gix_hash::ObjectId, Error<E>>
+    ) -> ExnResult<gix_hash::ObjectId>
     where
-        E: std::error::Error + Send + Sync + 'static,
         D: crate::FileData + Send + Sync,
     {
         Ok(if check.file_checksum() {
             pack.checksum()
                 .verify(&self.pack_checksum())
-                .map_err(Error::PackMismatch)?;
+                .or_raise_erased(|| gix_error::corruption("Pack checksum differs from index"))?;
             let (pack_res, id) = parallel::join(
                 move || pack.verify_checksum(pack_progress, should_interrupt),
                 move || self.verify_checksum(index_progress, should_interrupt),
             );
-            pack_res.map_err(Error::PackVerify)?;
-            id.map_err(Error::IndexVerify)?
+            pack_res?;
+            id?
         } else {
             self.index_checksum()
         })
     }
 
     #[expect(clippy::too_many_arguments)]
-    fn decode_and_process_entry<C, E, D>(
+    fn decode_and_process_entry<C, D>(
         &self,
         check: SafetyCheck,
         pack: &crate::data::File<D>,
@@ -164,33 +161,44 @@ where
         inflate: &mut gix_zlib::Inflate,
         progress: &mut dyn Progress,
         index_entry: &index::Entry,
-        processor: &mut impl FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> Result<(), E>,
-    ) -> Result<crate::data::decode::entry::Outcome, Error<E>>
+        processor: &mut impl FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> ExnResult,
+    ) -> ExnResult<Option<crate::data::decode::entry::Outcome>>
     where
         C: crate::cache::DecodeEntry,
-        E: std::error::Error + Send + Sync + 'static,
         D: crate::FileData + Send + Sync,
     {
-        let pack_entry = pack.entry(index_entry.pack_offset)?;
+        let pack_entry = pack.entry(index_entry.pack_offset).or_erased()?;
         let pack_entry_data_offset = pack_entry.data_offset;
-        let entry_stats = pack
-            .decode_entry(
-                pack_entry,
-                buf,
-                inflate,
-                &|id, _| {
-                    let index = self.lookup(id)?;
-                    pack.entry(self.pack_offset_at_index(index))
-                        .ok()
-                        .map(crate::data::decode::entry::ResolvedBase::InPack)
-                },
-                cache,
-            )
-            .map_err(|e| Error::PackDecode {
-                source: e,
-                id: index_entry.oid,
-                offset: index_entry.pack_offset,
-            })?;
+        let entry_stats = match pack.decode_entry(
+            pack_entry,
+            buf,
+            inflate,
+            &|id, _| {
+                let index = self.lookup(id)?;
+                pack.entry(self.pack_offset_at_index(index))
+                    .ok()
+                    .map(crate::data::decode::entry::ResolvedBase::InPack)
+            },
+            cache,
+        ) {
+            Ok(stats) => stats,
+            Err(err) if !check.fatal_decode_error() => {
+                progress.info(format!(
+                    "Ignoring decode error for object {} at offset {}: {err}",
+                    index_entry.oid, index_entry.pack_offset
+                ));
+                return Ok(None);
+            }
+            Err(err) => {
+                return Err(err
+                    .raise(message!(
+                        "Object {} at offset {} could not be decoded",
+                        index_entry.oid,
+                        index_entry.pack_offset
+                    ))
+                    .erased());
+            }
+        };
         let object_kind = entry_stats.kind;
         let header_size = (pack_entry_data_offset - index_entry.pack_offset) as usize;
         let entry_len = header_size + entry_stats.compressed_size;
@@ -204,40 +212,38 @@ where
             progress,
             processor,
         )?;
-        Ok(entry_stats)
+        Ok(Some(entry_stats))
     }
 }
 
-fn process_entry<E>(
+fn process_entry(
     check: SafetyCheck,
     object_kind: gix_object::Kind,
     decompressed: &[u8],
     index_entry: &index::Entry,
     pack_entry_crc32: impl FnOnce() -> u32,
     progress: &dyn Progress,
-    processor: &mut impl FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> Result<(), E>,
-) -> Result<(), Error<E>>
-where
-    E: std::error::Error + Send + Sync + 'static,
-{
+    processor: &mut impl FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> ExnResult,
+) -> ExnResult {
     if check.object_checksum() {
         gix_object::Data::new(decompressed, object_kind, index_entry.oid.kind())
             .verify_checksum(&index_entry.oid)
-            .map_err(|source| Error::PackObjectVerify {
-                offset: index_entry.pack_offset,
-                source,
+            .or_raise_erased(|| {
+                gix_error::corruption(format!(
+                    "Error verifying object at offset {} against checksum in the index file",
+                    index_entry.pack_offset
+                ))
             })?;
         if let Some(desired_crc32) = index_entry.crc32 {
             let actual_crc32 = pack_entry_crc32();
             if actual_crc32 != desired_crc32 {
-                return Err(Error::Crc32Mismatch {
-                    actual: actual_crc32,
-                    expected: desired_crc32,
-                    offset: index_entry.pack_offset,
-                    kind: object_kind,
-                });
+                return Err(gix_error::corruption(format!(
+                    "The CRC32 of {object_kind} object at offset {} didn't match the checksum in the index file: expected {desired_crc32}, got {actual_crc32}",
+                    index_entry.pack_offset
+                ))
+                .raise_erased());
             }
         }
     }
-    processor(object_kind, decompressed, index_entry, progress).map_err(Error::Processor)
+    processor(object_kind, decompressed, index_entry, progress)
 }
diff --git a/gix-pack/src/index/traverse/reduce.rs b/gix-pack/src/index/traverse/reduce.rs
index f4039cc43c0..8704ebf837f 100644
--- a/gix-pack/src/index/traverse/reduce.rs
+++ b/gix-pack/src/index/traverse/reduce.rs
@@ -3,6 +3,7 @@ use std::{
     time::Instant,
 };
 
+use gix_error::{ErrorExt, ExnResult, retryable};
 use gix_features::{
     parallel,
     progress::Progress,
@@ -27,24 +28,21 @@ fn div_decode_result(lhs: &mut data::decode::entry::Outcome, div: usize) {
     }
 }
 
-pub struct Reducer<'a, P, E> {
+pub struct Reducer<'a, P> {
     progress: OwnShared<Mutable<P>>,
-    check: traverse::SafetyCheck,
     then: Instant,
     entries_seen: usize,
     stats: traverse::Statistics,
     should_interrupt: &'a AtomicBool,
-    _error: std::marker::PhantomData<E>,
 }
 
-impl<'a, P, E> Reducer<'a, P, E>
+impl<'a, P> Reducer<'a, P>
 where
     P: Progress,
 {
     pub fn from_progress(
         progress: OwnShared<Mutable<P>>,
         pack_data_len_in_bytes: usize,
-        check: traverse::SafetyCheck,
         should_interrupt: &'a AtomicBool,
     ) -> Self {
         let stats = traverse::Statistics {
@@ -53,34 +51,25 @@ where
         };
         Reducer {
             progress,
-            check,
             then: Instant::now(),
             entries_seen: 0,
             should_interrupt,
             stats,
-            _error: Default::default(),
         }
     }
 }
 
-impl<P, E> parallel::Reduce for Reducer<'_, P, E>
+impl<P> parallel::Reduce for Reducer<'_, P>
 where
     P: Progress,
-    E: std::error::Error + Send + Sync + 'static,
 {
-    type Input = Result<Vec<data::decode::entry::Outcome>, traverse::Error<E>>;
+    type Input = ExnResult<Vec<data::decode::entry::Outcome>>;
     type FeedProduce = ();
     type Output = traverse::Statistics;
-    type Error = traverse::Error<E>;
+    type Error = gix_error::Exn;
 
     fn feed(&mut self, input: Self::Input) -> Result<(), Self::Error> {
-        let chunk_stats: Vec<_> = match input {
-            Err(err @ traverse::Error::PackDecode { .. }) if !self.check.fatal_decode_error() => {
-                lock(&self.progress).info(format!("Ignoring decode error: {err}"));
-                return Ok(());
-            }
-            res => res,
-        }?;
+        let chunk_stats = input?;
         self.entries_seen += chunk_stats.len();
 
         let chunk_total = chunk_stats.into_iter().fold(
@@ -106,7 +95,7 @@ where
         lock(&self.progress).set(self.entries_seen);
 
         if self.should_interrupt.load(Ordering::SeqCst) {
-            return Err(Self::Error::Interrupted);
+            return Err(retryable("Interrupted").raise_erased());
         }
         Ok(())
     }
diff --git a/gix-pack/src/index/traverse/with_index.rs b/gix-pack/src/index/traverse/with_index.rs
index 56360f5ddc2..d48d115d98c 100644
--- a/gix-pack/src/index/traverse/with_index.rs
+++ b/gix-pack/src/index/traverse/with_index.rs
@@ -1,8 +1,9 @@
 use std::sync::atomic::{AtomicBool, Ordering};
 
+use gix_error::ExnResult;
+
 use gix_features::{parallel, progress::DynNestedProgress};
 
-use super::Error;
 use crate::{
     cache::delta::traverse,
     index::{self, traverse::Outcome, util::index_entries_sorted_by_offset_ascending},
@@ -62,7 +63,7 @@ where
     /// at the cost of memory.
     ///
     /// For more details, see the documentation on the [`traverse()`][index::File::traverse()] method.
-    pub fn traverse_with_index<Processor, E, D>(
+    pub fn traverse_with_index<Processor, D>(
         &self,
         pack: &crate::data::File<D>,
         mut processor: Processor,
@@ -73,12 +74,11 @@ where
             thread_limit,
             alloc_limit_bytes,
         }: Options,
-    ) -> Result<Outcome, Error<E>>
+    ) -> ExnResult<Outcome>
     where
-        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn gix_features::progress::Progress) -> Result<(), E>
+        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn gix_features::progress::Progress) -> ExnResult
             + Send
             + Clone,
-        E: std::error::Error + Send + Sync + 'static,
         D: crate::FileData + Send + Sync,
     {
         let (verify_result, traversal_result) = parallel::join(
@@ -100,7 +100,7 @@ where
                     res
                 }
             },
-            || -> Result<_, Error<_>> {
+            || -> ExnResult<_> {
                 let sorted_entries = index_entries_sorted_by_offset_ascending(
                     self,
                     &mut progress.add_child_with_id(
@@ -135,7 +135,7 @@ where
                         data.object_kind = object_kind;
                         data.compressed_size = entry_end - pack_entry.data_offset;
                         data.object_size = bytes.len() as u64;
-                        let result = index::traverse::process_entry(
+                        index::traverse::process_entry(
                             check,
                             object_kind,
                             bytes,
@@ -151,14 +151,7 @@ where
                             },
                             progress,
                             &mut processor,
-                        );
-                        match result {
-                            Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {
-                                progress.info(format!("Ignoring decode error: {err}"));
-                                Ok(())
-                            }
-                            res => res,
-                        }
+                        )
                     },
                     traverse::Options {
                         object_progress: Box::new(
diff --git a/gix-pack/src/index/traverse/with_lookup.rs b/gix-pack/src/index/traverse/with_lookup.rs
index c81ba1f006a..4132f688870 100644
--- a/gix-pack/src/index/traverse/with_lookup.rs
+++ b/gix-pack/src/index/traverse/with_lookup.rs
@@ -1,12 +1,14 @@
 use std::sync::atomic::{AtomicBool, Ordering};
 
+use gix_error::ExnResult;
+
 use gix_features::{
     parallel::{self, in_parallel_if},
     progress::{self, Count, DynNestedProgress, Progress},
     threading::{Mutable, OwnShared, lock},
 };
 
-use super::{Error, Reducer};
+use super::Reducer;
 use crate::{
     data, exact_vec, index,
     index::{traverse::Outcome, util},
@@ -68,7 +70,7 @@ where
     /// waste while decoding objects.
     ///
     /// For more details, see the documentation on the [`traverse()`][index::File::traverse()] method.
-    pub fn traverse_with_lookup<C, Processor, E, F, D>(
+    pub fn traverse_with_lookup<C, Processor, F, D>(
         &self,
         mut processor: Processor,
         pack: &data::File<D>,
@@ -79,11 +81,10 @@ where
             check,
             make_pack_lookup_cache,
         }: Options<F>,
-    ) -> Result<Outcome, Error<E>>
+    ) -> ExnResult<Outcome>
     where
         C: crate::cache::DecodeEntry,
-        E: std::error::Error + Send + Sync + 'static,
-        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> Result<(), E> + Send + Clone,
+        Processor: FnMut(gix_object::Kind, &[u8], &index::Entry, &dyn Progress) -> ExnResult + Send + Clone,
         F: Fn() -> C + Send + Clone,
         D: crate::FileData + Send + Sync,
     {
@@ -144,7 +145,7 @@ where
                     state_per_thread,
                     move |entries: &[index::Entry],
                           (cache, buf, inflate, progress)|
-                          -> Result<Vec<data::decode::entry::Outcome>, Error<_>> {
+                          -> ExnResult<Vec<data::decode::entry::Outcome>> {
                         progress.init(
                             Some(entries.len()),
                             gix_features::progress::count_with_decimals("objects", 2),
@@ -163,13 +164,7 @@ where
                                 &mut processor,
                             );
                             progress.inc();
-                            let stat = match result {
-                                Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {
-                                    progress.info(format!("Ignoring decode error: {err}"));
-                                    continue;
-                                }
-                                res => res,
-                            }?;
+                            let Some(stat) = result? else { continue };
                             stats.push(stat);
                             if should_interrupt.load(Ordering::Relaxed) {
                                 break;
@@ -177,7 +172,7 @@ where
                         }
                         Ok(stats)
                     },
-                    Reducer::from_progress(reduce_progress, pack.data_len(), check, should_interrupt),
+                    Reducer::from_progress(reduce_progress, pack.data_len(), should_interrupt),
                 )
             },
         );
diff --git a/gix-pack/src/index/verify.rs b/gix-pack/src/index/verify.rs
index 7b907bef494..4477268e4f0 100644
--- a/gix-pack/src/index/verify.rs
+++ b/gix-pack/src/index/verify.rs
@@ -1,7 +1,9 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_error::{ErrorExt, ExnResult, ResultExt};
 use gix_features::progress::{DynNestedProgress, Progress};
 use gix_object::WriteTo;
+use gix_object::bstr::ByteSlice;
 
 use crate::index;
 
@@ -9,31 +11,6 @@ use crate::index;
 pub mod integrity {
     use std::marker::PhantomData;
 
-    use gix_object::bstr::BString;
-
-    /// Returned by [`index::File::verify_integrity()`][crate::index::File::verify_integrity()].
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Reserialization of an object failed")]
-        Io(#[from] std::io::Error),
-        #[error("The fan at index {index} is out of order as it's larger then the following value.")]
-        Fan { index: usize },
-        #[error("{kind} object {id} could not be decoded")]
-        ObjectDecode {
-            source: gix_object::decode::Error,
-            kind: gix_object::Kind,
-            id: gix_hash::ObjectId,
-        },
-        #[error("{kind} object {id} wasn't re-encoded without change, wanted\n{expected}\n\nGOT\n\n{actual}")]
-        ObjectEncodeMismatch {
-            kind: gix_object::Kind,
-            id: gix_hash::ObjectId,
-            expected: BString,
-            actual: BString,
-        },
-    }
-
     /// Returned by [`index::File::verify_integrity()`][crate::index::File::verify_integrity()].
     pub struct Outcome {
         /// The computed checksum of the index which matched the stored one.
@@ -87,12 +64,6 @@ pub mod integrity {
     }
 }
 
-///
-pub mod checksum {
-    /// Returned by [`index::File::verify_checksum()`][crate::index::File::verify_checksum()].
-    pub type Error = crate::verify::checksum::Error;
-}
-
 /// Various ways in which a pack and index can be verified
 #[derive(Default, Debug, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum Mode {
@@ -141,7 +112,7 @@ where
         &self,
         progress: &mut dyn Progress,
         should_interrupt: &AtomicBool,
-    ) -> Result<gix_hash::ObjectId, checksum::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         crate::verify::checksum_on_disk_or_mmap(
             self.path(),
             &self.data,
@@ -174,16 +145,17 @@ where
         pack: Option<PackContext<'_, F, D>>,
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
-    ) -> Result<integrity::Outcome, index::traverse::Error<index::verify::integrity::Error>>
+    ) -> ExnResult<integrity::Outcome>
     where
         C: crate::cache::DecodeEntry,
         F: Fn() -> C + Send + Clone,
         D: crate::FileData + Send + Sync,
     {
         if let Some(first_invalid) = crate::verify::fan(&self.fan) {
-            return Err(index::traverse::Error::Processor(integrity::Error::Fan {
-                index: first_invalid,
-            }));
+            return Err(gix_error::corruption(format!(
+                "The fan at index {first_invalid} is out of order as it's larger then the following value."
+            ))
+            .raise_erased());
         }
 
         match pack {
@@ -225,7 +197,6 @@ where
                         .add_child_with_id("checksum of index".into(), integrity::ProgressId::ChecksumBytes.into()),
                     should_interrupt,
                 )
-                .map_err(index::traverse::Error::IndexVerify)
                 .map(|id| integrity::Outcome {
                     actual_index_checksum: id,
                     pack_traverse_statistics: None,
@@ -233,6 +204,7 @@ where
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn verify_entry(
         verify_mode: Mode,
         encode_buf: &mut Vec<u8>,
@@ -240,29 +212,31 @@ where
         buf: &[u8],
         index_entry: &index::Entry,
         _progress: &dyn gix_features::progress::Progress,
-    ) -> Result<(), integrity::Error> {
+    ) -> ExnResult {
         if let Mode::HashCrc32Decode | Mode::HashCrc32DecodeEncode = verify_mode {
             use gix_object::Kind::*;
             match object_kind {
                 Tree | Commit | Tag => {
-                    let object =
-                        gix_object::ObjectRef::from_bytes(buf, object_kind, index_entry.oid.kind()).map_err(|err| {
-                            integrity::Error::ObjectDecode {
-                                source: err,
-                                kind: object_kind,
-                                id: index_entry.oid,
-                            }
+                    let object = gix_object::ObjectRef::from_bytes(buf, object_kind, index_entry.oid.kind())
+                        .or_raise_erased(|| {
+                            gix_error::corruption(format!(
+                                "{object_kind} object {} could not be decoded",
+                                index_entry.oid
+                            ))
                         })?;
                     if let Mode::HashCrc32DecodeEncode = verify_mode {
                         encode_buf.clear();
-                        object.write_to(&mut *encode_buf)?;
+                        object
+                            .write_to(&mut *encode_buf)
+                            .or_raise_erased(|| gix_error::corruption("Reserialization of an object failed"))?;
                         if encode_buf.as_slice() != buf {
-                            return Err(integrity::Error::ObjectEncodeMismatch {
-                                kind: object_kind,
-                                id: index_entry.oid,
-                                expected: buf.into(),
-                                actual: encode_buf.clone().into(),
-                            });
+                            return Err(gix_error::corruption(format!(
+                                "{object_kind} object {} wasn't re-encoded without change, wanted\n{}\n\nGOT\n\n{}",
+                                index_entry.oid,
+                                buf.as_bstr(),
+                                encode_buf.as_bstr()
+                            ))
+                            .raise_erased());
                         }
                     }
                 }
diff --git a/gix-pack/src/index/write/error.rs b/gix-pack/src/index/write/error.rs
deleted file mode 100644
index 01cd286c094..00000000000
--- a/gix-pack/src/index/write/error.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-/// Returned by [`crate::index::write_data_iter_to_stream()`]
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("An error occurred when writing the pack index file")]
-    Io(#[from] std::io::Error),
-    #[error("A pack entry could not be extracted")]
-    PackEntryDecode(#[from] crate::data::input::Error),
-    #[error("Indices of type {} cannot be written, only {} are supported", *.0 as usize, crate::index::Version::default() as usize)]
-    Unsupported(crate::index::Version),
-    #[error("Ref delta objects are not supported as there is no way to look them up. Resolve them beforehand.")]
-    IteratorInvariantNoRefDelta,
-    #[error("The iterator failed to set a trailing hash over all prior pack entries in the last provided entry")]
-    IteratorInvariantTrailer,
-    #[error("Only u32::MAX objects can be stored in a pack, found {0}")]
-    IteratorInvariantTooManyObjects(usize),
-    #[error("{pack_offset} is not a valid offset for pack offset {distance}")]
-    IteratorInvariantBaseOffset { pack_offset: u64, distance: u64 },
-    #[error(transparent)]
-    Tree(#[from] crate::cache::delta::Error),
-    #[error(transparent)]
-    TreeTraversal(#[from] crate::cache::delta::traverse::Error),
-}
-
-impl From<gix_hash::io::Error> for Error {
-    fn from(err: gix_hash::io::Error) -> Self {
-        Error::Io(std::io::Error::other(err.into_error()))
-    }
-}
diff --git a/gix-pack/src/index/write/mod.rs b/gix-pack/src/index/write/mod.rs
index 638c075bd2b..c799fdfb617 100644
--- a/gix-pack/src/index/write/mod.rs
+++ b/gix-pack/src/index/write/mod.rs
@@ -1,7 +1,5 @@
-pub use error::Error;
-
-mod error;
-
+use gix_error::ExnResult;
+use gix_error::ResultExt;
 pub(crate) struct TreeEntry {
     pub id: gix_hash::ObjectId,
     pub crc32: u32,
@@ -58,11 +56,12 @@ impl From<ProgressId> for gix_features::progress::Id {
 pub(super) mod function {
     use std::{io, sync::atomic::AtomicBool};
 
+    use gix_error::{ErrorExt, ExnResult, OptionExt, ResultExt};
     use gix_features::progress::{self, Count, Progress, prodash::DynNestedProgress};
 
     use crate::cache::delta::{Tree, traverse};
 
-    use super::{Error, Outcome, ProgressId, TreeEntry, modify_base};
+    use super::{Outcome, ProgressId, TreeEntry, modify_base};
 
     /// Write information about `entries` as obtained from a pack data file into a pack index file via the `out` stream.
     /// The resolver produced by `make_resolver` must resolve pack entries from the same pack data file that produced the
@@ -99,7 +98,7 @@ pub(super) mod function {
     pub fn write_data_iter_to_stream<F, F2, R>(
         version: crate::index::Version,
         make_resolver: F,
-        entries: &mut dyn Iterator<Item = Result<crate::data::input::Entry, crate::data::input::Error>>,
+        entries: &mut dyn Iterator<Item = ExnResult<crate::data::input::Entry>>,
         thread_limit: Option<usize>,
         root_progress: &mut dyn DynNestedProgress,
         out: &mut dyn io::Write,
@@ -107,14 +106,19 @@ pub(super) mod function {
         object_hash: gix_hash::Kind,
         alloc_limit_bytes: Option<usize>,
         pack_version: crate::data::Version,
-    ) -> Result<Outcome, Error>
+    ) -> ExnResult<Outcome>
     where
         F: FnOnce() -> io::Result<(F2, R)>,
         R: Send + Sync,
         F2: for<'r> Fn(crate::data::EntryRange, &'r R) -> Option<&'r [u8]> + Send + Clone,
     {
         if version != crate::index::Version::default() {
-            return Err(Error::Unsupported(version));
+            return Err(gix_error::validation(format!(
+                "Indices of type {} cannot be written, only {} are supported",
+                version as usize,
+                crate::index::Version::default() as usize
+            ))
+            .raise_erased());
         }
         let mut num_objects: usize = 0;
         let mut last_seen_trailer = None;
@@ -173,12 +177,12 @@ pub(super) mod function {
                 }
                 OfsDelta { base_distance } => {
                     let base_pack_offset =
-                        crate::data::entry::Header::verified_base_pack_offset(pack_offset, base_distance).ok_or(
-                            Error::IteratorInvariantBaseOffset {
-                                pack_offset,
-                                distance: base_distance,
-                            },
-                        )?;
+                        crate::data::entry::Header::verified_base_pack_offset(pack_offset, base_distance)
+                            .ok_or_raise_erased(|| {
+                                gix_error::validation(format!(
+                                    "{pack_offset} is not a valid offset for pack offset {base_distance}"
+                                ))
+                            })?;
                     tree.add_child(
                         base_pack_offset,
                         pack_offset,
@@ -193,9 +197,11 @@ pub(super) mod function {
             num_objects += 1;
             objects_progress.inc();
         }
-        let num_objects: u32 = num_objects
-            .try_into()
-            .map_err(|_| Error::IteratorInvariantTooManyObjects(num_objects))?;
+        let num_objects = u32::try_from(num_objects).or_raise_erased(|| {
+            gix_error::validation(format!(
+                "Only u32::MAX objects can be stored in a pack, found {num_objects}"
+            ))
+        })?;
 
         objects_progress.show_throughput(indexing_start);
         decompressed_progress.show_throughput(indexing_start);
@@ -251,7 +257,12 @@ pub(super) mod function {
                 hasher.update(&header);
                 hasher.try_finalize().map_err(gix_hash::io::from_hasher)?
             }
-            None => return Err(Error::IteratorInvariantTrailer),
+            None => {
+                return Err(gix_error::validation(
+                    "The iterator failed to set a trailing hash over all prior pack entries in the last provided entry",
+                )
+                .raise_erased());
+            }
         };
         let index_hash = crate::index::encode::write_to(
             out,
@@ -281,9 +292,9 @@ fn modify_base(
     pack_entry: &crate::data::Entry,
     decompressed: &[u8],
     hash: gix_hash::Kind,
-) -> Result<(), gix_hash::hasher::Error> {
+) -> ExnResult {
     let object_kind = pack_entry.header.as_kind().expect("base object as source of iteration");
-    let id = gix_object::compute_hash(hash, object_kind, decompressed)?;
+    let id = gix_object::compute_hash(hash, object_kind, decompressed).or_erased()?;
     entry.id = id;
     Ok(())
 }
diff --git a/gix-pack/src/multi_index/chunk.rs b/gix-pack/src/multi_index/chunk.rs
index 27e9a9b5bc1..6c9a67e7034 100644
--- a/gix-pack/src/multi_index/chunk.rs
+++ b/gix-pack/src/multi_index/chunk.rs
@@ -2,41 +2,13 @@
 pub mod index_names {
     use std::path::{Path, PathBuf};
 
-    use gix_object::bstr::{BString, ByteSlice};
+    use gix_error::ExnResult;
+
+    use gix_object::bstr::ByteSlice;
 
     /// The ID used for the index-names chunk.
     pub const ID: gix_chunk::Id = *b"PNAM";
 
-    ///
-    pub mod decode {
-        use std::collections::TryReserveError;
-
-        use gix_object::bstr::BString;
-
-        /// The error returned by [`from_bytes()`][super::from_bytes()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("The pack names were not ordered alphabetically.")]
-            NotOrderedAlphabetically,
-            #[error("Each pack path name must be terminated with a null byte")]
-            MissingNullByte,
-            #[error("Entry too large to fit in memory")]
-            OutOfMemory,
-            #[error("Couldn't turn path '{path}' into OS path due to encoding issues")]
-            PathEncoding { path: BString },
-            #[error("non-padding bytes found after all paths were read.")]
-            UnknownTrailerBytes,
-        }
-
-        impl From<TryReserveError> for Error {
-            #[cold]
-            fn from(_: TryReserveError) -> Self {
-                Self::OutOfMemory
-            }
-        }
-    }
-
     /// Parse null-separated index names from the given `chunk` of bytes.
     ///
     /// `chunk`
@@ -50,38 +22,63 @@ pub mod index_names {
     ///  It is used to reject reserving the output `Vec<PathBuf>` if its capacity estimate exceeds the limit,
     ///  and to reject any single path entry whose byte length exceeds the limit before turning it into a `PathBuf`.
     ///  Use `None` to disable this limit.
-    pub fn from_bytes(
-        mut chunk: &[u8],
-        num_packs: u32,
-        alloc_limit_bytes: Option<usize>,
-    ) -> Result<Vec<PathBuf>, decode::Error> {
+    pub fn from_bytes(mut chunk: &[u8], num_packs: u32, alloc_limit_bytes: Option<usize>) -> ExnResult<Vec<PathBuf>> {
+        use gix_error::{ErrorExt, OptionExt, ResourceExhaustionKind, ResultExt};
+
         let mut out = Vec::new();
-        let num_packs = usize::try_from(num_packs).map_err(|_| decode::Error::OutOfMemory)?;
+        let num_packs = usize::try_from(num_packs).or_raise_erased(|| {
+            gix_error::resource_exhaustion(
+                ResourceExhaustionKind::AllocationFailure,
+                "Pack count does not fit into memory",
+            )
+        })?;
+        if num_packs > chunk.len() {
+            return Err(gix_error::corruption("Pack count exceeds the available pack-name data").raise_erased());
+        }
         let vec_allocation = num_packs
             .checked_mul(std::mem::size_of::<PathBuf>())
-            .ok_or(decode::Error::OutOfMemory)?;
+            .ok_or_raise_erased(|| {
+                gix_error::resource_exhaustion(
+                    ResourceExhaustionKind::AllocationFailure,
+                    "Pack names require more memory than can be represented",
+                )
+            })?;
         if alloc_limit_bytes.is_some_and(|limit| vec_allocation > limit) {
-            return Err(decode::Error::OutOfMemory);
+            return Err(gix_error::resource_exhaustion(
+                ResourceExhaustionKind::AllocationLimit,
+                "Pack names require more memory than allowed",
+            )
+            .raise_erased());
         }
-        out.try_reserve(num_packs)?;
+        out.try_reserve(num_packs)
+            .or_raise_erased(|| gix_error::message("Pack names require more memory than can be reserved"))?;
 
         for _ in 0..num_packs {
-            let null_byte_pos = chunk.find_byte(b'\0').ok_or(decode::Error::MissingNullByte)?;
+            let null_byte_pos = chunk.find_byte(b'\0').ok_or_raise_erased(|| {
+                gix_error::corruption("Each pack path name must be terminated with a null byte")
+            })?;
 
             let path = &chunk[..null_byte_pos];
             if alloc_limit_bytes.is_some_and(|limit| path.len() > limit) {
-                return Err(decode::Error::OutOfMemory);
+                return Err(gix_error::resource_exhaustion(
+                    ResourceExhaustionKind::AllocationLimit,
+                    "Pack path requires more memory than allowed",
+                )
+                .raise_erased());
             }
             let path = gix_path::try_from_byte_slice(path)
-                .map_err(|_| decode::Error::PathEncoding {
-                    path: BString::from(path),
+                .or_raise_erased(|| {
+                    gix_error::corruption(format!(
+                        "Couldn't turn path '{}' into OS path due to encoding issues",
+                        path.as_bstr()
+                    ))
                 })?
                 .to_owned();
 
             if let Some(previous) = out.last()
                 && previous >= &path
             {
-                return Err(decode::Error::NotOrderedAlphabetically);
+                return Err(gix_error::corruption("The pack names were not ordered alphabetically").raise_erased());
             }
             out.push(path);
 
@@ -89,7 +86,7 @@ pub mod index_names {
         }
 
         if !chunk.is_empty() && !chunk.iter().all(|b| *b == 0) {
-            return Err(decode::Error::UnknownTrailerBytes);
+            return Err(gix_error::corruption("Non-padding bytes found after all paths were read").raise_erased());
         }
         // NOTE: git writes garbage into this chunk, usually extra \0 bytes, which we simply ignore. If we were strict
         // about it we couldn't read this chunk data at all.
diff --git a/gix-pack/src/multi_index/init.rs b/gix-pack/src/multi_index/init.rs
index ecea678aedd..6574c6835e8 100644
--- a/gix-pack/src/multi_index/init.rs
+++ b/gix-pack/src/multi_index/init.rs
@@ -1,55 +1,29 @@
-use std::path::{Path, PathBuf};
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+};
+
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 
 use crate::multi_index::{File, Version, chunk};
 
-mod error {
-    use crate::multi_index::chunk;
-
-    /// The error returned by [File::at()][super::File::at()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not open multi-index file at '{path}'")]
-        Io {
-            source: std::io::Error,
-            path: std::path::PathBuf,
-        },
-        #[error("{message}")]
-        Corrupt { message: &'static str },
-        #[error("Unsupported multi-index version: {version})")]
-        UnsupportedVersion { version: u8 },
-        #[error("Unsupported hash kind: {kind})")]
-        UnsupportedObjectHash { kind: u8 },
-        #[error(transparent)]
-        ChunkFileQuery(#[from] gix_error::Message),
-        #[error(transparent)]
-        ChunkFileDecode(#[from] gix_error::ValidationError),
-        #[error("The multi-pack fan doesn't have the correct size of 256 * 4 bytes")]
-        MultiPackFanSize,
-        #[error(transparent)]
-        PackNames(#[from] chunk::index_names::decode::Error),
-        #[error("multi-index chunk {:?} has invalid size: {message}", String::from_utf8_lossy(.id))]
-        InvalidChunkSize { id: gix_chunk::Id, message: &'static str },
-    }
+fn corrupt(message: impl Into<Cow<'static, str>>) -> gix_error::Exn {
+    gix_error::corruption(message).raise_erased()
 }
 
-pub use error::Error;
-
 /// Initialization
 impl File<crate::MMap> {
     /// Open the multi-index file at the given `path`.
     ///
     /// `alloc_limit_bytes` bounds each allocation caused by user-controlled on-disk data, useful for untrusted input.
     /// Use `None` to disable the limit.
-    pub fn at(path: impl AsRef<Path>, alloc_limit_bytes: Option<usize>) -> Result<Self, Error> {
+    pub fn at(path: impl AsRef<Path>, alloc_limit_bytes: Option<usize>) -> ExnResult<Self> {
         Self::at_inner(path.as_ref(), alloc_limit_bytes)
     }
 
-    fn at_inner(path: &Path, alloc_limit_bytes: Option<usize>) -> Result<Self, Error> {
-        let data = crate::mmap::read_only(path).map_err(|source| Error::Io {
-            source,
-            path: path.to_owned(),
-        })?;
+    fn at_inner(path: &Path, alloc_limit_bytes: Option<usize>) -> ExnResult<Self> {
+        let data = crate::mmap::read_only(path)
+            .or_raise_erased(|| message!("Could not open multi-index file at '{}'", path.display()))?;
         Self::from_data(data, path.to_owned(), alloc_limit_bytes)
     }
 }
@@ -65,7 +39,7 @@ where
     ///
     ///  It is used to reject reserving the output `Vec<PathBuf>` if its capacity estimate exceeds the limit,
     ///  and to reject any single path entry whose byte length exceeds the limit before turning it into a `PathBuf`.
-    pub fn from_data(data: T, path: PathBuf, alloc_limit_bytes: Option<usize>) -> Result<Self, Error> {
+    pub fn from_data(data: T, path: PathBuf, alloc_limit_bytes: Option<usize>) -> ExnResult<Self> {
         const TRAILER_LEN: usize = gix_hash::Kind::shortest().len_in_bytes(); /* trailing hash */
         if data.len()
             < Self::HEADER_LEN
@@ -73,27 +47,27 @@ where
                 + chunk::fanout::SIZE
                 + TRAILER_LEN
         {
-            return Err(Error::Corrupt {
-                message: "multi-index file is truncated and too short",
-            });
+            return Err(corrupt("multi-index file is truncated and too short"));
         }
 
         let (version, object_hash, num_chunks, num_indices) = {
             let (signature, data) = data.split_at(4);
             if signature != Self::SIGNATURE {
-                return Err(Error::Corrupt {
-                    message: "Invalid signature",
-                });
+                return Err(corrupt("Invalid signature"));
             }
             let (version, data) = data.split_at(1);
             let version = match version[0] {
                 1 => Version::V1,
-                version => return Err(Error::UnsupportedVersion { version }),
+                version => {
+                    return Err(
+                        gix_error::validation(format!("Unsupported multi-index version: {version}")).raise_erased(),
+                    );
+                }
             };
 
             let (object_hash, data) = data.split_at(1);
             let object_hash = gix_hash::Kind::try_from(object_hash[0])
-                .map_err(|unknown| Error::UnsupportedObjectHash { kind: unknown })?;
+                .map_err(|unknown| gix_error::validation(format!("Unsupported hash kind: {unknown}")).raise_erased())?;
             let (num_chunks, data) = data.split_at(1);
             let num_chunks = num_chunks[0];
 
@@ -105,40 +79,43 @@ where
             (version, object_hash, num_chunks, num_indices)
         };
 
-        let chunks = gix_chunk::file::Index::from_bytes(&data, Self::HEADER_LEN, u32::from(num_chunks))?;
+        let chunks = gix_chunk::file::Index::from_bytes(&data, Self::HEADER_LEN, u32::from(num_chunks))
+            .or_raise_erased(|| gix_error::corruption("Could not decode multi-index chunk table"))?;
 
-        let index_names = chunks.data_by_id(&data, chunk::index_names::ID)?;
-        let index_names = chunk::index_names::from_bytes(index_names, num_indices, alloc_limit_bytes)?;
+        let index_names = chunks
+            .data_by_id(&data, chunk::index_names::ID)
+            .or_raise_erased(|| gix_error::corruption("Could not read multi-index pack names"))?;
+        let index_names = chunk::index_names::from_bytes(index_names, num_indices, alloc_limit_bytes).or_erased()?;
 
-        let fan = chunks.data_by_id(&data, chunk::fanout::ID)?;
-        let fan = chunk::fanout::from_bytes(fan).ok_or(Error::MultiPackFanSize)?;
+        let fan = chunks
+            .data_by_id(&data, chunk::fanout::ID)
+            .or_raise_erased(|| gix_error::corruption("Could not read multi-index fan"))?;
+        let fan = chunk::fanout::from_bytes(fan)
+            .ok_or_else(|| corrupt("The multi-index fan doesn't have the correct size of 256 * 4 bytes"))?;
         let num_objects = fan[255];
         validate_fan(&fan)?;
 
-        let lookup = chunks.validated_usize_offset_by_id(chunk::lookup::ID, |offset| {
-            chunk::lookup::is_valid(&offset, object_hash, num_objects)
-                .then_some(offset)
-                .ok_or(Error::InvalidChunkSize {
-                    id: chunk::lookup::ID,
-                    message: "The chunk with alphabetically ordered object ids doesn't have the correct size",
-                })
-        })??;
-        let offsets = chunks.validated_usize_offset_by_id(chunk::offsets::ID, |offset| {
-            chunk::offsets::is_valid(&offset, num_objects)
-                .then_some(offset)
-                .ok_or(Error::InvalidChunkSize {
-                    id: chunk::offsets::ID,
-                    message: "The chunk with offsets into the pack doesn't have the correct size",
-                })
-        })??;
+        let lookup = chunks
+            .validated_usize_offset_by_id(chunk::lookup::ID, |offset| {
+                chunk::lookup::is_valid(&offset, object_hash, num_objects)
+                    .then_some(offset)
+                    .ok_or_else(|| {
+                        corrupt("The chunk with alphabetically ordered object ids doesn't have the correct size")
+                    })
+            })
+            .or_raise_erased(|| gix_error::corruption("Could not find the multi-index object-id lookup chunk"))??;
+        let offsets = chunks
+            .validated_usize_offset_by_id(chunk::offsets::ID, |offset| {
+                chunk::offsets::is_valid(&offset, num_objects)
+                    .then_some(offset)
+                    .ok_or_else(|| corrupt("The chunk with offsets into the pack doesn't have the correct size"))
+            })
+            .or_raise_erased(|| gix_error::corruption("Could not find the multi-index pack-offset chunk"))??;
         let large_offsets = chunks
             .validated_usize_offset_by_id(chunk::large_offsets::ID, |offset| {
                 chunk::large_offsets::is_valid(&offset)
                     .then_some(offset)
-                    .ok_or(Error::InvalidChunkSize {
-                        id: chunk::large_offsets::ID,
-                        message: "The chunk with large offsets into the pack doesn't have the correct size",
-                    })
+                    .ok_or_else(|| corrupt("The chunk with large offsets into the pack doesn't have the correct size"))
             })
             .ok()
             .transpose()?;
@@ -146,9 +123,9 @@ where
         let checksum_offset = chunks.highest_offset() as usize;
         let trailer = &data[checksum_offset..];
         if trailer.len() != object_hash.len_in_bytes() {
-            return Err(Error::Corrupt {
-                message: "Trailing checksum didn't have the expected size or there were unknown bytes after the checksum.",
-            });
+            return Err(corrupt(
+                "Trailing checksum didn't have the expected size or there were unknown bytes after the checksum.",
+            ));
         }
 
         Ok(File {
@@ -169,11 +146,9 @@ where
     }
 }
 
-fn validate_fan(fan: &[u32; 256]) -> Result<(), Error> {
+fn validate_fan(fan: &[u32; 256]) -> ExnResult {
     if !crate::fan_is_monotonically_increasing(fan) {
-        return Err(Error::Corrupt {
-            message: "multi-index fan-out table must be monotonically increasing",
-        });
+        return Err(corrupt("multi-index fan-out table must be monotonically increasing"));
     }
     Ok(())
 }
diff --git a/gix-pack/src/multi_index/verify.rs b/gix-pack/src/multi_index/verify.rs
index 5052d1127cd..730c154af2a 100644
--- a/gix-pack/src/multi_index/verify.rs
+++ b/gix-pack/src/multi_index/verify.rs
@@ -1,44 +1,12 @@
 use std::{cmp::Ordering, sync::atomic::AtomicBool, time::Instant};
 
+use gix_error::{ErrorExt, ExnResult, retryable};
 use gix_features::progress::{Count, DynNestedProgress, Progress};
 
 use crate::{exact_vec, index, multi_index::File};
 
 ///
 pub mod integrity {
-    use crate::multi_index::EntryIndex;
-
-    /// Returned by [`multi_index::File::verify_integrity()`][crate::multi_index::File::verify_integrity()].
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Object {id} should be at pack-offset {expected_pack_offset} but was found at {actual_pack_offset}")]
-        PackOffsetMismatch {
-            id: gix_hash::ObjectId,
-            expected_pack_offset: u64,
-            actual_pack_offset: u64,
-        },
-        #[error(transparent)]
-        MultiIndexChecksum(#[from] crate::multi_index::verify::checksum::Error),
-        #[error(transparent)]
-        IndexIntegrity(#[from] crate::index::verify::integrity::Error),
-        #[error(transparent)]
-        BundleInit(#[from] crate::bundle::init::Error),
-        #[error("Counted {actual} objects, but expected {expected} as per multi-index")]
-        UnexpectedObjectCount { actual: usize, expected: usize },
-        #[error("{id} wasn't found in the index referenced in the multi-pack index")]
-        OidNotFound { id: gix_hash::ObjectId },
-        #[error("The object id at multi-index entry {index} wasn't in order")]
-        OutOfOrder { index: EntryIndex },
-        #[error("The fan at index {index} is out of order as it's larger then the following value.")]
-        Fan { index: usize },
-        #[error("The multi-index claims to have no objects")]
-        Empty,
-        #[error("The multi-index path '{path}' has no parent directory")]
-        InvalidPath { path: std::path::PathBuf },
-        #[error("Interrupted")]
-        Interrupted,
-    }
 
     /// Returned by [`multi_index::File::verify_integrity()`][crate::multi_index::File::verify_integrity()].
     pub struct Outcome {
@@ -69,12 +37,6 @@ pub mod integrity {
     }
 }
 
-///
-pub mod checksum {
-    /// Returned by [`multi_index::File::verify_checksum()`][crate::multi_index::File::verify_checksum()].
-    pub type Error = crate::verify::checksum::Error;
-}
-
 impl<T> File<T>
 where
     T: crate::FileData,
@@ -85,7 +47,7 @@ where
         &self,
         progress: &mut dyn Progress,
         should_interrupt: &AtomicBool,
-    ) -> Result<gix_hash::ObjectId, checksum::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         crate::verify::checksum_on_disk_or_mmap(
             self.path(),
             &self.data,
@@ -103,17 +65,13 @@ where
         &self,
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
-    ) -> Result<gix_hash::ObjectId, integrity::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         self.verify_integrity_inner(
             progress,
             should_interrupt,
             false,
             index::verify::integrity::Options::default(),
         )
-        .map_err(|err| match err {
-            index::traverse::Error::Processor(err) => err,
-            _ => unreachable!("BUG: no other error type is possible"),
-        })
         .map(|o| o.actual_index_checksum)
     }
 
@@ -125,7 +83,7 @@ where
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
         options: index::verify::integrity::Options<F>,
-    ) -> Result<integrity::Outcome, index::traverse::Error<integrity::Error>>
+    ) -> ExnResult<integrity::Outcome>
     where
         C: crate::cache::DecodeEntry,
         F: Fn() -> C + Send + Clone,
@@ -139,36 +97,36 @@ where
         should_interrupt: &AtomicBool,
         deep_check: bool,
         options: index::verify::integrity::Options<F>,
-    ) -> Result<integrity::Outcome, index::traverse::Error<integrity::Error>>
+    ) -> ExnResult<integrity::Outcome>
     where
         C: crate::cache::DecodeEntry,
         F: Fn() -> C + Send + Clone,
     {
         let parent = self.path.parent().ok_or_else(|| {
-            index::traverse::Error::Processor(integrity::Error::InvalidPath {
-                path: self.path.clone(),
-            })
+            gix_error::validation(format!(
+                "The multi-index path '{}' has no parent directory",
+                self.path.display()
+            ))
+            .raise_erased()
         })?;
 
-        let actual_index_checksum = self
-            .verify_checksum(
-                &mut progress.add_child_with_id(
-                    format!("{}: checksum", self.path.display()),
-                    integrity::ProgressId::ChecksumBytes.into(),
-                ),
-                should_interrupt,
-            )
-            .map_err(integrity::Error::from)
-            .map_err(index::traverse::Error::Processor)?;
+        let actual_index_checksum = self.verify_checksum(
+            &mut progress.add_child_with_id(
+                format!("{}: checksum", self.path.display()),
+                integrity::ProgressId::ChecksumBytes.into(),
+            ),
+            should_interrupt,
+        )?;
 
         if let Some(first_invalid) = crate::verify::fan(&self.fan) {
-            return Err(index::traverse::Error::Processor(integrity::Error::Fan {
-                index: first_invalid,
-            }));
+            return Err(gix_error::corruption(format!(
+                "The fan at index {first_invalid} is out of order as it's larger then the following value."
+            ))
+            .raise_erased());
         }
 
         if self.num_objects == 0 {
-            return Err(index::traverse::Error::Processor(integrity::Error::Empty));
+            return Err(gix_error::corruption("The multi-index claims to have no objects").raise_erased());
         }
 
         let mut pack_traverse_statistics = Vec::new();
@@ -189,9 +147,10 @@ where
                 let rhs = self.oid_at_index(entry_index + 1);
 
                 if rhs.cmp(lhs) != Ordering::Greater {
-                    return Err(index::traverse::Error::Processor(integrity::Error::OutOfOrder {
-                        index: entry_index,
-                    }));
+                    return Err(gix_error::corruption(format!(
+                        "The object id at multi-index entry {entry_index} wasn't in order"
+                    ))
+                    .raise_erased());
                 }
                 let (pack_id, _) = self.pack_id_and_pack_offset_at_index(entry_index);
                 pack_ids_and_offsets.push((pack_id, entry_index));
@@ -222,18 +181,12 @@ where
             let index;
             let index_path = parent.join(index_file_name);
             let index = if deep_check {
-                let mut opened_bundle = crate::Bundle::at(index_path, self.object_hash)
-                    .map_err(integrity::Error::from)
-                    .map_err(index::traverse::Error::Processor)?;
+                let mut opened_bundle = crate::Bundle::at(index_path, self.object_hash)?;
                 opened_bundle.pack.alloc_limit_bytes = self.alloc_limit_bytes;
                 bundle = Some(opened_bundle);
                 bundle.as_ref().map(|b| &b.index).expect("just set")
             } else {
-                index = Some(
-                    index::File::at(index_path, self.object_hash)
-                        .map_err(|err| integrity::Error::BundleInit(crate::bundle::init::Error::Index(err)))
-                        .map_err(index::traverse::Error::Processor)?,
-                );
+                index = Some(index::File::at(index_path, self.object_hash)?);
                 index.as_ref().expect("just set")
             };
 
@@ -255,23 +208,23 @@ where
                     let oid = self.oid_at_index(entry_id);
                     let (_, expected_pack_offset) = self.pack_id_and_pack_offset_at_index(entry_id);
                     let entry_in_bundle_index = index.lookup(oid).ok_or_else(|| {
-                        index::traverse::Error::Processor(integrity::Error::OidNotFound { id: oid.to_owned() })
+                        gix_error::corruption(format!(
+                            "{oid} wasn't found in the index referenced in the multi-pack index"
+                        ))
+                        .raise_erased()
                     })?;
                     let actual_pack_offset = index.pack_offset_at_index(entry_in_bundle_index);
                     if actual_pack_offset != expected_pack_offset {
-                        return Err(index::traverse::Error::Processor(
-                            integrity::Error::PackOffsetMismatch {
-                                id: oid.to_owned(),
-                                expected_pack_offset,
-                                actual_pack_offset,
-                            },
-                        ));
+                        return Err(gix_error::corruption(format!(
+                            "Object {oid} should be at pack-offset {expected_pack_offset} but was found at {actual_pack_offset}"
+                        ))
+                        .raise_erased());
                     }
                     offsets_progress.inc();
                 }
 
                 if should_interrupt.load(std::sync::atomic::Ordering::Relaxed) {
-                    return Err(index::traverse::Error::Processor(integrity::Error::Interrupted));
+                    return Err(retryable("Interrupted").raise_erased());
                 }
                 offsets_progress.show_throughput(offset_start);
             }
@@ -283,34 +236,7 @@ where
                 let crate::bundle::verify::integrity::Outcome {
                     actual_index_checksum: _,
                     pack_traverse_outcome,
-                } = bundle
-                    .verify_integrity(progress, should_interrupt, options.clone())
-                    .map_err(|err| {
-                        use index::traverse::Error::*;
-                        match err {
-                            Processor(err) => Processor(integrity::Error::IndexIntegrity(err)),
-                            IndexVerify(err) => IndexVerify(err),
-                            Tree(err) => Tree(err),
-                            TreeTraversal(err) => TreeTraversal(err),
-                            PackVerify(err) => PackVerify(err),
-                            PackDecode { id, offset, source } => PackDecode { id, offset, source },
-                            PackMismatch(err) => PackMismatch(err),
-                            EntryType(err) => EntryType(err),
-                            PackObjectVerify { offset, source } => PackObjectVerify { offset, source },
-                            Crc32Mismatch {
-                                expected,
-                                actual,
-                                offset,
-                                kind,
-                            } => Crc32Mismatch {
-                                expected,
-                                actual,
-                                offset,
-                                kind,
-                            },
-                            Interrupted => Interrupted,
-                        }
-                    })?;
+                } = bundle.verify_integrity(progress, should_interrupt, options.clone())?;
                 pack_traverse_statistics.push(pack_traverse_outcome);
             }
         }
diff --git a/gix-pack/src/multi_index/write.rs b/gix-pack/src/multi_index/write.rs
index 1d5d9c71c4e..b912e2a5f66 100644
--- a/gix-pack/src/multi_index/write.rs
+++ b/gix-pack/src/multi_index/write.rs
@@ -2,29 +2,6 @@ use std::time::SystemTime;
 
 use crate::multi_index;
 
-mod error {
-    /// The error returned by [`crate::multi_index::write_from_index_paths()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error("Interrupted")]
-        Interrupted,
-        #[error(transparent)]
-        OpenIndex(#[from] crate::index::init::Error),
-        #[error("Too many index entries to fit in memory")]
-        OutOfMemory,
-    }
-
-    impl From<gix_hash::io::Error> for Error {
-        fn from(err: gix_hash::io::Error) -> Self {
-            Error::Io(std::io::Error::other(err.into_error()))
-        }
-    }
-}
-pub use error::Error;
-
 /// An entry suitable for sorting and writing
 pub(crate) struct Entry {
     pub(crate) id: gix_hash::ObjectId,
@@ -83,11 +60,12 @@ pub(super) mod function {
         time::{Instant, SystemTime},
     };
 
+    use gix_error::{ErrorExt, ExnResult, ResourceExhaustionKind, ResultExt, retryable};
     use gix_features::progress::{Count, DynNestedProgress, Progress};
 
     use crate::{MMap, multi_index};
 
-    use super::{Entry, Error, Options, Outcome, ProgressId};
+    use super::{Entry, Options, Outcome, ProgressId};
 
     /// Create a new multi-index file for writing to `out` from the pack index files at `index_paths`.
     ///
@@ -98,7 +76,7 @@ pub(super) mod function {
         progress: &mut dyn DynNestedProgress,
         should_interrupt: &AtomicBool,
         Options { object_hash }: Options,
-    ) -> Result<Outcome, Error> {
+    ) -> ExnResult<Outcome> {
         let out = gix_hash::io::Write::new(out, object_hash);
         let (index_paths_sorted, index_filenames_sorted) = {
             index_paths.sort();
@@ -126,9 +104,12 @@ pub(super) mod function {
                     .unwrap_or(SystemTime::UNIX_EPOCH);
                 let index = crate::index::File::at(index, object_hash)?;
 
-                entries
-                    .try_reserve(index.num_objects() as usize)
-                    .map_err(|_| Error::OutOfMemory)?;
+                entries.try_reserve(index.num_objects() as usize).or_raise_erased(|| {
+                    gix_error::resource_exhaustion(
+                        ResourceExhaustionKind::AllocationFailure,
+                        "Too many index entries to fit in memory",
+                    )
+                })?;
                 entries.extend(index.iter().map(|e| Entry {
                     id: e.oid,
                     pack_index: index_id as u32,
@@ -137,7 +118,7 @@ pub(super) mod function {
                 }));
                 progress.inc();
                 if should_interrupt.load(Ordering::Relaxed) {
-                    return Err(Error::Interrupted);
+                    return Err(retryable("Interrupted").raise_erased());
                 }
             }
             progress.show_throughput(start);
@@ -154,7 +135,7 @@ pub(super) mod function {
             progress.inc_by(entries.len());
             progress.show_throughput(start);
             if should_interrupt.load(Ordering::Relaxed) {
-                return Err(Error::Interrupted);
+                return Err(retryable("Interrupted").raise_erased());
             }
             entries
         };
@@ -229,7 +210,7 @@ pub(super) mod function {
                 .map_err(gix_hash::io::from_std_io)?;
                 progress.inc();
                 if should_interrupt.load(Ordering::Relaxed) {
-                    return Err(Error::Interrupted);
+                    return Err(retryable("Interrupted").raise_erased());
                 }
             }
         }
diff --git a/gix-pack/src/testing.rs b/gix-pack/src/testing.rs
index 2336974e814..0491ca1f8b6 100644
--- a/gix-pack/src/testing.rs
+++ b/gix-pack/src/testing.rs
@@ -1,4 +1,5 @@
 use crate::find::Entry;
+use gix_error::ExnResult;
 
 /// An in-memory object database without pack locations.
 #[derive(Clone)]
@@ -29,7 +30,7 @@ impl crate::Find for Memory {
         id: &gix_hash::oid,
         buffer: &'a mut Vec<u8>,
         _pack_cache: &mut dyn crate::cache::DecodeEntry,
-    ) -> Result<Option<(gix_object::Data<'a>, Option<crate::data::entry::Location>)>, gix_object::find::Error> {
+    ) -> ExnResult<Option<(gix_object::Data<'a>, Option<crate::data::entry::Location>)>> {
         Ok(self.objects.get(id).map(|(kind, data)| {
             buffer.clear();
             buffer.extend_from_slice(data);
diff --git a/gix-pack/src/verify.rs b/gix-pack/src/verify.rs
index 4bdca84de36..41e37ffd93e 100644
--- a/gix-pack/src/verify.rs
+++ b/gix-pack/src/verify.rs
@@ -1,22 +1,8 @@
 use std::{path::Path, sync::atomic::AtomicBool};
 
+use gix_error::{Class, ClassificationMarker, ErrorExt, ExnResult, ResultExt, message};
 use gix_features::progress::Progress;
 
-///
-pub mod checksum {
-    /// Returned by various methods to verify the checksum of a memory mapped file that might also exist on disk.
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Interrupted by user")]
-        Interrupted,
-        #[error("Failed to hash data")]
-        Hasher(#[source] gix_error::Error),
-        #[error(transparent)]
-        Verify(#[from] gix_hash::verify::Error),
-    }
-}
-
 /// Returns the `index` at which the following `index + 1` value is not an increment over the value at `index`.
 pub fn fan(data: &[u32]) -> Option<usize> {
     data.windows(2)
@@ -25,8 +11,7 @@ pub fn fan(data: &[u32]) -> Option<usize> {
 }
 
 /// Calculate the hash of the given kind by trying to read the file from disk at `data_path` or falling back on the mapped content in `data`.
-/// `Ok(expected)` or [`checksum::Error::Verify`] is returned if the hash matches or mismatches.
-/// If the [`checksum::Error::Interrupted`] is returned, the operation was interrupted.
+/// `Ok(expected)` is returned if the hash matches, otherwise the error is classified as corruption.
 pub fn checksum_on_disk_or_mmap(
     data_path: &Path,
     data: &[u8],
@@ -34,7 +19,7 @@ pub fn checksum_on_disk_or_mmap(
     object_hash: gix_hash::Kind,
     progress: &mut dyn Progress,
     should_interrupt: &AtomicBool,
-) -> Result<gix_hash::ObjectId, checksum::Error> {
+) -> ExnResult<gix_hash::ObjectId> {
     let data_len_without_trailer = data.len() - object_hash.len_in_bytes();
     let actual = match gix_hash::bytes_of_file(
         data_path,
@@ -45,7 +30,9 @@ pub fn checksum_on_disk_or_mmap(
     ) {
         Ok(id) => id,
         Err(err) => match err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind) {
-            Some(std::io::ErrorKind::Interrupted) => return Err(checksum::Error::Interrupted),
+            Some(std::io::ErrorKind::Interrupted) => {
+                return Err(ClassificationMarker::with_source(Class::Retryable, err.into_error()).raise_erased());
+            }
             Some(_) => {
                 let start = std::time::Instant::now();
                 let mut hasher = gix_hash::hasher(object_hash);
@@ -54,13 +41,14 @@ pub fn checksum_on_disk_or_mmap(
                 progress.show_throughput(start);
                 hasher
                     .try_finalize()
-                    .map_err(gix_hash::io::from_hasher)
-                    .map_err(|err| checksum::Error::Hasher(err.into_error()))?
+                    .or_raise_erased(|| message("Failed to hash data"))?
             }
-            None => return Err(checksum::Error::Hasher(err.into_error())),
+            None => return Err(err),
         },
     };
 
-    actual.verify(&expected)?;
+    actual
+        .verify(&expected)
+        .or_raise_erased(|| gix_error::corruption("Failed to verify pack file checksum"))?;
     Ok(actual)
 }
diff --git a/gix-pack/tests/pack/bundle.rs b/gix-pack/tests/pack/bundle.rs
index f2c7a6d943d..d524a1cd81c 100644
--- a/gix-pack/tests/pack/bundle.rs
+++ b/gix-pack/tests/pack/bundle.rs
@@ -1,4 +1,5 @@
 mod locate {
+    use crate::Result;
     use bstr::ByteSlice;
     use gix_object::Kind;
     use gix_odb::pack;
@@ -20,12 +21,13 @@ mod locate {
     }
 
     mod locate_and_verify {
+        use crate::Result;
         use gix_odb::pack;
 
         use crate::{PACKS_AND_INDICES, fixture_path};
 
         #[test]
-        fn all() -> Result<(), Box<dyn std::error::Error>> {
+        fn all() -> Result {
             for (index_path, data_path) in PACKS_AND_INDICES {
                 // both paths are equivalent
                 pack::Bundle::at(fixture_path(index_path), gix_hash::Kind::Sha1)?;
@@ -49,7 +51,7 @@ mod locate {
     }
 
     #[test]
-    fn blob() -> Result<(), Box<dyn std::error::Error>> {
+    fn blob() -> Result {
         let mut out = Vec::new();
         let obj = locate("bd46bb3f5bb4ca5431770c4fde0735fb89d382f3", &mut out);
 
@@ -65,7 +67,7 @@ mod locate {
     }
 
     #[test]
-    fn tree() -> Result<(), Box<dyn std::error::Error>> {
+    fn tree() -> Result {
         let mut out = Vec::new();
         let obj = locate("e90926b07092bccb7bf7da445fae6ffdfacf3eae", &mut out);
 
@@ -75,7 +77,7 @@ mod locate {
     }
 
     #[test]
-    fn commit() -> Result<(), Box<dyn std::error::Error>> {
+    fn commit() -> Result {
         let mut out = Vec::new();
         let obj = locate("779c5451ba9fe210ffd1f55db202e55f51acecac", &mut out);
 
@@ -87,6 +89,7 @@ mod locate {
 
 #[cfg(all(not(feature = "wasm"), feature = "streaming-input"))]
 mod write_to_directory {
+    use crate::Result;
     use std::{
         fs,
         io::{Cursor, Write},
@@ -98,9 +101,9 @@ mod write_to_directory {
     use gix_odb::pack;
     use gix_testtools::tempfile::TempDir;
 
-    use crate::{SMALL_PACK, SMALL_PACK_INDEX, error_chain_contains_message, fixture_path};
+    use crate::{SMALL_PACK, SMALL_PACK_INDEX, fixture_path};
 
-    fn expected_outcome() -> Result<pack::bundle::write::Outcome, Box<dyn std::error::Error>> {
+    fn expected_outcome() -> Result<pack::bundle::write::Outcome> {
         Ok(pack::bundle::write::Outcome {
             index: pack::index::write::Outcome {
                 index_version: pack::index::Version::V2,
@@ -117,7 +120,7 @@ mod write_to_directory {
     }
 
     #[test]
-    fn without_providing_one() -> Result<(), Box<dyn std::error::Error>> {
+    fn without_providing_one() -> Result {
         let res = write_pack(None::<&Path>, SMALL_PACK)?;
         assert_eq!(res, expected_outcome()?);
         assert_eq!(
@@ -129,12 +132,14 @@ mod write_to_directory {
     }
 
     #[test]
-    fn given_a_directory() -> Result<(), Box<dyn std::error::Error>> {
+    fn given_a_directory() -> Result {
         let dir = TempDir::new()?;
         let mut res = write_pack(Some(&dir), SMALL_PACK)?;
         let (index_path, data_path, keep_path) = (res.index_path.take(), res.data_path.take(), res.keep_path.take());
         assert_eq!(res, expected_outcome()?);
-        let mut sorted_entries = fs::read_dir(&dir)?.filter_map(Result::ok).collect::<Vec<_>>();
+        let mut sorted_entries = fs::read_dir(&dir)?
+            .filter_map(std::result::Result::ok)
+            .collect::<Vec<_>>();
         sorted_entries.sort_by_key(fs::DirEntry::file_name);
         assert_eq!(
             sorted_entries.len(),
@@ -162,7 +167,7 @@ mod write_to_directory {
     /// already has. `index-pack --fix-thin` makes such packs self-contained by appending
     /// those bases, leaving the original deltas as forward references.
     #[test]
-    fn in_pack_ref_deltas_with_forward_references() -> Result<(), Box<dyn std::error::Error>> {
+    fn in_pack_ref_deltas_with_forward_references() -> Result {
         for object_hash in [gix_hash::Kind::Sha1, gix_hash::Kind::Sha256] {
             for objects in [
                 &[b"A".as_slice(), b"B".as_slice()][..],
@@ -219,7 +224,7 @@ mod write_to_directory {
     }
 
     #[test]
-    fn version_3_with_thin_pack_lookup() -> Result<(), Box<dyn std::error::Error>> {
+    fn version_3_with_thin_pack_lookup() -> Result {
         let object_hash = gix_hash::Kind::Sha1;
         let pack_data = ref_delta_pack(
             object_hash,
@@ -247,7 +252,7 @@ mod write_to_directory {
     }
 
     #[test]
-    fn unresolved_ref_delta_base_is_reported() -> Result<(), Box<dyn std::error::Error>> {
+    fn unresolved_ref_delta_base_is_reported() -> Result {
         let object_hash = gix_hash::Kind::Sha1;
         let base_id = object_hash.null();
         let delta = [0, 0];
@@ -274,16 +279,13 @@ mod write_to_directory {
             },
         )
         .expect_err("a ref-delta without an in-pack or external base cannot be indexed");
-        let expected = format!("The ref-delta base object {base_id} could not be found");
-        assert!(
-            error_chain_contains_message(&err, &expected),
-            "the missing base id is retained in the error chain"
-        );
+        assert!(err.is_not_found(), "an unresolved base is classified as not found");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "the missing base id is retained in the error chain", @"The ref-delta base object Oid(1) could not be found");
         Ok(())
     }
 
     #[test]
-    fn respects_alloc_limit_bytes() -> Result<(), Box<dyn std::error::Error>> {
+    fn respects_alloc_limit_bytes() -> Result {
         let pack_file = fs::File::open(fixture_path(SMALL_PACK))?;
         static SHOULD_INTERRUPT: AtomicBool = AtomicBool::new(false);
 
@@ -306,10 +308,7 @@ mod write_to_directory {
         )
         .expect_err("a zero allocation limit rejects non-empty delta-tree storage");
 
-        assert!(
-            error_chain_contains_message(&err, "The pack delta tree is too large to fit in memory"),
-            "bundle writing must forward its allocation limit to index writing"
-        );
+        insta::assert_debug_snapshot!(err, "bundle writing must forward its allocation limit to index writing", @"The pack delta tree is too large to fit in memory");
         Ok(())
     }
 
@@ -317,13 +316,10 @@ mod write_to_directory {
         entry.path().file_name().unwrap().to_str().unwrap().to_owned()
     }
 
-    fn write_pack(
-        directory: Option<impl AsRef<Path>>,
-        pack_file: &str,
-    ) -> Result<pack::bundle::write::Outcome, Box<dyn std::error::Error>> {
+    fn write_pack(directory: Option<impl AsRef<Path>>, pack_file: &str) -> Result<pack::bundle::write::Outcome> {
         let pack_file = fs::File::open(fixture_path(pack_file))?;
         static SHOULD_INTERRUPT: AtomicBool = AtomicBool::new(false);
-        pack::Bundle::write_to_directory_eagerly(
+        Ok(pack::Bundle::write_to_directory_eagerly(
             Box::new(pack_file),
             None,
             directory,
@@ -338,8 +334,7 @@ mod write_to_directory {
                 alloc_limit_bytes: None,
                 compression: gix_zlib::Compression::BEST_SPEED,
             },
-        )
-        .map_err(Into::into)
+        )?)
     }
 
     /// Build a complete pack whose one-byte blobs form a forward `REF_DELTA` chain.
@@ -358,7 +353,7 @@ mod write_to_directory {
         object_hash: gix_hash::Kind,
         objects: &[&'static [u8]],
         version: pack::data::Version,
-    ) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+    ) -> Result<Vec<u8>> {
         let mut pack_data = pack::data::header::encode(version, objects.len() as u32).to_vec();
         for pair in objects.windows(2).rev() {
             let (base, resolved) = (pair[0], pair[1]);
@@ -377,7 +372,7 @@ mod write_to_directory {
         Ok(pack_data)
     }
 
-    fn deflate(input: &[u8]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+    fn deflate(input: &[u8]) -> Result<Vec<u8>> {
         let mut out = gix_zlib::stream::deflate::Write::new(Vec::new(), gix_zlib::Compression::BEST_SPEED);
         out.write_all(input)?;
         out.flush()?;
diff --git a/gix-pack/tests/pack/data/file.rs b/gix-pack/tests/pack/data/file.rs
index 6929497dc58..8a341f039c9 100644
--- a/gix-pack/tests/pack/data/file.rs
+++ b/gix-pack/tests/pack/data/file.rs
@@ -6,7 +6,33 @@ fn pack_at(at: &str) -> pack::data::File {
     pack::data::File::at(fixture_path(at).as_path(), gix_hash::Kind::Sha1).expect("valid pack file")
 }
 
+#[test]
+fn unresolved_delta_base_is_not_found() {
+    use gix_error::{ErrorExt, message};
+
+    let base_id = gix_hash::ObjectId::empty_blob(gix_hash::Kind::Sha1);
+    let err = pack::data::decode::DeltaBaseUnresolved(base_id).and_raise(message("Could not decode object"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "an unresolved delta base is a missing object", @"
+    Could not decode object
+    |
+    └─ A delta chain could not be followed as the ref base with id Oid(1) could not be found
+    ");
+    assert!(err.is_not_found(), "an unresolved delta base is a missing object");
+    assert!(
+        err.probable_cause().is::<pack::data::decode::DeltaBaseUnresolved>(),
+        "the missing delta base, not its classification marker or outer context, is the probable cause"
+    );
+    assert_eq!(
+        err.downcast_any_ref::<pack::data::decode::DeltaBaseUnresolved>()
+            .expect("the missing delta base is retained")
+            .0,
+        base_id,
+        "the decode failure retains the missing object ID"
+    );
+}
+
 mod method {
+    use crate::Result;
     use std::sync::atomic::AtomicBool;
 
     use gix_features::progress;
@@ -20,7 +46,7 @@ mod method {
     }
 
     #[test]
-    fn verify_checksum() -> Result<(), Box<dyn std::error::Error>> {
+    fn verify_checksum() -> Result {
         let p = pack_at(SMALL_PACK);
         assert_eq!(
             p.verify_checksum(&mut progress::Discard, &AtomicBool::new(false))?,
@@ -30,7 +56,7 @@ mod method {
     }
 
     #[test]
-    fn verify_checksum_from_memory() -> Result<(), Box<dyn std::error::Error>> {
+    fn verify_checksum_from_memory() -> Result {
         let p = pack_from_memory_at(SMALL_PACK);
         assert_eq!(
             p.verify_checksum(&mut progress::Discard, &AtomicBool::new(false))?,
@@ -62,23 +88,27 @@ mod method {
         buf.clear();
         let pack = pack_at(SMALL_PACK).with_alloc_limit_bytes(Some(0));
         let entry = pack.entry(entry_offset).expect("valid object type");
-        assert!(
-            matches!(
-                pack.decode_entry(
-                    entry,
-                    &mut buf,
-                    &mut inflate,
-                    &|_, _| None,
-                    &mut gix_odb::pack::cache::Never
-                ),
-                Err(gix_odb::pack::data::decode::Error::OutOfMemory)
-            ),
-            "pack-controlled allocations larger than the configured limit are rejected"
+        let err = pack
+            .decode_entry(
+                entry,
+                &mut buf,
+                &mut inflate,
+                &|_, _| None,
+                &mut gix_odb::pack::cache::Never,
+            )
+            .expect_err("pack-controlled allocations larger than the configured limit are rejected");
+        insta::assert_debug_snapshot!(err, "decode entry respects alloc limit bytes", @"Entry too large to fit in memory");
+        assert_eq!(
+            err.classify().find_map(|classification| match classification.class() {
+                gix_error::Class::ResourceExhaustion(kind) => Some(kind),
+                _ => None,
+            }),
+            Some(gix_error::ResourceExhaustionKind::AllocationLimit)
         );
     }
 
     #[test]
-    fn iter() -> Result<(), Box<dyn std::error::Error>> {
+    fn iter() -> Result {
         let pack = pack_at(SMALL_PACK);
         let it = pack.streaming_iter()?;
         assert_eq!(it.count(), pack.num_objects() as usize);
@@ -263,6 +293,20 @@ mod decompress_entry {
         );
     }
 
+    #[test]
+    fn caller_provided_buffer_must_be_large_enough() {
+        let p = pack_at(SMALL_PACK);
+        let entry = p.entry(1968).expect("valid object type");
+        let mut buf = vec![0; entry.decompressed_size as usize - 1];
+
+        let err = p
+            .decompress_entry(&entry, &mut Default::default(), &mut buf)
+            .expect_err("an undersized caller-provided buffer is invalid input");
+        insta::assert_debug_snapshot!(err, "caller provided buffer must be large enough", @"Output buffer is too small for the decompressed entry");
+        assert!(err.is_validation());
+        assert!(!err.is_resource_exhausted());
+    }
+
     fn decompress_entry_at_offset(offset: u64) -> Vec<u8> {
         let p = pack_at(SMALL_PACK);
         let entry = p.entry(offset).expect("valid object type");
diff --git a/gix-pack/tests/pack/data/fuzzed.rs b/gix-pack/tests/pack/data/fuzzed.rs
index 62a4a80bbf2..c8618a2be2c 100644
--- a/gix-pack/tests/pack/data/fuzzed.rs
+++ b/gix-pack/tests/pack/data/fuzzed.rs
@@ -175,12 +175,16 @@ fn declared_object_size_over_alloc_limit_bytes_is_reported_as_out_of_memory() {
         )
     }));
 
-    assert!(
-        matches!(
-            result.expect("configured allocation limits must not cause panics"),
-            Err(gix_pack::data::decode::Error::OutOfMemory)
-        ),
-        "pack-controlled allocations larger than the configured limit must be rejected"
+    let err = result
+        .expect("configured allocation limits must not cause panics")
+        .expect_err("pack-controlled allocations larger than the configured limit must be rejected");
+    insta::assert_debug_snapshot!(err, "declared object size over alloc limit bytes is reported as out of memory", @"Entry too large to fit in memory");
+    assert_eq!(
+        err.classify().find_map(|classification| match classification.class() {
+            gix_error::Class::ResourceExhaustion(kind) => Some(kind),
+            _ => None,
+        }),
+        Some(gix_error::ResourceExhaustionKind::AllocationLimit)
     );
 }
 
diff --git a/gix-pack/tests/pack/data/header.rs b/gix-pack/tests/pack/data/header.rs
index 84d3d84adc6..4f3d69fb7df 100644
--- a/gix-pack/tests/pack/data/header.rs
+++ b/gix-pack/tests/pack/data/header.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use crate::fixture_path;
 
 #[test]
-fn encode_decode_roundtrip() -> crate::Result {
+fn encode_decode_roundtrip() -> Result {
     let buf = std::fs::read(fixture_path(
         "objects/pack/pack-11fdfa9e156ab73caae3b6da867192221f2089c2.pack",
     ))?;
diff --git a/gix-pack/tests/pack/data/input.rs b/gix-pack/tests/pack/data/input.rs
index 7eb9f034f38..6e3af25060b 100644
--- a/gix-pack/tests/pack/data/input.rs
+++ b/gix-pack/tests/pack/data/input.rs
@@ -1,8 +1,11 @@
 mod lookup_ref_delta_objects {
+    use crate::Result;
     use std::sync::atomic::{AtomicUsize, Ordering};
 
+    use gix_error::ExnResult;
+
     use gix_hash::{ObjectId, oid};
-    use gix_object::{Data, find::Error};
+    use gix_object::Data;
     use gix_pack::data::{entry::Header, input, input::LookupRefDeltaObjectsIter};
 
     use crate::hex_to_id;
@@ -58,9 +61,7 @@ mod lookup_ref_delta_objects {
         }
     }
 
-    fn into_results_iter(
-        entries: Vec<input::Entry>,
-    ) -> impl ExactSizeIterator<Item = Result<input::Entry, input::Error>> {
+    fn into_results_iter(entries: Vec<input::Entry>) -> impl ExactSizeIterator<Item = ExnResult<input::Entry>> {
         entries.into_iter().map(Ok)
     }
 
@@ -79,7 +80,7 @@ mod lookup_ref_delta_objects {
     }
 
     impl gix_object::Find for FindData<'_> {
-        fn try_find<'a>(&self, id: &oid, buf: &'a mut Vec<u8>) -> Result<Option<Data<'a>>, Error> {
+        fn try_find<'a>(&self, id: &oid, buf: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             self.calls.fetch_add(1, Ordering::Relaxed);
             if let Some(data) = self.data {
                 buf.resize(data.len(), 0);
@@ -96,7 +97,7 @@ mod lookup_ref_delta_objects {
     }
 
     #[test]
-    fn only_ref_deltas_are_handled() -> crate::Result {
+    fn only_ref_deltas_are_handled() -> Result {
         let input = compute_offsets(vec![entry(base(), D_A), entry(delta_ofs(100), D_B)]);
         let expected = input.clone();
         let actual = LookupRefDeltaObjectsIter::new(
@@ -104,7 +105,7 @@ mod lookup_ref_delta_objects {
             gix_object::find::Never,
             gix_zlib::Compression::BEST_SPEED,
         )
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
         assert_eq!(actual, expected, "it won't change the input at all");
         validate_pack_offsets(&actual);
         Ok(())
@@ -134,7 +135,7 @@ mod lookup_ref_delta_objects {
             (actual_size.0, actual_size.1.map(|s| s * 2)),
             "size hints are estimated and the upper bound reflects the worst-case scenario for the amount of possible objects"
         );
-        let actual = iter.collect::<Result<Vec<_>, _>>().unwrap();
+        let actual = iter.collect::<std::result::Result<Vec<_>, _>>().unwrap();
 
         assert_eq!(calls.load(Ordering::Relaxed), 2, "there is only two objects to insert");
         assert_eq!(actual.len(), 7, "two object was inserted");
@@ -183,6 +184,7 @@ mod lookup_ref_delta_objects {
 
     #[test]
     fn invalid_ofs_delta_base_distance_is_reported_after_base_insertion() {
+        let mut diagnostics = Vec::new();
         for distance in [0, u64::MAX] {
             let input = compute_offsets(vec![
                 entry(delta_ref(gix_hash::Kind::Sha1.null()), D_A),
@@ -193,19 +195,21 @@ mod lookup_ref_delta_objects {
 
             let result =
                 LookupRefDeltaObjectsIter::new(into_results_iter(input), &db, gix_zlib::Compression::BEST_SPEED)
-                    .collect::<Result<Vec<_>, _>>();
+                    .collect::<std::result::Result<Vec<_>, _>>();
 
+            let err = result.expect_err("zero and out-of-bounds base distances must be rejected");
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
             assert!(
-                matches!(
-                    result,
-                    Err(input::Error::InvalidBaseDistance {
-                        distance: actual,
-                        ..
-                    }) if actual == distance
-                ),
+                err.is_corrupted(),
                 "zero and out-of-bounds base distances are rejected as corrupt pack data"
             );
         }
+        insta::assert_debug_snapshot!(diagnostics, "invalid ofs delta base distance is reported after base insertion", @"
+        [
+            The OFS_DELTA base distance 0 is invalid for pack offset 30,
+            The OFS_DELTA base distance 18446744073709551615 is invalid for pack offset 30,
+        ]
+        ");
     }
 
     #[test]
@@ -218,7 +222,7 @@ mod lookup_ref_delta_objects {
         let calls = AtomicUsize::default();
         let db = FindData::new(None, &calls);
         let result = LookupRefDeltaObjectsIter::new(into_results_iter(input), &db, gix_zlib::Compression::BEST_SPEED)
-            .collect::<Result<Vec<_>, _>>()
+            .collect::<std::result::Result<Vec<_>, _>>()
             .expect("missing objects may be in the pack itself");
         assert_eq!(calls.load(Ordering::Relaxed), 1, "it tries to lookup the object");
         assert_eq!(result, expected, "the unresolved ref-delta is unchanged");
@@ -226,18 +230,15 @@ mod lookup_ref_delta_objects {
 
     #[test]
     fn inner_errors_are_passed_on() {
+        use gix_error::ErrorExt;
+
+        let object_id = gix_hash::Kind::Sha1.null();
         let input = vec![
             Ok(entry(base(), D_A)),
-            Err(input::Error::NotFound {
-                object_id: gix_hash::Kind::Sha1.null(),
-            }),
-            Ok(entry(base(), D_B)),
-        ];
-        let expected = vec![
-            Ok(entry(base(), D_A)),
-            Err(input::Error::NotFound {
-                object_id: gix_hash::Kind::Sha1.null(),
-            }),
+            Err(
+                gix_error::not_found(format!("The object {object_id} could not be decoded or wasn't found"))
+                    .raise_erased(),
+            ),
             Ok(entry(base(), D_B)),
         ];
         let actual = LookupRefDeltaObjectsIter::new(
@@ -246,9 +247,17 @@ mod lookup_ref_delta_objects {
             gix_zlib::Compression::BEST_SPEED,
         )
         .collect::<Vec<_>>();
-        for (actual, expected) in actual.into_iter().zip(expected) {
-            assert_eq!(format!("{actual:?}"), format!("{expected:?}"));
-        }
+        assert_eq!(
+            actual[0].as_ref().expect("first entry passes through"),
+            &entry(base(), D_A)
+        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(actual[1]
+                .as_ref()
+                .expect_err("the inner error passes through")), &[]), "inner errors are passed on", @"The object Oid(1) could not be decoded or wasn't found");
+        assert_eq!(
+            actual[2].as_ref().expect("last entry passes through"),
+            &entry(base(), D_B)
+        );
     }
 
     #[test]
@@ -256,7 +265,7 @@ mod lookup_ref_delta_objects {
         struct MaxSizeHint;
 
         impl Iterator for MaxSizeHint {
-            type Item = Result<input::Entry, input::Error>;
+            type Item = ExnResult<input::Entry>;
 
             fn next(&mut self) -> Option<Self::Item> {
                 None
diff --git a/gix-pack/tests/pack/data/output/count_and_entries.rs b/gix-pack/tests/pack/data/output/count_and_entries.rs
index 5f8a6ffe566..ea15b4e9ccc 100644
--- a/gix-pack/tests/pack/data/output/count_and_entries.rs
+++ b/gix-pack/tests/pack/data/output/count_and_entries.rs
@@ -1,14 +1,14 @@
+use crate::Result;
 use std::sync::atomic::AtomicBool;
 
+use gix_error::ExnResult;
+
 use gix_features::{
     parallel::{InOrderIter, reduce::Finalize},
     progress,
 };
 use gix_odb::{pack, pack::FindExt};
-use gix_pack::data::{
-    output,
-    output::{count, entry},
-};
+use gix_pack::data::{output, output::count};
 
 use crate::{
     data::output::{DbKind, db},
@@ -16,7 +16,8 @@ use crate::{
 };
 
 #[test]
-fn invalid_ofs_delta_base_distance_is_an_error() -> crate::Result {
+fn invalid_ofs_delta_base_distance_is_an_error() -> Result {
+    let mut error_snapshots = Vec::new();
     let first_entry_offset = gix_pack::data::header::SIZE as gix_pack::data::Offset;
     for base_distance in [first_entry_offset, u64::MAX] {
         let mut data = Vec::new();
@@ -42,21 +43,23 @@ fn invalid_ofs_delta_base_distance_is_an_error() -> crate::Result {
             gix_pack::data::Version::V2,
         );
 
-        assert!(
-            matches!(
-                result,
-                Some(Err(entry::Error::EntryType(
-                    gix_pack::data::entry::decode::Error::Corrupt { .. }
-                )))
-            ),
-            "an invalid packed delta is reported as corrupt"
-        );
+        let err = result
+            .and_then(std::result::Result::err)
+            .expect("an invalid OFS_DELTA base distance must fail");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_corrupted(), "an invalid packed delta is reported as corrupt");
     }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid ofs delta base distance is an error", @"
+    [
+        an ofs-delta base distance pointing before pack start,
+        an ofs-delta base distance pointing before pack start,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn traversals() -> crate::Result {
+fn traversals() -> Result {
     #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
     struct Count {
         trees: usize,
@@ -318,7 +321,7 @@ fn traversals() -> crate::Result {
                 "ad454f92f046c2873aebac2686d30d5b100ee10fae1a28e2994df52a0c097cae",
             );
             let mut commits = gix_traverse::commit::Simple::new(Some(head), db.clone())
-                .map(Result::unwrap)
+                .map(std::result::Result::unwrap)
                 .map(|c| c.id)
                 .collect::<Vec<_>>();
             if let Some(take) = take {
@@ -375,7 +378,7 @@ fn traversals() -> crate::Result {
                 },
             );
             let entries: Vec<_> = InOrderIter::from(entries_iter.by_ref())
-                .collect::<Result<Vec<_>, _>>()?
+                .collect::<std::result::Result<Vec<_>, _>>()?
                 .into_iter()
                 .flatten()
                 .collect();
@@ -408,7 +411,7 @@ fn traversals() -> crate::Result {
 }
 
 #[test]
-fn tree_additions_from_each_merge_parent_are_kept() -> crate::Result {
+fn tree_additions_from_each_merge_parent_are_kept() -> Result {
     use gix_object::Write;
 
     let object_hash = object_hash();
@@ -440,7 +443,7 @@ fn tree_additions_from_each_merge_parent_are_kept() -> crate::Result {
         .take_object_memory()
         .expect("in-memory object storage is still enabled");
     let db = gix_pack::testing::Memory::new(objects.drain());
-    let mut input = std::iter::once(Ok::<_, Box<dyn std::error::Error + Send + Sync>>(merge_commit_id));
+    let mut input = std::iter::once(Ok::<_, gix_error::Exn>(merge_commit_id));
 
     let (counts, stats) = output::count::objects_unthreaded(
         &db,
@@ -486,7 +489,7 @@ fn tree_additions_from_each_merge_parent_are_kept() -> crate::Result {
 /// level 1 being much weaker than it used to be, entries have to be compressed with the
 /// configured level, defaulting to what `git` uses.
 #[test]
-fn entry_sizes_depend_on_compression_level() -> crate::Result {
+fn entry_sizes_depend_on_compression_level() -> Result {
     use gix_object::WriteTo;
     let (tree_id, buf) = {
         // Deterministic pseudo-random bytes (xorshift64*), so tree content is stable across runs.
@@ -529,7 +532,7 @@ fn entry_sizes_depend_on_compression_level() -> crate::Result {
         (tree_id, buf)
     };
 
-    let entry_size = |compression| -> Result<usize, output::entry::Error> {
+    let entry_size = |compression| -> ExnResult<usize> {
         Ok(output::Entry::from_data(
             &output::Count::from_data(tree_id, None),
             &gix_object::Data::new(&buf, gix_object::Kind::Tree, gix_hash::Kind::Sha1),
@@ -557,19 +560,14 @@ fn entry_sizes_depend_on_compression_level() -> crate::Result {
 #[test]
 #[cfg(all(not(feature = "wasm"), feature = "streaming-input"))]
 fn empty_pack_is_allowed() {
-    assert_eq!(
-        write_and_verify(
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(write_and_verify(
             db(DbKind::DeterministicGeneratedContent, object_hash()).unwrap(),
             vec![],
             object_hash(),
             hex_to_id("029d08823bd8a8eab510ad6ac75c823cfd3ed31e"),
             None,
         )
-        .unwrap_err()
-        .to_string(),
-        "pack data directory should be set",
-        "empty packs are not actually written as they would be useless"
-    );
+        .expect_err("empty packs are not actually written as they would be useless")), &[]), "empty packs are not actually written as they would be useless", @r#""pack data directory should be set""#);
 }
 
 fn write_and_verify(
@@ -578,7 +576,7 @@ fn write_and_verify(
     object_hash: gix_hash::Kind,
     _expected_pack_hash: gix_hash::ObjectId,
     _expected_thin_pack_hash: Option<gix_hash::ObjectId>,
-) -> crate::Result {
+) -> Result {
     let tmp_dir = gix_testtools::tempfile::TempDir::new()?;
     let pack_file_path = tmp_dir.path().join("new.pack");
     let mut pack_file = std::fs::OpenOptions::new()
@@ -588,7 +586,7 @@ fn write_and_verify(
     let (num_written_bytes, pack_hash) = {
         let num_entries = entries.len();
         let mut pack_writer = output::bytes::FromEntriesIter::new(
-            std::iter::once(Ok::<_, entry::iter_from_counts::Error>(entries)),
+            std::iter::once(Ok::<_, gix_error::Exn>(entries)),
             &mut pack_file,
             num_entries as u32,
             pack::data::Version::V2,
diff --git a/gix-pack/tests/pack/data/output/mod.rs b/gix-pack/tests/pack/data/output/mod.rs
index bde6112f973..3e7a8d4d2fe 100644
--- a/gix-pack/tests/pack/data/output/mod.rs
+++ b/gix-pack/tests/pack/data/output/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{path::PathBuf, sync::Arc};
 
 use gix_pack::data::output;
@@ -32,7 +33,7 @@ enum DbKind {
     DeterministicGeneratedContentMultiIndex,
 }
 
-fn db(kind: DbKind, object_hash: gix_hash::Kind) -> crate::Result<gix_odb::HandleArc> {
+fn db(kind: DbKind, object_hash: gix_hash::Kind) -> Result<gix_odb::HandleArc> {
     use DbKind::*;
     let name = match kind {
         DeterministicGeneratedContent => "make_pack_gen_repo.sh",
diff --git a/gix-pack/tests/pack/index.rs b/gix-pack/tests/pack/index.rs
index 91bd112b7df..a2164373216 100644
--- a/gix-pack/tests/pack/index.rs
+++ b/gix-pack/tests/pack/index.rs
@@ -1,5 +1,6 @@
 const SHA1_SIZE: usize = gix_hash::Kind::Sha1.len_in_bytes();
 
+use crate::Result;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 
 use gix_object::{self as object};
@@ -18,12 +19,13 @@ mod fuzzed;
 
 mod version {
     mod v1 {
+        use crate::Result;
         use gix_pack::index;
 
         use crate::{INDEX_V1, fixture_path};
 
         #[test]
-        fn lookup() -> Result<(), Box<dyn std::error::Error>> {
+        fn lookup() -> Result {
             let object_hash = gix_hash::Kind::Sha1;
             let file = index::File::at(fixture_path(INDEX_V1), object_hash)?;
             for (id, desired_index, assertion) in &[
@@ -62,12 +64,13 @@ mod version {
     }
 
     mod v2 {
+        use crate::Result;
         use gix_pack::index;
 
         use crate::{INDEX_V2, fixture_path};
 
         #[test]
-        fn lookup() -> Result<(), Box<dyn std::error::Error>> {
+        fn lookup() -> Result {
             let object_hash = gix_hash::Kind::Sha1;
             let file = index::File::at(fixture_path(INDEX_V2), object_hash)?;
             for (id, expected, assertion_message, hex_len) in [
@@ -116,6 +119,7 @@ mod version {
 
     #[cfg(feature = "parallel")]
     mod any {
+        use crate::Result;
         use std::{fs, io, sync::atomic::AtomicBool};
 
         use gix_features::progress;
@@ -129,13 +133,13 @@ mod version {
         }
 
         #[test]
-        fn write_to_stream() -> Result<(), Box<dyn std::error::Error>> {
+        fn write_to_stream() -> Result {
             fn assert_index_write(
                 mode: &input::Mode,
                 compressed: &input::EntryDataMode,
                 index_path: &&str,
                 data_path: &&str,
-            ) -> Result<(), Box<dyn std::error::Error>> {
+            ) -> Result {
                 let mut pack_iter = pack::data::input::BytesToEntriesIter::new_from_header(
                     io::BufReader::new(fs::File::open(fixture_path(data_path))?),
                     *mode,
@@ -229,7 +233,7 @@ mod version {
         }
 
         #[test]
-        fn write_to_stream_respects_alloc_limit_bytes() -> Result<(), Box<dyn std::error::Error>> {
+        fn write_to_stream_respects_alloc_limit_bytes() -> Result {
             let data_path = SMALL_PACK;
             let mut pack_iter = pack::data::input::BytesToEntriesIter::new_from_header(
                 io::BufReader::new(fs::File::open(fixture_path(data_path))?),
@@ -258,10 +262,7 @@ mod version {
             )
             .expect_err("a zero allocation limit rejects non-empty delta-tree storage");
 
-            assert!(
-                crate::error_chain_contains_message(&err, "The pack delta tree is too large to fit in memory"),
-                "index writing must apply the allocation limit to delta-tree storage"
-            );
+            insta::assert_debug_snapshot!(err, "index writing must apply the allocation limit to delta-tree storage", @"The pack delta tree is too large to fit in memory");
             Ok(())
         }
 
@@ -292,7 +293,7 @@ fn traverse_with_index_and_forward_ref_deltas() {
             &data,
             |_, _, _, _| {
                 count.fetch_add(1, Ordering::SeqCst);
-                Ok::<_, std::io::Error>(())
+                Ok::<_, gix_error::Exn>(())
             },
             &mut progress::Discard,
             &AtomicBool::new(false),
@@ -303,14 +304,14 @@ fn traverse_with_index_and_forward_ref_deltas() {
 }
 
 #[test]
-fn traverse_with_index_respects_alloc_limit_bytes() -> Result<(), Box<dyn std::error::Error>> {
+fn traverse_with_index_respects_alloc_limit_bytes() -> Result {
     let index = index::File::at(fixture_path(SMALL_PACK_INDEX), gix_hash::Kind::Sha1)?;
     let data = pack::data::File::at(fixture_path(SMALL_PACK), gix_hash::Kind::Sha1)?;
 
     let prevent_allocation = Some(0);
     let err = match index.traverse_with_index(
         &data,
-        |_, _, _, _| Ok::<_, std::io::Error>(()),
+        |_, _, _, _| Ok::<_, gix_error::Exn>(()),
         &mut progress::Discard,
         &AtomicBool::new(false),
         index::traverse::with_index::Options {
@@ -323,10 +324,7 @@ fn traverse_with_index_respects_alloc_limit_bytes() -> Result<(), Box<dyn std::e
         Err(err) => err,
     };
 
-    assert!(
-        crate::error_chain_contains_message(&err, "Entry too large to fit in memory"),
-        "traverse_with_index must pass its allocation limit to delta-tree traversal"
-    );
+    insta::assert_debug_snapshot!(err, "traverse_with_index must pass its allocation limit to delta-tree traversal", @"Entry too large to fit in memory");
     Ok(())
 }
 
@@ -354,7 +352,7 @@ fn from_memory_backing_supports_verification_and_traversal() {
             &data,
             |_, _, _, _| {
                 count.fetch_add(1, Ordering::SeqCst);
-                Ok::<_, std::io::Error>(())
+                Ok::<_, gix_error::Exn>(())
             },
             &mut progress::Discard,
             &AtomicBool::new(false),
@@ -382,7 +380,7 @@ static MODES: &[index::verify::Mode] = &[
 ];
 
 #[test]
-fn pack_lookup() -> Result<(), Box<dyn std::error::Error>> {
+fn pack_lookup() -> Result {
     for (index_path, pack_path, stats) in &[
         (
             INDEX_V2,
@@ -550,7 +548,8 @@ fn pack_lookup() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 #[test]
-fn verify_integrity_respects_pack_alloc_limit_bytes() -> Result<(), Box<dyn std::error::Error>> {
+fn verify_integrity_respects_pack_alloc_limit_bytes() -> Result {
+    let mut errors = Vec::new();
     let prevent_allocation = Some(0);
     let idx = index::File::at(fixture_path(SMALL_PACK_INDEX), gix_hash::Kind::Sha1)?;
     let pack = pack::data::File::at(fixture_path(SMALL_PACK), gix_hash::Kind::Sha1)?
@@ -576,18 +575,27 @@ fn verify_integrity_respects_pack_alloc_limit_bytes() -> Result<(), Box<dyn std:
             Err(err) => err,
         };
 
-        assert!(
-            crate::error_chain_contains_message(&err, "Entry too large to fit in memory"),
-            "{traversal:?}: verify_integrity() must obtain the allocation limit from the pack data file, even for \
-             DeltaTreeLookup where decoded objects are resolved by delta-tree traversal instead of regular pack \
-             lookups"
-        );
+        errors.push((traversal, err));
     }
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(errors), &[]), "both traversal algorithms respect the pack's decoded-object allocation limit", @"
+    [
+        (
+            Lookup,
+            Object Oid(1) at offset 12 could not be decoded
+            |
+            └─ Entry too large to fit in memory,
+        ),
+        (
+            DeltaTreeLookup,
+            Entry too large to fit in memory,
+        ),
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn iter() -> Result<(), Box<dyn std::error::Error>> {
+fn iter() -> Result {
     for (path, kind, num_objects, index_checksum, pack_checksum) in [
         (
             INDEX_V1,
diff --git a/gix-pack/tests/pack/iter.rs b/gix-pack/tests/pack/iter.rs
index cea09477767..c858168eb3f 100644
--- a/gix-pack/tests/pack/iter.rs
+++ b/gix-pack/tests/pack/iter.rs
@@ -14,6 +14,7 @@ fn size_of_entry() {
 }
 
 mod new_from_header {
+    use crate::Result;
     use std::fs;
 
     use gix_odb::{
@@ -24,7 +25,7 @@ mod new_from_header {
     use crate::{SMALL_PACK, V2_PACKS_AND_INDICES, fixture_path};
 
     #[test]
-    fn header_encode() -> Result<(), Box<dyn std::error::Error>> {
+    fn header_encode() -> Result {
         for (_, data_file) in V2_PACKS_AND_INDICES {
             let data = fs::read(fixture_path(data_file))?;
             for entry in pack::data::input::BytesToEntriesIter::new_from_header(
@@ -55,7 +56,7 @@ mod new_from_header {
     }
 
     #[test]
-    fn generic_iteration() -> Result<(), Box<dyn std::error::Error>> {
+    fn generic_iteration() -> Result {
         for compression_mode in &[
             EntryDataMode::Ignore,
             EntryDataMode::Keep,
@@ -103,7 +104,7 @@ mod new_from_header {
     }
 
     #[test]
-    fn version_3_is_accepted() -> Result<(), Box<dyn std::error::Error>> {
+    fn version_3_is_accepted() -> Result {
         let mut data = fs::read(fixture_path(SMALL_PACK))?;
         data[4..8].copy_from_slice(&3u32.to_be_bytes());
 
@@ -119,7 +120,7 @@ mod new_from_header {
             "Git accepts pack version 3 with the version 2 entry layout"
         );
         assert_eq!(
-            iter.collect::<Result<Vec<_>, _>>()?.len(),
+            iter.collect::<std::result::Result<Vec<_>, _>>()?.len(),
             42,
             "all entries should be readable"
         );
@@ -127,7 +128,7 @@ mod new_from_header {
     }
 
     #[test]
-    fn restore_missing_trailer() -> Result<(), Box<dyn std::error::Error>> {
+    fn restore_missing_trailer() -> Result {
         let pack = fs::read(fixture_path(SMALL_PACK))?;
         let mut iter = pack::data::input::BytesToEntriesIter::new_from_header(
             std::io::BufReader::new(&pack[..pack.len() - 20]),
@@ -146,7 +147,7 @@ mod new_from_header {
     }
 
     #[test]
-    fn restore_partial_pack() -> Result<(), Box<dyn std::error::Error>> {
+    fn restore_partial_pack() -> Result {
         let pack = fs::read(fixture_path(SMALL_PACK))?;
         let mut iter = pack::data::input::BytesToEntriesIter::new_from_header(
             std::io::BufReader::new(&pack[..pack.len() / 2]),
diff --git a/gix-pack/tests/pack/main.rs b/gix-pack/tests/pack/main.rs
index 43fbc553f65..cdcd505aea4 100644
--- a/gix-pack/tests/pack/main.rs
+++ b/gix-pack/tests/pack/main.rs
@@ -34,18 +34,6 @@ pub fn hex_to_id_for_hash(object_hash: gix_hash::Kind, sha1: &str, sha256: &str)
     })
 }
 
-pub(crate) fn error_chain_contains_message(mut err: &(dyn std::error::Error + 'static), message: &str) -> bool {
-    loop {
-        if err.to_string() == message {
-            return true;
-        }
-        match err.source() {
-            Some(source) => err = source,
-            None => return false,
-        }
-    }
-}
-
 /// Read fixture data into memory and intentionally leak it to obtain a `'static` byte slice.
 ///
 /// This is acceptable in tests because the fixtures are small, loaded only for the duration of the
diff --git a/gix-pack/tests/pack/malformed.rs b/gix-pack/tests/pack/malformed.rs
index 15c5841290d..0fcdd8dde63 100644
--- a/gix-pack/tests/pack/malformed.rs
+++ b/gix-pack/tests/pack/malformed.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{
     io::Write,
     panic::{AssertUnwindSafe, catch_unwind},
@@ -12,7 +13,7 @@ const FIRST_ENTRY_OFFSET: data::Offset = data::header::SIZE as data::Offset;
 /// `gix_pack::data::File::decode_entry()` and panic while slicing the base object instead of
 /// returning an error for attacker-controlled pack data.
 #[test]
-fn delta_copy_is_reported_without_panicking() -> crate::Result {
+fn delta_copy_is_reported_without_panicking() -> Result {
     let pack_data = ref_delta_pack(&[1, 2, 0x90, 0x02])?;
     let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
     let entry = pack.entry(FIRST_ENTRY_OFFSET)?;
@@ -37,7 +38,7 @@ fn delta_copy_is_reported_without_panicking() -> crate::Result {
 /// instead of rejecting the attacker-controlled size header.
 #[test]
 #[cfg(target_pointer_width = "64")]
-fn oversized_delta_result_is_rejected_without_panicking() -> crate::Result {
+fn oversized_delta_result_is_rejected_without_panicking() -> Result {
     let mut delta = encode_delta_size(1);
     delta.extend(encode_delta_size(isize::MAX as u64 + 1));
 
@@ -63,7 +64,7 @@ fn oversized_delta_result_is_rejected_without_panicking() -> crate::Result {
 /// A delta entry can declare more decompressed bytes than zlib actually produces. Header parsing
 /// must only inspect the produced bytes, not the zero-filled remainder of the output buffer.
 #[test]
-fn truncated_delta_header_ignores_zero_filled_remainder() -> crate::Result {
+fn truncated_delta_header_ignores_zero_filled_remainder() -> Result {
     let pack_data = ref_delta_pack_with_declared_size(&[1, 0x80], 3)?;
     let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
     let entry = pack.entry(FIRST_ENTRY_OFFSET)?;
@@ -80,7 +81,7 @@ fn truncated_delta_header_ignores_zero_filled_remainder() -> crate::Result {
 }
 
 #[test]
-fn complete_delta_with_mismatched_declared_size_is_rejected() -> crate::Result {
+fn complete_delta_with_mismatched_declared_size_is_rejected() -> Result {
     for (name, delta, decompressed_size) in [
         ("shorter", &[1, 1, 0x90, 1][..], 5),
         ("longer", &[1, 1, 0x90, 1, 0][..], 4),
@@ -102,7 +103,8 @@ fn complete_delta_with_mismatched_declared_size_is_rejected() -> crate::Result {
 }
 
 #[test]
-fn plain_object_with_mismatched_declared_size_is_rejected() -> crate::Result {
+fn plain_object_with_mismatched_declared_size_is_rejected() -> Result {
+    let mut diagnostics = Vec::new();
     for (blob, decompressed_size) in [(b"A".as_slice(), 2), (b"AB".as_slice(), 1)] {
         let pack_data = blob_pack_with_declared_size(blob, decompressed_size)?;
         let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
@@ -112,16 +114,19 @@ fn plain_object_with_mismatched_declared_size_is_rejected() -> crate::Result {
 
         let res = pack.decode_entry(entry, &mut out, &mut inflate, &resolve_external_blob, &mut cache::Never);
 
-        assert_err_message(
-            res,
-            "Pack entry is truncated: pack entry decompressed size does not match entry header",
-        );
+        diagnostics.push(res.expect_err("malformed pack data must be rejected"));
     }
+    insta::assert_debug_snapshot!(diagnostics, "plain object with mismatched declared size is rejected", @"
+    [
+        Pack entry is truncated: pack entry decompressed size does not match entry header,
+        Pack entry is truncated: pack entry decompressed size does not match entry header,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn empty_plain_object_is_accepted() -> crate::Result {
+fn empty_plain_object_is_accepted() -> Result {
     let pack_data = blob_pack_with_declared_size(b"", 0)?;
     let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
     let entry = pack.entry(FIRST_ENTRY_OFFSET)?;
@@ -137,7 +142,7 @@ fn empty_plain_object_is_accepted() -> crate::Result {
 }
 
 #[test]
-fn delta_with_mismatched_base_size_is_rejected_before_allocating_work_buffers() -> crate::Result {
+fn delta_with_mismatched_base_size_is_rejected_before_allocating_work_buffers() -> Result {
     let declared_base_size = 1_000_000;
     let mut delta = encode_delta_size(declared_base_size);
     delta.extend([1, 0x90, 1]);
@@ -149,10 +154,7 @@ fn delta_with_mismatched_base_size_is_rejected_before_allocating_work_buffers()
 
     let res = pack.decode_entry(entry, &mut out, &mut inflate, &resolve_external_blob, &mut cache::Never);
 
-    assert_err_message(
-        res,
-        "Corrupt delta data: delta base size does not match base object size",
-    );
+    insta::assert_debug_snapshot!(res.expect_err("malformed pack data must be rejected"), "delta with mismatched base size is rejected before allocating work buffers", @"Corrupt delta data: delta base size does not match base object size");
     assert!(
         out.capacity() < declared_base_size as usize,
         "the invalid declared base size must not determine work-buffer capacity"
@@ -161,7 +163,7 @@ fn delta_with_mismatched_base_size_is_rejected_before_allocating_work_buffers()
 }
 
 #[test]
-fn in_pack_delta_base_with_mismatched_declared_size_is_rejected() -> crate::Result {
+fn in_pack_delta_base_with_mismatched_declared_size_is_rejected() -> Result {
     let (pack_data, delta_offset) = ofs_delta_pack_with_mismatched_base_size()?;
     let pack = data::File::from_data(
         pack_data.as_slice(),
@@ -174,15 +176,12 @@ fn in_pack_delta_base_with_mismatched_declared_size_is_rejected() -> crate::Resu
 
     let res = pack.decode_entry(entry, &mut out, &mut inflate, &resolve_external_blob, &mut cache::Never);
 
-    assert_err_message(
-        res,
-        "Corrupt delta data: delta base size does not match base object size",
-    );
+    insta::assert_debug_snapshot!(res.expect_err("malformed pack data must be rejected"), "in pack delta base with mismatched declared size is rejected", @"Corrupt delta data: delta base size does not match base object size");
     Ok(())
 }
 
 #[test]
-fn decode_header_ignores_zero_filled_delta_remainder() -> crate::Result {
+fn decode_header_ignores_zero_filled_delta_remainder() -> Result {
     let pack_data = ref_delta_pack_with_declared_size(&[1, 0x80], 3)?;
     let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
     let entry = pack.entry(FIRST_ENTRY_OFFSET)?;
@@ -190,27 +189,14 @@ fn decode_header_ignores_zero_filled_delta_remainder() -> crate::Result {
 
     let res = pack.decode_header(entry, &mut inflate, &resolve_external_header_blob);
 
-    assert_err_message(
-        res,
-        "Pack entry is truncated: pack entry decompressed to fewer bytes than declared in the entry header",
-    );
+    insta::assert_debug_snapshot!(res.expect_err("malformed pack data must be rejected"), "decode header ignores zero filled delta remainder", @"Pack entry is truncated: pack entry decompressed to fewer bytes than declared in the entry header");
     Ok(())
 }
 
 #[test]
-fn decode_header_with_mismatched_declared_delta_size_is_rejected() -> crate::Result {
-    for (delta, decompressed_size, message) in [
-        (
-            &[1, 1, 0x90, 1][..],
-            5,
-            "Pack entry is truncated: pack entry decompressed to fewer bytes than declared in the entry header",
-        ),
-        (
-            &[1, 1, 0x90, 1, 0][..],
-            4,
-            "Pack entry is truncated: pack entry decompressed to more bytes than declared in the entry header",
-        ),
-    ] {
+fn decode_header_with_mismatched_declared_delta_size_is_rejected() -> Result {
+    let mut diagnostics = Vec::new();
+    for (delta, decompressed_size) in [(&[1, 1, 0x90, 1][..], 5), (&[1, 1, 0x90, 1, 0][..], 4)] {
         let pack_data = ref_delta_pack_with_declared_size(delta, decompressed_size)?;
         let pack = data::File::from_data(pack_data, PathBuf::from("malformed.pack"), gix_hash::Kind::Sha1)?;
         let entry = pack.entry(FIRST_ENTRY_OFFSET)?;
@@ -218,13 +204,20 @@ fn decode_header_with_mismatched_declared_delta_size_is_rejected() -> crate::Res
 
         let res = pack.decode_header(entry, &mut inflate, &resolve_external_header_blob);
 
-        assert_err_message(res, message);
+        diagnostics.push(res.expect_err("malformed pack data must be rejected"));
     }
+    insta::assert_debug_snapshot!(diagnostics, "decode header with mismatched declared delta size is rejected", @"
+    [
+        Pack entry is truncated: pack entry decompressed to fewer bytes than declared in the entry header,
+        Pack entry is truncated: pack entry decompressed to more bytes than declared in the entry header,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn large_mismatched_declared_delta_size_is_rejected_during_full_decode() -> crate::Result {
+fn large_mismatched_declared_delta_size_is_rejected_during_full_decode() -> Result {
+    let mut diagnostics = Vec::new();
     for (delta_len, decompressed_size) in [(33, 34), (34, 33)] {
         let delta = padded_delta(delta_len);
         let pack_data = ref_delta_pack_with_declared_size(&delta, decompressed_size)?;
@@ -239,24 +232,17 @@ fn large_mismatched_declared_delta_size_is_rejected_during_full_decode() -> crat
         let mut out = Vec::new();
         let res = pack.decode_entry(entry, &mut out, &mut inflate, &resolve_external_blob, &mut cache::Never);
 
-        assert_err_message(
-            res,
-            "Pack entry is truncated: pack entry decompressed size does not match entry header",
-        );
+        diagnostics.push(res.expect_err("malformed pack data must be rejected"));
     }
+    insta::assert_debug_snapshot!(diagnostics, "large mismatched declared delta size is rejected during full decode", @"
+    [
+        Pack entry is truncated: pack entry decompressed size does not match entry header,
+        Pack entry is truncated: pack entry decompressed size does not match entry header,
+    ]
+    ");
     Ok(())
 }
 
-fn assert_err_message<T, E>(res: Result<T, E>, expected: &str)
-where
-    E: std::fmt::Debug + std::fmt::Display,
-{
-    match res {
-        Ok(_) => panic!("operation should fail"),
-        Err(err) => assert_eq!(err.to_string(), expected),
-    }
-}
-
 fn padded_delta(len: usize) -> Vec<u8> {
     let mut delta = vec![1, 1, 0x90, 1];
     delta.resize(len, 0);
@@ -279,7 +265,7 @@ fn encode_delta_size(mut size: u64) -> Vec<u8> {
     out
 }
 
-fn deflate(bytes: &[u8]) -> crate::Result<Vec<u8>> {
+fn deflate(bytes: &[u8]) -> Result<Vec<u8>> {
     let mut write = gix_zlib::stream::deflate::Write::new(Vec::new(), gix_zlib::Compression::BEST_SPEED);
     write.write_all(bytes)?;
     write.flush()?;
@@ -291,7 +277,7 @@ fn deflate(bytes: &[u8]) -> crate::Result<Vec<u8>> {
 ///
 /// This creates malformed plain-object fixtures that exercise the same header-vs-stream size
 /// validation as delta fixtures, but without involving base-object resolution or delta parsing.
-fn blob_pack_with_declared_size(blob: &[u8], decompressed_size: u64) -> crate::Result<Vec<u8>> {
+fn blob_pack_with_declared_size(blob: &[u8], decompressed_size: u64) -> Result<Vec<u8>> {
     let mut pack = Vec::new();
     pack.extend_from_slice(&data::header::encode(data::Version::V2, 1));
     data::entry::Header::Blob.write_to(decompressed_size, &mut pack)?;
@@ -306,7 +292,7 @@ fn blob_pack_with_declared_size(blob: &[u8], decompressed_size: u64) -> crate::R
 /// The delta itself declares a base size of one byte, so this fixture verifies that decoding uses
 /// the in-pack base entry's declared size when allocating the base buffer and rejects the base
 /// stream mismatch instead of slicing past the buffer.
-fn ofs_delta_pack_with_mismatched_base_size() -> crate::Result<(Vec<u8>, data::Offset)> {
+fn ofs_delta_pack_with_mismatched_base_size() -> Result<(Vec<u8>, data::Offset)> {
     let mut pack = Vec::new();
     pack.extend_from_slice(&data::header::encode(data::Version::V2, 2));
 
@@ -325,7 +311,7 @@ fn ofs_delta_pack_with_mismatched_base_size() -> crate::Result<(Vec<u8>, data::O
     Ok((pack, delta_offset))
 }
 
-fn ref_delta_pack(delta: &[u8]) -> crate::Result<Vec<u8>> {
+fn ref_delta_pack(delta: &[u8]) -> Result<Vec<u8>> {
     ref_delta_pack_with_declared_size(delta, delta.len() as u64)
 }
 
@@ -336,7 +322,7 @@ fn ref_delta_pack(delta: &[u8]) -> crate::Result<Vec<u8>> {
 /// produces, leaving zero-filled slack in the caller's output buffer, or it may promise fewer
 /// bytes than the stream actually contains. The dedicated helper keeps those tests explicit,
 /// while `ref_delta_pack()` remains the shorthand for internally consistent fixtures.
-fn ref_delta_pack_with_declared_size(delta: &[u8], decompressed_size: u64) -> crate::Result<Vec<u8>> {
+fn ref_delta_pack_with_declared_size(delta: &[u8], decompressed_size: u64) -> Result<Vec<u8>> {
     let mut pack = Vec::new();
     pack.extend_from_slice(&data::header::encode(data::Version::V2, 1));
     data::entry::Header::RefDelta {
diff --git a/gix-pack/tests/pack/multi_index/fuzzed.rs b/gix-pack/tests/pack/multi_index/fuzzed.rs
index f52e5d9333c..857df586cdf 100644
--- a/gix-pack/tests/pack/multi_index/fuzzed.rs
+++ b/gix-pack/tests/pack/multi_index/fuzzed.rs
@@ -37,9 +37,9 @@ fn malformed_fanout_is_reported_without_panicking() {
 }
 
 /// Reproducer for the allocation-limit fuzz case: long user-controlled pack names in the `PNAM`
-/// chunk must be rejected as `OutOfMemory` when they exceed the configured allocation limit.
+/// chunk must be rejected as resource exhaustion when they exceed the configured allocation limit.
 #[test]
-fn long_pack_names_over_alloc_limit_bytes_are_rejected_as_out_of_memory() {
+fn long_pack_names_over_alloc_limit_bytes_are_resource_exhaustion() {
     let long_name = format!("{}.idx", "a".repeat(65));
     let index = gix_pack::multi_index::File::from_data(
         valid_multi_index_with_index_name(long_name.as_bytes()),
@@ -50,38 +50,41 @@ fn long_pack_names_over_alloc_limit_bytes_are_rejected_as_out_of_memory() {
 
     assert_eq!(index.index_names(), [PathBuf::from(&long_name)]);
 
-    assert!(
-        matches!(
-            gix_pack::multi_index::File::from_data(
-                valid_multi_index_with_index_name(long_name.as_bytes()),
-                PathBuf::from("fuzzed-long-name.midx"),
-                Some(0)
-            ),
-            Err(gix_pack::multi_index::init::Error::PackNames(
-                gix_pack::multi_index::chunk::index_names::decode::Error::OutOfMemory
-            ))
-        ),
-        "multi-index pack names larger than the configured limit must be rejected, including with a zero limit"
+    let err = gix_pack::multi_index::File::from_data(
+        valid_multi_index_with_index_name(long_name.as_bytes()),
+        PathBuf::from("fuzzed-long-name.midx"),
+        Some(0),
+    )
+    .err()
+    .expect("multi-index pack names larger than a zero allocation limit must be rejected");
+    assert_eq!(
+        err.classify().find_map(|classification| match classification.class() {
+            gix_error::Class::ResourceExhaustion(kind) => Some(kind),
+            _ => None,
+        }),
+        Some(gix_error::ResourceExhaustionKind::AllocationLimit),
+        "an application limit doesn't make otherwise valid input corrupt"
     );
+    insta::assert_debug_snapshot!(err, "the error explains the allocation-limit failure", @"Pack names require more memory than allowed");
+    assert!(!err.is_corrupted());
 }
 
 /// Reproducer for the fuzz target OOM case: the harness uses an allocation cap so attacker-controlled
 /// index counts must fail deterministically before reserving absurd `Vec<PathBuf>` capacities.
 #[test]
 fn absurd_pack_count_is_rejected_with_fuzz_alloc_limit() {
+    let err = gix_pack::multi_index::File::from_data(
+        multi_index_with_absurd_pack_count(),
+        PathBuf::from("fuzzed-absurd-pack-count.midx"),
+        Some(0),
+    )
+    .err()
+    .expect("an absurd pack count must be rejected under a zero allocation limit");
     assert!(
-        matches!(
-            gix_pack::multi_index::File::from_data(
-                multi_index_with_absurd_pack_count(),
-                PathBuf::from("fuzzed-absurd-pack-count.midx"),
-                Some(0)
-            ),
-            Err(gix_pack::multi_index::init::Error::PackNames(
-                gix_pack::multi_index::chunk::index_names::decode::Error::OutOfMemory
-            ))
-        ),
-        "multi-index files advertising absurd pack counts must be rejected under the allocation cap, including with a zero limit"
+        err.is_corrupted(),
+        "a pack count which cannot fit in the available name data is corrupt input"
     );
+    insta::assert_debug_snapshot!(err, "the error explains the structural failure", @"Pack count exceeds the available pack-name data");
 }
 
 fn malformed_multi_index_with_inconsistent_fanout() -> Vec<u8> {
diff --git a/gix-pack/tests/pack/multi_index/verify.rs b/gix-pack/tests/pack/multi_index/verify.rs
index 4aedca0e503..3280445127b 100644
--- a/gix-pack/tests/pack/multi_index/verify.rs
+++ b/gix-pack/tests/pack/multi_index/verify.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::sync::atomic::AtomicBool;
 
 use gix_features::progress;
@@ -6,7 +7,7 @@ use maplit::btreemap;
 use crate::{multi_index::multi_index, object_hash};
 
 #[test]
-fn checksum() -> crate::Result {
+fn checksum() -> Result {
     let (file, _) = multi_index(object_hash());
     assert_eq!(
         file.verify_checksum(&mut progress::Discard, &AtomicBool::new(false))?,
diff --git a/gix-pack/tests/pack/multi_index/write.rs b/gix-pack/tests/pack/multi_index/write.rs
index 5bac137a20a..5e11535553f 100644
--- a/gix-pack/tests/pack/multi_index/write.rs
+++ b/gix-pack/tests/pack/multi_index/write.rs
@@ -1,6 +1,7 @@
+use crate::Result;
 use std::{
     path::{Path, PathBuf},
-    sync::atomic::AtomicBool,
+    sync::atomic::{AtomicBool, Ordering},
 };
 
 use gix_features::progress;
@@ -9,7 +10,7 @@ use gix_testtools::fixture_path;
 /// Writes a multi-index from the static SHA-1 pack indices, with pinned SHA-1 expectations.
 /// The SHA-256 counterpart lives in [`from_a_hash_parameterized_pack`] below.
 #[test]
-fn from_paths() -> crate::Result {
+fn from_paths() -> Result {
     let pack_dir = fixture_path("objects/pack");
     let written = write_multi_index_from_pack_dir(&pack_dir, gix_hash::Kind::Sha1)?;
     assert_eq!(written.input_indices.len(), 3);
@@ -38,7 +39,7 @@ fn from_paths() -> crate::Result {
 /// Like [`from_paths`], but sources its input index from the hash-parameterized fixture so the
 /// writer runs under both SHA-1 and SHA-256. The fixture's gc leaves one pack, hence one index.
 #[test]
-fn from_a_hash_parameterized_pack() -> crate::Result {
+fn from_a_hash_parameterized_pack() -> Result {
     let object_hash = crate::object_hash();
     let pack_dir = crate::scripted_fixture_read_only("make_pack_gen_repo_multi_index.sh")?.join(".git/objects/pack");
     let written = write_multi_index_from_pack_dir(&pack_dir, object_hash)?;
@@ -57,6 +58,87 @@ fn from_a_hash_parameterized_pack() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn interrupted_before_writing() {
+    for index_paths in [Vec::new(), vec![fixture_path(crate::SMALL_PACK_INDEX)]] {
+        let mut out = Vec::new();
+        let err = gix_pack::multi_index::write_from_index_paths(
+            index_paths,
+            &mut out,
+            &mut progress::Discard,
+            &AtomicBool::new(true),
+            gix_pack::multi_index::write::Options {
+                object_hash: gix_hash::Kind::Sha1,
+            },
+        )
+        .err()
+        .expect("interruption stops both entry collection and deduplication");
+
+        assert_retryable_interruption(&err);
+        assert!(
+            out.is_empty(),
+            "interruption before writing leaves the output untouched"
+        );
+    }
+}
+
+#[test]
+fn interrupted_while_writing_chunks() {
+    struct InterruptOnWrite<'a>(&'a AtomicBool);
+
+    impl std::io::Write for InterruptOnWrite<'_> {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            self.0.store(true, Ordering::Relaxed);
+            Ok(buf.len())
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> {
+            Ok(())
+        }
+    }
+
+    let should_interrupt = AtomicBool::new(false);
+    let err = gix_pack::multi_index::write_from_index_paths(
+        vec![fixture_path(crate::SMALL_PACK_INDEX)],
+        &mut InterruptOnWrite(&should_interrupt),
+        &mut progress::Discard,
+        &should_interrupt,
+        gix_pack::multi_index::write::Options {
+            object_hash: gix_hash::Kind::Sha1,
+        },
+    )
+    .err()
+    .expect("interruption during output stops chunk writing");
+
+    assert_retryable_interruption(&err);
+}
+
+fn assert_retryable_interruption(err: &gix_error::Exn) {
+    assert!(
+        err.is_retryable(),
+        "interruption retains its explicit retry classification"
+    );
+    assert!(err.can_retry(), "interrupted multi-index writing can be retried");
+    insta::allow_duplicates! {
+        insta::assert_debug_snapshot!(err, "interruption reports one retryable diagnostic without synthetic causes", @"Interrupted");
+    }
+
+    let mut diagnostics = err.iter_errors();
+    let diagnostic = diagnostics
+        .next()
+        .and_then(|err| err.downcast_ref::<gix_error::Message>())
+        .expect("interruption is a visible Message diagnostic");
+    assert_eq!(
+        diagnostic.class,
+        Some(gix_error::Class::Retryable),
+        "the diagnostic itself carries the retry classification"
+    );
+    assert!(
+        diagnostics.next().is_none(),
+        "a standalone interruption has no extra causes"
+    );
+}
+
 struct WrittenMultiIndex {
     file: gix_pack::multi_index::File,
     dir: gix_testtools::tempfile::TempDir,
@@ -65,7 +147,7 @@ struct WrittenMultiIndex {
 }
 
 impl WrittenMultiIndex {
-    fn verify_integrity_with_referenced_packs(&self) -> crate::Result {
+    fn verify_integrity_with_referenced_packs(&self) -> Result {
         // Place the referenced pack and index next to the multi-index so integrity can resolve them.
         for ro_index in &self.input_indices {
             std::fs::copy(
@@ -100,7 +182,7 @@ impl WrittenMultiIndex {
     }
 }
 
-fn write_multi_index_from_pack_dir(pack_dir: &Path, object_hash: gix_hash::Kind) -> crate::Result<WrittenMultiIndex> {
+fn write_multi_index_from_pack_dir(pack_dir: &Path, object_hash: gix_hash::Kind) -> Result<WrittenMultiIndex> {
     let input_indices = std::fs::read_dir(pack_dir)?
         .filter_map(|r| {
             let idx_path = r.ok()?.path();
diff --git a/gix-packetline/Cargo.toml b/gix-packetline/Cargo.toml
index 10c62030223..f93f24ab3f4 100644
--- a/gix-packetline/Cargo.toml
+++ b/gix-packetline/Cargo.toml
@@ -40,9 +40,9 @@ required-features = ["blocking-io"]
 
 [dependencies]
 gix-trace = { version = "^0.1.21", path = "../gix-trace" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
-thiserror = "2.0.18"
 faster-hex = { version = "0.10.1", default-features = false, features = ["std"] }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 # async support
@@ -53,6 +53,8 @@ pin-project-lite = { version = "0.2.6", optional = true }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
 gix-odb = { path = "../gix-odb" }
 gix-pack-for-configuration = { package = "gix-pack", path = "../gix-pack", default-features = false, features = ["streaming-input"] }
 gix-hash = { path = "../gix-hash", features = ["sha1"] }
diff --git a/gix-packetline/src/async_io/encode.rs b/gix-packetline/src/async_io/encode.rs
index 7a452c04729..434b9ac2b76 100644
--- a/gix-packetline/src/async_io/encode.rs
+++ b/gix-packetline/src/async_io/encode.rs
@@ -9,8 +9,7 @@ use futures_lite::AsyncWriteExt;
 
 use crate::{
     BandRef, Channel, DELIMITER_LINE, ERR_PREFIX, ErrorRef, FLUSH_LINE, MAX_DATA_LEN, PacketLineRef, RESPONSE_END_LINE,
-    TextRef,
-    encode::{Error, u16_to_hex},
+    TextRef, encode::u16_to_hex,
 };
 
 pin_project_lite::pin_project! {
@@ -59,13 +58,13 @@ impl<W: AsyncWrite + Unpin> AsyncWrite for LineWriter<'_, W> {
                 State::Idle => {
                     let data_len = this.prefix.len() + data.len() + this.suffix.len();
                     if data_len > MAX_DATA_LEN {
-                        let err = Error::DataLengthLimitExceeded {
-                            length_in_bytes: data_len,
-                        };
+                        let err = gix_error::validation(format!(
+                            "Cannot encode more than {MAX_DATA_LEN} bytes, got {data_len}"
+                        ));
                         return Poll::Ready(Err(io::Error::other(err)));
                     }
                     if data.is_empty() {
-                        let err = Error::DataIsEmpty;
+                        let err = gix_error::validation("Empty lines are invalid");
                         return Poll::Ready(Err(io::Error::other(err)));
                     }
                     let data_len = data_len + 4;
@@ -148,13 +147,11 @@ async fn prefixed_and_suffixed_data_to_write(
 ) -> io::Result<usize> {
     let data_len = prefix.len() + data.len() + suffix.len();
     if data_len > MAX_DATA_LEN {
-        let err = Error::DataLengthLimitExceeded {
-            length_in_bytes: data_len,
-        };
+        let err = gix_error::validation(format!("Cannot encode more than {MAX_DATA_LEN} bytes, got {data_len}"));
         return Err(io::Error::other(err));
     }
     if data.is_empty() {
-        let err = Error::DataIsEmpty;
+        let err = gix_error::validation("Empty lines are invalid");
         return Err(io::Error::other(err));
     }
 
diff --git a/gix-packetline/src/async_io/read.rs b/gix-packetline/src/async_io/read.rs
index 999f269c978..60b3f62ad49 100644
--- a/gix-packetline/src/async_io/read.rs
+++ b/gix-packetline/src/async_io/read.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     io,
     ops::{Deref, DerefMut},
@@ -35,14 +36,9 @@ where
         }
     }
 
-    async fn read_line_inner<'a>(
-        reader: &mut T,
-        buf: &'a mut [u8],
-    ) -> io::Result<Result<PacketLineRef<'a>, decode::Error>> {
+    async fn read_line_inner<'a>(reader: &mut T, buf: &'a mut [u8]) -> io::Result<ExnMessageResult<PacketLineRef<'a>>> {
         if buf.len() < U16_HEX_BYTES {
-            return Ok(Err(decode::Error::NotEnoughData {
-                bytes_needed: U16_HEX_BYTES - buf.len(),
-            }));
+            return Ok(Err(decode::not_enough_data(U16_HEX_BYTES - buf.len()).into()));
         }
         let (hex_bytes, data_bytes) = buf.split_at_mut(U16_HEX_BYTES);
         reader.read_exact(hex_bytes).await?;
@@ -52,9 +48,9 @@ where
             Err(err) => return Ok(Err(err)),
         };
         if num_data_bytes > data_bytes.len() {
-            return Ok(Err(decode::Error::DataLengthLimitExceeded {
-                length_in_bytes: num_data_bytes + U16_HEX_BYTES,
-            }));
+            return Ok(Err(
+                decode::data_length_limit_exceeded(num_data_bytes + U16_HEX_BYTES).into()
+            ));
         }
 
         let (data_bytes, _) = data_bytes.split_at_mut(num_data_bytes);
@@ -82,6 +78,7 @@ where
                 Ok(Ok(line)) => {
                     if trace {
                         match line {
+                            #[allow(unused_variables, reason = "Used when tracing is enabled at compile time.")]
                             PacketLineRef::Data(d) => {
                                 gix_trace::trace!("<< {}", d.as_bstr().trim().as_bstr());
                             }
@@ -134,7 +131,7 @@ where
     ///  * natural EOF
     ///  * ERR packet line encountered if [`fail_on_err_lines()`](StreamingPeekableIterState::fail_on_err_lines()) is true.
     ///  * A `delimiter` packet line encountered
-    pub async fn read_line(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, decode::Error>>> {
+    pub async fn read_line(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         let state = &mut self.state;
         if state.is_done {
             return None;
@@ -166,7 +163,7 @@ where
     /// was encountered.
     ///
     /// Multiple calls to peek will return the same packet line, if there is one.
-    pub async fn peek_line(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, decode::Error>>> {
+    pub async fn peek_line(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         let state = &mut self.state;
         if state.is_done {
             return None;
diff --git a/gix-packetline/src/async_io/sidebands.rs b/gix-packetline/src/async_io/sidebands.rs
index a6648c02afb..a148f6c4cd8 100644
--- a/gix-packetline/src/async_io/sidebands.rs
+++ b/gix-packetline/src/async_io/sidebands.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     future::Future,
     pin::Pin,
@@ -7,9 +8,9 @@ use std::{
 use futures_io::{AsyncBufRead, AsyncRead};
 
 use super::read::StreamingPeekableIter;
-use crate::{BandRef, PacketLineRef, TextRef, U16_HEX_BYTES, decode, read::ProgressAction};
+use crate::{BandRef, PacketLineRef, TextRef, U16_HEX_BYTES, read::ProgressAction};
 
-type ReadLineResult<'a> = Option<std::io::Result<Result<PacketLineRef<'a>, decode::Error>>>;
+type ReadLineResult<'a> = Option<std::io::Result<ExnMessageResult<PacketLineRef<'a>>>>;
 /// An implementor of [`AsyncBufRead`] yielding packet lines on each call to `read_line()`.
 /// It's also possible to hide the underlying packet lines using the [`Read`](AsyncRead) implementation which is useful
 /// if they represent binary data, like the one of a pack file.
@@ -134,7 +135,7 @@ where
     /// # Warning
     ///
     /// This skips all sideband handling and may return an unprocessed line with sidebands still contained in it.
-    pub async fn peek_data_line(&mut self) -> Option<std::io::Result<Result<&[u8], decode::Error>>> {
+    pub async fn peek_data_line(&mut self) -> Option<std::io::Result<ExnMessageResult<&[u8]>>> {
         match self.state {
             State::Idle { ref mut parent } => match parent
                 .as_mut()
@@ -161,7 +162,7 @@ where
     /// # Warning
     ///
     /// This skips all sideband handling and may return an unprocessed line with sidebands still contained in it.
-    pub async fn read_data_line(&mut self) -> Option<std::io::Result<Result<PacketLineRef<'_>, decode::Error>>> {
+    pub async fn read_data_line(&mut self) -> Option<std::io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         match &mut self.state {
             State::Idle { parent: Some(parent) } => {
                 assert_eq!(
diff --git a/gix-packetline/src/blocking_io/encode.rs b/gix-packetline/src/blocking_io/encode.rs
index 72485d82fe9..270b274f1d0 100644
--- a/gix-packetline/src/blocking_io/encode.rs
+++ b/gix-packetline/src/blocking_io/encode.rs
@@ -2,8 +2,7 @@ use std::io;
 
 use crate::{
     BandRef, Channel, DELIMITER_LINE, ERR_PREFIX, ErrorRef, FLUSH_LINE, MAX_DATA_LEN, PacketLineRef, RESPONSE_END_LINE,
-    TextRef,
-    encode::{Error, u16_to_hex},
+    TextRef, encode::u16_to_hex,
 };
 
 /// Write a response-end message to `out`.
@@ -86,12 +85,12 @@ fn prefixed_and_suffixed_data_to_write(
 ) -> io::Result<usize> {
     let data_len = prefix.len() + data.len() + suffix.len();
     if data_len > MAX_DATA_LEN {
-        return Err(io::Error::other(Error::DataLengthLimitExceeded {
-            length_in_bytes: data_len,
-        }));
+        return Err(io::Error::other(gix_error::validation(format!(
+            "Cannot encode more than {MAX_DATA_LEN} bytes, got {data_len}"
+        ))));
     }
     if data.is_empty() {
-        return Err(io::Error::other(Error::DataIsEmpty));
+        return Err(io::Error::other(gix_error::validation("Empty lines are invalid")));
     }
 
     let data_len = data_len + 4;
diff --git a/gix-packetline/src/blocking_io/read.rs b/gix-packetline/src/blocking_io/read.rs
index 9806656e942..a41a8a1b0bb 100644
--- a/gix-packetline/src/blocking_io/read.rs
+++ b/gix-packetline/src/blocking_io/read.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     io,
     ops::{Deref, DerefMut},
@@ -33,11 +34,9 @@ where
         }
     }
 
-    fn read_line_inner<'a>(reader: &mut T, buf: &'a mut [u8]) -> io::Result<Result<PacketLineRef<'a>, decode::Error>> {
+    fn read_line_inner<'a>(reader: &mut T, buf: &'a mut [u8]) -> io::Result<ExnMessageResult<PacketLineRef<'a>>> {
         if buf.len() < U16_HEX_BYTES {
-            return Ok(Err(decode::Error::NotEnoughData {
-                bytes_needed: U16_HEX_BYTES - buf.len(),
-            }));
+            return Ok(Err(decode::not_enough_data(U16_HEX_BYTES - buf.len()).into()));
         }
         let (hex_bytes, data_bytes) = buf.split_at_mut(U16_HEX_BYTES);
         reader.read_exact(hex_bytes)?;
@@ -47,9 +46,9 @@ where
             Err(err) => return Ok(Err(err)),
         };
         if num_data_bytes > data_bytes.len() {
-            return Ok(Err(decode::Error::DataLengthLimitExceeded {
-                length_in_bytes: num_data_bytes + U16_HEX_BYTES,
-            }));
+            return Ok(Err(
+                decode::data_length_limit_exceeded(num_data_bytes + U16_HEX_BYTES).into()
+            ));
         }
 
         let (data_bytes, _) = data_bytes.split_at_mut(num_data_bytes);
@@ -131,7 +130,7 @@ where
     ///  * natural EOF
     ///  * ERR packet line encountered if [`fail_on_err_lines()`](StreamingPeekableIterState::fail_on_err_lines()) is true.
     ///  * A `delimiter` packet line encountered
-    pub fn read_line(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, decode::Error>>> {
+    pub fn read_line(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         let state = &mut self.state;
         if state.is_done {
             return None;
@@ -162,7 +161,7 @@ where
     /// was encountered.
     ///
     /// Multiple calls to peek will return the same packet line, if there is one.
-    pub fn peek_line(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, decode::Error>>> {
+    pub fn peek_line(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         let state = &mut self.state;
         if state.is_done {
             return None;
diff --git a/gix-packetline/src/blocking_io/sidebands.rs b/gix-packetline/src/blocking_io/sidebands.rs
index a96b56a2661..8a0037be75d 100644
--- a/gix-packetline/src/blocking_io/sidebands.rs
+++ b/gix-packetline/src/blocking_io/sidebands.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{io, io::BufRead};
 
 use super::read::StreamingPeekableIter;
@@ -89,7 +90,7 @@ where
     /// # Warning
     ///
     /// This skips all sideband handling and may return an unprocessed line with sidebands still contained in it.
-    pub fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], crate::decode::Error>>> {
+    pub fn peek_data_line(&mut self) -> Option<io::Result<ExnMessageResult<&[u8]>>> {
         match self.parent.peek_line() {
             Some(Ok(Ok(PacketLineRef::Data(line)))) => Some(Ok(Ok(line))),
             Some(Ok(Err(err))) => Some(Ok(Err(err))),
@@ -103,7 +104,7 @@ where
     /// # Warning
     ///
     /// This skips all sideband handling and may return an unprocessed line with sidebands still contained in it.
-    pub fn read_data_line(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, crate::decode::Error>>> {
+    pub fn read_data_line(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         assert_eq!(
             self.cap, 0,
             "we don't support partial buffers right now - read-line must be used consistently"
diff --git a/gix-packetline/src/decode.rs b/gix-packetline/src/decode.rs
index d3c2530ef62..48e537dcbb9 100644
--- a/gix-packetline/src/decode.rs
+++ b/gix-packetline/src/decode.rs
@@ -1,38 +1,16 @@
-use bstr::BString;
-
 use crate::{DELIMITER_LINE, FLUSH_LINE, MAX_DATA_LEN, MAX_LINE_LEN, PacketLineRef, RESPONSE_END_LINE, U16_HEX_BYTES};
+use gix_error::ExnMessageResult;
 
-/// The error used in the [`decode`][mod@crate::decode] module
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to decode the first four hex bytes indicating the line length: {err}")]
-    HexDecode { err: String },
-    #[error(
+pub(crate) fn data_length_limit_exceeded(length_in_bytes: usize) -> gix_error::Message {
+    gix_error::validation(format!(
         "The data received claims to be larger than the maximum allowed size: got {length_in_bytes}, exceeds {MAX_DATA_LEN}"
-    )]
-    DataLengthLimitExceeded { length_in_bytes: usize },
-    #[error("Received an invalid empty line")]
-    DataIsEmpty,
-    #[error("Received an invalid line of length 3")]
-    InvalidLineLength,
-    #[error("{data:?} - consumed {bytes_consumed} bytes")]
-    Line { data: BString, bytes_consumed: usize },
-    #[error("Needing {bytes_needed} additional bytes to decode the line successfully")]
-    NotEnoughData { bytes_needed: usize },
+    ))
 }
 
-///
-pub mod band {
-    /// The error used in [`PacketLineRef::decode_band()`][super::PacketLineRef::decode_band()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("attempt to decode a non-side channel line or input was malformed: {band_id}")]
-        InvalidSideBand { band_id: u8 },
-        #[error("attempt to decode a non-data line into a side-channel band")]
-        NonDataLine,
-    }
+pub(crate) fn not_enough_data(bytes_needed: usize) -> gix_error::Message {
+    gix_error::validation(format!(
+        "Needing {bytes_needed} additional bytes to decode the line successfully"
+    ))
 }
 
 /// A utility return type to support incremental parsing of packet lines.
@@ -61,7 +39,7 @@ pub enum PacketLineOrWantedSize<'a> {
 }
 
 /// Decode the `four_bytes` packet line prefix provided in hexadecimal form and check it for validity.
-pub fn hex_prefix(four_bytes: &[u8]) -> Result<PacketLineOrWantedSize<'_>, Error> {
+pub fn hex_prefix(four_bytes: &[u8]) -> ExnMessageResult<PacketLineOrWantedSize<'_>> {
     debug_assert_eq!(four_bytes.len(), 4, "need four hex bytes");
     for (line_bytes, line_type) in &[
         (FLUSH_LINE, PacketLineRef::Flush),
@@ -74,14 +52,18 @@ pub fn hex_prefix(four_bytes: &[u8]) -> Result<PacketLineOrWantedSize<'_>, Error
     }
 
     let mut buf = [0u8; U16_HEX_BYTES / 2];
-    faster_hex::hex_decode(four_bytes, &mut buf).map_err(|err| Error::HexDecode { err: err.to_string() })?;
+    faster_hex::hex_decode(four_bytes, &mut buf).map_err(|err| {
+        gix_error::validation(format!(
+            "Failed to decode the first four hex bytes indicating the line length: {err}"
+        ))
+    })?;
     let wanted_bytes = u16::from_be_bytes(buf);
 
     if wanted_bytes == 3 {
-        return Err(Error::InvalidLineLength);
+        return Err(gix_error::validation("Received an invalid line of length 3").into());
     }
     if wanted_bytes == 4 {
-        return Err(Error::DataIsEmpty);
+        return Err(gix_error::validation("Received an invalid empty line").into());
     }
     debug_assert!(
         wanted_bytes as usize > U16_HEX_BYTES,
@@ -91,18 +73,16 @@ pub fn hex_prefix(four_bytes: &[u8]) -> Result<PacketLineOrWantedSize<'_>, Error
 }
 
 /// Obtain a `PacketLine` from `data` after assuring `data` is small enough to fit.
-pub fn to_data_line(data: &[u8]) -> Result<PacketLineRef<'_>, Error> {
+pub fn to_data_line(data: &[u8]) -> ExnMessageResult<PacketLineRef<'_>> {
     if data.len() > MAX_LINE_LEN {
-        return Err(Error::DataLengthLimitExceeded {
-            length_in_bytes: data.len(),
-        });
+        return Err(data_length_limit_exceeded(data.len()).into());
     }
 
     Ok(PacketLineRef::Data(data))
 }
 
 /// Decode `data` as packet line while reporting whether the data is complete or not using a [`Stream`].
-pub fn streaming(data: &[u8]) -> Result<Stream<'_>, Error> {
+pub fn streaming(data: &[u8]) -> ExnMessageResult<Stream<'_>> {
     let data_len = data.len();
     if data_len < U16_HEX_BYTES {
         return Ok(Stream::Incomplete {
@@ -119,9 +99,7 @@ pub fn streaming(data: &[u8]) -> Result<Stream<'_>, Error> {
         }
     } + U16_HEX_BYTES;
     if wanted_bytes > MAX_LINE_LEN {
-        return Err(Error::DataLengthLimitExceeded {
-            length_in_bytes: wanted_bytes,
-        });
+        return Err(data_length_limit_exceeded(wanted_bytes).into());
     }
     if data_len < wanted_bytes {
         return Ok(Stream::Incomplete {
@@ -139,9 +117,9 @@ pub fn streaming(data: &[u8]) -> Result<Stream<'_>, Error> {
 ///
 /// Note that failure also happens if there is not enough data to parse a complete packet line, as opposed to [`streaming()`] decoding
 /// succeeds in that case, stating how much more bytes are required.
-pub fn all_at_once(data: &[u8]) -> Result<PacketLineRef<'_>, Error> {
+pub fn all_at_once(data: &[u8]) -> ExnMessageResult<PacketLineRef<'_>> {
     match streaming(data)? {
         Stream::Complete { line, .. } => Ok(line),
-        Stream::Incomplete { bytes_needed } => Err(Error::NotEnoughData { bytes_needed }),
+        Stream::Incomplete { bytes_needed } => Err(not_enough_data(bytes_needed).into()),
     }
 }
diff --git a/gix-packetline/src/encode.rs b/gix-packetline/src/encode.rs
index eef8e172bab..fe575daef0c 100644
--- a/gix-packetline/src/encode.rs
+++ b/gix-packetline/src/encode.rs
@@ -1,15 +1,3 @@
-use super::MAX_DATA_LEN;
-
-/// The error returned by most functions in the [`encode`](crate::encode) module
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Cannot encode more than {MAX_DATA_LEN} bytes, got {length_in_bytes}")]
-    DataLengthLimitExceeded { length_in_bytes: usize },
-    #[error("Empty lines are invalid")]
-    DataIsEmpty,
-}
-
 pub(crate) fn u16_to_hex(value: u16) -> [u8; 4] {
     let mut buf = [0u8; 4];
     faster_hex::hex_encode(&value.to_be_bytes(), &mut buf).expect("two bytes to 4 hex chars never fails");
diff --git a/gix-packetline/src/lib.rs b/gix-packetline/src/lib.rs
index 5d601fc0794..f8af93b9e2b 100644
--- a/gix-packetline/src/lib.rs
+++ b/gix-packetline/src/lib.rs
@@ -4,7 +4,7 @@
 //!
 //! ```
 //! # #[cfg(feature = "blocking-io")]
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //! use std::io::Write;
 //!
 //! use gix_packetline::{
@@ -45,6 +45,7 @@
 #![deny(missing_docs, unsafe_code)]
 
 use bstr::BStr;
+use gix_error::ExnMessageResult;
 
 ///
 #[cfg(feature = "async-io")]
@@ -162,14 +163,23 @@ impl<'a> PacketLineRef<'a> {
     }
 
     /// Decode the band of this [`slice`](PacketLineRef::as_slice())
-    pub fn decode_band(&self) -> Result<BandRef<'a>, decode::band::Error> {
-        let d = self.as_slice().ok_or(decode::band::Error::NonDataLine)?;
-        let (&band_id, d) = d.split_first().ok_or(decode::band::Error::NonDataLine)?;
+    pub fn decode_band(&self) -> ExnMessageResult<BandRef<'a>> {
+        let d = self
+            .as_slice()
+            .ok_or_else(|| gix_error::validation("attempt to decode a non-data line into a side-channel band"))?;
+        let (&band_id, d) = d
+            .split_first()
+            .ok_or_else(|| gix_error::validation("attempt to decode a non-data line into a side-channel band"))?;
         Ok(match band_id {
             1 => BandRef::Data(d),
             2 => BandRef::Progress(d),
             3 => BandRef::Error(d),
-            band => return Err(decode::band::Error::InvalidSideBand { band_id: band }),
+            band => {
+                return Err(gix_error::validation(format!(
+                    "attempt to decode a non-side channel line or input was malformed: {band}"
+                ))
+                .into());
+            }
         })
     }
 }
diff --git a/gix-packetline/src/read.rs b/gix-packetline/src/read.rs
index e8ea4b1061e..8c92c27161b 100644
--- a/gix-packetline/src/read.rs
+++ b/gix-packetline/src/read.rs
@@ -1,6 +1,8 @@
 #[cfg(any(feature = "blocking-io", feature = "async-io"))]
 use crate::MAX_LINE_LEN;
 use crate::{PacketLineRef, U16_HEX_BYTES};
+#[cfg(any(feature = "blocking-io", feature = "async-io"))]
+use gix_error::ExnMessageResult;
 
 /// Allow the read-progress handler to determine how to continue.
 ///
@@ -10,9 +12,9 @@ pub type ProgressAction = std::ops::ControlFlow<()>;
 
 #[cfg(any(feature = "blocking-io", feature = "async-io"))]
 pub(crate) type ExhaustiveOutcome<'a> = (
-    bool,                                                                     // is_done
-    Option<PacketLineRef<'static>>,                                           // stopped_at
-    Option<std::io::Result<Result<PacketLineRef<'a>, crate::decode::Error>>>, // actual method result
+    bool,                                                         // is_done
+    Option<PacketLineRef<'static>>,                               // stopped_at
+    Option<std::io::Result<ExnMessageResult<PacketLineRef<'a>>>>, // actual method result
 );
 
 mod error {
diff --git a/gix-packetline/tests/packetline/decode.rs b/gix-packetline/tests/packetline/decode.rs
index af406d1cda8..9e81ddb4259 100644
--- a/gix-packetline/tests/packetline/decode.rs
+++ b/gix-packetline/tests/packetline/decode.rs
@@ -1,16 +1,15 @@
 mod streaming {
+    use gix_error::ExnMessageResult;
     use gix_packetline::{
         ErrorRef, PacketLineRef,
-        decode::{self, Stream, streaming},
+        decode::{Stream, streaming},
     };
 
-    use crate::assert_err_display;
-
     fn assert_complete(
-        res: Result<Stream, decode::Error>,
+        res: ExnMessageResult<Stream>,
         expected_consumed: usize,
         expected_value: PacketLineRef,
-    ) -> crate::Result {
+    ) -> ExnMessageResult {
         match res? {
             Stream::Complete { line, bytes_consumed } => {
                 assert_eq!(bytes_consumed, expected_consumed);
@@ -34,7 +33,7 @@ mod streaming {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-io", test)]
         #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-        async fn trailing_line_feeds_are_removed_explicitly() -> crate::Result {
+        async fn trailing_line_feeds_are_removed_explicitly() -> gix_error::TestResult {
             let line = decode::all_at_once(b"0006a\n")?;
             assert_eq!(line.as_text().expect("text").0.as_bstr(), b"a".as_bstr());
             let mut out = Vec::new();
@@ -48,7 +47,7 @@ mod streaming {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-io", test)]
         #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-        async fn all_kinds_of_packetlines() -> crate::Result {
+        async fn all_kinds_of_packetlines() -> gix_error::TestResult {
             for (line, bytes) in &[
                 (PacketLineRef::ResponseEnd, 4),
                 (PacketLineRef::Delimiter, 4),
@@ -65,7 +64,7 @@ mod streaming {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-io", test)]
         #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-        async fn error_line() -> crate::Result {
+        async fn error_line() -> gix_error::TestResult {
             let mut out = Vec::new();
             encode_io::write_error(
                 &PacketLineRef::Data(b"the error").as_error().expect("data line"),
@@ -80,7 +79,7 @@ mod streaming {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-io", test)]
         #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-        async fn side_bands() -> crate::Result {
+        async fn side_bands() -> gix_error::TestResult {
             for channel in &[Channel::Data, Channel::Error, Channel::Progress] {
                 let mut out = Vec::new();
                 let band = PacketLineRef::Data(b"band data")
@@ -98,39 +97,36 @@ mod streaming {
             let err = PacketLineRef::Data(b"")
                 .decode_band()
                 .expect_err("empty data cannot contain a sideband designator");
-            assert_eq!(
-                err.to_string(),
-                "attempt to decode a non-data line into a side-channel band",
-                "empty sideband data is reported as malformed input"
-            );
+            insta::assert_debug_snapshot!(err, "empty sideband data is reported as malformed input", @"attempt to decode a non-data line into a side-channel band");
         }
     }
 
     #[test]
-    fn flush() -> crate::Result {
-        assert_complete(streaming(b"0000someotherstuff"), 4, PacketLineRef::Flush)
+    fn flush() -> gix_error::TestResult {
+        assert_complete(streaming(b"0000someotherstuff"), 4, PacketLineRef::Flush)?;
+        Ok(())
     }
 
     #[test]
-    fn trailing_line_feeds_are_not_removed_automatically() -> crate::Result {
-        assert_complete(streaming(b"0006a\n"), 6, PacketLineRef::Data(b"a\n"))
+    fn trailing_line_feeds_are_not_removed_automatically() -> gix_error::TestResult {
+        assert_complete(streaming(b"0006a\n"), 6, PacketLineRef::Data(b"a\n"))?;
+        Ok(())
     }
 
     #[test]
-    fn ignore_extra_bytes() -> crate::Result {
-        assert_complete(streaming(b"0006a\nhello"), 6, PacketLineRef::Data(b"a\n"))
+    fn ignore_extra_bytes() -> gix_error::TestResult {
+        assert_complete(streaming(b"0006a\nhello"), 6, PacketLineRef::Data(b"a\n"))?;
+        Ok(())
     }
 
     #[test]
     fn error_on_oversized_line() {
-        assert_err_display(
-            streaming(b"ffff"),
-            "The data received claims to be larger than the maximum allowed size: got 65535, exceeds 65516",
-        );
+        let err = (streaming(b"ffff")).expect_err("the packet line is invalid");
+        insta::assert_debug_snapshot!(err, "error on oversized line", @"The data received claims to be larger than the maximum allowed size: got 65535, exceeds 65516");
     }
 
     #[test]
-    fn error_on_error_line() -> crate::Result {
+    fn error_on_error_line() -> gix_error::TestResult {
         let line = PacketLineRef::Data(b"ERR the error");
         assert_complete(
             streaming(b"0011ERR the error-and just ignored because not part of the size"),
@@ -146,21 +142,21 @@ mod streaming {
 
     #[test]
     fn error_on_invalid_hex() {
-        assert_err_display(
-            streaming(b"fooo"),
-            "Failed to decode the first four hex bytes indicating the line length: Invalid character",
-        );
+        let err = (streaming(b"fooo")).expect_err("the packet line is invalid");
+        insta::assert_debug_snapshot!(err, "error on invalid hex", @"Failed to decode the first four hex bytes indicating the line length: Invalid character");
     }
 
     #[test]
     fn error_on_empty_line() {
-        assert_err_display(streaming(b"0004"), "Received an invalid empty line");
+        let err = (streaming(b"0004")).expect_err("the packet line is invalid");
+        insta::assert_debug_snapshot!(err, "error on empty line", @"Received an invalid empty line");
     }
 
     mod incomplete {
-        use gix_packetline::decode::{self, Stream, streaming};
+        use gix_error::ExnMessageResult;
+        use gix_packetline::decode::{Stream, streaming};
 
-        fn assert_incomplete(res: Result<Stream, decode::Error>, expected_missing: usize) -> crate::Result {
+        fn assert_incomplete(res: ExnMessageResult<Stream>, expected_missing: usize) -> ExnMessageResult {
             match res? {
                 Stream::Complete { .. } => {
                     panic!("expected parsing to be partial, not complete");
@@ -173,14 +169,14 @@ mod streaming {
         }
 
         #[test]
-        fn missing_hex_bytes() -> crate::Result {
+        fn missing_hex_bytes() -> gix_error::TestResult {
             assert_incomplete(streaming(b"0"), 3)?;
             assert_incomplete(streaming(b"00"), 2)?;
             Ok(())
         }
 
         #[test]
-        fn missing_data_bytes() -> crate::Result {
+        fn missing_data_bytes() -> gix_error::TestResult {
             assert_incomplete(streaming(b"0005"), 1)?;
             assert_incomplete(streaming(b"0006a"), 1)?;
             Ok(())
diff --git a/gix-packetline/tests/packetline/encode.rs b/gix-packetline/tests/packetline/encode.rs
index 4b9d6ba460b..370406d45f5 100644
--- a/gix-packetline/tests/packetline/encode.rs
+++ b/gix-packetline/tests/packetline/encode.rs
@@ -6,7 +6,6 @@ mod data_to_write {
     #[cfg(all(feature = "async-io", not(feature = "blocking-io")))]
     use futures_lite::io;
 
-    use crate::assert_err_display;
     #[cfg(all(feature = "async-io", not(feature = "blocking-io")))]
     use gix_packetline::async_io::encode::data_to_write;
     #[cfg(feature = "blocking-io")]
@@ -15,7 +14,7 @@ mod data_to_write {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn binary_and_non_binary() -> crate::Result {
+    async fn binary_and_non_binary() -> gix_error::TestResult {
         let mut out = Vec::new();
         let res = data_to_write(b"\0", &mut out).await?;
         assert_eq!(res, 5);
@@ -38,14 +37,32 @@ mod data_to_write {
         }
 
         let res = data_to_write(&vec_sized(65516 + 1), io::sink()).await;
-        assert_err_display(res, "Cannot encode more than 65516 bytes, got 65517");
+        let err = (res).expect_err("the packet line is invalid");
+        insta::assert_debug_snapshot!(err, "error if data exceeds limit", @r#"
+        Custom {
+            kind: Other,
+            error: Message {
+                message: "Cannot encode more than 65516 bytes, got 65517",
+                class: Validation,
+            },
+        }
+        "#);
     }
 
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
     async fn error_if_data_is_empty() {
-        assert_err_display(data_to_write(&[], io::sink()).await, "Empty lines are invalid");
+        let err = (data_to_write(&[], io::sink()).await).expect_err("the packet line is invalid");
+        insta::assert_debug_snapshot!(err, "error if data is empty", @r#"
+        Custom {
+            kind: Other,
+            error: Message {
+                message: "Empty lines are invalid",
+                class: Validation,
+            },
+        }
+        "#);
     }
 }
 
@@ -59,7 +76,7 @@ mod text_to_write {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn always_appends_a_newline() -> crate::Result {
+    async fn always_appends_a_newline() -> gix_error::TestResult {
         let mut out = Vec::new();
         let res = text_to_write(b"a", &mut out).await?;
         assert_eq!(res, 6);
@@ -87,7 +104,7 @@ mod error {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn write_line() -> crate::Result {
+    async fn write_line() -> gix_error::TestResult {
         let mut out = Vec::new();
         let res = error_to_write(b"hello error", &mut out).await?;
         assert_eq!(res, 19);
@@ -106,7 +123,7 @@ mod flush_delim_response_end {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn success_flush_delim_response_end() -> crate::Result {
+    async fn success_flush_delim_response_end() -> gix_error::TestResult {
         let mut out = Vec::new();
         let res = flush_to_write(&mut out).await?;
         assert_eq!(res, 4);
diff --git a/gix-packetline/tests/packetline/main-async.rs b/gix-packetline/tests/packetline/main-async.rs
index 9f004fe5410..0cf2dbc2571 100644
--- a/gix-packetline/tests/packetline/main-async.rs
+++ b/gix-packetline/tests/packetline/main-async.rs
@@ -2,18 +2,6 @@ pub mod bisync {
     pub use gix_macros::{discard as only_sync, keep as bisync, keep as only_async};
 }
 
-pub type Result = std::result::Result<(), Box<dyn std::error::Error>>;
-
-pub fn assert_err_display<T: std::fmt::Debug, E: std::error::Error>(
-    res: std::result::Result<T, E>,
-    expected: impl AsRef<str>,
-) {
-    match res {
-        Ok(v) => panic!("Expected error '{}', got value {:?}", expected.as_ref(), v),
-        Err(err) => assert_eq!(err.to_string(), expected.as_ref()),
-    }
-}
-
 #[cfg(all(feature = "async-io", not(feature = "blocking-io")))]
 mod decode;
 #[cfg(all(feature = "async-io", not(feature = "blocking-io")))]
diff --git a/gix-packetline/tests/packetline/main-blocking.rs b/gix-packetline/tests/packetline/main-blocking.rs
index 3a98e202d86..62a16c87b72 100644
--- a/gix-packetline/tests/packetline/main-blocking.rs
+++ b/gix-packetline/tests/packetline/main-blocking.rs
@@ -2,18 +2,6 @@ pub mod bisync {
     pub use gix_macros::{discard as only_async, keep as only_sync, sync as bisync};
 }
 
-pub type Result = std::result::Result<(), Box<dyn std::error::Error>>;
-
-pub fn assert_err_display<T: std::fmt::Debug, E: std::error::Error>(
-    res: std::result::Result<T, E>,
-    expected: impl AsRef<str>,
-) {
-    match res {
-        Ok(v) => panic!("Expected error '{}', got value {:?}", expected.as_ref(), v),
-        Err(err) => assert_eq!(err.to_string(), expected.as_ref()),
-    }
-}
-
 #[cfg(feature = "blocking-io")]
 mod decode;
 #[cfg(feature = "blocking-io")]
diff --git a/gix-packetline/tests/packetline/read/mod.rs b/gix-packetline/tests/packetline/read/mod.rs
index 1d89e00a515..578c1b63cdf 100644
--- a/gix-packetline/tests/packetline/read/mod.rs
+++ b/gix-packetline/tests/packetline/read/mod.rs
@@ -25,7 +25,7 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn peek_follows_read_line_delimiter_logic() -> crate::Result {
+    async fn peek_follows_read_line_delimiter_logic() -> gix_error::TestResult {
         let mut rd = StreamingPeekableIter::new(&b"0005a00000005b"[..], &[PacketLineRef::Flush], false);
         let res = rd.peek_line().await;
         assert_eq!(res.expect("line")??, PacketLineRef::Data(b"a"));
@@ -53,18 +53,21 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn peek_follows_read_line_err_logic() -> crate::Result {
+    async fn peek_follows_read_line_err_logic() -> gix_error::TestResult {
         let mut rd = StreamingPeekableIter::new(&b"0005a0009ERR e0000"[..], &[PacketLineRef::Flush], false);
         rd.fail_on_err_lines(true);
         let res = rd.peek_line().await;
         assert_eq!(res.expect("line")??, PacketLineRef::Data(b"a"));
         rd.read_line().await;
         let res = rd.peek_line().await;
-        assert_eq!(
-            res.expect("line").unwrap_err().to_string(),
-            "e",
-            "io errors are used to communicate remote errors when peeking"
-        );
+        insta::assert_debug_snapshot!(res.expect("line").expect_err("io errors are used to communicate remote errors when peeking"), "io errors are used to communicate remote errors when peeking", @r#"
+        Custom {
+            kind: Other,
+            error: Error {
+                message: "e",
+            },
+        }
+        "#);
         let res = rd.peek_line().await;
         assert!(res.is_none(), "we are still done, no way around it");
         assert_eq!(rd.stopped_at(), None, "we stopped not because of a delimiter");
@@ -82,7 +85,7 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn peek_eof_is_none() -> crate::Result {
+    async fn peek_eof_is_none() -> gix_error::TestResult {
         let mut rd = StreamingPeekableIter::new(&b"0005a0009ERR e0000"[..], &[PacketLineRef::Flush], false);
         rd.fail_on_err_lines(false);
         let res = rd.peek_line().await;
@@ -105,7 +108,8 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn peek_non_data() -> crate::Result {
+    async fn peek_non_data() -> gix_error::TestResult {
+        let mut inline_error_diagnostics = Vec::new();
         let mut rd = StreamingPeekableIter::new(&b"000000010002"[..], &[PacketLineRef::ResponseEnd], false);
         let res = rd.read_line().await;
         assert_eq!(res.expect("line")??, PacketLineRef::Flush);
@@ -116,8 +120,10 @@ pub mod streaming_peek_iter {
         assert_eq!(res.expect("line")??, PacketLineRef::ResponseEnd);
         for _ in 0..2 {
             let res = rd.peek_line().await;
+            let err = res.expect("error").expect_err("the operation must fail");
+            inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
             assert_eq!(
-                res.expect("error").unwrap_err().kind(),
+                err.kind(),
                 std::io::ErrorKind::UnexpectedEof,
                 "peeks on error/eof repeat the error"
             );
@@ -127,13 +133,38 @@ pub mod streaming_peek_iter {
             None,
             "The reader is configured to ignore ResponseEnd, and thus hits the end of stream"
         );
+        if cfg!(feature = "blocking-io") {
+            insta::assert_debug_snapshot!(inline_error_diagnostics, "peek non data", @r#"
+            [
+                Error {
+                    kind: UnexpectedEof,
+                    message: "failed to fill whole buffer",
+                },
+                Error {
+                    kind: UnexpectedEof,
+                    message: "failed to fill whole buffer",
+                },
+            ]
+            "#);
+        } else {
+            insta::assert_debug_snapshot!(inline_error_diagnostics, "peek non data", @"
+            [
+                Kind(
+                    UnexpectedEof,
+                ),
+                Kind(
+                    UnexpectedEof,
+                ),
+            ]
+            ");
+        }
         Ok(())
     }
 
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn fail_on_err_lines() -> crate::Result {
+    async fn fail_on_err_lines() -> gix_error::TestResult {
         let input = b"00010009ERR e0002";
         let mut rd = StreamingPeekableIter::new(&input[..], &[], false);
         let res = rd.read_line().await;
@@ -150,11 +181,14 @@ pub mod streaming_peek_iter {
         let res = rd.read_line().await;
         assert_eq!(res.expect("line")??, PacketLineRef::Delimiter);
         let res = rd.read_line().await;
-        assert_eq!(
-            res.expect("line").unwrap_err().to_string(),
-            "e",
-            "io errors are used to communicate remote errors"
-        );
+        insta::assert_debug_snapshot!(res.expect("line").expect_err("io errors are used to communicate remote errors"), "io errors are used to communicate remote errors", @r#"
+        Custom {
+            kind: Other,
+            error: Error {
+                message: "e",
+            },
+        }
+        "#);
         let res = rd.read_line().await;
         assert!(res.is_none(), "iteration is done after the first error");
 
@@ -173,7 +207,7 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn oversized_packet_lengths_are_reported_instead_of_panicking() -> crate::Result {
+    async fn oversized_packet_lengths_are_reported_instead_of_panicking() -> gix_error::TestResult {
         let mut rd = StreamingPeekableIter::new(&b"ffff\n"[..], &[], false);
         let err = rd
             .read_line()
@@ -181,17 +215,14 @@ pub mod streaming_peek_iter {
             .expect("a decode error instead of EOF")
             .expect("no IO error expected")
             .expect_err("decode should fail for oversized lengths");
-        assert!(matches!(
-            err,
-            gix_packetline::decode::Error::DataLengthLimitExceeded { length_in_bytes: 65535 }
-        ));
+        insta::assert_debug_snapshot!(err, "oversized packet lengths are reported instead of panicking", @"The data received claims to be larger than the maximum allowed size: got 65535, exceeds 65516");
         Ok(())
     }
 
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn peek() -> crate::Result {
+    async fn peek() -> gix_error::TestResult {
         let bytes = fixture_bytes("v1/fetch/01-many-refs.response");
         let mut rd = StreamingPeekableIter::new(&bytes[..], &[PacketLineRef::Flush], false);
         let res = rd.peek_line().await;
@@ -229,7 +260,7 @@ pub mod streaming_peek_iter {
     #[crate::bisync::bisync]
     #[cfg_attr(feature = "blocking-io", test)]
     #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-    async fn read_from_file_and_reader_advancement() -> crate::Result {
+    async fn read_from_file_and_reader_advancement() -> gix_error::TestResult {
         let mut bytes = fixture_bytes("v1/fetch/01-many-refs.response");
         bytes.extend(fixture_bytes("v1/fetch/01-many-refs.response"));
         let mut rd = StreamingPeekableIter::new(&bytes[..], &[PacketLineRef::Flush], false);
@@ -247,8 +278,23 @@ pub mod streaming_peek_iter {
         // this reset is will cause actual io::Errors to occur
         rd.reset();
         let res = rd.read_line().await;
+        let err = res.expect("some error").expect_err("the operation must fail");
+        if cfg!(feature = "blocking-io") {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "trying to keep reading from exhausted input results in Some() containing the original error", @r#"
+            Error {
+                kind: UnexpectedEof,
+                message: "failed to fill whole buffer",
+            }
+            "#);
+        } else {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "trying to keep reading from exhausted input results in Some() containing the original error", @"
+            Kind(
+                UnexpectedEof,
+            )
+            ");
+        }
         assert_eq!(
-            res.expect("some error").unwrap_err().kind(),
+            err.kind(),
             io::ErrorKind::UnexpectedEof,
             "trying to keep reading from exhausted input results in Some() containing the original error"
         );
diff --git a/gix-packetline/tests/packetline/read/sideband.rs b/gix-packetline/tests/packetline/read/sideband.rs
index c472eb54bd0..04edd4a5ab5 100644
--- a/gix-packetline/tests/packetline/read/sideband.rs
+++ b/gix-packetline/tests/packetline/read/sideband.rs
@@ -42,7 +42,7 @@ mod util {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn read_pack_with_progress_extraction() -> crate::Result {
+async fn read_pack_with_progress_extraction() -> gix_error::TestResult {
     let buf = fixture_bytes("v1/01-clone.combined-output");
     let mut rd = StreamingPeekableIter::new(&buf[..], &[PacketLineRef::Flush], false);
 
@@ -105,7 +105,7 @@ async fn read_pack_with_progress_extraction() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn read_line_trait_method_reads_one_packet_line_at_a_time() -> crate::Result {
+async fn read_line_trait_method_reads_one_packet_line_at_a_time() -> gix_error::TestResult {
     let buf = fixture_bytes("v1/01-clone.combined-output-no-binary");
 
     let mut rd = StreamingPeekableIter::new(&buf[..], &[PacketLineRef::Flush], false);
@@ -156,7 +156,7 @@ async fn read_line_trait_method_reads_one_packet_line_at_a_time() -> crate::Resu
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn readline_reads_one_packet_line_at_a_time() -> crate::Result {
+async fn readline_reads_one_packet_line_at_a_time() -> gix_error::TestResult {
     let buf = fixture_bytes("v1/01-clone.combined-output-no-binary");
 
     let mut rd = StreamingPeekableIter::new(&buf[..], &[PacketLineRef::Flush], false);
@@ -207,7 +207,7 @@ async fn readline_reads_one_packet_line_at_a_time() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn empty_progress_and_error_sidebands_are_forwarded_without_panic() -> crate::Result {
+async fn empty_progress_and_error_sidebands_are_forwarded_without_panic() -> gix_error::TestResult {
     let input = b"0005\x020005\x030000";
     let mut rd = StreamingPeekableIter::new(&input[..], &[PacketLineRef::Flush], false);
     let mut seen = Vec::new();
@@ -233,7 +233,7 @@ async fn empty_progress_and_error_sidebands_are_forwarded_without_panic() -> cra
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn peek_past_an_actual_eof_is_an_error() -> crate::Result {
+async fn peek_past_an_actual_eof_is_an_error() -> gix_error::TestResult {
     let input = b"0009ERR e";
     let mut rd = StreamingPeekableIter::new(&input[..], &[], false);
     let mut reader = rd.as_read();
@@ -248,8 +248,23 @@ async fn peek_past_an_actual_eof_is_an_error() -> crate::Result {
     );
 
     let res = reader.peek_data_line().await;
+    let err = res.expect("an err").expect_err("foo");
+    if cfg!(feature = "blocking-io") {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "peeking past the end is not an error as the caller should make sure we don't try 'invalid' reads", @r#"
+        Error {
+            kind: UnexpectedEof,
+            message: "failed to fill whole buffer",
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "peeking past the end is not an error as the caller should make sure we don't try 'invalid' reads", @"
+        Kind(
+            UnexpectedEof,
+        )
+        ");
+    }
     assert_eq!(
-        res.expect("an err").expect_err("foo").kind(),
+        err.kind(),
         std::io::ErrorKind::UnexpectedEof,
         "peeking past the end is not an error as the caller should make sure we don't try 'invalid' reads"
     );
@@ -259,7 +274,7 @@ async fn peek_past_an_actual_eof_is_an_error() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn peek_past_a_delimiter_is_no_error() -> crate::Result {
+async fn peek_past_a_delimiter_is_no_error() -> gix_error::TestResult {
     let input = b"0009hello0000";
     let mut rd = StreamingPeekableIter::new(&input[..], &[PacketLineRef::Flush], false);
     let mut reader = rd.as_read();
@@ -289,15 +304,23 @@ async fn handling_of_err_lines() {
     let mut reader = rd.as_read();
     let res = reader.read(buf.as_mut()).await;
     let err = res.unwrap_err();
-    assert_eq!(err.to_string(), "e", "it respects errors and passes them on");
-    assert_eq!(
-        err.into_inner()
+    insta::assert_debug_snapshot!(err, "it respects errors and passes them on", @r#"
+    Custom {
+        kind: Other,
+        error: Error {
+            message: "e",
+        },
+    }
+    "#);
+    insta::assert_debug_snapshot!(err.into_inner()
             .expect("inner err")
             .downcast::<gix_packetline::read::Error>()
             .expect("it's this type")
-            .message,
-        "e",
-    );
+            , "handling of err lines", @r#"
+    Error {
+        message: "e",
+    }
+    "#);
     let res = reader.read(buf.as_mut()).await;
     assert_eq!(
         res.expect("read to succeed - EOF"),
@@ -306,11 +329,14 @@ async fn handling_of_err_lines() {
     );
     reader.reset_with(&[PacketLineRef::Flush]);
     let res = reader.read(buf.as_mut()).await;
-    assert_eq!(
-        res.unwrap_err().to_string(),
-        "x",
-        "after a reset it continues reading, but retains the 'fail_on_err_lines' setting"
-    );
+    insta::assert_debug_snapshot!(res.expect_err("after a reset it continues reading, but retains the 'fail_on_err_lines' setting"), "after a reset it continues reading, but retains the 'fail_on_err_lines' setting", @r#"
+    Custom {
+        kind: Other,
+        error: Error {
+            message: "x",
+        },
+    }
+    "#);
     assert_eq!(
         reader.stopped_at(),
         None,
diff --git a/gix-packetline/tests/packetline/write.rs b/gix-packetline/tests/packetline/write.rs
index caae2c908ae..c9e3bd42f63 100644
--- a/gix-packetline/tests/packetline/write.rs
+++ b/gix-packetline/tests/packetline/write.rs
@@ -16,7 +16,7 @@ const MAX_LINE_LEN: usize = 4 + MAX_DATA_LEN;
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn each_write_results_in_one_line() -> crate::Result {
+async fn each_write_results_in_one_line() -> gix_error::TestResult {
     let mut w = Writer::new(Vec::new());
     w.write_all(b"hello").await?;
     w.write(b"world!").await?;
@@ -29,7 +29,7 @@ async fn each_write_results_in_one_line() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn write_text_and_write_binary() -> crate::Result {
+async fn write_text_and_write_binary() -> gix_error::TestResult {
     let buf = {
         let mut w = Writer::new(Vec::new());
         w.enable_text_mode();
@@ -46,7 +46,7 @@ async fn write_text_and_write_binary() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-io", test)]
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
-async fn huge_writes_are_split_into_lines() -> crate::Result {
+async fn huge_writes_are_split_into_lines() -> gix_error::TestResult {
     let buf = {
         let data = vec![0u8; MAX_DATA_LEN * 2];
         let mut w = Writer::new(Vec::new());
@@ -62,8 +62,10 @@ async fn huge_writes_are_split_into_lines() -> crate::Result {
 #[cfg_attr(all(feature = "async-io", not(feature = "blocking-io")), async_std::test)]
 async fn empty_writes_fail_with_error() {
     let res = Writer::new(Vec::new()).write(&[]).await;
-    assert_eq!(
-        res.unwrap_err().to_string(),
-        "empty packet lines are not permitted as '0004' is invalid"
-    );
+    insta::assert_debug_snapshot!(res.expect_err("empty writes fail with error"), "empty writes fail with error", @r#"
+    Custom {
+        kind: Other,
+        error: "empty packet lines are not permitted as '0004' is invalid",
+    }
+    "#);
 }
diff --git a/gix-path/Cargo.toml b/gix-path/Cargo.toml
index e73aa958b48..25037271ba1 100644
--- a/gix-path/Cargo.toml
+++ b/gix-path/Cargo.toml
@@ -21,6 +21,8 @@ gix-validate = { version = "^0.11.4", path = "../gix-validate" }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
 serial_test = { version = "3.4.0", default-features = false }
 tempfile = "3.26.0"
 
diff --git a/gix-path/src/convert.rs b/gix-path/src/convert.rs
index ba2b9a37052..23134b454d2 100644
--- a/gix-path/src/convert.rs
+++ b/gix-path/src/convert.rs
@@ -4,18 +4,19 @@ use std::{
     path::{Component, Path, PathBuf},
 };
 
-use bstr::{BStr, BString};
+use gix_error::ExnMessageResult;
 
-/// The error type returned by [`into_bstr()`] and others may suffer from failed conversions from or to bytes.
-pub type Utf8Error = gix_error::ValidationError;
+use bstr::{BStr, BString};
+#[cfg(not(unix))]
+use gix_error::ResultExt;
 
 #[cfg(not(unix))]
-fn utf8_error() -> Utf8Error {
-    Utf8Error::new("Could not convert to UTF8 or from UTF8 due to ill-formed input")
+fn utf8_error() -> gix_error::Message {
+    gix_error::validation("Could not convert to UTF8 or from UTF8 due to ill-formed input")
 }
 
 /// Like [`into_bstr()`], but takes `OsStr` as input for a lossless, but fallible, conversion.
-pub fn os_str_into_bstr(path: &OsStr) -> Result<&BStr, Utf8Error> {
+pub fn os_str_into_bstr(path: &OsStr) -> ExnMessageResult<&BStr> {
     let path = try_into_bstr(Cow::Borrowed(path.as_ref()))?;
     match path {
         Cow::Borrowed(path) => Ok(path),
@@ -24,7 +25,7 @@ pub fn os_str_into_bstr(path: &OsStr) -> Result<&BStr, Utf8Error> {
 }
 
 /// Like [`into_bstr()`], but takes `OsString` as input for a lossless, but fallible, conversion.
-pub fn os_string_into_bstring(path: OsString) -> Result<BString, Utf8Error> {
+pub fn os_string_into_bstring(path: OsString) -> ExnMessageResult<BString> {
     let path = try_into_bstr(Cow::Owned(path.into()))?;
     match path {
         Cow::Borrowed(_path) => unreachable!("borrowed cows stay borrowed"),
@@ -33,7 +34,7 @@ pub fn os_string_into_bstring(path: OsString) -> Result<BString, Utf8Error> {
 }
 
 /// Like [`into_bstr()`], but takes `Cow<OsStr>` as input for a lossless, but fallible, conversion.
-pub fn try_os_str_into_bstr(path: Cow<'_, OsStr>) -> Result<Cow<'_, BStr>, Utf8Error> {
+pub fn try_os_str_into_bstr(path: Cow<'_, OsStr>) -> ExnMessageResult<Cow<'_, BStr>> {
     match path {
         Cow::Borrowed(path) => os_str_into_bstr(path).map(Cow::Borrowed),
         Cow::Owned(path) => os_string_into_bstring(path).map(Cow::Owned),
@@ -42,9 +43,9 @@ pub fn try_os_str_into_bstr(path: Cow<'_, OsStr>) -> Result<Cow<'_, BStr>, Utf8E
 
 /// Convert the given path either into its raw bytes on Unix or its UTF-8 encoded counterpart on non-Unix platforms.
 ///
-/// On non-Unix platforms, if the source `Path`` contains ill-formed, lone surrogates, the UTF-8 conversion will fail
-/// causing `Utf8Error` to be returned.
-pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, BStr>, Utf8Error> {
+/// On non-Unix platforms, if the source `Path` contains ill-formed, lone surrogates, the UTF-8 conversion will fail
+/// causing an [`Exn<Message>`](gix_error::Exn) with the encoding failure as its source to be returned.
+pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> ExnMessageResult<Cow<'a, BStr>> {
     let path = path.into();
     let path_str = match path {
         Cow::Owned(path) => Cow::Owned({
@@ -54,7 +55,9 @@ pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, BStr>
                 path.into_os_string().into_vec().into()
             };
             #[cfg(not(unix))]
-            let p: BString = path.into_os_string().into_string().map_err(|_| utf8_error())?.into();
+            let p: BString = String::from_utf8(path.into_os_string().into_encoded_bytes())
+                .or_raise(utf8_error)?
+                .into();
             p
         }),
         Cow::Borrowed(path) => Cow::Borrowed({
@@ -64,7 +67,10 @@ pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, BStr>
                 path.as_os_str().as_bytes().into()
             };
             #[cfg(not(unix))]
-            let p: &BStr = path.to_str().ok_or_else(utf8_error)?.as_bytes().into();
+            let p: &BStr = std::str::from_utf8(path.as_os_str().as_encoded_bytes())
+                .or_raise(utf8_error)?
+                .as_bytes()
+                .into();
             p
         }),
     };
@@ -91,19 +97,19 @@ pub fn join_bstr_unix_pathsep<'a, 'b>(base: impl Into<Cow<'a, BStr>>, path: impl
 /// On non-Unix platforms, the input is required to be valid UTF-8, which is guaranteed if we wrote it before.
 /// There are some potential Git versions and Windows installations which produce malformed UTF-16
 /// if certain emojis are in the path. It's as rare as it sounds, but possible.
-pub fn try_from_byte_slice(input: &[u8]) -> Result<&Path, Utf8Error> {
+pub fn try_from_byte_slice(input: &[u8]) -> ExnMessageResult<&Path> {
     #[cfg(unix)]
     let p = {
         use std::os::unix::ffi::OsStrExt;
         OsStr::from_bytes(input).as_ref()
     };
     #[cfg(not(unix))]
-    let p = Path::new(std::str::from_utf8(input).map_err(|_| utf8_error())?);
+    let p = Path::new(std::str::from_utf8(input).or_raise(utf8_error)?);
     Ok(p)
 }
 
 /// Similar to [`from_byte_slice()`], but takes either borrowed or owned `input`.
-pub fn try_from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Result<Cow<'a, Path>, Utf8Error> {
+pub fn try_from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> ExnMessageResult<Cow<'a, Path>> {
     let input = input.into();
     match input {
         Cow::Borrowed(input) => try_from_byte_slice(input).map(Cow::Borrowed),
@@ -117,7 +123,7 @@ pub fn from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Cow<'a, Path> {
 }
 
 /// Similar to [`try_from_bstr()`], but takes and produces owned data.
-pub fn try_from_bstring(input: impl Into<BString>) -> Result<PathBuf, Utf8Error> {
+pub fn try_from_bstring(input: impl Into<BString>) -> ExnMessageResult<PathBuf> {
     let input = input.into();
     #[cfg(unix)]
     let p = {
@@ -125,17 +131,7 @@ pub fn try_from_bstring(input: impl Into<BString>) -> Result<PathBuf, Utf8Error>
         std::ffi::OsString::from_vec(input.into()).into()
     };
     #[cfg(not(unix))]
-    let p = {
-        use bstr::ByteVec;
-        PathBuf::from(
-            {
-                let v: Vec<_> = input.into();
-                v
-            }
-            .into_string()
-            .map_err(|_| utf8_error())?,
-        )
-    };
+    let p = PathBuf::from(String::from_utf8(input.into()).or_raise(utf8_error)?);
     Ok(p)
 }
 
diff --git a/gix-path/src/realpath.rs b/gix-path/src/realpath.rs
index e1ac63c03e8..cb2b805a644 100644
--- a/gix-path/src/realpath.rs
+++ b/gix-path/src/realpath.rs
@@ -1,17 +1,13 @@
-/// The error returned by [`realpath()`][super::realpath()].
-pub type Error = gix_error::Exn;
-
 /// The default amount of symlinks we may follow when resolving a path in [`realpath()`][crate::realpath()].
 pub const MAX_SYMLINKS: u8 = 32;
 
 pub(crate) mod function {
-    use gix_error::{ErrorExt, ResultExt, ValidationError};
+    use gix_error::{ErrorExt, ExnResult, ResultExt};
     use std::path::{
         Component::{CurDir, Normal, ParentDir, Prefix, RootDir},
         Path, PathBuf,
     };
 
-    use super::Error;
     use crate::realpath::MAX_SYMLINKS;
 
     /// Check each component of `path` and see if it is a symlink. If so, resolve it.
@@ -20,7 +16,7 @@ pub(crate) mod function {
     /// If `path` is relative, the current working directory be used to make it absolute.
     /// Note that the returned path will be verbatim, and repositories with `core.precomposeUnicode`
     /// set will probably want to precompose the paths unicode.
-    pub fn realpath(path: impl AsRef<Path>) -> Result<PathBuf, Error> {
+    pub fn realpath(path: impl AsRef<Path>) -> ExnResult<PathBuf> {
         let path = path.as_ref();
         let cwd = path
             .is_relative()
@@ -32,9 +28,9 @@ pub(crate) mod function {
 
     /// The same as [`realpath()`], but allow to configure `max_symlinks` to configure how many symbolic links we are going to follow.
     /// This serves to avoid running into cycles or doing unreasonable amounts of work.
-    pub fn realpath_opts(path: &Path, cwd: &Path, max_symlinks: u8) -> Result<PathBuf, Error> {
+    pub fn realpath_opts(path: &Path, cwd: &Path, max_symlinks: u8) -> ExnResult<PathBuf> {
         if path.as_os_str().is_empty() {
-            return Err(ValidationError::new("Empty is not a valid path").raise_erased());
+            return Err(gix_error::validation("Empty is not a valid path").raise_erased());
         }
 
         let mut real_path = PathBuf::new();
@@ -53,7 +49,7 @@ pub(crate) mod function {
                 CurDir => {}
                 ParentDir => {
                     if !real_path.pop() {
-                        return Err(ValidationError::new(
+                        return Err(gix_error::validation(
                             "Ran out of path components while following parent component '..'",
                         )
                         .raise_erased());
@@ -65,7 +61,7 @@ pub(crate) mod function {
                     if real_path.is_symlink() {
                         num_symlinks += 1;
                         if num_symlinks > max_symlinks {
-                            return Err(ValidationError::new(format!(
+                            return Err(gix_error::validation(format!(
                                 "The maximum allowed number {max_symlinks} of symlinks in path is exceeded"
                             ))
                             .raise_erased());
@@ -81,7 +77,7 @@ pub(crate) mod function {
                         components = path_backing.components();
                     }
                     if symlink_checks > MAX_SYMLINK_CHECKS {
-                        return Err(ValidationError::new(format!(
+                        return Err(gix_error::validation(format!(
                             "Cannot resolve symlinks in path with more than {MAX_SYMLINK_CHECKS} components (takes too long)"
                         ))
                         .raise_erased());
diff --git a/gix-path/src/relative_path.rs b/gix-path/src/relative_path.rs
index c14f2e46f2f..c01ef39e987 100644
--- a/gix-path/src/relative_path.rs
+++ b/gix-path/src/relative_path.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use bstr::{BStr, BString, ByteSlice};
-use gix_error::{ErrorExt, ResultExt, ValidationError};
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt};
 use gix_validate::path::component::Options;
 
 use crate::{os_str_into_bstr, try_from_bstr, try_from_byte_slice};
@@ -13,6 +13,9 @@ pub(super) mod types {
     /// - The path separator always is `/`, independent of the platform.
     /// - Only normal components are allowed.
     /// - It is always represented as a bunch of bytes.
+    ///
+    /// Conversion errors for invalid components include the component bytes as `input`
+    /// [metadata](gix_error::Exn::metadata()).
     #[repr(transparent)]
     pub struct RelativePath {
         inner: BStr,
@@ -28,7 +31,7 @@ pub(super) mod types {
 use types::RelativePath;
 
 impl RelativePath {
-    fn new_unchecked(value: &BStr) -> Result<&RelativePath, Error> {
+    fn new_unchecked(value: &BStr) -> ExnMessageResult<&RelativePath> {
         // SAFETY: `RelativePath` is transparent and equivalent to a `&BStr` if provided as reference.
         #[expect(unsafe_code)]
         unsafe {
@@ -37,27 +40,25 @@ impl RelativePath {
     }
 }
 
-/// The error used in [`RelativePath`].
-pub type Error = gix_error::Exn<ValidationError>;
-
-fn relative_path_from_value_and_path<'a>(path_bstr: &'a BStr, path: &Path) -> Result<&'a RelativePath, Error> {
+fn relative_path_from_value_and_path<'a>(path_bstr: &'a BStr, path: &Path) -> ExnMessageResult<&'a RelativePath> {
     if path.is_absolute() {
-        return Err(ValidationError::new("A RelativePath is not allowed to be absolute").raise());
+        return Err(gix_error::validation("A RelativePath is not allowed to be absolute").raise());
     }
 
     let options = Options::default();
 
     for component in path.components() {
         let component = os_str_into_bstr(component.as_os_str())?;
-        gix_validate::path::component(component, None, options)
-            .or_raise(|| ValidationError::new_with_input("Relative path contains an invalid component", component))?;
+        gix_validate::path::component(component, None, options).or_raise(|| {
+            gix_error::validation("Relative path contains an invalid component").with("input", component)
+        })?;
     }
 
     RelativePath::new_unchecked(BStr::new(path_bstr.as_bytes()))
 }
 
 impl<'a> TryFrom<&'a str> for &'a RelativePath {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &'a str) -> Result<Self, Self::Error> {
         relative_path_from_value_and_path(value.into(), Path::new(value))
@@ -65,7 +66,7 @@ impl<'a> TryFrom<&'a str> for &'a RelativePath {
 }
 
 impl<'a> TryFrom<&'a BStr> for &'a RelativePath {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &'a BStr) -> Result<Self, Self::Error> {
         let path = try_from_bstr(value)?;
@@ -74,7 +75,7 @@ impl<'a> TryFrom<&'a BStr> for &'a RelativePath {
 }
 
 impl<'a> TryFrom<&'a [u8]> for &'a RelativePath {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     #[inline]
     fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
@@ -84,7 +85,7 @@ impl<'a> TryFrom<&'a [u8]> for &'a RelativePath {
 }
 
 impl<'a, const N: usize> TryFrom<&'a [u8; N]> for &'a RelativePath {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     #[inline]
     fn try_from(value: &'a [u8; N]) -> Result<Self, Self::Error> {
@@ -94,7 +95,7 @@ impl<'a, const N: usize> TryFrom<&'a [u8; N]> for &'a RelativePath {
 }
 
 impl<'a> TryFrom<&'a BString> for &'a RelativePath {
-    type Error = Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &'a BString) -> Result<Self, Self::Error> {
         let path = try_from_bstr(value.as_bstr())?;
diff --git a/gix-path/tests/path/convert/mod.rs b/gix-path/tests/path/convert/mod.rs
index 2fe7952a971..9b014b4fb6f 100644
--- a/gix-path/tests/path/convert/mod.rs
+++ b/gix-path/tests/path/convert/mod.rs
@@ -20,6 +20,45 @@ fn assure_windows_separators() {
 
 mod normalize;
 
+#[cfg(windows)]
+#[test]
+fn invalid_encodings_retain_their_sources() {
+    let mut error_snapshots = Vec::new();
+    use std::{ffi::OsString, os::windows::ffi::OsStringExt};
+
+    let path = OsString::from_wide(&[0xd800]);
+    for err in [
+        gix_path::os_str_into_bstr(&path).expect_err("a lone surrogate is not UTF-8"),
+        gix_path::os_string_into_bstring(path).expect_err("owned paths reject lone surrogates too"),
+        gix_path::try_from_byte_slice(b"\xff").expect_err("Windows paths require UTF-8"),
+        gix_path::try_from_bstring(b"\xff".as_bstr()).expect_err("owned Windows paths require UTF-8"),
+    ] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "invalid encodings remain validation errors");
+        assert!(
+            err.downcast_any_ref::<std::str::Utf8Error>().is_some()
+                || err.downcast_any_ref::<std::string::FromUtf8Error>().is_some(),
+            "both borrowed and owned conversions retain the concrete encoding failure"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "borrowed and owned conversions retain the malformed UTF-8 cause", @"
+    [
+        Could not convert to UTF8 or from UTF8 due to ill-formed input
+        |
+        └─ invalid utf-8 sequence of 1 bytes from index 0,
+        Could not convert to UTF8 or from UTF8 due to ill-formed input
+        |
+        └─ invalid utf-8 sequence of 1 bytes from index 0,
+        Could not convert to UTF8 or from UTF8 due to ill-formed input
+        |
+        └─ invalid utf-8 sequence of 1 bytes from index 0,
+        Could not convert to UTF8 or from UTF8 due to ill-formed input
+        |
+        └─ invalid utf-8 sequence of 1 bytes from index 0,
+    ]
+    ");
+}
+
 mod normalize_and_clean {
     use std::{borrow::Cow, path::Path};
 
diff --git a/gix-path/tests/path/convert/normalize.rs b/gix-path/tests/path/convert/normalize.rs
index 2ce82b0f08f..a5f2ff169ca 100644
--- a/gix-path/tests/path/convert/normalize.rs
+++ b/gix-path/tests/path/convert/normalize.rs
@@ -15,7 +15,7 @@ fn no_change_if_there_are_no_trailing_relative_components() {
 }
 
 #[test]
-fn special_cases_around_cwd() -> crate::Result {
+fn special_cases_around_cwd() -> gix_error::TestResult {
     let cwd = std::env::current_dir()?;
     assert_eq!(
         normalize(p("./../../.git/modules/src/llvm-project").into(), &cwd).unwrap(),
diff --git a/gix-path/tests/path/main.rs b/gix-path/tests/path/main.rs
index 956b5d5fe63..711c28b627b 100644
--- a/gix-path/tests/path/main.rs
+++ b/gix-path/tests/path/main.rs
@@ -1,5 +1,3 @@
-pub type Result<T = ()> = std::result::Result<T, gix_error::TestError>;
-
 mod convert;
 mod realpath;
 mod relative_path;
diff --git a/gix-path/tests/path/realpath.rs b/gix-path/tests/path/realpath.rs
index fa68ac16c4b..97b9a37cefd 100644
--- a/gix-path/tests/path/realpath.rs
+++ b/gix-path/tests/path/realpath.rs
@@ -3,45 +3,44 @@ use std::{
     time::Duration,
 };
 
+use gix_error::ExnResult;
+
 use bstr::ByteVec;
-use gix_path::{realpath::Error, realpath_opts};
+use gix_path::realpath_opts;
 
-fn assert_validation<T>(result: Result<T, Error>, expected_message: &str) {
+fn assert_validation<T>(result: ExnResult<T>) -> gix_error::Exn {
     let err = result.err().expect("input should be invalid");
-    let validation = err
-        .downcast_any_ref::<gix_error::ValidationError>()
-        .expect("error should be classified as validation");
-    assert_eq!(validation.message, expected_message);
+    assert!(err.is_validation(), "error should be classified as validation");
+    err
 }
 
 #[test]
-fn fuzzed_timeout() -> crate::Result {
+fn fuzzed_timeout() -> gix_error::TestResult {
     let path = PathBuf::from(std::fs::read("tests/fixtures/fuzzed/54k-path-components.path")?.into_string()?);
     assert_eq!(path.components().count(), 54862);
     let start = std::time::Instant::now();
-    assert_validation(
-        gix_path::realpath_opts(&path, Path::new("/cwd"), gix_path::realpath::MAX_SYMLINKS),
-        "Cannot resolve symlinks in path with more than 2048 components (takes too long)",
-    );
+    let err = assert_validation(gix_path::realpath_opts(
+        &path,
+        Path::new("/cwd"),
+        gix_path::realpath::MAX_SYMLINKS,
+    ));
     assert!(
         start.elapsed() < Duration::from_millis(if cfg!(windows) { 2000 } else { 1000 }),
         "took too long: {:.02} , we can't take too much time for this, and should keep the amount of work reasonable\
         as paths can be part of URls which sometimes are canonicalized",
         start.elapsed().as_secs_f32()
     );
+    insta::assert_debug_snapshot!(err, "excessive path components fail before expensive symlink resolution", @"Cannot resolve symlinks in path with more than 2048 components (takes too long)");
     Ok(())
 }
 
 #[test]
-fn assorted() -> crate::Result {
+fn assorted() -> gix_error::TestResult {
     let cwd = tempfile::tempdir()?;
     let cwd = cwd.path();
     let symlinks_disabled = 0;
 
-    assert_validation(
-        realpath_opts("".as_ref(), cwd, symlinks_disabled),
-        "Empty is not a valid path",
-    );
+    insta::assert_debug_snapshot!(assert_validation(realpath_opts("".as_ref(), cwd, symlinks_disabled)), "assorted", @"Empty is not a valid path");
 
     assert_eq!(
         realpath_opts("b/.git".as_ref(), cwd, symlinks_disabled)?,
@@ -89,7 +88,7 @@ fn assorted() -> crate::Result {
 }
 
 #[test]
-fn link_cycle_is_detected() -> crate::Result {
+fn link_cycle_is_detected() -> gix_error::TestResult {
     let tmp_dir = canonicalized_tempdir()?;
     let dir = tmp_dir.path();
     let link_name = "link";
@@ -98,15 +97,12 @@ fn link_cycle_is_detected() -> crate::Result {
     create_symlink(&link_path, link_destination)?;
     let max_symlinks = 8;
 
-    assert_validation(
-        realpath_opts(&link_path.join(".git"), "".as_ref(), max_symlinks),
-        "The maximum allowed number 8 of symlinks in path is exceeded",
-    );
+    insta::assert_debug_snapshot!(assert_validation(realpath_opts(&link_path.join(".git"), "".as_ref(), max_symlinks)), "link cycle is detected", @"The maximum allowed number 8 of symlinks in path is exceeded");
     Ok(())
 }
 
 #[test]
-fn symlink_with_absolute_path_gets_expanded() -> crate::Result {
+fn symlink_with_absolute_path_gets_expanded() -> gix_error::TestResult {
     let tmp_dir = canonicalized_tempdir()?;
     let dir = tmp_dir.path();
     let link_from = dir.join("a").join("b").join("tmp_p_q_link");
@@ -122,7 +118,7 @@ fn symlink_with_absolute_path_gets_expanded() -> crate::Result {
 }
 
 #[test]
-fn symlink_to_relative_path_gets_expanded_into_absolute_path() -> crate::Result {
+fn symlink_to_relative_path_gets_expanded_into_absolute_path() -> gix_error::TestResult {
     let cwd = canonicalized_tempdir()?;
     let dir = cwd.path();
     let link_name = "pq_link";
@@ -136,14 +132,11 @@ fn symlink_to_relative_path_gets_expanded_into_absolute_path() -> crate::Result
 }
 
 #[test]
-fn symlink_processing_is_disabled_if_the_value_is_zero() -> crate::Result {
+fn symlink_processing_is_disabled_if_the_value_is_zero() -> gix_error::TestResult {
     let cwd = canonicalized_tempdir()?;
     let link_name = "x_link";
     create_symlink(cwd.path().join(link_name), Path::new("link destination does not exist"))?;
-    assert_validation(
-        realpath_opts(&Path::new(link_name).join(".git"), cwd.path(), 0),
-        "The maximum allowed number 0 of symlinks in path is exceeded",
-    );
+    insta::assert_debug_snapshot!(assert_validation(realpath_opts(&Path::new(link_name).join(".git"), cwd.path(), 0)), "symlink processing is disabled if the value is zero", @"The maximum allowed number 0 of symlinks in path is exceeded");
     Ok(())
 }
 
diff --git a/gix-path/tests/path/relative_path.rs b/gix-path/tests/path/relative_path.rs
index f32360494de..8227dbea8c9 100644
--- a/gix-path/tests/path/relative_path.rs
+++ b/gix-path/tests/path/relative_path.rs
@@ -1,13 +1,14 @@
 use bstr::{BStr, BString};
-use gix_path::{RelativePath, relative_path::Error};
+use gix_error::ExnMessageResult;
+use gix_path::RelativePath;
 
-fn assert_validation<T>(result: Result<T, Error>, expected_message: &str, has_component_source: bool) {
+fn assert_validation<T>(result: ExnMessageResult<T>, has_component_source: bool) -> gix_error::Exn<gix_error::Message> {
     let err = result.err().expect("input should be invalid");
-    assert_eq!(err.message, expected_message);
     assert_eq!(
         err.downcast_any_ref::<gix_validate::path::component::Error>().is_some(),
         has_component_source
     );
+    err
 }
 
 #[cfg(not(windows))]
@@ -19,12 +20,11 @@ fn absolute_paths_return_err() {
     let path_u8: &[u8] = &b"/refs/heads"[..];
     let path_bstring: BString = "/refs/heads".into();
 
-    let message = "A RelativePath is not allowed to be absolute";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8a), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, false);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_str), false), "absolute paths return err", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), false), "absolute paths return err", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_u8), false), "absolute paths return err", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_u8a), false), "absolute paths return err", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), false), "absolute paths return err", @"A RelativePath is not allowed to be absolute");
 }
 
 #[cfg(windows)]
@@ -35,11 +35,10 @@ fn absolute_paths_with_backslashes_return_err() {
     let path_u8: &[u8] = &b"c:\\refs\\heads"[..];
     let path_bstring: BString = r"c:\refs\heads".into();
 
-    let message = "A RelativePath is not allowed to be absolute";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, false);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, false);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_str), false), "Windows absolute paths cannot be relative paths", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), false), "Windows absolute paths cannot be relative paths", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_u8), false), "Windows absolute paths cannot be relative paths", @"A RelativePath is not allowed to be absolute");
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), false), "Windows absolute paths cannot be relative paths", @"A RelativePath is not allowed to be absolute");
 }
 
 #[test]
@@ -49,25 +48,56 @@ fn dots_in_paths_return_err() {
     let path_u8: &[u8] = &b"./heads"[..];
     let path_bstring: BString = "./heads".into();
 
-    let message = "Relative path contains an invalid component";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, true);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_str), true), "dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"="."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), true), "dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"="."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_u8), true), "dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"="."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), true), "dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"="."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
 }
 
 #[test]
 fn dots_in_paths_with_backslashes_return_err() {
     let path_str: &str = r".\heads";
     let path_bstr: &BStr = path_str.into();
-    let path_u8: &[u8] = &b".\\heads"[..];
-    let path_bstring: BString = r".\heads".into();
+    let path_u8: &[u8] = path_str.as_bytes();
+    let path_bstring: BString = path_str.into();
 
-    let message = "Relative path contains an invalid component";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, true);
+    insta::allow_duplicates! {
+        for err in [
+            assert_validation(TryInto::<&RelativePath>::try_into(path_str), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(path_u8), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), true),
+        ] {
+            #[cfg(windows)]
+            insta::assert_debug_snapshot!(err, "Windows treats backslashes as separators", @r#"
+            Relative path contains an invalid component, "input"="."
+            |
+            └─ Relative components '.' and '..' are disallowed
+            "#);
+            #[cfg(not(windows))]
+            insta::assert_debug_snapshot!(err, "backslashes are rejected inside Unix path components", @r#"
+            Relative path contains an invalid component, "input"=".\\heads"
+            |
+            └─ Path separators like / or \ are not allowed
+            "#);
+        }
+    };
 }
 
 #[test]
@@ -77,23 +107,54 @@ fn double_dots_in_paths_return_err() {
     let path_u8: &[u8] = &b"../heads"[..];
     let path_bstring: BString = "../heads".into();
 
-    let message = "Relative path contains an invalid component";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, true);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_str), true), "double dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"=".."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), true), "double dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"=".."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(path_u8), true), "double dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"=".."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
+    insta::assert_debug_snapshot!(assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), true), "double dots in paths return err", @r#"
+    Relative path contains an invalid component, "input"=".."
+    |
+    └─ Relative components '.' and '..' are disallowed
+    "#);
 }
 
 #[test]
 fn double_dots_in_paths_with_backslashes_return_err() {
     let path_str: &str = r"..\heads";
     let path_bstr: &BStr = path_str.into();
-    let path_u8: &[u8] = &b"..\\heads"[..];
-    let path_bstring: BString = r"..\heads".into();
+    let path_u8: &[u8] = path_str.as_bytes();
+    let path_bstring: BString = path_str.into();
 
-    let message = "Relative path contains an invalid component";
-    assert_validation(TryInto::<&RelativePath>::try_into(path_str), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(path_u8), message, true);
-    assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), message, true);
+    insta::allow_duplicates! {
+        for err in [
+            assert_validation(TryInto::<&RelativePath>::try_into(path_str), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(path_bstr), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(path_u8), true),
+            assert_validation(TryInto::<&RelativePath>::try_into(&path_bstring), true),
+        ] {
+            #[cfg(windows)]
+            insta::assert_debug_snapshot!(err, "Windows treats backslashes as separators", @r#"
+            Relative path contains an invalid component, "input"=".."
+            |
+            └─ Relative components '.' and '..' are disallowed
+            "#);
+            #[cfg(not(windows))]
+            insta::assert_debug_snapshot!(err, "backslashes are rejected inside Unix path components", @r#"
+            Relative path contains an invalid component, "input"="..\\heads"
+            |
+            └─ Path separators like / or \ are not allowed
+            "#);
+        }
+    };
 }
diff --git a/gix-pathspec/Cargo.toml b/gix-pathspec/Cargo.toml
index 1466bb5021e..fdec026a082 100644
--- a/gix-pathspec/Cargo.toml
+++ b/gix-pathspec/Cargo.toml
@@ -23,11 +23,12 @@ gix-glob = { version = "^0.27.1", path = "../gix-glob" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-attributes = { version = "^0.35.0", path = "../gix-attributes" }
 gix-config-value = { version = "^0.19.1", path = "../gix-config-value" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 bitflags = "2"
-thiserror = "2.0.18"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 serial_test = "3.4.0"
diff --git a/gix-pathspec/fuzz/fuzz_targets/parse.rs b/gix-pathspec/fuzz/fuzz_targets/parse.rs
index af5a9f76810..3004c7eb531 100644
--- a/gix-pathspec/fuzz/fuzz_targets/parse.rs
+++ b/gix-pathspec/fuzz/fuzz_targets/parse.rs
@@ -4,7 +4,7 @@ use libfuzzer_sys::fuzz_target;
 use std::hint::black_box;
 
 fn fuzz(data: &[u8]) -> Result<()> {
-    let pattern = gix_pathspec::parse(data, Default::default())?;
+    let pattern = gix_pathspec::parse(data, Default::default()).map_err(|err| err.into_error())?;
     _ = black_box(pattern.is_nil());
     _ = black_box(pattern.prefix_directory());
     _ = black_box(pattern.path());
diff --git a/gix-pathspec/src/defaults.rs b/gix-pathspec/src/defaults.rs
index d48c259575b..5a22038c697 100644
--- a/gix-pathspec/src/defaults.rs
+++ b/gix-pathspec/src/defaults.rs
@@ -1,19 +1,8 @@
 use std::ffi::OsString;
 
-use crate::{Defaults, MagicSignature, SearchMode};
+use gix_error::{ErrorExt, ExnMessageResult};
 
-///
-pub mod from_environment {
-    /// The error returned by [Defaults::from_environment()](super::Defaults::from_environment()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ParseValue(#[from] gix_config_value::Error),
-        #[error("Glob and no-glob settings are mutually exclusive")]
-        MixedGlobAndNoGlob,
-    }
-}
+use crate::{Defaults, MagicSignature, SearchMode};
 
 impl Defaults {
     /// Initialize this instance using information from the environment as
@@ -28,8 +17,8 @@ impl Defaults {
     ///
     /// Instead of failing if `GIT_LITERAL_PATHSPECS` is used with glob globals, we ignore these. Also our implementation allows global
     /// `icase` settings in combination with this setting.
-    pub fn from_environment(var: &mut dyn FnMut(&str) -> Option<OsString>) -> Result<Self, from_environment::Error> {
-        let mut env_bool = |name: &str| -> Result<Option<bool>, gix_config_value::Error> {
+    pub fn from_environment(var: &mut dyn FnMut(&str) -> Option<OsString>) -> ExnMessageResult<Self> {
+        let mut env_bool = |name: &str| -> ExnMessageResult<Option<bool>> {
             var(name)
                 .map(|val| gix_config_value::Boolean::try_from(val).map(|b| b.0))
                 .transpose()
@@ -53,7 +42,7 @@ impl Defaults {
         search_mode = env_bool("GIT_NOGLOB_PATHSPECS")?
             .map(|no_glob| {
                 if glob.unwrap_or_default() && no_glob {
-                    Err(from_environment::Error::MixedGlobAndNoGlob)
+                    Err(gix_error::validation("Glob and no-glob settings are mutually exclusive").raise())
                 } else {
                     Ok(SearchMode::Literal)
                 }
diff --git a/gix-pathspec/src/lib.rs b/gix-pathspec/src/lib.rs
index d18e0a38810..f8b67421e15 100644
--- a/gix-pathspec/src/lib.rs
+++ b/gix-pathspec/src/lib.rs
@@ -4,7 +4,7 @@
 //! ## Examples
 //!
 //! ```
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //! use std::path::Path;
 //!
 //! fn no_attrs(
@@ -39,6 +39,7 @@
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
+use gix_error::ExnMessageResult;
 use std::path::PathBuf;
 
 use bitflags::bitflags;
@@ -46,21 +47,6 @@ use bstr::BString;
 /// `gix-glob` types are available through [`attributes::glob`].
 pub use gix_attributes as attributes;
 
-///
-pub mod normalize {
-    use std::path::PathBuf;
-
-    /// The error returned by [Pattern::normalize()](super::Pattern::normalize()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The path '{}' is not inside of the worktree '{}'", path.display(), worktree_path.display())]
-        AbsolutePathOutsideOfWorktree { path: PathBuf, worktree_path: PathBuf },
-        #[error("The path '{}' leaves the repository", path.display())]
-        OutsideOfWorktree { path: PathBuf },
-    }
-}
-
 mod pattern;
 
 ///
@@ -178,6 +164,6 @@ pub enum SearchMode {
 /// setting the given `default` values in case these aren't specified in `input`.
 ///
 /// Note that empty [paths](Pattern::path) are allowed here, and generally some processing has to be performed.
-pub fn parse(input: &[u8], default: Defaults) -> Result<Pattern, parse::Error> {
+pub fn parse(input: &[u8], default: Defaults) -> ExnMessageResult<Pattern> {
     Pattern::from_bytes(input, default)
 }
diff --git a/gix-pathspec/src/parse.rs b/gix-pathspec/src/parse.rs
index 4c590142972..42fa2e250cf 100644
--- a/gix-pathspec/src/parse.rs
+++ b/gix-pathspec/src/parse.rs
@@ -1,37 +1,15 @@
+use gix_error::ExnMessageResult;
 use std::borrow::Cow;
 
 use bstr::{BStr, BString, ByteSlice};
 
 use crate::{Defaults, MagicSignature, Pattern, SearchMode};
 
-/// The error returned by [parse()][crate::parse()].
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("An empty string is not a valid pathspec")]
-    EmptyString,
-    #[error("Found {keyword:?} in signature, which is not a valid keyword")]
-    InvalidKeyword { keyword: BString },
-    #[error("Unimplemented short keyword: {short_keyword:?}")]
-    Unimplemented { short_keyword: char },
-    #[error("Missing ')' at the end of pathspec signature")]
-    MissingClosingParenthesis,
-    #[error(transparent)]
-    InvalidAttribute(#[from] gix_attributes::name::Error),
-    #[error("Invalid character in attribute value: {character:?}")]
-    InvalidAttributeValue { character: char },
-    #[error(r"Escape character '\' is not allowed as the last character in an attribute value")]
-    TrailingEscapeCharacter,
-    #[error("Attribute specification cannot be empty")]
-    EmptyAttribute,
-    #[error("Only one attribute specification is allowed in the same pathspec")]
-    MultipleAttributeSpecifications,
-    #[error("'literal' and 'glob' keywords cannot be used together in the same pathspec")]
-    IncompatibleSearchModes,
-}
-
 impl Pattern {
     /// Try to parse a path-spec pattern from the given `input` bytes.
+    /// Errors store the offending input, keyword, or attribute value bytes as `input`
+    /// in [`gix_error::Message::values`]. After [wrapping](gix_error::Error::from_error()),
+    /// inspect them with [metadata](gix_error::Error::metadata()).
     pub fn from_bytes(
         input: &[u8],
         Defaults {
@@ -39,9 +17,11 @@ impl Pattern {
             search_mode,
             literal,
         }: Defaults,
-    ) -> Result<Self, Error> {
+    ) -> ExnMessageResult<Self> {
         if input.is_empty() {
-            return Err(Error::EmptyString);
+            return Err(gix_error::validation("An empty string is not a valid pathspec")
+                .with("input", input)
+                .into());
         }
         if literal {
             return Ok(Self::from_literal(input, signature));
@@ -93,7 +73,7 @@ impl Pattern {
     }
 }
 
-fn parse_short_keywords(input: &[u8], cursor: &mut usize) -> Result<MagicSignature, Error> {
+fn parse_short_keywords(input: &[u8], cursor: &mut usize) -> ExnMessageResult<MagicSignature> {
     let unimplemented_chars = b"\"#%&'-',;<=>@_`~";
 
     let mut signature = MagicSignature::empty();
@@ -104,9 +84,9 @@ fn parse_short_keywords(input: &[u8], cursor: &mut usize) -> Result<MagicSignatu
             b'^' | b'!' => MagicSignature::EXCLUDE,
             b':' => break,
             _ if unimplemented_chars.contains(&b) => {
-                return Err(Error::Unimplemented {
-                    short_keyword: b.into(),
-                });
+                return Err(gix_error::validation("Unimplemented short keyword")
+                    .with("input", vec![b])
+                    .into());
             }
             _ => {
                 *cursor -= 1;
@@ -118,8 +98,10 @@ fn parse_short_keywords(input: &[u8], cursor: &mut usize) -> Result<MagicSignatu
     Ok(signature)
 }
 
-fn parse_long_keywords(input: &[u8], p: &mut Pattern, cursor: &mut usize) -> Result<(), Error> {
-    let end = input.find(")").ok_or(Error::MissingClosingParenthesis)?;
+fn parse_long_keywords(input: &[u8], p: &mut Pattern, cursor: &mut usize) -> ExnMessageResult {
+    let end = input
+        .find(")")
+        .ok_or_else(|| gix_error::validation("Missing ')' at the end of pathspec signature").with("input", input))?;
 
     let input = &input[*cursor..end];
     *cursor = end + 1;
@@ -141,24 +123,40 @@ fn parse_long_keywords(input: &[u8], p: &mut Pattern, cursor: &mut usize) -> Res
             b"icase" => p.signature |= MagicSignature::ICASE,
             b"exclude" => p.signature |= MagicSignature::EXCLUDE,
             b"literal" => match p.search_mode {
-                SearchMode::PathAwareGlob => return Err(Error::IncompatibleSearchModes),
+                SearchMode::PathAwareGlob => {
+                    return Err(gix_error::validation(
+                        "'literal' and 'glob' keywords cannot be used together in the same pathspec",
+                    )
+                    .with("input", keyword)
+                    .into());
+                }
                 _ => p.search_mode = SearchMode::Literal,
             },
             b"glob" => match p.search_mode {
-                SearchMode::Literal => return Err(Error::IncompatibleSearchModes),
+                SearchMode::Literal => {
+                    return Err(gix_error::validation(
+                        "'literal' and 'glob' keywords cannot be used together in the same pathspec",
+                    )
+                    .with("input", keyword)
+                    .into());
+                }
                 _ => p.search_mode = SearchMode::PathAwareGlob,
             },
             _ if keyword.starts_with(attr_prefix) => {
                 if p.attributes.is_empty() {
                     p.attributes = parse_attributes(&keyword[attr_prefix.len()..])?;
                 } else {
-                    return Err(Error::MultipleAttributeSpecifications);
+                    return Err(gix_error::validation(
+                        "Only one attribute specification is allowed in the same pathspec",
+                    )
+                    .with("input", keyword)
+                    .into());
                 }
             }
             _ => {
-                return Err(Error::InvalidKeyword {
-                    keyword: BString::from(keyword),
-                });
+                return Err(gix_error::validation("Found invalid keyword in pathspec signature")
+                    .with("input", keyword)
+                    .into());
             }
         }
         Ok(())
@@ -168,8 +166,8 @@ fn parse_long_keywords(input: &[u8], p: &mut Pattern, cursor: &mut usize) -> Res
 fn split_on_non_escaped_char(
     input: &[u8],
     split_char: u8,
-    mut f: impl FnMut(&[u8]) -> Result<(), Error>,
-) -> Result<(), Error> {
+    mut f: impl FnMut(&[u8]) -> ExnMessageResult,
+) -> ExnMessageResult {
     // Mirrors `strcspn_escaped()` in Git's `pathspec.c`: a backslash consumes the byte that
     // follows it, so `\,` is a literal comma while `\\,` is an escaped backslash followed by a
     // separator. Scanning byte-by-byte also lets a separator at index 0 be seen, which a
@@ -190,9 +188,9 @@ fn split_on_non_escaped_char(
     f(&input[last..])
 }
 
-fn parse_attributes(input: &[u8]) -> Result<Vec<gix_attributes::Assignment>, Error> {
+fn parse_attributes(input: &[u8]) -> ExnMessageResult<Vec<gix_attributes::Assignment>> {
     if input.is_empty() {
-        return Err(Error::EmptyAttribute);
+        return Err(gix_error::validation("Attribute specification cannot be empty").into());
     }
 
     input
@@ -226,12 +224,17 @@ fn parse_attributes(input: &[u8]) -> Result<Vec<gix_attributes::Assignment>, Err
         .collect()
 }
 
-fn unescape_and_check_attr_value(value: &BStr) -> Result<BString, Error> {
+fn unescape_and_check_attr_value(value: &BStr) -> ExnMessageResult<BString> {
     let mut out = BString::from(Vec::with_capacity(value.len()));
     let mut bytes = value.iter();
     while let Some(mut b) = bytes.next().copied() {
         if b == b'\\' {
-            b = *bytes.next().ok_or(Error::TrailingEscapeCharacter)?;
+            b = *bytes.next().ok_or_else(|| {
+                gix_error::validation(
+                    r"Escape character '\' is not allowed as the last character in an attribute value",
+                )
+                .with("input", value)
+            })?;
         }
 
         out.push(validated_attr_value_byte(b)?);
@@ -239,9 +242,11 @@ fn unescape_and_check_attr_value(value: &BStr) -> Result<BString, Error> {
     Ok(out)
 }
 
-fn check_attribute_value(input: &BStr) -> Result<(), Error> {
+fn check_attribute_value(input: &BStr) -> ExnMessageResult {
     match input.iter().copied().find(|b| !is_valid_attr_value(*b)) {
-        Some(b) => Err(Error::InvalidAttributeValue { character: b as char }),
+        Some(b) => Err(gix_error::validation("Invalid character in attribute value")
+            .with("input", vec![b])
+            .into()),
         None => Ok(()),
     }
 }
@@ -250,12 +255,12 @@ fn is_valid_attr_value(byte: u8) -> bool {
     byte.is_ascii_alphanumeric() || b",-_".contains(&byte)
 }
 
-fn validated_attr_value_byte(byte: u8) -> Result<u8, Error> {
+fn validated_attr_value_byte(byte: u8) -> ExnMessageResult<u8> {
     if is_valid_attr_value(byte) {
         Ok(byte)
     } else {
-        Err(Error::InvalidAttributeValue {
-            character: byte as char,
-        })
+        Err(gix_error::validation("Invalid character in attribute value")
+            .with("input", vec![byte])
+            .into())
     }
 }
diff --git a/gix-pathspec/src/pattern.rs b/gix-pathspec/src/pattern.rs
index 2dc1d0ed38f..a51cb12cf1b 100644
--- a/gix-pathspec/src/pattern.rs
+++ b/gix-pathspec/src/pattern.rs
@@ -1,8 +1,9 @@
+use gix_error::ExnMessageResult;
 use std::path::{Component, Path, PathBuf};
 
 use bstr::{BStr, BString, ByteSlice, ByteVec};
 
-use crate::{MagicSignature, Pattern, SearchMode, normalize};
+use crate::{MagicSignature, Pattern, SearchMode};
 
 /// Access
 impl Pattern {
@@ -40,7 +41,9 @@ impl Pattern {
     /// `prefix` can be empty, we will still normalize this pathspec to resolve relative path components, and
     /// it is assumed not to contain any relative path components, e.g. '', 'a', 'a/b' are valid.
     /// `root` is the absolute path to the root of either the worktree or the repository's `git_dir`.
-    pub fn normalize(&mut self, prefix: &Path, root: &Path) -> Result<&mut Self, normalize::Error> {
+    /// Errors store the path bytes as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
+    pub fn normalize(&mut self, prefix: &Path, root: &Path) -> ExnMessageResult<&mut Self> {
         fn prefix_components_to_subtract(path: &Path) -> usize {
             let parent_component_end_bound = path.components().enumerate().fold(None::<usize>, |acc, (idx, c)| {
                 matches!(c, Component::ParentDir).then_some(idx + 1).or(acc)
@@ -65,10 +68,12 @@ impl Pattern {
             let rela_path = match path.strip_prefix(root) {
                 Ok(path) => path,
                 Err(_) => {
-                    return Err(normalize::Error::AbsolutePathOutsideOfWorktree {
-                        path: path.into_owned(),
-                        worktree_path: root.into(),
-                    });
+                    return Err(gix_error::validation(format!(
+                        "The path is not inside of the worktree '{}'",
+                        root.display()
+                    ))
+                    .with("input", gix_path::into_bstr(path.into_owned()).into_owned())
+                    .into());
                 }
             };
             path = rela_path.to_owned().into();
@@ -103,9 +108,9 @@ impl Pattern {
                 path
             }
             None => {
-                return Err(normalize::Error::OutsideOfWorktree {
-                    path: path.into_owned(),
-                });
+                return Err(gix_error::validation("The path leaves the repository")
+                    .with("input", gix_path::into_bstr(path.into_owned()).into_owned())
+                    .into());
             }
         };
 
diff --git a/gix-pathspec/src/search/init.rs b/gix-pathspec/src/search/init.rs
index 0c35088bbba..f44c7e1ff7d 100644
--- a/gix-pathspec/src/search/init.rs
+++ b/gix-pathspec/src/search/init.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::path::Path;
 
 use crate::{MagicSignature, Pattern, Search, search::Spec};
@@ -8,7 +9,7 @@ fn mapping_from_pattern(
     prefix: &Path,
     root: &Path,
     sequence_number: usize,
-) -> Result<gix_glob::search::pattern::Mapping<Spec>, crate::normalize::Error> {
+) -> ExnMessageResult<gix_glob::search::pattern::Mapping<Spec>> {
     pathspec.normalize(prefix, root)?;
     let mut match_all = pathspec.is_nil();
     let glob = {
@@ -98,17 +99,17 @@ impl Search {
         pathspecs: impl IntoIterator<Item = Pattern>,
         prefix: Option<&std::path::Path>,
         root: &std::path::Path,
-    ) -> Result<Self, crate::normalize::Error> {
+    ) -> ExnMessageResult<Self> {
         fn inner(
             pathspecs: &mut dyn Iterator<Item = Pattern>,
             prefix: Option<&std::path::Path>,
             root: &std::path::Path,
-        ) -> Result<Search, crate::normalize::Error> {
+        ) -> ExnMessageResult<Search> {
             let prefix = prefix.unwrap_or(std::path::Path::new(""));
             let mut patterns = pathspecs
                 .enumerate()
                 .map(|(idx, pattern)| mapping_from_pattern(pattern, prefix, root, idx))
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<std::result::Result<Vec<_>, _>>()?;
 
             if patterns.is_empty() && !prefix.as_os_str().is_empty() {
                 patterns.push(mapping_from_pattern(
diff --git a/gix-pathspec/tests/defaults.rs b/gix-pathspec/tests/defaults.rs
index bae81cc66fc..bee96dc1070 100644
--- a/gix-pathspec/tests/defaults.rs
+++ b/gix-pathspec/tests/defaults.rs
@@ -11,7 +11,7 @@ fn literal_only_combines_with_icase() -> gix_testtools::Result {
             .set("GIT_ICASE_PATHSPECS", "1")
             .set("GIT_NOGLOB_PATHSPECS", "yes");
         assert_eq!(
-            Defaults::from_environment(&mut |n| std::env::var_os(n))?,
+            Defaults::from_environment(&mut |name| std::env::var_os(name))?,
             Defaults {
                 signature: MagicSignature::ICASE,
                 search_mode: SearchMode::Literal,
@@ -25,7 +25,7 @@ fn literal_only_combines_with_icase() -> gix_testtools::Result {
             .set("GIT_ICASE_PATHSPECS", "false")
             .set("GIT_GLOB_PATHSPECS", "yes");
         assert_eq!(
-            Defaults::from_environment(&mut |n| std::env::var_os(n))?,
+            Defaults::from_environment(&mut |name| std::env::var_os(name))?,
             Defaults {
                 signature: MagicSignature::default(),
                 search_mode: SearchMode::Literal,
@@ -40,7 +40,7 @@ fn literal_only_combines_with_icase() -> gix_testtools::Result {
 fn nothing_is_set_then_it_is_like_the_default_impl() -> gix_testtools::Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     assert_eq!(
-        Defaults::from_environment(&mut |n| std::env::var_os(n))?,
+        Defaults::from_environment(&mut |name| std::env::var_os(name))?,
         Defaults::default()
     );
     Ok(())
@@ -52,16 +52,25 @@ fn glob_and_noglob_cause_error() -> gix_testtools::Result {
     let _environment = gix_testtools::isolate_git_environment()?
         .set("GIT_GLOB_PATHSPECS", "1")
         .set("GIT_NOGLOB_PATHSPECS", "yes");
-    assert_eq!(
-        Defaults::from_environment(&mut |n| std::env::var_os(n))
-            .unwrap_err()
-            .to_string(),
-        "Glob and no-glob settings are mutually exclusive"
-    );
+    insta::assert_debug_snapshot!(Defaults::from_environment(&mut |n| std::env::var_os(n))
+            .expect_err("glob and noglob cause error"), "glob and noglob cause error", @"Glob and no-glob settings are mutually exclusive");
 
     Ok(())
 }
 
+#[test]
+#[serial]
+fn invalid_values_retain_the_config_validation_error() {
+    let _env = gix_testtools::Env::new().set("GIT_GLOB_PATHSPECS", "invalid");
+    let err = Defaults::from_environment(&mut |name| std::env::var_os(name))
+        .expect_err("the environment value is not a boolean");
+    insta::assert_debug_snapshot!(err, "invalid values retain the config validation error", @r#"Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid""#);
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"invalid".as_slice()))
+    );
+}
+
 #[test]
 #[serial]
 fn noglob_works() -> gix_testtools::Result {
@@ -69,7 +78,7 @@ fn noglob_works() -> gix_testtools::Result {
         .set("GIT_GLOB_PATHSPECS", "0")
         .set("GIT_NOGLOB_PATHSPECS", "true");
     assert_eq!(
-        Defaults::from_environment(&mut |n| std::env::var_os(n))?,
+        Defaults::from_environment(&mut |name| std::env::var_os(name))?,
         Defaults {
             signature: MagicSignature::default(),
             search_mode: SearchMode::Literal,
@@ -85,7 +94,7 @@ fn noglob_works() -> gix_testtools::Result {
 fn glob_works() -> gix_testtools::Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("GIT_GLOB_PATHSPECS", "yes");
     assert_eq!(
-        Defaults::from_environment(&mut |n| std::env::var_os(n))?,
+        Defaults::from_environment(&mut |name| std::env::var_os(name))?,
         Defaults {
             signature: MagicSignature::default(),
             search_mode: SearchMode::PathAwareGlob,
diff --git a/gix-pathspec/tests/normalize/mod.rs b/gix-pathspec/tests/normalize/mod.rs
index c8f88de992c..72c86195b3c 100644
--- a/gix-pathspec/tests/normalize/mod.rs
+++ b/gix-pathspec/tests/normalize/mod.rs
@@ -1,7 +1,9 @@
+use crate::Result;
+use gix_error::ExnMessageResult;
 use std::path::Path;
 
 #[test]
-fn consuming_the_entire_prefix_does_not_lead_to_a_single_dot() -> crate::Result {
+fn consuming_the_entire_prefix_does_not_lead_to_a_single_dot() -> Result {
     let spec = normalized_spec("..", "a", "")?;
     assert_eq!(
         spec.path(),
@@ -17,7 +19,7 @@ fn consuming_the_entire_prefix_does_not_lead_to_a_single_dot() -> crate::Result
 }
 
 #[test]
-fn removes_relative_path_components() -> crate::Result {
+fn removes_relative_path_components() -> Result {
     for (input_path, expected_path, expected_prefix) in [
         ("..", "a", ""),
         ("c", "a/b/c", "a/b"),
@@ -46,7 +48,7 @@ fn removes_relative_path_components() -> crate::Result {
 }
 
 #[test]
-fn single_dot_is_special_and_directory_is_implied_without_trailing_slash() -> crate::Result {
+fn single_dot_is_special_and_directory_is_implied_without_trailing_slash() -> Result {
     for (input_path, expected) in [(".", "."), ("./", ".")] {
         let spec = normalized_spec(input_path, "", "/repo")?;
         assert_eq!(spec.path(), expected);
@@ -57,7 +59,7 @@ fn single_dot_is_special_and_directory_is_implied_without_trailing_slash() -> cr
 }
 
 #[test]
-fn absolute_path_made_relative() -> crate::Result {
+fn absolute_path_made_relative() -> Result {
     for (input_path, expected, prefix_dir) in [
         ("/repo/a", "a", ""),
         ("/repo/a/..//.///b", "b", ""),
@@ -78,7 +80,7 @@ fn absolute_path_made_relative() -> crate::Result {
 }
 
 #[test]
-fn relative_top_patterns_ignore_the_prefix() -> crate::Result {
+fn relative_top_patterns_ignore_the_prefix() -> Result {
     let spec = normalized_spec(":(top)c", "a/b", "")?;
     assert_eq!(spec.path(), "c");
     assert_eq!(spec.prefix_directory(), "");
@@ -86,7 +88,7 @@ fn relative_top_patterns_ignore_the_prefix() -> crate::Result {
 }
 
 #[test]
-fn absolute_top_patterns_ignore_the_prefix_but_are_made_relative() -> crate::Result {
+fn absolute_top_patterns_ignore_the_prefix_but_are_made_relative() -> Result {
     let spec = normalized_spec(":(top)/a/b", "prefix-ignored", "/a")?;
     assert_eq!(spec.path(), "b");
     assert_eq!(spec.prefix_directory(), "");
@@ -96,38 +98,40 @@ fn absolute_top_patterns_ignore_the_prefix_but_are_made_relative() -> crate::Res
 #[test]
 fn relative_path_breaks_out_of_working_tree() {
     let err = normalized_spec("../a", "", "").unwrap_err();
-    assert_eq!(err.to_string(), "The path '../a' leaves the repository");
+    insta::assert_debug_snapshot!(err, "relative path breaks out of working tree", @r#"The path leaves the repository, "input"="../a""#);
+    assert_eq!(err.values["input"], gix_error::MetadataValue::from(b"../a".as_slice()));
     let err = normalized_spec("../../b", "a", "").unwrap_err();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(r"a\../../b", "a/../../b")]), "relative path breaks out of working tree", @r#"The path leaves the repository, "input"="a/../../b""#);
     assert_eq!(
-        err.to_string(),
-        format!(
-            "The path '{}' leaves the repository",
-            if cfg!(windows) { r"a\../../b" } else { "a/../../b" }
-        )
+        err.values["input"],
+        gix_error::MetadataValue::from((if cfg!(windows) { r"a\../../b" } else { "a/../../b" }).as_bytes())
     );
 }
 
 #[test]
 fn absolute_path_breaks_out_of_working_tree() {
     let err = normalized_spec("/path/to/repo/..///./a", "", "/path/to/repo").unwrap_err();
-    assert_eq!(err.to_string(), "The path '..///./a' leaves the repository");
+    insta::assert_debug_snapshot!(err, "absolute path breaks out of working tree", @r#"The path leaves the repository, "input"="..///./a""#);
+    assert_eq!(
+        err.values["input"],
+        gix_error::MetadataValue::from(b"..///./a".as_slice())
+    );
     let err = normalized_spec("/path/to/repo/../../../dev", "", "/path/to/repo").unwrap_err();
-    assert_eq!(err.to_string(), "The path '../../../dev' leaves the repository");
+    insta::assert_debug_snapshot!(err, "absolute path breaks out of working tree", @r#"The path leaves the repository, "input"="../../../dev""#);
+    assert_eq!(
+        err.values["input"],
+        gix_error::MetadataValue::from(b"../../../dev".as_slice())
+    );
 }
 
 #[test]
 fn absolute_path_escapes_worktree() {
-    assert_eq!(
-        normalized_spec("/dev", "", "/path/to/repo").unwrap_err().to_string(),
-        "The path '/dev' is not inside of the worktree '/path/to/repo'"
-    );
+    let err = normalized_spec("/dev", "", "/path/to/repo").expect_err("the path is outside of the worktree");
+    insta::assert_debug_snapshot!(err, "absolute path escapes worktree", @r#"The path is not inside of the worktree '/path/to/repo', "input"="/dev""#);
+    assert_eq!(err.values["input"], gix_error::MetadataValue::from(b"/dev".as_slice()));
 }
 
-fn normalized_spec(
-    path: &str,
-    prefix: &str,
-    root: &str,
-) -> Result<gix_pathspec::Pattern, gix_pathspec::normalize::Error> {
+fn normalized_spec(path: &str, prefix: &str, root: &str) -> ExnMessageResult<gix_pathspec::Pattern> {
     let mut spec = gix_pathspec::parse(path.as_bytes(), Default::default()).expect("valid");
     spec.normalize(Path::new(prefix), Path::new(root))?;
     Ok(spec)
diff --git a/gix-pathspec/tests/parse/invalid.rs b/gix-pathspec/tests/parse/invalid.rs
index b6ae3a9747d..ff6ce103cf2 100644
--- a/gix-pathspec/tests/parse/invalid.rs
+++ b/gix-pathspec/tests/parse/invalid.rs
@@ -1,20 +1,36 @@
-use gix_pathspec::parse::Error;
+use gix_error::Message;
 
 use crate::parse::check_against_baseline;
 
+fn assert_validation(input: &str) -> Message {
+    let err = gix_pathspec::parse(input.as_bytes(), Default::default()).expect_err("pathspec is invalid");
+    assert!(err.is_validation(), "invalid pathspecs retain their classification");
+    err.into_inner()
+}
+
 #[test]
 fn empty_input() {
     let input = "";
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-    let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-    assert!(output.is_err());
-    assert!(matches!(output.unwrap_err(), Error::EmptyString));
+    let err = assert_validation(input);
+    insta::assert_debug_snapshot!(err, "empty input", @r#"
+    Message {
+        message: "An empty string is not a valid pathspec",
+        class: Validation,
+        values: {"input": Bytes("")},
+    }
+    "#);
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"".as_slice()))
+    );
 }
 
 #[test]
 fn invalid_short_signatures() {
+    let mut diagnostics = Vec::new();
     let inputs = vec![
         ":\"()", ":#()", ":%()", ":&()", ":'()", ":,()", ":-()", ":;()", ":<()", ":=()", ":>()", ":@()", ":_()",
         ":`()", ":~()",
@@ -23,14 +39,94 @@ fn invalid_short_signatures() {
     for input in inputs.into_iter() {
         assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-        let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-        assert!(output.is_err());
-        assert!(matches!(output.unwrap_err(), Error::Unimplemented { .. }));
+        let err = assert_validation(input);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(matches!(err.values.get("input"), Some(gix_error::MetadataValue::Bytes(input)) if input.len() == 1));
     }
+    insta::assert_debug_snapshot!(diagnostics, "invalid short signatures", @r##"
+    [
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("\"")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("#")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("%")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("&")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("\'")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes(",")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("-")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes(";")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("<")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("=")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes(">")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("@")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("_")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("`")},
+        },
+        Message {
+            message: "Unimplemented short keyword",
+            class: Validation,
+            values: {"input": Bytes("~")},
+        },
+    ]
+    "##);
 }
 
 #[test]
 fn invalid_keywords() {
+    let mut diagnostics = Vec::new();
     let inputs = vec![
         ":( )some/path",
         ":(tp)some/path",
@@ -41,14 +137,39 @@ fn invalid_keywords() {
     for input in inputs.into_iter() {
         assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-        let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-        assert!(output.is_err());
-        assert!(matches!(output.unwrap_err(), Error::InvalidKeyword { .. }));
+        let err = assert_validation(input);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(err.values.contains_key("input"), "the invalid keyword is retained");
     }
+    insta::assert_debug_snapshot!(diagnostics, "invalid keywords", @r#"
+    [
+        Message {
+            message: "Found invalid keyword in pathspec signature",
+            class: Validation,
+            values: {"input": Bytes(" ")},
+        },
+        Message {
+            message: "Found invalid keyword in pathspec signature",
+            class: Validation,
+            values: {"input": Bytes("tp")},
+        },
+        Message {
+            message: "Found invalid keyword in pathspec signature",
+            class: Validation,
+            values: {"input": Bytes(" exclude")},
+        },
+        Message {
+            message: "Found invalid keyword in pathspec signature",
+            class: Validation,
+            values: {"input": Bytes("icse")},
+        },
+    ]
+    "#);
 }
 
 #[test]
 fn invalid_attributes() {
+    let mut diagnostics = Vec::new();
     let inputs = vec![
         ":(attr:+invalidAttr)some/path",
         ":(attr:validAttr +invalidAttr)some/path",
@@ -63,10 +184,57 @@ fn invalid_attributes() {
     for input in inputs {
         assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-        let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-        assert!(output.is_err(), "This pathspec did not produce an error {input}");
-        assert!(matches!(output.unwrap_err(), Error::InvalidAttribute(_)));
+        let err = assert_validation(input);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(
+            err.values.contains_key("input"),
+            "the invalid attribute name is retained"
+        );
     }
+    insta::assert_debug_snapshot!(diagnostics, "invalid attributes", @r#"
+    [
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("+invalidAttr")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("+invalidAttr")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("+invalidAttr")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("inva\\lid")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("a\tb")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("a\rb")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("a=b")},
+        },
+        Message {
+            message: "Attribute has non-ascii characters or starts with '-'",
+            class: Validation,
+            values: {"input": Bytes("a=b")},
+        },
+    ]
+    "#);
 }
 
 #[test]
@@ -74,17 +242,23 @@ fn attribute_values_are_not_split_on_non_space_blanks() {
     let input = ":(attr:a=one\tb=two)some/path";
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-    assert!(
-        matches!(
-            gix_pathspec::parse(input.as_bytes(), Default::default()),
-            Err(Error::InvalidAttributeValue { .. })
-        ),
-        "the tab belongs to the value and makes it invalid"
+    let err = assert_validation(input);
+    insta::assert_debug_snapshot!(err, "attribute values are not split on non space blanks", @r#"
+    Message {
+        message: "Invalid character in attribute value",
+        class: Validation,
+        values: {"input": Bytes("\t")},
+    }
+    "#);
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"\t".as_slice()))
     );
 }
 
 #[test]
 fn invalid_attribute_values() {
+    let mut diagnostics = Vec::new();
     let inputs = vec![
         r":(attr:v=inva#lid)some/path",
         r":(attr:v=inva\\lid)some/path",
@@ -99,17 +273,59 @@ fn invalid_attribute_values() {
     for input in inputs {
         assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-        let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-        assert!(output.is_err(), "This pathspec did not produce an error {input}");
-        assert!(
-            matches!(output.unwrap_err(), Error::InvalidAttributeValue { .. }),
-            "Errors did not match for pathspec: {input}"
-        );
+        let err = assert_validation(input);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(matches!(err.values.get("input"), Some(gix_error::MetadataValue::Bytes(input)) if input.len() == 1));
     }
+    insta::assert_debug_snapshot!(diagnostics, "invalid attribute values", @r##"
+    [
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("#")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("\\")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("\\")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("#")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("=")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("#")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("\xef")},
+        },
+        Message {
+            message: "Invalid character in attribute value",
+            class: Validation,
+            values: {"input": Bytes("\xef")},
+        },
+    ]
+    "##);
 }
 
 #[test]
 fn escape_character_at_end_of_attribute_value() {
+    let mut diagnostics = Vec::new();
     let inputs = vec![
         r":(attr:v=invalid\)some/path",
         r":(attr:v=invalid\ )some/path",
@@ -119,10 +335,32 @@ fn escape_character_at_end_of_attribute_value() {
     for input in inputs {
         assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-        let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-        assert!(output.is_err(), "This pathspec did not produce an error {input}");
-        assert!(matches!(output.unwrap_err(), Error::TrailingEscapeCharacter));
+        let err = assert_validation(input);
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert!(
+            err.values.contains_key("input"),
+            "the invalid attribute value is retained"
+        );
     }
+    insta::assert_debug_snapshot!(diagnostics, "escape character at end of attribute value", @r#"
+    [
+        Message {
+            message: "Escape character '\\' is not allowed as the last character in an attribute value",
+            class: Validation,
+            values: {"input": Bytes("invalid\\")},
+        },
+        Message {
+            message: "Escape character '\\' is not allowed as the last character in an attribute value",
+            class: Validation,
+            values: {"input": Bytes("invalid\\")},
+        },
+        Message {
+            message: "Escape character '\\' is not allowed as the last character in an attribute value",
+            class: Validation,
+            values: {"input": Bytes("invalid\\")},
+        },
+    ]
+    "#);
 }
 
 #[test]
@@ -131,9 +369,12 @@ fn empty_attribute_specification() {
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-    let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-    assert!(output.is_err());
-    assert!(matches!(output.unwrap_err(), Error::EmptyAttribute));
+    insta::assert_debug_snapshot!(assert_validation(input), "empty attribute specification", @r#"
+    Message {
+        message: "Attribute specification cannot be empty",
+        class: Validation,
+    }
+    "#);
 }
 
 #[test]
@@ -142,9 +383,18 @@ fn multiple_attribute_specifications() {
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-    let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-    assert!(output.is_err());
-    assert!(matches!(output.unwrap_err(), Error::MultipleAttributeSpecifications));
+    let err = assert_validation(input);
+    insta::assert_debug_snapshot!(err, "multiple attribute specifications", @r#"
+    Message {
+        message: "Only one attribute specification is allowed in the same pathspec",
+        class: Validation,
+        values: {"input": Bytes("attr:two")},
+    }
+    "#);
+    assert!(
+        err.values.contains_key("input"),
+        "the duplicate attribute specification is retained"
+    );
 }
 
 #[test]
@@ -153,9 +403,18 @@ fn missing_parentheses() {
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-    let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-    assert!(output.is_err());
-    assert!(matches!(output.unwrap_err(), Error::MissingClosingParenthesis));
+    let err = assert_validation(input);
+    insta::assert_debug_snapshot!(err, "missing parentheses", @r#"
+    Message {
+        message: "Missing ')' at the end of pathspec signature",
+        class: Validation,
+        values: {"input": Bytes(":(top")},
+    }
+    "#);
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(input.as_bytes()))
+    );
 }
 
 #[test]
@@ -164,7 +423,16 @@ fn glob_and_literal_keywords_present() {
 
     assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
 
-    let output = gix_pathspec::parse(input.as_bytes(), Default::default());
-    assert!(output.is_err());
-    assert!(matches!(output.unwrap_err(), Error::IncompatibleSearchModes));
+    let err = assert_validation(input);
+    insta::assert_debug_snapshot!(err, "glob and literal keywords present", @r#"
+    Message {
+        message: "'literal' and 'glob' keywords cannot be used together in the same pathspec",
+        class: Validation,
+        values: {"input": Bytes("literal")},
+    }
+    "#);
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"literal".as_slice()))
+    );
 }
diff --git a/gix-pathspec/tests/parse/mod.rs b/gix-pathspec/tests/parse/mod.rs
index 3c54fa1e72b..df4d26446c2 100644
--- a/gix-pathspec/tests/parse/mod.rs
+++ b/gix-pathspec/tests/parse/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::collections::HashMap;
 
 use bstr::{BStr, BString, ByteSlice};
@@ -57,7 +58,7 @@ impl From<Pattern> for NormalizedPattern {
 static BASELINE: LazyLock<HashMap<BString, usize>> = LazyLock::new(|| {
     let base = gix_testtools::scripted_fixture_read_only("parse_baseline.sh").unwrap();
 
-    (|| -> crate::Result<_> {
+    (|| -> Result<_> {
         let mut map = HashMap::new();
         let baseline = std::fs::read(base.join("baseline.git"))?;
         let mut lines = baseline.lines();
diff --git a/gix-pathspec/tests/parse/valid.rs b/gix-pathspec/tests/parse/valid.rs
index 0c193ebf867..43c170ba99d 100644
--- a/gix-pathspec/tests/parse/valid.rs
+++ b/gix-pathspec/tests/parse/valid.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_attributes::State;
 use gix_pathspec::{MagicSignature, SearchMode};
 
@@ -120,7 +121,7 @@ fn there_is_no_pathspec_pathspec() {
 }
 
 #[test]
-fn defaults_are_used() -> crate::Result {
+fn defaults_are_used() -> Result {
     let defaults = gix_pathspec::Defaults {
         signature: MagicSignature::EXCLUDE,
         search_mode: SearchMode::Literal,
@@ -136,7 +137,7 @@ fn defaults_are_used() -> crate::Result {
 }
 
 #[test]
-fn literal_from_defaults_is_overridden_by_element_glob() -> crate::Result {
+fn literal_from_defaults_is_overridden_by_element_glob() -> Result {
     let defaults = gix_pathspec::Defaults {
         search_mode: SearchMode::Literal,
         ..Default::default()
@@ -151,7 +152,7 @@ fn literal_from_defaults_is_overridden_by_element_glob() -> crate::Result {
 }
 
 #[test]
-fn glob_from_defaults_is_overridden_by_element_glob() -> crate::Result {
+fn glob_from_defaults_is_overridden_by_element_glob() -> Result {
     let defaults = gix_pathspec::Defaults {
         search_mode: SearchMode::PathAwareGlob,
         ..Default::default()
diff --git a/gix-pathspec/tests/search/mod.rs b/gix-pathspec/tests/search/mod.rs
index 1bb1280668a..527d8ebcb89 100644
--- a/gix-pathspec/tests/search/mod.rs
+++ b/gix-pathspec/tests/search/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use bstr::BStr;
@@ -11,12 +12,12 @@ fn is_send_with_parallel_enabled() {
 }
 
 #[test]
-fn directories() -> crate::Result {
+fn directories() -> Result {
     baseline::run("directory", true, baseline::directories)
 }
 
 #[test]
-fn directory_matches_prefix() -> crate::Result {
+fn directory_matches_prefix() -> Result {
     for spec in ["dir", "dir/", "di*", "dir/*", "dir/*.o"] {
         for specs in [&[spec] as &[_], &[spec, "other"]] {
             let search = gix_pathspec::Search::from_specs(pathspecs(specs), None, Path::new(""))?;
@@ -58,7 +59,7 @@ fn directory_matches_prefix() -> crate::Result {
 }
 
 #[test]
-fn directory_matches_prefix_starting_wildcards_always_match() -> crate::Result {
+fn directory_matches_prefix_starting_wildcards_always_match() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["*ir"]), None, Path::new(""))?;
     assert!(search.directory_matches_prefix("dir".into(), false));
     assert!(search.directory_matches_prefix("d".into(), false));
@@ -66,7 +67,7 @@ fn directory_matches_prefix_starting_wildcards_always_match() -> crate::Result {
 }
 
 #[test]
-fn empty_dir_always_matches() -> crate::Result {
+fn empty_dir_always_matches() -> Result {
     for specs in [
         &["*ir"] as &[_],
         &[],
@@ -91,7 +92,7 @@ fn empty_dir_always_matches() -> crate::Result {
 }
 
 #[test]
-fn directory_matches_prefix_leading() -> crate::Result {
+fn directory_matches_prefix_leading() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["d/d/generated/b"]), None, Path::new(""))?;
     assert!(!search.directory_matches_prefix("di".into(), false));
     assert!(!search.directory_matches_prefix("di".into(), true));
@@ -114,7 +115,7 @@ fn directory_matches_prefix_leading() -> crate::Result {
 }
 
 #[test]
-fn directory_matches_prefix_negative_wildcard() -> crate::Result {
+fn directory_matches_prefix_negative_wildcard() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&[":!*generated*"]), None, Path::new(""))?;
     assert!(
         search.directory_matches_prefix("di".into(), false),
@@ -137,7 +138,7 @@ fn directory_matches_prefix_negative_wildcard() -> crate::Result {
 }
 
 #[test]
-fn directory_matches_prefix_all_excluded() -> crate::Result {
+fn directory_matches_prefix_all_excluded() -> Result {
     for spec in ["!dir", "!dir/", "!d*", "!di*", "!dir/*", "!dir/*.o", "!*ir"] {
         for specs in [&[spec] as &[_], &[spec, "other"]] {
             let search = gix_pathspec::Search::from_specs(pathspecs(specs), None, Path::new(""))?;
@@ -151,7 +152,7 @@ fn directory_matches_prefix_all_excluded() -> crate::Result {
 }
 
 #[test]
-fn no_pathspecs_match_everything() -> crate::Result {
+fn no_pathspecs_match_everything() -> Result {
     let mut search = gix_pathspec::Search::from_specs([], None, Path::new(""))?;
     assert_eq!(search.patterns().count(), 0, "nothing artificial is added");
     let m = search
@@ -169,7 +170,7 @@ fn no_pathspecs_match_everything() -> crate::Result {
 }
 
 #[test]
-fn included_directory_and_excluded_subdir_top_level_with_prefix() -> crate::Result {
+fn included_directory_and_excluded_subdir_top_level_with_prefix() -> Result {
     let mut search = gix_pathspec::Search::from_specs(pathspecs(&[":/foo", ":!/foo/target/"]), None, Path::new("foo"))?;
     let m = search
         .pattern_matching_relative_path("foo".into(), Some(true), &mut no_attrs)
@@ -210,7 +211,7 @@ fn included_directory_and_excluded_subdir_top_level_with_prefix() -> crate::Resu
 }
 
 #[test]
-fn starts_with() -> crate::Result {
+fn starts_with() -> Result {
     let mut search = gix_pathspec::Search::from_specs(pathspecs(&["a/*"]), None, Path::new(""))?;
     assert!(
         search
@@ -250,7 +251,7 @@ fn starts_with() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_respects_must_be_dir() -> crate::Result {
+fn simplified_search_respects_must_be_dir() -> Result {
     let mut search = gix_pathspec::Search::from_specs(pathspecs(&["a/be/"]), None, Path::new(""))?;
     assert_eq!(
         search
@@ -319,7 +320,7 @@ fn simplified_search_respects_must_be_dir() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_respects_ignore_case() -> crate::Result {
+fn simplified_search_respects_ignore_case() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&[":(icase)foo/**/bar"]), None, Path::new(""))?;
     assert!(search.can_match_relative_path("Foo".into(), None));
     assert!(search.can_match_relative_path("foo".into(), Some(true)));
@@ -329,7 +330,7 @@ fn simplified_search_respects_ignore_case() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_respects_all_excluded() -> crate::Result {
+fn simplified_search_respects_all_excluded() -> Result {
     let search = gix_pathspec::Search::from_specs(
         pathspecs(&[":(exclude)a/file", ":(exclude)b/file"]),
         None,
@@ -350,7 +351,7 @@ fn simplified_search_respects_all_excluded() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_wildcards() -> crate::Result {
+fn simplified_search_wildcards() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["**/a*"]), None, Path::new(""))?;
     assert!(
         search.can_match_relative_path("a".into(), None),
@@ -366,7 +367,7 @@ fn simplified_search_wildcards() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_wildcards_simple() -> crate::Result {
+fn simplified_search_wildcards_simple() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["dir/*"]), None, Path::new(""))?;
     for is_dir in [None, Some(false), Some(true)] {
         assert!(
@@ -391,7 +392,7 @@ fn simplified_search_wildcards_simple() -> crate::Result {
 }
 
 #[test]
-fn simplified_search_handles_nil() -> crate::Result {
+fn simplified_search_handles_nil() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&[":"]), None, Path::new(""))?;
     assert!(search.can_match_relative_path("a".into(), None), "everything matches");
     assert!(search.can_match_relative_path("a".into(), Some(false)));
@@ -411,7 +412,7 @@ fn simplified_search_handles_nil() -> crate::Result {
 }
 
 #[test]
-fn longest_common_directory_no_prefix() -> crate::Result {
+fn longest_common_directory_no_prefix() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["tests/a/", "tests/b/", ":!*.sh"]), None, Path::new(""))?;
     assert_eq!(search.common_prefix(), "tests/");
     assert_eq!(search.prefix_directory(), Path::new(""));
@@ -424,7 +425,7 @@ fn longest_common_directory_no_prefix() -> crate::Result {
 }
 
 #[test]
-fn longest_common_directory_with_prefix() -> crate::Result {
+fn longest_common_directory_with_prefix() -> Result {
     let search = gix_pathspec::Search::from_specs(
         pathspecs(&["tests/a/", "tests/b/", ":!*.sh"]),
         Some(Path::new("a/b")),
@@ -445,7 +446,7 @@ fn longest_common_directory_with_prefix() -> crate::Result {
 }
 
 #[test]
-fn init_with_exclude() -> crate::Result {
+fn init_with_exclude() -> Result {
     let search = gix_pathspec::Search::from_specs(pathspecs(&["tests/", ":!*.sh"]), None, Path::new(""))?;
     assert_eq!(search.patterns().count(), 2, "nothing artificial is added");
     assert!(
@@ -476,7 +477,7 @@ fn init_with_exclude() -> crate::Result {
 }
 
 #[test]
-fn no_pathspecs_respect_prefix() -> crate::Result {
+fn no_pathspecs_respect_prefix() -> Result {
     let mut search = gix_pathspec::Search::from_specs([], Some(Path::new("a")), Path::new(""))?;
     assert_eq!(
         search.patterns().count(),
@@ -508,7 +509,7 @@ fn no_pathspecs_respect_prefix() -> crate::Result {
 }
 
 #[test]
-fn prefixes_are_always_case_sensitive() -> crate::Result {
+fn prefixes_are_always_case_sensitive() -> Result {
     let path = gix_testtools::scripted_fixture_read_only("match_baseline_files.sh")?.join("paths");
     let items = baseline::parse_paths(path)?;
 
@@ -585,7 +586,7 @@ fn prefixes_are_always_case_sensitive() -> crate::Result {
 }
 
 #[test]
-fn common_prefix() -> crate::Result {
+fn common_prefix() -> Result {
     for (specs, prefix, expected_common_prefix, expected_common_dir) in [
         (&["foo/bar", ":(icase)foo/bar"] as &[_], None, "", ""),
         (&["foo/bar", "foo"], None, "foo", ""),
@@ -612,7 +613,7 @@ fn common_prefix() -> crate::Result {
 }
 
 #[test]
-fn files() -> crate::Result {
+fn files() -> Result {
     baseline::run("file", false, baseline::files)
 }
 
@@ -624,6 +625,7 @@ fn pathspecs(input: &[&str]) -> Vec<gix_pathspec::Pattern> {
 }
 
 mod baseline {
+    use crate::Result;
     use std::path::{Path, PathBuf};
 
     use bstr::{BString, ByteSlice};
@@ -631,8 +633,8 @@ mod baseline {
     pub fn run(
         name: &str,
         items_are_dirs: bool,
-        init: impl FnOnce() -> crate::Result<(PathBuf, Vec<String>, Vec<Expected>)>,
-    ) -> crate::Result {
+        init: impl FnOnce() -> Result<(PathBuf, Vec<String>, Vec<Expected>)>,
+    ) -> Result {
         let (root, items, expected) = init()?;
         let mut collection = Default::default();
         let attrs =
@@ -740,7 +742,7 @@ mod baseline {
         }
     }
 
-    pub fn directories() -> crate::Result<(PathBuf, Vec<String>, Vec<Expected>)> {
+    pub fn directories() -> Result<(PathBuf, Vec<String>, Vec<Expected>)> {
         let root = gix_testtools::scripted_fixture_read_only("match_baseline_dirs.sh")?.join("parent");
         let buf = std::fs::read(root.join("paths"))?;
         let items = submodule::matches_from_status(&buf)
@@ -750,7 +752,7 @@ mod baseline {
         Ok((root, items, expected))
     }
 
-    pub fn files() -> crate::Result<(PathBuf, Vec<String>, Vec<Expected>)> {
+    pub fn files() -> Result<(PathBuf, Vec<String>, Vec<Expected>)> {
         let root = gix_testtools::scripted_fixture_read_only("match_baseline_files.sh")?;
         let items = parse_paths(root.join("paths"))?;
         let expected = files::parse_expected(&std::fs::read(root.join("baseline.git"))?);
diff --git a/gix-prompt/Cargo.toml b/gix-prompt/Cargo.toml
index 97729348412..32fdec119ef 100644
--- a/gix-prompt/Cargo.toml
+++ b/gix-prompt/Cargo.toml
@@ -17,14 +17,14 @@ doctest = false
 [dependencies]
 gix-command = { version = "^0.10.0", path = "../gix-command" }
 gix-config-value = { version = "^0.19.0", path = "../gix-config-value" }
-
-thiserror = "2.0.18"
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
 [target.'cfg(unix)'.dependencies]
 rustix = { version = "1.1.2", features = ["termios"] }
 parking_lot = "0.12.4"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 serial_test = { version = "3.4.0", default-features = false }
 
diff --git a/gix-prompt/examples/askpass.rs b/gix-prompt/examples/askpass.rs
index 72b9f0e2992..590f9047401 100644
--- a/gix-prompt/examples/askpass.rs
+++ b/gix-prompt/examples/askpass.rs
@@ -1,4 +1,4 @@
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let prompt = std::env::args()
         .nth(1)
         .ok_or("First argument must be the prompt to display when asking for a password")?;
diff --git a/gix-prompt/examples/credentials.rs b/gix-prompt/examples/credentials.rs
index f90e36e3f23..72461c471ba 100644
--- a/gix-prompt/examples/credentials.rs
+++ b/gix-prompt/examples/credentials.rs
@@ -1,4 +1,5 @@
-fn main() -> Result<(), gix_prompt::Error> {
+use gix_error::ExnMessageResult;
+fn main() -> ExnMessageResult {
     let user = gix_prompt::openly("Username: ")?;
     eprintln!("{user:?}");
     let pass = gix_prompt::securely("Password: ")?;
diff --git a/gix-prompt/examples/use-askpass.rs b/gix-prompt/examples/use-askpass.rs
index 49c6e92e185..a9e08155bca 100644
--- a/gix-prompt/examples/use-askpass.rs
+++ b/gix-prompt/examples/use-askpass.rs
@@ -1,6 +1,6 @@
 use gix_prompt::{Mode, Options};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let pass = gix_prompt::ask(
         "Password: ",
         &Options {
diff --git a/gix-prompt/src/lib.rs b/gix-prompt/src/lib.rs
index 141c0f3f792..34fa5aae238 100644
--- a/gix-prompt/src/lib.rs
+++ b/gix-prompt/src/lib.rs
@@ -7,8 +7,9 @@
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
+use gix_error::ExnMessageResult;
 mod types;
-pub use types::{Error, Mode, Options};
+pub use types::{Mode, Options};
 
 ///
 pub mod unix;
@@ -17,15 +18,17 @@ use unix::imp;
 
 #[cfg(not(unix))]
 mod imp {
-    use crate::{Error, Options};
+    use crate::Options;
+    use gix_error::ExnMessageResult;
+    use gix_error::{ErrorExt, message};
 
-    pub(crate) fn ask(_prompt: &str, _opts: &Options) -> Result<String, Error> {
-        Err(Error::UnsupportedPlatform)
+    pub(crate) fn ask(_prompt: &str, _opts: &Options) -> ExnMessageResult<String> {
+        Err(message("The current platform has no implementation for prompting in the terminal").raise())
     }
 }
 
 /// Ask the user given a `prompt`, returning the result.
-pub fn ask(prompt: &str, opts: &Options) -> Result<String, Error> {
+pub fn ask(prompt: &str, opts: &Options) -> ExnMessageResult<String> {
     if let Some(askpass) = opts.askpass.as_deref() {
         match gix_command::prepare(askpass).arg(prompt).spawn() {
             Ok(cmd) => {
@@ -55,7 +58,7 @@ pub fn ask(prompt: &str, opts: &Options) -> Result<String, Error> {
 /// Ask for information typed by the user into the terminal after showing the prompt, like `"Username: `.
 ///
 /// Use [`ask()`] for more control.
-pub fn openly(prompt: impl AsRef<str>) -> Result<String, Error> {
+pub fn openly(prompt: impl AsRef<str>) -> ExnMessageResult<String> {
     imp::ask(
         prompt.as_ref(),
         &Options {
@@ -68,7 +71,7 @@ pub fn openly(prompt: impl AsRef<str>) -> Result<String, Error> {
 /// Ask for information _securely_ after showing the `prompt` (like `"password: "`) by not showing what's typed.
 ///
 /// Use [`ask()`] for more control.
-pub fn securely(prompt: impl AsRef<str>) -> Result<String, Error> {
+pub fn securely(prompt: impl AsRef<str>) -> ExnMessageResult<String> {
     imp::ask(
         prompt.as_ref(),
         &Options {
diff --git a/gix-prompt/src/types.rs b/gix-prompt/src/types.rs
index 06e955c15f4..92f418fcfb2 100644
--- a/gix-prompt/src/types.rs
+++ b/gix-prompt/src/types.rs
@@ -1,23 +1,5 @@
 use std::path::PathBuf;
 
-/// The error returned by [ask()][crate::ask()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Terminal prompts are disabled")]
-    Disabled,
-    #[error("The current platform has no implementation for prompting in the terminal")]
-    UnsupportedPlatform,
-    #[error(
-        "Failed to open terminal at {:?} for writing prompt, or to write it",
-        crate::unix::TTY_PATH
-    )]
-    TtyIo(#[from] std::io::Error),
-    #[cfg(unix)]
-    #[error("Failed to obtain or set terminal configuration")]
-    TerminalConfiguration(#[from] rustix::io::Errno),
-}
-
 /// The way the user is prompted.
 #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
 pub enum Mode {
diff --git a/gix-prompt/src/unix.rs b/gix-prompt/src/unix.rs
index 5026f481231..5942bf4f5ea 100644
--- a/gix-prompt/src/unix.rs
+++ b/gix-prompt/src/unix.rs
@@ -9,28 +9,41 @@ pub(crate) mod imp {
         io::{BufRead, Read, Write},
     };
 
+    use gix_error::{ErrorExt, ExnMessageResult, Message, ResultExt, message};
     use parking_lot::{Mutex, RawMutex, const_mutex, lock_api::MutexGuard};
     use rustix::termios::{self, Termios};
 
-    use crate::{Error, Mode, Options, unix::TTY_PATH};
+    use crate::{Mode, Options, unix::TTY_PATH};
 
     static TERM_STATE: Mutex<Option<Termios>> = const_mutex(None);
 
+    fn tty_io() -> Message {
+        gix_error::message!("Failed to open terminal at {TTY_PATH:?} for writing prompt, or to write it")
+    }
+
+    fn terminal_configuration() -> Message {
+        message("Failed to obtain or set terminal configuration")
+    }
+
     /// Ask the user given a `prompt`, returning the result.
-    pub(crate) fn ask(prompt: &str, Options { mode, .. }: &Options) -> Result<String, Error> {
+    pub(crate) fn ask(prompt: &str, Options { mode, .. }: &Options) -> ExnMessageResult<String> {
         match mode {
-            Mode::Disable => Err(Error::Disabled),
+            Mode::Disable => Err(message("Terminal prompts are disabled").raise()),
             Mode::Hidden => {
                 let state = TERM_STATE.lock();
                 let mut in_out = save_term_state_and_disable_echo(
                     state,
-                    std::fs::OpenOptions::new().write(true).read(true).open(TTY_PATH)?,
+                    std::fs::OpenOptions::new()
+                        .write(true)
+                        .read(true)
+                        .open(TTY_PATH)
+                        .or_raise(tty_io)?,
                 )?;
-                in_out.write_all(prompt.as_bytes())?;
+                in_out.write_all(prompt.as_bytes()).or_raise(tty_io)?;
 
                 let mut buf_read = std::io::BufReader::with_capacity(64, in_out);
                 let mut out = String::with_capacity(64);
-                buf_read.read_line(&mut out)?;
+                buf_read.read_line(&mut out).or_raise(tty_io)?;
 
                 out.pop();
                 if out.ends_with('\r') {
@@ -40,12 +53,16 @@ pub(crate) mod imp {
                 Ok(out)
             }
             Mode::Visible => {
-                let mut in_out = std::fs::OpenOptions::new().write(true).read(true).open(TTY_PATH)?;
-                in_out.write_all(prompt.as_bytes())?;
+                let mut in_out = std::fs::OpenOptions::new()
+                    .write(true)
+                    .read(true)
+                    .open(TTY_PATH)
+                    .or_raise(tty_io)?;
+                in_out.write_all(prompt.as_bytes()).or_raise(tty_io)?;
 
                 let mut buf_read = std::io::BufReader::with_capacity(64, in_out);
                 let mut out = String::with_capacity(64);
-                buf_read.read_line(&mut out)?;
+                buf_read.read_line(&mut out).or_raise(tty_io)?;
                 Ok(out.trim_end().to_owned())
             }
         }
@@ -86,9 +103,9 @@ pub(crate) mod imp {
     }
 
     impl RestoreTerminalStateOnDrop<'_> {
-        fn restore_term_state(mut self) -> Result<(), Error> {
+        fn restore_term_state(mut self) -> ExnMessageResult {
             let state = self.state.take().expect("BUG: we exist only if something is saved");
-            termios::tcsetattr(&self.fd, termios::OptionalActions::Flush, &state)?;
+            termios::tcsetattr(&self.fd, termios::OptionalActions::Flush, &state).or_raise(terminal_configuration)?;
             Ok(())
         }
     }
@@ -104,19 +121,19 @@ pub(crate) mod imp {
     fn save_term_state_and_disable_echo(
         mut state: TermiosGuard<'_>,
         fd: File,
-    ) -> Result<RestoreTerminalStateOnDrop<'_>, Error> {
+    ) -> ExnMessageResult<RestoreTerminalStateOnDrop<'_>> {
         assert!(
             state.is_none(),
             "BUG: recursive calls are not possible and we restore afterwards"
         );
 
-        let prev = termios::tcgetattr(&fd)?;
+        let prev = termios::tcgetattr(&fd).or_raise(terminal_configuration)?;
         let mut new = prev.clone();
         *state = prev.into();
 
         new.local_modes &= !termios::LocalModes::ECHO;
         new.local_modes |= termios::LocalModes::ECHONL;
-        termios::tcsetattr(&fd, termios::OptionalActions::Flush, &new)?;
+        termios::tcsetattr(&fd, termios::OptionalActions::Flush, &new).or_raise(terminal_configuration)?;
 
         Ok(RestoreTerminalStateOnDrop { fd, state })
     }
diff --git a/gix-prompt/tests/prompt.rs b/gix-prompt/tests/prompt.rs
index 0269a18bf94..bf76c80a8f8 100644
--- a/gix-prompt/tests/prompt.rs
+++ b/gix-prompt/tests/prompt.rs
@@ -4,6 +4,25 @@ mod options;
 mod ask {
     use gix_testtools::bstr::ByteSlice;
 
+    #[test]
+    #[cfg(unix)]
+    fn disabled_is_a_message_without_a_source() {
+        let err = gix_prompt::ask(
+            "ignored",
+            &gix_prompt::Options {
+                mode: gix_prompt::Mode::Disable,
+                askpass: None,
+            },
+        )
+        .expect_err("terminal prompting is disabled");
+        insta::assert_debug_snapshot!(err.error(), "disabled is a message without a source", @r#"
+        Message {
+            message: "Terminal prompts are disabled",
+        }
+        "#);
+        assert_eq!(err.iter().count(), 1, "there is no underlying operation error");
+    }
+
     /// Evaluates Cargo's target directory for this project at runtime to adjust for the concrete
     /// execution environment. This is necessary because certain environment variables and
     /// configuration options can change its location (e.g. CARGO_TARGET_DIR).
@@ -54,7 +73,19 @@ mod ask {
     #[test]
     fn askpass_only() -> gix_testtools::Result {
         let mut cmd = std::process::Command::new(env!("CARGO"));
-        cmd.args(["build", "--example", "use-askpass", "--example", "askpass"]);
+        cmd.args([
+            "build",
+            "-p",
+            "gix-prompt",
+            "-p",
+            "gix-hash",
+            "--features",
+            "sha1",
+            "--example",
+            "use-askpass",
+            "--example",
+            "askpass",
+        ]);
         assert!(
             cmd.status().expect("Cargo can build prompt examples").success(),
             "prompt examples must build successfully before they run"
@@ -71,7 +102,17 @@ mod ask {
     #[test]
     fn username_password() -> gix_testtools::Result {
         let mut cmd = std::process::Command::new(env!("CARGO"));
-        cmd.args(["build", "--example", "credentials"]);
+        cmd.args([
+            "build",
+            "-p",
+            "gix-prompt",
+            "-p",
+            "gix-hash",
+            "--features",
+            "sha1",
+            "--example",
+            "credentials",
+        ]);
         assert!(
             cmd.status().expect("Cargo can build prompt examples").success(),
             "prompt examples must build successfully before they run"
diff --git a/gix-protocol/Cargo.toml b/gix-protocol/Cargo.toml
index e0c2de19e89..2188e153e63 100644
--- a/gix-protocol/Cargo.toml
+++ b/gix-protocol/Cargo.toml
@@ -72,6 +72,7 @@ path = "tests/async-protocol.rs"
 required-features = ["async-client"]
 
 [dependencies]
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-features = { version = "^0.49.1", path = "../gix-features", features = [
     "progress",
 ] }
@@ -91,7 +92,6 @@ gix-credentials = { version = "^0.40.0", path = "../gix-credentials", optional =
 gix-refspec = { version = "^0.45.1", path = "../gix-refspec", optional = true }
 gix-lock = { version = "^24.0.0", path = "../gix-lock", optional = true }
 
-thiserror = "2.0.18"
 nonempty = "0.12.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = [
     "derive",
@@ -109,6 +109,8 @@ futures-lite = { version = "2.1.0", optional = true }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
 async-std = { version = "1.9.0", features = ["attributes"] }
 gix-packetline = { path = "../gix-packetline", version = "^0.22.2" }
 gix-protocol = { path = "../gix-protocol", features = ["sha1"] }
diff --git a/gix-protocol/src/command.rs b/gix-protocol/src/command.rs
index ab128e0a04e..daee0f19263 100644
--- a/gix-protocol/src/command.rs
+++ b/gix-protocol/src/command.rs
@@ -17,6 +17,7 @@ impl Command {
 #[cfg(any(test, feature = "async-client", feature = "blocking-client"))]
 mod with_io {
     use bstr::{BString, ByteSlice};
+    use gix_error::ExnMessageResult;
     use gix_transport::client::Capabilities;
 
     use crate::{Command, command::Feature};
@@ -175,17 +176,17 @@ mod with_io {
             server: &Capabilities,
             arguments: &[BString],
             features: &[Feature],
-        ) -> Result<(), validate_argument_prefixes::Error> {
-            use validate_argument_prefixes::Error;
+        ) -> ExnMessageResult {
             let allowed = self.all_argument_prefixes();
             for arg in arguments {
                 if allowed.iter().any(|allowed| arg.starts_with(allowed.as_bytes())) {
                     continue;
                 }
-                return Err(Error::UnsupportedArgument {
-                    command: self.as_str(),
-                    argument: arg.clone(),
-                });
+                return Err(gix_error::validation(format!(
+                    "{}: argument {arg} is not known or allowed",
+                    self.as_str()
+                ))
+                .into());
             }
             match version {
                 gix_transport::Protocol::V0 | gix_transport::Protocol::V1 => {
@@ -196,10 +197,11 @@ mod with_io {
                         {
                             continue;
                         }
-                        return Err(Error::UnsupportedCapability {
-                            command: self.as_str(),
-                            feature: feature.to_string(),
-                        });
+                        return Err(gix_error::validation(format!(
+                            "{}: capability {feature} is not supported",
+                            self.as_str()
+                        ))
+                        .into());
                     }
                 }
                 gix_transport::Protocol::V2 => {
@@ -220,10 +222,11 @@ mod with_io {
                         match *feature {
                             "agent" | "object-format" => {}
                             _ => {
-                                return Err(Error::UnsupportedCapability {
-                                    command: self.as_str(),
-                                    feature: feature.to_string(),
-                                });
+                                return Err(gix_error::validation(format!(
+                                    "{}: capability {feature} is not supported",
+                                    self.as_str()
+                                ))
+                                .into());
                             }
                         }
                     }
@@ -232,21 +235,4 @@ mod with_io {
             Ok(())
         }
     }
-
-    ///
-    pub mod validate_argument_prefixes {
-        use bstr::BString;
-
-        /// The error returned by [Command::validate_argument_prefixes()](super::Command::validate_argument_prefixes()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("{command}: argument {argument} is not known or allowed")]
-            UnsupportedArgument { command: &'static str, argument: BString },
-            #[error("{command}: capability {feature} is not supported")]
-            UnsupportedCapability { command: &'static str, feature: String },
-        }
-    }
 }
-#[cfg(any(test, feature = "async-client", feature = "blocking-client"))]
-pub use with_io::validate_argument_prefixes;
diff --git a/gix-protocol/src/fetch/error.rs b/gix-protocol/src/fetch/error.rs
deleted file mode 100644
index 5c1416aed4e..00000000000
--- a/gix-protocol/src/fetch/error.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-/// The error returned by [`fetch()`](crate::fetch()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not decode server reply")]
-    FetchResponse(#[from] crate::fetch::response::Error),
-    #[error(transparent)]
-    Negotiate(#[from] crate::fetch::negotiate::Error),
-    #[error(transparent)]
-    Client(#[from] crate::transport::client::Error),
-    #[error("Server lack feature {feature:?}: {description}")]
-    MissingServerFeature {
-        feature: &'static str,
-        description: &'static str,
-    },
-    #[error("Could not write 'shallow' file to incorporate remote updates after fetching")]
-    WriteShallowFile(#[from] gix_shallow::write::Error),
-    #[error("Could not read 'shallow' file to send current shallow boundary")]
-    ReadShallowFile(#[from] gix_shallow::read::Error),
-    #[error("'shallow' file could not be locked in preparation for writing changes")]
-    LockShallowFile(#[source] std::io::Error),
-    #[error("Receiving objects from shallow remotes is prohibited due to the value of `clone.rejectShallow`")]
-    RejectShallowRemote,
-    #[error("Failed to consume the pack sent by the remote")]
-    ConsumePack(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error("Failed to read remaining bytes in stream")]
-    ReadRemainingBytes(#[source] std::io::Error),
-}
-
-impl crate::transport::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::FetchResponse(err) => err.is_spurious(),
-            Error::Client(err) => err.is_spurious(),
-            _ => false,
-        }
-    }
-}
diff --git a/gix-protocol/src/fetch/function.rs b/gix-protocol/src/fetch/function.rs
index 70ebf7a7d75..a3e57f048b0 100644
--- a/gix-protocol/src/fetch/function.rs
+++ b/gix-protocol/src/fetch/function.rs
@@ -3,10 +3,11 @@ use std::{
     sync::atomic::{AtomicBool, Ordering},
 };
 
+use gix_error::{Class, ClassificationMarker, ErrorExt, ExnResult, ResultExt, message};
 use gix_features::progress::DynNestedProgress;
 
 use crate::fetch::{
-    Arguments, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags, negotiate,
+    Arguments, Context, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags, negotiate,
 };
 #[crate::bisync::only_async]
 use crate::transport::client::async_io::{ExtendedBufRead, HandleProgress, Transport};
@@ -36,9 +37,9 @@ use crate::transport::client::blocking_io::{ExtendedBufRead, HandleProgress, Tra
 /// Return `Ok(None)` if there was nothing to do because all remote refs are at the same state as they are locally,
 /// or there was nothing wanted, or `Ok(Some(outcome))` to inform about all the changes that were made.
 #[crate::bisync::bisync]
-pub async fn fetch<P, T, E>(
+pub async fn fetch<P, T>(
     negotiate: &mut impl Negotiate,
-    consume_pack: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> Result<bool, E>,
+    consume_pack: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> ExnResult<bool>,
     mut progress: P,
     should_interrupt: &AtomicBool,
     Context {
@@ -53,12 +54,11 @@ pub async fn fetch<P, T, E>(
         tags,
         reject_shallow_remote,
     }: Options<'_>,
-) -> Result<Option<Outcome>, Error>
+) -> ExnResult<Option<Outcome>>
 where
     P: gix_features::progress::NestedProgress,
     P::SubProgress: 'static,
     T: Transport,
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
 {
     let _span = gix_trace::coarse!("gix_protocol::fetch()");
     let v1_shallow_updates = handshake.v1_shallow_updates.take();
@@ -76,12 +76,10 @@ where
     let mut arguments = Arguments::new(protocol_version, fetch_features, trace_packetlines);
     if matches!(tags, Tags::Included) {
         if !arguments.can_use_include_tag() {
-            return Err(Error::MissingServerFeature {
-                    feature: "include-tag",
-                    description:
-                    // NOTE: if this is an issue, we could probably do what's proposed here.
-                    "To make this work we would have to implement another pass to fetch attached tags separately",
-                });
+            return Err(gix_error::validation(
+                "Server lack feature \"include-tag\": To make this work we would have to implement another pass to fetch attached tags separately",
+            )
+            .raise_erased());
         }
         arguments.use_include_tag();
     }
@@ -91,7 +89,9 @@ where
         "negotiate",
         protocol_version = handshake.server_protocol_version as usize
     );
-    let action = negotiate.mark_complete_and_common_ref()?;
+    let action = negotiate
+        .mark_complete_and_common_ref()
+        .or_raise_erased(|| message("Failed to prepare fetch negotiation"))?;
     let mut previous_response = None::<crate::fetch::Response>;
     match &action {
         negotiate::Action::NoChange | negotiate::Action::SkipToRefUpdate => Ok(None),
@@ -109,26 +109,31 @@ where
                 progress.step();
                 progress.set_name(format!("negotiate (round {})", rounds.len() + 1));
                 if should_interrupt.load(Ordering::Relaxed) {
-                    return Err(Error::Negotiate(negotiate::Error::NegotiationFailed {
-                        rounds: rounds.len(),
-                    }));
+                    return Err(ClassificationMarker::with_source(
+                        Class::Retryable,
+                        gix_error::message!(
+                            "We were unable to figure out what objects the server should send after {} round(s)",
+                            rounds.len()
+                        ),
+                    )
+                    .raise_erased());
                 }
 
-                let is_done = match negotiate.one_round(&mut state, &mut arguments, previous_response.as_ref()) {
-                    Ok((round, is_done)) => {
-                        rounds.push(round);
-                        is_done
-                    }
-                    Err(err) => {
-                        return Err(err.into());
-                    }
-                };
-                let mut reader = arguments.send(transport, is_done).await?;
+                let (round, is_done) = negotiate
+                    .one_round(&mut state, &mut arguments, previous_response.as_ref())
+                    .or_raise_erased(|| message("Failed to negotiate objects with the server"))?;
+                rounds.push(round);
+                let mut reader = arguments
+                    .send(transport, is_done)
+                    .await
+                    .or_raise_erased(|| message("Failed to send fetch arguments"))?;
                 if sideband_all {
                     setup_remote_progress(&mut progress, &mut reader, should_interrupt);
                 }
                 let response =
-                    crate::fetch::Response::from_line_reader(protocol_version, &mut reader, is_done, !is_done).await?;
+                    crate::fetch::Response::from_line_reader(protocol_version, &mut reader, is_done, !is_done)
+                        .await
+                        .or_raise_erased(|| message("Could not decode server reply"))?;
                 let has_pack = response.has_pack();
                 previous_response = Some(response);
                 if has_pack {
@@ -147,7 +152,10 @@ where
             previous_response.append_v1_shallow_updates(v1_shallow_updates);
             if !previous_response.shallow_updates().is_empty() && shallow_lock.is_none() {
                 if reject_shallow_remote {
-                    return Err(Error::RejectShallowRemote);
+                    return Err(gix_error::validation(
+                        "Receiving objects from shallow remotes is prohibited due to the value of `clone.rejectShallow`",
+                    )
+                    .raise_erased());
                 }
                 shallow_lock = acquire_shallow_lock(&shallow_file).map(Some)?;
             }
@@ -159,7 +167,9 @@ where
                 // Assure the final flush packet is consumed.
                 let has_read_to_end = reader.stopped_at().is_some();
                 if !has_read_to_end {
-                    read_remaining(&mut reader).await.map_err(Error::ReadRemainingBytes)?;
+                    read_remaining(&mut reader)
+                        .await
+                        .or_raise_erased(|| message("Failed to read remaining bytes in stream"))?;
                 }
             }
             drop(reader);
@@ -167,7 +177,10 @@ where
             if let Some(shallow_lock) = shallow_lock
                 && !previous_response.shallow_updates().is_empty()
             {
-                gix_shallow::write(shallow_lock, shallow_commits, previous_response.shallow_updates())?;
+                gix_shallow::write(shallow_lock, shallow_commits, previous_response.shallow_updates())
+                    .or_raise_erased(|| {
+                        message("Could not write 'shallow' file to incorporate remote updates after fetching")
+                    })?;
             }
             Ok(Some(Outcome {
                 last_response: previous_response,
@@ -178,35 +191,33 @@ where
 }
 
 #[crate::bisync::only_async]
-fn consume_received_pack<R, E>(
+fn consume_received_pack<R>(
     reader: R,
-    consume: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> Result<bool, E>,
+    consume: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> ExnResult<bool>,
     progress: &mut dyn DynNestedProgress,
     should_interrupt: &AtomicBool,
-) -> Result<(R, bool), Error>
+) -> ExnResult<(R, bool)>
 where
     R: crate::futures_io::AsyncBufRead + Unpin,
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
 {
     let mut reader = crate::futures_lite::io::BlockOn::new(reader);
-    let may_read_to_end =
-        consume(&mut reader, progress, should_interrupt).map_err(|err| Error::ConsumePack(err.into()))?;
+    let may_read_to_end = consume(&mut reader, progress, should_interrupt)
+        .or_raise_erased(|| message("Failed to consume the pack sent by the remote"))?;
     Ok((reader.into_inner(), may_read_to_end))
 }
 
 #[crate::bisync::only_sync]
-fn consume_received_pack<R, E>(
+fn consume_received_pack<R>(
     mut reader: R,
-    consume: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> Result<bool, E>,
+    consume: impl FnOnce(&mut dyn std::io::BufRead, &mut dyn DynNestedProgress, &AtomicBool) -> ExnResult<bool>,
     progress: &mut dyn DynNestedProgress,
     should_interrupt: &AtomicBool,
-) -> Result<(R, bool), Error>
+) -> ExnResult<(R, bool)>
 where
     R: std::io::BufRead,
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
 {
-    let may_read_to_end =
-        consume(&mut reader, progress, should_interrupt).map_err(|err| Error::ConsumePack(err.into()))?;
+    let may_read_to_end = consume(&mut reader, progress, should_interrupt)
+        .or_raise_erased(|| message("Failed to consume the pack sent by the remote"))?;
     Ok((reader, may_read_to_end))
 }
 
@@ -222,26 +233,27 @@ fn read_remaining(reader: &mut impl std::io::Read) -> std::io::Result<()> {
     std::io::copy(reader, &mut std::io::sink()).map(|_| ())
 }
 
-fn acquire_shallow_lock(shallow_file: &Path) -> Result<gix_lock::File, Error> {
+fn acquire_shallow_lock(shallow_file: &Path) -> ExnResult<gix_lock::File> {
     gix_lock::File::acquire_to_update_resource(shallow_file, gix_lock::acquire::Fail::Immediately, None)
-        .map_err(|err| Error::LockShallowFile(std::io::Error::other(err.into_error())))
+        .or_raise_erased(|| message("'shallow' file could not be locked in preparation for writing changes"))
 }
 
 fn add_shallow_args(
     args: &mut Arguments,
     shallow: &Shallow,
     shallow_file: &std::path::Path,
-) -> Result<(Option<nonempty::NonEmpty<gix_hash::ObjectId>>, Option<gix_lock::File>), Error> {
+) -> ExnResult<(Option<nonempty::NonEmpty<gix_hash::ObjectId>>, Option<gix_lock::File>)> {
     let expect_change = *shallow != Shallow::NoChange;
     let shallow_lock = expect_change.then(|| acquire_shallow_lock(shallow_file)).transpose()?;
 
-    let shallow_commits = gix_shallow::read(shallow_file)?;
+    let shallow_commits = gix_shallow::read(shallow_file)
+        .or_raise_erased(|| message("Could not read 'shallow' file to send current shallow boundary"))?;
     if (shallow_commits.is_some() || expect_change) && !args.can_use_shallow() {
         // NOTE: if this is an issue, we can always unshallow the repo ourselves.
-        return Err(Error::MissingServerFeature {
-            feature: "shallow",
-            description: "shallow clones need server support to remain shallow, otherwise bigger than expected packs are sent effectively unshallowing the repository",
-        });
+        return Err(gix_error::validation(
+            "Server lack feature \"shallow\": shallow clones need server support to remain shallow, otherwise bigger than expected packs are sent effectively unshallowing the repository",
+        )
+        .raise_erased());
     }
     if let Some(shallow_commits) = &shallow_commits {
         for commit in shallow_commits.iter() {
diff --git a/gix-protocol/src/fetch/mod.rs b/gix-protocol/src/fetch/mod.rs
index 1f8eb8445eb..f0af72722d8 100644
--- a/gix-protocol/src/fetch/mod.rs
+++ b/gix-protocol/src/fetch/mod.rs
@@ -21,12 +21,6 @@
 mod arguments;
 pub use arguments::Arguments;
 
-#[cfg(any(feature = "blocking-client", feature = "async-client"))]
-#[cfg(feature = "fetch")]
-mod error;
-#[cfg(any(feature = "blocking-client", feature = "async-client"))]
-#[cfg(feature = "fetch")]
-pub use error::Error;
 ///
 pub mod response;
 
diff --git a/gix-protocol/src/fetch/negotiate.rs b/gix-protocol/src/fetch/negotiate.rs
index 2d356f03d95..66c4b0dc309 100644
--- a/gix-protocol/src/fetch/negotiate.rs
+++ b/gix-protocol/src/fetch/negotiate.rs
@@ -8,6 +8,7 @@
 use std::borrow::Cow;
 
 use gix_date::SecondsSinceUnixEpoch;
+use gix_error::{ExnMessageResult, ExnResult, ResultExt, message};
 use gix_negotiate::Flags;
 use gix_ref::file::ReferenceExt;
 
@@ -15,26 +16,6 @@ use crate::fetch::{RefMap, Shallow, Tags, refmap};
 
 type Queue = gix_revwalk::PriorityQueue<SecondsSinceUnixEpoch, gix_hash::ObjectId>;
 
-/// The error returned during [`one_round()`] or [`mark_complete_and_common_ref()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("We were unable to figure out what objects the server should send after {rounds} round(s)")]
-    NegotiationFailed { rounds: usize },
-    #[error(transparent)]
-    LookupCommitInGraph(#[from] gix_revwalk::graph::get_or_insert_default::Error),
-    #[error(transparent)]
-    OpenPackedRefsBuffer(#[from] gix_ref::packed::buffer::open::Error),
-    #[error(transparent)]
-    IO(#[from] std::io::Error),
-    #[error(transparent)]
-    InitRefIter(#[from] gix_ref::file::iter::loose_then_packed::Error),
-    #[error(transparent)]
-    PeelToId(#[from] gix_ref::peel::to_id::Error),
-    #[error(transparent)]
-    AlternateRefsAndObjects(Box<dyn std::error::Error + Send + Sync + 'static>),
-}
-
 /// Determines what should be done after [preparing the commit-graph for negotiation](mark_complete_and_common_ref).
 #[must_use]
 #[derive(Debug, Clone)]
@@ -118,18 +99,17 @@ pub struct Round {
 ///     - `f(mapping) -> bool` returns `true` if the given mapping should not participate in change tracking.
 ///     - [`make_refmapping_ignore_predicate()`] is a typical implementation for this.
 #[expect(clippy::too_many_arguments)]
-pub fn mark_complete_and_common_ref<Out, F, E>(
+pub fn mark_complete_and_common_ref<Out, F>(
     objects: &(impl gix_object::Find + gix_object::FindHeader + gix_object::Exists),
     refs: &gix_ref::file::Store,
-    alternates: impl FnOnce() -> Result<Out, E>,
+    alternates: impl FnOnce() -> ExnResult<Out>,
     negotiator: &mut dyn gix_negotiate::Negotiator,
     graph: &mut gix_negotiate::Graph<'_, '_>,
     ref_map: &RefMap,
     shallow: &Shallow,
     mapping_is_ignored: impl Fn(&refmap::Mapping) -> bool,
-) -> Result<Action, Error>
+) -> ExnMessageResult<Action>
 where
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
     Out: Iterator<Item = (gix_ref::file::Store, F)>,
     F: gix_object::Find,
 {
@@ -178,7 +158,8 @@ where
 
         if let Some(commit) = want_id
             .and_then(|id| graph.get_or_insert_commit(id.into(), |_| {}).transpose())
-            .transpose()?
+            .transpose()
+            .or_raise(|| message("Could not look up commit in graph"))?
         {
             remote_ref_target_known[mapping_idx] = true;
             cutoff_date = cutoff_date.unwrap_or_default().max(commit.commit_time).into();
@@ -204,7 +185,7 @@ where
     // (`git` is conditional here based on `deepen`, but it doesn't make sense and it's hard to extract from history when that happened).
     let mut queue = Queue::new();
     mark_all_refs_in_repo(refs, objects, graph, &mut queue, Flags::COMPLETE)?;
-    for (alt_refs, alt_objs) in alternates().map_err(|err| Error::AlternateRefsAndObjects(err.into()))? {
+    for (alt_refs, alt_objs) in alternates().or_raise(|| message("Could not obtain alternate refs and objects"))? {
         mark_all_refs_in_repo(&alt_refs, &alt_objs, graph, &mut queue, Flags::COMPLETE)?;
     }
     // Keep track of the tips, which happen to be on our queue right, before we traverse the graph with cutoff.
@@ -217,7 +198,7 @@ where
         Cow::Borrowed(&queue)
     };
 
-    gix_trace::detail!("mark known_common").into_scope(|| -> Result<_, Error> {
+    gix_trace::detail!("mark known_common").into_scope(|| -> ExnMessageResult<_> {
         // mark all complete advertised refs as common refs.
         for mapping in ref_map
             .mappings
@@ -232,7 +213,9 @@ where
                 .filter(|(c, _)| c.data.flags.contains(Flags::COMPLETE))
                 .map(|(_, id)| id)
             {
-                negotiator.known_common(common_id.into(), graph)?;
+                negotiator
+                    .known_common(common_id.into(), graph)
+                    .or_raise(|| message("Could not mark common commit"))?;
             }
         }
         Ok(())
@@ -240,9 +223,11 @@ where
 
     // As negotiators currently may rely on getting `known_common` calls first and tips after, we adhere to that which is the only
     // reason we cached the set of tips.
-    gix_trace::detail!("mark tips", num_tips = tips.len()).into_scope(|| -> Result<_, Error> {
+    gix_trace::detail!("mark tips", num_tips = tips.len()).into_scope(|| -> ExnMessageResult<_> {
         for tip in tips.iter_unordered() {
-            negotiator.add_tip(*tip, graph)?;
+            negotiator
+                .add_tip(*tip, graph)
+                .or_raise(|| message("Could not add negotiation tip"))?;
         }
         Ok(())
     })?;
@@ -339,7 +324,7 @@ fn mark_recent_complete_commits(
     queue: &mut Queue,
     graph: &mut gix_negotiate::Graph<'_, '_>,
     cutoff: SecondsSinceUnixEpoch,
-) -> Result<(), Error> {
+) -> ExnMessageResult {
     let _span = gix_trace::detail!("mark_recent_complete", queue_len = queue.len());
     while let Some(id) = queue
         .peek()
@@ -353,7 +338,8 @@ fn mark_recent_complete_commits(
                 .get_or_insert_commit(parent_id, |md| {
                     was_complete = md.flags.contains(Flags::COMPLETE);
                     md.flags |= Flags::COMPLETE;
-                })?
+                })
+                .or_raise(|| message("Could not look up commit in graph"))?
                 .filter(|_| !was_complete)
             {
                 queue.insert(parent.commit_time, parent_id);
@@ -369,24 +355,30 @@ fn mark_all_refs_in_repo(
     graph: &mut gix_negotiate::Graph<'_, '_>,
     queue: &mut Queue,
     mark: Flags,
-) -> Result<(), Error> {
+) -> ExnMessageResult {
     let _span = gix_trace::detail!("mark_all_refs");
-    for local_ref in store.iter()?.all()? {
-        let mut local_ref = local_ref?;
-        let id =
-            match local_ref.peel_to_id_packed(store, objects, store.cached_packed_buffer()?.as_ref().map(|b| &***b)) {
-                Ok(id) => id,
-                Err(gix_ref::peel::to_id::Error::FollowToObject(gix_ref::peel::to_object::Error::Follow(
-                    gix_ref::file::find::existing::Error::NotFound { .. },
-                ))) => continue,
-                Err(err) => return Err(err.into()),
-            };
+    for local_ref in store
+        .iter()
+        .or_raise(|| message("Could not open packed refs"))?
+        .all()
+        .or_raise(|| message("Could not initialize ref iterator"))?
+    {
+        let mut local_ref = local_ref.or_raise(|| message("Could not read reference"))?;
+        let packed = store
+            .cached_packed_buffer()
+            .or_raise(|| message("Could not open packed refs"))?;
+        let id = match local_ref.peel_to_id_packed(store, objects, packed.as_ref().map(|b| &***b)) {
+            Ok(id) => id,
+            Err(err) if err.downcast_any_ref::<gix_ref::file::find::NotFound>().is_some() => continue,
+            Err(err) => return Err(err).or_raise(|| message("Could not peel reference to ID")),
+        };
         let mut is_complete = false;
         if let Some(commit) = graph
             .get_or_insert_commit(id, |md| {
                 is_complete = md.flags.contains(Flags::COMPLETE);
                 md.flags |= mark;
-            })?
+            })
+            .or_raise(|| message("Could not look up commit in graph"))?
             .filter(|_| !is_complete)
         {
             queue.insert(commit.commit_time, id);
@@ -456,7 +448,7 @@ pub fn one_round(
     state: &mut one_round::State,
     arguments: &mut crate::fetch::Arguments,
     previous_response: Option<&crate::fetch::Response>,
-) -> Result<(Round, bool), Error> {
+) -> ExnMessageResult<(Round, bool)> {
     let mut seen_ack = false;
     if let Some(response) = previous_response {
         use crate::fetch::response::Acknowledgement;
@@ -464,7 +456,9 @@ pub fn one_round(
             match ack {
                 Acknowledgement::Common(id) => {
                     seen_ack = true;
-                    negotiator.in_common_with_remote(*id, graph)?;
+                    negotiator
+                        .in_common_with_remote(*id, graph)
+                        .or_raise(|| message("Could not mark remote-common commit"))?;
                     if let Some(common) = &mut state.common_commits {
                         common.push(*id);
                     }
@@ -488,7 +482,7 @@ pub fn one_round(
 
     let mut haves_added = 0;
     for have_id in (0..state.haves_to_send).map_while(|_| negotiator.next_have(graph)) {
-        arguments.have(have_id?);
+        arguments.have(have_id.or_raise(|| message("Could not obtain next negotiation commit"))?);
         haves_added += 1;
     }
     // Note that we are differing from the git implementation, which does an extra-round of with no new haves sent at all.
diff --git a/gix-protocol/src/fetch/refmap/init.rs b/gix-protocol/src/fetch/refmap/init.rs
index b006a894bd2..c6a9ac7c33e 100644
--- a/gix-protocol/src/fetch/refmap/init.rs
+++ b/gix-protocol/src/fetch/refmap/init.rs
@@ -1,4 +1,6 @@
-use bstr::{BString, ByteSlice};
+use bstr::ByteSlice;
+use gix_error::ExnResult;
+use gix_error::{ErrorExt, ResultExt, message};
 use gix_transport::client::Capabilities;
 
 use crate::{
@@ -9,18 +11,6 @@ use crate::{
     handshake::Ref,
 };
 
-/// The error returned by [`crate::Handshake::prepare_lsrefs_or_extract_refmap()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("The object format {format:?} as used by the remote is unsupported")]
-    UnknownObjectFormat { format: BString },
-    #[error(transparent)]
-    MappingValidation(#[from] gix_refspec::match_group::validate::Error),
-    #[error(transparent)]
-    ListRefs(#[from] crate::ls_refs::Error),
-}
-
 /// For use in [`RefMap::from_refs()`].
 #[derive(Debug, Clone)]
 pub struct Context {
@@ -44,7 +34,8 @@ impl Context {
 impl RefMap {
     /// Create a ref-map from already obtained `remote_refs`. Use `context` to pass in refspecs.
     /// `capabilities` are used to determine the object format.
-    pub fn from_refs(remote_refs: Vec<Ref>, capabilities: &Capabilities, context: Context) -> Result<RefMap, Error> {
+    /// Invalid or unsupported object formats include their bytes as `input` [metadata](gix_error::Exn::metadata()).
+    pub fn from_refs(remote_refs: Vec<Ref>, capabilities: &Capabilities, context: Context) -> ExnResult<RefMap> {
         let all_refspecs = context.aggregate_refspecs();
         let Context {
             fetch_refspecs,
@@ -63,7 +54,8 @@ impl RefMap {
                     object,
                 }
             }))
-            .validated()?;
+            .validated()
+            .or_raise_erased(|| message("Failed to validate mappings between remote and local references"))?;
 
         let mappings = res.mappings;
         let mappings = mappings
@@ -103,16 +95,21 @@ impl RefMap {
 /// When the capability is absent, the server is implicitly speaking Sha1 - older servers
 /// don't advertise it at all, and even newer ones may omit it for empty repositories.
 /// In builds whose `gix-hash` lacks the `sha1` feature, it's treated as unknown object format error.
-fn extract_object_hash(capabilities: &Capabilities) -> Result<gix_hash::Kind, Error> {
+/// Errors include the object format bytes as `input` [metadata](gix_error::Exn::metadata()).
+fn extract_object_hash(capabilities: &Capabilities) -> ExnResult<gix_hash::Kind> {
     let object_format = match capabilities.capability("object-format").and_then(|c| c.value()) {
-        Some(object_format) => object_format.to_str().map_err(|_| Error::UnknownObjectFormat {
-            format: object_format.into(),
+        Some(object_format) => object_format.to_str().or_raise_erased(|| {
+            gix_error::validation("The object format used by the remote isn't valid UTF-8")
+                .with("input", object_format.as_bytes())
         })?,
         None => "sha1",
     };
-    object_format
-        .parse::<gix_hash::Kind>()
-        .map_err(|_| Error::UnknownObjectFormat {
-            format: object_format.into(),
-        })
+    match object_format.parse::<gix_hash::Kind>() {
+        Ok(kind) => Ok(kind),
+        Err(err) => Err(
+            gix_error::validation(format!("The object format used by the remote is unsupported: {err}"))
+                .with("input", object_format.as_bytes())
+                .raise_erased(),
+        ),
+    }
 }
diff --git a/gix-protocol/src/fetch/response/io.rs b/gix-protocol/src/fetch/response/io.rs
index a9d9766cfb8..342bd8f9b7e 100644
--- a/gix-protocol/src/fetch/response/io.rs
+++ b/gix-protocol/src/fetch/response/io.rs
@@ -4,10 +4,11 @@ use std::io;
 use crate::transport::client::async_io::ExtendedBufRead;
 #[crate::bisync::only_sync]
 use crate::transport::client::blocking_io::ExtendedBufRead;
-use gix_transport::{Protocol, client::MessageKind};
+use gix_error::{ErrorExt, ExnResult, message};
+use gix_transport::{Protocol, client, client::MessageKind};
 
 use crate::fetch::{
-    Response, response,
+    Response,
     response::{Acknowledgement, ShallowUpdate, WantedRef, shallow_update_from_line},
 };
 
@@ -16,10 +17,10 @@ async fn parse_v2_section<'a, T>(
     line: &mut String,
     reader: &mut impl ExtendedBufRead<'a>,
     res: &mut Vec<T>,
-    parse: impl Fn(&str) -> Result<T, response::Error>,
-) -> Result<bool, response::Error> {
+    parse: impl Fn(&str) -> ExnResult<T>,
+) -> ExnResult<bool> {
     line.clear();
-    while reader.readline_str(line).await? != 0 {
+    while reader.readline_str(line).await.map_err(read_error)? != 0 {
         res.push(parse(line)?);
         line.clear();
     }
@@ -52,7 +53,7 @@ impl Response {
         reader: &mut impl ExtendedBufRead<'a>,
         client_expects_pack: bool,
         wants_to_negotiate: bool,
-    ) -> Result<Response, response::Error> {
+    ) -> ExnResult<Response> {
         match version {
             Protocol::V0 | Protocol::V1 => {
                 let mut line = String::new();
@@ -70,8 +71,8 @@ impl Response {
                         // to deal with this correctly.
                         // For now this is acceptable, as V2 can be used as a workaround, which also is the default.
                         Some(Err(err)) if err.kind() == io::ErrorKind::UnexpectedEof => break 'lines false,
-                        Some(Err(err)) => return Err(err.into()),
-                        Some(Ok(Err(err))) => return Err(err.into()),
+                        Some(Err(err)) => return Err(read_error(err)),
+                        Some(Ok(Err(err))) => return Err(transport_error(err)),
                         None => {
                             // maybe we saw a shallow flush packet, let's reset and retry
                             debug_assert_eq!(
@@ -79,12 +80,12 @@ impl Response {
                                 Some(MessageKind::Flush),
                                 "If this isn't a flush packet, we don't know what's going on"
                             );
-                            reader.readline_str(&mut line).await?;
+                            reader.readline_str(&mut line).await.map_err(read_error)?;
                             reader.reset(Protocol::V1);
                             match reader.peek_data_line().await {
                                 Some(Ok(Ok(line))) => String::from_utf8_lossy(line),
-                                Some(Err(err)) => return Err(err.into()),
-                                Some(Ok(Err(err))) => return Err(err.into()),
+                                Some(Err(err)) => return Err(read_error(err)),
+                                Some(Ok(Err(err))) => return Err(transport_error(err)),
                                 None => break 'lines false, // EOF
                             }
                         }
@@ -94,7 +95,7 @@ impl Response {
                         break 'lines true;
                     }
                     assert_ne!(
-                        reader.readline_str(&mut line).await?,
+                        reader.readline_str(&mut line).await.map_err(read_error)?,
                         0,
                         "consuming a peeked line works"
                     );
@@ -123,8 +124,8 @@ impl Response {
                 let mut wanted_refs = Vec::<WantedRef>::new();
                 let has_pack = 'section: loop {
                     line.clear();
-                    if reader.readline_str(&mut line).await? == 0 {
-                        return Err(response::Error::Io(io::Error::new(
+                    if reader.readline_str(&mut line).await.map_err(read_error)? == 0 {
+                        return Err(read_error(io::Error::new(
                             io::ErrorKind::UnexpectedEof,
                             "Could not read message headline",
                         )));
@@ -150,7 +151,12 @@ impl Response {
                             // what follows is the packfile itself, which can be read with a sideband enabled reader
                             break 'section true;
                         }
-                        _ => return Err(response::Error::UnknownSectionHeader { header: line }),
+                        _ => {
+                            return Err(
+                                gix_error::corruption(format!("Unknown or unsupported header: {line:?}"))
+                                    .raise_erased(),
+                            );
+                        }
                     }
                 };
                 Ok(Response {
@@ -163,3 +169,64 @@ impl Response {
         }
     }
 }
+
+fn read_error(err: io::Error) -> gix_error::Exn {
+    let err = if err.kind() == io::ErrorKind::Other {
+        match err.into_inner() {
+            Some(err) => match err.downcast::<gix_transport::packetline::read::Error>() {
+                Ok(err) => return (*err).and_raise(message("Failed to read from line reader")).erased(),
+                Err(err) => io::Error::other(err),
+            },
+            None => io::ErrorKind::Other.into(),
+        }
+    } else {
+        err
+    };
+    transport_error(err.into())
+}
+
+fn transport_error(err: client::Error) -> gix_error::Exn {
+    err.and_raise(message("Failed to read from line reader")).erased()
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn line_reader_io_preserves_classification() {
+        let err = super::read_error(std::io::ErrorKind::ConnectionAborted.into()).into_error();
+        insta::assert_debug_snapshot!(err, "connection failures remain retryable while reading packet lines", @"
+        Failed to read from line reader
+        |
+        └─ An IO error occurred when talking to the server
+        |
+        └─ connection aborted
+        ");
+        assert!(
+            err.can_retry_lenient(),
+            "connection failures remain retryable while reading packet lines"
+        );
+        assert!(!err.can_retry(), "connection failures require the lenient policy");
+        assert!(
+            !err.is_retryable(),
+            "wrapping I/O does not add an explicit retry marker"
+        );
+
+        let err = super::read_error(std::io::ErrorKind::OutOfMemory.into()).into_error();
+        insta::assert_debug_snapshot!(err, "memory exhaustion isn't retryable by the conservative policy", @"
+        Failed to read from line reader
+        |
+        └─ An IO error occurred when talking to the server
+        |
+        └─ out of memory
+        ");
+        assert!(
+            !err.can_retry(),
+            "memory exhaustion isn't retryable by the conservative policy"
+        );
+        assert!(err.can_retry_lenient(), "the lenient policy includes memory exhaustion");
+        assert!(
+            err.is_resource_exhausted(),
+            "the allocation failure remains recognizable"
+        );
+    }
+}
diff --git a/gix-protocol/src/fetch/response/mod.rs b/gix-protocol/src/fetch/response/mod.rs
index 61200b4bae4..7956c6efa24 100644
--- a/gix-protocol/src/fetch/response/mod.rs
+++ b/gix-protocol/src/fetch/response/mod.rs
@@ -1,50 +1,12 @@
 use bstr::BString;
-use gix_transport::{Protocol, client};
+use gix_error::ExnResult;
+use gix_error::{ErrorExt, ResultExt};
+use gix_transport::Protocol;
 
 use crate::{command::Feature, fetch::Response};
 
-/// The error returned in the [response module][crate::fetch::response].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to read from line reader")]
-    Io(#[source] std::io::Error),
-    #[error(transparent)]
-    UploadPack(#[from] gix_transport::packetline::read::Error),
-    #[error(transparent)]
-    Transport(#[from] client::Error),
-    #[error("Currently we require feature {feature:?}, which is not supported by the server")]
-    MissingServerCapability { feature: &'static str },
-    #[error("Encountered an unknown line prefix in {line:?}")]
-    UnknownLineType { line: String },
-    #[error("Unknown or unsupported header: {header:?}")]
-    UnknownSectionHeader { header: String },
-}
-
-impl From<std::io::Error> for Error {
-    fn from(err: std::io::Error) -> Self {
-        if err.kind() == std::io::ErrorKind::Other {
-            match err.into_inner() {
-                Some(err) => match err.downcast::<gix_transport::packetline::read::Error>() {
-                    Ok(err) => Error::UploadPack(*err),
-                    Err(err) => Error::Io(std::io::Error::other(err)),
-                },
-                None => Error::Io(std::io::ErrorKind::Other.into()),
-            }
-        } else {
-            Error::Io(err)
-        }
-    }
-}
-
-impl gix_transport::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::Io(err) => err.is_spurious(),
-            Error::Transport(err) => err.is_spurious(),
-            _ => false,
-        }
-    }
+fn unknown_line(line: &str) -> gix_error::Exn {
+    gix_error::corruption(format!("Encountered an unknown line prefix in {line:?}")).raise_erased()
 }
 
 /// An 'ACK' line received from the server.
@@ -72,24 +34,24 @@ pub struct WantedRef {
 }
 
 /// Parse a `ShallowUpdate` from a `line` as received to the server.
-pub fn shallow_update_from_line(line: &str) -> Result<ShallowUpdate, Error> {
+pub fn shallow_update_from_line(line: &str) -> ExnResult<ShallowUpdate> {
     match line.trim_end().split_once(' ') {
         Some((prefix, id)) => {
             let id = gix_hash::ObjectId::from_hex(id.as_bytes())
-                .map_err(|_| Error::UnknownLineType { line: line.to_owned() })?;
+                .or_raise_erased(|| gix_error::corruption(format!("Encountered an unknown line prefix in {line:?}")))?;
             Ok(match prefix {
                 "shallow" => ShallowUpdate::Shallow(id),
                 "unshallow" => ShallowUpdate::Unshallow(id),
-                _ => return Err(Error::UnknownLineType { line: line.to_owned() }),
+                _ => return Err(unknown_line(line)),
             })
         }
-        None => Err(Error::UnknownLineType { line: line.to_owned() }),
+        None => Err(unknown_line(line)),
     }
 }
 
 impl Acknowledgement {
     /// Parse an `Acknowledgement` from a `line` as received to the server.
-    pub fn from_line(line: &str) -> Result<Acknowledgement, Error> {
+    pub fn from_line(line: &str) -> ExnResult<Acknowledgement> {
         let mut tokens = line.trim_end().splitn(3, ' ');
         match (tokens.next(), tokens.next(), tokens.next()) {
             (Some(first), id, description) => Ok(match first {
@@ -97,22 +59,23 @@ impl Acknowledgement {
                 "NAK" => Acknowledgement::Nak,     // V1
                 "ACK" => {
                     let id = match id {
-                        Some(id) => gix_hash::ObjectId::from_hex(id.as_bytes())
-                            .map_err(|_| Error::UnknownLineType { line: line.to_owned() })?,
-                        None => return Err(Error::UnknownLineType { line: line.to_owned() }),
+                        Some(id) => gix_hash::ObjectId::from_hex(id.as_bytes()).or_raise_erased(|| {
+                            gix_error::corruption(format!("Encountered an unknown line prefix in {line:?}"))
+                        })?,
+                        None => return Err(unknown_line(line)),
                     };
                     if let Some(description) = description {
                         match description {
                             "common" => {}
                             "ready" => return Ok(Acknowledgement::Ready),
-                            _ => return Err(Error::UnknownLineType { line: line.to_owned() }),
+                            _ => return Err(unknown_line(line)),
                         }
                     }
                     Acknowledgement::Common(id)
                 }
-                _ => return Err(Error::UnknownLineType { line: line.to_owned() }),
+                _ => return Err(unknown_line(line)),
             }),
-            (None, _, _) => Err(Error::UnknownLineType { line: line.to_owned() }),
+            (None, _, _) => Err(unknown_line(line)),
         }
     }
     /// Returns the hash of the acknowledged object if this instance acknowledges a common one.
@@ -126,14 +89,15 @@ impl Acknowledgement {
 
 impl WantedRef {
     /// Parse a `WantedRef` from a `line` as received from the server.
-    pub fn from_line(line: &str) -> Result<WantedRef, Error> {
+    pub fn from_line(line: &str) -> ExnResult<WantedRef> {
         match line.trim_end().split_once(' ') {
             Some((id, path)) => {
-                let id = gix_hash::ObjectId::from_hex(id.as_bytes())
-                    .map_err(|_| Error::UnknownLineType { line: line.to_owned() })?;
+                let id = gix_hash::ObjectId::from_hex(id.as_bytes()).or_raise_erased(|| {
+                    gix_error::corruption(format!("Encountered an unknown line prefix in {line:?}"))
+                })?;
                 Ok(WantedRef { id, path: path.into() })
             }
-            None => Err(Error::UnknownLineType { line: line.to_owned() }),
+            None => Err(unknown_line(line)),
         }
     }
 }
@@ -149,24 +113,26 @@ impl Response {
     ///
     /// Even though technically any set of features supported by the server could work, we only implement the ones that
     /// make it easy to maintain all versions with a single code base that aims to be and remain maintainable.
-    pub fn check_required_features(version: Protocol, features: &[Feature]) -> Result<(), Error> {
+    pub fn check_required_features(version: Protocol, features: &[Feature]) -> ExnResult {
         match version {
             Protocol::V0 | Protocol::V1 => {
                 let has = |name: &str| features.iter().any(|f| f.0 == name);
                 // Let's focus on V2 standards, and simply not support old servers to keep our code simpler
                 if !has("multi_ack_detailed") {
-                    return Err(Error::MissingServerCapability {
-                        feature: "multi_ack_detailed",
-                    });
+                    return Err(gix_error::validation(
+                        "Currently we require feature \"multi_ack_detailed\", which is not supported by the server",
+                    )
+                    .raise_erased());
                 }
                 // It's easy to NOT do sideband for us, but then again, everyone supports it.
                 // CORRECTION: If sideband is off, it would send the packfile without packet line encoding,
                 // which is nothing we ever want to deal with (despite it being more efficient). In V2, this
                 // is not even an option anymore, sidebands are always present.
                 if !has("side-band") && !has("side-band-64k") {
-                    return Err(Error::MissingServerCapability {
-                        feature: "side-band OR side-band-64k",
-                    });
+                    return Err(gix_error::validation(
+                        "Currently we require feature \"side-band OR side-band-64k\", which is not supported by the server",
+                    )
+                    .raise_erased());
                 }
             }
             Protocol::V2 => {}
diff --git a/gix-protocol/src/fetch/types.rs b/gix-protocol/src/fetch/types.rs
index 718dd33ffdc..421ce4d7221 100644
--- a/gix-protocol/src/fetch/types.rs
+++ b/gix-protocol/src/fetch/types.rs
@@ -40,15 +40,15 @@ pub struct Context<'a, T> {
 #[cfg(feature = "fetch")]
 mod with_fetch {
     use bstr::ByteSlice;
+    use gix_error::{ExnMessageResult, ExnResult};
 
     use crate::fetch::{self, negotiate, refmap};
 
     /// For use in [`fetch`](crate::fetch()).
-    pub struct NegotiateContext<'a, 'b, 'c, Objects, Alternates, AlternatesOut, AlternatesErr, Find>
+    pub struct NegotiateContext<'a, 'b, 'c, Objects, Alternates, AlternatesOut, Find>
     where
         Objects: gix_object::Find + gix_object::FindHeader + gix_object::Exists,
-        Alternates: FnOnce() -> Result<AlternatesOut, AlternatesErr>,
-        AlternatesErr: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
+        Alternates: FnOnce() -> ExnResult<AlternatesOut>,
         AlternatesOut: Iterator<Item = (gix_ref::file::Store, Find)>,
         Find: gix_object::Find,
     {
@@ -70,7 +70,7 @@ mod with_fetch {
     /// Typical implementations use the utilities found in the [`negotiate`] module.
     pub trait Negotiate {
         /// Typically invokes [`negotiate::mark_complete_and_common_ref()`].
-        fn mark_complete_and_common_ref(&mut self) -> Result<negotiate::Action, negotiate::Error>;
+        fn mark_complete_and_common_ref(&mut self) -> ExnMessageResult<negotiate::Action>;
         /// Typically invokes [`negotiate::add_wants()`].
         /// Returns `true` if wants were added, or `false` if the negotiation should be aborted.
         #[must_use]
@@ -81,7 +81,7 @@ mod with_fetch {
             state: &mut negotiate::one_round::State,
             arguments: &mut fetch::Arguments,
             previous_response: Option<&fetch::Response>,
-        ) -> Result<(negotiate::Round, bool), negotiate::Error>;
+        ) -> ExnMessageResult<(negotiate::Round, bool)>;
     }
 
     /// The outcome of [`fetch()`](crate::fetch()).
diff --git a/gix-protocol/src/handshake/function.rs b/gix-protocol/src/handshake/function.rs
index 96f9a34f350..af3347aec1f 100644
--- a/gix-protocol/src/handshake/function.rs
+++ b/gix-protocol/src/handshake/function.rs
@@ -1,8 +1,9 @@
 use crate::bisync::bisync;
+use gix_error::ExnResult;
+use gix_error::{ErrorExt, ResultExt, message};
 use gix_features::{progress, progress::Progress};
 use gix_transport::{Service, client};
 
-use super::Error;
 use crate::Handshake;
 #[crate::bisync::only_async]
 use crate::transport::client::async_io::{SetServiceResponse, Transport};
@@ -22,7 +23,7 @@ pub async fn handshake<AuthFn, T>(
     mut authenticate: AuthFn,
     extra_parameters: Vec<(String, Option<String>)>,
     progress: &mut impl Progress,
-) -> Result<Handshake, Error>
+) -> ExnResult<Handshake>
 where
     AuthFn: FnMut(credentials::helper::Action) -> credentials::protocol::Result,
     T: Transport,
@@ -60,20 +61,32 @@ where
                         url: Some(url.clone()),
                         www_authenticate,
                         ..Default::default()
-                    }))?
-                    .ok_or(Error::EmptyCredentials)?;
-                transport.set_identity(identity)?;
+                    }))
+                    .or_raise_erased(|| message("Failed to obtain credentials"))?
+                    .ok_or_else(|| {
+                        message(
+                        "No credentials were returned at all as if the credential helper isn't functioning unknowingly",
+                    )
+                    .raise_erased()
+                    })?;
+                transport
+                    .set_identity(identity)
+                    .or_raise_erased(|| message("Could not set transport identity"))?;
                 progress.step();
                 progress.set_name("handshake (authenticated)".into());
                 match transport.handshake(service, &extra_parameters).await {
                     Ok(v) => {
-                        authenticate(next.store())?;
+                        authenticate(next.store()).or_raise_erased(|| message("Failed to store credentials"))?;
                         Ok(v)
                     }
                     // Still no permission? Reject the credentials.
                     Err(client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {
-                        authenticate(next.erase())?;
-                        return Err(Error::InvalidCredentials { url, source: err });
+                        authenticate(next.erase()).or_raise_erased(|| message("Failed to erase credentials"))?;
+                        return Err(err
+                            .and_raise(message!(
+                                "Credentials provided for \"{url}\" were not accepted by the remote"
+                            ))
+                            .erased());
                     }
                     // Otherwise, do nothing, as we don't know if it actually got to try the credentials.
                     // If they were previously stored, they remain. In the worst case, the user has to enter them again
@@ -82,12 +95,14 @@ where
                 }
             }
             Err(err) => Err(err),
-        }?;
+        }
+        .or_raise_erased(|| message("Transport handshake failed"))?;
 
         if !supported_versions.is_empty() && !supported_versions.contains(&actual_protocol) {
-            return Err(Error::TransportProtocolPolicyViolation {
-                actual_version: actual_protocol,
-            });
+            return Err(gix_error::validation(format!(
+                "The transport didn't accept the advertised server version {actual_protocol:?} and closed the connection client side"
+            ))
+            .raise_erased());
         }
 
         let parsed_refs = match refs {
diff --git a/gix-protocol/src/handshake/mod.rs b/gix-protocol/src/handshake/mod.rs
index 9fd6ce403f4..9f5c448889f 100644
--- a/gix-protocol/src/handshake/mod.rs
+++ b/gix-protocol/src/handshake/mod.rs
@@ -72,6 +72,8 @@ pub(crate) mod hero {
     #[cfg(feature = "fetch")]
     mod fetch {
         use crate::{Handshake, command::Feature, fetch::RefMap, ls_refs::RefPrefixes};
+        use gix_error::ExnResult;
+        use gix_error::{ResultExt, message};
         use gix_features::progress::Progress;
 
         /// Intermediate state while potentially fetching a refmap after the handshake.
@@ -91,7 +93,7 @@ pub(crate) mod hero {
                     mut progress: impl Progress,
                     transport: &mut impl $transport,
                     trace_packetlines: bool,
-                ) -> Result<RefMap, crate::fetch::refmap::init::Error> {
+                ) -> ExnResult<RefMap> {
                     let (cmd, cx) = match self {
                         ObtainRefMap::Existing(map) => return Ok(map),
                         ObtainRefMap::LsRefsCommand(cmd, cx) => (cmd, cx),
@@ -104,7 +106,8 @@ pub(crate) mod hero {
                     let capabilities = cmd.capabilities;
                     let remote_refs = cmd
                         .$invoke(transport, &mut progress, trace_packetlines)
-                        .await?;
+                        .await
+                        .or_raise_erased(|| message("Failed to list references on the remote"))?;
                     RefMap::from_refs(remote_refs, capabilities, cx)
                 }
             };
@@ -137,7 +140,7 @@ pub(crate) mod hero {
                 user_agent: Feature,
                 prefix_from_spec_as_filter_on_remote: bool,
                 refmap_context: crate::fetch::refmap::init::Context,
-            ) -> Result<ObtainRefMap<'_>, crate::fetch::refmap::init::Error> {
+            ) -> ExnResult<ObtainRefMap<'_>> {
                 if let Some(refs) = self.refs.take() {
                     return Ok(ObtainRefMap::Existing(RefMap::from_refs(
                         refs,
@@ -159,46 +162,6 @@ pub(crate) mod hero {
     }
 }
 
-#[cfg(feature = "handshake")]
-mod error {
-    use bstr::BString;
-    use gix_transport::client;
-
-    use crate::{credentials, handshake::refs};
-
-    /// The error returned by [`handshake()`][crate::handshake()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Failed to obtain credentials")]
-        Credentials(#[from] credentials::protocol::Error),
-        #[error("No credentials were returned at all as if the credential helper isn't functioning unknowingly")]
-        EmptyCredentials,
-        #[error("Credentials provided for \"{url}\" were not accepted by the remote")]
-        InvalidCredentials { url: BString, source: std::io::Error },
-        #[error(transparent)]
-        Transport(#[from] client::Error),
-        #[error(
-            "The transport didn't accept the advertised server version {actual_version:?} and closed the connection client side"
-        )]
-        TransportProtocolPolicyViolation { actual_version: gix_transport::Protocol },
-        #[error(transparent)]
-        ParseRefs(#[from] refs::parse::Error),
-    }
-
-    impl gix_transport::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::Transport(err) => err.is_spurious(),
-                _ => false,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "handshake")]
-pub use error::Error;
-
 #[cfg(any(feature = "blocking-client", feature = "async-client"))]
 #[cfg(feature = "handshake")]
 pub(crate) mod function;
diff --git a/gix-protocol/src/handshake/refs/async_io.rs b/gix-protocol/src/handshake/refs/async_io.rs
index 07a6877504a..c1cbd758497 100644
--- a/gix-protocol/src/handshake/refs/async_io.rs
+++ b/gix-protocol/src/handshake/refs/async_io.rs
@@ -1,16 +1,20 @@
 #[cfg(not(feature = "blocking-client"))]
 use crate::fetch::response::ShallowUpdate;
-use crate::handshake::{Ref, refs, refs::parse::Error};
+use crate::handshake::{Ref, refs};
 use crate::transport::client::async_io::ReadlineBufRead;
+use gix_error::ExnResult;
+use gix_error::{ResultExt, message};
 
 /// 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 ReadlineBufRead) -> Result<Vec<Ref>, Error> {
+pub async fn from_v2_refs(in_refs: &mut dyn ReadlineBufRead) -> ExnResult<Vec<Ref>> {
     let mut out_refs = Vec::new();
     while let Some(line) = in_refs
         .readline()
         .await
-        .transpose()?
-        .transpose()?
+        .transpose()
+        .or_raise_erased(|| message("Could not read advertised ref"))?
+        .transpose()
+        .or_raise_erased(|| message("Could not decode advertised ref"))?
         .and_then(|l| l.as_bstr())
     {
         out_refs.push(refs::shared::parse_v2(line)?);
@@ -30,7 +34,7 @@ pub async fn from_v2_refs(in_refs: &mut dyn ReadlineBufRead) -> Result<Vec<Ref>,
 pub async fn from_v1_refs_received_as_part_of_handshake_and_capabilities<'a>(
     in_refs: &mut dyn ReadlineBufRead,
     capabilities: impl Iterator<Item = gix_transport::client::capabilities::Capability<'a>>,
-) -> Result<(Vec<Ref>, Vec<ShallowUpdate>), refs::parse::Error> {
+) -> ExnResult<(Vec<Ref>, Vec<ShallowUpdate>)> {
     let mut out_refs = refs::shared::from_capabilities(capabilities)?;
     let mut out_shallow = Vec::new();
     let number_of_possible_symbolic_refs_for_lookup = out_refs.len();
@@ -38,8 +42,10 @@ pub async fn from_v1_refs_received_as_part_of_handshake_and_capabilities<'a>(
     while let Some(line) = in_refs
         .readline()
         .await
-        .transpose()?
-        .transpose()?
+        .transpose()
+        .or_raise_erased(|| message("Could not read advertised ref"))?
+        .transpose()
+        .or_raise_erased(|| message("Could not decode advertised ref"))?
         .and_then(|l| l.as_bstr())
     {
         refs::shared::parse_v1(
diff --git a/gix-protocol/src/handshake/refs/blocking_io.rs b/gix-protocol/src/handshake/refs/blocking_io.rs
index a0eab0b2b26..072c1e33179 100644
--- a/gix-protocol/src/handshake/refs/blocking_io.rs
+++ b/gix-protocol/src/handshake/refs/blocking_io.rs
@@ -1,13 +1,22 @@
 use crate::transport::client::blocking_io::ReadlineBufRead;
 use crate::{
     fetch::response::ShallowUpdate,
-    handshake::{Ref, refs, refs::parse::Error},
+    handshake::{Ref, refs},
 };
+use gix_error::ExnResult;
+use gix_error::{ResultExt, message};
 
 /// 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 ReadlineBufRead) -> Result<Vec<Ref>, Error> {
+pub fn from_v2_refs(in_refs: &mut dyn ReadlineBufRead) -> ExnResult<Vec<Ref>> {
     let mut out_refs = Vec::new();
-    while let Some(line) = in_refs.readline().transpose()?.transpose()?.and_then(|l| l.as_bstr()) {
+    while let Some(line) = in_refs
+        .readline()
+        .transpose()
+        .or_raise_erased(|| message("Could not read advertised ref"))?
+        .transpose()
+        .or_raise_erased(|| message("Could not decode advertised ref"))?
+        .and_then(|l| l.as_bstr())
+    {
         out_refs.push(refs::shared::parse_v2(line)?);
     }
     Ok(out_refs)
@@ -24,12 +33,19 @@ pub fn from_v2_refs(in_refs: &mut dyn ReadlineBufRead) -> Result<Vec<Ref>, Error
 pub fn from_v1_refs_received_as_part_of_handshake_and_capabilities<'a>(
     in_refs: &mut dyn ReadlineBufRead,
     capabilities: impl Iterator<Item = gix_transport::client::capabilities::Capability<'a>>,
-) -> Result<(Vec<Ref>, Vec<ShallowUpdate>), Error> {
+) -> ExnResult<(Vec<Ref>, Vec<ShallowUpdate>)> {
     let mut out_refs = refs::shared::from_capabilities(capabilities)?;
     let mut out_shallow = Vec::new();
     let number_of_possible_symbolic_refs_for_lookup = out_refs.len();
 
-    while let Some(line) = in_refs.readline().transpose()?.transpose()?.and_then(|l| l.as_bstr()) {
+    while let Some(line) = in_refs
+        .readline()
+        .transpose()
+        .or_raise_erased(|| message("Could not read advertised ref"))?
+        .transpose()
+        .or_raise_erased(|| message("Could not decode advertised ref"))?
+        .and_then(|l| l.as_bstr())
+    {
         refs::shared::parse_v1(
             number_of_possible_symbolic_refs_for_lookup,
             &mut out_refs,
diff --git a/gix-protocol/src/handshake/refs/mod.rs b/gix-protocol/src/handshake/refs/mod.rs
index 77c04ac74d7..9e50ae0b675 100644
--- a/gix-protocol/src/handshake/refs/mod.rs
+++ b/gix-protocol/src/handshake/refs/mod.rs
@@ -2,35 +2,6 @@ use bstr::BStr;
 
 use super::Ref;
 
-///
-pub mod parse {
-    use bstr::BString;
-
-    /// The error returned when parsing References/refs from the server response.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        DecodePacketline(#[from] gix_transport::packetline::decode::Error),
-        #[error(transparent)]
-        Id(#[from] gix_hash::decode::Error),
-        #[error("{symref:?} could not be parsed. A symref is expected to look like <NAME>:<target>.")]
-        MalformedSymref { symref: BString },
-        #[error("{0:?} could not be parsed. A V1 ref line should be '<hex-hash> <path>'.")]
-        MalformedV1RefLine(BString),
-        #[error(
-            "{0:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
-        )]
-        MalformedV2RefLine(BString),
-        #[error("The ref attribute {attribute:?} is unknown. Found in line {line:?}")]
-        UnknownAttribute { attribute: BString, line: BString },
-        #[error("{message}")]
-        InvariantViolation { message: &'static str },
-    }
-}
-
 impl Ref {
     /// Provide shared fields referring to the ref itself, namely `(name, target, [peeled])`.
     /// In case of peeled refs, the tag object itself is returned as it is what the ref directly refers to, and target of the tag is returned
diff --git a/gix-protocol/src/handshake/refs/shared.rs b/gix-protocol/src/handshake/refs/shared.rs
index d5792621a39..e1a386ab34e 100644
--- a/gix-protocol/src/handshake/refs/shared.rs
+++ b/gix-protocol/src/handshake/refs/shared.rs
@@ -1,9 +1,8 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnResult;
+use gix_error::{ErrorExt, ResultExt};
 
-use crate::{
-    fetch::response::ShallowUpdate,
-    handshake::{Ref, refs::parse::Error},
-};
+use crate::{fetch::response::ShallowUpdate, handshake::Ref};
 
 impl From<InternalRef> for Ref {
     fn from(v: InternalRef) -> Self {
@@ -94,7 +93,7 @@ impl InternalRef {
 
 pub(crate) fn from_capabilities<'a>(
     capabilities: impl Iterator<Item = gix_transport::client::capabilities::Capability<'a>>,
-) -> Result<Vec<InternalRef>, Error> {
+) -> ExnResult<Vec<InternalRef>> {
     let mut out_refs = Vec::new();
     let symref_values = capabilities.filter_map(|c| {
         if c.name() == b"symref".as_bstr() {
@@ -104,13 +103,17 @@ pub(crate) fn from_capabilities<'a>(
         }
     });
     for symref in symref_values {
-        let (left, right) = symref.split_at(symref.find_byte(b':').ok_or_else(|| Error::MalformedSymref {
-            symref: symref.to_owned(),
+        let (left, right) = symref.split_at(symref.find_byte(b':').ok_or_else(|| {
+            gix_error::corruption(format!(
+                "{symref:?} could not be parsed. A symref is expected to look like <NAME>:<target>."
+            ))
+            .raise_erased()
         })?);
         if left.is_empty() || right.is_empty() {
-            return Err(Error::MalformedSymref {
-                symref: symref.to_owned(),
-            });
+            return Err(gix_error::corruption(format!(
+                "{symref:?} could not be parsed. A symref is expected to look like <NAME>:<target>."
+            ))
+            .raise_erased());
         }
         out_refs.push(InternalRef::SymbolicForLookup {
             path: left.into(),
@@ -128,16 +131,20 @@ pub(in crate::handshake::refs) fn parse_v1(
     out_refs: &mut Vec<InternalRef>,
     out_shallow: &mut Vec<ShallowUpdate>,
     line: &BStr,
-) -> Result<(), Error> {
+) -> ExnResult {
     let trimmed = line.trim_end();
-    let (hex_hash, path) = trimmed.split_at(
-        trimmed
-            .find(b" ")
-            .ok_or_else(|| Error::MalformedV1RefLine(trimmed.to_owned().into()))?,
-    );
+    let (hex_hash, path) = trimmed.split_at(trimmed.find(b" ").ok_or_else(|| {
+        gix_error::corruption(format!(
+            "{trimmed:?} could not be parsed. A V1 ref line should be '<hex-hash> <path>'."
+        ))
+        .raise_erased()
+    })?);
     let path = &path[1..];
     if path.is_empty() {
-        return Err(Error::MalformedV1RefLine(trimmed.to_owned().into()));
+        return Err(gix_error::corruption(format!(
+            "{trimmed:?} could not be parsed. A V1 ref line should be '<hex-hash> <path>'."
+        ))
+        .raise_erased());
     }
     match path.strip_suffix(b"^{}") {
         Some(stripped) => {
@@ -145,33 +152,34 @@ pub(in crate::handshake::refs) fn parse_v1(
                 // this is a special dummy-ref just for the sake of getting capabilities across in a repo that is empty.
                 return Ok(());
             }
-            let (previous_path, tag) =
-                out_refs
-                    .pop()
-                    .and_then(InternalRef::unpack_direct)
-                    .ok_or(Error::InvariantViolation {
-                        message: "Expecting peeled refs to be preceded by direct refs",
-                    })?;
+            let (previous_path, tag) = out_refs.pop().and_then(InternalRef::unpack_direct).ok_or_else(|| {
+                gix_error::corruption("Expecting peeled refs to be preceded by direct refs").raise_erased()
+            })?;
             if previous_path != stripped {
-                return Err(Error::InvariantViolation {
-                    message: "Expecting peeled refs to have the same base path as the previous, unpeeled one",
-                });
+                return Err(gix_error::corruption(
+                    "Expecting peeled refs to have the same base path as the previous, unpeeled one",
+                )
+                .raise_erased());
             }
             out_refs.push(InternalRef::Peeled {
                 path: previous_path,
                 tag,
-                object: gix_hash::ObjectId::from_hex(hex_hash.as_bytes())?,
+                object: gix_hash::ObjectId::from_hex(hex_hash.as_bytes())
+                    .or_raise_erased(|| gix_error::corruption("Could not decode peeled object ID"))?,
             });
         }
         None => {
             let object = match gix_hash::ObjectId::from_hex(hex_hash.as_bytes()) {
                 Ok(id) => id,
                 Err(_) if hex_hash.as_bstr() == "shallow" => {
-                    let id = gix_hash::ObjectId::from_hex(path)?;
+                    let id = gix_hash::ObjectId::from_hex(path)
+                        .or_raise_erased(|| gix_error::corruption("Could not decode shallow object ID"))?;
                     out_shallow.push(ShallowUpdate::Shallow(id));
                     return Ok(());
                 }
-                Err(err) => return Err(err.into()),
+                Err(err) => {
+                    return Err(err.raise(gix_error::corruption("Could not decode object ID")).erased());
+                }
             };
             match out_refs
                 .iter()
@@ -197,7 +205,7 @@ pub(in crate::handshake::refs) fn parse_v1(
     Ok(())
 }
 
-pub(in crate::handshake::refs) fn parse_v2(line: &BStr) -> Result<Ref, Error> {
+pub(in crate::handshake::refs) fn parse_v2(line: &BStr) -> ExnResult<Ref> {
     let trimmed = line.trim_end();
     let mut tokens = trimmed.splitn(4, |b| *b == b' ');
     match (tokens.next(), tokens.next()) {
@@ -205,10 +213,16 @@ pub(in crate::handshake::refs) fn parse_v2(line: &BStr) -> Result<Ref, Error> {
             let id = if hex_hash == b"unborn" {
                 None
             } else {
-                Some(gix_hash::ObjectId::from_hex(hex_hash.as_bytes())?)
+                Some(
+                    gix_hash::ObjectId::from_hex(hex_hash.as_bytes())
+                        .or_raise_erased(|| gix_error::corruption("Could not decode object ID"))?,
+                )
             };
             if path.is_empty() {
-                return Err(Error::MalformedV2RefLine(trimmed.to_owned().into()));
+                return Err(gix_error::corruption(format!(
+                    "{trimmed:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
+                ))
+                .raise_erased());
             }
             let mut symref_target = None;
             let mut peeled = None;
@@ -217,43 +231,59 @@ pub(in crate::handshake::refs) fn parse_v2(line: &BStr) -> Result<Ref, Error> {
                 match (tokens.next(), tokens.next()) {
                     (Some(attribute), Some(value)) => {
                         if value.is_empty() {
-                            return Err(Error::MalformedV2RefLine(trimmed.to_owned().into()));
+                            return Err(gix_error::corruption(format!(
+                                "{trimmed:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
+                            ))
+                            .raise_erased());
                         }
                         match attribute {
                             b"peeled" => {
-                                peeled = Some(gix_hash::ObjectId::from_hex(value.as_bytes())?);
+                                peeled = Some(
+                                    gix_hash::ObjectId::from_hex(value.as_bytes())
+                                        .or_raise_erased(|| gix_error::corruption("Could not decode peeled object ID"))?,
+                                );
                             }
                             b"symref-target" => {
                                 symref_target = Some(value);
                             }
                             _ => {
-                                return Err(Error::UnknownAttribute {
-                                    attribute: attribute.to_owned().into(),
-                                    line: trimmed.to_owned().into(),
-                                });
+                                return Err(gix_error::corruption(format!(
+                                    "The ref attribute {attribute:?} is unknown. Found in line {trimmed:?}"
+                                ))
+                                .raise_erased());
                             }
                         }
                     }
-                    _ => return Err(Error::MalformedV2RefLine(trimmed.to_owned().into())),
+                    _ => {
+                        return Err(gix_error::corruption(format!(
+                            "{trimmed:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
+                        ))
+                        .raise_erased());
+                    }
                 }
             }
             if tokens.next().is_some() {
-                return Err(Error::MalformedV2RefLine(trimmed.to_owned().into()));
+                return Err(gix_error::corruption(format!(
+                    "{trimmed:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
+                ))
+                .raise_erased());
             }
             Ok(match (symref_target, peeled) {
                 (Some(target_name), peeled) => match target_name {
                     b"(null)" => match peeled {
                         None => Ref::Direct {
                             full_ref_name: path.into(),
-                            object: id.ok_or(Error::InvariantViolation {
-                                message: "got 'unborn' while (null) was a symref target",
+                            object: id.ok_or_else(|| {
+                                gix_error::corruption("got 'unborn' while (null) was a symref target")
+                                    .raise_erased()
                             })?,
                         },
                         Some(peeled) => Ref::Peeled {
                             full_ref_name: path.into(),
                             object: peeled,
-                            tag: id.ok_or(Error::InvariantViolation {
-                                message: "got 'unborn' while (null) was a symref target",
+                            tag: id.ok_or_else(|| {
+                                gix_error::corruption("got 'unborn' while (null) was a symref target")
+                                    .raise_erased()
                             })?,
                         },
                     },
@@ -273,19 +303,22 @@ pub(in crate::handshake::refs) fn parse_v2(line: &BStr) -> Result<Ref, Error> {
                 (None, Some(peeled)) => Ref::Peeled {
                     full_ref_name: path.into(),
                     object: peeled,
-                    tag: id.ok_or(Error::InvariantViolation {
-                        message: "got 'unborn' as tag target",
+                    tag: id.ok_or_else(|| {
+                        gix_error::corruption("got 'unborn' as tag target").raise_erased()
                     })?,
                 },
                 (None, None) => Ref::Direct {
-                    object: id.ok_or(Error::InvariantViolation {
-                        message: "got 'unborn' as object name of direct reference",
+                    object: id.ok_or_else(|| {
+                        gix_error::corruption("got 'unborn' as object name of direct reference").raise_erased()
                     })?,
                     full_ref_name: path.into(),
                 },
             })
         }
-        _ => Err(Error::MalformedV2RefLine(trimmed.to_owned().into())),
+        _ => Err(gix_error::corruption(format!(
+            "{trimmed:?} could not be parsed. A V2 ref line should be '<hex-hash> <path>[ (peeled|symref-target):<value>'."
+        ))
+        .raise_erased()),
     }
 }
 
@@ -296,7 +329,7 @@ mod tests {
     use crate::handshake::{refs, refs::shared::InternalRef};
 
     #[test]
-    fn from_capabilities_extracts_symbolic_references() -> Result<(), client::Error> {
+    fn from_capabilities_extracts_symbolic_references() -> std::result::Result<(), client::Error> {
         let caps = client::Capabilities::from_bytes(
             b"\0unrelated symref=HEAD:refs/heads/main symref=ANOTHER:refs/heads/foo symref=MISSING_NAMESPACE_TARGET:(null) agent=git/2.28.0",
         )?
diff --git a/gix-protocol/src/ls_refs.rs b/gix-protocol/src/ls_refs.rs
index 9b25c365b40..b11ad4c723e 100644
--- a/gix-protocol/src/ls_refs.rs
+++ b/gix-protocol/src/ls_refs.rs
@@ -1,34 +1,3 @@
-#[cfg(any(feature = "blocking-client", feature = "async-client"))]
-mod error {
-    use crate::handshake::refs::parse;
-
-    /// The error returned by invoking a [`super::function::LsRefsCommand`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        Transport(#[from] gix_transport::client::Error),
-        #[error(transparent)]
-        Parse(#[from] parse::Error),
-        #[error(transparent)]
-        ArgumentValidation(#[from] crate::command::validate_argument_prefixes::Error),
-    }
-
-    impl gix_transport::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::Io(err) => err.is_spurious(),
-                Error::Transport(err) => err.is_spurious(),
-                _ => false,
-            }
-        }
-    }
-}
-#[cfg(any(feature = "blocking-client", feature = "async-client"))]
-pub use error::Error;
-
 #[cfg(any(feature = "blocking-client", feature = "async-client"))]
 pub use self::function::RefPrefixes;
 
@@ -37,10 +6,10 @@ pub(crate) mod function {
     use std::collections::HashSet;
 
     use bstr::{BString, ByteVec};
+    use gix_error::{ExnResult, ResultExt, message};
     use gix_features::progress::Progress;
     use gix_transport::client::Capabilities;
 
-    use super::Error;
     #[cfg(feature = "async-client")]
     use crate::transport::client::async_io::TransportV2Ext as _;
     #[cfg(feature = "blocking-client")]
@@ -141,14 +110,16 @@ pub(crate) mod function {
                 mut transport: impl $transport,
                 progress: &mut impl Progress,
                 trace: bool,
-            ) -> Result<Vec<Ref>, Error> {
+            ) -> ExnResult<Vec<Ref>> {
                 let _span = gix_features::trace::detail!("gix_protocol::LsRefsCommand::invoke()", mode = $mode);
-                Command::LsRefs.validate_argument_prefixes(
-                    gix_transport::Protocol::V2,
-                    self.capabilities,
-                    &self.arguments,
-                    &self.features,
-                )?;
+                Command::LsRefs
+                    .validate_argument_prefixes(
+                        gix_transport::Protocol::V2,
+                        self.capabilities,
+                        &self.arguments,
+                        &self.features,
+                    )
+                    .or_raise_erased(|| message("Invalid ls-refs arguments or capabilities"))?;
 
                 progress.step();
                 progress.set_name("list refs".into());
@@ -163,8 +134,9 @@ pub(crate) mod function {
                         },
                         trace,
                     )
-                    .await?;
-                Ok($from_v2_refs(&mut remote_refs).await?)
+                    .await
+                    .or_raise_erased(|| message("Could not invoke ls-refs"))?;
+                $from_v2_refs(&mut remote_refs).await
             }
         };
     }
@@ -223,11 +195,82 @@ pub(crate) mod function {
     }
 
     #[cfg(test)]
-    mod ref_prefixes {
+    mod tests {
         use bstr::{BString, ByteSlice};
 
         use super::RefPrefixes;
 
+        #[cfg(feature = "blocking-client")]
+        #[test]
+        fn invoke_preserves_transport_retryability() {
+            let mut error_snapshots = Vec::new();
+            use std::io::{self, ErrorKind};
+
+            struct FailingWriter(ErrorKind);
+            impl io::Write for FailingWriter {
+                fn write(&mut self, _buf: &[u8]) -> io::Result<usize> {
+                    Err(self.0.into())
+                }
+                fn flush(&mut self) -> io::Result<()> {
+                    Ok(())
+                }
+            }
+
+            let capabilities = super::Capabilities::from_lines("version 2\nls-refs\nagent=test\n".into())
+                .expect("valid V2 capabilities");
+            for (kind, retryable) in [
+                (ErrorKind::BrokenPipe, true),
+                (ErrorKind::ConnectionReset, true),
+                (ErrorKind::PermissionDenied, false),
+            ] {
+                let transport = gix_transport::client::git::blocking_io::Connection::new(
+                    &[][..],
+                    FailingWriter(kind),
+                    gix_transport::Protocol::V2,
+                    "repo.git",
+                    None::<(&str, _)>,
+                    gix_transport::client::git::ConnectMode::Process,
+                    false,
+                );
+                let err = super::LsRefsCommand::new(None, &capabilities, ("agent", Some("test".into())))
+                    .invoke_blocking(transport, &mut gix_features::progress::Discard, false)
+                    .expect_err("the transport write fails")
+                    .into_error();
+                error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+                assert_eq!(err.can_retry_lenient(), retryable, "preserve retry policy for {kind:?}");
+                assert!(
+                    !err.is_retryable(),
+                    "I/O failures are classified without extra retry markers"
+                );
+                assert_eq!(
+                    err.downcast_any_ref::<io::Error>()
+                        .expect("retain the I/O cause")
+                        .kind(),
+                    kind,
+                    "the original transport failure remains available"
+                );
+            }
+            insta::assert_debug_snapshot!(error_snapshots, "invoke preserves transport retryability", @"
+            [
+                Could not invoke ls-refs
+                |
+                └─ An IO error occurred when talking to the server
+                |
+                └─ broken pipe,
+                Could not invoke ls-refs
+                |
+                └─ An IO error occurred when talking to the server
+                |
+                └─ connection reset,
+                Could not invoke ls-refs
+                |
+                └─ An IO error occurred when talking to the server
+                |
+                └─ permission denied,
+            ]
+            ");
+        }
+
         #[test]
         fn extend_preserves_first_seen_order_and_deduplicates_prefixes() {
             let mut prefixes = RefPrefixes::new();
diff --git a/gix-protocol/tests/protocol/command.rs b/gix-protocol/tests/protocol/command.rs
index 111c68f1314..0b46dc5e9da 100644
--- a/gix-protocol/tests/protocol/command.rs
+++ b/gix-protocol/tests/protocol/command.rs
@@ -141,34 +141,66 @@ mod v2 {
 
             #[test]
             fn unknown_argument() {
-                assert_eq!(
-                    Command::LsRefs
-                        .validate_argument_prefixes(
-                            gix_transport::Protocol::V2,
-                            &capabilities("other", "do-not-matter"),
-                            &[b"definitely-nothing-we-know".as_bstr().into()],
-                            &[],
-                        )
-                        .unwrap_err()
-                        .to_string(),
-                    "ls-refs: argument definitely-nothing-we-know is not known or allowed"
+                let err = Command::LsRefs
+                    .validate_argument_prefixes(
+                        gix_transport::Protocol::V2,
+                        &capabilities("other", "do-not-matter"),
+                        &[b"definitely-nothing-we-know".as_bstr().into()],
+                        &[],
+                    )
+                    .expect_err("the argument is unknown")
+                    .into_inner();
+                assert!(
+                    gix_error::classify(&err).is_validation(),
+                    "unknown arguments are invalid input"
                 );
+                insta::assert_debug_snapshot!(err, "unknown argument", @r#"
+                Message {
+                    message: "ls-refs: argument definitely-nothing-we-know is not known or allowed",
+                    class: Validation,
+                }
+                "#);
             }
 
             #[test]
             fn unknown_feature() {
-                assert_eq!(
-                    Command::LsRefs
+                let mut error_snapshots = Vec::new();
+                for version in [
+                    gix_transport::Protocol::V0,
+                    gix_transport::Protocol::V1,
+                    gix_transport::Protocol::V2,
+                ] {
+                    let err = Command::LsRefs
                         .validate_argument_prefixes(
-                            gix_transport::Protocol::V2,
+                            version,
                             &capabilities("other", "do-not-matter"),
                             &[],
                             &[("some-feature-that-does-not-exist", None)],
                         )
-                        .unwrap_err()
-                        .to_string(),
-                    "ls-refs: capability some-feature-that-does-not-exist is not supported"
-                );
+                        .expect_err("the feature is unsupported")
+                        .into_inner();
+                    assert!(
+                        gix_error::classify(&err).is_validation(),
+                        "unsupported capabilities are invalid input"
+                    );
+                    error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+                }
+                insta::assert_debug_snapshot!(error_snapshots, "unknown feature", @r#"
+                [
+                    Message {
+                        message: "ls-refs: capability some-feature-that-does-not-exist is not supported",
+                        class: Validation,
+                    },
+                    Message {
+                        message: "ls-refs: capability some-feature-that-does-not-exist is not supported",
+                        class: Validation,
+                    },
+                    Message {
+                        message: "ls-refs: capability some-feature-that-does-not-exist is not supported",
+                        class: Validation,
+                    },
+                ]
+                "#);
             }
         }
     }
diff --git a/gix-protocol/tests/protocol/fetch/_impl.rs b/gix-protocol/tests/protocol/fetch/_impl.rs
index 82bab99993e..9308b7b7535 100644
--- a/gix-protocol/tests/protocol/fetch/_impl.rs
+++ b/gix-protocol/tests/protocol/fetch/_impl.rs
@@ -12,6 +12,8 @@ pub enum RefsAction {
 
 mod fetch_fn {
     use crate::bisync::bisync;
+    use gix_error::ExnResult;
+    use gix_error::{ErrorExt, ResultExt, message};
     use gix_features::progress::NestedProgress;
     use gix_protocol::{
         Command, LsRefsCommand, credentials,
@@ -25,7 +27,6 @@ mod fetch_fn {
     use std::ops::ControlFlow;
 
     use super::{Action, Delegate, RefsAction};
-    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)]
@@ -76,7 +77,7 @@ mod fetch_fn {
         fetch_mode: FetchConnection,
         agent: impl Into<String>,
         trace: bool,
-    ) -> Result<(), Error>
+    ) -> ExnResult
     where
         F: FnMut(credentials::helper::Action) -> credentials::protocol::Result,
         D: Delegate,
@@ -96,7 +97,8 @@ mod fetch_fn {
             delegate.handshake_extra_parameters(),
             &mut progress,
         )
-        .await?;
+        .await
+        .or_raise_erased(|| message("Protocol handshake failed"))?;
 
         let agent = gix_protocol::agent(agent);
         let refs = match refs {
@@ -108,20 +110,23 @@ mod fetch_fn {
                     {
                         LsRefsCommand::new(None, &capabilities, ("agent", Some(agent.clone())))
                             .invoke_async(&mut transport, &mut progress, trace)
-                            .await?
+                            .await
+                            .or_raise_erased(|| message("Failed to list remote references"))?
                     }
                     #[cfg(feature = "blocking-client")]
                     {
-                        LsRefsCommand::new(None, &capabilities, ("agent", Some(agent.clone()))).invoke_blocking(
-                            &mut transport,
-                            &mut progress,
-                            trace,
-                        )?
+                        LsRefsCommand::new(None, &capabilities, ("agent", Some(agent.clone())))
+                            .invoke_blocking(&mut transport, &mut progress, trace)
+                            .or_raise_erased(|| message("Failed to list remote references"))?
                     }
                 }
                 Err(err) => {
-                    indicate_end_of_interaction(transport, trace).await?;
-                    return Err(err.into());
+                    indicate_end_of_interaction(transport, trace)
+                        .await
+                        .or_raise_erased(|| message("Failed to end the interaction"))?;
+                    return Err(err
+                        .and_raise(message("Failed to prepare listing remote references"))
+                        .erased());
                 }
             },
         };
@@ -133,7 +138,9 @@ mod fetch_fn {
                 return if matches!(protocol_version, gix_transport::Protocol::V1)
                     || matches!(fetch_mode, FetchConnection::TerminateOnSuccessfulCompletion)
                 {
-                    indicate_end_of_interaction(transport, trace).await.map_err(Into::into)
+                    indicate_end_of_interaction(transport, trace)
+                        .await
+                        .or_raise_erased(|| message("Failed to end the interaction"))
                 } else {
                     Ok(())
                 };
@@ -144,8 +151,10 @@ mod fetch_fn {
                     .expect("BUG: delegates must always produce valid arguments");
             }
             Err(err) => {
-                indicate_end_of_interaction(transport, trace).await?;
-                return Err(err.into());
+                indicate_end_of_interaction(transport, trace)
+                    .await
+                    .or_raise_erased(|| message("Failed to end the interaction"))?;
+                return Err(err.and_raise(message("Failed to prepare the fetch")).erased());
             }
         }
 
@@ -159,8 +168,13 @@ mod fetch_fn {
             progress.step();
             progress.set_name(format!("negotiate (round {round})"));
             round += 1;
-            let action = delegate.negotiate(&refs, &mut arguments, previous_response.as_ref())?;
-            let mut reader = arguments.send(&mut transport, action == Action::Cancel).await?;
+            let action = delegate
+                .negotiate(&refs, &mut arguments, previous_response.as_ref())
+                .or_raise_erased(|| message("Fetch negotiation failed"))?;
+            let mut reader = arguments
+                .send(&mut transport, action == Action::Cancel)
+                .await
+                .or_raise_erased(|| message("Failed to send fetch arguments"))?;
             if sideband_all {
                 setup_remote_progress(&mut progress, &mut reader);
             }
@@ -170,14 +184,18 @@ mod fetch_fn {
                 true,  /* hack, telling us we don't want this delegate approach anymore */
                 false, /* just as much of a hack which causes us to expect a pack immediately */
             )
-            .await?;
+            .await
+            .or_raise_erased(|| message("Could not decode server reply"))?;
             previous_response = if response.has_pack() {
                 progress.step();
                 progress.set_name("receiving pack".into());
                 if !sideband_all {
                     setup_remote_progress(&mut progress, &mut reader);
                 }
-                delegate.receive_pack(reader, progress, &refs, &response).await?;
+                delegate
+                    .receive_pack(reader, progress, &refs, &response)
+                    .await
+                    .or_raise_erased(|| message("Failed to receive pack"))?;
                 break 'negotiation;
             } else {
                 match action {
@@ -189,7 +207,9 @@ mod fetch_fn {
         if matches!(protocol_version, gix_transport::Protocol::V2)
             && matches!(fetch_mode, FetchConnection::TerminateOnSuccessfulCompletion)
         {
-            indicate_end_of_interaction(transport, trace).await?;
+            indicate_end_of_interaction(transport, trace)
+                .await
+                .or_raise_erased(|| message("Failed to end the interaction"))?;
         }
         Ok(())
     }
diff --git a/gix-protocol/tests/protocol/fetch/arguments.rs b/gix-protocol/tests/protocol/fetch/arguments.rs
index eaec7e1ef9e..66383cdfb31 100644
--- a/gix-protocol/tests/protocol/fetch/arguments.rs
+++ b/gix-protocol/tests/protocol/fetch/arguments.rs
@@ -24,6 +24,8 @@ struct Transport<T> {
 mod impls {
     use std::borrow::Cow;
 
+    use gix_error::ExnResult;
+
     use bstr::BStr;
     use gix_transport::{
         Protocol, Service, client,
@@ -52,10 +54,7 @@ mod impls {
             self.stateful
         }
 
-        fn configure(
-            &mut self,
-            config: &dyn std::any::Any,
-        ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn configure(&mut self, config: &dyn std::any::Any) -> ExnResult {
             self.inner.configure(config)
         }
     }
@@ -84,6 +83,8 @@ mod impls {
 mod impls {
     use std::borrow::Cow;
 
+    use gix_error::ExnResult;
+
     use async_trait::async_trait;
     use bstr::BStr;
     use gix_transport::{
@@ -113,10 +114,7 @@ mod impls {
             self.stateful
         }
 
-        fn configure(
-            &mut self,
-            config: &dyn std::any::Any,
-        ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn configure(&mut self, config: &dyn std::any::Any) -> ExnResult {
             self.inner.configure(config)
         }
     }
diff --git a/gix-protocol/tests/protocol/fetch/mod.rs b/gix-protocol/tests/protocol/fetch/mod.rs
index 259a355e9bc..8ab2256b813 100644
--- a/gix-protocol/tests/protocol/fetch/mod.rs
+++ b/gix-protocol/tests/protocol/fetch/mod.rs
@@ -15,30 +15,6 @@ use _impl::{Action, DelegateBlocking, RefsAction};
 
 mod ref_map;
 
-mod error {
-    use std::io;
-
-    use gix_protocol::{fetch::response, handshake, ls_refs};
-    use gix_transport::client;
-
-    /// The error used in [`fetch()`][crate::fetch()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Handshake(#[from] handshake::Error),
-        #[error("Could not access repository or failed to read streaming pack file")]
-        Io(#[from] io::Error),
-        #[error(transparent)]
-        Transport(#[from] client::Error),
-        #[error(transparent)]
-        LsRefs(#[from] ls_refs::Error),
-        #[error(transparent)]
-        Response(#[from] response::Error),
-    }
-}
-pub use error::Error;
-
 mod arguments;
 
 #[cfg(feature = "blocking-client")]
@@ -46,7 +22,6 @@ type Cursor = std::io::Cursor<Vec<u8>>;
 #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
 type Cursor = futures_lite::io::Cursor<Vec<u8>>;
 
-#[expect(clippy::result_large_err)]
 fn helper_unused(_action: gix_credentials::helper::Action) -> gix_credentials::protocol::Result {
     panic!("Call to credentials helper is unexpected")
 }
diff --git a/gix-protocol/tests/protocol/fetch/ref_map.rs b/gix-protocol/tests/protocol/fetch/ref_map.rs
index 6accb81d2a1..9a3eb0201de 100644
--- a/gix-protocol/tests/protocol/fetch/ref_map.rs
+++ b/gix-protocol/tests/protocol/fetch/ref_map.rs
@@ -30,10 +30,13 @@ mod from_refs {
     fn unknown_object_format_errors() {
         let caps = caps_with(b"symref=HEAD:refs/heads/main object-format=sha999 agent=git/2.54.0");
         let err = RefMap::from_refs(Vec::new(), &caps, ctx()).expect_err("unknown format must error");
-        assert!(
-            matches!(err, refmap::init::Error::UnknownObjectFormat { ref format } if format == "sha999"),
-            "Any `object-format` value we don't recognize must surface as an `UnknownObjectFormat` error
-            rather than silently defaulting to Sha1, so callers can refuse to fetch from unsupported servers"
+        insta::assert_debug_snapshot!(err, "unknown formats are validation errors", @r#"The object format used by the remote is unsupported: sha999, "input"="sha999""#);
+        assert!(err.is_validation(), "unknown formats are validation errors");
+        let metadata = err.metadata().next().expect("the unsupported format is retained");
+        assert_eq!(
+            metadata.get("input"),
+            Some(&gix_error::MetadataValue::from(b"sha999".as_slice())),
+            "the unsupported format is retained for callers"
         );
     }
 
diff --git a/gix-protocol/tests/protocol/fetch/response.rs b/gix-protocol/tests/protocol/fetch/response.rs
index 159b8d1367b..0f0bb57cadd 100644
--- a/gix-protocol/tests/protocol/fetch/response.rs
+++ b/gix-protocol/tests/protocol/fetch/response.rs
@@ -16,6 +16,7 @@ fn id(hex: &str) -> gix_hash::ObjectId {
 
 mod v1 {
     mod from_line_reader {
+        use crate::Result;
         #[cfg(feature = "blocking-client")]
         use std::io::Read;
 
@@ -32,7 +33,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn clone() -> crate::Result {
+        async fn clone() -> Result {
             let mut provider = mock_reader("v1/clone-only.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader, true, false).await?;
@@ -47,7 +48,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn shallow_clone() -> crate::Result {
+        async fn shallow_clone() -> Result {
             let mut provider = mock_reader("v1/clone-deepen-1.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader, true, false).await?;
@@ -66,7 +67,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn empty_shallow_clone_due_to_depth_being_too_high() -> crate::Result {
+        async fn empty_shallow_clone_due_to_depth_being_too_high() -> Result {
             let mut provider = mock_reader("v1/clone-deepen-5.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader, true, false).await?;
@@ -82,7 +83,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn unshallow_fetch() -> crate::Result {
+        async fn unshallow_fetch() -> Result {
             let mut provider = mock_reader("v1/fetch-unshallow.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader, true, true).await?;
@@ -115,7 +116,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn fetch_acks_without_pack() -> crate::Result {
+        async fn fetch_acks_without_pack() -> Result {
             let mut provider = mock_reader("v1/fetch-no-pack.response");
             let r =
                 fetch::Response::from_line_reader(Protocol::V1, &mut provider.as_read_without_sidebands(), true, true)
@@ -134,7 +135,7 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn fetch_acks_and_pack() -> crate::Result {
+        async fn fetch_acks_and_pack() -> Result {
             let mut provider = mock_reader("v1/fetch.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V1, &mut reader, true, true).await?;
@@ -157,6 +158,7 @@ mod v1 {
     }
 
     mod arguments {
+        use crate::Result;
         use bstr::ByteSlice;
         use gix_protocol::{Command, fetch};
         use gix_transport::{Protocol, client::Capabilities};
@@ -166,8 +168,9 @@ mod v1 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn all() -> crate::Result {
-            let (caps, _) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack filter side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])?;
+        async fn all() -> Result {
+            let (caps, _) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack filter side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])
+                ?;
             let mut args = fetch::Arguments::new(
                 Protocol::V1,
                 Command::Fetch.default_features(Protocol::V1, &caps),
@@ -222,6 +225,7 @@ mod v1 {
 }
 mod v2 {
     mod from_line_reader {
+        use crate::Result;
         #[cfg(feature = "blocking-client")]
         use std::io::Read;
 
@@ -242,7 +246,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn clone() -> crate::Result {
+        async fn clone() -> Result {
             for keepalive in [false, true] {
                 let fixture = format!(
                     "v2/clone-only{}.response",
@@ -268,7 +272,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn shallow_clone() -> crate::Result {
+        async fn shallow_clone() -> Result {
             let mut provider = mock_reader("v2/clone-deepen-1.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader, true, true).await?;
@@ -287,7 +291,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn unshallow_fetch() -> crate::Result {
+        async fn unshallow_fetch() -> Result {
             let mut provider = mock_reader("v2/fetch-unshallow.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader, true, true).await?;
@@ -321,7 +325,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn empty_shallow_clone() -> crate::Result {
+        async fn empty_shallow_clone() -> Result {
             let mut provider = mock_reader("v2/clone-deepen-5.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader, true, true).await?;
@@ -337,7 +341,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn clone_with_sidebands() -> crate::Result {
+        async fn clone_with_sidebands() -> Result {
             let mut provider = mock_reader("v2/clone-only-2.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader, true, true).await?;
@@ -362,7 +366,7 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn fetch_acks_without_pack() -> crate::Result {
+        async fn fetch_acks_without_pack() -> Result {
             let mut provider = mock_reader("v2/fetch-no-pack.response");
             let r =
                 fetch::Response::from_line_reader(Protocol::V2, &mut provider.as_read_without_sidebands(), true, true)
@@ -375,24 +379,32 @@ mod v2 {
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
         async fn fetch_with_err_response() {
+            let mut error_snapshots = Vec::new();
             let mut provider = mock_reader("v2/fetch-err-line.response");
             provider.fail_on_err_lines(true);
             let mut sidebands = provider.as_read_without_sidebands();
             match fetch::Response::from_line_reader(Protocol::V2, &mut sidebands, true, true).await {
                 Ok(_) => panic!("need error response"),
-                Err(err) => match err {
-                    fetch::response::Error::UploadPack(err) => {
-                        assert_eq!(err.message, "segmentation fault\n");
-                    }
-                    err => panic!("we expect upload pack errors, got {err:#?}"),
-                },
+                Err(err) => {
+                    let packetline_err = err
+                        .downcast_any_ref::<gix_transport::packetline::read::Error>()
+                        .unwrap_or_else(|| panic!("the remote ERR packet is retained in the error chain: {err:#?}"));
+                    error_snapshots.push(gix_testtools::redact_debug_snapshot(&(packetline_err), &[]));
+                }
             }
+            insta::assert_debug_snapshot!(error_snapshots, "fetch with err response", @r#"
+            [
+                Error {
+                    message: "segmentation fault\n",
+                },
+            ]
+            "#);
         }
 
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn fetch_acks_and_pack() -> crate::Result {
+        async fn fetch_acks_and_pack() -> Result {
             let mut provider = mock_reader("v2/fetch.response");
             let mut reader = provider.as_read_without_sidebands();
             let r = fetch::Response::from_line_reader(Protocol::V2, &mut reader, true, true).await?;
@@ -417,6 +429,7 @@ mod v2 {
     }
 
     mod arguments {
+        use crate::Result;
         use bstr::ByteSlice;
         use gix_protocol::{Command, fetch};
         use gix_transport::{Protocol, client::Capabilities};
@@ -426,8 +439,9 @@ mod v2 {
         #[crate::bisync::bisync]
         #[cfg_attr(feature = "blocking-client", test)]
         #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-        async fn all() -> crate::Result {
-            let (caps, _) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack filter side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])?;
+        async fn all() -> Result {
+            let (caps, _) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack filter side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])
+                ?;
             let mut args = fetch::Arguments::new(
                 Protocol::V2,
                 Command::Fetch.default_features(Protocol::V1, &caps),
diff --git a/gix-protocol/tests/protocol/fetch/v1.rs b/gix-protocol/tests/protocol/fetch/v1.rs
index 297d9504423..583f15e900b 100644
--- a/gix-protocol/tests/protocol/fetch/v1.rs
+++ b/gix-protocol/tests/protocol/fetch/v1.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_features::progress;
 use gix_protocol::handshake;
@@ -8,7 +9,7 @@ use crate::fetch::{_impl::FetchConnection, CloneDelegate, LsRemoteDelegate, help
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn clone() -> crate::Result {
+async fn clone() -> Result {
     for with_keepalive in [false, true] {
         let out = Vec::new();
         let mut dlg = CloneDelegate::default();
@@ -43,7 +44,7 @@ async fn clone() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn clone_empty_with_capabilities() -> crate::Result {
+async fn clone_empty_with_capabilities() -> Result {
     let out = Vec::new();
     let mut dlg = CloneDelegate::default();
     crate::fetch(
@@ -68,7 +69,7 @@ async fn clone_empty_with_capabilities() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ls_remote() -> crate::Result {
+async fn ls_remote() -> Result {
     let out = Vec::new();
     let mut delegate = LsRemoteDelegate::default();
     let mut transport = transport(
@@ -114,7 +115,7 @@ async fn ls_remote() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ls_remote_handshake_failure_due_to_downgrade() -> crate::Result {
+async fn ls_remote_handshake_failure_due_to_downgrade() -> Result {
     let out = Vec::new();
     let delegate = LsRemoteDelegate::default();
 
diff --git a/gix-protocol/tests/protocol/fetch/v2.rs b/gix-protocol/tests/protocol/fetch/v2.rs
index 22d8c137633..181389a85e1 100644
--- a/gix-protocol/tests/protocol/fetch/v2.rs
+++ b/gix-protocol/tests/protocol/fetch/v2.rs
@@ -1,17 +1,17 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_features::progress;
 use gix_protocol::handshake;
 use gix_transport::Protocol;
 
 use crate::fetch::{
-    _impl::FetchConnection, CloneDelegate, CloneRefInWantDelegate, Error, LsRemoteDelegate, helper_unused, oid,
-    transport,
+    _impl::FetchConnection, CloneDelegate, CloneRefInWantDelegate, LsRemoteDelegate, helper_unused, oid, transport,
 };
 
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn clone_abort_prep() -> crate::Result {
+async fn clone_abort_prep() -> Result {
     let out = Vec::new();
     let mut dlg = CloneDelegate {
         abort_with: Some(std::io::Error::other("hello world")),
@@ -51,20 +51,18 @@ async fn clone_abort_prep() -> crate::Result {
         .as_bytes()
         .as_bstr()
     );
-    match err {
-        Error::Io(err) => {
-            assert_eq!(err.kind(), std::io::ErrorKind::Other);
-            assert_eq!(err.get_ref().expect("other error").to_string(), "hello world");
-        }
-        _ => panic!("should not have another error here"),
-    }
+    let err = err
+        .downcast_any_ref::<std::io::Error>()
+        .expect("delegate I/O error is retained");
+    assert_eq!(err.kind(), std::io::ErrorKind::Other);
+    insta::assert_debug_snapshot!(err.get_ref().expect("other error"), "clone abort prep", @r#""hello world""#);
     Ok(())
 }
 
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ls_remote() -> crate::Result {
+async fn ls_remote() -> Result {
     let out = Vec::new();
     let mut delegate = LsRemoteDelegate::default();
     let mut transport = transport(
@@ -121,7 +119,7 @@ async fn ls_remote() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ls_remote_abort_in_prep_ls_refs() -> crate::Result {
+async fn ls_remote_abort_in_prep_ls_refs() -> Result {
     let out = Vec::new();
     let mut delegate = LsRemoteDelegate {
         abort_with: Some(std::io::Error::other("hello world")),
@@ -150,20 +148,18 @@ async fn ls_remote_abort_in_prep_ls_refs() -> crate::Result {
         transport.into_inner().1.as_bstr(),
         b"0044git-upload-pack does/not/matter\x00\x00version=2\x00value-only\x00key=value\x000000".as_bstr()
     );
-    match err {
-        Error::Io(err) => {
-            assert_eq!(err.kind(), std::io::ErrorKind::Other);
-            assert_eq!(err.get_ref().expect("other error").to_string(), "hello world");
-        }
-        err => panic!("should not have another error here, got: {err}"),
-    }
+    let err = err
+        .downcast_any_ref::<std::io::Error>()
+        .expect("delegate I/O error is retained");
+    assert_eq!(err.kind(), std::io::ErrorKind::Other);
+    insta::assert_debug_snapshot!(err.get_ref().expect("other error"), "ls remote abort in prep ls refs", @r#""hello world""#);
     Ok(())
 }
 
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ref_in_want() -> crate::Result {
+async fn ref_in_want() -> Result {
     let out = Vec::new();
     let mut delegate = CloneRefInWantDelegate {
         want_refs: vec!["refs/heads/main".into()],
@@ -222,7 +218,7 @@ async fn ref_in_want() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn ref_in_want_sha256() -> crate::Result {
+async fn ref_in_want_sha256() -> Result {
     let out = Vec::new();
     let mut delegate = CloneRefInWantDelegate {
         want_refs: vec!["refs/heads/main".into()],
diff --git a/gix-protocol/tests/protocol/handshake.rs b/gix-protocol/tests/protocol/handshake.rs
index f5b62cd3a46..6d46f1ac3bb 100644
--- a/gix-protocol/tests/protocol/handshake.rs
+++ b/gix-protocol/tests/protocol/handshake.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use gix_transport::client::Capabilities;
 
 /// Convert a hexadecimal hash into its corresponding `ObjectId` or _panic_.
@@ -209,9 +210,7 @@ impl std::io::BufRead for Fixture<'_> {
 
 #[cfg(feature = "blocking-client")]
 impl gix_transport::client::blocking_io::ReadlineBufRead for Fixture<'_> {
-    fn readline(
-        &mut self,
-    ) -> Option<std::io::Result<Result<gix_packetline::PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    fn readline(&mut self) -> Option<std::io::Result<ExnMessageResult<gix_packetline::PacketLineRef<'_>>>> {
         use bstr::{BStr, ByteSlice};
         let bytes: &BStr = self.0.into();
         let mut lines = bytes.lines();
@@ -273,9 +272,7 @@ impl futures_io::AsyncBufRead for Fixture<'_> {
 #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
 #[async_trait::async_trait(?Send)]
 impl gix_transport::client::async_io::ReadlineBufRead for Fixture<'_> {
-    async fn readline(
-        &mut self,
-    ) -> Option<std::io::Result<Result<gix_packetline::PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    async fn readline(&mut self) -> Option<std::io::Result<ExnMessageResult<gix_packetline::PacketLineRef<'_>>>> {
         use bstr::{BStr, ByteSlice};
         let bytes: &BStr = self.0.into();
         let mut lines = bytes.lines();
diff --git a/gix-protocol/tests/protocol/mod.rs b/gix-protocol/tests/protocol/mod.rs
index 498a93a4f06..5bb5ba471cf 100644
--- a/gix-protocol/tests/protocol/mod.rs
+++ b/gix-protocol/tests/protocol/mod.rs
@@ -1,4 +1,4 @@
-pub type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+pub type Result = std::result::Result<(), Box<dyn std::error::Error + Send + Sync>>;
 
 pub fn fixture_bytes(path: &str) -> Vec<u8> {
     std::fs::read(std::path::PathBuf::from("tests").join("fixtures").join(path))
diff --git a/gix-quote/src/ansi_c.rs b/gix-quote/src/ansi_c.rs
index 8eeb9f565e3..ae2a52f169e 100644
--- a/gix-quote/src/ansi_c.rs
+++ b/gix-quote/src/ansi_c.rs
@@ -1,13 +1,7 @@
-///
-pub mod undo {
-    /// The error returned by [`ansi_c`](crate::ansi_c::undo()).
-    pub type Error = gix_error::Exn<gix_error::ValidationError>;
-}
-
 use std::{borrow::Cow, io::Read};
 
 use bstr::{BStr, BString, ByteSlice};
-use gix_error::{ErrorExt, OptionExt, ResultExt, ValidationError};
+use gix_error::{ErrorExt, ExnMessageResult, OptionExt, ResultExt};
 
 /// Quote `input` using Git's C-style quotation rules.
 ///
@@ -55,29 +49,32 @@ pub fn quote(input: &BStr) -> Cow<'_, BStr> {
 /// The amount of consumed bytes allow to pass strings that start with a quote, and skip all quoted text for additional processing
 ///
 /// A quote that is never closed is an error.
+/// Errors include the original or remaining `input` bytes as [metadata](gix_error::Exn::metadata()).
 /// See [the tests][tests] for quotation examples.
 ///
 /// [tests]: https://github.com/GitoxideLabs/gitoxide/blob/64872690e60efdd9267d517f4d9971eecd3b875c/gix-quote/tests/quote.rs#L57-L74
-pub fn undo(input: &BStr) -> Result<(Cow<'_, BStr>, usize), undo::Error> {
+pub fn undo(input: &BStr) -> ExnMessageResult<(Cow<'_, BStr>, usize)> {
     if !input.starts_with(b"\"") {
         return Ok((input.into(), input.len()));
     }
     if input.len() < 2 {
-        return Err(ValidationError::new_with_input("Input must be surrounded by double quotes", input).raise());
+        return Err(gix_error::validation("Input must be surrounded by double quotes")
+            .with("input", input)
+            .raise());
     }
     let original = input.as_bstr();
     let mut input = &input[1..];
     let mut consumed = 1;
     let mut out = BString::default();
-    fn consume_one_past(input: &mut &BStr, position: usize) -> Result<u8, undo::Error> {
-        use gix_error::{OptionExt, ValidationError};
+    fn consume_one_past(input: &mut &BStr, position: usize) -> ExnMessageResult<u8> {
+        use gix_error::OptionExt;
         *input = input
             .get(position + 1..)
-            .ok_or_raise(|| ValidationError::new_with_input("Unexpected end of input", *input))?
+            .ok_or_raise(|| gix_error::validation("Unexpected end of input").with("input", *input))?
             .as_bstr();
         let next = *input
             .first()
-            .ok_or_raise(|| ValidationError::new_with_input("Unexpected end of input", *input))?;
+            .ok_or_raise(|| gix_error::validation("Unexpected end of input").with("input", *input))?;
         *input = input.get(1..).unwrap_or_default().as_bstr();
         Ok(next)
     }
@@ -106,26 +103,24 @@ pub fn undo(input: &BStr) -> Result<(Cow<'_, BStr>, usize), undo::Error> {
                                 input
                                     .get(..2)
                                     .ok_or_raise(|| {
-                                        ValidationError::new_with_input(
+                                        gix_error::validation(
                                             "Unexpected end of input when fetching two more octal bytes",
-                                            input,
                                         )
+                                        .with("input", input)
                                     })?
                                     .read_exact(&mut buf[1..])
                                     .expect("impossible to fail as numbers match");
                                 let byte = gix_utils::btoi::to_unsigned_with_radix(&buf, 8).or_raise(|| {
-                                    ValidationError::new_with_input("Invalid octal escape value", original)
+                                    gix_error::validation("Invalid octal escape value").with("input", original)
                                 })?;
                                 out.push(byte);
                                 input = &input[2..];
                                 consumed += 2;
                             }
                             _ => {
-                                return Err(ValidationError::new_with_input(
-                                    format!("Invalid escaped value {next}"),
-                                    original,
-                                )
-                                .raise());
+                                return Err(gix_error::validation(format!("Invalid escaped value {next}"))
+                                    .with("input", original)
+                                    .raise());
                             }
                         }
                     }
@@ -133,9 +128,9 @@ pub fn undo(input: &BStr) -> Result<(Cow<'_, BStr>, usize), undo::Error> {
                 }
             }
             None => {
-                return Err(
-                    ValidationError::new_with_input("Missing closing quote in quoted string", original).raise(),
-                );
+                return Err(gix_error::validation("Missing closing quote in quoted string")
+                    .with("input", original)
+                    .raise());
             }
         }
     }
diff --git a/gix-ref/Cargo.toml b/gix-ref/Cargo.toml
index 2100883c537..565a6c216ab 100644
--- a/gix-ref/Cargo.toml
+++ b/gix-ref/Cargo.toml
@@ -37,8 +37,6 @@ gix-validate = { version = "^0.11.4", path = "../gix-validate" }
 gix-actor = { version = "^0.42.0", path = "../gix-actor" }
 gix-lock = { version = "^24.0.0", path = "../gix-lock" }
 gix-tempfile = { version = "^24.0.0", default-features = false, path = "../gix-tempfile" }
-
-thiserror = "2.0.18"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 # packed refs
diff --git a/gix-ref/fuzz/fuzz_targets/fuzz_log.rs b/gix-ref/fuzz/fuzz_targets/fuzz_log.rs
index 204ab6e7ba2..b69fa96162a 100644
--- a/gix-ref/fuzz/fuzz_targets/fuzz_log.rs
+++ b/gix-ref/fuzz/fuzz_targets/fuzz_log.rs
@@ -1,6 +1,5 @@
 #![no_main]
 
-use anyhow::Result;
 use arbitrary::Arbitrary;
 use gix_ref::file::log;
 use libfuzzer_sys::fuzz_target;
@@ -13,7 +12,7 @@ struct Ctx<'a> {
     multi_line_forward: &'a [u8],
 }
 
-fn fuzz(ctx: Ctx) -> Result<()> {
+fn fuzz(ctx: Ctx) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let line = log::LineRef::from_bytes(ctx.line_ref)?;
     _ = black_box(line.previous_oid());
     _ = black_box(line.new_oid());
diff --git a/gix-ref/fuzz/fuzz_targets/fuzz_packed_buffer.rs b/gix-ref/fuzz/fuzz_targets/fuzz_packed_buffer.rs
index 241c8cc1628..02e2ea80700 100644
--- a/gix-ref/fuzz/fuzz_targets/fuzz_packed_buffer.rs
+++ b/gix-ref/fuzz/fuzz_targets/fuzz_packed_buffer.rs
@@ -1,6 +1,5 @@
 #![no_main]
 
-use anyhow::Result;
 use arbitrary::Arbitrary;
 use bstr::BStr;
 use gix_ref::{packed::Buffer, FullNameRef};
@@ -13,7 +12,7 @@ struct Ctx<'a> {
     name: &'a [u8],
 }
 
-fn fuzz(ctx: Ctx) -> Result<()> {
+fn fuzz(ctx: Ctx) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let buffer = Buffer::from_bytes(ctx.packed_file_contents, gix_hash::Kind::Sha1)?;
     _ = black_box(buffer.iter()?.count());
 
diff --git a/gix-ref/src/lib.rs b/gix-ref/src/lib.rs
index 046d23d8f42..752f325a69c 100644
--- a/gix-ref/src/lib.rs
+++ b/gix-ref/src/lib.rs
@@ -15,6 +15,18 @@
 //!   * **packed**
 //!     * references are stored in a single human-readable file, along with their targets if they are symbolic.
 //!
+//! Concrete recovery signals such as missing references and reflog identities expose classification-only
+//! [`gix_error::ClassificationMarker`] sources. Use `is_not_found()`, `is_corrupted()`, `is_validation()`, or
+//! `classify()` on [`gix_error::Exn`] and [`gix_error::Error`] rather than downcasting these sources to classifier
+//! error types. Callee errors retain their concrete causes. Locally detected failures may use a single classified
+//! [`gix_error::Message`] containing both the diagnostic and its values.
+//! Operations return [`gix_error::Exn`], with diagnostic [`gix_error::Message`] keys documented where they are added.
+//! Inspect these dictionaries with [`metadata()`](gix_error::Exn::metadata), and add context available at the call site.
+//! For recovery, downcast to [`file::find::NotFound`] to distinguish an absent reference from an absent object,
+//! [`file::find::ReferenceDecode`] for loose reference contents that could not be decoded,
+//! [`file::transaction::prepare::ReferenceOutOfDate`] or [`file::transaction::prepare::MustNotExist`] for a failed
+//! update constraint, and [`file::log::create_or_update::MissingCommitter`] for a missing reflog identity.
+//!
 //! ## Feature Flags
 #![cfg_attr(
     all(doc, feature = "document-features"),
@@ -50,9 +62,6 @@ mod target;
 ///
 pub mod log;
 
-///
-pub mod peel;
-
 ///
 pub mod store {
     ///
diff --git a/gix-ref/src/name.rs b/gix-ref/src/name.rs
index 70a36f2190a..04aa7233c38 100644
--- a/gix-ref/src/name.rs
+++ b/gix-ref/src/name.rs
@@ -132,10 +132,12 @@ impl<'a> From<&'a FullNameRef> for &'a PartialNameRef {
 }
 
 impl<'a> convert::TryFrom<&'a OsStr> for &'a PartialNameRef {
-    type Error = Error;
+    type Error = gix_error::Exn<Error>;
 
     fn try_from(v: &'a OsStr) -> Result<Self, Self::Error> {
-        let v = gix_path::os_str_into_bstr(v).map_err(|_| Error::InvalidByte {
+        use gix_error::ResultExt;
+
+        let v = gix_path::os_str_into_bstr(v).or_raise(|| Error::InvalidByte {
             byte: "<unknown encoding>".into(),
         })?;
         Ok(PartialNameRef::new_unchecked(gix_validate::reference::name_partial(
diff --git a/gix-ref/src/peel.rs b/gix-ref/src/peel.rs
deleted file mode 100644
index b4b48102cf3..00000000000
--- a/gix-ref/src/peel.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-///
-pub mod to_id {
-    use gix_object::bstr::BString;
-
-    /// The error returned by [`crate::file::ReferenceExt::peel_to_id()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FollowToObject(#[from] super::to_object::Error),
-        #[error("An error occurred when trying to resolve an object a reference points to")]
-        Find(#[from] gix_object::find::Error),
-        #[error("Object {oid} as referred to by {name:?} could not be found")]
-        NotFound { oid: gix_hash::ObjectId, name: BString },
-    }
-}
-
-///
-pub mod to_object {
-    use std::path::PathBuf;
-
-    use crate::file;
-
-    /// The error returned by [`file::ReferenceExt::follow_to_object_packed()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not follow a single level of a symbolic reference")]
-        Follow(#[from] file::find::existing::Error),
-        #[error("Aborting due to reference cycle with first seen path being {start_absolute:?}")]
-        Cycle { start_absolute: PathBuf },
-        #[error("Refusing to follow more than {max_depth} levels of indirection")]
-        DepthLimitExceeded { max_depth: usize },
-    }
-}
diff --git a/gix-ref/src/store/file/find.rs b/gix-ref/src/store/file/find.rs
index 82d657bc66f..07103402bb1 100644
--- a/gix-ref/src/store/file/find.rs
+++ b/gix-ref/src/store/file/find.rs
@@ -1,11 +1,11 @@
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, message};
+
 use std::{
     borrow::Cow,
     io::{self, Read},
     path::{Path, PathBuf},
 };
 
-pub use error::Error;
-
 use crate::{
     BStr, BString, FullNameRef, PartialName, PartialNameRef, Reference, file,
     name::is_pseudo_ref,
@@ -34,27 +34,37 @@ impl file::Store {
     ///   for a version with more control.
     ///
     /// [git-lookup-docs]: https://github.com/git/git/blob/5d5b1473453400224ebb126bf3947e0a3276bdf5/Documentation/revisions.txt#L34-L46
-    pub fn try_find<'a, Name, E>(&self, partial: Name) -> Result<Option<Reference>, Error>
+    pub fn try_find<'a, Name, E>(&self, partial: Name) -> ExnResult<Option<Reference>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
         let packed = self.assure_packed_refs_uptodate()?;
-        self.find_one_with_verified_input(partial.try_into()?, packed.as_ref().map(|b| &***b))
+        self.find_one_with_verified_input(
+            partial
+                .try_into()
+                .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?,
+            packed.as_ref().map(|b| &***b),
+        )
     }
 
-    /// Similar to [`file::Store::find()`] but a non-existing ref is treated as error.
+    /// Like [`file::Store::try_find()`], returning `None` for a non-existing reference.
     ///
     /// Find only loose references, that is references that aren't in the packed-refs buffer.
     /// All symbolic references are loose references.
     /// `HEAD` is always a loose reference.
-    pub fn try_find_loose<'a, Name, E>(&self, partial: Name) -> Result<Option<loose::Reference>, Error>
+    pub fn try_find_loose<'a, Name, E>(&self, partial: Name) -> ExnResult<Option<loose::Reference>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        self.find_one_with_verified_input(partial.try_into()?, None)
-            .map(|r| r.map(Into::into))
+        self.find_one_with_verified_input(
+            partial
+                .try_into()
+                .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?,
+            None,
+        )
+        .map(|r| r.map(Into::into))
     }
 
     /// Similar to [`file::Store::find()`], but allows to pass a snapshotted packed buffer instead.
@@ -62,19 +72,24 @@ impl file::Store {
         &self,
         partial: Name,
         packed: Option<&packed::Buffer>,
-    ) -> Result<Option<Reference>, Error>
+    ) -> ExnResult<Option<Reference>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        self.find_one_with_verified_input(partial.try_into()?, packed)
+        self.find_one_with_verified_input(
+            partial
+                .try_into()
+                .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?,
+            packed,
+        )
     }
 
     pub(crate) fn find_one_with_verified_input(
         &self,
         partial_name: &PartialNameRef,
         packed: Option<&packed::Buffer>,
-    ) -> Result<Option<Reference>, Error> {
+    ) -> ExnResult<Option<Reference>> {
         fn decompose_if(mut r: Reference, input_changed_to_precomposed: bool) -> Reference {
             if input_changed_to_precomposed {
                 use gix_object::bstr::ByteSlice;
@@ -152,6 +167,8 @@ impl file::Store {
         }
     }
 
+    /// Resolve and read a candidate. Read failures include [metadata](gix_error::Exn::metadata()) `path` (native path),
+    /// the file that failed.
     fn find_inner(
         &self,
         inbetween: &str,
@@ -160,7 +177,7 @@ impl file::Store {
         packed: Option<&packed::Buffer>,
         path_buf: &mut BString,
         consider_pseudo_ref: bool,
-    ) -> Result<Option<Reference>, Error> {
+    ) -> ExnResult<Option<Reference>> {
         let full_name = precomposed_partial_name
             .unwrap_or(partial_name)
             .construct_full_name_ref(inbetween, path_buf, consider_pseudo_ref);
@@ -168,10 +185,9 @@ impl file::Store {
             Ok(content_buf) => content_buf,
             Err(err) if err.kind() == io::ErrorKind::NotADirectory => return Ok(None),
             Err(err) => {
-                return Err(Error::ReadFileContents {
-                    source: err,
-                    path: self.reference_path(full_name),
-                });
+                return Err(err
+                    .and_raise(read_reference_error(self.reference_path(full_name)))
+                    .erased());
             }
         };
 
@@ -207,8 +223,7 @@ impl file::Store {
                         }
                         r
                     })
-                    .map_err(|err| Error::ReferenceCreation {
-                        source: err,
+                    .or_raise_erased(|| ReferenceDecode {
                         relative_path: full_name.to_path().to_owned(),
                     })?,
             )),
@@ -349,119 +364,98 @@ fn path_has_file_prefix(base: &Path, relative_path: &Path) -> bool {
     false
 }
 
-///
-pub mod existing {
-    pub use error::Error;
-
-    use crate::{
-        PartialNameRef, Reference,
-        file::{self},
-        store_impl::{
-            file::{find, loose},
-            packed,
-        },
-    };
-
-    impl file::Store {
-        /// Similar to [`file::Store::try_find()`] but a non-existing ref is treated as error.
-        pub fn find<'a, Name, E>(&self, partial: Name) -> Result<Reference, Error>
-        where
-            Name: TryInto<&'a PartialNameRef, Error = E>,
-            crate::name::Error: From<E>,
-        {
-            let packed = self.assure_packed_refs_uptodate().map_err(find::Error::PackedOpen)?;
-            self.find_existing_inner(partial, packed.as_ref().map(|b| &***b))
-        }
+impl file::Store {
+    /// Similar to [`file::Store::try_find()`] but a non-existing ref is treated as error.
+    pub fn find<'a, Name, E>(&self, partial: Name) -> ExnResult<Reference>
+    where
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
+    {
+        let packed = self.assure_packed_refs_uptodate()?;
+        self.find_existing_inner(partial, packed.as_ref().map(|b| &***b))
+    }
 
-        /// Similar to [`file::Store::find()`], but supports a stable packed buffer.
-        pub fn find_packed<'a, Name, E>(
-            &self,
-            partial: Name,
-            packed: Option<&packed::Buffer>,
-        ) -> Result<Reference, Error>
-        where
-            Name: TryInto<&'a PartialNameRef, Error = E>,
-            crate::name::Error: From<E>,
-        {
-            self.find_existing_inner(partial, packed)
-        }
+    /// Similar to [`file::Store::find()`], but supports a stable packed buffer.
+    pub fn find_packed<'a, Name, E>(&self, partial: Name, packed: Option<&packed::Buffer>) -> ExnResult<Reference>
+    where
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
+    {
+        self.find_existing_inner(partial, packed)
+    }
 
-        /// Similar to [`file::Store::find()`] won't handle packed-refs.
-        pub fn find_loose<'a, Name, E>(&self, partial: Name) -> Result<loose::Reference, Error>
-        where
-            Name: TryInto<&'a PartialNameRef, Error = E>,
-            crate::name::Error: From<E>,
-        {
-            self.find_existing_inner(partial, None).map(Into::into)
-        }
+    /// Similar to [`file::Store::find()`] won't handle packed-refs.
+    pub fn find_loose<'a, Name, E>(&self, partial: Name) -> ExnResult<loose::Reference>
+    where
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
+    {
+        self.find_existing_inner(partial, None).map(Into::into)
+    }
 
-        /// Similar to [`file::Store::find()`] but a non-existing ref is treated as error.
-        pub(crate) fn find_existing_inner<'a, Name, E>(
-            &self,
-            partial: Name,
-            packed: Option<&packed::Buffer>,
-        ) -> Result<Reference, Error>
-        where
-            Name: TryInto<&'a PartialNameRef, Error = E>,
-            crate::name::Error: From<E>,
-        {
-            let path = partial
-                .try_into()
-                .map_err(|err| Error::Find(find::Error::RefnameValidation(err.into())))?;
-            match self.find_one_with_verified_input(path, packed) {
-                Ok(Some(r)) => Ok(r),
-                Ok(None) => Err(Error::NotFound {
-                    name: path.to_partial_path().to_owned(),
-                }),
-                Err(err) => Err(err.into()),
+    /// Similar to [`file::Store::find()`] but a non-existing ref is treated as error.
+    pub(crate) fn find_existing_inner<'a, Name, E>(
+        &self,
+        partial: Name,
+        packed: Option<&packed::Buffer>,
+    ) -> ExnResult<Reference>
+    where
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
+    {
+        let path = partial
+            .try_into()
+            .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?;
+        match self.find_one_with_verified_input(path, packed) {
+            Ok(Some(r)) => Ok(r),
+            Ok(None) => Err(NotFound {
+                name: path.to_partial_path().to_owned(),
             }
+            .raise_erased()),
+            Err(err) => Err(err),
         }
     }
+}
 
-    mod error {
-        use std::path::PathBuf;
+/// The raised error's [metadata](gix_error::Exn::metadata()) `path` (native path) identifies the reference file that
+/// could not be read.
+pub(super) fn read_reference_error(path: impl Into<PathBuf>) -> Message {
+    Message::new("Could not read reference").with("path", path.into())
+}
 
-        use crate::store_impl::file::find;
+/// A reference lookup found no matching name, including a missing symbolic referent.
+#[derive(Debug)]
+pub struct NotFound {
+    /// The name whose lookup failed. It may have been discovered while following symbolic references.
+    pub name: PathBuf,
+}
 
-        /// The error returned by [file::Store::find_existing()][crate::file::Store::find()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("An error occurred while trying to find a reference")]
-            Find(#[from] find::Error),
-            #[error("The ref partially named {name:?} could not be found")]
-            NotFound { name: PathBuf },
-        }
+impl std::fmt::Display for NotFound {
+    #[allow(clippy::unnecessary_debug_formatting)]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "The ref partially named {:?} could not be found", self.name)
     }
 }
 
-mod error {
-    use std::{convert::Infallible, io, path::PathBuf};
-
-    use crate::{file, store_impl::packed};
-
-    /// The error returned by [file::Store::find()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The ref name or path is not a valid ref name")]
-        RefnameValidation(#[from] crate::name::Error),
-        #[error("The ref file {path:?} could not be read in full")]
-        ReadFileContents { source: io::Error, path: PathBuf },
-        #[error("The reference at \"{relative_path}\" could not be instantiated")]
-        ReferenceCreation {
-            source: file::loose::reference::decode::Error,
-            relative_path: PathBuf,
-        },
-        #[error("A packed ref lookup failed")]
-        PackedRef(#[from] packed::find::Error),
-        #[error("Could not open the packed refs buffer when trying to find references.")]
-        PackedOpen(#[from] packed::buffer::open::Error),
+impl std::error::Error for NotFound {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::NOT_FOUND })
     }
+}
 
-    impl From<Infallible> for Error {
-        fn from(_: Infallible) -> Self {
-            unreachable!("this impl is needed to allow passing a known valid partial path as parameter")
-        }
+/// A loose reference was found at this path, but its contents could not be decoded.
+/// The decoding error is retained as a cause in the exception.
+#[derive(Debug)]
+pub struct ReferenceDecode {
+    /// The resolved reference path, relative to the Git directory.
+    pub relative_path: PathBuf,
+}
+
+impl std::fmt::Display for ReferenceDecode {
+    #[allow(clippy::unnecessary_debug_formatting)]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "The reference at {:?} could not be decoded", self.relative_path)
     }
 }
+
+impl std::error::Error for ReferenceDecode {}
diff --git a/gix-ref/src/store/file/log/iter.rs b/gix-ref/src/store/file/log/iter.rs
index 5231bb0efb3..84d84343883 100644
--- a/gix-ref/src/store/file/log/iter.rs
+++ b/gix-ref/src/store/file/log/iter.rs
@@ -1,52 +1,8 @@
-use gix_object::bstr::ByteSlice;
-
-use crate::{
-    FullNameRef, file,
-    file::loose::reference::logiter::must_be_io_err,
-    store_impl::file::{log, log::iter::decode::LineNumber},
-};
-
-///
-pub mod decode {
-    use crate::store_impl::file::log;
-
-    /// The error returned by items in the [forward][super::forward()] and [reverse][super::reverse()] iterators
-    #[derive(Debug)]
-    pub struct Error {
-        inner: log::line::decode::Error,
-        line: LineNumber,
-    }
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "In line {}: {}", self.line, self.inner)
-        }
-    }
-
-    impl std::error::Error for Error {}
-
-    impl Error {
-        pub(crate) fn new(err: log::line::decode::Error, line: LineNumber) -> Self {
-            Error { line, inner: err }
-        }
-    }
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, Message, ResultExt};
 
-    #[derive(Debug)]
-    pub(crate) enum LineNumber {
-        FromStart(usize),
-        FromEnd(usize),
-    }
+use gix_object::bstr::ByteSlice;
 
-    impl std::fmt::Display for LineNumber {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            let (line, suffix) = match self {
-                LineNumber::FromStart(line) => (line, ""),
-                LineNumber::FromEnd(line) => (line, " from the end"),
-            };
-            write!(f, "{}{}", line + 1, suffix)
-        }
-    }
-}
+use crate::{FullNameRef, file, store_impl::file::log};
 
 /// Returns a forward iterator over the given `lines`, starting from the first line in the file and ending at the last.
 ///
@@ -67,12 +23,14 @@ pub struct Forward<'a> {
 }
 
 impl<'a> Iterator for Forward<'a> {
-    type Item = Result<log::LineRef<'a>, decode::Error>;
+    type Item = ExnMessageResult<log::LineRef<'a>>;
 
+    /// Decode failures include [metadata](gix_error::Exn::metadata()) `line` (one-based position) and `from_end`
+    /// (whether counting from the end).
     fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(|(ln, line)| {
-            log::LineRef::from_bytes(line).map_err(|err| decode::Error::new(err, decode::LineNumber::FromStart(ln)))
-        })
+        self.inner
+            .next()
+            .map(|(ln, line)| log::LineRef::from_bytes(line).or_raise(|| invalid_reflog_entry(ln + 1, false)))
     }
 }
 
@@ -92,15 +50,13 @@ impl Platform<'_, '_> {
     pub fn rev(&mut self) -> std::io::Result<Option<log::iter::Reverse<'_, std::fs::File>>> {
         self.buf.clear();
         self.buf.resize(1024 * 4, 0);
-        self.store
-            .reflog_iter_rev(self.name, &mut self.buf)
-            .map_err(must_be_io_err)
+        self.store.reflog_iter_rev_inner(self.name, &mut self.buf)
     }
 
     /// Return a forward iterator over all log-lines, oldest to most recent.
     pub fn all(&mut self) -> std::io::Result<Option<log::iter::Forward<'_>>> {
         self.buf.clear();
-        self.store.reflog_iter(self.name, &mut self.buf).map_err(must_be_io_err)
+        self.store.reflog_iter_inner(self.name, &mut self.buf)
     }
 }
 
@@ -140,35 +96,21 @@ where
     })
 }
 
-///
-pub mod reverse {
-
-    use super::decode;
-
-    /// The error returned by the [`Reverse`][super::Reverse] iterator
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The buffer could not be filled to make more lines available")]
-        Io(#[from] std::io::Error),
-        #[error("Could not decode log line")]
-        Decode(#[from] decode::Error),
-    }
-}
-
 impl<F> Iterator for Reverse<'_, F>
 where
     F: std::io::Read + std::io::Seek,
 {
-    type Item = Result<crate::log::Line, reverse::Error>;
+    type Item = ExnResult<crate::log::Line>;
 
+    /// Decode failures include [metadata](gix_error::Exn::metadata()) `line` (one-based position) and `from_end`
+    /// (whether counting from the end).
     fn next(&mut self) -> Option<Self::Item> {
         match (self.last_nl_pos.take(), self.read_and_pos.take()) {
             // Initial state - load first data block
             (None, Some((mut read, pos))) => {
                 let npos = pos.saturating_sub(self.buf.len() as u64);
                 if let Err(err) = read.seek(std::io::SeekFrom::Start(npos)) {
-                    return Some(Err(err.into()));
+                    return Some(Err(err.raise_erased()));
                 }
 
                 let n = (pos - npos) as usize;
@@ -177,7 +119,7 @@ where
                 }
                 let buf = &mut self.buf[..n];
                 if let Err(err) = read.read_exact(buf) {
-                    return Some(Err(err.into()));
+                    return Some(Err(err.raise_erased()));
                 }
 
                 let last_byte = *buf.last().expect("we have read non-zero bytes before");
@@ -193,9 +135,7 @@ where
                     let buf = &self.buf[start + 1..end];
                     let res = Some(
                         log::LineRef::from_bytes(buf)
-                            .map_err(|err| {
-                                reverse::Error::Decode(decode::Error::new(err, LineNumber::FromEnd(self.count)))
-                            })
+                            .or_raise_erased(|| invalid_reflog_entry(self.count + 1, true))
                             .map(Into::into),
                     );
                     self.count += 1;
@@ -207,9 +147,7 @@ where
                         let buf = &self.buf[..end];
                         Some(
                             log::LineRef::from_bytes(buf)
-                                .map_err(|err| {
-                                    reverse::Error::Decode(decode::Error::new(err, LineNumber::FromEnd(self.count)))
-                                })
+                                .or_raise_erased(|| invalid_reflog_entry(self.count + 1, true))
                                 .map(Into::into),
                         )
                     } else {
@@ -219,15 +157,15 @@ where
                                 "buffer too small for line size, got until {:?}",
                                 self.buf.as_bstr()
                             ))
-                            .into()));
+                            .raise_erased()));
                         }
                         let n = (last_read_pos - npos) as usize;
                         self.buf.copy_within(0..end, n);
                         if let Err(err) = read.seek(std::io::SeekFrom::Start(npos)) {
-                            return Some(Err(err.into()));
+                            return Some(Err(err.raise_erased()));
                         }
                         if let Err(err) = read.read_exact(&mut self.buf[..n]) {
-                            return Some(Err(err.into()));
+                            return Some(Err(err.raise_erased()));
                         }
                         self.read_and_pos = Some((read, npos));
                         self.last_nl_pos = Some(n + end);
@@ -241,3 +179,9 @@ where
         }
     }
 }
+
+fn invalid_reflog_entry(line: usize, from_end: bool) -> Message {
+    Message::new("Invalid reflog entry")
+        .with("line", line)
+        .with("from_end", from_end)
+}
diff --git a/gix-ref/src/store/file/log/line.rs b/gix-ref/src/store/file/log/line.rs
index 43fa2b53a1f..2b7e32be183 100644
--- a/gix-ref/src/store/file/log/line.rs
+++ b/gix-ref/src/store/file/log/line.rs
@@ -10,38 +10,30 @@ impl LineRef<'_> {
 }
 
 mod write {
+    use gix_error::ExnMessageResult;
     use std::io;
 
     use gix_object::bstr::{BStr, ByteSlice};
 
     use crate::log::Line;
 
-    /// The Error produced by [`Line::write_to()`] (but wrapped in an io error).
-    #[derive(Debug, thiserror::Error)]
-    enum Error {
-        #[error(r"Messages must not contain newlines (\n)")]
-        IllegalCharacter,
-    }
-
-    impl From<Error> for io::Error {
-        fn from(err: Error) -> Self {
-            io::Error::other(err)
-        }
-    }
-
     /// Output
     impl Line {
         /// Serialize this instance to `out` in the git serialization format for ref log lines.
         pub fn write_to(&self, out: &mut dyn io::Write) -> io::Result<()> {
             write!(out, "{} {} ", self.previous_oid, self.new_oid)?;
             self.signature.write_to(out)?;
-            writeln!(out, "\t{}", check_newlines(self.message.as_ref())?)
+            writeln!(
+                out,
+                "\t{}",
+                check_newlines(self.message.as_ref()).map_err(io::Error::other)?
+            )
         }
     }
 
-    fn check_newlines(input: &BStr) -> Result<&BStr, Error> {
+    fn check_newlines(input: &BStr) -> ExnMessageResult<&BStr> {
         if input.find_byte(b'\n').is_some() {
-            return Err(Error::IllegalCharacter);
+            return Err(gix_error::validation(r"Messages must not contain newlines (\n)").into());
         }
         Ok(input)
     }
@@ -70,44 +62,12 @@ impl<'a> From<LineRef<'a>> for Line {
     }
 }
 
-///
-pub mod decode {
+mod decode {
+    use gix_error::{ErrorExt, ExnMessageResult, Message, ResultExt};
     use gix_object::bstr::{BStr, ByteSlice};
 
     use crate::{file::log::LineRef, parse::hex_hash_any};
 
-    ///
-    mod error {
-        use gix_object::bstr::{BString, ByteSlice};
-
-        /// The error returned by [`from_bytes(…)`][super::Line::from_bytes()]
-        #[derive(Debug)]
-        pub struct Error {
-            pub input: BString,
-        }
-
-        impl std::fmt::Display for Error {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(
-                    f,
-                    r"{:?} did not match '<old-hexsha> <new-hexsha> <name> <<email>> <timestamp> <tz>\t<message>'",
-                    self.input
-                )
-            }
-        }
-
-        impl std::error::Error for Error {}
-
-        impl Error {
-            pub(crate) fn new(input: &[u8]) -> Self {
-                Error {
-                    input: input.as_bstr().to_owned(),
-                }
-            }
-        }
-    }
-    pub use error::Error;
-
     impl<'a> LineRef<'a> {
         /// Decode a reflog line from the given bytes.
         ///
@@ -115,8 +75,11 @@ pub mod decode {
         /// signature, and an optional tab-separated message, for example:
         ///
         /// `0123456789012345678901234567890123456789 89abcdef89abcdef89abcdef89abcdef89abcdef Name <name@example.com> 1700000000 +0000\tmessage`
-        pub fn from_bytes(input: &'a [u8]) -> Result<LineRef<'a>, Error> {
-            decode(input).map_err(|_| Error::new(first_line(input)))
+        ///
+        /// Errors include [metadata](gix_error::Exn::metadata()) `input` (bytes), the first input line without its
+        /// trailing newline.
+        pub fn from_bytes(input: &'a [u8]) -> ExnMessageResult<LineRef<'a>> {
+            decode(input).or_raise(|| Message::new("Could not decode reflog line").with("input", first_line(input)))
         }
     }
 
@@ -135,20 +98,22 @@ pub mod decode {
     ///
     /// Return an error if the first line does not match the reflog line
     /// format.
-    fn decode(bytes: &[u8]) -> Result<LineRef<'_>, ()> {
+    fn decode(bytes: &[u8]) -> ExnMessageResult<LineRef<'_>> {
+        let invalid = || gix_error::corruption("Malformed reflog line");
         let line = first_line(bytes);
         let (mut head, message) = match line.find_byte(b'\t') {
             Some(tab) => (&line[..tab], line[tab + 1..].as_bstr()),
             None => (line, BStr::new(b"")),
         };
 
-        let old = hex_hash_any(&mut head)?;
-        head = head.strip_prefix(b" ").ok_or(())?;
-        let new = hex_hash_any(&mut head)?;
-        head = head.strip_prefix(b" ").ok_or(())?;
-        let signature = gix_actor::signature::decode(&mut head).map_err(|_| ())?;
+        let old = hex_hash_any(&mut head).map_err(|()| invalid())?;
+        head = head.strip_prefix(b" ").ok_or_else(invalid)?;
+        let new = hex_hash_any(&mut head).map_err(|()| invalid())?;
+        head = head.strip_prefix(b" ").ok_or_else(invalid)?;
+        let signature =
+            gix_actor::signature::decode(&mut head).or_raise(|| gix_error::corruption("Invalid reflog signature"))?;
         if !head.is_empty() {
-            return Err(());
+            return Err(invalid().raise());
         }
         Ok(LineRef {
             previous_oid: old,
diff --git a/gix-ref/src/store/file/log/mod.rs b/gix-ref/src/store/file/log/mod.rs
index 3ba2582308c..da583da3805 100644
--- a/gix-ref/src/store/file/log/mod.rs
+++ b/gix-ref/src/store/file/log/mod.rs
@@ -1,6 +1,6 @@
 use gix_object::bstr::BStr;
 
-pub use super::loose::reflog::{Error, create_or_update};
+pub use super::loose::reflog::create_or_update;
 
 ///
 pub mod iter;
diff --git a/gix-ref/src/store/file/loose/reference/decode.rs b/gix-ref/src/store/file/loose/reference/decode.rs
index ddad5ecb87c..38a62299b69 100644
--- a/gix-ref/src/store/file/loose/reference/decode.rs
+++ b/gix-ref/src/store/file/loose/reference/decode.rs
@@ -1,3 +1,5 @@
+use gix_error::{ErrorExt, Exn, ExnResult, Message, ResultExt, message};
+
 use gix_hash::ObjectId;
 use gix_object::bstr::BString;
 
@@ -8,37 +10,27 @@ enum MaybeUnsafeState {
     UnvalidatedPath(BString),
 }
 
-/// The error returned by [`Reference::try_from_path()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    /// Git's placeholder for an unsupported backend, such as reftable, was encountered.
-    #[error("This reference uses an unsupported storage backend, such as reftable")]
-    UnsupportedStorage,
-    #[error("{content:?} could not be parsed")]
-    Parse { content: BString },
-    #[error("The path {path:?} to a symbolic reference within a ref file is invalid")]
-    RefnameValidation {
-        source: gix_validate::reference::name::Error,
-        path: BString,
-    },
-}
-
 impl TryFrom<MaybeUnsafeState> for Target {
-    type Error = Error;
+    type Error = Exn;
 
+    /// Invalid symbolic targets include [metadata](gix_error::Exn::metadata()) `target` (bytes), as read from the
+    /// reference contents.
     fn try_from(v: MaybeUnsafeState) -> Result<Self, Self::Error> {
         Ok(match v {
             MaybeUnsafeState::Id(id) => Target::Object(id),
             MaybeUnsafeState::UnvalidatedPath(name) => {
                 Target::Symbolic(match gix_validate::reference::name(name.as_ref()) {
                     Ok(_) => FullName(name),
-                    Err(_) if name == "refs/heads/.invalid" => return Err(Error::UnsupportedStorage),
+                    Err(_) if name == "refs/heads/.invalid" => {
+                        return Err(
+                            message("This reference uses an unsupported storage backend, such as reftable")
+                                .raise_erased(),
+                        );
+                    }
                     Err(err) => {
-                        return Err(Error::RefnameValidation {
-                            source: err,
-                            path: name,
-                        });
+                        return Err(err
+                            .and_raise(Message::new("Invalid symbolic reference target").with("target", name))
+                            .erased());
                     }
                 })
             }
@@ -49,14 +41,17 @@ impl TryFrom<MaybeUnsafeState> for Target {
 impl Reference {
     /// Create a new reference named `name` from the loose reference file contents in `path_contents`,
     /// parsing object ids as `object_hash`.
-    pub fn try_from_path(name: FullName, path_contents: &[u8], object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    ///
+    /// Errors include [metadata](gix_error::Exn::metadata()) `input` (bytes), the supplied reference contents.
+    pub fn try_from_path(name: FullName, path_contents: &[u8], object_hash: gix_hash::Kind) -> ExnResult<Self> {
         Ok(Reference {
             name,
-            target: parse(path_contents, object_hash)
-                .map_err(|_| Error::Parse {
-                    content: path_contents.into(),
-                })?
-                .try_into()?,
+            target: Target::try_from(parse(path_contents, object_hash).map_err(|()| {
+                gix_error::corruption("Reference content could not be parsed")
+                    .with("input", path_contents)
+                    .raise_erased()
+            })?)
+            .or_raise_erased(|| Message::new("Could not decode reference").with("input", path_contents))?,
         })
     }
 }
diff --git a/gix-ref/src/store/file/loose/reference/logiter.rs b/gix-ref/src/store/file/loose/reference/logiter.rs
index 0bc81f22de9..ee54c66128f 100644
--- a/gix-ref/src/store/file/loose/reference/logiter.rs
+++ b/gix-ref/src/store/file/loose/reference/logiter.rs
@@ -1,14 +1,8 @@
 use crate::store_impl::{
     file,
-    file::{log, loose, loose::Reference},
+    file::{log, loose::Reference},
 };
-
-pub(crate) fn must_be_io_err(err: loose::reflog::Error) -> std::io::Error {
-    match err {
-        loose::reflog::Error::Io(err) => err,
-        loose::reflog::Error::RefnameValidation(_) => unreachable!("we are called from a valid ref"),
-    }
-}
+use gix_error::ExnMessageResult;
 
 impl Reference {
     /// Returns true if a reflog exists in the given `store`.
@@ -30,7 +24,7 @@ impl Reference {
         store: &file::Store,
         buf: &'b mut [u8],
     ) -> std::io::Result<Option<log::iter::Reverse<'b, std::fs::File>>> {
-        store.reflog_iter_rev(self.name.as_ref(), buf).map_err(must_be_io_err)
+        store.reflog_iter_rev_inner(self.name.as_ref(), buf)
     }
 
     /// Return a reflog forward iterator for this ref and write its file contents into `buf`, in the given `store`.
@@ -41,7 +35,7 @@ impl Reference {
         &'a self,
         store: &file::Store,
         buf: &'b mut Vec<u8>,
-    ) -> std::io::Result<Option<impl Iterator<Item = Result<log::LineRef<'b>, log::iter::decode::Error>> + 'a>> {
-        store.reflog_iter(self.name.as_ref(), buf).map_err(must_be_io_err)
+    ) -> std::io::Result<Option<impl Iterator<Item = ExnMessageResult<log::LineRef<'b>>> + 'a>> {
+        store.reflog_iter_inner(self.name.as_ref(), buf)
     }
 }
diff --git a/gix-ref/src/store/file/loose/reflog.rs b/gix-ref/src/store/file/loose/reflog.rs
index afc70fc23f2..55764348326 100644
--- a/gix-ref/src/store/file/loose/reflog.rs
+++ b/gix-ref/src/store/file/loose/reflog.rs
@@ -1,3 +1,5 @@
+use gix_error::{ExnResult, Message, ResultExt, message};
+
 use std::{io::Read, path::PathBuf};
 
 use crate::{
@@ -14,7 +16,6 @@ impl file::Store {
     pub fn reflog_exists<'a, Name, E>(&self, name: Name) -> Result<bool, E>
     where
         Name: TryInto<&'a FullNameRef, Error = E>,
-        crate::name::Error: From<E>,
     {
         Ok(self.reflog_path(name.try_into()?).is_file())
     }
@@ -23,16 +24,29 @@ impl file::Store {
     ///
     /// The iterator will traverse log entries from most recent to oldest, reading the underlying file in chunks from the back.
     /// Return `Ok(None)` if no reflog exists.
+    ///
+    /// Read failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the resolved reflog path.
     pub fn reflog_iter_rev<'a, 'b, Name, E>(
         &self,
         name: Name,
         buf: &'b mut [u8],
-    ) -> Result<Option<log::iter::Reverse<'b, std::fs::File>>, Error>
+    ) -> ExnResult<Option<log::iter::Reverse<'b, std::fs::File>>>
     where
         Name: TryInto<&'a FullNameRef, Error = E>,
-        crate::name::Error: From<E>,
+        Result<&'a FullNameRef, E>: ResultExt<Success = &'a FullNameRef>,
     {
-        let name: &FullNameRef = name.try_into().map_err(|err| Error::RefnameValidation(err.into()))?;
+        let name = name
+            .try_into()
+            .or_raise_erased(|| message("The reflog name or path is not a valid ref name"))?;
+        self.reflog_iter_rev_inner(name, buf)
+            .or_raise_erased(|| read_reflog_error(self.reflog_path(name)))
+    }
+
+    pub(crate) fn reflog_iter_rev_inner<'b>(
+        &self,
+        name: &FullNameRef,
+        buf: &'b mut [u8],
+    ) -> std::io::Result<Option<log::iter::Reverse<'b, std::fs::File>>> {
         let path = self.reflog_path(name);
         if path.is_dir() {
             return Ok(None);
@@ -40,7 +54,7 @@ impl file::Store {
         match std::fs::File::open(&path) {
             Ok(file) => Ok(Some(log::iter::reverse(file, buf)?)),
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
-            Err(err) => Err(err.into()),
+            Err(err) => Err(err),
         }
     }
 
@@ -48,29 +62,42 @@ impl file::Store {
     ///
     /// The iterator will traverse log entries from oldest to newest.
     /// Return `Ok(None)` if no reflog exists.
+    ///
+    /// Read failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the resolved reflog path.
     pub fn reflog_iter<'a, 'b, Name, E>(
         &self,
         name: Name,
         buf: &'b mut Vec<u8>,
-    ) -> Result<Option<log::iter::Forward<'b>>, Error>
+    ) -> ExnResult<Option<log::iter::Forward<'b>>>
     where
         Name: TryInto<&'a FullNameRef, Error = E>,
-        crate::name::Error: From<E>,
+        Result<&'a FullNameRef, E>: ResultExt<Success = &'a FullNameRef>,
     {
-        let name: &FullNameRef = name.try_into().map_err(|err| Error::RefnameValidation(err.into()))?;
+        let name = name
+            .try_into()
+            .or_raise_erased(|| message("The reflog name or path is not a valid ref name"))?;
+        self.reflog_iter_inner(name, buf)
+            .or_raise_erased(|| read_reflog_error(self.reflog_path(name)))
+    }
+
+    pub(crate) fn reflog_iter_inner<'b>(
+        &self,
+        name: &FullNameRef,
+        buf: &'b mut Vec<u8>,
+    ) -> std::io::Result<Option<log::iter::Forward<'b>>> {
         let path = self.reflog_path(name);
         match std::fs::File::open(&path) {
             Ok(mut file) => {
                 buf.clear();
                 if let Err(err) = file.read_to_end(buf) {
-                    return if path.is_dir() { Ok(None) } else { Err(err.into()) };
+                    return if path.is_dir() { Ok(None) } else { Err(err) };
                 }
                 Ok(Some(log::iter::forward(buf)))
             }
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
             #[cfg(windows)]
             Err(err) if err.kind() == std::io::ErrorKind::PermissionDenied => Ok(None),
-            Err(err) => Err(err.into()),
+            Err(err) => Err(err),
         }
     }
 }
@@ -83,6 +110,12 @@ impl file::Store {
     }
 }
 
+/// The raised error's [metadata](gix_error::Exn::metadata()) `path` (native path) identifies the resolved reflog path
+/// that could not be read.
+fn read_reflog_error(path: PathBuf) -> Message {
+    Message::new("Could not read reflog").with("path", path)
+}
+
 ///
 pub mod create_or_update {
     use std::{
@@ -91,12 +124,16 @@ pub mod create_or_update {
         path::{Path, PathBuf},
     };
 
+    use gix_error::{ErrorExt, ExnResult, Message, ResultExt};
     use gix_hash::{ObjectId, oid};
     use gix_object::bstr::BStr;
 
     use crate::store_impl::{file, file::WriteReflog};
 
     impl file::Store {
+        /// Append a reflog entry. Filesystem failures include [metadata](gix_error::Exn::metadata()) `path` (native
+        /// path), the affected file or directory.
+        /// A missing identity is reported as [`MissingCommitter`] only when a log entry must actually be written.
         pub(crate) fn reflog_create_or_append(
             &self,
             name: &FullNameRef,
@@ -105,7 +142,7 @@ pub mod create_or_update {
             committer: Option<gix_actor::SignatureRef<'_>>,
             message: &BStr,
             mut force_create_reflog: bool,
-        ) -> Result<(), Error> {
+        ) -> ExnResult {
             let (reflog_base, full_name) = self.reflog_base_and_relative_path(name);
             match self.write_reflog {
                 WriteReflog::Normal | WriteReflog::Always => {
@@ -118,11 +155,8 @@ pub mod create_or_update {
 
                     if force_create_reflog || self.should_autocreate_reflog(&full_name) {
                         let parent_dir = log_path.parent().expect("always with parent directory");
-                        gix_tempfile::create_dir::all(parent_dir, Default::default()).map_err(|err| {
-                            Error::CreateLeadingDirectories {
-                                source: err,
-                                reflog_directory: parent_dir.to_owned(),
-                            }
+                        gix_tempfile::create_dir::all(parent_dir, Default::default()).or_raise_erased(|| {
+                            Message::new("Could not create reflog directory").with("path", parent_dir)
                         })?;
                         options.create(true);
                     }
@@ -136,21 +170,15 @@ pub mod create_or_update {
                                 gix_tempfile::remove_dir::empty_depth_first(log_path.clone())
                                     .and_then(|_| options.open(&log_path))
                                     .map(Some)
-                                    .map_err(|_| Error::Append {
-                                        source: err,
-                                        reflog_path: self.reflog_path(name),
-                                    })?
+                                    .or_raise_erased(|| open_reflog_for_appending_error(log_path.as_path()))?
                             } else {
-                                return Err(Error::Append {
-                                    source: err,
-                                    reflog_path: log_path,
-                                });
+                                return Err(err.and_raise(open_reflog_for_appending_error(log_path)).erased());
                             }
                         }
                     };
 
                     if let Some(mut file) = file_for_appending {
-                        let committer = committer.ok_or(Error::MissingCommitter)?;
+                        let committer = committer.ok_or_else(|| MissingCommitter.raise_erased())?;
                         write!(file, "{} {} ", previous_oid.unwrap_or_else(|| new.kind().null()), new)
                             .and_then(|_| committer.trim().write_to(&mut file))
                             .and_then(|_| {
@@ -160,9 +188,8 @@ pub mod create_or_update {
                                     writeln!(file)
                                 }
                             })
-                            .map_err(|err| Error::Append {
-                                source: err,
-                                reflog_path: self.reflog_path(name),
+                            .or_raise_erased(|| {
+                                Message::new("Could not append reflog entry").with("path", log_path.as_path())
                             })?;
                     }
                     Ok(())
@@ -198,46 +225,30 @@ pub mod create_or_update {
         }
     }
 
-    #[cfg(test)]
-    mod tests;
+    /// The raised error's [metadata](gix_error::Exn::metadata()) `path` (native path) identifies the reflog that could
+    /// not be opened for appending.
+    fn open_reflog_for_appending_error(path: impl Into<PathBuf>) -> Message {
+        Message::new("Could not open reflog for appending").with("path", path.into())
+    }
+
+    /// A reflog entry requires a committer identity which wasn't provided.
+    #[derive(Debug)]
+    pub struct MissingCommitter;
 
-    mod error {
-        use std::path::PathBuf;
-
-        /// The error returned when creating or appending to a reflog
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Could create one or more directories in {reflog_directory:?} to contain reflog file")]
-            CreateLeadingDirectories {
-                source: std::io::Error,
-                reflog_directory: PathBuf,
-            },
-            #[error("Could not open reflog file at {reflog_path:?} for appending")]
-            Append {
-                source: std::io::Error,
-                reflog_path: PathBuf,
-            },
-            #[error("reflog message must not contain newlines")]
-            MessageWithNewlines,
-            #[error("reflog messages need a committer which isn't set")]
-            MissingCommitter,
+    impl std::fmt::Display for MissingCommitter {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str("reflog messages need a committer which isn't set")
         }
     }
-    pub use error::Error;
-
-    use crate::FullNameRef;
-}
 
-mod error {
-    /// The error returned by [`crate::file::Store::reflog_iter()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The reflog name or path is not a valid ref name")]
-        RefnameValidation(#[from] crate::name::Error),
-        #[error("The reflog file could not read")]
-        Io(#[from] std::io::Error),
+    impl std::error::Error for MissingCommitter {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(const { &gix_error::ClassificationMarker::VALIDATION })
+        }
     }
+
+    #[cfg(test)]
+    mod tests;
+
+    use crate::FullNameRef;
 }
-pub use error::Error;
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 4a18fa445aa..128cc9a8958 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
@@ -5,7 +5,7 @@ use gix_testtools::tempfile::TempDir;
 
 use super::*;
 
-type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
+use gix_testtools::Result;
 
 static SHA1_TO_SHA256_HASHES: std::sync::LazyLock<std::collections::HashMap<&str, &str>> =
     std::sync::LazyLock::new(|| {
@@ -183,6 +183,55 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append
     Ok(())
 }
 
+#[test]
+fn non_empty_reflog_directory_preserves_open_error_context() -> Result {
+    let (_keep, store) = empty_store(WriteReflog::Normal)?;
+    let name: &FullNameRef = "refs/heads/main".try_into()?;
+    let path = store.reflog_path(name);
+    std::fs::create_dir_all(&path)?;
+    std::fs::write(path.join("keep"), b"not an empty directory")?;
+
+    let err = store
+        .reflog_create_or_append(
+            name,
+            None,
+            &gix_testtools::object_hash().null(),
+            None,
+            b"update".as_bstr(),
+            false,
+        )
+        .expect_err("a non-empty directory cannot be replaced with a reflog")
+        .into_error();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")]), "the conflicting directory exists", @r#"
+    Could not open reflog for appending, "path"="<git-dir>/logs/refs/heads/main"
+    |
+    └─ I/O error (Other)
+    |
+    └─ Directory not empty
+    "#);
+    let details = err.metadata().next().expect("reflog open context");
+    assert!(
+        err.downcast_any_ref::<gix_error::Message>().is_some(),
+        "reflog open context retains its message type"
+    );
+    assert_eq!(details.len(), 1, "open context contains only the path");
+    assert_eq!(
+        details["path"],
+        gix_error::MetadataValue::Path(path),
+        "the reflog path remains a native path"
+    );
+    assert!(
+        err.downcast_any_ref::<std::io::Error>().is_some(),
+        "the directory removal error remains accessible"
+    );
+    assert!(!err.is_not_found(), "the conflicting directory exists");
+    assert!(
+        !err.is_corrupted(),
+        "a directory collision does not imply corrupt reflog contents"
+    );
+    Ok(())
+}
+
 #[test]
 fn reflog_write_normalizes_committer_name_and_email_like_git() -> Result {
     let (_keep, store) = empty_store(WriteReflog::Always)?;
diff --git a/gix-ref/src/store/file/mod.rs b/gix-ref/src/store/file/mod.rs
index 022ad604e90..97e49c1088c 100644
--- a/gix-ref/src/store/file/mod.rs
+++ b/gix-ref/src/store/file/mod.rs
@@ -125,11 +125,6 @@ mod overlay_iter;
 ///
 pub mod iter {
     pub use super::overlay_iter::{LooseThenPacked, Platform};
-
-    ///
-    pub mod loose_then_packed {
-        pub use super::super::overlay_iter::Error;
-    }
 }
 
 ///
diff --git a/gix-ref/src/store/file/overlay_iter.rs b/gix-ref/src/store/file/overlay_iter.rs
index b368079907e..a928e5e4fea 100644
--- a/gix-ref/src/store/file/overlay_iter.rs
+++ b/gix-ref/src/store/file/overlay_iter.rs
@@ -1,3 +1,5 @@
+use gix_error::{ExnMessageResult, ExnResult, ResultExt, message};
+
 use gix_object::bstr::ByteSlice;
 use gix_path::RelativePath;
 use std::{
@@ -64,48 +66,31 @@ impl<'p> LooseThenPacked<'p, '_> {
         }
     }
 
-    fn convert_packed(
-        &mut self,
-        packed: Result<packed::Reference<'p>, packed::iter::Error>,
-    ) -> Result<Reference, Error> {
-        packed
-            .map(Into::into)
-            .map(|r| self.strip_namespace(r))
-            .map_err(|err| match err {
-                packed::iter::Error::Reference {
-                    invalid_line,
-                    line_number,
-                } => Error::PackedReference {
-                    invalid_line,
-                    line_number,
-                },
-                packed::iter::Error::Header { .. } => unreachable!("this one only happens on iteration creation"),
-            })
+    fn convert_packed(&mut self, packed: ExnMessageResult<packed::Reference<'p>>) -> ExnResult<Reference> {
+        packed.map(Into::into).map(|r| self.strip_namespace(r)).or_erased()
     }
 
-    fn convert_loose(&mut self, res: std::io::Result<(PathBuf, FullName)>) -> Result<Reference, Error> {
+    /// Read failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the loose reference being
+    /// visited.
+    fn convert_loose(&mut self, res: std::io::Result<(PathBuf, FullName)>) -> ExnResult<Reference> {
         let buf = &mut self.buf;
         let git_dir = self.git_dir;
         let common_dir = self.common_dir;
-        let (refpath, name) = res.map_err(Error::Traversal)?;
+        let (refpath, name) = res.or_raise_erased(|| message("Could not traverse reference directory"))?;
         std::fs::File::open(&refpath)
             .and_then(|mut f| {
                 buf.clear();
                 f.read_to_end(buf)
             })
-            .map_err(|err| Error::ReadFileContents {
-                source: err,
-                path: refpath.to_owned(),
-            })?;
+            .or_raise_erased(|| file::find::read_reference_error(refpath.as_path()))?;
         loose::Reference::try_from_path(name, buf, self.object_hash)
-            .map_err(|err| {
+            .or_raise_erased(|| {
                 let relative_path = refpath
                     .strip_prefix(git_dir)
                     .ok()
                     .or_else(|| common_dir.and_then(|common_dir| refpath.strip_prefix(common_dir).ok()))
                     .expect("one of our bases contains the path");
-                Error::ReferenceCreation {
-                    source: err,
+                file::find::ReferenceDecode {
                     relative_path: relative_path.into(),
                 }
             })
@@ -115,7 +100,7 @@ impl<'p> LooseThenPacked<'p, '_> {
 }
 
 impl Iterator for LooseThenPacked<'_, '_> {
-    type Item = Result<Reference, Error>;
+    type Item = ExnResult<Reference>;
 
     fn next(&mut self) -> Option<Self::Item> {
         fn advance_to_non_private(iter: &mut Peekable<SortedLoosePaths>) {
@@ -224,7 +209,7 @@ impl file::Store {
     ///
     /// Note that since packed-refs are storing refs as precomposed unicode if [`Self::precompose_unicode`] is true, for consistency
     /// we also return loose references as precomposed unicode.
-    pub fn iter(&self) -> Result<Platform<'_>, packed::buffer::open::Error> {
+    pub fn iter(&self) -> ExnResult<Platform<'_>> {
         Ok(Platform {
             store: self,
             packed: self.assure_packed_refs_uptodate()?,
@@ -415,7 +400,7 @@ impl file::Store {
                 let prefix = prefix
                     .as_bstr()
                     .try_into()
-                    .map_err(|err: gix_path::relative_path::Error| std::io::Error::other(err.into_error()))?;
+                    .map_err(|err: gix_error::Exn<gix_error::Message>| std::io::Error::other(err.into_error()))?;
                 let git_dir_info = IterInfo::from_prefix(self.git_dir(), prefix, self.precompose_unicode)?;
                 let common_dir_info = self
                     .common_dir()
@@ -442,7 +427,7 @@ impl file::Store {
                         Some(prefix) => packed.iter_prefixed(prefix.into_owned()),
                         None => packed.iter(),
                     }
-                    .map_err(std::io::Error::other)?
+                    .map_err(|err| std::io::Error::other(err.into_error()))?
                     .peekable(),
                 ),
                 None => None,
@@ -454,29 +439,3 @@ impl file::Store {
         })
     }
 }
-
-mod error {
-    use std::{io, path::PathBuf};
-
-    use gix_object::bstr::BString;
-
-    use crate::store_impl::file;
-
-    /// The error returned by the [`LooseThenPacked`][super::LooseThenPacked] iterator.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The file system could not be traversed")]
-        Traversal(#[source] io::Error),
-        #[error("The ref file {path:?} could not be read in full")]
-        ReadFileContents { source: io::Error, path: PathBuf },
-        #[error("The reference at \"{relative_path}\" could not be instantiated")]
-        ReferenceCreation {
-            source: file::loose::reference::decode::Error,
-            relative_path: PathBuf,
-        },
-        #[error("Invalid reference in line {line_number}: {invalid_line:?}")]
-        PackedReference { invalid_line: BString, line_number: usize },
-    }
-}
-pub use error::Error;
diff --git a/gix-ref/src/store/file/packed.rs b/gix-ref/src/store/file/packed.rs
index 1905304ee26..5a1bac7f734 100644
--- a/gix-ref/src/store/file/packed.rs
+++ b/gix-ref/src/store/file/packed.rs
@@ -1,3 +1,5 @@
+use gix_error::{ExnResult, ResultExt, message};
+
 use std::path::PathBuf;
 
 use crate::store_impl::{file, packed};
@@ -5,12 +7,9 @@ use crate::store_impl::{file, packed};
 impl file::Store {
     /// Return a packed transaction ready to receive updates. Use this to create or update `packed-refs`.
     /// Note that if you already have a [`packed::Buffer`] then use its [`packed::Buffer::into_transaction()`] method instead.
-    pub(crate) fn packed_transaction(
-        &self,
-        lock_mode: gix_lock::acquire::Fail,
-    ) -> Result<packed::Transaction, transaction::Error> {
+    pub(crate) fn packed_transaction(&self, lock_mode: gix_lock::acquire::Fail) -> ExnResult<packed::Transaction> {
         let lock = gix_lock::File::acquire_to_update_resource(self.packed_refs_path(), lock_mode, None)
-            .map_err(|err| transaction::Error::TransactionLock(std::io::Error::other(err.into_error())))?;
+            .or_raise_erased(|| message("Could not lock packed refs"))?;
         // We 'steal' the possibly existing packed buffer which may safe time if it's already there and fresh.
         // If nothing else is happening, nobody will get to see the soon stale buffer either, but if so, they will pay
         // for reloading it. That seems preferred over always loading up a new one.
@@ -26,14 +25,14 @@ impl file::Store {
     ///
     /// Note that it will automatically be memory mapped if it exceeds the default threshold of 32KB.
     /// Change the threshold with [file::Store::set_packed_buffer_mmap_threshold()].
-    pub fn open_packed_buffer(&self) -> Result<Option<packed::Buffer>, packed::buffer::open::Error> {
+    pub fn open_packed_buffer(&self) -> ExnResult<Option<packed::Buffer>> {
         match packed::Buffer::open(
             self.packed_refs_path(),
             self.packed_buffer_mmap_threshold,
             self.object_hash,
         ) {
             Ok(buf) => Ok(Some(buf)),
-            Err(packed::buffer::open::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
+            Err(err) if err.is_not_found() => Ok(None),
             Err(err) => Err(err),
         }
     }
@@ -43,9 +42,7 @@ impl file::Store {
     ///
     /// Use this to make successive calls to [`file::Store::try_find_packed()`]
     /// or obtain iterators using [`file::Store::iter_packed()`] in a way that assures the packed-refs content won't change.
-    pub fn cached_packed_buffer(
-        &self,
-    ) -> Result<Option<file::packed::SharedBufferSnapshot>, packed::buffer::open::Error> {
+    pub fn cached_packed_buffer(&self) -> ExnResult<Option<file::packed::SharedBufferSnapshot>> {
         self.assure_packed_refs_uptodate()
     }
 
@@ -61,22 +58,6 @@ impl file::Store {
     }
 }
 
-///
-pub mod transaction {
-
-    use crate::store_impl::packed;
-
-    /// The error returned by [`file::Transaction::prepare()`][crate::file::Transaction::prepare()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An existing pack couldn't be opened or read when preparing a transaction")]
-        BufferOpen(#[from] packed::buffer::open::Error),
-        #[error("The lock for a packed transaction could not be obtained")]
-        TransactionLock(#[source] std::io::Error),
-    }
-}
-
 /// An up-to-date snapshot of the packed refs buffer.
 pub type SharedBufferSnapshot = gix_fs::SharedFileSnapshot<packed::Buffer>;
 
@@ -84,6 +65,7 @@ pub(crate) mod modifiable {
     use gix_features::threading::OwnShared;
 
     use crate::{file, packed};
+    use gix_error::{ExnResult, Message, ResultExt};
 
     pub(crate) type MutableSharedBuffer = OwnShared<gix_fs::SharedFileSnapshotMut<packed::Buffer>>;
 
@@ -95,15 +77,22 @@ pub(crate) mod modifiable {
         ///
         /// As some filesystems don't have nanosecond granularity, changes are likely to be missed
         /// if they happen within one second otherwise.
-        pub fn force_refresh_packed_buffer(&self) -> Result<(), packed::buffer::open::Error> {
+        ///
+        /// [Metadata](gix_error::Exn::metadata()) `path` (native path) identifies a packed-refs file whose modification
+        /// time could not be read.
+        pub fn force_refresh_packed_buffer(&self) -> ExnResult {
             self.packed.force_refresh(|| {
-                let modified = self.packed_refs_path().metadata()?.modified()?;
+                let path = self.packed_refs_path();
+                let modified = path
+                    .metadata()
+                    .and_then(|metadata| metadata.modified())
+                    .or_raise_erased(|| {
+                        Message::new("Could not read packed refs modification time").with("path", path)
+                    })?;
                 self.open_packed_buffer().map(|packed| Some(modified).zip(packed))
             })
         }
-        pub(crate) fn assure_packed_refs_uptodate(
-            &self,
-        ) -> Result<Option<super::SharedBufferSnapshot>, packed::buffer::open::Error> {
+        pub(crate) fn assure_packed_refs_uptodate(&self) -> ExnResult<Option<super::SharedBufferSnapshot>> {
             self.packed.recent_snapshot(
                 || self.packed_refs_path().metadata().and_then(|m| m.modified()).ok(),
                 || self.open_packed_buffer(),
diff --git a/gix-ref/src/store/file/raw_ext.rs b/gix-ref/src/store/file/raw_ext.rs
index f14e54abc24..76797e1eaee 100644
--- a/gix-ref/src/store/file/raw_ext.rs
+++ b/gix-ref/src/store/file/raw_ext.rs
@@ -1,9 +1,10 @@
 use std::collections::BTreeSet;
 
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, corruption, not_found};
 use gix_hash::ObjectId;
 
 use crate::{
-    Target, packed, peel,
+    Target, packed,
     raw::Reference,
     store_impl::{file, file::log},
 };
@@ -26,11 +27,7 @@ pub trait ReferenceExt: Sealed {
     /// This is useful to learn where this reference is ultimately pointing to after following all symbolic
     /// refs and all annotated tags to the first non-tag object.
     #[deprecated = "Use `peel_to_id()` instead"]
-    fn peel_to_id_in_place(
-        &mut self,
-        store: &file::Store,
-        objects: &dyn gix_object::Find,
-    ) -> Result<ObjectId, peel::to_id::Error>;
+    fn peel_to_id_in_place(&mut self, store: &file::Store, objects: &dyn gix_object::Find) -> ExnResult<ObjectId>;
 
     /// Follow all symbolic targets this reference might point to and peel the underlying object
     /// to the end of the tag-chain, returning the first non-tag object the annotated tag points to,
@@ -41,11 +38,7 @@ pub trait ReferenceExt: Sealed {
     ///
     /// Note that this method mutates `self` in place if it does not already point to a
     /// non-symbolic object.
-    fn peel_to_id(
-        &mut self,
-        store: &file::Store,
-        objects: &dyn gix_object::Find,
-    ) -> Result<ObjectId, peel::to_id::Error>;
+    fn peel_to_id(&mut self, store: &file::Store, objects: &dyn gix_object::Find) -> ExnResult<ObjectId>;
 
     /// Like [`ReferenceExt::peel_to_id_in_place()`], but with support for a known stable `packed` buffer
     /// to use for resolving symbolic links.
@@ -55,16 +48,19 @@ pub trait ReferenceExt: Sealed {
         store: &file::Store,
         objects: &dyn gix_object::Find,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_id::Error>;
+    ) -> ExnResult<ObjectId>;
 
     /// Like [`ReferenceExt::peel_to_id()`], but with support for a known stable `packed` buffer to
     /// use for resolving symbolic links.
+    /// Object lookup failures include [metadata](gix_error::Exn::metadata()) `object_id` (hex text) and `reference`
+    /// (name bytes).
+    /// Missing objects are classified as not found; lookup errors retain their own classifications.
     fn peel_to_id_packed(
         &mut self,
         store: &file::Store,
         objects: &dyn gix_object::Find,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_id::Error>;
+    ) -> ExnResult<ObjectId>;
 
     /// Like [`ReferenceExt::follow()`], but follows all symbolic references while gracefully handling loops,
     /// altering this instance in place.
@@ -73,30 +69,24 @@ pub trait ReferenceExt: Sealed {
         &mut self,
         store: &file::Store,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_object::Error>;
+    ) -> ExnResult<ObjectId>;
 
     /// Like [`ReferenceExt::follow()`], but follows all symbolic references while gracefully handling loops,
     /// altering this instance in place.
-    fn follow_to_object_packed(
-        &mut self,
-        store: &file::Store,
-        packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_object::Error>;
+    /// Cycle failures include [metadata](gix_error::Exn::metadata()) `path` (native path); depth-limit failures include
+    /// `max_depth` (unsigned integer).
+    fn follow_to_object_packed(&mut self, store: &file::Store, packed: Option<&packed::Buffer>) -> ExnResult<ObjectId>;
 
     /// Follow this symbolic reference one level and return the ref it refers to.
     ///
     /// Returns `None` if this is not a symbolic reference, hence the leaf of the chain.
-    fn follow(&self, store: &file::Store) -> Option<Result<Reference, file::find::existing::Error>>;
+    fn follow(&self, store: &file::Store) -> Option<ExnResult<Reference>>;
 
     /// Follow this symbolic reference one level and return the ref it refers to,
     /// possibly providing access to `packed` references for lookup if it contains the referent.
     ///
     /// Returns `None` if this is not a symbolic reference, hence the leaf of the chain.
-    fn follow_packed(
-        &self,
-        store: &file::Store,
-        packed: Option<&packed::Buffer>,
-    ) -> Option<Result<Reference, file::find::existing::Error>>;
+    fn follow_packed(&self, store: &file::Store, packed: Option<&packed::Buffer>) -> Option<ExnResult<Reference>>;
 }
 
 impl ReferenceExt for Reference {
@@ -114,24 +104,12 @@ impl ReferenceExt for Reference {
             .expect("infallible name conversion")
     }
 
-    fn peel_to_id_in_place(
-        &mut self,
-        store: &file::Store,
-        objects: &dyn gix_object::Find,
-    ) -> Result<ObjectId, peel::to_id::Error> {
+    fn peel_to_id_in_place(&mut self, store: &file::Store, objects: &dyn gix_object::Find) -> ExnResult<ObjectId> {
         self.peel_to_id(store, objects)
     }
 
-    fn peel_to_id(
-        &mut self,
-        store: &file::Store,
-        objects: &dyn gix_object::Find,
-    ) -> Result<ObjectId, peel::to_id::Error> {
-        let packed = store.assure_packed_refs_uptodate().map_err(|err| {
-            peel::to_id::Error::FollowToObject(peel::to_object::Error::Follow(file::find::existing::Error::Find(
-                file::find::Error::PackedOpen(err),
-            )))
-        })?;
+    fn peel_to_id(&mut self, store: &file::Store, objects: &dyn gix_object::Find) -> ExnResult<ObjectId> {
+        let packed = store.assure_packed_refs_uptodate()?;
         self.peel_to_id_packed(store, objects, packed.as_ref().map(|b| &***b))
     }
 
@@ -140,23 +118,25 @@ impl ReferenceExt for Reference {
         store: &file::Store,
         objects: &dyn gix_object::Find,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_id::Error> {
+    ) -> ExnResult<ObjectId> {
         self.peel_to_id_packed(store, objects, packed)
     }
 
+    /// Object lookup failures include [metadata](gix_error::Exn::metadata()) `object_id` (hex text) and `reference`
+    /// (name bytes).
     fn peel_to_id_packed(
         &mut self,
         store: &file::Store,
         objects: &dyn gix_object::Find,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_id::Error> {
+    ) -> ExnResult<ObjectId> {
         match self.peeled {
             Some(peeled) => {
                 self.target = Target::Object(peeled.to_owned());
                 Ok(peeled)
             }
             None => {
-                let mut oid = self.follow_to_object_packed(store, packed)?;
+                let mut object_id = self.follow_to_object_packed(store, packed)?;
                 let mut buf = Vec::new();
                 let peeled_id = loop {
                     let gix_object::Data {
@@ -164,21 +144,31 @@ impl ReferenceExt for Reference {
                         data,
                         object_hash: hash_kind,
                     } = objects
-                        .try_find(&oid, &mut buf)?
-                        .ok_or_else(|| peel::to_id::Error::NotFound {
-                            oid,
-                            name: self.name.0.clone(),
+                        .try_find(&object_id, &mut buf)
+                        .or_raise_erased(|| {
+                            Message::new("Could not peel reference to an object")
+                                .with("object_id", object_id.to_string())
+                                .with("reference", self.name.as_bstr())
+                        })?
+                        .ok_or_else(|| {
+                            not_found("Could not peel reference to an object: object could not be found")
+                                .with("object_id", object_id.to_string())
+                                .with("reference", self.name.as_bstr())
+                                .raise_erased()
                         })?;
                     match kind {
                         gix_object::Kind::Tag => {
-                            oid = gix_object::TagRefIter::from_bytes(data, hash_kind)
+                            object_id = gix_object::TagRefIter::from_bytes(data, hash_kind)
                                 .target_id()
-                                .map_err(|_err| peel::to_id::Error::NotFound {
-                                    oid,
-                                    name: self.name.0.clone(),
-                                })?;
+                                .or_raise(|| {
+                                    corruption(format!(
+                                        "Could not decode tag {object_id} as referred to by {:?}",
+                                        self.name.0
+                                    ))
+                                })
+                                .or_erased()?;
                         }
-                        _ => break oid,
+                        _ => break object_id,
                     }
                 };
                 self.peeled = Some(peeled_id);
@@ -192,15 +182,13 @@ impl ReferenceExt for Reference {
         &mut self,
         store: &file::Store,
         packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_object::Error> {
+    ) -> ExnResult<ObjectId> {
         self.follow_to_object_packed(store, packed)
     }
 
-    fn follow_to_object_packed(
-        &mut self,
-        store: &file::Store,
-        packed: Option<&packed::Buffer>,
-    ) -> Result<ObjectId, peel::to_object::Error> {
+    /// Cycle failures include [metadata](gix_error::Exn::metadata()) `path` (native path); depth-limit failures include
+    /// `max_depth` (unsigned integer).
+    fn follow_to_object_packed(&mut self, store: &file::Store, packed: Option<&packed::Buffer>) -> ExnResult<ObjectId> {
         match self.target {
             Target::Object(id) => Ok(id),
             Target::Symbolic(_) => {
@@ -209,17 +197,17 @@ impl ReferenceExt for Reference {
                 while let Some(next) = cursor.follow_packed(store, packed) {
                     let next = next?;
                     if seen.contains(&next.name) {
-                        return Err(peel::to_object::Error::Cycle {
-                            start_absolute: store.reference_path(cursor.name.as_ref()),
-                        });
+                        return Err(corruption("Aborting symbolic reference cycle")
+                            .with("path", store.reference_path(cursor.name.as_ref()))
+                            .raise_erased());
                     }
                     *cursor = next;
                     seen.insert(cursor.name.clone());
                     const MAX_REF_DEPTH: usize = 5;
                     if seen.len() == MAX_REF_DEPTH {
-                        return Err(peel::to_object::Error::DepthLimitExceeded {
-                            max_depth: MAX_REF_DEPTH,
-                        });
+                        return Err(Message::new("Symbolic reference depth limit exceeded")
+                            .with("max_depth", MAX_REF_DEPTH)
+                            .raise_erased());
                     }
                 }
                 let oid = self.target.try_id().expect("peeled ref").to_owned();
@@ -228,30 +216,24 @@ impl ReferenceExt for Reference {
         }
     }
 
-    fn follow(&self, store: &file::Store) -> Option<Result<Reference, file::find::existing::Error>> {
-        let packed = match store
-            .assure_packed_refs_uptodate()
-            .map_err(|err| file::find::existing::Error::Find(file::find::Error::PackedOpen(err)))
-        {
+    fn follow(&self, store: &file::Store) -> Option<ExnResult<Reference>> {
+        let packed = match store.assure_packed_refs_uptodate() {
             Ok(packed) => packed,
             Err(err) => return Some(Err(err)),
         };
         self.follow_packed(store, packed.as_ref().map(|b| &***b))
     }
 
-    fn follow_packed(
-        &self,
-        store: &file::Store,
-        packed: Option<&packed::Buffer>,
-    ) -> Option<Result<Reference, file::find::existing::Error>> {
+    fn follow_packed(&self, store: &file::Store, packed: Option<&packed::Buffer>) -> Option<ExnResult<Reference>> {
         match &self.target {
             Target::Object(_) => None,
             Target::Symbolic(full_name) => match store.try_find_packed(full_name.as_ref(), packed) {
                 Ok(Some(next)) => Some(Ok(next)),
-                Ok(None) => Some(Err(file::find::existing::Error::NotFound {
+                Ok(None) => Some(Err(file::find::NotFound {
                     name: full_name.to_path().to_owned(),
-                })),
-                Err(err) => Some(Err(file::find::existing::Error::Find(err))),
+                }
+                .raise_erased())),
+                Err(err) => Some(Err(err)),
             },
         }
     }
diff --git a/gix-ref/src/store/file/transaction/commit.rs b/gix-ref/src/store/file/transaction/commit.rs
index 1d87caa7292..d93ae03b298 100644
--- a/gix-ref/src/store/file/transaction/commit.rs
+++ b/gix-ref/src/store/file/transaction/commit.rs
@@ -1,3 +1,5 @@
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, message};
+
 use crate::{
     Target,
     store_impl::file::{Transaction, transaction::PackedRefs},
@@ -25,11 +27,14 @@ impl Transaction<'_, '_> {
     ///   along with empty parent directories
     ///
     /// Note that transactions will be prepared automatically as needed.
-    pub fn commit<'a>(self, committer: impl Into<Option<gix_actor::SignatureRef<'a>>>) -> Result<Vec<RefEdit>, Error> {
+    /// Per-reference failures include [metadata](gix_error::Exn::metadata()) `reference` (bytes), the affected name.
+    /// A missing reflog identity is identifiable as [`file::log::create_or_update::MissingCommitter`](crate::file::log::create_or_update::MissingCommitter).
+    pub fn commit<'a>(self, committer: impl Into<Option<gix_actor::SignatureRef<'a>>>) -> ExnResult<Vec<RefEdit>> {
         self.commit_inner(committer.into())
     }
 
-    fn commit_inner(self, committer: Option<gix_actor::SignatureRef<'_>>) -> Result<Vec<RefEdit>, Error> {
+    /// Per-reference failures include [metadata](gix_error::Exn::metadata()) `reference` (bytes), the affected name.
+    fn commit_inner(self, committer: Option<gix_actor::SignatureRef<'_>>) -> ExnResult<Vec<RefEdit>> {
         let mut updates = self.updates.expect("BUG: must call prepare before commit");
         let delete_loose_refs = matches!(
             self.packed_refs,
@@ -74,14 +79,19 @@ impl Transaction<'_, '_> {
                         if let Some((previous, new_oid)) = log_update {
                             let do_update = previous.as_ref() != Some(new_oid);
                             if do_update {
-                                self.store.reflog_create_or_append(
-                                    change.update.name.as_ref(),
-                                    previous,
-                                    new_oid,
-                                    committer,
-                                    log.message.as_ref(),
-                                    log.force_create_reflog,
-                                )?;
+                                self.store
+                                    .reflog_create_or_append(
+                                        change.update.name.as_ref(),
+                                        previous,
+                                        new_oid,
+                                        committer,
+                                        log.message.as_ref(),
+                                        log.force_create_reflog,
+                                    )
+                                    .or_raise_erased(|| {
+                                        Message::new("Could not update reflog")
+                                            .with("reference", change.update.name.as_bstr())
+                                    })?;
                             }
                         }
                     }
@@ -104,10 +114,9 @@ impl Transaction<'_, '_> {
                         };
 
                         if let Some(err) = err {
-                            return Err(Error::LockCommit {
-                                source: err,
-                                full_name: change.name(),
-                            });
+                            return Err(err
+                                .and_raise(Message::new("Could not commit reference").with("reference", change.name()))
+                                .erased());
                         }
                     }
                 }
@@ -125,10 +134,9 @@ impl Transaction<'_, '_> {
                     let reflog_path = reflog_root.join(relative_name);
                     if let Err(err) = std::fs::remove_file(&reflog_path) {
                         if err.kind() != std::io::ErrorKind::NotFound {
-                            return Err(Error::DeleteReflog {
-                                source: err,
-                                full_name: change.name(),
-                            });
+                            return Err(err
+                                .and_raise(Message::new("Could not delete reflog").with("reference", change.name()))
+                                .erased());
                         }
                     } else {
                         gix_tempfile::remove_dir::empty_upward_until_boundary(
@@ -142,7 +150,8 @@ impl Transaction<'_, '_> {
         }
 
         if let Some(t) = self.packed_transaction {
-            t.commit().map_err(Error::PackedTransactionCommit)?;
+            t.commit()
+                .or_raise_erased(|| message("Could not commit packed-ref transaction"))?;
             // Always refresh ourselves right away to avoid races. We ignore errors as there may be many reasons this fails, and it's not
             // critical to be done here. In other words, the pack may be refreshed at a later time and then it might work.
             self.store.force_refresh_packed_buffer().ok();
@@ -163,10 +172,9 @@ impl Transaction<'_, '_> {
                 if let Err(err) = std::fs::remove_file(reference_path)
                     && err.kind() != std::io::ErrorKind::NotFound
                 {
-                    return Err(Error::DeleteReference {
-                        err,
-                        full_name: change.name(),
-                    });
+                    return Err(err
+                        .and_raise(Message::new("Could not delete reference").with("reference", change.name()))
+                        .erased());
                 }
                 drop(lock);
             }
@@ -174,29 +182,5 @@ impl Transaction<'_, '_> {
         Ok(updates.into_iter().map(|edit| edit.update).collect())
     }
 }
-mod error {
-    use gix_object::bstr::BString;
-
-    use crate::store_impl::{file, packed};
-
-    /// The error returned by various [`Transaction`][super::Transaction] methods.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The packed-ref transaction could not be committed")]
-        PackedTransactionCommit(#[source] packed::transaction::commit::Error),
-        #[error("Edit preprocessing failed with error")]
-        PreprocessingFailed { source: std::io::Error },
-        #[error("The change for reference {full_name:?} could not be committed")]
-        LockCommit { source: std::io::Error, full_name: BString },
-        #[error("The reference {full_name} could not be deleted")]
-        DeleteReference { full_name: BString, err: std::io::Error },
-        #[error("The reflog of reference {full_name:?} could not be deleted")]
-        DeleteReflog { full_name: BString, source: std::io::Error },
-        #[error("The reflog could not be created or updated")]
-        CreateOrUpdateRefLog(#[from] file::log::create_or_update::Error),
-    }
-}
-pub use error::Error;
 
 use crate::transaction::PreviousValue;
diff --git a/gix-ref/src/store/file/transaction/prepare.rs b/gix-ref/src/store/file/transaction/prepare.rs
index 666a5962eef..58d3d44f234 100644
--- a/gix-ref/src/store/file/transaction/prepare.rs
+++ b/gix-ref/src/store/file/transaction/prepare.rs
@@ -1,3 +1,5 @@
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, message};
+
 use crate::{
     FullName, FullNameRef, Reference, Target, packed,
     packed::transaction::buffer_into_transaction,
@@ -20,47 +22,16 @@ impl Transaction<'_, '_> {
         store: &file::Store,
         name: &FullNameRef,
         packed: Option<&packed::Buffer>,
-    ) -> Result<Option<Reference>, Error> {
-        store
+    ) -> ExnResult<Option<Reference>> {
+        let loose = store
             .ref_contents(name)
-            .map_err(Error::from)
-            .and_then(|maybe_loose| {
-                maybe_loose
-                    .map(|buf| {
-                        loose::Reference::try_from_path(name.to_owned(), &buf, store.object_hash)
-                            .map(Reference::from)
-                            .map_err(Error::from)
-                    })
-                    .transpose()
-            })
-            .or_else(|err| match err {
-                Error::ReferenceDecode(_) => Ok(None),
-                other => Err(other),
-            })
-            .and_then(|maybe_loose| match (maybe_loose, packed) {
-                (None, Some(packed)) => packed
-                    .try_find(name)
-                    .map(|opt| opt.map(Into::into))
-                    .map_err(Error::from),
-                (None, None) => Ok(None),
-                (maybe_loose, _) => Ok(maybe_loose),
-            })
-    }
-
-    /// Map a lock-acquisition failure to our error type, surfacing genuine I/O errors
-    /// (such as a path collision reported as `NotADirectory`) as [`Error::Io`] rather than
-    /// burying them in [`Error::LockAcquire`], which is reserved for actual contention.
-    // This happens for path collisions where `a` is a ref file, and `a/b` is the lock to be created.
-    fn lock_acquire_error(err: gix_lock::acquire::Error, full_name: &str) -> Error {
-        match (
-            err.downcast_any_ref::<gix_error::RetryableError>().is_some(),
-            err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind),
-        ) {
-            (false, Some(kind)) => Error::Io(std::io::Error::new(kind, err.into_error())),
-            _ => Error::LockAcquire {
-                source: std::io::Error::other(err.into_error()),
-                full_name: full_name.into(),
-            },
+            .or_raise_erased(|| message("Could not read existing reference"))?
+            // Git permits replacing malformed loose references, but I/O errors must propagate.
+            .and_then(|buf| loose::Reference::try_from_path(name.to_owned(), &buf, store.object_hash).ok())
+            .map(Reference::from);
+        match (loose, packed) {
+            (None, Some(packed)) => packed.try_find(name).map(|reference| reference.map(Into::into)),
+            (reference, _) => Ok(reference),
         }
     }
 
@@ -70,7 +41,7 @@ impl Transaction<'_, '_> {
         packed: Option<&packed::Buffer>,
         change: &mut Edit,
         direct_to_packed_refs: bool,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         use std::io::Write;
         assert!(
             change.lock.is_none(),
@@ -81,7 +52,9 @@ impl Transaction<'_, '_> {
         // The lock file itself (e.g. `CON.lock`) is also a device name,
         // so acquiring it would fail or open the device instead of
         // returning the configured validation error.
-        store.check_windows_device_name(change.update.name.as_ref())?;
+        store
+            .check_windows_device_name(change.update.name.as_ref())
+            .or_raise_erased(|| message("Invalid reference filename"))?;
 
         let lock = match &mut change.update.change {
             Change::Delete { expected, .. } => {
@@ -90,8 +63,7 @@ impl Transaction<'_, '_> {
                     base.join(relative_path.as_ref()),
                     lock_fail_mode,
                     Some(base.clone().into_owned()),
-                )
-                .map_err(|err| Self::lock_acquire_error(err, "borrowcheck won't allow change.name()"))?;
+                )?;
 
                 let existing_ref = Self::read_existing_ref(store, change.update.name.as_ref(), packed)?;
 
@@ -102,9 +74,7 @@ impl Transaction<'_, '_> {
                     (PreviousValue::ExistingMustMatch(_) | PreviousValue::Any, None)
                     | (PreviousValue::MustExist | PreviousValue::Any, Some(_)) => {}
                     (PreviousValue::MustExist | PreviousValue::MustExistAndMatch(_), None) => {
-                        return Err(Error::DeleteReferenceMustExist {
-                            full_name: change.name(),
-                        });
+                        return Err(gix_error::not_found("The reference to delete must exist").raise_erased());
                     }
                     (
                         PreviousValue::MustExistAndMatch(previous) | PreviousValue::ExistingMustMatch(previous),
@@ -112,12 +82,13 @@ impl Transaction<'_, '_> {
                     ) => {
                         let actual = existing.target.clone();
                         if *previous != actual {
-                            let expected = previous.clone();
-                            return Err(Error::ReferenceOutOfDate {
+                            let context = message!("Expected reference content {previous}");
+                            return Err(ReferenceOutOfDate {
                                 full_name: change.name(),
-                                expected,
                                 actual,
-                            });
+                            }
+                            .and_raise(context)
+                            .erased());
                         }
                     }
                 }
@@ -137,12 +108,6 @@ impl Transaction<'_, '_> {
                         lock_fail_mode,
                         Some(base.clone().into_owned()),
                     )
-                    .map_err(|err| {
-                        Self::lock_acquire_error(
-                            err,
-                            "borrowcheck won't allow change.name() and this will be corrected by caller",
-                        )
-                    })
                 };
                 let mut lock = obtain_lock()?;
 
@@ -153,18 +118,17 @@ impl Transaction<'_, '_> {
                     | (PreviousValue::MustExist, Some(_))
                     | (PreviousValue::MustNotExist | PreviousValue::ExistingMustMatch(_), None) => {}
                     (PreviousValue::MustExist, None) => {
-                        let expected = Target::Object(store.object_hash.null());
-                        let full_name = change.name();
-                        return Err(Error::MustExist { full_name, expected });
+                        return Err(gix_error::not_found("The reference to update must exist").raise_erased());
                     }
                     (PreviousValue::MustNotExist, Some(existing)) => {
                         if existing.target != *new {
-                            let new = new.clone();
-                            return Err(Error::MustNotExist {
+                            let context = message!("Expected the reference not to exist when writing {new}");
+                            return Err(MustNotExist {
                                 full_name: change.name(),
                                 actual: existing.target.clone(),
-                                new,
-                            });
+                            }
+                            .and_raise(context)
+                            .erased());
                         }
                     }
                     (
@@ -173,20 +137,21 @@ impl Transaction<'_, '_> {
                     ) => {
                         if *previous != existing.target {
                             let actual = existing.target.clone();
-                            let expected = previous.to_owned();
-                            let full_name = change.name();
-                            return Err(Error::ReferenceOutOfDate {
-                                full_name,
+                            let context = message!("Expected reference content {previous}");
+                            return Err(ReferenceOutOfDate {
+                                full_name: change.name(),
                                 actual,
-                                expected,
-                            });
+                            }
+                            .and_raise(context)
+                            .erased());
                         }
                     }
 
                     (PreviousValue::MustExistAndMatch(previous), None) => {
-                        let expected = previous.to_owned();
-                        let full_name = change.name();
-                        return Err(Error::MustExist { full_name, expected });
+                        return Err(
+                            gix_error::not_found(format!("The reference must exist with content {previous}"))
+                                .raise_erased(),
+                        );
                     }
                 }
 
@@ -212,10 +177,17 @@ impl Transaction<'_, '_> {
                     lock.with_mut(|file| match new {
                         Target::Object(oid) => writeln!(file, "{oid}"),
                         Target::Symbolic(name) => writeln!(file, "ref: {}", name.0),
-                    })?;
-                    Some(lock.close()?)
+                    })
+                    .or_raise_erased(|| message("Could not write loose reference"))?;
+                    Some(
+                        lock.close()
+                            .or_raise_erased(|| message("Could not close reference lock"))?,
+                    )
                 } else if keep_lock_for_loose_source_delete {
-                    Some(lock.close()?)
+                    Some(
+                        lock.close()
+                            .or_raise_erased(|| message("Could not close reference lock"))?,
+                    )
                 } else {
                     None
                 }
@@ -232,12 +204,16 @@ impl Transaction<'_, '_> {
     /// If the operation succeeds, the transaction can be committed or dropped to cause a rollback automatically.
     /// Rollbacks happen automatically on failure and they tend to be perfect.
     /// This method is idempotent.
+    ///
+    /// Failed edits identify the requested and resolved names in [metadata](gix_error::Exn::metadata()) `reference` and
+    /// `referent` (bytes).
+    /// [`ReferenceOutOfDate`] and [`MustNotExist`] retain the actual target observed while holding the lock.
     pub fn prepare(
         self,
         edits: impl IntoIterator<Item = RefEdit>,
         ref_files_lock_fail_mode: gix_lock::acquire::Fail,
         packed_refs_lock_fail_mode: gix_lock::acquire::Fail,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         self.prepare_inner(
             &mut edits.into_iter(),
             ref_files_lock_fail_mode,
@@ -245,12 +221,14 @@ impl Transaction<'_, '_> {
         )
     }
 
+    /// Failed edits include [metadata](gix_error::Exn::metadata()) `reference` (requested name bytes) and `referent`
+    /// (resolved name bytes).
     fn prepare_inner(
         mut self,
         edits: &mut dyn Iterator<Item = RefEdit>,
         ref_files_lock_fail_mode: gix_lock::acquire::Fail,
         packed_refs_lock_fail_mode: gix_lock::acquire::Fail,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         assert!(self.updates.is_none(), "BUG: Must not call prepare(…) multiple times");
         let store = self.store;
         let mut updates: Vec<_> = edits
@@ -277,7 +255,7 @@ impl Transaction<'_, '_> {
                     leaf_referent_previous_oid: None,
                 },
             )
-            .map_err(Error::PreprocessingFailed)?;
+            .or_raise_erased(|| message("Could not preprocess reference edits"))?;
 
         let mut maybe_updates_for_packed_refs = match self.packed_refs {
             PackedRefs::DeletionsAndNonSymbolicUpdates(_)
@@ -341,15 +319,7 @@ impl Transaction<'_, '_> {
                 let packed_transaction: Option<_> =
                     if maybe_updates_for_packed_refs.unwrap_or(0) > 0 || self.store.packed_refs_lock_path().is_file() {
                         // We have to create a packed-ref even if it doesn't exist
-                        self.store
-                            .packed_transaction(packed_refs_lock_fail_mode)
-                            .map_err(|err| match err {
-                                file::packed::transaction::Error::BufferOpen(err) => Error::from(err),
-                                file::packed::transaction::Error::TransactionLock(err) => {
-                                    Error::PackedTransactionAcquire(err)
-                                }
-                            })?
-                            .into()
+                        self.store.packed_transaction(packed_refs_lock_fail_mode)?.into()
                     } else {
                         // A packed transaction is optional - we only have deletions that can't be made if
                         // no packed-ref file exists anyway
@@ -362,7 +332,6 @@ impl Transaction<'_, '_> {
                                     self.store.precompose_unicode,
                                     self.store.namespace.clone(),
                                 )
-                                .map_err(|err| Error::PackedTransactionAcquire(std::io::Error::other(err.into_error())))
                             })
                             .transpose()?
                     };
@@ -391,26 +360,21 @@ impl Transaction<'_, '_> {
                     PackedRefs::DeletionsAndNonSymbolicUpdatesRemoveLooseSourceReference(_)
                 ),
             ) {
-                let err = match err {
-                    Error::LockAcquire {
-                        source,
-                        full_name: _bogus,
-                    } => Error::LockAcquire {
-                        source,
-                        full_name: {
-                            let mut cursor = change.parent_index;
-                            let mut ref_name = change.name();
-                            while let Some(parent_idx) = cursor {
-                                let parent = &updates[parent_idx];
-                                ref_name = parent.name();
-                                cursor = parent.parent_index;
-                            }
-                            ref_name
-                        },
-                    },
-                    other => other,
-                };
-                return Err(err);
+                let referent = change.name();
+                let mut ref_name = referent.clone();
+                let mut cursor = change.parent_index;
+                while let Some(parent_idx) = cursor {
+                    let parent = &updates[parent_idx];
+                    ref_name = parent.name();
+                    cursor = parent.parent_index;
+                }
+                return Err(err
+                    .raise(
+                        Message::new("Could not prepare reference edit")
+                            .with("reference", ref_name)
+                            .with("referent", referent),
+                    )
+                    .erased());
             }
 
             // traverse parent chain from leaf/peeled ref and set the leaf previous oid accordingly
@@ -464,53 +428,41 @@ fn possibly_adjust_name_for_prefixes(name: &FullNameRef) -> Option<FullName> {
     }
 }
 
-mod error {
-    use gix_object::bstr::BString;
+/// A reference changed since the caller obtained its expected value.
+/// Retrying requires reading and reconciling the new value first.
+#[derive(Debug)]
+pub struct ReferenceOutOfDate {
+    /// The reference whose target did not match the expected value.
+    pub full_name: crate::bstr::BString,
+    /// The target observed while holding the reference lock.
+    pub actual: Target,
+}
+
+impl std::fmt::Display for ReferenceOutOfDate {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "The reference {:?} changed to {}", self.full_name, self.actual)
+    }
+}
+
+impl std::error::Error for ReferenceOutOfDate {}
 
-    use crate::{
-        Target,
-        store_impl::{file, packed},
-    };
+/// A reference exists with a different target although the edit required its absence.
+#[derive(Debug)]
+pub struct MustNotExist {
+    /// The reference which unexpectedly exists.
+    pub full_name: crate::bstr::BString,
+    /// The target observed while holding the reference lock.
+    pub actual: Target,
+}
 
-    /// The error returned by various [`Transaction`][super::Transaction] methods.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The packed ref buffer could not be loaded")]
-        Packed(#[from] packed::buffer::open::Error),
-        #[error("The lock for the packed-ref file could not be obtained")]
-        PackedTransactionAcquire(#[source] std::io::Error),
-        #[error("The packed transaction could not be prepared")]
-        PackedTransactionPrepare(#[from] packed::transaction::prepare::Error),
-        #[error("The packed ref file could not be parsed")]
-        PackedFind(#[from] packed::find::Error),
-        #[error("Edit preprocessing failed with an error")]
-        PreprocessingFailed(#[source] std::io::Error),
-        #[error("A lock could not be obtained for reference {full_name:?}")]
-        LockAcquire { source: std::io::Error, full_name: BString },
-        #[error("An IO error occurred while applying an edit")]
-        Io(#[from] std::io::Error),
-        #[error("The reference {full_name:?} for deletion did not exist or could not be parsed")]
-        DeleteReferenceMustExist { full_name: BString },
-        #[error(
-            "Reference {full_name:?} was not supposed to exist when writing it with value {new:?}, but actual content was {actual:?}"
-        )]
-        MustNotExist {
-            full_name: BString,
-            actual: Target,
-            new: Target,
-        },
-        #[error("Reference {full_name:?} was supposed to exist with value {expected}, but didn't.")]
-        MustExist { full_name: BString, expected: Target },
-        #[error("The reference {full_name:?} should have content {expected}, actual content was {actual}")]
-        ReferenceOutOfDate {
-            full_name: BString,
-            expected: Target,
-            actual: Target,
-        },
-        #[error("Could not read reference")]
-        ReferenceDecode(#[from] file::loose::reference::decode::Error),
+impl std::fmt::Display for MustNotExist {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "The reference {:?} already exists with content {}",
+            self.full_name, self.actual
+        )
     }
 }
 
-pub use error::Error;
+impl std::error::Error for MustNotExist {}
diff --git a/gix-ref/src/store/general/handle/find.rs b/gix-ref/src/store/general/handle/find.rs
index a259da3f5d9..8a8a8f82bf0 100644
--- a/gix-ref/src/store/general/handle/find.rs
+++ b/gix-ref/src/store/general/handle/find.rs
@@ -1,37 +1,19 @@
-use crate::{PartialNameRef, Reference, store};
-
-mod error {
-    use std::convert::Infallible;
-
-    /// The error returned by [`crate::file::Store::find_loose()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An error occurred while finding a reference in the loose file database")]
-        Loose(#[from] crate::file::find::Error),
-        #[error("The ref name or path is not a valid ref name")]
-        RefnameValidation(#[from] crate::name::Error),
-    }
-
-    impl From<Infallible> for Error {
-        fn from(_: Infallible) -> Self {
-            unreachable!("this impl is needed to allow passing a known valid partial path as parameter")
-        }
-    }
-}
+use gix_error::{ExnResult, ResultExt, message};
 
-pub use error::Error;
+use crate::{PartialNameRef, Reference, store};
 
 use crate::store::handle;
 
 impl store::Handle {
     /// TODO: actually implement this with handling of the packed buffer.
-    pub fn try_find<'a, Name, E>(&self, partial: Name) -> Result<Option<Reference>, Error>
+    pub fn try_find<'a, Name, E>(&self, partial: Name) -> ExnResult<Option<Reference>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        let _name = partial.try_into()?;
+        let _name = partial
+            .try_into()
+            .or_raise_erased(|| message("Invalid reference name"))?;
         match &self.state {
             handle::State::Loose { .. } => {
                 todo!()
@@ -40,38 +22,13 @@ impl store::Handle {
     }
 }
 
-mod existing {
-    mod error {
-        use std::path::PathBuf;
-
-        /// The error returned by [file::Store::find_existing()][crate::file::Store::find_existing()].
-        #[derive(Debug, thiserror::Error)]
-        pub enum Error {
-            #[error("An error occurred while finding a reference in the database")]
-            Find(#[from] crate::store::find::Error),
-            #[error("The ref partially named {name:?} could not be found")]
-            NotFound { name: PathBuf },
-        }
-    }
-
-    pub use error::Error;
-
-    use crate::{PartialNameRef, Reference, store};
-
-    impl store::Handle {
-        /// Similar to [`crate::file::Store::find()`] but a non-existing ref is treated as error.
-        pub fn find<'a, Name, E>(&self, _partial: Name) -> Result<Reference, Error>
-        where
-            Name: TryInto<&'a PartialNameRef, Error = E>,
-            crate::name::Error: From<E>,
-        {
-            todo!()
-            // match self.try_find(partial) {}
-            // match self.find_one_with_verified_input(path.to_partial_path().as_ref(), packed) {
-            //     Ok(Some(r)) => Ok(r),
-            //     Ok(None) => Err(Error::NotFound(path.to_partial_path().into_owned())),
-            //     Err(err) => Err(err.into()),
-            // }
-        }
+impl store::Handle {
+    /// Similar to [`crate::file::Store::find()`] but a non-existing ref is treated as error.
+    pub fn find<'a, Name, E>(&self, _partial: Name) -> ExnResult<Reference>
+    where
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
+    {
+        todo!()
     }
 }
diff --git a/gix-ref/src/store/general/init.rs b/gix-ref/src/store/general/init.rs
index 5c1e5f7bbe6..40d1423f14b 100644
--- a/gix-ref/src/store/general/init.rs
+++ b/gix-ref/src/store/general/init.rs
@@ -1,15 +1,6 @@
-use std::path::PathBuf;
-
-mod error {
-    /// The error returned by [`crate::Store::at()`].
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error("There was an error accessing the store's directory")]
-        Io(#[from] std::io::Error),
-    }
-}
+use gix_error::{ExnResult, Message, ResultExt};
 
-pub use error::Error;
+use std::path::PathBuf;
 
 use crate::file;
 
@@ -23,7 +14,7 @@ impl crate::Store {
     ///
     /// Note that if [`precompose_unicode`](crate::store::init::Options::precompose_unicode) is set in the options,
     /// the `git_dir` is also expected to use precomposed unicode, or else some operations that strip prefixes will fail.
-    pub fn at(git_dir: PathBuf, object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    pub fn at(git_dir: PathBuf, object_hash: gix_hash::Kind) -> ExnResult<Self> {
         Self::at_opts(git_dir, object_hash, Default::default())
     }
 
@@ -32,13 +23,16 @@ impl crate::Store {
     ///
     /// Note that if [`precompose_unicode`](crate::store::init::Options::precompose_unicode) is set in the options,
     /// the `git_dir` is also expected to use precomposed unicode, or else some operations that strip prefixes will fail.
+    ///
+    /// Errors include [metadata](gix_error::Exn::metadata()) `path` (native path), the reference store directory.
     pub fn at_opts(
         git_dir: PathBuf,
         object_hash: gix_hash::Kind,
         opts: crate::store::init::Options,
-    ) -> Result<Self, Error> {
+    ) -> ExnResult<Self> {
         // for now, just try to read the directory - later we will do that naturally as we have to figure out if it's a ref-table or not.
-        std::fs::read_dir(&git_dir)?;
+        std::fs::read_dir(&git_dir)
+            .or_raise_erased(|| Message::new("Could not access reference store").with("path", git_dir.as_path()))?;
         Ok(crate::Store {
             inner: crate::store::State::Loose {
                 store: file::Store::at_opts(git_dir, object_hash, opts),
diff --git a/gix-ref/src/store/packed/buffer.rs b/gix-ref/src/store/packed/buffer.rs
index f02ae3ca337..301aa54ac00 100644
--- a/gix-ref/src/store/packed/buffer.rs
+++ b/gix-ref/src/store/packed/buffer.rs
@@ -1,3 +1,7 @@
+use std::path::PathBuf;
+
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, message};
+
 use crate::store_impl::packed;
 
 impl AsRef<[u8]> for packed::Buffer {
@@ -15,112 +19,94 @@ impl AsRef<[u8]> for packed::Backing {
     }
 }
 
-///
-pub mod open {
-    use std::path::PathBuf;
-
-    use crate::store_impl::packed;
-
-    /// Initialization
-    impl packed::Buffer {
-        fn open_with_backing(
-            backing: packed::Backing,
-            path: PathBuf,
-            object_hash: gix_hash::Kind,
-        ) -> Result<Self, Error> {
-            let (backing, offset) = {
-                let (offset, sorted) = {
-                    let mut input = backing.as_ref();
-                    if *input.first().unwrap_or(&b' ') == b'#' {
-                        let header = packed::decode::header(&mut input).map_err(|_| Error::HeaderParsing)?;
-                        let offset = backing.as_ref().len() - input.len();
-                        (offset, header.sorted)
-                    } else {
-                        (0, false)
-                    }
-                };
-
-                if !sorted {
-                    // this implementation is likely slower than what git does, but it's less code, too.
-                    let mut entries =
-                        packed::Iter::new(&backing.as_ref()[offset..], object_hash)?.collect::<Result<Vec<_>, _>>()?;
-                    entries.sort_by_key(|e| e.name.as_bstr());
-                    let mut serialized = Vec::<u8>::new();
-                    for entry in entries {
-                        serialized.extend_from_slice(entry.target);
-                        serialized.push(b' ');
-                        serialized.extend_from_slice(entry.name.as_bstr());
-                        serialized.push(b'\n');
-                        if let Some(object) = entry.object {
-                            serialized.push(b'^');
-                            serialized.extend_from_slice(object);
-                            serialized.push(b'\n');
-                        }
-                    }
-                    (Backing::InMemory(serialized), 0)
+/// Initialization
+impl packed::Buffer {
+    fn open_with_backing(backing: packed::Backing, path: PathBuf, object_hash: gix_hash::Kind) -> ExnResult<Self> {
+        let (backing, offset) = {
+            let (offset, sorted) = {
+                let mut input = backing.as_ref();
+                if *input.first().unwrap_or(&b' ') == b'#' {
+                    let header = packed::decode::header(&mut input).map_err(|()| {
+                        gix_error::corruption("The header could not be parsed, even though first line started with '#'")
+                            .raise_erased()
+                    })?;
+                    let offset = backing.as_ref().len() - input.len();
+                    (offset, header.sorted)
                 } else {
-                    (backing, offset)
+                    (0, false)
                 }
             };
-            Ok(packed::Buffer {
-                offset,
-                data: backing,
-                path,
-                object_hash,
-            })
-        }
 
-        /// Open the file at `path`, parsing object ids as `object_hash`, and map it into memory if the file size is larger
-        /// than `use_memory_map_if_larger_than_bytes`.
-        ///
-        /// In order to allow fast lookups and optimizations, the contents of the packed refs must be sorted.
-        /// If that's not the case, they will be sorted on the fly with the data being written into a memory buffer.
-        pub fn open(
-            path: PathBuf,
-            use_memory_map_if_larger_than_bytes: u64,
-            object_hash: gix_hash::Kind,
-        ) -> Result<Self, Error> {
-            let backing = if std::fs::metadata(&path)?.len() <= use_memory_map_if_larger_than_bytes {
-                packed::Backing::InMemory(std::fs::read(&path)?)
+            if !sorted {
+                // this implementation is likely slower than what git does, but it's less code, too.
+                let mut entries = packed::Iter::new(&backing.as_ref()[offset..], object_hash)
+                    .or_raise_erased(|| message("Could not iterate unsorted packed refs"))?
+                    .collect::<Result<Vec<_>, _>>()
+                    .or_erased()?;
+                entries.sort_by_key(|e| e.name.as_bstr());
+                let mut serialized = Vec::<u8>::new();
+                for entry in entries {
+                    serialized.extend_from_slice(entry.target);
+                    serialized.push(b' ');
+                    serialized.extend_from_slice(entry.name.as_bstr());
+                    serialized.push(b'\n');
+                    if let Some(object) = entry.object {
+                        serialized.push(b'^');
+                        serialized.extend_from_slice(object);
+                        serialized.push(b'\n');
+                    }
+                }
+                (packed::Backing::InMemory(serialized), 0)
             } else {
-                packed::Backing::Mapped(
-                    // SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.
-                    #[expect(unsafe_code)]
-                    unsafe {
-                        memmap2::MmapOptions::new().map_copy_read_only(&std::fs::File::open(&path)?)?
-                    },
-                )
-            };
-            Self::open_with_backing(backing, path, object_hash)
-        }
-
-        /// Open a buffer from `bytes`, which is the content of a typical `packed-refs` file, parsing object ids as
-        /// `object_hash`.
-        ///
-        /// In order to allow fast lookups and optimizations, the contents of the packed refs must be sorted.
-        /// If that's not the case, they will be sorted on the fly.
-        pub fn from_bytes(bytes: &[u8], object_hash: gix_hash::Kind) -> Result<Self, Error> {
-            let backing = packed::Backing::InMemory(bytes.into());
-            Self::open_with_backing(backing, PathBuf::from("<memory>"), object_hash)
-        }
+                (backing, offset)
+            }
+        };
+        Ok(packed::Buffer {
+            offset,
+            data: backing,
+            path,
+            object_hash,
+        })
     }
 
-    mod error {
-        use crate::packed;
-
-        /// The error returned by [`open()`][super::packed::Buffer::open()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("The packed-refs file did not have a header or wasn't sorted and could not be iterated")]
-            Iter(#[from] packed::iter::Error),
-            #[error("The header could not be parsed, even though first line started with '#'")]
-            HeaderParsing,
-            #[error("The buffer could not be opened or read")]
-            Io(#[from] std::io::Error),
-        }
+    /// Open the file at `path`, parsing object ids as `object_hash`, and map it into memory if the file size is larger
+    /// than `use_memory_map_if_larger_than_bytes`.
+    ///
+    /// In order to allow fast lookups and optimizations, the contents of the packed refs must be sorted.
+    /// If that's not the case, they will be sorted on the fly with the data being written into a memory buffer.
+    ///
+    /// I/O failures include [metadata](gix_error::Exn::metadata()) `path` (native path), the packed-refs file.
+    pub fn open(
+        path: PathBuf,
+        use_memory_map_if_larger_than_bytes: u64,
+        object_hash: gix_hash::Kind,
+    ) -> ExnResult<Self> {
+        let backing = (|| -> std::io::Result<packed::Backing> {
+            Ok(
+                if std::fs::metadata(&path)?.len() <= use_memory_map_if_larger_than_bytes {
+                    packed::Backing::InMemory(std::fs::read(&path)?)
+                } else {
+                    packed::Backing::Mapped(
+                        // SAFETY: Git replaces packed-refs rather than changing a mapped file in place.
+                        #[expect(unsafe_code)]
+                        unsafe {
+                            memmap2::MmapOptions::new().map_copy_read_only(&std::fs::File::open(&path)?)?
+                        },
+                    )
+                },
+            )
+        })()
+        .or_raise_erased(|| Message::new("Could not open packed refs").with("path", path.as_path()))?;
+        Self::open_with_backing(backing, path, object_hash)
     }
-    pub use error::Error;
 
-    use crate::packed::Backing;
+    /// Open a buffer from `bytes`, which is the content of a typical `packed-refs` file, parsing object ids as
+    /// `object_hash`.
+    ///
+    /// In order to allow fast lookups and optimizations, the contents of the packed refs must be sorted.
+    /// If that's not the case, they will be sorted on the fly.
+    pub fn from_bytes(bytes: &[u8], object_hash: gix_hash::Kind) -> ExnResult<Self> {
+        let backing = packed::Backing::InMemory(bytes.into());
+        Self::open_with_backing(backing, PathBuf::from("<memory>"), object_hash)
+    }
 }
diff --git a/gix-ref/src/store/packed/decode/mod.rs b/gix-ref/src/store/packed/decode/mod.rs
index c967ffa757d..9d250003232 100644
--- a/gix-ref/src/store/packed/decode/mod.rs
+++ b/gix-ref/src/store/packed/decode/mod.rs
@@ -1,3 +1,4 @@
+use gix_error::{ExnMessageResult, ResultExt};
 use gix_object::bstr::{BStr, ByteSlice};
 
 use crate::{parse, store_impl::packed};
@@ -76,18 +77,17 @@ pub fn header(input: &mut &[u8]) -> Result<Header, ()> {
 ///
 /// On success, `input` is advanced past the reference line and, if present, the
 /// peeled object line.
-pub fn reference<'a>(input: &mut &'a [u8], object_hash: gix_hash::Kind) -> Result<packed::Reference<'a>, ()> {
-    let target = parse::hex_hash(input, object_hash)?;
-    let Some(rest) = input.strip_prefix(b" ") else {
-        return Err(());
-    };
-    *input = rest;
-    let name = until_line_end_without_separator(input)?.try_into().map_err(|_| ())?;
+pub fn reference<'a>(input: &mut &'a [u8], object_hash: gix_hash::Kind) -> ExnMessageResult<packed::Reference<'a>> {
+    let invalid = || gix_error::corruption("Malformed packed reference");
+    let target = parse::hex_hash(input, object_hash).map_err(|()| invalid())?;
+    *input = input.strip_prefix(b" ").ok_or_else(invalid)?;
+    let name = <&crate::FullNameRef>::try_from(until_line_end_without_separator(input).map_err(|()| invalid())?)
+        .or_raise(invalid)?;
 
     let object = if let Some(rest) = input.strip_prefix(b"^") {
         *input = rest;
-        let object = parse::hex_hash(input, object_hash)?;
-        parse::newline(input)?;
+        let object = parse::hex_hash(input, object_hash).map_err(|()| invalid())?;
+        parse::newline(input).map_err(|()| invalid())?;
         Some(object)
     } else {
         None
diff --git a/gix-ref/src/store/packed/find.rs b/gix-ref/src/store/packed/find.rs
index 005f87f4357..15905656141 100644
--- a/gix-ref/src/store/packed/find.rs
+++ b/gix-ref/src/store/packed/find.rs
@@ -1,3 +1,5 @@
+use gix_error::{ErrorExt, ExnResult, Message, ResultExt, message};
+
 use gix_object::bstr::{BStr, BString};
 
 use crate::{FullNameRef, PartialNameRef, store_impl::packed};
@@ -8,12 +10,14 @@ impl packed::Buffer {
     ///
     /// Note that it will look it up verbatim and does not deal with namespaces or special prefixes like
     /// `main-worktree/` or `worktrees/<name>/`, as this is left to the caller.
-    pub fn try_find<'a, Name, E>(&self, name: Name) -> Result<Option<packed::Reference<'_>>, Error>
+    pub fn try_find<'a, Name, E>(&self, name: Name) -> ExnResult<Option<packed::Reference<'_>>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        let name = name.try_into()?;
+        let name = name
+            .try_into()
+            .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?;
         let mut buf = BString::default();
         for inbetween in &["", "tags", "heads", "remotes"] {
             let (name, was_absolute) = if name.looks_like_full_name(false) {
@@ -36,35 +40,40 @@ impl packed::Buffer {
         Ok(None)
     }
 
-    pub(crate) fn try_find_full_name(&self, name: &FullNameRef) -> Result<Option<packed::Reference<'_>>, Error> {
+    /// Look up a resolved name. Decode failures include [metadata](gix_error::Exn::metadata()) `name` (bytes), the
+    /// requested full name.
+    pub(crate) fn try_find_full_name(&self, name: &FullNameRef) -> ExnResult<Option<packed::Reference<'_>>> {
         match self.binary_search_by(name.as_bstr()) {
             Ok(line_start) => {
                 let mut input = &self.as_ref()[line_start..];
-                Ok(Some(
-                    packed::decode::reference(&mut input, self.object_hash).map_err(|_| Error::Parse)?,
-                ))
+                packed::decode::reference(&mut input, self.object_hash).map(Some)
             }
             Err((parse_failure, _)) => {
                 if parse_failure {
-                    Err(Error::Parse)
+                    Err(gix_error::corruption("Malformed packed reference record").raise())
                 } else {
                     Ok(None)
                 }
             }
         }
+        .or_raise_erased(|| Message::new("Could not decode packed reference").with("name", name.as_bstr()))
     }
 
     /// Find a reference with the given `name` and return it.
-    pub fn find<'a, Name, E>(&self, name: Name) -> Result<packed::Reference<'_>, existing::Error>
+    pub fn find<'a, Name, E>(&self, name: Name) -> ExnResult<packed::Reference<'_>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        Error: From<E>,
+        Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        match self.try_find(name) {
-            Ok(Some(r)) => Ok(r),
-            Ok(None) => Err(existing::Error::NotFound),
-            Err(err) => Err(existing::Error::Find(err)),
-        }
+        let name = name
+            .try_into()
+            .or_raise_erased(|| message("The ref name or path is not a valid ref name"))?;
+        self.try_find::<_, std::convert::Infallible>(name)?.ok_or_else(|| {
+            crate::file::find::NotFound {
+                name: name.to_partial_path().to_owned(),
+            }
+            .raise_erased()
+        })
     }
 
     /// Perform a binary search where `Ok(pos)` is the beginning of the line that matches `name` perfectly and `Err(pos)`
@@ -97,41 +106,6 @@ impl packed::Buffer {
     }
 }
 
-mod error {
-    use std::convert::Infallible;
-
-    /// The error returned by [`find()`][super::packed::Buffer::find()]
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The ref name or path is not a valid ref name")]
-        RefnameValidation(#[from] crate::name::Error),
-        #[error("The reference could not be parsed")]
-        Parse,
-    }
-
-    impl From<Infallible> for Error {
-        fn from(_: Infallible) -> Self {
-            unreachable!("this impl is needed to allow passing a known valid partial path as parameter")
-        }
-    }
-}
-pub use error::Error;
-
-///
-pub mod existing {
-
-    /// The error returned by [`find_existing()`][super::packed::Buffer::find()]
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The find operation failed")]
-        Find(#[from] super::Error),
-        #[error("The reference did not exist even though that was expected")]
-        NotFound,
-    }
-}
-
 pub(crate) fn transform_full_name_for_lookup(name: &FullNameRef) -> Option<&FullNameRef> {
     match name.category_and_short_name() {
         Some((c, sn)) => {
diff --git a/gix-ref/src/store/packed/iter.rs b/gix-ref/src/store/packed/iter.rs
index aa2ef319f2e..e84f7bac85b 100644
--- a/gix-ref/src/store/packed/iter.rs
+++ b/gix-ref/src/store/packed/iter.rs
@@ -1,3 +1,5 @@
+use gix_error::{ErrorExt, ExnMessageResult, Message, corruption};
+
 use gix_object::bstr::{BString, ByteSlice};
 
 use crate::store_impl::{packed, packed::decode};
@@ -5,16 +7,20 @@ use crate::store_impl::{packed, packed::decode};
 /// packed-refs specific functionality
 impl packed::Buffer {
     /// Return an iterator of references stored in this packed refs buffer, ordered by reference name.
+    /// Header failures include [metadata](gix_error::Exn::metadata()) `input` (bytes), the first line without its
+    /// newline.
     ///
     /// # Note
     ///
     /// There is no namespace support in packed iterators. It can be emulated using `iter_prefixed(…)`.
-    pub fn iter(&self) -> Result<packed::Iter<'_>, packed::iter::Error> {
+    pub fn iter(&self) -> ExnMessageResult<packed::Iter<'_>> {
         packed::Iter::new(self.as_ref(), self.object_hash)
     }
 
     /// Return an iterator yielding only references matching the given prefix, ordered by reference name.
-    pub fn iter_prefixed(&self, prefix: BString) -> Result<packed::Iter<'_>, packed::iter::Error> {
+    /// Header failures include [metadata](gix_error::Exn::metadata()) `input` (bytes), the first selected line without
+    /// its newline.
+    pub fn iter_prefixed(&self, prefix: BString) -> ExnMessageResult<packed::Iter<'_>> {
         let first_record_with_prefix = self.binary_search_by(prefix.as_bstr()).unwrap_or_else(|(_, pos)| pos);
         packed::Iter::new_with_prefix(
             &self.as_ref()[first_record_with_prefix..],
@@ -25,8 +31,10 @@ impl packed::Buffer {
 }
 
 impl<'a> Iterator for packed::Iter<'a> {
-    type Item = Result<packed::Reference<'a>, Error>;
+    type Item = ExnMessageResult<packed::Reference<'a>>;
 
+    /// Decode failures include [metadata](gix_error::Exn::metadata()) `line` (one-based line number within this
+    /// iterator's input) and `input` (line bytes).
     fn next(&mut self) -> Option<Self::Item> {
         if self.cursor.is_empty() {
             return None;
@@ -35,7 +43,7 @@ impl<'a> Iterator for packed::Iter<'a> {
         let start = self.cursor;
         match decode::reference(&mut self.cursor, self.object_hash) {
             Ok(reference) => {
-                self.current_line += 1;
+                self.current_line += 1 + usize::from(reference.object.is_some());
                 if let Some(ref prefix) = self.prefix
                     && !reference.name.as_bstr().starts_with_str(prefix)
                 {
@@ -44,7 +52,7 @@ impl<'a> Iterator for packed::Iter<'a> {
                 }
                 Some(Ok(reference))
             }
-            Err(_) => {
+            Err(err) => {
                 self.cursor = start;
                 let (failed_line, next_cursor) = self
                     .cursor
@@ -54,13 +62,11 @@ impl<'a> Iterator for packed::Iter<'a> {
                 let line_number = self.current_line;
                 self.current_line += 1;
 
-                Some(Err(Error::Reference {
-                    invalid_line: failed_line
-                        .get(..failed_line.len().saturating_sub(1))
-                        .unwrap_or(failed_line)
-                        .into(),
-                    line_number,
-                }))
+                Some(Err(err.raise(
+                    Message::new("Invalid packed reference")
+                        .with("input", failed_line.strip_suffix(b"\n").unwrap_or(failed_line))
+                        .with("line", line_number),
+                )))
             }
         }
     }
@@ -69,18 +75,22 @@ impl<'a> Iterator for packed::Iter<'a> {
 impl<'a> packed::Iter<'a> {
     /// Return a new iterator after successfully parsing the possibly existing first line of the given `packed` refs buffer,
     /// parsing object ids as `object_hash`.
-    pub fn new(packed: &'a [u8], object_hash: gix_hash::Kind) -> Result<Self, Error> {
+    /// Header failures include [metadata](gix_error::Exn::metadata()) `input` (bytes), the first line without its
+    /// newline.
+    pub fn new(packed: &'a [u8], object_hash: gix_hash::Kind) -> ExnMessageResult<Self> {
         Self::new_with_prefix(packed, object_hash, None)
     }
 
     /// Returns an iterator whose references will only match `prefix`.
     ///
     /// It assumes that the underlying `packed` buffer is indeed sorted and parses object ids as `object_hash`.
+    /// Header failures include [metadata](gix_error::Exn::metadata()) `input` (bytes), the first line without its
+    /// newline.
     pub(in crate::store_impl::packed) fn new_with_prefix(
         packed: &'a [u8],
         object_hash: gix_hash::Kind,
         prefix: Option<BString>,
-    ) -> Result<Self, Error> {
+    ) -> ExnMessageResult<Self> {
         if packed.is_empty() {
             Ok(packed::Iter {
                 cursor: packed,
@@ -90,8 +100,10 @@ impl<'a> packed::Iter<'a> {
             })
         } else if packed[0] == b'#' {
             let mut input = packed;
-            decode::header(&mut input).map_err(|_| Error::Header {
-                invalid_first_line: packed.lines().next().unwrap_or(packed).into(),
+            decode::header(&mut input).map_err(|()| {
+                corruption("Invalid packed reference header")
+                    .with("input", packed.lines().next().unwrap_or(packed))
+                    .raise()
             })?;
             let refs = input;
             Ok(packed::Iter {
@@ -110,19 +122,3 @@ impl<'a> packed::Iter<'a> {
         }
     }
 }
-
-mod error {
-    use gix_object::bstr::BString;
-
-    /// The error returned by [`Iter`][super::packed::Iter],
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The header existed but could not be parsed: {invalid_first_line:?}")]
-        Header { invalid_first_line: BString },
-        #[error("Invalid reference in line {line_number}: {invalid_line:?}")]
-        Reference { invalid_line: BString, line_number: usize },
-    }
-}
-
-pub use error::Error;
diff --git a/gix-ref/src/store/packed/transaction.rs b/gix-ref/src/store/packed/transaction.rs
index 9915d39d7c2..ea72dd0e186 100644
--- a/gix-ref/src/store/packed/transaction.rs
+++ b/gix-ref/src/store/packed/transaction.rs
@@ -1,7 +1,9 @@
 use std::{borrow::Cow, fmt::Formatter, io::Write};
 
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, Message, ResultExt, message, not_found};
+
 use crate::{
-    Namespace, Target, file,
+    FullNameRef, Namespace, Target, file,
     store_impl::{packed, packed::Edit},
     transaction::{Change, RefEdit},
 };
@@ -48,11 +50,14 @@ impl packed::Transaction {
 impl packed::Transaction {
     /// Prepare the transaction by checking all edits for applicability.
     /// Use `objects` to access objects for the purpose of peeling them - this is only used if packed-refs are involved.
+    /// Object lookup failures include [metadata](gix_error::Exn::metadata()) `object_id` (hex text) and `reference`
+    /// (name bytes).
+    /// Missing objects are classified as not found; lookup errors retain their own classifications.
     pub fn prepare(
         mut self,
         edits: &mut dyn Iterator<Item = RefEdit>,
         objects: &dyn gix_object::Find,
-    ) -> Result<Self, prepare::Error> {
+    ) -> ExnResult<Self> {
         assert!(self.edits.is_none(), "BUG: cannot call prepare(…) more than once");
         let buffer = &self.buffer;
         // Remove all edits which are deletions that aren't here in the first place
@@ -106,7 +111,9 @@ impl packed::Transaction {
             {
                 let mut next_id = new;
                 edit.peeled = loop {
-                    let data = objects.try_find(&next_id, &mut buf)?;
+                    let data = objects
+                        .try_find(&next_id, &mut buf)
+                        .or_raise_erased(|| peel_reference_error(&next_id, edit.inner.name.as_ref()))?;
                     match data {
                         Some(gix_object::Data {
                             kind: gix_object::Kind::Tag,
@@ -115,19 +122,17 @@ impl packed::Transaction {
                         }) => {
                             next_id = gix_object::TagRefIter::from_bytes(data, hash_kind)
                                 .target_id()
-                                .map_err(|_| {
-                                    prepare::Error::Resolve(
-                                        format!("Couldn't get target object id from tag {next_id}").into(),
-                                    )
-                                })?;
+                                .or_raise(|| gix_error::message!("Couldn't get target object id from tag {next_id}"))
+                                .or_raise_erased(|| peel_reference_error(&next_id, edit.inner.name.as_ref()))?;
                         }
                         Some(_) => {
                             break if next_id == new { None } else { Some(next_id) };
                         }
                         None => {
-                            return Err(prepare::Error::Resolve(
-                                format!("Couldn't find object with id {next_id}").into(),
-                            ));
+                            return Err(not_found("Could not peel packed reference: object could not be found")
+                                .with("object_id", next_id.to_string())
+                                .with("reference", edit.inner.name.as_bstr())
+                                .raise_erased());
                         }
                     }
                 };
@@ -140,7 +145,7 @@ impl packed::Transaction {
                 .take()
                 .map(gix_lock::File::close)
                 .transpose()
-                .map_err(prepare::Error::CloseLock)?;
+                .or_raise_erased(|| message("Could not close unused packed reference lock"))?;
         } else {
             // NOTE that we don't do any additional checks here but apply all edits unconditionally.
             // This is because this transaction system is internal and will be used correctly from the
@@ -154,32 +159,33 @@ impl packed::Transaction {
     ///
     /// Please note that actual edits invalidated existing packed buffers.
     /// Note: There is the potential to write changes into memory and return such a packed-refs buffer for reuse.
-    pub fn commit(self) -> Result<(), commit::Error> {
+    pub fn commit(self) -> ExnResult {
         let mut edits = self.edits.expect("BUG: cannot call commit() before prepare(…)");
         if edits.is_empty() {
             return Ok(());
         }
 
         let mut file = self.lock.expect("a write lock for applying changes");
-        let refs_sorted: Box<dyn Iterator<Item = Result<packed::Reference<'_>, packed::iter::Error>>> =
-            match self.buffer.as_ref() {
-                Some(buffer) => Box::new(buffer.iter()?),
-                None => Box::new(std::iter::empty()),
-            };
+        let refs_sorted: Box<dyn Iterator<Item = ExnMessageResult<packed::Reference<'_>>>> = match self.buffer.as_ref()
+        {
+            Some(buffer) => Box::new(buffer.iter().or_erased()?),
+            None => Box::new(std::iter::empty()),
+        };
 
         let mut refs_sorted = refs_sorted.peekable();
 
         edits.sort_by(|l, r| l.inner.name.as_bstr().cmp(r.inner.name.as_bstr()));
         let mut peekable_sorted_edits = edits.iter().peekable();
 
-        file.with_mut(|f| f.write_all(HEADER_LINE))?;
+        file.with_mut(|f| f.write_all(HEADER_LINE))
+            .or_raise_erased(|| message("Could not write packed refs header"))?;
 
         let mut num_written_lines = 0;
         loop {
             match (refs_sorted.peek(), peekable_sorted_edits.peek()) {
                 (Some(Err(_)), _) => {
                     let err = refs_sorted.next().expect("next").expect_err("err");
-                    return Err(commit::Error::Iteration(err));
+                    return Err(err.erased());
                 }
                 (None, None) => {
                     break;
@@ -187,7 +193,8 @@ impl packed::Transaction {
                 (Some(Ok(_)), None) => {
                     let pref = refs_sorted.next().expect("next").expect("no err");
                     num_written_lines += 1;
-                    file.with_mut(|out| write_packed_ref(out, pref))?;
+                    file.with_mut(|out| write_packed_ref(out, pref))
+                        .or_raise_erased(|| message("Could not write packed reference"))?;
                 }
                 (Some(Ok(pref)), Some(edit)) => {
                     use std::cmp::Ordering::*;
@@ -195,36 +202,50 @@ impl packed::Transaction {
                         Less => {
                             let pref = refs_sorted.next().expect("next").expect("valid");
                             num_written_lines += 1;
-                            file.with_mut(|out| write_packed_ref(out, pref))?;
+                            file.with_mut(|out| write_packed_ref(out, pref))
+                                .or_raise_erased(|| message("Could not write packed reference"))?;
                         }
                         Greater => {
                             let edit = peekable_sorted_edits.next().expect("next");
-                            file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))?;
+                            file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))
+                                .or_raise_erased(|| message("Could not write packed reference edit"))?;
                         }
                         Equal => {
                             let _pref = refs_sorted.next().expect("next").expect("valid");
                             let edit = peekable_sorted_edits.next().expect("next");
-                            file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))?;
+                            file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))
+                                .or_raise_erased(|| message("Could not write packed reference edit"))?;
                         }
                     }
                 }
                 (None, Some(_)) => {
                     let edit = peekable_sorted_edits.next().expect("next");
-                    file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))?;
+                    file.with_mut(|out| write_edit(out, edit, &mut num_written_lines))
+                        .or_raise_erased(|| message("Could not write packed reference edit"))?;
                 }
             }
         }
 
         if num_written_lines == 0 {
-            std::fs::remove_file(file.resource_path())?;
+            std::fs::remove_file(file.resource_path())
+                .or_raise_erased(|| message("Could not delete empty packed refs"))?;
         } else {
-            file.commit()?;
+            file.commit()
+                .or_raise_erased(|| message("Could not commit packed refs"))?;
         }
         drop(refs_sorted);
         Ok(())
     }
 }
 
+/// The raised error's [metadata](gix_error::Exn::metadata()) `object_id` (hex text) and `reference` (name bytes)
+/// identify the object and packed reference being peeled.
+fn peel_reference_error(object_id: &gix_hash::oid, reference: &FullNameRef) -> Message {
+    Message::new("Could not peel packed reference")
+        .with("object_id", object_id.to_string())
+        .with("reference", reference.as_bstr())
+}
+
 fn write_packed_ref(out: &mut dyn std::io::Write, pref: packed::Reference<'_>) -> std::io::Result<()> {
     write!(out, "{} ", pref.target)?;
     out.write_all(pref.name.as_bstr())?;
@@ -264,7 +285,7 @@ pub(crate) fn buffer_into_transaction(
     lock_mode: gix_lock::acquire::Fail,
     precompose_unicode: bool,
     namespace: Option<Namespace>,
-) -> Result<packed::Transaction, gix_lock::acquire::Error> {
+) -> ExnResult<packed::Transaction> {
     let lock = gix_lock::File::acquire_to_update_resource(&buffer.path, lock_mode, None)?;
     Ok(packed::Transaction {
         buffer: Some(buffer),
@@ -275,33 +296,3 @@ pub(crate) fn buffer_into_transaction(
         namespace,
     })
 }
-
-///
-pub mod prepare {
-    /// The error used in [`Transaction::prepare(…)`][crate::file::Transaction::prepare()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not close a lock which won't ever be committed")]
-        CloseLock(#[from] std::io::Error),
-        #[error("The lookup of an object failed while peeling it")]
-        Resolve(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-    }
-}
-
-///
-pub mod commit {
-    use crate::store_impl::packed;
-
-    /// The error used in [`Transaction::commit(…)`][crate::file::Transaction::commit()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Changes to the resource could not be committed")]
-        Commit(#[from] gix_lock::commit::Error<gix_lock::File>),
-        #[error("Some references in the packed refs buffer could not be parsed")]
-        Iteration(#[from] packed::iter::Error),
-        #[error("Failed to write a ref line to the packed ref file")]
-        Io(#[from] std::io::Error),
-    }
-}
diff --git a/gix-ref/tests/refs/error.rs b/gix-ref/tests/refs/error.rs
new file mode 100644
index 00000000000..e2f5e45298e
--- /dev/null
+++ b/gix-ref/tests/refs/error.rs
@@ -0,0 +1,689 @@
+use crate::Result;
+use gix_error::{Class, Error, ErrorExt, ExnResult, Message, MetadataValue};
+use gix_ref::{file::ReferenceExt, packed, transaction::PreviousValue};
+
+#[test]
+fn missing_references_retain_their_name_and_classification() -> Result {
+    let mut error_snapshots = Vec::new();
+    let store = crate::file::store_with_packed_refs()?;
+    let packed = store.open_packed_buffer()?.expect("the fixture has packed refs");
+    let missing = std::ffi::OsStr::new("missing");
+    for err in [
+        store.find(missing).expect_err("the reference is absent"),
+        store.find_loose(missing).expect_err("the reference is absent"),
+        store
+            .find_packed(missing, Some(&packed))
+            .expect_err("the reference is absent"),
+        packed.find(missing).expect_err("the reference is absent"),
+    ] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(
+            err.is_not_found(),
+            "missing loose and packed refs are classified: {err}"
+        );
+        assert!(
+            err.probable_cause().is::<gix_ref::file::find::NotFound>(),
+            "the missing reference, not its classification marker, is the probable cause"
+        );
+        assert_eq!(
+            err.downcast_any_ref::<gix_ref::file::find::NotFound>()
+                .expect("the concrete reference lookup error is retained")
+                .name
+                .as_os_str(),
+            missing,
+            "the lookup failure retains the missing reference name"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "missing references remain classified after erasure", @r#"
+    [
+        The ref partially named "missing" could not be found,
+        The ref partially named "missing" could not be found,
+        The ref partially named "missing" could not be found,
+        The ref partially named "missing" could not be found,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn peeling_missing_targets_is_classified() -> Result {
+    let mut error_snapshots = Vec::new();
+    use gix_lock::acquire::Fail;
+    use gix_ref::{file::transaction::PackedRefs, transaction::RefEdit};
+
+    let (_keep, packed_store) = crate::file::transaction::prepare_and_commit::empty_store()?;
+    let blob_id = crate::fixture_hash_kind().empty_blob();
+    let name = "refs/tags/missing";
+    let packed_err = packed_store
+        .transaction()
+        .packed_refs(PackedRefs::DeletionsAndNonSymbolicUpdates(Box::new(
+            gix_object::find::Never,
+        )))
+        .prepare(
+            [RefEdit::update(
+                name.try_into()?,
+                gix_ref::Target::Object(blob_id),
+                PreviousValue::Any,
+                "",
+            )],
+            Fail::Immediately,
+            Fail::Immediately,
+        )
+        .expect_err("the object to pack is absent")
+        .into_error();
+    let details = packed_err.metadata().next().expect("packed peeling context");
+    let diagnostic = packed_err
+        .downcast_any_ref::<Message>()
+        .expect("packed peeling diagnostic");
+    assert_eq!(
+        details.len(),
+        2,
+        "peeling context contains only the object and reference"
+    );
+    assert_eq!(
+        details["object_id"],
+        gix_error::MetadataValue::String(blob_id.to_string()),
+        "object ids remain hex text"
+    );
+    assert_eq!(
+        details["reference"],
+        gix_error::MetadataValue::Bytes(name.into()),
+        "reference names remain bytes"
+    );
+    assert_eq!(
+        diagnostic.class,
+        Some(Class::NotFound),
+        "the missing-object classification remains accessible on the diagnostic"
+    );
+
+    let store = crate::file::store_at("make_ref_repository.sh")?;
+    let mut symbolic = store.find("HEAD")?;
+    symbolic.target = gix_ref::Target::Symbolic("refs/heads/missing".try_into()?);
+    let mut direct = store.find("main")?;
+    for err in [
+        Error::from(
+            symbolic
+                .follow(&store)
+                .expect("HEAD is symbolic")
+                .expect_err("the referent is absent"),
+        ),
+        Error::from(
+            symbolic
+                .peel_to_id(&store, &gix_object::find::Never)
+                .expect_err("the symbolic target is absent"),
+        ),
+        Error::from(
+            direct
+                .peel_to_id(&store, &gix_object::find::Never)
+                .expect_err("the object database is empty"),
+        ),
+        packed_err,
+    ] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(
+            err.is_not_found(),
+            "missing referents and objects are classified: {err}"
+        );
+        assert!(!err.is_corrupted(), "absence alone does not imply corruption");
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "peeling missing targets is classified", @r#"
+    [
+        The ref partially named "refs/heads/missing" could not be found,
+        The ref partially named "refs/heads/missing" could not be found,
+        Could not peel reference to an object: object could not be found, "object_id"="Oid(1)", "reference"="refs/heads/main",
+        Could not peel packed reference: object could not be found, "object_id"="Oid(1)", "reference"="refs/tags/missing",
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn peeling_missing_objects_has_one_classified_diagnostic() -> Result {
+    let mut error_snapshots = Vec::new();
+    for err in peeling_errors(gix_object::find::Never)? {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_not_found(), "an absent object is classified as not found");
+        assert_eq!(err.iter_errors().count(), 1, "absence does not need a synthetic cause");
+        let details = err.metadata().next().expect("peeling details survive conversion");
+        let diagnostic = err.downcast_any_ref::<Message>().expect("peeling diagnostic");
+        assert_eq!(
+            diagnostic.class,
+            Some(Class::NotFound),
+            "the diagnostic carries its class"
+        );
+        assert_eq!(
+            details["object_id"],
+            MetadataValue::from(crate::fixture_hash_kind().null().to_string()),
+            "the missing object is identified"
+        );
+        assert_eq!(
+            details["reference"],
+            MetadataValue::from(b"refs/tags/tag".as_slice()),
+            "the reference being peeled is identified"
+        );
+        assert!(
+            err.probable_cause().is::<Message>(),
+            "the classified diagnostic itself is the probable cause"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "peeling missing objects has one classified diagnostic", @r#"
+    [
+        Could not peel reference to an object: object could not be found, "object_id"="Oid(1)", "reference"="refs/tags/tag",
+        Could not peel packed reference: object could not be found, "object_id"="Oid(1)", "reference"="refs/tags/tag",
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn object_lookup_failures_retain_their_causes() -> Result {
+    let mut error_snapshots = Vec::new();
+    struct UnavailableObjects(std::io::ErrorKind);
+    impl gix_object::Find for UnavailableObjects {
+        fn try_find<'a>(
+            &self,
+            _object_id: &gix_hash::oid,
+            _buffer: &'a mut Vec<u8>,
+        ) -> ExnResult<Option<gix_object::Data<'a>>> {
+            Err(std::io::Error::new(self.0, gix_error::message("object database unavailable")).raise_erased())
+        }
+    }
+
+    for kind in [std::io::ErrorKind::PermissionDenied, std::io::ErrorKind::TimedOut] {
+        for err in peeling_errors(UnavailableObjects(kind))? {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(!err.is_not_found(), "a failed lookup does not imply an absent object");
+            assert!(!err.is_corrupted(), "a failed lookup does not imply corrupt data");
+            assert_eq!(
+                err.can_retry(),
+                kind == std::io::ErrorKind::TimedOut,
+                "retryability still comes from the callee"
+            );
+            assert_eq!(
+                err.iter_errors().count(),
+                3,
+                "the context retains the real I/O error and its payload"
+            );
+            assert_eq!(
+                err.downcast_any_ref::<std::io::Error>()
+                    .expect("the I/O error remains available")
+                    .kind(),
+                kind,
+                "the callee's concrete error remains intact"
+            );
+            let details = err.metadata().next().expect("peeling context");
+            assert_eq!(
+                err.downcast_any_ref::<Message>().expect("peeling context").class,
+                None,
+                "the context does not reclassify the lookup failure"
+            );
+            assert_eq!(
+                details["object_id"],
+                MetadataValue::from(crate::fixture_hash_kind().null().to_string()),
+                "failed lookups retain the requested object"
+            );
+            assert_eq!(
+                details["reference"],
+                MetadataValue::from(b"refs/tags/tag".as_slice()),
+                "failed lookups retain the reference being peeled"
+            );
+        }
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "object lookup failures retain their causes", @r#"
+    [
+        Could not peel reference to an object, "object_id"="Oid(1)", "reference"="refs/tags/tag"
+        |
+        └─ I/O error (PermissionDenied)
+        |
+        └─ object database unavailable,
+        Could not peel packed reference, "object_id"="Oid(1)", "reference"="refs/tags/tag"
+        |
+        └─ I/O error (PermissionDenied)
+        |
+        └─ object database unavailable,
+        Could not peel reference to an object, "object_id"="Oid(1)", "reference"="refs/tags/tag"
+        |
+        └─ I/O error (TimedOut)
+        |
+        └─ object database unavailable,
+        Could not peel packed reference, "object_id"="Oid(1)", "reference"="refs/tags/tag"
+        |
+        └─ I/O error (TimedOut)
+        |
+        └─ object database unavailable,
+    ]
+    "#);
+    Ok(())
+}
+
+fn peeling_errors(objects: impl gix_object::Find) -> Result<[gix_error::Exn; 2]> {
+    use gix_lock::acquire::Fail;
+    use gix_ref::{file::transaction::PackedRefs, transaction::RefEdit};
+
+    let (_keep, store) = crate::file::transaction::prepare_and_commit::empty_store()?;
+    let mut reference = gix_ref::Reference {
+        name: "refs/tags/tag".try_into()?,
+        target: gix_ref::Target::Object(crate::fixture_hash_kind().null()),
+        peeled: None,
+    };
+    let peel_error = reference
+        .peel_to_id(&store, &objects)
+        .expect_err("the supplied object finder fails");
+    let prepare_error = store
+        .transaction()
+        .packed_refs(PackedRefs::DeletionsAndNonSymbolicUpdates(Box::new(objects)))
+        .prepare(
+            [RefEdit::update(
+                reference.name,
+                reference.target,
+                PreviousValue::Any,
+                "",
+            )],
+            Fail::Immediately,
+            Fail::Immediately,
+        )
+        .expect_err("the supplied object finder also fails while preparing packed refs");
+    Ok([peel_error, prepare_error])
+}
+
+#[test]
+fn malformed_tags_are_corruption_instead_of_missing_objects() -> Result {
+    struct MalformedTag;
+    impl gix_object::Find for MalformedTag {
+        fn try_find<'a>(
+            &self,
+            object_id: &gix_hash::oid,
+            _buffer: &'a mut Vec<u8>,
+        ) -> ExnResult<Option<gix_object::Data<'a>>> {
+            Ok(Some(gix_object::Data {
+                kind: gix_object::Kind::Tag,
+                object_hash: object_id.kind(),
+                data: b"object invalid\n",
+            }))
+        }
+    }
+
+    let store = crate::file::store_at("make_ref_repository.sh")?;
+    let err = Error::from(
+        store
+            .find("main")?
+            .peel_to_id(&store, &MalformedTag)
+            .expect_err("the tag target cannot be decoded"),
+    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "malformed stored tag data is corruption", @r#"
+    Could not decode tag Oid(1) as referred to by "refs/heads/main"
+    |
+    └─ object parsing failed
+    "#);
+    assert!(err.is_corrupted(), "malformed stored tag data is corruption");
+    assert!(
+        !err.is_not_found(),
+        "the malformed tag was found in the object database"
+    );
+    assert!(err.is_validation(), "the tag parser's original error remains available");
+    Ok(())
+}
+
+#[test]
+fn malformed_reference_data_is_classified() -> Result {
+    let mut error_snapshots = Vec::new();
+    let store = crate::file::store_at("make_ref_repository.sh")?;
+    let hash = crate::fixture_hash_kind();
+    let packed = packed::Buffer::from_bytes(
+        b"# pack-refs with: peeled fully-peeled sorted\nbogus refs/heads/main\n",
+        hash,
+    )?;
+    for err in [
+        Error::from(
+            gix_ref::file::loose::Reference::try_from_path("HEAD".try_into()?, b"invalid", hash)
+                .expect_err("the loose ref is malformed"),
+        ),
+        Error::from(packed::Buffer::from_bytes(b"# invalid\n", hash).expect_err("the header is malformed")),
+        Error::from(packed.find("main").expect_err("the packed ref is malformed")),
+        Error::from(
+            packed
+                .iter()?
+                .next()
+                .expect("one packed ref")
+                .expect_err("the ref is malformed"),
+        ),
+        Error::from(
+            store
+                .iter_packed(Some(&packed))?
+                .find_map(std::result::Result::err)
+                .expect("the overlay encounters the malformed packed ref"),
+        ),
+        Error::from(
+            store
+                .find("loop-a")?
+                .peel_to_id(&store, &gix_object::find::Never)
+                .expect_err("the symbolic refs form a cycle"),
+        ),
+        Error::from(gix_ref::file::log::LineRef::from_bytes(b"invalid").expect_err("the reflog line is malformed")),
+        Error::from(
+            gix_ref::file::log::iter::forward(b"invalid\n")
+                .next()
+                .expect("one reflog line")
+                .expect_err("the reflog line is malformed"),
+        ),
+    ] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(err),
+            &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")],
+        ));
+        assert!(err.is_corrupted(), "malformed stored data is classified: {err}");
+        assert!(!err.is_not_found(), "malformed stored data is present");
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "malformed reference data is classified", @r#"
+    [
+        Reference content could not be parsed, "input"="invalid",
+        The header could not be parsed, even though first line started with '#',
+        Could not decode packed reference, "name"="refs/main"
+        |
+        └─ Malformed packed reference record,
+        Invalid packed reference, "input"="bogus refs/heads/main", "line"=1
+        |
+        └─ Malformed packed reference,
+        Invalid packed reference, "input"="bogus refs/heads/main", "line"=1
+        |
+        └─ Malformed packed reference,
+        Aborting symbolic reference cycle, "path"="<git-dir>/refs/loop-a",
+        Could not decode reflog line, "input"="invalid"
+        |
+        └─ Malformed reflog line,
+        Invalid reflog entry, "from_end"=false, "line"=1
+        |
+        └─ Could not decode reflog line, "input"="invalid"
+        |
+        └─ Malformed reflog line,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn missing_transaction_targets_are_classified() -> Result {
+    let mut error_snapshots = Vec::new();
+    use gix_lock::acquire::Fail;
+    use gix_ref::transaction::RefEdit;
+
+    let (_keep, store) = crate::file::transaction::prepare_and_commit::empty_store()?;
+    for edit in [
+        RefEdit::delete("refs/heads/missing".try_into()?, PreviousValue::MustExist),
+        RefEdit::update(
+            "refs/heads/missing".try_into()?,
+            gix_ref::Target::Object(crate::fixture_hash_kind().null()),
+            PreviousValue::MustExist,
+            "update",
+        ),
+    ] {
+        let err = Error::from(
+            store
+                .transaction()
+                .prepare([edit], Fail::Immediately, Fail::Immediately)
+                .expect_err("the edit requires an existing reference"),
+        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_not_found(), "updates and deletions classify missing refs: {err}");
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "missing transaction targets are classified", @r#"
+    [
+        Could not prepare reference edit, "reference"="refs/heads/missing", "referent"="refs/heads/missing"
+        |
+        └─ The reference to delete must exist,
+        Could not prepare reference edit, "reference"="refs/heads/missing", "referent"="refs/heads/missing"
+        |
+        └─ The reference to update must exist,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn invalid_reflog_input_is_classified() -> Result {
+    let mut error_snapshots = Vec::new();
+    use crate::file::transaction::prepare_and_commit::{committer, create_at, empty_store};
+    use gix_lock::acquire::Fail;
+
+    let (_keep, store) = empty_store()?;
+    let line = gix_ref::log::Line {
+        previous_oid: crate::fixture_hash_kind().null(),
+        new_oid: crate::fixture_hash_kind().null(),
+        signature: committer(),
+        message: "invalid\nmessage".into(),
+    };
+    let missing_committer = store
+        .transaction()
+        .prepare([create_at("refs/heads/new")], Fail::Immediately, Fail::Immediately)?
+        .commit(None)
+        .expect_err("writing a reflog requires a committer");
+    assert!(
+        missing_committer.is_validation(),
+        "a missing reflog identity is invalid input"
+    );
+    assert!(
+        missing_committer
+            .probable_cause()
+            .is::<gix_ref::file::log::create_or_update::MissingCommitter>(),
+        "the missing committer, not its classification marker, is the probable cause"
+    );
+    assert!(
+        missing_committer
+            .downcast_any_ref::<gix_ref::file::log::create_or_update::MissingCommitter>()
+            .is_some(),
+        "callers can request an identity without parsing the diagnostic message"
+    );
+    for err in [
+        Error::from_error(line.write_to(&mut Vec::new()).expect_err("newlines are forbidden")),
+        missing_committer.into_error(),
+    ] {
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_validation(), "invalid reflog input is classified: {err}");
+        assert!(!err.is_corrupted(), "invalid input does not imply corrupt stored data");
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid reflog input is classified", @r#"
+    [
+        Custom {
+            kind: Other,
+            error: Messages must not contain newlines (\n),
+        },
+        Could not update reflog, "reference"="refs/heads/new"
+        |
+        └─ reflog messages need a committer which isn't set,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn malformed_packed_names_and_reflog_signatures_retain_parser_errors() -> Result {
+    let hash = crate::fixture_hash_kind();
+    let packed = packed::Buffer::from_bytes(
+        format!("# pack-refs with: sorted\n{} refs/heads/bad..name\n", hash.null()).as_bytes(),
+        hash,
+    )?;
+    let err = Error::from(
+        packed
+            .iter()?
+            .next()
+            .expect("one packed ref")
+            .expect_err("the name is invalid"),
+    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "malformed packed names and reflog signatures retain parser errors", @r#"
+    Invalid packed reference, "input"="Oid(1) refs/heads/bad..name", "line"=1
+    |
+    └─ Malformed packed reference
+    |
+    └─ Reference name cannot contain repeated dots
+    "#);
+    assert!(err.is_corrupted());
+    assert!(
+        err.downcast_any_ref::<gix_ref::name::Error>().is_some(),
+        "packed iteration retains the name validator's error"
+    );
+
+    let line = format!("{0} {0} invalid signature\tmessage", hash.null());
+    let err =
+        Error::from(gix_ref::file::log::LineRef::from_bytes(line.as_bytes()).expect_err("the signature is invalid"));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "malformed packed names and reflog signatures retain parser errors", @r#"
+    Could not decode reflog line, "input"="Oid(1) Oid(1) invalid signature\tmessage"
+    |
+    └─ Invalid reflog signature
+    |
+    └─ Closing '>' not found
+    "#);
+    assert!(err.is_corrupted());
+    assert!(
+        err.is_validation(),
+        "reflog decoding retains the signature validator's error"
+    );
+    Ok(())
+}
+
+#[test]
+fn custom_name_conversion_errors_keep_their_sources() -> Result {
+    let mut error_snapshots = Vec::new();
+    struct Name<E>(E);
+    impl<E> TryInto<&'static gix_ref::PartialNameRef> for Name<E> {
+        type Error = E;
+        fn try_into(self) -> std::result::Result<&'static gix_ref::PartialNameRef, E> {
+            Err(self.0)
+        }
+    }
+    #[derive(Debug)]
+    struct Custom(std::io::Error);
+    impl std::fmt::Display for Custom {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str("custom name conversion")
+        }
+    }
+    impl std::error::Error for Custom {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(&self.0)
+        }
+    }
+    let store = crate::file::store_at("make_ref_repository.sh")?;
+    for kind in [std::io::ErrorKind::TimedOut, std::io::ErrorKind::NotFound] {
+        for err in [
+            store.try_find(Name(Custom(kind.into()))).expect_err("conversion fails"),
+            store
+                .try_find(Name(Custom(kind.into()).raise()))
+                .expect_err("conversion fails"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.downcast_any_ref::<Custom>().is_some(), "custom type is preserved");
+            assert_eq!(err.can_retry(), kind == std::io::ErrorKind::TimedOut);
+            assert_eq!(err.is_not_found(), kind == std::io::ErrorKind::NotFound);
+        }
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "custom name conversion errors keep their sources", @"
+    [
+        The ref name or path is not a valid ref name
+        |
+        └─ custom name conversion
+        |
+        └─ timed out,
+        The ref name or path is not a valid ref name
+        |
+        └─ custom name conversion
+        |
+        └─ timed out,
+        The ref name or path is not a valid ref name
+        |
+        └─ custom name conversion
+        |
+        └─ entity not found,
+        The ref name or path is not a valid ref name
+        |
+        └─ custom name conversion
+        |
+        └─ entity not found,
+    ]
+    ");
+    Ok(())
+}
+
+#[test]
+fn a_depth_limit_does_not_imply_corruption() -> Result {
+    let (_keep, store) = crate::file::transaction::prepare_and_commit::empty_store()?;
+    let refs = store.git_dir().join("refs/heads");
+    std::fs::create_dir_all(&refs)?;
+    for index in 0..6 {
+        std::fs::write(
+            refs.join(format!("r{index}")),
+            if index == 5 {
+                format!("{}\n", crate::fixture_hash_kind().null())
+            } else {
+                format!("ref: refs/heads/r{}\n", index + 1)
+            },
+        )?;
+    }
+    let err = store
+        .find("r0")?
+        .follow_to_object_packed(&store, None)
+        .expect_err("the valid symbolic chain exceeds the depth limit")
+        .into_error();
+    insta::assert_debug_snapshot!(err, "a valid symbolic chain need not be corrupted", @r#"Symbolic reference depth limit exceeded, "max_depth"=5"#);
+    assert!(!err.is_corrupted(), "a valid symbolic chain need not be corrupted");
+    assert!(!err.is_not_found(), "all symbolic targets exist");
+    let details = err.metadata().next().expect("limit details");
+    assert_eq!(
+        err.downcast_any_ref::<Message>().expect("limit diagnostic").class,
+        None,
+        "the depth limit remains unclassified"
+    );
+    assert!(
+        err.classify().next().is_none(),
+        "no classification is added through a cause"
+    );
+    assert_eq!(
+        details["max_depth"],
+        MetadataValue::from(5_usize),
+        "the configured depth limit is retained"
+    );
+    Ok(())
+}
+
+#[test]
+fn loose_reference_diagnostics_keep_input_with_the_failure() -> Result {
+    let hash = crate::fixture_hash_kind();
+    let contents = b"invalid\xff";
+    let err = gix_ref::file::loose::Reference::try_from_path("HEAD".try_into()?, contents, hash)
+        .expect_err("a malformed object id is corruption");
+    insta::assert_debug_snapshot!(err, "scalar context does not invent a validation failure", @r#"Reference content could not be parsed, "input"="invalid\xff""#);
+    assert!(
+        err.is_corrupted() && !err.is_validation(),
+        "scalar context does not invent a validation failure"
+    );
+    assert_eq!(
+        err.iter_errors().count(),
+        1,
+        "the syntax failure and its input form one diagnostic"
+    );
+    assert_eq!(
+        err.metadata().next().expect("reference input")["input"],
+        gix_error::MetadataValue::from(contents.as_slice()),
+        "non-UTF8 reference contents remain bytes"
+    );
+
+    let err = gix_ref::file::loose::Reference::try_from_path("HEAD".try_into()?, b"ref: refs/heads/.bad\n", hash)
+        .expect_err("a symbolic target must be a valid reference name");
+    insta::assert_debug_snapshot!(err, "the callee's validation class remains available", @r#"
+    Could not decode reference, "input"="ref: refs/heads/.bad\n"
+    |
+    └─ Invalid symbolic reference target, "target"="refs/heads/.bad"
+    |
+    └─ Reference name cannot start with a dot
+    "#);
+    assert!(err.is_validation(), "the callee's validation class remains available");
+    assert!(
+        err.downcast_any_ref::<gix_validate::reference::name::Error>().is_some(),
+        "the real symbolic-target validator remains a cause"
+    );
+    assert_eq!(
+        err.metadata().next().expect("reference input")["input"],
+        gix_error::MetadataValue::from(b"ref: refs/heads/.bad\n".as_slice()),
+        "symbolic-target context retains the complete contents"
+    );
+    Ok(())
+}
diff --git a/gix-ref/tests/refs/file/log.rs b/gix-ref/tests/refs/file/log.rs
index da170882f88..613d18488d8 100644
--- a/gix-ref/tests/refs/file/log.rs
+++ b/gix-ref/tests/refs/file/log.rs
@@ -1,22 +1,28 @@
 mod line {
     mod write_to {
+        use crate::Result;
         use gix_object::bstr::ByteVec;
         use gix_ref::file::log;
 
         #[test]
-        fn newlines_in_message_of_the_input_fails_and_we_trust_signature_writing_validation() -> crate::Result {
+        fn newlines_in_message_of_the_input_fails_and_we_trust_signature_writing_validation() -> Result {
             let line = "0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c1";
             let mut line = log::LineRef::from_bytes(line.as_bytes())?.to_owned();
             line.message.push_str("and here come\nthe newline");
             let err = line
                 .write_to(&mut Vec::new())
                 .expect_err("newlines in messages are caught");
-            assert!(err.to_string().contains("newline"));
+            insta::assert_debug_snapshot!(err, "newlines in message of the input fails and we trust signature writing validation", @r"
+            Custom {
+                kind: Other,
+                error: Messages must not contain newlines (\n),
+            }
+            ");
             Ok(())
         }
 
         #[test]
-        fn round_trips() -> crate::Result {
+        fn round_trips() -> Result {
             let lines = &[
                 "0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c1\n",
                 "0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	\n",
@@ -33,10 +39,11 @@ mod line {
     }
 
     mod parse {
+        use crate::Result;
         use gix_ref::file::log;
 
         #[test]
-        fn angle_bracket_in_comment() -> crate::Result {
+        fn angle_bracket_in_comment() -> Result {
             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");
@@ -51,14 +58,15 @@ mod line {
 }
 
 mod iter {
+    use crate::Result;
     use std::path::PathBuf;
 
-    fn reflog_dir() -> crate::Result<PathBuf> {
+    fn reflog_dir() -> Result<PathBuf> {
         Ok(crate::scripted_fixture_read_only("make_repo_for_reflog.sh")?
             .join(".git")
             .join("logs"))
     }
-    fn reflog(name: &str) -> crate::Result<Vec<u8>> {
+    fn reflog(name: &str) -> Result<Vec<u8>> {
         Ok(std::fs::read(reflog_dir()?.join(name))?)
     }
 
@@ -77,10 +85,11 @@ mod iter {
         }
 
         mod with_buffer_too_small_for_single_line {
-            use std::error::Error;
+            use crate::Result;
 
             #[test]
-            fn single_line() -> crate::Result {
+            fn single_line() -> Result {
+                let mut error_snapshots = Vec::new();
                 let mut buf = [0u8; 128];
                 let two_lines: Vec<u8> = b"0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c1".to_vec();
                 let two_lines_trailing_nl = {
@@ -91,28 +100,41 @@ mod iter {
                 for line in &[two_lines, two_lines_trailing_nl] {
                     let read = std::io::Cursor::new(line);
                     let mut iter = gix_ref::file::log::iter::reverse(read, &mut buf)?;
-                    assert_eq!(
-                        iter.next()
+                    error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                        &(iter
+                            .next()
                             .expect("an error")
                             .expect_err("buffer too small")
-                            .source()
-                            .expect("source")
-                            .to_string(),
-                        r#"buffer too small for line size, got until "0000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000\tcommit (initial): c1""#
-                    );
+                            .downcast_any_ref::<std::io::Error>()
+                            .expect("original I/O failure")),
+                        &[],
+                    ));
                     assert!(iter.next().is_none(), "iterator depleted");
                 }
+                insta::assert_debug_snapshot!(error_snapshots, "single line", @r#"
+                [
+                    Custom {
+                        kind: Other,
+                        error: "buffer too small for line size, got until \"0000000000000000 Oid(1) committer <committer@example.com> 946771200 +0000\\tcommit (initial): c1\"",
+                    },
+                    Custom {
+                        kind: Other,
+                        error: "buffer too small for line size, got until \"0000000000000000 Oid(1) committer <committer@example.com> 946771200 +0000\\tcommit (initial): c1\"",
+                    },
+                ]
+                "#);
                 Ok(())
             }
         }
 
         mod with_buffer_big_enough_for_largest_line {
+            use crate::Result;
             use gix_ref::log::Line;
 
             use crate::file::log::iter::reflog;
 
             #[test]
-            fn single_line() -> crate::Result {
+            fn single_line() -> Result {
                 let mut buf = [0u8; 1024];
                 let two_lines: Vec<u8> = b"0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c1".to_vec();
                 let two_lines_trailing_nl = {
@@ -138,7 +160,7 @@ mod iter {
             }
 
             #[test]
-            fn two_lines() -> crate::Result {
+            fn two_lines() -> Result {
                 let two_lines: Vec<u8> = b"1000000000000000000000000000000000000000 234385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c2\n0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000	commit (initial): c1".to_vec();
                 let two_lines_trailing_nl = {
                     let mut l = two_lines.clone();
@@ -176,14 +198,14 @@ mod iter {
             }
 
             #[test]
-            fn realistic_logs_can_be_read_completely() -> crate::Result {
+            fn realistic_logs_can_be_read_completely() -> Result {
                 let log = reflog("refs/heads/old")?;
                 let mut buf = Vec::with_capacity(16 * 1024);
                 for size in [2048, 3000, 4096, 8192, 16384] {
                     buf.resize(size, 0);
                     let read = std::io::Cursor::new(&*log);
                     let count = gix_ref::file::log::iter::reverse(read, &mut buf)?
-                        .filter_map(Result::ok)
+                        .filter_map(std::result::Result::ok)
                         .count();
                     assert_eq!(
                         count, 581,
@@ -195,12 +217,13 @@ mod iter {
         }
     }
     mod forward {
+        use crate::Result;
         use gix_object::bstr::B;
 
         use crate::{file::log::iter::reflog, hex_to_id};
 
         #[test]
-        fn all_success() -> crate::Result {
+        fn all_success() -> Result {
             let log = reflog("HEAD")?;
             let iter = gix_ref::file::log::iter::forward(&log);
             assert_eq!(iter.count(), 5, "the log as a known amount of entries");
@@ -221,9 +244,21 @@ mod iter {
 
             let mut iter = gix_ref::file::log::iter::forward(log_first_broken.as_bytes());
             let err = iter.next().expect("error is not none").expect_err("the line is broken");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "a single failure does not abort iteration", @r#"
+            Invalid reflog entry, "from_end"=false, "line"=1
+            |
+            └─ Could not decode reflog line, "input"="Oid(1) 134385fbroken7062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000\tcommit"
+            |
+            └─ Malformed reflog line
+            "#);
+            assert!(err.is_corrupted());
+            let mut details = err.metadata();
+            let position = details.next().expect("line position");
+            assert_eq!(position["line"], gix_error::MetadataValue::from(1_u64));
+            assert_eq!(position["from_end"], gix_error::MetadataValue::from(false));
             assert_eq!(
-                err.to_string(),
-                r#"In line 1: "0000000000000000000000000000000000000000 134385fbroken7062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000\tcommit" did not match '<old-hexsha> <new-hexsha> <name> <<email>> <timestamp> <tz>\t<message>'"#
+                details.next().expect("decoder input")["input"],
+                gix_error::MetadataValue::from(log_first_broken.lines().next().expect("first line").as_bytes())
             );
             assert!(iter.next().expect("a second line").is_ok(), "line parses ok");
             assert!(iter.next().is_none(), "iterator exhausted");
diff --git a/gix-ref/tests/refs/file/mod.rs b/gix-ref/tests/refs/file/mod.rs
index 0ddaf38e4d6..067c53848b0 100644
--- a/gix-ref/tests/refs/file/mod.rs
+++ b/gix-ref/tests/refs/file/mod.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+use gix_error::ExnResult;
 use gix_ref::file;
 
 // TODO: when ready, add a new test entry point with a feature toggle to switch this to `gix_ref::Store`.
@@ -5,29 +7,29 @@ use gix_ref::file;
 //       The same can be done when RefTable is available, and its corresponding tests.
 pub type Store = file::Store;
 
-fn store() -> crate::Result<Store> {
+fn store() -> Result<Store> {
     store_at("make_ref_repository.sh")
 }
 
-pub fn store_with_packed_refs() -> crate::Result<Store> {
+pub fn store_with_packed_refs() -> Result<Store> {
     store_at("make_packed_ref_repository.sh")
 }
 
-pub fn store_at(name: &str) -> crate::Result<Store> {
+pub fn store_at(name: &str) -> Result<Store> {
     named_store_at(name, "")
 }
 
-pub fn named_store_at(script_name: &str, name: &str) -> crate::Result<Store> {
+pub fn named_store_at(script_name: &str, name: &str) -> Result<Store> {
     let path = crate::scripted_fixture_read_only(script_name)?;
     Ok(Store::at(path.join(name).join(".git"), crate::fixture_hash_kind()))
 }
 
-pub fn store_at_with_args(name: &str, args: impl IntoIterator<Item = impl Into<String>>) -> crate::Result<Store> {
+pub fn store_at_with_args(name: &str, args: impl IntoIterator<Item = impl Into<String>>) -> Result<Store> {
     let path = crate::scripted_fixture_read_only_with_args(name, args)?;
     Ok(Store::at(path.join(".git"), crate::fixture_hash_kind()))
 }
 
-fn store_writable(name: &str) -> crate::Result<(gix_testtools::tempfile::TempDir, Store)> {
+fn store_writable(name: &str) -> Result<(gix_testtools::tempfile::TempDir, Store)> {
     let dir = crate::scripted_fixture_writable(name)?;
     let git_dir = dir.path().join(".git");
     Ok((dir, Store::at(git_dir, crate::fixture_hash_kind())))
@@ -39,11 +41,7 @@ pub fn odb_at(objects_dir: impl Into<std::path::PathBuf>) -> std::io::Result<gix
 
 struct EmptyCommit;
 impl gix_object::Find for EmptyCommit {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        _buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, _buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         Ok(Some(gix_object::Data {
             kind: gix_object::Kind::Commit,
             object_hash: id.kind(),
diff --git a/gix-ref/tests/refs/file/reference.rs b/gix-ref/tests/refs/file/reference.rs
index d5892c2bb3d..647c916d4a5 100644
--- a/gix-ref/tests/refs/file/reference.rs
+++ b/gix-ref/tests/refs/file/reference.rs
@@ -1,11 +1,12 @@
 mod reflog {
     mod packed {
+        use crate::Result;
         use gix_ref::file::ReferenceExt;
 
         use crate::file;
 
         #[test]
-        fn iter() -> crate::Result {
+        fn iter() -> Result {
             let store = file::store_with_packed_refs()?;
             let r = store.find("main")?;
             assert_eq!(r.log_iter(&store).all()?.expect("log exists").count(), 1);
@@ -14,7 +15,7 @@ mod reflog {
         }
 
         #[test]
-        fn iter_rev() -> crate::Result {
+        fn iter_rev() -> Result {
             let store = file::store_with_packed_refs()?;
             let r = store.find("main")?;
             assert_eq!(r.log_iter(&store).rev()?.expect("log exists").count(), 1);
@@ -23,10 +24,11 @@ mod reflog {
     }
 
     mod loose {
+        use crate::Result;
         use crate::file;
 
         #[test]
-        fn iter() -> crate::Result {
+        fn iter() -> Result {
             let store = file::store()?;
             let r = store.find_loose("HEAD")?;
             let mut buf = Vec::new();
@@ -36,7 +38,7 @@ mod reflog {
         }
 
         #[test]
-        fn iter_rev() -> crate::Result {
+        fn iter_rev() -> Result {
             let store = file::store()?;
             let r = store.find_loose("HEAD")?;
             let mut buf = [0u8; 256];
@@ -47,6 +49,7 @@ mod reflog {
 }
 
 mod peel {
+    use crate::Result;
     use gix_object::FindExt;
     use gix_ref::{Reference, file::ReferenceExt};
 
@@ -57,7 +60,7 @@ mod peel {
     };
 
     #[test]
-    fn one_level() -> crate::Result {
+    fn one_level() -> Result {
         let store = file::store()?;
         let r = store.find_loose("HEAD")?;
         assert_eq!(r.kind(), gix_ref::Kind::Symbolic, "there is something to peel");
@@ -77,7 +80,7 @@ mod peel {
     }
 
     #[test]
-    fn peel_with_packed_involvement() -> crate::Result {
+    fn peel_with_packed_involvement() -> Result {
         let store = store_with_packed_refs()?;
         let mut head: Reference = store.find_loose("HEAD")?.into();
         let expected = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
@@ -91,7 +94,7 @@ mod peel {
     }
 
     #[test]
-    fn peel_one_level_with_pack() -> crate::Result {
+    fn peel_one_level_with_pack() -> Result {
         let store = store_with_packed_refs()?;
 
         let mut head = store.find("dt1")?;
@@ -129,7 +132,7 @@ mod peel {
     }
 
     #[test]
-    fn to_id_multi_hop() -> crate::Result {
+    fn to_id_multi_hop() -> Result {
         let store = file::store()?;
         let mut r: Reference = store.find_loose("multi-link")?.into();
         assert_eq!(r.kind(), gix_ref::Kind::Symbolic, "there is something to peel");
@@ -153,7 +156,7 @@ mod peel {
     }
 
     #[test]
-    fn to_id_long_jump() -> crate::Result {
+    fn to_id_long_jump() -> Result {
         for packed in [None, Some("packed")] {
             let store = file::store_at_with_args("make_multi_hop_ref.sh", packed)?;
             let odb = crate::file::odb_at(store.git_dir().join("objects"))?;
@@ -185,23 +188,41 @@ mod peel {
     }
 
     #[test]
-    fn to_id_cycle() -> crate::Result {
+    fn to_id_cycle() -> Result {
         let store = file::store()?;
         let mut r: Reference = store.find_loose("loop-a")?.into();
         assert_eq!(r.kind(), gix_ref::Kind::Symbolic, "there is something to peel");
         assert_eq!(r, "refs/loop-a");
 
-        assert!(matches!(
-            r.peel_to_id(&store, &gix_object::find::Never).unwrap_err(),
-            gix_ref::peel::to_id::Error::FollowToObject(gix_ref::peel::to_object::Error::Cycle { .. })
-        ));
+        let err = r.peel_to_id(&store, &gix_object::find::Never).expect_err("cyclic refs");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")]), "a symbolic cycle is corruption", @r#"Aborting symbolic reference cycle, "path"="<git-dir>/refs/loop-a""#);
+        assert!(err.is_corrupted(), "a symbolic cycle is corruption");
+        assert_eq!(err.iter_errors().count(), 1, "a cycle does not need a synthetic cause");
+        let details = err.metadata().next().expect("cycle details");
+        assert_eq!(
+            err.downcast_any_ref::<gix_error::Message>()
+                .expect("cycle diagnostic")
+                .class,
+            Some(gix_error::Class::Corruption),
+            "the diagnostic itself classifies the cycle"
+        );
+        assert_eq!(
+            details["path"],
+            gix_error::MetadataValue::from(store.git_dir().join("refs/loop-a")),
+            "the path that closes the cycle remains available"
+        );
+        assert!(
+            err.probable_cause().is::<gix_error::Message>(),
+            "the cycle diagnostic itself is the probable cause"
+        );
         assert_eq!(r, "refs/loop-a", "the ref is not changed on error");
 
         let mut r: Reference = store.find_loose("loop-a")?.into();
         let err = r
             .follow_to_object_packed(&store, store.cached_packed_buffer()?.as_ref().map(|p| &***p))
-            .unwrap_err();
-        assert!(matches!(err, gix_ref::peel::to_object::Error::Cycle { .. }));
+            .expect_err("the symbolic references form a cycle");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")]), "following also reports the cycle", @r#"Aborting symbolic reference cycle, "path"="<git-dir>/refs/loop-a""#);
+        assert!(err.is_corrupted(), "following also reports the cycle");
         Ok(())
     }
 }
@@ -222,16 +243,21 @@ mod parse {
                     )
                     .expect_err("the loose reference content is invalid or unsupported");
                     assert_eq!(
-                        err.to_string(),
-                        $err,
-                        "the error identifies why decoding failed"
+                        err.metadata().next().expect("decode context")["input"],
+                        gix_error::MetadataValue::from($input.as_slice()),
+                        "the original contents remain available"
+                    );
+                    assert!(
+                        err.iter_errors()
+                            .any(|cause| cause.to_string().contains($err)),
+                        "the error identifies why decoding failed: {err}"
                     );
                 }
             };
         }
 
-        mktest!(hex_id, b"foobar", "\"foobar\" could not be parsed");
-        mktest!(ref_tag, b"reff: hello", "\"reff: hello\" could not be parsed");
+        mktest!(hex_id, b"foobar", "Reference content could not be parsed");
+        mktest!(ref_tag, b"reff: hello", "Reference content could not be parsed");
         mktest!(
             reftable_placeholder,
             b"ref: refs/heads/.invalid\n",
@@ -240,17 +266,17 @@ mod parse {
         mktest!(
             other_invalid_symbolic_target,
             b"ref: refs/heads/.invalid-other\n",
-            "The path \"refs/heads/.invalid-other\" to a symbolic reference within a ref file is invalid"
+            "Invalid symbolic reference target"
         );
         mktest!(
             sha256_sized_id_for_sha1,
             b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
-            "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\n\" could not be parsed"
+            "Reference content could not be parsed"
         );
         mktest!(
             trailing_garbage_after_id,
             b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaextra",
-            "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaextra\" could not be parsed"
+            "Reference content could not be parsed"
         );
     }
     mod valid {
diff --git a/gix-ref/tests/refs/file/store/access.rs b/gix-ref/tests/refs/file/store/access.rs
index b7d4097d797..529e88fbc79 100644
--- a/gix-ref/tests/refs/file/store/access.rs
+++ b/gix-ref/tests/refs/file/store/access.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use crate::file::{named_store_at, store};
 
 #[test]
-fn set_packed_buffer_mmap_threshold() -> crate::Result {
+fn set_packed_buffer_mmap_threshold() -> Result {
     let mut store = store()?;
     let prev = store.set_packed_buffer_mmap_threshold(0);
     if cfg!(windows) {
@@ -22,7 +23,7 @@ fn set_packed_buffer_mmap_threshold() -> crate::Result {
 }
 
 #[test]
-fn is_pristine() -> crate::Result {
+fn is_pristine() -> Result {
     let store = named_store_at("make_pristine.sh", "untouched")?;
     assert_eq!(store.is_pristine("refs/heads/main".try_into()?), Some(true));
     assert_eq!(store.is_pristine("refs/heads/other".try_into()?), Some(false));
diff --git a/gix-ref/tests/refs/file/store/find.rs b/gix-ref/tests/refs/file/store/find.rs
index bc246b8b2ae..14e50af2dd7 100644
--- a/gix-ref/tests/refs/file/store/find.rs
+++ b/gix-ref/tests/refs/file/store/find.rs
@@ -1,8 +1,9 @@
 mod existing {
+    use crate::Result;
     use crate::{file::store_at, hex_to_id};
 
     #[test]
-    fn various_repositories() -> crate::Result {
+    fn various_repositories() -> Result {
         for fixture in [
             "make_ref_repository.sh",
             "make_packed_ref_repository.sh",
@@ -23,11 +24,12 @@ mod existing {
     }
 
     mod convert {
+        use crate::Result;
         use gix_ref::{PartialName, PartialNameRef};
 
         // TODO: figure this out
         #[test]
-        fn possible_inputs() -> crate::Result {
+        fn possible_inputs() -> Result {
             let store = crate::file::store()?;
             store.find_loose("dt1")?;
             store.find_loose(&String::from("dt1"))?; // Owned Strings don't have an impl for PartialName
@@ -62,7 +64,7 @@ mod existing {
         impl<'a> TryFrom<&'a CustomType> for &'a PartialNameRef {
             type Error = gix_ref::name::Error;
 
-            fn try_from(value: &'a CustomType) -> Result<Self, Self::Error> {
+            fn try_from(value: &'a CustomType) -> std::result::Result<Self, Self::Error> {
                 value.0.as_str().try_into()
             }
         }
@@ -94,7 +96,7 @@ mod existing {
         impl<'a> TryFrom<&'a CustomName> for PartialName {
             type Error = gix_ref::name::Error;
 
-            fn try_from(value: &'a CustomName) -> Result<Self, Self::Error> {
+            fn try_from(value: &'a CustomName) -> std::result::Result<Self, Self::Error> {
                 PartialName::try_from(value.to_partial_name())
             }
         }
@@ -102,15 +104,17 @@ mod existing {
 }
 
 mod loose {
+    use crate::Result;
     use crate::{file::store, hex_to_id};
 
     mod existing {
+        use crate::Result;
         use std::path::Path;
 
         use crate::file::store;
 
         #[test]
-        fn capitalized_branch() -> crate::Result {
+        fn capitalized_branch() -> Result {
             let store = store()?;
             assert_eq!(
                 store.find("A")?,
@@ -121,7 +125,8 @@ mod loose {
         }
 
         #[test]
-        fn success_and_failure() -> crate::Result {
+        fn success_and_failure() -> Result {
+            let mut error_snapshots = Vec::new();
             let store = store()?;
             for (partial_name, expected_path) in [("main", Some("refs/heads/main")), ("does-not-exist", None)] {
                 let reference = store.find_loose(partial_name);
@@ -129,19 +134,29 @@ mod loose {
                     Some(expected_path) => assert_eq!(reference?, expected_path),
                     None => match reference {
                         Ok(_) => panic!("Expected error"),
-                        Err(gix_ref::file::find::existing::Error::NotFound { name }) => {
-                            assert_eq!(name, Path::new(partial_name));
+                        Err(err) => {
+                            error_snapshots.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+                            assert_eq!(
+                                err.downcast_any_ref::<gix_ref::file::find::NotFound>()
+                                    .expect("absent reference")
+                                    .name,
+                                Path::new(partial_name)
+                            );
                         }
-                        Err(err) => panic!("Unexpected err: {err:?}"),
                     },
                 }
             }
+            insta::assert_debug_snapshot!(error_snapshots, "success and failure", @r#"
+            [
+                The ref partially named "does-not-exist" could not be found,
+            ]
+            "#);
             Ok(())
         }
     }
 
     #[test]
-    fn fetch_head_can_be_parsed() -> crate::Result {
+    fn fetch_head_can_be_parsed() -> Result {
         let store = store()?;
         assert_eq!(
             store.find_loose("FETCH_HEAD")?.target.id(),
@@ -152,7 +167,7 @@ mod loose {
     }
 
     #[test]
-    fn success() -> crate::Result {
+    fn success() -> Result {
         let store = store()?;
         for (partial_name, expected_path, expected_ref_kind) in &[
             ("dt1", "refs/tags/dt1", gix_ref::Kind::Object),     // tags before heads
@@ -177,7 +192,7 @@ mod loose {
     }
 
     #[test]
-    fn failure() -> crate::Result {
+    fn failure() -> Result {
         let store = store()?;
         for (partial_name, reason, is_err) in &[
             ("foobar", "does not exist", false),
@@ -192,11 +207,48 @@ mod loose {
                 assert!(reference.is_none(), "{}", reason);
             }
         }
+
+        let mut store = store;
+        store.prohibit_windows_device_names = true;
+        let name = "refs/heads/CON";
+        let err = store
+            .try_find_loose(name)
+            .expect_err("reserved device names cannot be read when prohibited")
+            .into_error();
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")]), "rejecting a device name retains the original I/O error kind", @r#"
+        Could not read reference, "path"="<git-dir>/refs/heads/CON"
+        |
+        └─ I/O error (Other)
+        |
+        └─ Illegal use of reserved Windows device name in "refs/heads/CON"
+        "#);
+        let details = err.metadata().next().expect("reference read context");
+        assert!(
+            err.downcast_any_ref::<gix_error::Message>().is_some(),
+            "the reference read diagnostic retains its concrete type"
+        );
+        assert_eq!(details.len(), 1, "read context contains only the path");
+        assert_eq!(
+            details["path"],
+            gix_error::MetadataValue::Path(store.git_dir().join(name)),
+            "the resolved reference path remains a native path"
+        );
+        assert_eq!(
+            err.downcast_any_ref::<std::io::Error>()
+                .expect("the original read error is retained")
+                .kind(),
+            std::io::ErrorKind::Other,
+            "rejecting a device name retains the original I/O error kind"
+        );
+        assert!(
+            !err.is_corrupted(),
+            "a prohibited path does not imply corrupt ref contents"
+        );
         Ok(())
     }
 
     #[test]
-    fn prefix_file_collision_is_not_found() -> crate::Result {
+    fn prefix_file_collision_is_not_found() -> Result {
         let (_tmp, store) = crate::file::store_writable("make_ref_repository.sh")?;
 
         assert!(
diff --git a/gix-ref/tests/refs/file/store/iter.rs b/gix-ref/tests/refs/file/store/iter.rs
index 34f2061052e..a6a30727e0b 100644
--- a/gix-ref/tests/refs/file/store/iter.rs
+++ b/gix-ref/tests/refs/file/store/iter.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use crate::{
     file::{store, store_at, store_with_packed_refs},
     hex_to_id,
@@ -5,12 +6,13 @@ use crate::{
 use gix_object::bstr::ByteSlice;
 
 mod with_namespace {
+    use crate::Result;
     use gix_object::bstr::{BString, ByteSlice};
 
     use crate::file::{store_at, transaction::prepare_and_commit::empty_store};
 
     #[test]
-    fn missing_refs_dir_yields_empty_iteration() -> crate::Result {
+    fn missing_refs_dir_yields_empty_iteration() -> Result {
         let (_dir, store) = empty_store()?;
         assert_eq!(store.iter()?.all()?.count(), 0);
         assert_eq!(store.loose_iter()?.count(), 0);
@@ -18,7 +20,7 @@ mod with_namespace {
     }
 
     #[test]
-    fn iteration_can_trivially_use_namespaces_as_prefixes() -> crate::Result {
+    fn iteration_can_trivially_use_namespaces_as_prefixes() -> Result {
         let store = store_at("make_namespaced_packed_ref_repository.sh")?;
         let packed = store.open_packed_buffer()?;
 
@@ -26,7 +28,7 @@ mod with_namespace {
         let namespaced_refs = store
             .iter()?
             .prefixed(ns_two.as_bstr().try_into().unwrap())?
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .map(|r: gix_ref::Reference| r.name)
             .collect::<Vec<_>>();
         let expected_namespaced_refs = vec![
@@ -39,7 +41,7 @@ mod with_namespace {
         assert_eq!(
             store
                 .loose_iter_prefixed(ns_two.as_bstr().try_into().unwrap())?
-                .map(Result::unwrap)
+                .map(std::result::Result::unwrap)
                 .collect::<Vec<_>>(),
             [
                 "refs/namespaces/bar/refs/heads/multi-link-target1",
@@ -52,7 +54,7 @@ mod with_namespace {
                 .as_ref()
                 .expect("present")
                 .iter_prefixed(ns_two.as_bstr().to_owned())?
-                .map(Result::unwrap)
+                .map(std::result::Result::unwrap)
                 .collect::<Vec<_>>(),
             ["refs/namespaces/bar/refs/remotes/origin/multi-link-target3"]
         );
@@ -80,7 +82,7 @@ mod with_namespace {
             store
                 .iter()?
                 .prefixed(ns_one.as_bstr().try_into().unwrap())?
-                .map(Result::unwrap)
+                .map(std::result::Result::unwrap)
                 .map(|r: gix_ref::Reference| (
                     r.name.as_bstr().to_owned(),
                     r.name_without_namespace(&ns_one)
@@ -106,7 +108,7 @@ mod with_namespace {
             store
                 .iter()?
                 .all()?
-                .map(Result::unwrap)
+                .map(std::result::Result::unwrap)
                 .filter_map(
                     |r: gix_ref::Reference| if r.name.as_bstr().starts_with_str("refs/namespaces") {
                         None
@@ -128,7 +130,7 @@ mod with_namespace {
     }
 
     #[test]
-    fn iteration_on_store_with_namespace_makes_namespace_transparent() -> crate::Result {
+    fn iteration_on_store_with_namespace_makes_namespace_transparent() -> Result {
         let ns_two = gix_ref::namespace::expand("bar")?;
         let mut ns_store = {
             let mut s = store_at("make_namespaced_packed_ref_repository.sh")?;
@@ -146,7 +148,7 @@ mod with_namespace {
         let ref_names = ns_store
             .iter()?
             .all()?
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .map(|r: gix_ref::Reference| r.name)
             .collect::<Vec<_>>();
         assert_eq!(ref_names, expected_refs);
@@ -171,12 +173,20 @@ mod with_namespace {
         }
 
         assert_eq!(
-            packed.as_ref().expect("present").iter()?.map(Result::unwrap).count(),
+            packed
+                .as_ref()
+                .expect("present")
+                .iter()?
+                .map(std::result::Result::unwrap)
+                .count(),
             8,
             "packed refs have no namespace support at all"
         );
         assert_eq!(
-            ns_store.loose_iter()?.map(Result::unwrap).collect::<Vec<_>>(),
+            ns_store
+                .loose_iter()?
+                .map(std::result::Result::unwrap)
+                .collect::<Vec<_>>(),
             [
                 "refs/heads/multi-link-target1",
                 "refs/multi-link",
@@ -188,7 +198,10 @@ mod with_namespace {
         {
             let prev = ns_store.namespace.take();
             assert_eq!(
-                ns_store.loose_iter()?.map(Result::unwrap).collect::<Vec<_>>(),
+                ns_store
+                    .loose_iter()?
+                    .map(std::result::Result::unwrap)
+                    .collect::<Vec<_>>(),
                 [
                     "refs/namespaces/bar/refs/heads/multi-link-target1",
                     "refs/namespaces/bar/refs/multi-link",
@@ -204,7 +217,11 @@ mod with_namespace {
         ns_store.namespace = ns_one.into();
 
         assert_eq!(
-            ns_store.iter()?.all()?.map(Result::unwrap).collect::<Vec<_>>(),
+            ns_store
+                .iter()?
+                .all()?
+                .map(std::result::Result::unwrap)
+                .collect::<Vec<_>>(),
             vec!["refs/d1", "refs/remotes/origin/HEAD", "refs/remotes/origin/main"],
         );
         Ok(())
@@ -212,7 +229,7 @@ mod with_namespace {
 }
 
 #[test]
-fn no_packed_available_thus_no_iteration_possible() -> crate::Result {
+fn no_packed_available_thus_no_iteration_possible() -> Result {
     let store_without_packed = store()?;
     assert!(
         store_without_packed.open_packed_buffer()?.is_none(),
@@ -222,48 +239,48 @@ fn no_packed_available_thus_no_iteration_possible() -> crate::Result {
 }
 
 #[test]
-fn packed_file_iter() -> crate::Result {
+fn packed_file_iter() -> Result {
     let store = store_with_packed_refs()?;
     assert_eq!(store.open_packed_buffer()?.expect("pack available").iter()?.count(), 11);
     Ok(())
 }
 
 #[test]
-fn pseudo_refs_iter() -> crate::Result {
+fn pseudo_refs_iter() -> Result {
     let store = store_at("make_pseudo_ref_repository.sh")?;
 
-    let actual = store.iter_pseudo()?.map(Result::unwrap).collect::<Vec<_>>();
+    let actual = store
+        .iter_pseudo()?
+        .map(std::result::Result::unwrap)
+        .collect::<Vec<_>>();
 
     assert_eq!(actual, ["FETCH_HEAD", "HEAD", "JIRI_HEAD"]);
     Ok(())
 }
 
 #[test]
-fn loose_iter_with_broken_refs() -> crate::Result {
+fn loose_iter_with_broken_refs() -> Result {
     let store = store()?;
 
     let mut actual: Vec<_> = store.loose_iter()?.collect();
     assert_eq!(actual.len(), 18);
-    actual.sort_by_key(Result::is_err);
+    actual.sort_by_key(std::result::Result::is_err);
     let first_error = actual
         .iter()
         .enumerate()
         .find_map(|(idx, r)| if r.is_err() { Some(idx) } else { None })
         .expect("there is an error");
 
-    assert_eq!(
-        first_error, 17,
-        "there is exactly one invalid item, and it didn't abort the iterator most importantly"
-    );
-    #[cfg(not(windows))]
-    let msg = r#"The reference at "refs/broken" could not be instantiated"#;
-    #[cfg(windows)]
-    let msg = r#"The reference at "refs\broken" could not be instantiated"#;
-    assert_eq!(
-        actual[first_error].as_ref().expect_err("unparsable ref").to_string(),
-        msg
-    );
-    let ref_paths: Vec<_> = actual.drain(..first_error).filter_map(Result::ok).collect();
+    insta::assert_debug_snapshot!(first_error, "there is exactly one invalid item, and it didn't abort the iterator most importantly", @"17");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(actual[first_error].as_ref().expect_err("unparsable ref"), &[(r"refs\broken", "refs/broken")]), "loose iter with broken refs", @r#"
+    The reference at "refs/broken" could not be decoded
+    |
+    └─ Reference content could not be parsed, "input"="notahexsha\n"
+    "#);
+    let ref_paths: Vec<_> = actual
+        .drain(..first_error)
+        .filter_map(std::result::Result::ok)
+        .collect();
 
     assert_eq!(
         ref_paths,
@@ -295,11 +312,11 @@ fn loose_iter_with_broken_refs() -> crate::Result {
 }
 
 #[test]
-fn loose_iter_with_prefix() -> crate::Result {
+fn loose_iter_with_prefix() -> Result {
     let prefix_with_slash = b"refs/heads/";
     let actual = store()?
         .loose_iter_prefixed(prefix_with_slash.try_into().unwrap())?
-        .collect::<Result<Vec<_>, _>>()
+        .collect::<std::result::Result<Vec<_>, _>>()
         .expect("no broken ref in this subset");
 
     assert_eq!(
@@ -317,11 +334,11 @@ fn loose_iter_with_prefix() -> crate::Result {
 }
 
 #[test]
-fn loose_iter_with_partial_prefix_dir() -> crate::Result {
+fn loose_iter_with_partial_prefix_dir() -> Result {
     let prefix_without_slash = b"refs/heads";
     let actual = store()?
         .loose_iter_prefixed(prefix_without_slash.try_into().unwrap())?
-        .collect::<Result<Vec<_>, _>>()
+        .collect::<std::result::Result<Vec<_>, _>>()
         .expect("no broken ref in this subset");
 
     assert_eq!(
@@ -339,10 +356,10 @@ fn loose_iter_with_partial_prefix_dir() -> crate::Result {
 }
 
 #[test]
-fn loose_iter_with_partial_prefix() -> crate::Result {
+fn loose_iter_with_partial_prefix() -> Result {
     let actual = store()?
         .loose_iter_prefixed(b"refs/heads/d".as_bstr().try_into().unwrap())?
-        .collect::<Result<Vec<_>, _>>()
+        .collect::<std::result::Result<Vec<_>, _>>()
         .expect("no broken ref in this subset");
 
     assert_eq!(actual, ["refs/heads/d1", "refs/heads/dt1"], "all paths are as expected");
@@ -350,7 +367,7 @@ fn loose_iter_with_partial_prefix() -> crate::Result {
 }
 
 #[test]
-fn overlay_iter() -> crate::Result {
+fn overlay_iter() -> Result {
     use gix_ref::Target::*;
 
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
@@ -358,7 +375,7 @@ fn overlay_iter() -> crate::Result {
         .iter()?
         .all()?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
     let c2 = hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7");
     assert_eq!(
@@ -384,91 +401,91 @@ fn overlay_iter() -> crate::Result {
 }
 
 #[test]
-fn overlay_iter_reproduce_1850() -> crate::Result {
+fn overlay_iter_reproduce_1850() -> Result {
     let store = store_at("make_repo_for_1850_repro.sh")?;
     let ref_names = store
         .iter()?
         .all()?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     if crate::fixture_hash_kind() != gix_hash::Kind::Sha1 {
-        insta::assert_debug_snapshot!(ref_names, @r#"
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(ref_names), &[]), @r#"
         [
             (
                 "refs/heads/ig-branch-remote",
                 Object(
-                    Sha256(1111111111111111111111111111111111111111111111111111111111111111),
+                    Oid(1),
                 ),
             ),
             (
                 "refs/heads/ig-inttest",
                 Object(
-                    Sha256(2222222222222222222222222222222222222222222222222222222222222222),
+                    Oid(2),
                 ),
             ),
             (
                 "refs/heads/ig-pr4021",
                 Object(
-                    Sha256(7777777777777777777777777777777777777777777777777777777777777777),
+                    Oid(3),
                 ),
             ),
             (
                 "refs/heads/ig/aliases",
                 Object(
-                    Sha256(4444444444444444444444444444444444444444444444444444444444444444),
+                    Oid(4),
                 ),
             ),
             (
                 "refs/heads/ig/cifail",
                 Object(
-                    Sha256(5555555555555555555555555555555555555555555555555555555555555555),
+                    Oid(5),
                 ),
             ),
             (
                 "refs/heads/ig/push-name",
                 Object(
-                    Sha256(6666666666666666666666666666666666666666666666666666666666666666),
+                    Oid(6),
                 ),
             ),
         ]
         "#);
     } else {
-        insta::assert_debug_snapshot!(ref_names, @r#"
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(ref_names), &[]), @r#"
         [
             (
                 "refs/heads/ig-branch-remote",
                 Object(
-                    Sha1(17dad46c0ce3be4d4b6d45def031437ab2e40666),
+                    Oid(1),
                 ),
             ),
             (
                 "refs/heads/ig-inttest",
                 Object(
-                    Sha1(83a70366fcc1255d35a00102138293bac673b331),
+                    Oid(2),
                 ),
             ),
             (
                 "refs/heads/ig-pr4021",
                 Object(
-                    Sha1(4dec145966c546402c5a9e28b932e7c8c939e01e),
+                    Oid(3),
                 ),
             ),
             (
                 "refs/heads/ig/aliases",
                 Object(
-                    Sha1(d773228d0ee0012fcca53fffe581b0fce0b1dc56),
+                    Oid(4),
                 ),
             ),
             (
                 "refs/heads/ig/cifail",
                 Object(
-                    Sha1(ba37abe04f91fec76a6b9a817d40ee2daec47207),
+                    Oid(5),
                 ),
             ),
             (
                 "refs/heads/ig/push-name",
                 Object(
-                    Sha1(d22f46f3d7d2504d56c573b5fe54919bd16be48a),
+                    Oid(6),
                 ),
             ),
         ]
@@ -478,13 +495,13 @@ fn overlay_iter_reproduce_1850() -> crate::Result {
 }
 
 #[test]
-fn overlay_iter_reproduce_1928() -> crate::Result {
+fn overlay_iter_reproduce_1928() -> Result {
     let store = store_at("make_repo_for_1928_repro.sh")?;
     let ref_names = store
         .iter()?
         .all()?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     if crate::fixture_hash_kind() != gix_hash::Kind::Sha1 {
         assert_eq!(
             ref_names.iter().map(|(name, _)| name.to_string()).collect::<Vec<_>>(),
@@ -492,24 +509,24 @@ fn overlay_iter_reproduce_1928() -> crate::Result {
         );
         return Ok(());
     }
-    insta::assert_debug_snapshot!(ref_names, @r#"
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(ref_names), &[]), @r#"
     [
         (
             "refs/heads/a-",
             Object(
-                Sha1(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),
+                Oid(1),
             ),
         ),
         (
             "refs/heads/a/b",
             Object(
-                Sha1(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb),
+                Oid(2),
             ),
         ),
         (
             "refs/heads/a0",
             Object(
-                Sha1(cccccccccccccccccccccccccccccccccccccccc),
+                Oid(3),
             ),
         ),
     ]
@@ -518,7 +535,7 @@ fn overlay_iter_reproduce_1928() -> crate::Result {
 }
 
 #[test]
-fn overlay_prefixed_iter() -> crate::Result {
+fn overlay_prefixed_iter() -> Result {
     use gix_ref::Target::*;
 
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
@@ -526,7 +543,7 @@ fn overlay_prefixed_iter() -> crate::Result {
         .iter()?
         .prefixed(b"refs/heads/".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
     let c2 = hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7");
     assert_eq!(
@@ -541,7 +558,7 @@ fn overlay_prefixed_iter() -> crate::Result {
 }
 
 #[test]
-fn overlay_partial_prefix_iter() -> crate::Result {
+fn overlay_partial_prefix_iter() -> Result {
     use gix_ref::Target::*;
 
     let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
@@ -549,7 +566,7 @@ fn overlay_partial_prefix_iter() -> crate::Result {
         .iter()?
         .prefixed(b"refs/heads/m".try_into().unwrap())? // 'm' is partial
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
     assert_eq!(ref_names, vec![(b"refs/heads/main".as_bstr().to_owned(), Object(c1)),]);
     Ok(())
@@ -557,7 +574,7 @@ fn overlay_partial_prefix_iter() -> crate::Result {
 
 #[test]
 /// The prefix `refs/d` should match `refs/d1` but not `refs/heads/d1`.
-fn overlay_partial_prefix_iter_reproduce_1934() -> crate::Result {
+fn overlay_partial_prefix_iter_reproduce_1934() -> Result {
     use gix_ref::Target::*;
 
     let store = store_at("make_ref_repository.sh")?;
@@ -567,7 +584,7 @@ fn overlay_partial_prefix_iter_reproduce_1934() -> crate::Result {
         .iter()?
         .prefixed(b"refs/d".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     assert_eq!(
         ref_names,
         vec![("refs/d1".into(), Object(c1))],
@@ -577,7 +594,7 @@ fn overlay_partial_prefix_iter_reproduce_1934() -> crate::Result {
 }
 
 #[test]
-fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
+fn overlay_partial_prefix_iter_when_prefix_is_dir() -> Result {
     // Test 'refs/prefix/' with and without trailing slash.
     use gix_ref::Target::*;
 
@@ -589,7 +606,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
         .iter()?
         .prefixed(b"refs/prefix/feature".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     assert_eq!(
         ref_names,
         vec![
@@ -602,7 +619,7 @@ fn overlay_partial_prefix_iter_when_prefix_is_dir() -> crate::Result {
         .iter()?
         .prefixed(b"refs/prefix/feature/".try_into().unwrap())?
         .map(|r| r.map(|r| (r.name.as_bstr().to_owned(), r.target)))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
     assert_eq!(
         ref_names,
         vec![("refs/prefix/feature/sub/dir/algo".into(), Object(c1)),]
diff --git a/gix-ref/tests/refs/file/store/mod.rs b/gix-ref/tests/refs/file/store/mod.rs
index 096209080c4..953d86bf650 100644
--- a/gix-ref/tests/refs/file/store/mod.rs
+++ b/gix-ref/tests/refs/file/store/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
 use gix_ref::{
@@ -18,7 +19,7 @@ mod iter;
 mod reflog;
 
 #[test]
-fn precompose_unicode_journey() -> crate::Result {
+fn precompose_unicode_journey() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let precomposed_a = "ä";
     let decomposed_a = "a\u{308}";
diff --git a/gix-ref/tests/refs/file/store/reflog.rs b/gix-ref/tests/refs/file/store/reflog.rs
index eb1a256715b..1d1f2368b24 100644
--- a/gix-ref/tests/refs/file/store/reflog.rs
+++ b/gix-ref/tests/refs/file/store/reflog.rs
@@ -1,4 +1,6 @@
-fn store() -> crate::Result<crate::file::Store> {
+use crate::Result;
+
+fn store() -> Result<crate::file::Store> {
     Ok(crate::file::Store::at_opts(
         crate::scripted_fixture_read_only("make_repo_for_reflog.sh")?.join(".git"),
         crate::fixture_hash_kind(),
@@ -10,10 +12,62 @@ fn store() -> crate::Result<crate::file::Store> {
 }
 
 mod iter_and_iter_rev {
+    use crate::Result;
     use crate::file::store::reflog::store;
 
+    #[cfg(unix)]
+    #[test]
+    fn read_failures_preserve_context() -> Result {
+        let mut error_snapshots = Vec::new();
+        let store = store()?;
+        let name = "refs/heads/main/child";
+        let mut buf = vec![0; 256];
+        for err in [
+            store.reflog_iter(name, &mut buf).err().expect("main is a file"),
+            store.reflog_iter_rev(name, &mut buf).err().expect("main is a file"),
+        ] {
+            let details = err.metadata().next().expect("reflog read context");
+            assert!(
+                err.downcast_any_ref::<gix_error::Message>().is_some(),
+                "the reflog read diagnostic retains its concrete type"
+            );
+            assert_eq!(details.len(), 1, "read context contains only the path");
+            assert_eq!(
+                details["path"],
+                gix_error::MetadataValue::Path(store.git_dir().join("logs").join(name)),
+                "both directions retain the resolved reflog path as a native path"
+            );
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")],
+            ));
+            assert_eq!(
+                err.downcast_any_ref::<std::io::Error>()
+                    .expect("the original open error is retained")
+                    .kind(),
+                std::io::ErrorKind::NotADirectory,
+                "a file at a path prefix retains its I/O error kind on Unix"
+            );
+            assert!(
+                !err.is_corrupted(),
+                "a path collision does not imply corrupt reflog contents"
+            );
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "read failures preserve context", @r#"
+        [
+            Could not read reflog, "path"="<git-dir>/logs/refs/heads/main/child"
+            |
+            └─ NotADirectory,
+            Could not read reflog, "path"="<git-dir>/logs/refs/heads/main/child"
+            |
+            └─ NotADirectory,
+        ]
+        "#);
+        Ok(())
+    }
+
     #[test]
-    fn non_existing_and_directory_returns_none() -> crate::Result {
+    fn non_existing_and_directory_returns_none() -> Result {
         let store = store()?;
         let mut buf = Vec::new();
         for name in &["FAILURE_NONEXISTING", "refs/heads"] {
@@ -26,24 +80,25 @@ mod iter_and_iter_rev {
     }
 
     #[test]
-    fn for_head_and_main() -> crate::Result {
+    fn for_head_and_main() -> Result {
         let store = store()?;
         let mut buf = Vec::new();
 
         let log = store.reflog_iter("HEAD", &mut buf)?.expect("exists");
-        assert_eq!(log.filter_map(Result::ok).count(), 5);
+        assert_eq!(log.filter_map(std::result::Result::ok).count(), 5);
 
         let log = store.reflog_iter("refs/heads/main", &mut buf)?.expect("exists");
-        assert_eq!(log.filter_map(Result::ok).count(), 5);
+        assert_eq!(log.filter_map(std::result::Result::ok).count(), 5);
         Ok(())
     }
 }
 
 mod iter_rev {
+    use crate::Result;
     use crate::file::store::reflog::store;
 
     #[test]
-    fn non_existing_and_directory_returns_none() -> crate::Result {
+    fn non_existing_and_directory_returns_none() -> Result {
         let store = store()?;
         let mut buf = [0u8; 256];
         for name in &["FAILURE_NONEXISTING", "refs/heads"] {
@@ -56,15 +111,15 @@ mod iter_rev {
     }
 
     #[test]
-    fn for_head_and_main() -> crate::Result {
+    fn for_head_and_main() -> Result {
         let store = store()?;
         let mut buf = [0u8; 256];
 
         let log = store.reflog_iter_rev("HEAD", &mut buf)?.expect("exists");
-        assert_eq!(log.filter_map(Result::ok).count(), 5);
+        assert_eq!(log.filter_map(std::result::Result::ok).count(), 5);
 
         let log = store.reflog_iter_rev("refs/heads/main", &mut buf)?.expect("exists");
-        assert_eq!(log.filter_map(Result::ok).count(), 5);
+        assert_eq!(log.filter_map(std::result::Result::ok).count(), 5);
         Ok(())
     }
 }
diff --git a/gix-ref/tests/refs/file/transaction/mod.rs b/gix-ref/tests/refs/file/transaction/mod.rs
index 8c58c9bd3f4..2bd9ffcdf81 100644
--- a/gix-ref/tests/refs/file/transaction/mod.rs
+++ b/gix-ref/tests/refs/file/transaction/mod.rs
@@ -1,4 +1,5 @@
 pub(crate) mod prepare_and_commit {
+    use crate::Result;
     use gix_hash::ObjectId;
     use gix_object::bstr::BString;
     use gix_ref::{
@@ -8,7 +9,7 @@ pub(crate) mod prepare_and_commit {
 
     use crate::hex_to_id;
 
-    fn reflog_lines(store: &file::Store, name: &str) -> crate::Result<Vec<gix_ref::log::Line>> {
+    fn reflog_lines(store: &file::Store, name: &str) -> Result<Vec<gix_ref::log::Line>> {
         let mut buf = Vec::new();
         let res = store
             .reflog_iter(name, &mut buf)?
@@ -18,7 +19,7 @@ pub(crate) mod prepare_and_commit {
         Ok(res)
     }
 
-    pub(crate) fn empty_store() -> crate::Result<(gix_testtools::tempfile::TempDir, file::Store)> {
+    pub(crate) fn empty_store() -> Result<(gix_testtools::tempfile::TempDir, file::Store)> {
         let dir = gix_testtools::tempfile::TempDir::new().unwrap();
         let store = file::Store::at(dir.path().into(), crate::fixture_hash_kind());
         Ok((dir, store))
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 8e77e278f66..80f524835c3 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 crate::Result;
 use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
 use gix_ref::{
@@ -20,7 +21,7 @@ fn case_sensitive(tmp_dir: &std::path::Path) -> bool {
 }
 
 #[test]
-fn conflicting_creation_without_packed_refs() -> crate::Result {
+fn conflicting_creation_without_packed_refs() -> Result {
     let (dir, store) = empty_store()?;
     let res = store.transaction().prepare(
         [create_at("refs/a"), create_at("refs/A")],
@@ -34,7 +35,20 @@ fn conflicting_creation_without_packed_refs() -> crate::Result {
         Ok(_) if !case_sensitive => panic!("should fail as 'a' and 'A' clash"),
         Err(err) if case_sensitive => panic!("should work as case sensitivity allows 'a' and 'A' to coexist: {err:?}"),
         Err(err) if !case_sensitive => {
-            assert_eq!(err.to_string(), "A lock could not be obtained for reference \"refs/A\"");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "case-insensitive filesystems reject simultaneous locks for refs/a and refs/A", @r#"
+            Could not prepare reference edit, "reference"="refs/A", "referent"="refs/A"
+            |
+            └─ The lock for resource '<git-dir>/refs/A' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/refs/A.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<git-dir>/refs/A.lock"
+            "#);
+            assert!(err.can_retry());
+            assert_eq!(
+                err.metadata().next().expect("failed edit")["reference"],
+                gix_error::MetadataValue::from(b"refs/A".as_slice())
+            );
         }
         _ => unreachable!("actually everything is covered"),
     }
@@ -42,7 +56,7 @@ fn conflicting_creation_without_packed_refs() -> crate::Result {
 }
 
 #[test]
-fn non_conflicting_creation_without_packed_refs_work() -> crate::Result {
+fn non_conflicting_creation_without_packed_refs_work() -> Result {
     let (_dir, store) = empty_store()?;
     let ongoing = store
         .transaction()
@@ -66,7 +80,7 @@ fn non_conflicting_creation_without_packed_refs_work() -> crate::Result {
 }
 
 #[test]
-fn packed_refs_lock_is_mandatory_for_multiple_ongoing_transactions_even_if_one_does_not_need_it() -> crate::Result {
+fn packed_refs_lock_is_mandatory_for_multiple_ongoing_transactions_even_if_one_does_not_need_it() -> Result {
     let (_dir, store) = empty_store()?;
     let ref_name = "refs/a";
     let _t1 = store
@@ -79,16 +93,25 @@ fn packed_refs_lock_is_mandatory_for_multiple_ongoing_transactions_even_if_one_d
     let t2res = store
         .transaction()
         .prepare([delete_at(ref_name)], Fail::Immediately, Fail::Immediately);
-    assert_eq!(
-        &t2res.unwrap_err().to_string()[..54],
-        "The lock for the packed-ref file could not be obtained",
+    let err = t2res.expect_err("packed refs are locked");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "if packed-refs are about to be created, other transactions always acquire a packed-refs lock as to not miss anything", @r#"
+    Could not lock packed refs
+    |
+    └─ The lock for resource '<git-dir>/packed-refs' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/packed-refs.lock' might need manual deletion.
+    |
+    └─ I/O error (AlreadyExists)
+    |
+    └─ AlreadyExists at path "<git-dir>/packed-refs.lock"
+    "#);
+    assert!(
+        err.can_retry(),
         "if packed-refs are about to be created, other transactions always acquire a packed-refs lock as to not miss anything"
     );
     Ok(())
 }
 
 #[test]
-fn conflicting_creation_into_packed_refs() -> crate::Result {
+fn conflicting_creation_into_packed_refs() -> Result {
     let (dir, store) = empty_store()?;
     let mut buf = TimeBuf::default();
     let transaction = store
@@ -107,9 +130,18 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
         );
 
     if !case_sensitive(dir.path()) {
-        assert_eq!(
-            transaction.unwrap_err().to_string(),
-            "A lock could not be obtained for reference \"refs/A\"",
+        let err = transaction.expect_err("case-insensitive collision");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "packed ref updates still acquire loose locks before their CAS read", @r#"
+        Could not prepare reference edit, "reference"="refs/A", "referent"="refs/A"
+        |
+        └─ The lock for resource '<git-dir>/refs/A' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/refs/A.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<git-dir>/refs/A.lock"
+        "#);
+        assert!(
+            err.can_retry(),
             "packed ref updates still acquire loose locks before their CAS read"
         );
         return Ok(());
@@ -172,9 +204,18 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             Fail::Immediately,
         );
 
-        assert_eq!(
-            &t2res.unwrap_err().to_string()[..40],
-            "The lock for the packed-ref file could n",
+        let err = t2res.expect_err("packed refs are locked");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "packed-refs files will always be locked if they are present as we have to look up their content", @r#"
+        Could not lock packed refs
+        |
+        └─ The lock for resource '<git-dir>/packed-refs' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/packed-refs.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<git-dir>/packed-refs.lock"
+        "#);
+        assert!(
+            err.can_retry(),
             "packed-refs files will always be locked if they are present as we have to look up their content"
         );
     }
@@ -188,11 +229,17 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             .transaction()
             .prepare([delete_at("refs/A")], Fail::Immediately, Fail::Immediately);
 
-        assert_eq!(
-            &t2res.unwrap_err().to_string()[..40],
-            "The lock for the packed-ref file could n",
-            "once again, packed-refs save the day"
-        );
+        let err = t2res.expect_err("packed refs are locked");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "once again, packed-refs save the day", @r#"
+        Could not lock packed refs
+        |
+        └─ The lock for resource '<git-dir>/packed-refs' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/packed-refs.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<git-dir>/packed-refs.lock"
+        "#);
+        assert!(err.can_retry(), "once again, packed-refs save the day");
     }
 
     // Create a loose ref at a path
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 5205c34c9e2..036ff97f5f2 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,5 +1,4 @@
-use std::error::Error;
-
+use crate::Result;
 use gix_date::parse::TimeBuf;
 use gix_hash::ObjectId;
 use gix_lock::acquire::Fail;
@@ -27,7 +26,7 @@ use crate::{
 mod collisions;
 
 #[test]
-fn intermediate_directories_are_removed_on_rollback() -> crate::Result {
+fn intermediate_directories_are_removed_on_rollback() -> Result {
     for explicit_rollback in [false, true] {
         let (dir, store) = empty_store()?;
 
@@ -59,8 +58,9 @@ fn intermediate_directories_are_removed_on_rollback() -> crate::Result {
 }
 
 #[test]
-fn reference_with_equally_named_empty_or_non_empty_directory_already_in_place_can_potentially_recover() -> crate::Result
-{
+fn reference_with_equally_named_empty_or_non_empty_directory_already_in_place_can_potentially_recover() -> Result {
+    #[cfg(not(windows))]
+    let mut error_snapshots = Vec::new();
     for is_empty in &[true, false] {
         let (dir, store) = empty_store()?;
         let head_dir = dir.path().join("HEAD");
@@ -90,22 +90,32 @@ fn reference_with_equally_named_empty_or_non_empty_directory_already_in_place_ca
                 "HEAD was created despite a directory being in the way"
             );
         } else {
-            match edits {
-                #[cfg_attr(target_os = "windows", allow(unused_variables))]
-                Err(transaction::commit::Error::LockCommit { source, full_name }) => {
-                    assert_eq!(full_name, "HEAD");
-                    #[cfg(not(windows))]
-                    assert_eq!(source.to_string(), "Directory not empty");
-                }
-                _ => unreachable!("other errors shouldn't happen here"),
-            }
+            let err = edits.expect_err("the directory is not empty");
+            assert_eq!(
+                err.metadata().next().expect("failed reference")["reference"],
+                gix_error::MetadataValue::from(b"HEAD".as_slice())
+            );
+            #[cfg(not(windows))]
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         }
     }
+    #[cfg(not(windows))]
+    insta::assert_debug_snapshot!(error_snapshots, "reference with equally named empty or non empty directory already in place can potentially recover", @r#"
+    [
+        Could not commit reference, "reference"="HEAD"
+        |
+        └─ I/O error (Other)
+        |
+        └─ I/O error (Other)
+        |
+        └─ Directory not empty,
+    ]
+    "#);
     Ok(())
 }
 
 #[test]
-fn reference_with_old_value_must_exist_when_creating_it() -> crate::Result {
+fn reference_with_old_value_must_exist_when_creating_it() -> Result {
     let (_keep, store) = empty_store()?;
 
     let new_target = Target::Object(crate::fixture_hash_kind().null());
@@ -120,18 +130,22 @@ fn reference_with_old_value_must_exist_when_creating_it() -> crate::Result {
         Fail::Immediately,
     );
 
-    match res {
-        Err(transaction::prepare::Error::MustExist { full_name, expected }) => {
-            assert_eq!(full_name, "HEAD");
-            assert_eq!(expected, new_target);
-        }
-        _ => unreachable!("unexpected result"),
-    }
+    let err = res.expect_err("the previous reference must exist");
+    insta::assert_debug_snapshot!(err, "reference with old value must exist when creating it", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="HEAD"
+    |
+    └─ The reference to update must exist
+    "#);
+    assert!(err.is_not_found());
+    assert_eq!(
+        err.metadata().next().expect("failed edit")["reference"],
+        gix_error::MetadataValue::from(b"HEAD".as_slice())
+    );
     Ok(())
 }
 
 #[test]
-fn reference_with_explicit_value_must_match_the_value_on_update() -> crate::Result {
+fn reference_with_explicit_value_must_match_the_value_on_update() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
@@ -146,18 +160,25 @@ fn reference_with_explicit_value_must_match_the_value_on_update() -> crate::Resu
         Fail::Immediately,
         Fail::Immediately,
     );
-    match res {
-        Err(transaction::prepare::Error::ReferenceOutOfDate { full_name, actual, .. }) => {
-            assert_eq!(full_name, "HEAD");
-            assert_eq!(actual, target);
-        }
-        _ => unreachable!("unexpected result"),
-    }
+    let err = res.expect_err("the transaction constraint is violated").into_error();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "retrying requires reconciling the current value", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="HEAD"
+    |
+    └─ Expected reference content Oid(1)
+    |
+    └─ The reference "HEAD" changed to ref: refs/heads/main
+    "#);
+    let actual = err
+        .downcast_any_ref::<transaction::prepare::ReferenceOutOfDate>()
+        .expect("typed recovery signal");
+    assert_eq!(actual.full_name, "HEAD");
+    assert_eq!(actual.actual, target);
+    assert!(!err.can_retry(), "retrying requires reconciling the current value");
     Ok(())
 }
 
 #[test]
-fn the_existing_must_match_constraint_allow_non_existing_references_to_be_created() -> crate::Result {
+fn the_existing_must_match_constraint_allow_non_existing_references_to_be_created() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let expected = PreviousValue::ExistingMustMatch(Target::Object(ObjectId::empty_tree(crate::fixture_hash_kind())));
     let mut buf = TimeBuf::default();
@@ -191,7 +212,7 @@ fn the_existing_must_match_constraint_allow_non_existing_references_to_be_create
 
 #[test]
 fn the_existing_must_match_constraint_requires_existing_references_to_have_the_given_value_to_cause_failure_on_mismatch()
--> crate::Result {
+-> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
@@ -206,18 +227,25 @@ fn the_existing_must_match_constraint_requires_existing_references_to_have_the_g
         Fail::Immediately,
         Fail::Immediately,
     );
-    match res {
-        Err(transaction::prepare::Error::ReferenceOutOfDate { full_name, actual, .. }) => {
-            assert_eq!(full_name, "HEAD");
-            assert_eq!(actual, target);
-        }
-        _ => unreachable!("unexpected result"),
-    }
+    let err = res.expect_err("the transaction constraint is violated").into_error();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "retrying requires reconciling the current value", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="HEAD"
+    |
+    └─ Expected reference content Oid(1)
+    |
+    └─ The reference "HEAD" changed to ref: refs/heads/main
+    "#);
+    let actual = err
+        .downcast_any_ref::<transaction::prepare::ReferenceOutOfDate>()
+        .expect("typed recovery signal");
+    assert_eq!(actual.full_name, "HEAD");
+    assert_eq!(actual.actual, target);
+    assert!(!err.can_retry(), "retrying requires reconciling the current value");
     Ok(())
 }
 
 #[test]
-fn reference_with_must_not_exist_constraint_cannot_be_created_if_it_exists_already() -> crate::Result {
+fn reference_with_must_not_exist_constraint_cannot_be_created_if_it_exists_already() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
@@ -225,18 +253,25 @@ fn reference_with_must_not_exist_constraint_cannot_be_created_if_it_exists_alrea
     let res = store
         .transaction()
         .prepare(Some(create_at("HEAD")), Fail::Immediately, Fail::Immediately);
-    match res {
-        Err(transaction::prepare::Error::MustNotExist { full_name, actual, .. }) => {
-            assert_eq!(full_name, "HEAD");
-            assert_eq!(actual, target);
-        }
-        _ => unreachable!("unexpected result"),
-    }
+    let err = res.expect_err("the transaction constraint is violated").into_error();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "retrying requires reconciling the current value", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="HEAD"
+    |
+    └─ Expected the reference not to exist when writing Oid(1)
+    |
+    └─ The reference "HEAD" already exists with content ref: refs/heads/main
+    "#);
+    let actual = err
+        .downcast_any_ref::<transaction::prepare::MustNotExist>()
+        .expect("typed recovery signal");
+    assert_eq!(actual.full_name, "HEAD");
+    assert_eq!(actual.actual, target);
+    assert!(!err.can_retry(), "retrying requires reconciling the current value");
     Ok(())
 }
 
 #[test]
-fn namespaced_updates_or_deletions_are_transparent_and_not_observable() -> crate::Result {
+fn namespaced_updates_or_deletions_are_transparent_and_not_observable() -> Result {
     let (_keep, mut store) = empty_store()?;
     store.namespace = gix_ref::namespace::expand("foo")?.into();
     let actual = vec![
@@ -253,7 +288,7 @@ fn namespaced_updates_or_deletions_are_transparent_and_not_observable() -> crate
 }
 
 #[test]
-fn reference_with_must_exist_constraint_must_exist_already_with_any_value() -> crate::Result {
+fn reference_with_must_exist_constraint_must_exist_already_with_any_value() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
@@ -293,8 +328,7 @@ fn reference_with_must_exist_constraint_must_exist_already_with_any_value() -> c
 }
 
 #[test]
-fn reference_with_must_not_exist_constraint_may_exist_already_if_the_new_value_matches_the_existing_one()
--> crate::Result {
+fn reference_with_must_not_exist_constraint_may_exist_already_if_the_new_value_matches_the_existing_one() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
@@ -333,7 +367,7 @@ fn reference_with_must_not_exist_constraint_may_exist_already_if_the_new_value_m
 }
 
 #[test]
-fn cancellation_after_preparation_leaves_no_change() -> crate::Result {
+fn cancellation_after_preparation_leaves_no_change() -> Result {
     let (dir, store) = empty_store()?;
 
     let tx = store.transaction();
@@ -357,7 +391,7 @@ fn cancellation_after_preparation_leaves_no_change() -> crate::Result {
 }
 
 #[test]
-fn symbolic_reference_writes_reflog_if_previous_value_is_set() -> crate::Result {
+fn symbolic_reference_writes_reflog_if_previous_value_is_set() -> Result {
     let (_keep, store) = empty_store()?;
     let referent = "refs/heads/alt-main";
     assert!(
@@ -405,7 +439,8 @@ fn symbolic_reference_writes_reflog_if_previous_value_is_set() -> crate::Result
 }
 
 #[test]
-fn windows_device_name_is_illegal_with_enabled_windows_protections() -> crate::Result {
+fn windows_device_name_is_illegal_with_enabled_windows_protections() -> Result {
+    let mut error_snapshots = Vec::new();
     let (_keep, mut store) = empty_store()?;
     store.prohibit_windows_device_names = true;
     let log_ignored = LogChange {
@@ -429,12 +464,7 @@ fn windows_device_name_is_illegal_with_enabled_windows_protections() -> crate::R
                 Fail::Immediately,
             )
             .unwrap_err();
-        assert_eq!(
-            err.source().expect("inner").to_string(),
-            format!("Illegal use of reserved Windows device name in \"{invalid_name}\""),
-            "it's notable that the check also kicks in when the previous value doesn't matter - we expect a 'read' to happen anyway \
-            - it can't be optimized away as the previous value is stored in the transaction result right now."
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
 
     #[cfg(not(windows))]
@@ -454,6 +484,24 @@ fn windows_device_name_is_illegal_with_enabled_windows_protections() -> crate::R
         )?;
     }
 
+    insta::assert_debug_snapshot!(error_snapshots, "windows device name is illegal with enabled windows protections", @r#"
+    [
+        Could not prepare reference edit, "reference"="refs/heads/CON", "referent"="refs/heads/CON"
+        |
+        └─ Invalid reference filename
+        |
+        └─ I/O error (Other)
+        |
+        └─ Illegal use of reserved Windows device name in "refs/heads/CON",
+        Could not prepare reference edit, "reference"="refs/CON/still-invalid", "referent"="refs/CON/still-invalid"
+        |
+        └─ Invalid reference filename
+        |
+        └─ I/O error (Other)
+        |
+        └─ Illegal use of reserved Windows device name in "refs/CON/still-invalid",
+    ]
+    "#);
     Ok(())
 }
 
@@ -468,7 +516,7 @@ fn windows_device_name_is_illegal_with_enabled_windows_protections() -> crate::R
 /// `LockAcquire(PermanentlyLocked)` instead.
 #[cfg(not(windows))]
 #[test]
-fn windows_device_name_check_runs_before_lock_acquisition() -> crate::Result {
+fn windows_device_name_check_runs_before_lock_acquisition() -> Result {
     let (keep, mut store) = empty_store()?;
     store.prohibit_windows_device_names = true;
 
@@ -490,17 +538,19 @@ fn windows_device_name_check_runs_before_lock_acquisition() -> crate::Result {
         )
         .unwrap_err();
 
-    assert_eq!(
-        err.source().expect("inner").to_string(),
-        "Illegal use of reserved Windows device name in \"refs/heads/CON\"",
-        "device-name validation must short-circuit before lock acquisition; otherwise the \
-         pre-existing lock file would surface as `LockAcquire(PermanentlyLocked)`"
-    );
+    insta::assert_debug_snapshot!(err.downcast_any_ref::<std::io::Error>()
+            .expect("original I/O failure"), "device-name validation must short-circuit before lock acquisition; otherwise the \
+         pre-existing lock file would surface as `LockAcquire(PermanentlyLocked)`", @r#"
+    Custom {
+        kind: Other,
+        error: "Illegal use of reserved Windows device name in \"refs/heads/CON\"",
+    }
+    "#);
     Ok(())
 }
 
 #[test]
-fn lock_failure_on_symbolic_referent_is_reported_for_the_symbolic_ref() -> crate::Result {
+fn lock_failure_on_symbolic_referent_is_reported_for_the_symbolic_ref() -> Result {
     let (keep, store) = empty_store()?;
     std::fs::write(keep.path().join("HEAD"), b"ref: refs/heads/main\n")?;
     std::fs::create_dir_all(keep.path().join("refs/heads"))?;
@@ -522,16 +572,33 @@ fn lock_failure_on_symbolic_referent_is_reported_for_the_symbolic_ref() -> crate
             Fail::Immediately,
         )
         .unwrap_err();
-
-    assert!(
-        matches!(err, transaction::prepare::Error::LockAcquire { full_name, .. } if full_name == "HEAD"),
-        "the lock error should name the symbolic ref that initiated the dereferenced update"
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(store.git_dir()).to_string_lossy(), "<git-dir>")]), "the original lock failure is classifiable", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="refs/heads/main"
+    |
+    └─ The lock for resource '<git-dir>/refs/heads/main' could not be obtained immediately after 1 attempt(s). The lockfile at '<git-dir>/refs/heads/main.lock' might need manual deletion.
+    |
+    └─ I/O error (AlreadyExists)
+    |
+    └─ AlreadyExists at path "<git-dir>/refs/heads/main.lock"
+    "#);
+
+    assert!(err.can_retry(), "the original lock failure is classifiable");
+    let details = err.metadata().next().expect("failed edit");
+    assert_eq!(
+        details["reference"],
+        gix_error::MetadataValue::from(b"HEAD".as_slice()),
+        "the failed edit identifies the symbolic reference requested by the caller"
+    );
+    assert_eq!(
+        details["referent"],
+        gix_error::MetadataValue::from(b"refs/heads/main".as_slice()),
+        "the actual locked referent is retained as well"
     );
     Ok(())
 }
 
 #[test]
-fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
+fn symbolic_head_missing_referent_then_update_referent() -> Result {
     for reflog_writemode in &[WriteReflog::Normal, WriteReflog::Disable, WriteReflog::Always] {
         let (_keep, mut store) = empty_store()?;
         store.write_reflog = *reflog_writemode;
@@ -665,7 +732,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
 #[test]
 /// Writing a peeled ref to which head points to doesn't update HEAD on the fly even though that might be what's would
 /// be needed to keep the reflog consistent
-fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_though_it_should() -> crate::Result {
+fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_though_it_should() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
     let referent = head.target.to_ref().try_name().expect("symbolic ref").to_owned();
@@ -714,7 +781,7 @@ fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_tho
 }
 
 #[test]
-fn packed_refs_are_looked_up_when_checking_existing_values() -> crate::Result {
+fn packed_refs_are_looked_up_when_checking_existing_values() -> Result {
     let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
     assert!(
         store.try_find_loose("main")?.is_none(),
@@ -763,7 +830,7 @@ fn packed_refs_creation_with_tag_loop_are_not_handled_and_cannot_exist_due_to_ob
 }
 
 #[test]
-fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs() -> crate::Result {
+fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs() -> Result {
     let (_keep, store) = store_writable("make_ref_repository.sh")?;
     assert!(
         store.open_packed_buffer()?.is_none(),
@@ -794,7 +861,7 @@ fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs(
     assert!(
         store
             .loose_iter()?
-            .filter_map(Result::ok)
+            .filter_map(std::result::Result::ok)
             .all(|r| r.kind() == gix_ref::Kind::Symbolic),
         "only symbolic refs are left"
     );
@@ -810,7 +877,7 @@ fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs(
 }
 
 #[test]
-fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs() -> crate::Result {
+fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs() -> Result {
     let (_keep, store) = store_writable("make_packed_ref_repository_for_overlay.sh")?;
     let branch = store.find("newer-as-loose")?;
     let packed = store.open_packed_buffer()?.expect("packed-refs");
@@ -820,7 +887,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
         "the packed ref is outdated"
     );
     let previous_reflog_entries = branch.log_iter(&store).all()?.expect("log").count();
-    let previous_packed_refs = packed.iter()?.filter_map(Result::ok).count();
+    let previous_packed_refs = packed.iter()?.filter_map(std::result::Result::ok).count();
 
     let edits = store
         .loose_iter()?
@@ -839,7 +906,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
     );
 
     assert_eq!(
-        store.loose_iter()?.filter_map(Result::ok).count(),
+        store.loose_iter()?.filter_map(std::result::Result::ok).count(),
         edits.len(),
         "the amount of loose refs didn't change and having symbolic ones isn't a problem"
     );
@@ -851,7 +918,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
 
     let packed = store.open_packed_buffer()?.expect("packed-refs");
     assert_eq!(
-        packed.iter()?.filter_map(Result::ok).count(),
+        packed.iter()?.filter_map(std::result::Result::ok).count(),
         previous_packed_refs,
         "the amount of packed refs doesn't change"
     );
@@ -864,7 +931,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
 }
 
 #[test]
-fn packed_refs_deletion_in_deletions_and_updates_mode() -> crate::Result {
+fn packed_refs_deletion_in_deletions_and_updates_mode() -> Result {
     let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
     assert!(
         store.try_find_loose("refs/heads/d1")?.is_none(),
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 c29dc4020c2..3630ad7d29e 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 crate::Result;
 use crate::{
     file::{
         store_writable,
@@ -7,7 +8,6 @@ use crate::{
 };
 use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
-use gix_ref::file::transaction::prepare::Error;
 use gix_ref::{
     FullName, Reference, Target,
     file::ReferenceExt,
@@ -15,7 +15,7 @@ use gix_ref::{
 };
 
 #[test]
-fn delete_a_ref_which_is_gone_succeeds() -> crate::Result {
+fn delete_a_ref_which_is_gone_succeeds() -> Result {
     let (_keep, store) = empty_store()?;
     let edits = store
         .transaction()
@@ -30,25 +30,25 @@ fn delete_a_ref_which_is_gone_succeeds() -> crate::Result {
 }
 
 #[test]
-fn delete_a_ref_which_is_gone_but_must_exist_fails() -> crate::Result {
+fn delete_a_ref_which_is_gone_but_must_exist_fails() -> Result {
     let (_keep, store) = empty_store()?;
     let res = store.transaction().prepare(
         Some(RefEdit::delete("DOES_NOT_EXIST".try_into()?, PreviousValue::MustExist)),
         Fail::Immediately,
         Fail::Immediately,
     );
-    match res {
-        Ok(_) => unreachable!("must exist, but it doesn't actually exist"),
-        Err(err) => assert_eq!(
-            err.to_string(),
-            "The reference \"DOES_NOT_EXIST\" for deletion did not exist or could not be parsed"
-        ),
-    }
+    let err = res.expect_err("the reference must exist");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "delete a ref which is gone but must exist fails", @r#"
+    Could not prepare reference edit, "reference"="DOES_NOT_EXIST", "referent"="DOES_NOT_EXIST"
+    |
+    └─ The reference to delete must exist
+    "#);
+    assert!(err.is_not_found(), "delete a ref which is gone but must exist fails");
     Ok(())
 }
 
 #[test]
-fn delete_ref_and_reflog_on_symbolic_no_deref() -> crate::Result {
+fn delete_ref_and_reflog_on_symbolic_no_deref() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
@@ -81,7 +81,7 @@ fn delete_ref_and_reflog_on_symbolic_no_deref() -> crate::Result {
 }
 
 #[test]
-fn delete_ref_with_incorrect_previous_value_fails() -> crate::Result {
+fn delete_ref_with_incorrect_previous_value_fails() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
@@ -99,18 +99,22 @@ fn delete_ref_with_incorrect_previous_value_fails() -> crate::Result {
         Fail::Immediately,
     );
 
-    match res {
-        Err(err) => {
-            assert_eq!(
-                err.to_string(),
-                format!(
-                    "The reference \"refs/heads/main\" should have content ref: refs/heads/main, actual content was {}",
-                    hex_to_id("02a7a22d90d7c02fb494ed25551850b868e634f0")
-                )
-            );
-        }
-        Ok(_) => unreachable!("must be err"),
-    }
+    let err = res.expect_err("the expected target differs");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "reference deletion retains the expected and actual target when they differ", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="refs/heads/main"
+    |
+    └─ Expected reference content ref: refs/heads/main
+    |
+    └─ The reference "refs/heads/main" changed to Oid(1)
+    "#);
+    let stale = err
+        .downcast_any_ref::<gix_ref::file::transaction::prepare::ReferenceOutOfDate>()
+        .expect("stale reference recovery signal");
+    assert_eq!(stale.full_name, "refs/heads/main");
+    assert_eq!(
+        stale.actual,
+        Target::Object(hex_to_id("02a7a22d90d7c02fb494ed25551850b868e634f0"))
+    );
     // everything stays as is
     let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
@@ -120,7 +124,7 @@ fn delete_ref_with_incorrect_previous_value_fails() -> crate::Result {
 }
 
 #[test]
-fn delete_reflog_only_of_symbolic_no_deref() -> crate::Result {
+fn delete_reflog_only_of_symbolic_no_deref() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
@@ -152,7 +156,7 @@ fn delete_reflog_only_of_symbolic_no_deref() -> crate::Result {
 }
 
 #[test]
-fn delete_reflog_only_of_symbolic_with_deref() -> crate::Result {
+fn delete_reflog_only_of_symbolic_with_deref() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
@@ -180,7 +184,7 @@ fn delete_reflog_only_of_symbolic_with_deref() -> crate::Result {
 }
 
 #[test]
-fn rename_a_to_a_slash_b_in_one_transaction() -> crate::Result {
+fn rename_a_to_a_slash_b_in_one_transaction() -> Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let old = store.find_loose("old")?;
 
@@ -196,17 +200,23 @@ fn rename_a_to_a_slash_b_in_one_transaction() -> crate::Result {
             Fail::Immediately,
         )
         .unwrap_err();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "path-prefix collisions are reported early, without losing the I/O kind", @r#"
+    Could not prepare reference edit, "reference"="refs/heads/old/new", "referent"="refs/heads/old/new"
+    |
+    └─ Another IO error occurred while obtaining the lock
+    |
+    └─ I/O error (NotADirectory)
+    |
+    └─ AlreadyExists
+    "#);
 
-    match err {
-        Error::Io(err) => {
-            assert_eq!(
-                err.kind(),
-                std::io::ErrorKind::NotADirectory,
-                "For now this isn't supported in the same transaction, and path-prefix collisions are reported early."
-            );
-        }
-        err => unreachable!("unexpected error variant: {err:?}"),
-    }
+    assert_eq!(
+        err.downcast_any_ref::<std::io::Error>()
+            .expect("original I/O error")
+            .kind(),
+        std::io::ErrorKind::NotADirectory,
+        "path-prefix collisions are reported early, without losing the I/O kind"
+    );
 
     let edits = store
         .transaction()
@@ -236,7 +246,7 @@ fn rename_a_to_a_slash_b_in_one_transaction() -> crate::Result {
 
 #[test]
 /// Based on https://github.com/git/git/blob/master/refs/files-backend.c#L514:L515
-fn delete_broken_ref_that_must_exist_fails_as_it_is_no_valid_ref() -> crate::Result {
+fn delete_broken_ref_that_must_exist_fails_as_it_is_no_valid_ref() -> Result {
     let (_keep, store) = empty_store()?;
     std::fs::write(store.git_dir().join("HEAD"), b"broken")?;
     assert!(store.try_find_loose("HEAD").is_err(), "the ref is truly broken");
@@ -246,20 +256,21 @@ fn delete_broken_ref_that_must_exist_fails_as_it_is_no_valid_ref() -> crate::Res
         Fail::Immediately,
         Fail::Immediately,
     );
-    match res {
-        Err(err) => {
-            assert_eq!(
-                err.to_string(),
-                "The reference \"HEAD\" for deletion did not exist or could not be parsed"
-            );
-        }
-        Ok(_) => unreachable!("expected error"),
-    }
+    let err = res.expect_err("a valid existing reference is required");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&store.git_dir().to_string_lossy(), "<git-dir>")]), "delete broken ref that must exist fails as it is no valid ref", @r#"
+    Could not prepare reference edit, "reference"="HEAD", "referent"="HEAD"
+    |
+    └─ The reference to delete must exist
+    "#);
+    assert!(
+        err.is_not_found(),
+        "delete broken ref that must exist fails as it is no valid ref"
+    );
     Ok(())
 }
 
 #[test]
-fn non_existing_can_be_deleted_with_the_may_exist_match_constraint() -> crate::Result {
+fn non_existing_can_be_deleted_with_the_may_exist_match_constraint() -> Result {
     let (_keep, store) = empty_store()?;
     let previous_value =
         PreviousValue::ExistingMustMatch(Target::Object(hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03")));
@@ -281,7 +292,7 @@ fn non_existing_can_be_deleted_with_the_may_exist_match_constraint() -> crate::R
 
 #[test]
 /// Based on https://github.com/git/git/blob/master/refs/files-backend.c#L514:L515
-fn delete_broken_ref_that_may_not_exist_works_even_in_deref_mode() -> crate::Result {
+fn delete_broken_ref_that_may_not_exist_works_even_in_deref_mode() -> Result {
     let (_keep, store) = empty_store()?;
     std::fs::write(store.git_dir().join("HEAD"), b"broken")?;
     assert!(store.try_find_loose("HEAD").is_err(), "the ref is truly broken");
@@ -301,7 +312,7 @@ fn delete_broken_ref_that_may_not_exist_works_even_in_deref_mode() -> crate::Res
 }
 
 #[test]
-fn store_write_mode_has_no_effect_and_reflogs_are_always_deleted() -> crate::Result {
+fn store_write_mode_has_no_effect_and_reflogs_are_always_deleted() -> Result {
     for reflog_writemode in &[
         gix_ref::store::WriteReflog::Normal,
         gix_ref::store::WriteReflog::Disable,
@@ -332,7 +343,7 @@ fn store_write_mode_has_no_effect_and_reflogs_are_always_deleted() -> crate::Res
 
 #[test]
 fn packed_refs_are_consulted_when_determining_previous_value_of_ref_to_be_deleted_and_are_deleted_from_packed_ref_file()
--> crate::Result {
+-> Result {
     let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
     assert!(
         store.try_find_loose("main")?.is_none(),
@@ -363,7 +374,7 @@ fn packed_refs_are_consulted_when_determining_previous_value_of_ref_to_be_delete
 }
 
 #[test]
-fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_refs() -> crate::Result {
+fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_refs() -> Result {
     let (_keep, store) = store_writable("make_packed_ref_repository_for_overlay.sh")?;
     let packed = store.open_packed_buffer()?.expect("packed-refs");
     let branch = store.find("newer-as-loose")?;
@@ -399,7 +410,7 @@ fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_
 }
 
 #[test]
-fn all_contained_references_deletes_the_packed_ref_file_too() -> crate::Result {
+fn all_contained_references_deletes_the_packed_ref_file_too() -> Result {
     for mode in ["must-exist", "may-exist"] {
         let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
         let edits = store
diff --git a/gix-ref/tests/refs/file/worktree.rs b/gix-ref/tests/refs/file/worktree.rs
index 2f85c95d0e9..58770f0b429 100644
--- a/gix-ref/tests/refs/file/worktree.rs
+++ b/gix-ref/tests/refs/file/worktree.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use std::{cmp::Ordering, path::PathBuf};
 
 use gix_ref::{Reference, file::ReferenceExt};
 use gix_testtools::Creation;
 
-fn dir(packed: bool, writable: bool) -> crate::Result<(PathBuf, Option<gix_testtools::tempfile::TempDir>)> {
+fn dir(packed: bool, writable: bool) -> Result<(PathBuf, Option<gix_testtools::tempfile::TempDir>)> {
     let name = "make_worktree_repo.sh";
     let mut args = Vec::new();
     if packed {
@@ -20,7 +21,7 @@ fn dir(packed: bool, writable: bool) -> crate::Result<(PathBuf, Option<gix_testt
 fn main_store(
     packed: bool,
     writable: impl Into<bool>,
-) -> crate::Result<(
+) -> Result<(
     gix_ref::file::Store,
     gix_odb::Handle,
     Option<gix_testtools::tempfile::TempDir>,
@@ -39,7 +40,7 @@ fn worktree_store(
     packed: bool,
     worktree_name: &str,
     writable: impl Into<bool>,
-) -> crate::Result<(
+) -> Result<(
     gix_ref::file::Store,
     gix_odb::Handle,
     Option<gix_testtools::tempfile::TempDir>,
@@ -82,10 +83,11 @@ impl From<Mode> for bool {
 }
 
 mod read_only {
+    use crate::Result;
     use crate::file::worktree::{Mode, assert_reflog, into_peel, main_store, worktree_store};
 
     #[test]
-    fn linked() -> crate::Result {
+    fn linked() -> Result {
         for packed in [false, true] {
             let (store, odb, _tmp) = worktree_store(packed, "w1", Mode::Read)?;
             assert_eq!(store.is_pristine("refs/heads/main".try_into()?), Some(false));
@@ -134,7 +136,7 @@ mod read_only {
     }
 
     #[test]
-    fn main() -> crate::Result {
+    fn main() -> Result {
         for packed in [false, true] {
             let (store, odb, _tmp) = main_store(packed, Mode::Read)?;
             assert_eq!(store.is_pristine("refs/heads/main".try_into()?), Some(false));
@@ -195,6 +197,7 @@ mod read_only {
 }
 
 mod writable {
+    use crate::Result;
     use gix_date::parse::TimeBuf;
     use gix_lock::acquire::Fail;
     use gix_ref::{
@@ -221,7 +224,8 @@ mod writable {
     }
 
     #[test]
-    fn main() -> crate::Result {
+    fn main() -> Result {
+        let mut error_snapshots = Vec::new();
         let new_id_main = hex_to_id("11111111111111111162102c6a483440bfda2a03");
         let new_id_main_str = new_id_main.to_string();
         let new_id_linked = hex_to_id("22222222222222222262102c6a483440bfda2a03");
@@ -262,7 +266,7 @@ mod writable {
                 store
                     .iter()?
                     .all()?
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),
                 [
@@ -290,7 +294,7 @@ mod writable {
                 store
                     .iter()?
                     .prefixed(b"refs/stacks/".try_into().unwrap())?
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),
                 [
@@ -419,20 +423,22 @@ mod writable {
                 );
             }
 
-            assert!(
-                matches!(
-                    store.transaction().prepare(
-                        vec![
-                            RefEdit::new("main-worktree/refs/heads/foo".try_into()?, change_with_id(new_id_main),),
-                            RefEdit::new("refs/heads/foo".try_into()?, change_with_id(new_id_main),),
-                        ],
-                        Fail::Immediately,
-                        Fail::Immediately,
-                    ),
-                    Err(gix_ref::file::transaction::prepare::Error::LockAcquire { .. })
-                ),
-                "prefixed refs resolve to the same name and will fail to be locked (so we don't check for this when doing dupe checking)"
-            );
+            let err = store
+                .transaction()
+                .prepare(
+                    vec![
+                        RefEdit::new("main-worktree/refs/heads/foo".try_into()?, change_with_id(new_id_main)),
+                        RefEdit::new("refs/heads/foo".try_into()?, change_with_id(new_id_main)),
+                    ],
+                    Fail::Immediately,
+                    Fail::Immediately,
+                )
+                .expect_err("aliases of the same reference contend for one lock");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &err,
+                &[(&(store.common_dir_resolved()).to_string_lossy(), "<common-git-dir>")],
+            ));
+            assert!(err.can_retry(), "aliases of the same reference contend for one lock");
 
             assert!(matches!(
                 store.transaction().prepare(
@@ -446,10 +452,28 @@ mod writable {
                     Fail::Immediately,
                     Fail::Immediately,
                 ),
-                Err(gix_ref::file::transaction::prepare::Error::LockAcquire { .. })
+                Err(ref err) if err.can_retry()
             ));
         }
 
+        insta::assert_debug_snapshot!(error_snapshots, "prefixed and unprefixed names share the main worktree reference lock", @r#"
+        [
+            Could not prepare reference edit, "reference"="refs/heads/foo", "referent"="refs/heads/foo"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/foo' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/foo.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/foo.lock",
+            Could not prepare reference edit, "reference"="refs/heads/foo", "referent"="refs/heads/foo"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/foo' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/foo.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/foo.lock",
+        ]
+        "#);
         Ok(())
     }
 
@@ -458,13 +482,14 @@ mod writable {
             .reflog_iter(name, buf)
             .unwrap()
             .unwrap_or_else(|| panic!("we expect to write reflogs for {}", name.as_bstr()))
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .map(|e| e.new_oid.to_owned().to_string())
             .collect::<Vec<_>>()
     }
 
     #[test]
-    fn linked() -> crate::Result {
+    fn linked() -> Result {
+        let mut error_snapshots = Vec::new();
         let new_id = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
         let new_id_str = new_id.to_string();
         let new_id_main = hex_to_id("22222222222222227062102c6a483440bfda2a03");
@@ -473,20 +498,22 @@ mod writable {
             let (store, _odb, _tmp) = worktree_store(packed, "w1", Mode::Write)?;
 
             for conflicting_name in ["main-worktree/refs/heads/shared", "worktrees/w1/refs/heads/shared"] {
-                assert!(
-                    matches!(
-                        store.transaction().prepare(
-                            vec![
-                                RefEdit::new(conflicting_name.try_into()?, change_with_id(new_id),),
-                                RefEdit::new("refs/heads/shared".try_into()?, change_with_id(new_id),),
-                            ],
-                            Fail::Immediately,
-                            Fail::Immediately,
-                        ),
-                        Err(gix_ref::file::transaction::prepare::Error::LockAcquire { .. })
-                    ),
-                    "prefixed refs resolve to the same name and will fail to be locked (so we don't check for this when doing dupe checking)"
-                );
+                let err = store
+                    .transaction()
+                    .prepare(
+                        vec![
+                            RefEdit::new(conflicting_name.try_into()?, change_with_id(new_id)),
+                            RefEdit::new("refs/heads/shared".try_into()?, change_with_id(new_id)),
+                        ],
+                        Fail::Immediately,
+                        Fail::Immediately,
+                    )
+                    .expect_err("aliases of the same reference contend for one lock");
+                error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                    &err,
+                    &[(&(store.common_dir_resolved()).to_string_lossy(), "<common-git-dir>")],
+                ));
+                assert!(err.can_retry(), "aliases of the same reference contend for one lock");
             }
 
             let mut t = store.transaction();
@@ -516,7 +543,7 @@ mod writable {
                 store
                     .iter()?
                     .all()?
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),
                 [
@@ -545,7 +572,7 @@ mod writable {
                 store
                     .iter()?
                     .prefixed(b"refs/stacks/".try_into().unwrap())?
-                    .map(Result::unwrap)
+                    .map(std::result::Result::unwrap)
                     .map(|r| (r.name.to_string(), r.target.to_string()))
                     .collect::<Vec<_>>(),
                 [
@@ -642,6 +669,38 @@ mod writable {
             }
         }
 
+        insta::assert_debug_snapshot!(error_snapshots, "worktree-prefixed names resolve to the same shared reference lock", @r#"
+        [
+            Could not prepare reference edit, "reference"="refs/heads/shared", "referent"="refs/heads/shared"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/shared' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/shared.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/shared.lock",
+            Could not prepare reference edit, "reference"="refs/heads/shared", "referent"="refs/heads/shared"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/shared' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/shared.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/shared.lock",
+            Could not prepare reference edit, "reference"="refs/heads/shared", "referent"="refs/heads/shared"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/shared' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/shared.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/shared.lock",
+            Could not prepare reference edit, "reference"="refs/heads/shared", "referent"="refs/heads/shared"
+            |
+            └─ The lock for resource '<common-git-dir>/refs/heads/shared' could not be obtained immediately after 1 attempt(s). The lockfile at '<common-git-dir>/refs/heads/shared.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<common-git-dir>/refs/heads/shared.lock",
+        ]
+        "#);
         Ok(())
     }
 }
@@ -654,7 +713,8 @@ fn assert_reflog(store: &gix_ref::file::Store, a: Reference, b: Reference) {
     match (arl, brl) {
         (Some(arl), Some(brl)) => {
             assert_eq!(
-                arl.map(Result::unwrap).cmp(brl.map(Result::unwrap)),
+                arl.map(std::result::Result::unwrap)
+                    .cmp(brl.map(std::result::Result::unwrap)),
                 Ordering::Equal,
                 "{} and {} should have equal reflogs",
                 a.name,
diff --git a/gix-ref/tests/refs/main.rs b/gix-ref/tests/refs/main.rs
index c723d12e57d..abda46b0be4 100644
--- a/gix-ref/tests/refs/main.rs
+++ b/gix-ref/tests/refs/main.rs
@@ -64,13 +64,15 @@ fn translate_sha1_to_fixture_sha256(hex: &str) -> String {
 pub use gix_testtools::Result;
 
 mod equality;
+mod error;
 mod file;
 mod fullname;
 mod partialname {
+    use crate::Result;
     use gix_ref::PartialName;
 
     #[test]
-    fn join() -> crate::Result {
+    fn join() -> Result {
         let pn = PartialName::try_from("no-trailing-slash")?;
         assert_eq!(pn.join("name".into())?, "no-trailing-slash/name");
 
diff --git a/gix-ref/tests/refs/packed/find.rs b/gix-ref/tests/refs/packed/find.rs
index a7158c15282..a95c9bc5546 100644
--- a/gix-ref/tests/refs/packed/find.rs
+++ b/gix-ref/tests/refs/packed/find.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_ref::packed;
 use gix_testtools::fixture_path;
 
@@ -14,11 +15,11 @@ fn a_lock_file_would_not_be_a_valid_partial_name() {
     // doesn't really belong here but want to make sure refname validation works as expected.
     // let err: &gix_ref::PartialNameRef = "heads/hello.lock".try_into().expect_err("this should fail");
     let err = <&gix_ref::PartialNameRef as TryFrom<_>>::try_from("heads/hello.lock").expect_err("this should fail");
-    assert_eq!(err.to_string(), "Reference name cannot end with '.lock'");
+    insta::assert_debug_snapshot!(err, "a lock file would not be a valid partial name", @"LockFileSuffix");
 }
 
 #[test]
-fn capitalized_branch() -> crate::Result {
+fn capitalized_branch() -> Result {
     let store = store_with_packed_refs()?;
     let packed_refs = store.open_packed_buffer()?.expect("packed-refs exist");
 
@@ -31,7 +32,7 @@ fn capitalized_branch() -> crate::Result {
 }
 
 #[test]
-fn all_iterable_refs_can_be_found() -> crate::Result {
+fn all_iterable_refs_can_be_found() -> Result {
     let store = store_with_packed_refs()?;
     let packed_refs = store.open_packed_buffer()?.expect("packed-refs exist");
 
@@ -46,7 +47,7 @@ fn all_iterable_refs_can_be_found() -> crate::Result {
 }
 
 #[test]
-fn binary_search_a_name_past_the_end_of_the_packed_refs_file() -> crate::Result {
+fn binary_search_a_name_past_the_end_of_the_packed_refs_file() -> Result {
     let packed_refs = packed::Buffer::open(
         fixture_path("packed-refs").join("triggers-out-of-bounds"),
         32,
@@ -57,7 +58,7 @@ fn binary_search_a_name_past_the_end_of_the_packed_refs_file() -> crate::Result
 }
 
 #[test]
-fn find_packed_refs_with_peeled_items_and_full_or_partial_names() -> crate::Result {
+fn find_packed_refs_with_peeled_items_and_full_or_partial_names() -> Result {
     let packed_refs = b"# pack-refs with: peeled fully-peeled sorted
 916840c0e2f67d370291042cb5274a597f4fa9bc refs/tags/TEST-0.0.1
 c4cebba92af964f2d126be90b8a6298c4cf84d45 refs/tags/gix-actor-v0.1.0
@@ -97,7 +98,7 @@ c4cebba92af964f2d126be90b8a6298c4cf84d45 refs/tags/gix-actor-v0.1.0
 }
 
 #[test]
-fn partial_name_to_full_name_conversion_rules_are_applied() -> crate::Result {
+fn partial_name_to_full_name_conversion_rules_are_applied() -> Result {
     let store = store_at("make_packed_refs_for_lookup_rules.sh")?;
     let packed = store.open_packed_buffer()?.expect("packed-refs exists");
 
@@ -155,7 +156,8 @@ fn partial_name_to_full_name_conversion_rules_are_applied() -> crate::Result {
 }
 
 #[test]
-fn invalid_refs_within_a_file_do_not_lead_to_incorrect_results() -> crate::Result {
+fn invalid_refs_within_a_file_do_not_lead_to_incorrect_results() -> Result {
+    let mut error_snapshots = Vec::new();
     let broken_packed_refs = b"# pack-refs with: peeled fully-peeled sorted
 916840c0e2f67d370291042cb5274a597f4fa9bc refs/tags/TEST-0.0.1
 bogus refs/tags/gix-actor-v0.1.0
@@ -176,18 +178,29 @@ bogus refs/tags/gix-actor-v0.1.0
     );
 
     for failing_name in &["refs/tags/TEST-0.0.1", "refs/tags/gix-actor-v0.1.0"] {
+        let err = buf.try_find(*failing_name).expect_err("it should detect an error");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_corrupted());
         assert_eq!(
-            buf.try_find(*failing_name)
-                .expect_err("it should detect an err")
-                .to_string(),
-            "The reference could not be parsed"
+            err.metadata().next().expect("failed lookup")["name"],
+            gix_error::MetadataValue::from(failing_name.as_bytes())
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid refs within a file do not lead to incorrect results", @r#"
+    [
+        Could not decode packed reference, "name"="refs/tags/TEST-0.0.1"
+        |
+        └─ Malformed packed reference record,
+        Could not decode packed reference, "name"="refs/tags/gix-actor-v0.1.0"
+        |
+        └─ Malformed packed reference record,
+    ]
+    "#);
     Ok(())
 }
 
 #[test]
-fn find_speed() -> crate::Result {
+fn find_speed() -> Result {
     let store = store_at("make_repository_with_lots_of_packed_refs.sh")?;
     let packed = store.open_packed_buffer()?.expect("packed-refs present");
     let start = std::time::Instant::now();
diff --git a/gix-ref/tests/refs/packed/iter.rs b/gix-ref/tests/refs/packed/iter.rs
index 1c1b58d6e85..bbb05a7fb4f 100644
--- a/gix-ref/tests/refs/packed/iter.rs
+++ b/gix-ref/tests/refs/packed/iter.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_ref::packed;
 
 use crate::file::{store_at, store_with_packed_refs};
@@ -5,7 +6,7 @@ use crate::file::{store_at, store_with_packed_refs};
 const HASH_KIND: gix_hash::Kind = gix_hash::Kind::Sha1;
 
 #[test]
-fn empty() -> crate::Result {
+fn empty() -> Result {
     assert_eq!(
         packed::Iter::new(&[], HASH_KIND)?.count(),
         0,
@@ -15,7 +16,52 @@ fn empty() -> crate::Result {
 }
 
 #[test]
-fn packed_refs_with_header() -> crate::Result {
+fn invalid_header_has_one_classified_diagnostic() {
+    let mut error_snapshots = Vec::new();
+    for (input, first_line) in [
+        (b"# invalid\nignored\n".as_slice(), b"# invalid".as_slice()),
+        (b"# invalid\r\nignored\r\n", b"# invalid"),
+        (b"# pack-refs with: sorted", b"# pack-refs with: sorted"),
+    ] {
+        let err = packed::Iter::new(input, HASH_KIND)
+            .err()
+            .expect("the header cannot be parsed");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_corrupted(), "an invalid packed-refs header is corruption");
+        assert_eq!(
+            err.iter_errors().count(),
+            1,
+            "a unit parser error adds no synthetic cause"
+        );
+        let details = err.metadata().next().expect("header details survive conversion");
+        assert_eq!(
+            err.downcast_any_ref::<gix_error::Message>()
+                .expect("header diagnostic")
+                .class,
+            Some(gix_error::Class::Corruption),
+            "the diagnostic carries its classification"
+        );
+        assert_eq!(
+            details["input"],
+            gix_error::MetadataValue::from(first_line),
+            "the original header is retained without its line ending"
+        );
+        assert!(
+            err.probable_cause().is::<gix_error::Message>(),
+            "the header diagnostic itself is the probable cause"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "invalid header has one classified diagnostic", @r##"
+    [
+        Invalid packed reference header, "input"="# invalid",
+        Invalid packed reference header, "input"="# invalid",
+        Invalid packed reference header, "input"="# pack-refs with: sorted",
+    ]
+    "##);
+}
+
+#[test]
+fn packed_refs_with_header() -> Result {
     let dir = crate::scripted_fixture_read_only("make_packed_ref_repository.sh")?;
     let buf = std::fs::read(dir.join(".git").join("packed-refs"))?;
     let iter = packed::Iter::new(&buf, crate::fixture_hash_kind())?;
@@ -24,19 +70,19 @@ fn packed_refs_with_header() -> crate::Result {
 }
 
 #[test]
-fn iter_prefix() -> crate::Result {
+fn iter_prefix() -> Result {
     let packed = store_with_packed_refs()?.open_packed_buffer()?.expect("packed-refs");
     assert_eq!(
         packed
             .iter_prefixed("refs/heads/".into())?
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec!["refs/heads/A", "refs/heads/d1", "refs/heads/dt1", "refs/heads/main"]
     );
 
     assert_eq!(
         packed
             .iter_prefixed("refs/heads/d".into())?
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec!["refs/heads/d1", "refs/heads/dt1"],
         "partial prefixes are fine, they don't have to resemble or be a directory"
     );
@@ -44,7 +90,7 @@ fn iter_prefix() -> crate::Result {
     assert_eq!(
         packed
             .iter_prefixed("refs/remotes/".into())?
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec!["refs/remotes/origin/main", "refs/remotes/origin/multi-link-target3",]
     );
 
@@ -52,7 +98,7 @@ fn iter_prefix() -> crate::Result {
     assert_eq!(
         packed
             .iter_prefixed(last_ref_in_file.into())?
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![last_ref_in_file],
         "prefixes which are a ref also work, this one is the last of the file"
     );
@@ -60,7 +106,7 @@ fn iter_prefix() -> crate::Result {
     assert_eq!(
         packed
             .iter_prefixed(first_ref_in_file.into())?
-            .collect::<Result<Vec<_>, _>>()?,
+            .collect::<std::result::Result<Vec<_>, _>>()?,
         vec![first_ref_in_file],
         "prefixes which are a ref also work, and this one at the beginning of the file"
     );
@@ -68,13 +114,13 @@ fn iter_prefix() -> crate::Result {
 }
 
 #[test]
-fn packed_refs_without_header() -> crate::Result {
+fn packed_refs_without_header() -> Result {
     let packed_refs = b"916840c0e2f67d370291042cb5274a597f4fa9bc refs/tags/TEST-0.0.1
 c4cebba92af964f2d126be90b8a6298c4cf84d45 refs/tags/gix-actor-v0.1.0
 ^13da90b54699a6b500ec5cd7d175f2cd5a1bed06
 0b92c8a256ae06c189e3b9c30b646d62ac8f7d10 refs/tags/gix-actor-v0.1.1\n";
     assert_eq!(
-        packed::Iter::new(packed_refs, HASH_KIND)?.collect::<Result<Vec<_>, _>>()?,
+        packed::Iter::new(packed_refs, HASH_KIND)?.collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             packed::Reference {
                 name: "refs/tags/TEST-0.0.1".try_into()?,
@@ -97,7 +143,8 @@ c4cebba92af964f2d126be90b8a6298c4cf84d45 refs/tags/gix-actor-v0.1.0
 }
 
 #[test]
-fn broken_ref_doesnt_end_the_iteration() -> crate::Result {
+fn broken_ref_doesnt_end_the_iteration() -> Result {
+    let mut error_snapshots = Vec::new();
     let packed_refs = b"916840c0e2f67d370291042cb5274a597f4fa9bc refs/tags/TEST-0.0.1
 buggy-hash refs/wrong
 ^buggy-hash-too
@@ -105,29 +152,30 @@ buggy-hash refs/wrong
     let mut iter = packed::Iter::new(packed_refs, HASH_KIND)?;
 
     assert!(iter.next().expect("first ref").is_ok(), "first line is valid");
-    assert_eq!(
-        iter.next()
-            .expect("second ref")
-            .expect_err("an error is produced")
-            .to_string(),
-        "Invalid reference in line 2: \"buggy-hash refs/wrong\"",
-        "second line is invalid",
-    );
-    assert_eq!(
-        iter.next()
-            .expect("third ref")
-            .expect_err("an error is produced")
-            .to_string(),
-        "Invalid reference in line 3: \"^buggy-hash-too\"",
-        "third line is invalid",
-    );
+    for (line, input) in [(2_u64, b"buggy-hash refs/wrong".as_slice()), (3, b"^buggy-hash-too")] {
+        let err = iter.next().expect("invalid line").expect_err("invalid reference");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(err.is_corrupted());
+        assert_eq!(err.values["line"], gix_error::MetadataValue::from(line));
+        assert_eq!(err.values["input"], gix_error::MetadataValue::from(input));
+    }
     assert!(iter.next().expect("last ref").is_ok(), "last line is valid");
     assert!(iter.next().is_none(), "exhausted");
+    insta::assert_debug_snapshot!(error_snapshots, "broken ref doesnt end the iteration", @r#"
+    [
+        Invalid packed reference, "input"="buggy-hash refs/wrong", "line"=2
+        |
+        └─ Malformed packed reference,
+        Invalid packed reference, "input"="^buggy-hash-too", "line"=3
+        |
+        └─ Malformed packed reference,
+    ]
+    "#);
     Ok(())
 }
 
 #[test]
-fn performance() -> crate::Result {
+fn performance() -> Result {
     let store = store_at("make_repository_with_lots_of_packed_refs.sh")?;
     let start = std::time::Instant::now();
     let actual = store
@@ -145,3 +193,20 @@ fn performance() -> crate::Result {
     );
     Ok(())
 }
+
+#[test]
+fn error_metadata_counts_peeled_lines_and_retains_unterminated_input() -> Result {
+    let input = format!("{0} refs/tags/one\n^{0}\nbroken", HASH_KIND.null());
+    let mut iter = packed::Iter::new(input.as_bytes(), HASH_KIND)?;
+    iter.next().expect("peeled tag")?;
+    let err = iter
+        .next()
+        .expect("last line")
+        .expect_err("malformed reference")
+        .into_error();
+    let details = err.metadata().next().expect("line details survive conversion");
+    assert_eq!(details["line"], gix_error::MetadataValue::from(3_u64));
+    assert_eq!(details["input"], gix_error::MetadataValue::from(b"broken".as_slice()));
+    assert!(iter.next().is_none());
+    Ok(())
+}
diff --git a/gix-ref/tests/refs/packed/mod.rs b/gix-ref/tests/refs/packed/mod.rs
index 698b6e83070..8eb05f6ef1c 100644
--- a/gix-ref/tests/refs/packed/mod.rs
+++ b/gix-ref/tests/refs/packed/mod.rs
@@ -1,6 +1,7 @@
+use crate::Result;
 use std::path::PathBuf;
 
-pub fn write_packed_refs_with(input: &[u8]) -> crate::Result<(gix_testtools::tempfile::TempDir, PathBuf)> {
+pub fn write_packed_refs_with(input: &[u8]) -> Result<(gix_testtools::tempfile::TempDir, PathBuf)> {
     let dir = gix_testtools::tempfile::tempdir()?;
     let packed_refs_path = dir.path().join("packed-refs");
     std::fs::write(&packed_refs_path, input)?;
diff --git a/gix-ref/tests/refs/packed/open.rs b/gix-ref/tests/refs/packed/open.rs
index 74a60ca60f6..1846e8bced7 100644
--- a/gix-ref/tests/refs/packed/open.rs
+++ b/gix-ref/tests/refs/packed/open.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_testtools::fixture_path;
@@ -13,7 +14,7 @@ fn sorted_buffer_works() {
 }
 
 #[test]
-fn empty_buffers_should_not_exist_but_are_fine_to_open() -> crate::Result {
+fn empty_buffers_should_not_exist_but_are_fine_to_open() -> Result {
     let (_keep, path) = write_packed_refs_with(&[])?;
     assert_eq!(gix_ref::packed::Buffer::open(path, 512, HASH_KIND)?.iter()?.count(), 0);
     Ok(())
@@ -28,7 +29,7 @@ fn unsorted_buffers_or_those_without_a_header_can_be_opened_and_searched() {
             HASH_KIND,
         )
         .unwrap();
-        for packed_ref in buffer.iter().unwrap().map(Result::unwrap) {
+        for packed_ref in buffer.iter().unwrap().map(std::result::Result::unwrap) {
             let found_ref = buffer
                 .find(packed_ref.name)
                 .expect("ref can be found as buffer is sorted");
@@ -41,16 +42,20 @@ fn unsorted_buffers_or_those_without_a_header_can_be_opened_and_searched() {
 }
 
 #[test]
-fn bogus_content_triggers_an_error() -> crate::Result {
+fn bogus_content_triggers_an_error() -> Result {
     let packed_refs_data = b"starts with a bogus record, not a header anyway";
     let (_keep, path) = write_packed_refs_with(packed_refs_data)?;
 
-    match gix_ref::packed::Buffer::open(path, 32, HASH_KIND) {
-        Ok(_) => unreachable!("unsorted buffers can't be opened"),
-        Err(err) => assert_eq!(
-            err.to_string(),
-            "The packed-refs file did not have a header or wasn't sorted and could not be iterated"
-        ),
-    }
+    let err = gix_ref::packed::Buffer::open(path, 32, HASH_KIND).expect_err("malformed packed refs");
+    insta::assert_debug_snapshot!(err, "bogus content triggers an error", @r#"
+    Invalid packed reference, "input"="starts with a bogus record, not a header anyway", "line"=1
+    |
+    └─ Malformed packed reference
+    "#);
+    assert!(err.is_corrupted());
+    assert_eq!(
+        err.metadata().next().expect("failed record")["input"],
+        gix_error::MetadataValue::from(packed_refs_data.as_slice())
+    );
     Ok(())
 }
diff --git a/gix-ref/tests/refs/store.rs b/gix-ref/tests/refs/store.rs
index 25695faa92c..7c64e38331d 100644
--- a/gix-ref/tests/refs/store.rs
+++ b/gix-ref/tests/refs/store.rs
@@ -1,7 +1,10 @@
+#[cfg(feature = "parallel")]
+use crate::Result;
+
 #[test]
 #[cfg(feature = "parallel")]
 fn is_send_and_sync() {
-    pub fn store_at(name: &str) -> crate::Result<gix_ref::file::Store> {
+    pub fn store_at(name: &str) -> Result<gix_ref::file::Store> {
         let path = crate::scripted_fixture_read_only(name)?;
         Ok(gix_ref::file::Store::at_opts(
             path.join(".git"),
@@ -13,7 +16,7 @@ fn is_send_and_sync() {
         ))
     }
 
-    pub fn store_with_packed_refs() -> crate::Result<gix_ref::file::Store> {
+    pub fn store_with_packed_refs() -> Result<gix_ref::file::Store> {
         store_at("make_packed_ref_repository.sh")
     }
     fn assert_type<T: Send + Sync>(_t: T) {}
diff --git a/gix-ref/tests/refs/transaction.rs b/gix-ref/tests/refs/transaction.rs
index 9bfee397d06..5467e4162de 100644
--- a/gix-ref/tests/refs/transaction.rs
+++ b/gix-ref/tests/refs/transaction.rs
@@ -1,6 +1,7 @@
 mod refedit {
+    use crate::Result;
     #[test]
-    fn constructors_apply_common_defaults() -> crate::Result {
+    fn constructors_apply_common_defaults() -> Result {
         use gix_ref::{
             FullName, Target,
             transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
@@ -63,6 +64,7 @@ mod refedit {
 }
 
 mod refedit_ext {
+    use crate::Result;
     use std::{cell::RefCell, collections::BTreeMap};
 
     use gix_object::bstr::{BString, ByteSlice};
@@ -99,7 +101,7 @@ mod refedit_ext {
     }
 
     #[test]
-    fn preprocessing_checks_duplicates_after_splits() -> crate::Result {
+    fn preprocessing_checks_duplicates_after_splits() -> Result {
         let store = MockStore::with(Some(("HEAD", Target::Symbolic("refs/heads/main".try_into()?))));
 
         let mut edits = vec![
@@ -110,10 +112,12 @@ mod refedit_ext {
         let err = edits
             .pre_process(&mut |n| store.find_existing(n), &mut |_, e| e)
             .expect_err("duplicate detected");
-        assert_eq!(
-            err.to_string(),
-            "A reference named 'refs/heads/main' has multiple edits"
-        );
+        insta::assert_debug_snapshot!(err, "preprocessing checks duplicates after splits", @r#"
+        Custom {
+            kind: AlreadyExists,
+            error: "A reference named 'refs/heads/main' has multiple edits",
+        }
+        "#);
         Ok(())
     }
 
@@ -129,16 +133,13 @@ mod refedit_ext {
                 .is_ok(),
             "there are no duplicates"
         );
-        assert_eq!(
-            vec![named_edit("HEAD"), named_edit("refs/heads/main"), named_edit("HEAD")]
+        insta::assert_debug_snapshot!(vec![named_edit("HEAD"), named_edit("refs/heads/main"), named_edit("HEAD")]
                 .assure_one_name_has_one_edit()
-                .expect_err("duplicate"),
-            "HEAD",
-            "a correctly named duplicate"
-        );
+                .expect_err("duplicate"), "a correctly named duplicate", @r#""HEAD""#);
     }
 
     mod splitting {
+        use crate::Result;
         use std::cell::Cell;
 
         use gix_ref::{
@@ -153,7 +154,7 @@ mod refedit_ext {
         }
 
         #[test]
-        fn non_symbolic_refs_are_ignored_or_if_the_deref_flag_is_not_set() -> crate::Result {
+        fn non_symbolic_refs_are_ignored_or_if_the_deref_flag_is_not_set() -> Result {
             let store = MockStore::with(Some((
                 "refs/heads/anything-but-not-symbolic",
                 Target::Object(gix_hash::Kind::Sha1.null()),
@@ -188,7 +189,7 @@ mod refedit_ext {
             Ok(())
         }
         #[test]
-        fn empty_inputs_are_ok() -> crate::Result {
+        fn empty_inputs_are_ok() -> Result {
             let store = MockStore::default();
             Vec::<RefEdit>::new()
                 .extend_with_splits_of_symbolic_refs(&mut |n| store.find_existing(n), &mut |_, e| e)
@@ -196,7 +197,7 @@ mod refedit_ext {
         }
 
         #[test]
-        fn symbolic_refs_cycles_are_handled_gracefully() -> crate::Result {
+        fn symbolic_refs_cycles_are_handled_gracefully() -> Result {
             #[derive(Default)]
             struct Cycler {
                 next_item: Cell<bool>,
@@ -232,16 +233,17 @@ mod refedit_ext {
             let err = edits
                 .extend_with_splits_of_symbolic_refs(&mut |n| store.find_existing(n), &mut |_, e| e)
                 .expect_err("cycle detected");
-            assert_eq!(
-                err.to_string(),
-                "Could not follow all splits after 5 rounds, assuming reference cycle"
-            );
+            insta::assert_debug_snapshot!(err, "symbolic refs cycles are handled gracefully", @r#"
+            Custom {
+                kind: WouldBlock,
+                error: "Could not follow all splits after 5 rounds, assuming reference cycle",
+            }
+            "#);
             Ok(())
         }
 
         #[test]
-        fn symbolic_refs_are_split_into_referents_handling_the_reflog_and_previous_values_recursively() -> crate::Result
-        {
+        fn symbolic_refs_are_split_into_referents_handling_the_reflog_and_previous_values_recursively() -> Result {
             let store = MockStore::with(vec![
                 (
                     "refs/heads/delete-symbolic-1",
diff --git a/gix-refspec/Cargo.toml b/gix-refspec/Cargo.toml
index ed56f1b2664..e44a3cce0e7 100644
--- a/gix-refspec/Cargo.toml
+++ b/gix-refspec/Cargo.toml
@@ -23,9 +23,9 @@ sha256 = ["gix-hash/sha256"]
 [dependencies]
 gix-validate = { version = "^0.11.4", path = "../gix-validate" }
 gix-hash = { version = "^0.26.2", path = "../gix-hash" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
-thiserror = "2.0.18"
 smallvec = "1.15.1"
 
 [dev-dependencies]
diff --git a/gix-refspec/src/match_group/validate.rs b/gix-refspec/src/match_group/validate.rs
index 39f83553b23..0adbc0fac30 100644
--- a/gix-refspec/src/match_group/validate.rs
+++ b/gix-refspec/src/match_group/validate.rs
@@ -7,7 +7,11 @@ use crate::{
     match_group::{Source, match_lhs},
 };
 
-/// The error returned [outcome validation](match_lhs::Outcome::validated()).
+/// The error returned by [outcome validation](match_lhs::Outcome::validated()).
+///
+/// Its source is a classification-only [`gix_error::ClassificationMarker`].
+/// Use [`gix_error::classify()`] or `is_validation()` on [`gix_error::Exn`] and [`gix_error::Error`] to check the
+/// classification, without depending on the concrete diagnostic type. Downcast to this type for all issues.
 #[derive(Debug)]
 pub struct Error {
     /// All issues discovered during validation.
@@ -34,7 +38,11 @@ impl std::fmt::Display for Error {
     }
 }
 
-impl std::error::Error for Error {}
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(const { &gix_error::ClassificationMarker::VALIDATION })
+    }
+}
 
 /// All possible issues found while validating matched mappings.
 #[derive(Debug, PartialEq, Eq)]
diff --git a/gix-refspec/src/parse.rs b/gix-refspec/src/parse.rs
index 767b06b1790..aecf6f577b3 100644
--- a/gix-refspec/src/parse.rs
+++ b/gix-refspec/src/parse.rs
@@ -1,34 +1,3 @@
-/// The error returned by the [`parse()`][crate::parse()] function.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Empty refspecs are invalid")]
-    Empty,
-    #[error("Negative refspecs cannot have destinations as they exclude sources")]
-    NegativeWithDestination,
-    #[error("Negative specs must not be empty")]
-    NegativeEmpty,
-    #[error("Negative specs must not be object hashes")]
-    NegativeObjectHash,
-    /// Retained for compatibility; partial negative ref names are accepted and this is no longer returned.
-    #[error("Negative specs must be full ref names, starting with \"refs/\"")]
-    NegativePartialName,
-    /// Retained for compatibility; negative ref patterns containing one `*` are accepted and this is no longer returned.
-    #[error("Negative glob patterns are not allowed")]
-    NegativeGlobPattern,
-    /// Retained for compatibility; invalid fetch destinations are reported as [`Error::ReferenceName`] instead.
-    #[error("Fetch destinations must be ref-names, like 'HEAD:refs/heads/branch'")]
-    InvalidFetchDestination,
-    #[error("Cannot push into an empty destination")]
-    PushToEmpty,
-    #[error("refspec patterns may only contain a single '*' character, found {pattern:?}")]
-    PatternUnsupported { pattern: bstr::BString },
-    #[error("Both sides of a two-sided specification need a pattern, like 'a/*:b/*'")]
-    PatternUnbalanced,
-    #[error(transparent)]
-    ReferenceName(#[from] gix_validate::reference::name::Error),
-}
-
 /// Define how the parsed refspec should be used.
 #[derive(PartialOrd, Ord, PartialEq, Eq, Copy, Clone, Hash, Debug)]
 pub enum Operation {
@@ -39,15 +8,15 @@ pub enum Operation {
 }
 
 pub(crate) mod function {
-    use crate::{
-        RefSpecRef,
-        parse::{Error, Operation},
-        types::Mode,
-    };
+    use crate::{RefSpecRef, parse::Operation, types::Mode};
     use bstr::{BStr, ByteSlice};
+    use gix_error::ErrorExt;
+    use gix_error::ExnMessageResult;
 
     /// Parse `spec` for use in `operation` and return it if it is valid.
-    pub fn parse(mut spec: &BStr, operation: Operation) -> Result<RefSpecRef<'_>, Error> {
+    /// Patterns with more than one `*` include the offending source or destination bytes as `input`
+    /// [metadata](gix_error::Exn::metadata()).
+    pub fn parse(mut spec: &BStr, operation: Operation) -> ExnMessageResult<RefSpecRef<'_>> {
         fn fetch_head_only(mode: Mode) -> RefSpecRef<'static> {
             RefSpecRef {
                 mode,
@@ -69,7 +38,7 @@ pub(crate) mod function {
             Some(_) => Mode::Normal,
             None => {
                 return match operation {
-                    Operation::Push => Err(Error::Empty),
+                    Operation::Push => Err(gix_error::validation("Empty refspecs are invalid").raise()),
                     Operation::Fetch => Ok(fetch_head_only(Mode::Normal)),
                 };
             }
@@ -81,7 +50,10 @@ pub(crate) mod function {
         let (mut src, dst) = match spec.rfind_byte(b':') {
             Some(pos) => {
                 if mode == Mode::Negative {
-                    return Err(Error::NegativeWithDestination);
+                    return Err(gix_error::validation(
+                        "Negative refspecs cannot have destinations as they exclude sources",
+                    )
+                    .raise());
                 }
 
                 let (src, dst) = spec.split_at(pos);
@@ -98,7 +70,9 @@ pub(crate) mod function {
                         Operation::Fetch => (Some("HEAD".into()), Some(dst)),
                     },
                     (Some(src), None) => match operation {
-                        Operation::Push => return Err(Error::PushToEmpty),
+                        Operation::Push => {
+                            return Err(gix_error::validation("Cannot push into an empty destination").raise());
+                        }
                         Operation::Fetch => (Some(src), None),
                     },
                     (Some(src), Some(dst)) => (Some(src), Some(dst)),
@@ -125,17 +99,20 @@ pub(crate) mod function {
             && src_had_pattern != dst_had_pattern
             && !(operation == Operation::Push && dst.is_none())
         {
-            return Err(Error::PatternUnbalanced);
+            return Err(gix_error::validation(
+                "Both sides of a two-sided specification need a pattern, like 'a/*:b/*'",
+            )
+            .raise());
         }
 
         if mode == Mode::Negative {
             match src {
                 Some(spec) => {
                     if looks_like_object_hash(spec) {
-                        return Err(Error::NegativeObjectHash);
+                        return Err(gix_error::validation("Negative specs must not be object hashes").raise());
                     }
                 }
-                None => return Err(Error::NegativeEmpty),
+                None => return Err(gix_error::validation("Negative specs must not be empty").raise()),
             }
         }
 
@@ -151,30 +128,40 @@ pub(crate) mod function {
         spec.len() >= gix_hash::Kind::shortest().len_in_hex() && spec.iter().all(u8::is_ascii_hexdigit)
     }
 
-    fn validate_partial_name_with_single_glob(spec: &BStr) -> Result<(), Error> {
+    fn validate_partial_name_with_single_glob(spec: &BStr) -> ExnMessageResult {
         let mut buf = smallvec::SmallVec::<[u8; 256]>::with_capacity(spec.len());
         buf.extend_from_slice(spec);
         let glob_pos = buf.find_byte(b'*').expect("glob present");
         buf[glob_pos] = b'a';
-        gix_validate::reference::name_partial(buf.as_bstr())?;
+        gix_validate::reference::name_partial(buf.as_bstr()).map_err(|source| {
+            let message = source.to_string();
+            source.and_raise(gix_error::validation(message))
+        })?;
         Ok(())
     }
 
     /// Validate `spec`, and return it along with whether it holds a glob.
     ///
     /// `any_name` skips the check entirely, for the one side Git leaves unchecked.
-    fn validated(spec: Option<&BStr>, any_name: bool) -> Result<(Option<&BStr>, bool), Error> {
+    fn validated(spec: Option<&BStr>, any_name: bool) -> ExnMessageResult<(Option<&BStr>, bool)> {
         match spec {
             Some(spec) => {
                 let glob_count = spec.iter().filter(|b| **b == b'*').take(2).count();
                 if glob_count > 1 {
-                    return Err(Error::PatternUnsupported { pattern: spec.into() });
+                    return Err(
+                        gix_error::validation("refspec patterns may only contain a single '*' character")
+                            .with("input", spec)
+                            .raise(),
+                    );
                 }
                 let has_globs = glob_count > 0;
                 if has_globs {
                     validate_partial_name_with_single_glob(spec)?;
                 } else if !any_name {
-                    gix_validate::reference::name_partial(spec)?;
+                    gix_validate::reference::name_partial(spec).map_err(|source| {
+                        let message = source.to_string();
+                        source.and_raise(gix_error::validation(message))
+                    })?;
                 }
                 Ok((Some(spec), has_globs))
             }
diff --git a/gix-refspec/tests/refspec/match_group.rs b/gix-refspec/tests/refspec/match_group.rs
index 87b36df5759..c8f41c84e7d 100644
--- a/gix-refspec/tests/refspec/match_group.rs
+++ b/gix-refspec/tests/refspec/match_group.rs
@@ -209,38 +209,40 @@ mod multiple {
 
     #[test]
     fn fetch_and_update_with_conflicts() {
-        baseline::agrees_with_fetch_specs_validation_error(
-            [
+        insta::assert_debug_snapshot!(baseline::agrees_with_fetch_specs_validation_error([
                 "refs/heads/f1:refs/remotes/origin/conflict",
                 "refs/heads/f2:refs/remotes/origin/conflict",
-            ],
-            "Found 1 issue that prevents the refspec mapping to be used: \n\tConflicting destination \"refs/remotes/origin/conflict\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict\")",
-        );
-        baseline::agrees_with_fetch_specs_validation_error(
-            [
+            ]), "conflicting destinations identify every contributing refspec", @"
+        Found 1 issue that prevents the refspec mapping to be used:\x20
+        \tConflicting destination \"refs/remotes/origin/conflict\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict\")
+        ");
+        insta::assert_debug_snapshot!(baseline::agrees_with_fetch_specs_validation_error([
                 "refs/heads/f1:refs/remotes/origin/conflict2",
                 "refs/heads/f2:refs/remotes/origin/conflict2",
                 "refs/heads/f1:refs/remotes/origin/conflict",
                 "refs/heads/f2:refs/remotes/origin/conflict",
                 "refs/heads/f3:refs/remotes/origin/conflict",
-            ],
-            "Found 2 issues that prevent the refspec mapping to be used: \n\tConflicting destination \"refs/remotes/origin/conflict\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict\"), refs/heads/f3 (\"refs/heads/f3:refs/remotes/origin/conflict\")\n\tConflicting destination \"refs/remotes/origin/conflict2\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict2\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict2\")",
-        );
-        baseline::agrees_with_fetch_specs_validation_error(
-            [
+            ]), "conflicting destinations identify every contributing refspec", @"
+        Found 2 issues that prevent the refspec mapping to be used:\x20
+        \tConflicting destination \"refs/remotes/origin/conflict\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict\"), refs/heads/f3 (\"refs/heads/f3:refs/remotes/origin/conflict\")
+        \tConflicting destination \"refs/remotes/origin/conflict2\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/conflict2\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/conflict2\")
+        ");
+        insta::assert_debug_snapshot!(baseline::agrees_with_fetch_specs_validation_error([
                 "refs/heads/f1:refs/remotes/origin/same",
                 "refs/tags/v0.0-f1:refs/remotes/origin/same",
-            ],
-            "Found 1 issue that prevents the refspec mapping to be used: \n\tConflicting destination \"refs/remotes/origin/same\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/same\"), refs/tags/v0.0-f1 (\"refs/tags/v0.0-f1:refs/remotes/origin/same\")",
-        );
-        baseline::agrees_with_fetch_specs_validation_error(
-            [
+            ]), "conflicting destinations identify every contributing refspec", @"
+        Found 1 issue that prevents the refspec mapping to be used:\x20
+        \tConflicting destination \"refs/remotes/origin/same\" would be written by refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/same\"), refs/tags/v0.0-f1 (\"refs/tags/v0.0-f1:refs/remotes/origin/same\")
+        ");
+        insta::assert_debug_snapshot!(baseline::agrees_with_fetch_specs_validation_error([
                 "+refs/heads/*:refs/remotes/origin/*",
                 "refs/heads/f1:refs/remotes/origin/f2",
                 "refs/heads/f2:refs/remotes/origin/f1",
-            ],
-            "Found 2 issues that prevent the refspec mapping to be used: \n\tConflicting destination \"refs/remotes/origin/f1\" would be written by refs/heads/f1 (\"+refs/heads/*:refs/remotes/origin/*\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/f1\")\n\tConflicting destination \"refs/remotes/origin/f2\" would be written by refs/heads/f2 (\"+refs/heads/*:refs/remotes/origin/*\"), refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/f2\")",
-        );
+            ]), "conflicting destinations identify every contributing refspec", @"
+        Found 2 issues that prevent the refspec mapping to be used:\x20
+        \tConflicting destination \"refs/remotes/origin/f1\" would be written by refs/heads/f1 (\"+refs/heads/*:refs/remotes/origin/*\"), refs/heads/f2 (\"refs/heads/f2:refs/remotes/origin/f1\")
+        \tConflicting destination \"refs/remotes/origin/f2\" would be written by refs/heads/f2 (\"+refs/heads/*:refs/remotes/origin/*\"), refs/heads/f1 (\"refs/heads/f1:refs/remotes/origin/f2\")
+        ");
     }
 
     #[test]
diff --git a/gix-refspec/tests/refspec/matching.rs b/gix-refspec/tests/refspec/matching.rs
index 7d95a5f7b51..cff0cf79ef2 100644
--- a/gix-refspec/tests/refspec/matching.rs
+++ b/gix-refspec/tests/refspec/matching.rs
@@ -3,9 +3,11 @@ use std::sync::LazyLock;
 static BASELINE: LazyLock<baseline::Baseline> = LazyLock::new(|| baseline::parse().unwrap());
 
 pub mod baseline {
+    use crate::Result;
     use std::{borrow::Borrow, collections::HashMap};
 
     use bstr::{BString, ByteSlice, ByteVec};
+    use gix_error::{Exn, ExnResult};
     use gix_hash::ObjectId;
     use gix_refspec::{
         MatchGroup,
@@ -36,7 +38,7 @@ pub mod baseline {
 
     static INPUT: LazyLock<Vec<Ref>> = LazyLock::new(|| parse_input().unwrap());
 
-    pub type Baseline = HashMap<Vec<BString>, Result<Vec<Mapping>, BString>>;
+    pub type Baseline = HashMap<Vec<BString>, std::result::Result<Vec<Mapping>, BString>>;
 
     #[derive(Debug)]
     pub struct Mapping {
@@ -76,29 +78,24 @@ pub mod baseline {
                     .collect(),
                 fixes: fixes.into_iter().collect(),
             },
-        );
+        )
+        .expect("refspec mappings agree with Git");
     }
 
     pub fn of_objects_always_matches_if_the_server_has_the_object<'a, 'b>(
         specs: impl IntoIterator<Item = &'a str> + Clone,
     ) {
-        check_fetch_remote(specs, Mode::Normal { validate_err: None });
+        check_fetch_remote(specs, Mode::Normal).expect("refspec mappings agree with Git");
     }
 
     pub fn agrees_with_fetch_specs<'a>(specs: impl IntoIterator<Item = &'a str> + Clone) {
-        check_fetch_remote(specs, Mode::Normal { validate_err: None });
+        check_fetch_remote(specs, Mode::Normal).expect("refspec mappings agree with Git");
     }
 
     pub fn agrees_with_fetch_specs_validation_error<'a>(
         specs: impl IntoIterator<Item = &'a str> + Clone,
-        validate_err: impl Into<String>,
-    ) {
-        check_fetch_remote(
-            specs,
-            Mode::Normal {
-                validate_err: Some(validate_err.into()),
-            },
-        );
+    ) -> Exn<gix_refspec::match_group::validate::Error> {
+        check_fetch_remote(specs, Mode::Normal).expect_err("conflicting refspecs fail validation")
     }
 
     /// Here we checked by hand which refs are actually written with a particular refspec
@@ -110,11 +107,14 @@ pub mod baseline {
     }
 
     enum Mode {
-        Normal { validate_err: Option<String> },
+        Normal,
         Custom { expected: Vec<Mapping>, fixes: Vec<Fix> },
     }
 
-    fn check_fetch_remote<'a>(specs: impl IntoIterator<Item = &'a str> + Clone, mode: Mode) {
+    fn check_fetch_remote<'a>(
+        specs: impl IntoIterator<Item = &'a str> + Clone,
+        mode: Mode,
+    ) -> ExnResult<(), gix_refspec::match_group::validate::Error> {
         let match_group = MatchGroup::from_fetch_specs(
             specs
                 .clone()
@@ -130,13 +130,19 @@ pub mod baseline {
 
         let actual = match_group.match_lhs(input()).validated();
         let (actual, expected) = match &mode {
-            Mode::Normal { validate_err } => match validate_err {
-                Some(err_message) => {
-                    assert_eq!(actual.unwrap_err().to_string(), *err_message);
-                    return;
+            Mode::Normal => match actual {
+                Err(err) => {
+                    use gix_error::ErrorExt;
+
+                    let err = err.raise();
+                    assert!(err.is_validation(), "custom mapping errors classify as invalid input");
+                    assert!(
+                        err.probable_cause().is::<gix_refspec::match_group::validate::Error>(),
+                        "the mapping error, not its classification marker, is the probable cause"
+                    );
+                    return Err(err);
                 }
-                None => {
-                    let (actual, fixed) = actual.unwrap();
+                Ok((actual, fixed)) => {
                     assert_eq!(
                         fixed,
                         Vec::<gix_refspec::match_group::validate::Fix>::new(),
@@ -173,6 +179,7 @@ pub mod baseline {
                 }
             }
         }
+        Ok(())
     }
 
     fn source_to_bstring(source: &SourceRef) -> BString {
@@ -182,7 +189,7 @@ pub mod baseline {
         }
     }
 
-    fn parse_input() -> crate::Result<Vec<Ref>> {
+    fn parse_input() -> Result<Vec<Ref>> {
         let dir = gix_testtools::scripted_fixture_read_only("match_baseline.sh")?;
         let refs_buf = std::fs::read(dir.join("clone").join("remote-refs.list"))?;
         let mut out = Vec::new();
@@ -206,7 +213,7 @@ pub mod baseline {
         Ok(out)
     }
 
-    pub(crate) fn parse() -> crate::Result<Baseline> {
+    pub(crate) fn parse() -> Result<Baseline> {
         let dir = gix_testtools::scripted_fixture_read_only("match_baseline.sh")?;
         let buf = std::fs::read(dir.join("clone").join("baseline.git"))?;
 
diff --git a/gix-refspec/tests/refspec/parse/fetch.rs b/gix-refspec/tests/refspec/parse/fetch.rs
index a7d4ab23ce1..936536ddd05 100644
--- a/gix-refspec/tests/refspec/parse/fetch.rs
+++ b/gix-refspec/tests/refspec/parse/fetch.rs
@@ -1,19 +1,29 @@
-use gix_refspec::{
-    Instruction,
-    instruction::Fetch,
-    parse::{Error, Operation},
-};
+use gix_refspec::{Instruction, instruction::Fetch, parse::Operation};
 
-use crate::parse::{assert_parse, b, try_parse};
+use crate::parse::{assert_parse, assert_reference_error, assert_unsupported_pattern, assert_validation, b};
 
 #[test]
 fn revspecs_are_disallowed() {
+    let mut diagnostics = Vec::new();
     for spec in ["main~1", "^@^{}", "HEAD:main~1"] {
-        assert!(matches!(
-            try_parse(spec, Operation::Fetch).unwrap_err(),
-            Error::ReferenceName(_)
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_reference_error(spec, Operation::Fetch),
+            &[],
         ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "revspecs are disallowed", @r#"
+    [
+        Reference name contains invalid byte: "~"
+        |
+        └─ Reference name contains invalid byte: "~",
+        Reference name contains invalid byte: "^"
+        |
+        └─ Reference name contains invalid byte: "^",
+        Reference name contains invalid byte: "~"
+        |
+        └─ Reference name contains invalid byte: "~",
+    ]
+    "#);
 }
 
 #[test]
@@ -40,28 +50,31 @@ fn object_hash_destination_are_valid_as_they_might_be_a_strange_partial_branch_n
 
 #[test]
 fn negative_must_not_be_empty() {
-    assert!(matches!(
-        try_parse("^", Operation::Fetch).unwrap_err(),
-        Error::NegativeEmpty
-    ));
+    insta::assert_debug_snapshot!(assert_validation("^", Operation::Fetch), "negative must not be empty", @"Negative specs must not be empty");
 }
 
 #[test]
 fn negative_must_not_be_object_hash() {
-    assert!(matches!(
-        try_parse("^e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", Operation::Fetch).unwrap_err(),
-        Error::NegativeObjectHash
-    ));
+    insta::assert_debug_snapshot!(assert_validation("^e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", Operation::Fetch), "negative must not be object hash", @"Negative specs must not be object hashes");
 }
 
 #[test]
 fn negative_with_destination() {
+    let mut diagnostics = Vec::new();
     for spec in ["^a:b", "^a:", "^:", "^:b"] {
-        assert!(matches!(
-            try_parse(spec, Operation::Fetch).unwrap_err(),
-            Error::NegativeWithDestination
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_validation(spec, Operation::Fetch),
+            &[],
         ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "negative with destination", @"
+    [
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+    ]
+    ");
 }
 
 #[test]
@@ -183,24 +196,40 @@ fn empty_refspec_is_enough_for_fetching_head_into_fetchhead() {
 
 #[test]
 fn glob_patterns_need_a_destination() {
+    let mut diagnostics = Vec::new();
     for spec in ["refs/heads/*", "refs/heads/*:", ":refs/heads/*"] {
-        assert!(matches!(
-            try_parse(spec, Operation::Fetch).unwrap_err(),
-            Error::PatternUnbalanced
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_validation(spec, Operation::Fetch),
+            &[],
         ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "glob patterns need a destination", @"
+    [
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+    ]
+    ");
 }
 
 #[test]
 fn patterns_with_multiple_asterisks_are_rejected() {
+    let mut diagnostics = Vec::new();
     for spec in [
         "refs/*/foo/*:refs/remotes/origin/*",
         "refs/*/*:refs/remotes/*",
         "a/*/c/*:b/*",
     ] {
-        assert!(matches!(
-            try_parse(spec, Operation::Fetch).unwrap_err(),
-            Error::PatternUnsupported { .. }
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_unsupported_pattern(spec, Operation::Fetch),
+            &[],
         ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "patterns with multiple asterisks are rejected", @r#"
+    [
+        refspec patterns may only contain a single '*' character, "input"="refs/*/foo/*",
+        refspec patterns may only contain a single '*' character, "input"="refs/*/*",
+        refspec patterns may only contain a single '*' character, "input"="a/*/c/*",
+    ]
+    "#);
 }
diff --git a/gix-refspec/tests/refspec/parse/invalid.rs b/gix-refspec/tests/refspec/parse/invalid.rs
index 558e496e250..04175aa1c63 100644
--- a/gix-refspec/tests/refspec/parse/invalid.rs
+++ b/gix-refspec/tests/refspec/parse/invalid.rs
@@ -1,61 +1,84 @@
-use gix_refspec::parse::{Error, Operation};
+use gix_refspec::parse::Operation;
 
-use crate::parse::try_parse;
+use crate::parse::{assert_reference_error, assert_unsupported_pattern, assert_validation};
 
 #[test]
 fn empty() {
-    assert!(matches!(try_parse("", Operation::Push).unwrap_err(), Error::Empty));
+    insta::assert_debug_snapshot!(assert_validation("", Operation::Push), "empty", @"Empty refspecs are invalid");
 }
 
 #[test]
 fn empty_component() {
+    let err = assert_reference_error("refs/heads/test:refs/remotes//test", Operation::Fetch);
+    insta::assert_debug_snapshot!(err, "empty component", @"
+    Reference name cannot contain repeated slashes
+    |
+    └─ Reference name cannot contain repeated slashes
+    ");
     assert!(matches!(
-        try_parse("refs/heads/test:refs/remotes//test", Operation::Fetch).unwrap_err(),
-        Error::ReferenceName(gix_validate::reference::name::Error::RepeatedSlash)
+        err.downcast_any_ref::<gix_validate::reference::name::Error>(),
+        Some(gix_validate::reference::name::Error::RepeatedSlash)
     ));
 }
 
 #[test]
 fn whitespace() {
+    let err = assert_reference_error("refs/heads/test:refs/remotes/ /test", Operation::Fetch);
+    insta::assert_debug_snapshot!(err, "whitespace", @r#"
+    Reference name contains invalid byte: " "
+    |
+    └─ Reference name contains invalid byte: " "
+    "#);
     assert!(matches!(
-        try_parse("refs/heads/test:refs/remotes/ /test", Operation::Fetch).unwrap_err(),
-        Error::ReferenceName(gix_validate::reference::name::Error::InvalidByte { .. })
+        err.downcast_any_ref::<gix_validate::reference::name::Error>(),
+        Some(gix_validate::reference::name::Error::InvalidByte { .. })
     ));
 }
 
 #[test]
 fn destination_cannot_be_a_lone_at_sign() {
+    let mut error_snapshots = Vec::new();
     for op in [Operation::Fetch, Operation::Push] {
+        let err = assert_reference_error("HEAD:@", op);
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         assert!(
             matches!(
-                try_parse("HEAD:@", op).expect_err("a lone '@' is not a valid destination"),
-                Error::ReferenceName(gix_validate::reference::name::Error::Reserved { name }) if name == "@"
+                err.downcast_any_ref::<gix_validate::reference::name::Error>(),
+                Some(gix_validate::reference::name::Error::Reserved { name }) if name == "@"
             ),
             "{op:?} validates refspec destinations"
         );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "destination cannot be a lone at sign", @r#"
+    [
+        Reference name is reserved and cannot be used: "@"
+        |
+        └─ Reference name is reserved and cannot be used: "@",
+        Reference name is reserved and cannot be used: "@"
+        |
+        └─ Reference name is reserved and cannot be used: "@",
+    ]
+    "#);
 }
 
 #[test]
 fn patterns_may_contain_only_one_asterisk() {
+    let mut diagnostics = Vec::new();
     for op in [Operation::Fetch, Operation::Push] {
         for spec in ["a/*/c/*", "a/*/c/*:x/*/y/*", "a**:**b", "+:**/"] {
-            assert!(matches!(
-                try_parse(spec, op).unwrap_err(),
-                Error::PatternUnsupported { .. }
+            diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &assert_unsupported_pattern(spec, op),
+                &[],
             ));
         }
     }
 
-    assert!(matches!(
-        try_parse("^*/*", Operation::Fetch).unwrap_err(),
-        Error::PatternUnsupported { .. }
-    ));
+    insta::assert_debug_snapshot!(assert_unsupported_pattern("^*/*", Operation::Fetch), "patterns may contain only one asterisk", @r#"refspec patterns may only contain a single '*' character, "input"="*/*""#);
     // Negative refspec patterns follow Git's single-asterisk refspec-pattern rule.
     for op in [Operation::Fetch, Operation::Push] {
-        assert!(matches!(
-            try_parse("^refs/heads/qa/*/*", op).unwrap_err(),
-            Error::PatternUnsupported { .. }
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_unsupported_pattern("^refs/heads/qa/*/*", op),
+            &[],
         ));
         for spec in [
             "^refs/heads/a*?",
@@ -63,49 +86,100 @@ fn patterns_may_contain_only_one_asterisk() {
             "^refs/heads/*..bad",
             "^refs/heads/*/",
         ] {
-            assert!(
-                matches!(try_parse(spec, op).unwrap_err(), Error::ReferenceName(_)),
-                "{spec}"
-            );
+            diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &assert_reference_error(spec, op),
+                &[],
+            ));
         }
     }
+    insta::assert_debug_snapshot!(diagnostics, "patterns may contain only one asterisk", @r#"
+    [
+        refspec patterns may only contain a single '*' character, "input"="a/*/c/*",
+        refspec patterns may only contain a single '*' character, "input"="a/*/c/*",
+        refspec patterns may only contain a single '*' character, "input"="a**",
+        refspec patterns may only contain a single '*' character, "input"="**/",
+        refspec patterns may only contain a single '*' character, "input"="a/*/c/*",
+        refspec patterns may only contain a single '*' character, "input"="a/*/c/*",
+        refspec patterns may only contain a single '*' character, "input"="a**",
+        refspec patterns may only contain a single '*' character, "input"="**/",
+        refspec patterns may only contain a single '*' character, "input"="refs/heads/qa/*/*",
+        Reference name contains invalid byte: "?"
+        |
+        └─ Reference name contains invalid byte: "?",
+        Reference name contains invalid byte: "["
+        |
+        └─ Reference name contains invalid byte: "[",
+        Reference name cannot contain repeated dots
+        |
+        └─ Reference name cannot contain repeated dots,
+        Reference name cannot end with a slash
+        |
+        └─ Reference name cannot end with a slash,
+        refspec patterns may only contain a single '*' character, "input"="refs/heads/qa/*/*",
+        Reference name contains invalid byte: "?"
+        |
+        └─ Reference name contains invalid byte: "?",
+        Reference name contains invalid byte: "["
+        |
+        └─ Reference name contains invalid byte: "[",
+        Reference name cannot contain repeated dots
+        |
+        └─ Reference name cannot contain repeated dots,
+        Reference name cannot end with a slash
+        |
+        └─ Reference name cannot end with a slash,
+    ]
+    "#);
 }
 
 #[test]
 fn one_sided_push_patterns_still_use_refspec_pattern_syntax() {
+    let mut diagnostics = Vec::new();
     for spec in ["refs/heads/[ab]*", "refs/heads/a?*", "refs/heads/*..bad"] {
-        assert!(
-            matches!(try_parse(spec, Operation::Push).unwrap_err(), Error::ReferenceName(_)),
-            "{spec} contains syntax Git refspec patterns do not support"
-        );
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_reference_error(spec, Operation::Push),
+            &[],
+        ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "one sided push patterns still use refspec pattern syntax", @r#"
+    [
+        Reference name contains invalid byte: "["
+        |
+        └─ Reference name contains invalid byte: "[",
+        Reference name contains invalid byte: "?"
+        |
+        └─ Reference name contains invalid byte: "?",
+        Reference name cannot contain repeated dots
+        |
+        └─ Reference name cannot contain repeated dots,
+    ]
+    "#);
 }
 
 #[test]
 fn both_sides_need_pattern_if_one_uses_it() {
+    let mut diagnostics = Vec::new();
     // For two-sided refspecs, both sides still need patterns if one uses it
     for op in [Operation::Fetch, Operation::Push] {
         for spec in ["a*:b/c", "a:b/*"] {
-            assert!(
-                matches!(try_parse(spec, op).unwrap_err(), Error::PatternUnbalanced),
-                "{}",
-                spec
-            );
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&assert_validation(spec, op), &[]));
         }
     }
 
-    assert!(matches!(
-        try_parse("refs/*/a", Operation::Fetch).unwrap_err(),
-        Error::PatternUnbalanced
-    ));
+    insta::assert_debug_snapshot!(assert_validation("refs/*/a", Operation::Fetch), "both sides need pattern if one uses it", @"Both sides of a two-sided specification need a pattern, like 'a/*:b/*'");
+    insta::assert_debug_snapshot!(diagnostics, "both sides need pattern if one uses it", @"
+    [
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+    ]
+    ");
 }
 
 #[test]
 fn push_to_empty() {
-    assert!(matches!(
-        try_parse("HEAD:", Operation::Push).unwrap_err(),
-        Error::PushToEmpty
-    ));
+    insta::assert_debug_snapshot!(assert_validation("HEAD:", Operation::Push), "push to empty", @"Cannot push into an empty destination");
 }
 
 #[test]
diff --git a/gix-refspec/tests/refspec/parse/mod.rs b/gix-refspec/tests/refspec/parse/mod.rs
index 29a347e5f5d..97b28e04c95 100644
--- a/gix-refspec/tests/refspec/parse/mod.rs
+++ b/gix-refspec/tests/refspec/parse/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::panic::catch_unwind;
 
 use bstr::ByteSlice;
@@ -58,7 +59,7 @@ fn baseline() {
 }
 
 #[test]
-fn local_and_remote() -> crate::Result {
+fn local_and_remote() -> Result {
     let spec = gix_refspec::parse("remote:local".into(), Operation::Fetch)?;
     assert_eq!(spec.remote(), spec.source());
     assert_eq!(spec.local(), spec.destination());
@@ -74,16 +75,45 @@ mod invalid;
 mod push;
 
 mod util {
+    use gix_error::ExnMessageResult;
     use gix_refspec::{Instruction, RefSpecRef, parse::Operation};
 
     pub fn b(input: &str) -> &bstr::BStr {
         input.into()
     }
 
-    pub fn try_parse(spec: &str, op: Operation) -> Result<RefSpecRef<'_>, gix_refspec::parse::Error> {
+    pub fn try_parse(spec: &str, op: Operation) -> ExnMessageResult<RefSpecRef<'_>> {
         gix_refspec::parse(spec.into(), op)
     }
 
+    pub fn assert_validation(spec: &str, op: Operation) -> gix_error::Exn<gix_error::Message> {
+        let err = try_parse(spec, op).expect_err("refspec is invalid");
+        assert!(err.is_validation(), "invalid refspecs retain their classification");
+        err
+    }
+
+    pub fn assert_reference_error(spec: &str, op: Operation) -> gix_error::Exn<gix_error::Message> {
+        let err = try_parse(spec, op).expect_err("refspec contains an invalid reference name");
+        assert!(
+            err.downcast_any_ref::<gix_validate::reference::name::Error>().is_some(),
+            "the original reference-name validation error is retained"
+        );
+        err
+    }
+
+    pub fn assert_unsupported_pattern(spec: &str, op: Operation) -> gix_error::Exn<gix_error::Message> {
+        let err = assert_validation(spec, op);
+        let Some(gix_error::MetadataValue::Bytes(input)) = err.values.get("input") else {
+            panic!("the unsupported pattern is retained as bytes");
+        };
+        assert!(
+            spec.as_bytes()
+                .windows(input.len())
+                .any(|candidate| candidate == input.as_slice())
+        );
+        err
+    }
+
     pub fn assert_parse<'a>(spec: &'a str, expected: Instruction<'_>) -> RefSpecRef<'a> {
         let spec = try_parse(spec, expected.operation()).expect("no error");
         assert_eq!(spec.instruction(), expected);
diff --git a/gix-refspec/tests/refspec/parse/push.rs b/gix-refspec/tests/refspec/parse/push.rs
index b0f1ea44263..d428d516114 100644
--- a/gix-refspec/tests/refspec/parse/push.rs
+++ b/gix-refspec/tests/refspec/parse/push.rs
@@ -1,34 +1,33 @@
-use crate::parse::{assert_parse, b, try_parse};
-use gix_refspec::{
-    Instruction,
-    instruction::Push,
-    parse::{Error, Operation},
-};
+use crate::parse::{assert_parse, assert_reference_error, assert_validation, b};
+use gix_refspec::{Instruction, instruction::Push, parse::Operation};
 
 #[test]
 fn negative_must_not_be_empty() {
-    assert!(matches!(
-        try_parse("^", Operation::Push).unwrap_err(),
-        Error::NegativeEmpty
-    ));
+    insta::assert_debug_snapshot!(assert_validation("^", Operation::Push), "negative must not be empty", @"Negative specs must not be empty");
 }
 
 #[test]
 fn negative_must_not_be_object_hash() {
-    assert!(matches!(
-        try_parse("^e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", Operation::Push).unwrap_err(),
-        Error::NegativeObjectHash
-    ));
+    insta::assert_debug_snapshot!(assert_validation("^e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", Operation::Push), "negative must not be object hash", @"Negative specs must not be object hashes");
 }
 
 #[test]
 fn negative_with_destination() {
+    let mut diagnostics = Vec::new();
     for spec in ["^a:b", "^a:", "^:", "^:b"] {
-        assert!(matches!(
-            try_parse(spec, Operation::Push).unwrap_err(),
-            Error::NegativeWithDestination
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_validation(spec, Operation::Push),
+            &[],
         ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "negative with destination", @"
+    [
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+        Negative refspecs cannot have destinations as they exclude sources,
+    ]
+    ");
 }
 
 #[test]
@@ -81,18 +80,20 @@ fn revspecs_with_ref_name_destination() {
 
 #[test]
 fn destinations_must_be_ref_names() {
-    assert!(matches!(
-        try_parse("a~1:b~1", Operation::Push).unwrap_err(),
-        Error::ReferenceName(_)
-    ));
+    insta::assert_debug_snapshot!(assert_reference_error("a~1:b~1", Operation::Push), "destinations must be ref names", @r#"
+    Reference name contains invalid byte: "~"
+    |
+    └─ Reference name contains invalid byte: "~"
+    "#);
 }
 
 #[test]
 fn single_refs_must_be_refnames() {
-    assert!(matches!(
-        try_parse("a~1", Operation::Push).unwrap_err(),
-        Error::ReferenceName(_)
-    ));
+    insta::assert_debug_snapshot!(assert_reference_error("a~1", Operation::Push), "single refs must be refnames", @r#"
+    Reference name contains invalid byte: "~"
+    |
+    └─ Reference name contains invalid byte: "~"
+    "#);
 }
 
 #[test]
@@ -170,13 +171,20 @@ fn colon_alone_is_for_pushing_matching_refs() {
 
 #[test]
 fn delete() {
+    let mut diagnostics = Vec::new();
     assert_parse(":a", Instruction::Push(Push::Delete { ref_or_pattern: b("a") }));
     assert_parse("+:a", Instruction::Push(Push::Delete { ref_or_pattern: b("a") }));
 
     for spec in [":refs/heads/*", "+:refs/heads/*"] {
-        assert!(
-            matches!(try_parse(spec, Operation::Push).unwrap_err(), Error::PatternUnbalanced),
-            "deletion destinations cannot be patterns"
-        );
+        diagnostics.push(gix_testtools::redact_debug_snapshot(
+            &assert_validation(spec, Operation::Push),
+            &[],
+        ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "delete", @"
+    [
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+        Both sides of a two-sided specification need a pattern, like 'a/*:b/*',
+    ]
+    ");
 }
diff --git a/gix-revision/fuzz/fuzz_targets/parse.rs b/gix-revision/fuzz/fuzz_targets/parse.rs
index 57472ab587c..4515dcf4e6e 100644
--- a/gix-revision/fuzz/fuzz_targets/parse.rs
+++ b/gix-revision/fuzz/fuzz_targets/parse.rs
@@ -3,7 +3,7 @@ use gix_revision::spec::parse::{delegate, Delegate};
 use libfuzzer_sys::fuzz_target;
 
 use bstr::BStr;
-use gix_error::Exn;
+use gix_error::ExnResult;
 
 fuzz_target!(|data: &[u8]| {
     drop(gix_revision::spec::parse(data.into(), &mut Noop));
@@ -12,37 +12,37 @@ fuzz_target!(|data: &[u8]| {
 struct Noop;
 
 impl Delegate for Noop {
-    fn done(&mut self) -> Result<(), Exn> {
+    fn done(&mut self) -> ExnResult {
         Ok(())
     }
 }
 
 impl delegate::Kind for Noop {
-    fn kind(&mut self, _kind: gix_revision::spec::Kind) -> Result<(), Exn> {
+    fn kind(&mut self, _kind: gix_revision::spec::Kind) -> ExnResult {
         Ok(())
     }
 }
 
 impl delegate::Navigate for Noop {
-    fn traverse(&mut self, _kind: delegate::Traversal) -> Result<(), Exn> {
+    fn traverse(&mut self, _kind: delegate::Traversal) -> ExnResult {
         Ok(())
     }
 
-    fn peel_until(&mut self, _kind: delegate::PeelTo<'_>) -> Result<(), Exn> {
+    fn peel_until(&mut self, _kind: delegate::PeelTo<'_>) -> ExnResult {
         Ok(())
     }
 
-    fn find(&mut self, _regex: &BStr, _negated: bool) -> Result<(), Exn> {
+    fn find(&mut self, _regex: &BStr, _negated: bool) -> ExnResult {
         Ok(())
     }
 
-    fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> Result<(), Exn> {
+    fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> ExnResult {
         Ok(())
     }
 }
 
 impl delegate::Revision for Noop {
-    fn find_ref(&mut self, _name: &BStr) -> Result<(), Exn> {
+    fn find_ref(&mut self, _name: &BStr) -> ExnResult {
         Ok(())
     }
 
@@ -50,19 +50,19 @@ impl delegate::Revision for Noop {
         &mut self,
         _prefix: gix_hash::Prefix,
         _hint: Option<delegate::PrefixHint<'_>>,
-    ) -> Result<(), Exn> {
+    ) -> ExnResult {
         Ok(())
     }
 
-    fn reflog(&mut self, _query: delegate::ReflogLookup) -> Result<(), Exn> {
+    fn reflog(&mut self, _query: delegate::ReflogLookup) -> ExnResult {
         Ok(())
     }
 
-    fn nth_checked_out_branch(&mut self, _branch_no: usize) -> Result<(), Exn> {
+    fn nth_checked_out_branch(&mut self, _branch_no: usize) -> ExnResult {
         Ok(())
     }
 
-    fn sibling_branch(&mut self, _kind: delegate::SiblingBranch) -> Result<(), Exn> {
+    fn sibling_branch(&mut self, _kind: delegate::SiblingBranch) -> ExnResult {
         Ok(())
     }
 }
diff --git a/gix-revision/src/describe.rs b/gix-revision/src/describe.rs
index 37b1be8fbbe..6580831a502 100644
--- a/gix-revision/src/describe.rs
+++ b/gix-revision/src/describe.rs
@@ -127,17 +127,14 @@ impl Default for Options<'_> {
     }
 }
 
-/// The error returned by the [`describe()`](function::describe()) function.
-pub type Error = gix_error::Message;
-
 pub(crate) mod function {
     use std::{borrow::Cow, cmp::Ordering};
 
     use bstr::BStr;
-    use gix_error::{Exn, ResultExt, message};
+    use gix_error::{ExnMessageResult, ResultExt, message};
     use gix_hash::oid;
 
-    use super::{Error, Outcome};
+    use super::Outcome;
     use crate::{
         Graph, PriorityQueue,
         describe::{CommitTime, Flags, MAX_CANDIDATES, Options},
@@ -157,7 +154,7 @@ pub(crate) mod function {
             fallback_to_oid,
             first_parent,
         }: Options<'name>,
-    ) -> Result<Option<Outcome<'name>>, Exn<Error>> {
+    ) -> ExnMessageResult<Option<Outcome<'name>>> {
         let _span = gix_trace::coarse!(
             "gix_revision::describe()",
             commit = %commit,
@@ -299,7 +296,7 @@ pub(crate) mod function {
         commit: gix_hash::ObjectId,
         commit_flags: Flags,
         first_parent: bool,
-    ) -> Result<(), Exn<Error>> {
+    ) -> ExnMessageResult {
         graph
             .insert_parents(
                 &commit,
@@ -319,7 +316,7 @@ pub(crate) mod function {
         graph: &mut Graph<'_, '_, Flags>,
         best_candidate: &mut Candidate<'_>,
         first_parent: bool,
-    ) -> Result<u32, Exn<Error>> {
+    ) -> ExnMessageResult<u32> {
         let mut commits_seen = 0;
         while let Some(commit) = queue.pop_value() {
             commits_seen += 1;
diff --git a/gix-revision/src/merge_base/function.rs b/gix-revision/src/merge_base/function.rs
index f05d30f441b..2e8a33a89d5 100644
--- a/gix-revision/src/merge_base/function.rs
+++ b/gix-revision/src/merge_base/function.rs
@@ -1,9 +1,9 @@
 use std::cmp::Ordering;
 
+use gix_error::{ExnMessageResult, ResultExt, message};
 use gix_hash::ObjectId;
 use gix_revwalk::graph;
 
-use super::{Error, Simple};
 use crate::{Graph, PriorityQueue, merge_base::Flags};
 
 /// Given a commit at `first` id, traverse the commit `graph` and return all possible merge-base between it and `others`,
@@ -28,7 +28,7 @@ pub fn merge_base(
     first: ObjectId,
     others: &[ObjectId],
     graph: &mut Graph<'_, '_, graph::Commit<Flags>>,
-) -> Result<Option<nonempty::NonEmpty<ObjectId>>, Error> {
+) -> ExnMessageResult<Option<nonempty::NonEmpty<ObjectId>>> {
     let _span = gix_trace::coarse!("gix_revision::merge_base()", ?first, ?others);
     if others.is_empty() || others.contains(&first) {
         return Ok(Some(nonempty::NonEmpty::new(first)));
@@ -46,7 +46,7 @@ pub fn merge_base(
 fn remove_redundant(
     commits: &[(ObjectId, GenThenTime)],
     graph: &mut Graph<'_, '_, graph::Commit<Flags>>,
-) -> Result<Vec<ObjectId>, Error> {
+) -> ExnMessageResult<Vec<ObjectId>> {
     if commits.is_empty() {
         return Ok(Vec::new());
     }
@@ -73,7 +73,7 @@ fn remove_redundant(
                         walk_start.push((parent_id, GenThenTime::from(&*parent)));
                     }
                 })
-                .map_err(|_| Simple("could not insert parent commit into graph"))?;
+                .or_raise(|| message("could not insert parent commit into graph"))?;
         }
     }
     walk_start.sort_by_key(|a| a.0);
@@ -126,7 +126,7 @@ fn remove_redundant(
                             stack.push((*parent_id, GenThenTime::from(&*parent)));
                         }
                     })
-                    .map_err(|_| Simple("could not insert parent commit into graph"))?
+                    .or_raise(|| message("could not insert parent commit into graph"))?
                     .is_some()
                 {
                     break;
@@ -207,7 +207,7 @@ fn paint_down_to_common(
     first: ObjectId,
     others: &[ObjectId],
     graph: &mut Graph<'_, '_, graph::Commit<Flags>>,
-) -> Result<Vec<(ObjectId, GenThenTime)>, Error> {
+) -> ExnMessageResult<Vec<(ObjectId, GenThenTime)>> {
     let mut queue = PaintQueue {
         queue: PriorityQueue::new(),
         non_stale: [0; 2],
@@ -216,14 +216,14 @@ fn paint_down_to_common(
         .get_or_insert_full_commit(first, |commit| {
             queue.insert(first, commit, Flags::COMMIT1);
         })
-        .map_err(|_| Simple("could not insert commit into graph"))?;
+        .or_raise(|| message("could not insert commit into graph"))?;
 
     for other in others {
         graph
             .get_or_insert_full_commit(*other, |commit| {
                 queue.insert(*other, commit, Flags::COMMIT2);
             })
-            .map_err(|_| Simple("could not insert commit into graph"))?;
+            .or_raise(|| message("could not insert commit into graph"))?;
     }
 
     let mut out = Vec::new();
@@ -245,7 +245,7 @@ fn paint_down_to_common(
                         queue.insert(parent_id, parent, flags_without_result);
                     }
                 })
-                .map_err(|_| Simple("could not insert parent commit into graph"))?;
+                .or_raise(|| message("could not insert parent commit into graph"))?;
         }
     }
 
diff --git a/gix-revision/src/merge_base/mod.rs b/gix-revision/src/merge_base/mod.rs
index 3599d27c66e..c2921bae514 100644
--- a/gix-revision/src/merge_base/mod.rs
+++ b/gix-revision/src/merge_base/mod.rs
@@ -16,28 +16,15 @@ bitflags::bitflags! {
     }
 }
 
-/// The error returned by the [`merge_base()`][function::merge_base()] function.
-pub type Error = Simple;
-
-/// A simple error type for merge base operations.
-#[derive(Debug)]
-pub struct Simple(pub &'static str);
-
-impl std::fmt::Display for Simple {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.0)
-    }
-}
-
-impl std::error::Error for Simple {}
-
 pub(crate) mod function;
 
 mod octopus {
+    use gix_error::ExnMessageResult;
+
     use gix_hash::ObjectId;
     use gix_revwalk::{Graph, graph};
 
-    use crate::merge_base::{Error, Flags};
+    use crate::merge_base::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.
@@ -51,7 +38,7 @@ mod octopus {
         mut first: ObjectId,
         others: &[ObjectId],
         graph: &mut Graph<'_, '_, graph::Commit<Flags>>,
-    ) -> Result<Option<ObjectId>, Error> {
+    ) -> ExnMessageResult<Option<ObjectId>> {
         for other in others {
             if let Some(next) =
                 crate::merge_base(first, std::slice::from_ref(other), graph)?.map(|bases| *bases.first())
diff --git a/gix-revision/src/spec/parse/delegate.rs b/gix-revision/src/spec/parse/delegate.rs
index f76e2209e75..3c5f1e105a1 100644
--- a/gix-revision/src/spec/parse/delegate.rs
+++ b/gix-revision/src/spec/parse/delegate.rs
@@ -1,5 +1,5 @@
 use bstr::BStr;
-use gix_error::Exn;
+use gix_error::ExnResult;
 
 /// Usually the first methods to call when parsing a rev-spec to set an anchoring revision (which is typically a `Commit` object).
 /// Methods can be called multiple time to either try input or to parse another rev-spec that is part of a range.
@@ -12,22 +12,22 @@ pub trait Revision {
     /// Resolve `name` as reference which might not be a valid reference name. The name may be partial like `main` or full like
     /// `refs/heads/main` solely depending on the users input.
     /// Symbolic referenced should be followed till their object, but objects **must not yet** be peeled.
-    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn>;
+    fn find_ref(&mut self, name: &BStr) -> ExnResult;
 
     /// An object prefix to disambiguate, returning `None` if it is ambiguous or wasn't found at all.
     ///
     /// If `hint` is set, it should be used to disambiguate multiple objects with the same prefix.
-    fn disambiguate_prefix(&mut self, prefix: gix_hash::Prefix, hint: Option<PrefixHint<'_>>) -> Result<(), Exn>;
+    fn disambiguate_prefix(&mut self, prefix: gix_hash::Prefix, hint: Option<PrefixHint<'_>>) -> ExnResult;
 
     /// Lookup the reflog of the previously set reference, or dereference `HEAD` to its reference
     /// to obtain the ref name (as opposed to `HEAD` itself).
     /// If there is no such reflog entry, return `None`.
-    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn>;
+    fn reflog(&mut self, query: ReflogLookup) -> ExnResult;
 
     /// When looking at `HEAD`, `branch_no` is the non-null checkout in the path, e.g. `1` means the last branch checked out,
     /// `2` is the one before that.
     /// Return `None` if there is no branch as the checkout history (via the reflog) isn't long enough.
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn>;
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> ExnResult;
 
     /// Lookup the previously set branch or dereference `HEAD` to its reference to use its name to lookup the sibling branch of `kind`
     /// in the configuration (typically in `refs/remotes/…`). The sibling branches are always local tracking branches.
@@ -35,7 +35,7 @@ pub trait Revision {
     /// of `refs/heads/`.
     /// Note that the caller isn't aware if the previously set reference is a branch or not and might call this method even though no reference
     /// is known.
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn>;
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> ExnResult;
 }
 
 /// Combine one or more specs into a range of multiple.
@@ -49,16 +49,16 @@ pub trait Kind {
     /// and no second specification is provided.
     ///
     /// Note that the method can be called even if other invariants are not fulfilled, treat these as errors.
-    fn kind(&mut self, kind: crate::spec::Kind) -> Result<(), Exn>;
+    fn kind(&mut self, kind: crate::spec::Kind) -> ExnResult;
 }
 
 /// Once an anchor is set one can adjust it using traversal methods.
 pub trait Navigate {
     /// Adjust the current revision to traverse the graph according to `kind`.
-    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn>;
+    fn traverse(&mut self, kind: Traversal) -> ExnResult;
 
     /// Peel the current object until it reached `kind` or `None` if the chain does not contain such object.
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn>;
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> ExnResult;
 
     /// Find the first revision/commit whose message matches the given `regex`.
     /// An empty `regex` matches every message, and `<rev>^{/}` resolves
@@ -67,7 +67,7 @@ pub trait Navigate {
     ///
     /// If no revision is known yet, find the _youngest_ matching commit from _any_ reference, including `HEAD`.
     /// Otherwise, only find commits reachable from the currently set revision.
-    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn>;
+    fn find(&mut self, regex: &BStr, negated: bool) -> ExnResult;
 
     /// Look up the given `path` at the given `stage` in the index returning its blob id,
     /// or return `None` if it doesn't exist at this `stage`.
@@ -77,7 +77,7 @@ pub trait Navigate {
     ///   and 3 being theirs, just like the stages Git records in the index.
     /// * `path` without prefix is relative to the root of the repository, while prefixes like `./` and `../` make it
     ///   relative to the current working directory.
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn>;
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> ExnResult;
 }
 
 /// A hint to make disambiguation when looking up prefixes possible.
diff --git a/gix-revision/src/spec/parse/function.rs b/gix-revision/src/spec/parse/function.rs
index 1549952afd6..f8c8ebb8763 100644
--- a/gix-revision/src/spec/parse/function.rs
+++ b/gix-revision/src/spec/parse/function.rs
@@ -2,10 +2,10 @@ use std::str::FromStr;
 
 use crate::{
     spec,
-    spec::parse::{Delegate, Error, delegate, delegate::SiblingBranch},
+    spec::parse::{Delegate, delegate, delegate::SiblingBranch},
 };
 use bstr::{BStr, BString, ByteSlice, ByteVec};
-use gix_error::{ErrorExt, Exn, ResultExt};
+use gix_error::{ErrorExt, Exn, ExnMessageResult, ExnResult, ResultExt};
 
 /// Parse a git [`revspec`](https://git-scm.com/docs/git-rev-parse#_specifying_revisions) and call `delegate` for each token
 /// successfully parsed.
@@ -13,7 +13,9 @@ use gix_error::{ErrorExt, Exn, ResultExt};
 /// Note that the `delegate` is expected to maintain enough state to lookup revisions properly.
 /// Returns `Ok(())` if all of `input` was consumed, or the error if either the `revspec` syntax was incorrect or
 /// the `delegate` failed to perform the request.
-pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<Error>> {
+/// Errors with input context include the offending or unconsumed `input` bytes as
+/// [metadata](gix_error::Exn::metadata()).
+pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> ExnMessageResult {
     use delegate::{Kind, Revision};
     let mut delegate = InterceptRev::new(delegate);
     let mut prev_kind = None;
@@ -22,7 +24,7 @@ pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<E
         let kind = spec::Kind::ExcludeReachable;
         delegate
             .kind(kind)
-            .or_raise(|| Error::new(format!("delegate.kind({kind:?}) failed")))?;
+            .or_raise(|| gix_error::validation(format!("delegate.kind({kind:?}) failed")))?;
         prev_kind = kind.into();
     }
 
@@ -35,12 +37,12 @@ pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<E
         return if input.is_empty() {
             Ok(())
         } else {
-            Err(Error::new_with_input("unconsumed input", input).raise())
+            Err(gix_error::validation("unconsumed input").with("input", input).raise())
         };
     }
     if let Some((rest, kind)) = try_range(input) {
         if let Some(prev_kind) = prev_kind {
-            return Err(Error::new(format!(
+            return Err(gix_error::validation(format!(
                 "cannot set spec kind more than once (was {prev_kind:?}, now {kind:?})"
             ))
             .raise());
@@ -48,11 +50,11 @@ pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<E
         if !found_revision {
             delegate
                 .find_ref("HEAD".into())
-                .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
+                .or_raise(|| gix_error::validation("delegate did not find the HEAD reference"))?;
         }
         delegate
             .kind(kind)
-            .or_raise(|| Error::new(format!("delegate.kind({kind:?}) failed")))?;
+            .or_raise(|| gix_error::validation(format!("delegate.kind({kind:?}) failed")))?;
         (input, found_revision) = {
             let remainder = revision(rest.as_bstr(), &mut delegate)?;
             (remainder, remainder != rest)
@@ -60,23 +62,23 @@ pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<E
         if !found_revision {
             delegate
                 .find_ref("HEAD".into())
-                .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
+                .or_raise(|| gix_error::validation("delegate did not find the HEAD reference"))?;
         }
     }
 
     if input.is_empty() {
         delegate
             .done()
-            .or_raise(|| Error::new("No revision was produced after all input was consumed"))
+            .or_raise(|| gix_error::validation("No revision was produced after all input was consumed"))
     } else {
-        Err(Error::new_with_input("unconsumed input", input).raise())
+        Err(gix_error::validation("unconsumed input").with("input", input).raise())
     }
 }
 
 mod intercept {
     use crate::spec::parse::{Delegate, delegate};
     use bstr::{BStr, BString};
-    use gix_error::Exn;
+    use gix_error::ExnResult;
 
     #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
     pub(crate) enum PrefixHintOwned {
@@ -133,7 +135,7 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn done(&mut self) -> Result<(), Exn> {
+        fn done(&mut self) -> ExnResult {
             self.done = true;
             self.inner.done()
         }
@@ -143,7 +145,7 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
+        fn find_ref(&mut self, name: &BStr) -> ExnResult {
             self.last_ref = name.to_owned().into();
             self.inner.find_ref(name)
         }
@@ -152,20 +154,20 @@ mod intercept {
             &mut self,
             prefix: gix_hash::Prefix,
             hint: Option<delegate::PrefixHint<'_>>,
-        ) -> Result<(), Exn> {
+        ) -> ExnResult {
             self.last_prefix = Some((prefix, hint.map(Into::into)));
             self.inner.disambiguate_prefix(prefix, hint)
         }
 
-        fn reflog(&mut self, query: delegate::ReflogLookup) -> Result<(), Exn> {
+        fn reflog(&mut self, query: delegate::ReflogLookup) -> ExnResult {
             self.inner.reflog(query)
         }
 
-        fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
+        fn nth_checked_out_branch(&mut self, branch_no: usize) -> ExnResult {
             self.inner.nth_checked_out_branch(branch_no)
         }
 
-        fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Result<(), Exn> {
+        fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> ExnResult {
             self.inner.sibling_branch(kind)
         }
     }
@@ -174,19 +176,19 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn traverse(&mut self, kind: delegate::Traversal) -> Result<(), Exn> {
+        fn traverse(&mut self, kind: delegate::Traversal) -> ExnResult {
             self.inner.traverse(kind)
         }
 
-        fn peel_until(&mut self, kind: delegate::PeelTo<'_>) -> Result<(), Exn> {
+        fn peel_until(&mut self, kind: delegate::PeelTo<'_>) -> ExnResult {
             self.inner.peel_until(kind)
         }
 
-        fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
+        fn find(&mut self, regex: &BStr, negated: bool) -> ExnResult {
             self.inner.find(regex, negated)
         }
 
-        fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
+        fn index_lookup(&mut self, path: &BStr, stage: u8) -> ExnResult {
             self.inner.index_lookup(path, stage)
         }
     }
@@ -195,7 +197,7 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn kind(&mut self, kind: crate::spec::Kind) -> Result<(), Exn> {
+        fn kind(&mut self, kind: crate::spec::Kind) -> ExnResult {
             self.inner.kind(kind)
         }
     }
@@ -208,7 +210,7 @@ trait ResultExt2 {
         F: FnOnce(Exn);
 }
 
-impl ResultExt2 for Result<(), Exn> {
+impl ResultExt2 for ExnResult {
     fn or_else_none<F>(self, f: F) -> Option<()>
     where
         F: FnOnce(Exn),
@@ -286,7 +288,7 @@ fn short_describe_prefix(name: &BStr) -> Option<&BStr> {
 }
 
 type InsideParensRestConsumed<'a> = (std::borrow::Cow<'a, BStr>, &'a BStr, usize);
-fn parens(input: &[u8]) -> Result<Option<InsideParensRestConsumed<'_>>, Error> {
+fn parens(input: &[u8]) -> ExnMessageResult<Option<InsideParensRestConsumed<'_>>> {
     if input.first() != Some(&b'{') {
         return Ok(None);
     }
@@ -343,46 +345,48 @@ fn parens(input: &[u8]) -> Result<Option<InsideParensRestConsumed<'_>>, Error> {
             return Ok(Some((inner, input[idx + 1..].as_bstr(), idx + 1)));
         }
     }
-    Err(Error::new_with_input("unclosed brace pair", input))
+    Err(gix_error::validation("unclosed brace pair").with("input", input).into())
 }
 
-fn try_parse<T: FromStr + PartialEq + Default>(input: &BStr) -> Result<Option<T>, Error> {
-    input
+fn try_parse<T: FromStr + PartialEq + Default>(input: &BStr) -> ExnMessageResult<Option<T>> {
+    Ok(input
         .to_str()
         .ok()
         .and_then(|n| {
             n.parse().ok().map(|n| {
                 if n == T::default() && input[0] == b'-' {
-                    return Err(Error::new_with_input(
-                        "negative zero is invalid - remove the minus sign",
-                        input,
-                    ));
+                    return Err(
+                        gix_error::validation("negative zero is invalid - remove the minus sign").with("input", input),
+                    );
                 }
                 Ok(n)
             })
         })
-        .transpose()
+        .transpose()?)
 }
 
-fn revision<'a, T>(mut input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Exn<Error>>
+fn revision<'a, T>(mut input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> ExnMessageResult<&'a BStr>
 where
     T: Delegate,
 {
     use delegate::{Navigate, Revision};
-    fn consume_all(res: Result<(), Exn>, err: impl FnOnce() -> String) -> Result<&'static BStr, Exn<Error>> {
-        res.map(|_| "".into()).or_raise(|| Error::new(err()))
+    fn consume_all(res: ExnResult, err: impl FnOnce() -> String) -> ExnMessageResult<&'static BStr> {
+        res.map(|_| "".into()).or_raise(|| gix_error::validation(err()))
     }
     match input.as_bytes() {
         [b':'] => {
-            return Err(
-                Error::new("':' must be followed by either slash and regex or path to lookup in HEAD tree").raise(),
-            );
+            return Err(gix_error::validation(
+                "':' must be followed by either slash and regex or path to lookup in HEAD tree",
+            )
+            .raise());
+        }
+        [b':', b'/'] => {
+            return Err(gix_error::validation("':/' must be followed by a regular expression").raise());
         }
-        [b':', b'/'] => return Err(Error::new("':/' must be followed by a regular expression").raise()),
         [b':', b'/', regex @ ..] => {
             let (regex, negated) = parse_regex_prefix(regex.as_bstr())?;
             if regex.is_empty() {
-                return Err(Error::new_with_input("unconsumed input", input).raise());
+                return Err(gix_error::validation("unconsumed input").with("input", input).raise());
             }
             return consume_all(delegate.find(regex, negated), || {
                 format!("Delegate couldn't find '{regex}' (negated: {negated})")
@@ -461,7 +465,7 @@ where
     if name.is_empty() && sep == Some(b'@') && sep_pos.and_then(|pos| input.get(pos + 1)) != Some(&b'{') {
         delegate
             .find_ref("HEAD".into())
-            .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
+            .or_raise(|| gix_error::validation("delegate did not find the HEAD reference"))?;
         sep_pos = sep_pos.map(|pos| pos + 1);
         sep = match sep_pos.and_then(|pos| input.get(pos).copied()) {
             None => return Ok("".into()),
@@ -493,85 +497,95 @@ where
                     }
                 })
             })
-            .ok_or_else(|| Error::new_with_input("couldn't parse revision", input).raise_all(errors))?;
+            .ok_or_else(|| {
+                gix_error::validation("couldn't parse revision")
+                    .with("input", input)
+                    .raise_all(errors)
+            })?;
     }
 
     input = {
         if let Some(b'@') = sep {
             let past_sep = input[sep_pos.map_or(input.len(), |pos| pos + 1)..].as_bstr();
             let (nav, rest, _consumed) = parens(past_sep)?.ok_or_else(|| {
-                Error::new_with_input(
-                    "@ character must be standalone or followed by {<content>}",
-                    &input[sep_pos.unwrap_or(input.len())..],
-                )
+                gix_error::validation("@ character must be standalone or followed by {<content>}")
+                    .with("input", &input[sep_pos.unwrap_or(input.len())..])
             })?;
             let nav = nav.as_ref();
             if let Some(n) = try_parse::<isize>(nav)? {
                 if n < 0 {
                     if name.is_empty() {
                         delegate.nth_checked_out_branch(n.unsigned_abs()).or_raise(|| {
-                            Error::new_with_input(
-                                format!("delegate.nth_checked_out_branch({n:?}) didn't find a branch"),
-                                nav,
-                            )
+                            gix_error::validation(format!(
+                                "delegate.nth_checked_out_branch({n:?}) didn't find a branch"
+                            ))
+                            .with("input", nav)
                         })?;
                     } else {
-                        return Err(Error::new_with_input(
+                        return Err(gix_error::validation(
                             "reference name must be followed by positive numbers in @{n}",
-                            nav,
                         )
+                        .with("input", nav)
                         .raise());
                     }
                 } else if has_ref_or_implied_name {
                     let lookup = if n >= 100000000 {
                         let time = nav
                             .to_str()
-                            .or_raise(|| Error::new_with_input("could not parse time for reflog lookup", nav))
+                            .or_raise(|| {
+                                gix_error::validation("could not parse time for reflog lookup").with("input", nav)
+                            })
                             .and_then(|date| {
-                                gix_date::parse(date, None)
-                                    .or_raise(|| Error::new_with_input("could not parse time for reflog lookup", nav))
+                                gix_date::parse(date, None).or_raise(|| {
+                                    gix_error::validation("could not parse time for reflog lookup").with("input", nav)
+                                })
                             })?;
                         delegate::ReflogLookup::Date(time)
                     } else {
                         delegate::ReflogLookup::Entry(n.try_into().expect("non-negative isize fits usize"))
                     };
-                    delegate
-                        .reflog(lookup)
-                        .or_raise(|| Error::new_with_input(format!("delegate.reflog({lookup:?}) failed"), nav))?;
+                    delegate.reflog(lookup).or_raise(|| {
+                        gix_error::validation(format!("delegate.reflog({lookup:?}) failed")).with("input", nav)
+                    })?;
                 } else {
-                    return Err(Error::new_with_input("reflog entries require a ref name", *name).raise());
+                    return Err(gix_error::validation("reflog entries require a ref name")
+                        .with("input", *name)
+                        .raise());
                 }
             } else if let Some(kind) = SiblingBranch::parse(nav) {
                 if has_ref_or_implied_name {
-                    delegate
-                        .sibling_branch(kind)
-                        .or_raise(|| Error::new_with_input(format!("delegate.sibling_branch({kind:?}) failed"), nav))
+                    delegate.sibling_branch(kind).or_raise(|| {
+                        gix_error::validation(format!("delegate.sibling_branch({kind:?}) failed")).with("input", nav)
+                    })
                 } else {
-                    Err(Error::new_with_input(
+                    Err(gix_error::validation(
                         "sibling branches like 'upstream' or 'push' require a branch name with remote configuration",
-                        *name,
                     )
+                    .with("input", *name)
                     .raise())
                 }?;
             } else if has_ref_or_implied_name {
                 let time = nav
                     .to_str()
-                    .map_err(|_| Error::new_with_input("could not parse time for reflog lookup", nav))
+                    .or_raise(|| gix_error::validation("could not parse time for reflog lookup").with("input", nav))
                     .and_then(|date| {
-                        gix_date::parse(date, Some(gix_date::Zoned::now()))
-                            .map_err(|_| Error::new_with_input("could not parse time for reflog lookup", nav))
+                        gix_date::parse(date, Some(gix_date::Zoned::now())).or_raise(|| {
+                            gix_error::validation("could not parse time for reflog lookup").with("input", nav)
+                        })
                     })?;
                 let lookup = delegate::ReflogLookup::Date(time);
-                delegate
-                    .reflog(lookup)
-                    .or_raise(|| Error::new_with_input(format!("delegate.reflog({lookup:?}) failed"), nav))?;
+                delegate.reflog(lookup).or_raise(|| {
+                    gix_error::validation(format!("delegate.reflog({lookup:?}) failed")).with("input", nav)
+                })?;
             } else {
-                return Err(Error::new_with_input("reflog entries require a ref name", *name).raise());
+                return Err(gix_error::validation("reflog entries require a ref name")
+                    .with("input", *name)
+                    .raise());
             }
             rest
         } else {
             if sep_pos == Some(0) && sep == Some(b'~') {
-                return Err(Error::new("tilde needs to follow an anchor, like @~").raise());
+                return Err(gix_error::validation("tilde needs to follow an anchor, like @~").raise());
             }
             input[sep_pos.unwrap_or(input.len())..].as_bstr()
         }
@@ -580,7 +594,7 @@ where
     navigate(input, delegate)
 }
 
-fn navigate<'a, T>(input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Exn<Error>>
+fn navigate<'a, T>(input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> ExnMessageResult<&'a BStr>
 where
     T: Delegate,
 {
@@ -597,9 +611,9 @@ where
                     .transpose()?
                     .unwrap_or((1, 0));
                 let traversal = delegate::Traversal::NthAncestor(number);
-                delegate
-                    .traverse(traversal)
-                    .or_raise(|| Error::new_with_input(format!("delegate.traverse({traversal:?}) failed"), input))?;
+                delegate.traverse(traversal).or_raise(|| {
+                    gix_error::validation(format!("delegate.traverse({traversal:?}) failed")).with("input", input)
+                })?;
                 cursor += consumed;
             }
             b'^' => {
@@ -613,23 +627,20 @@ where
                             number
                                 .checked_mul(-1)
                                 .ok_or_else(|| {
-                                    Error::new_with_input("could not parse number", past_sep.expect("present"))
+                                    gix_error::validation("could not parse number")
+                                        .with("input", past_sep.expect("present"))
                                 })?
                                 .try_into()
                                 .expect("non-negative"),
                         );
                         delegate.traverse(traversal).or_raise(|| {
-                            Error::new_with_input(
-                                "delegate.traverse({traversal:?}) failed",
-                                past_sep.unwrap_or_default(),
-                            )
+                            gix_error::validation("delegate.traverse({traversal:?}) failed")
+                                .with("input", past_sep.unwrap_or_default())
                         })?;
                         let kind = spec::Kind::RangeBetween;
                         delegate.kind(kind).or_raise(|| {
-                            Error::new_with_input(
-                                format!("delegate.kind({kind:?}) failed"),
-                                past_sep.unwrap_or_default(),
-                            )
+                            gix_error::validation(format!("delegate.kind({kind:?}) failed"))
+                                .with("input", past_sep.unwrap_or_default())
                         })?;
                         if let Some((prefix, hint)) = delegate.last_prefix.take() {
                             match &hint {
@@ -637,24 +648,24 @@ where
                                 None => delegate.disambiguate_prefix(prefix, None),
                             }
                             .or_raise(|| {
-                                Error::new_with_input(
-                                    format!("delegate.disambiguate_prefix({hint:?}) failed"),
-                                    past_sep.unwrap_or_default(),
-                                )
+                                gix_error::validation(format!("delegate.disambiguate_prefix({hint:?}) failed"))
+                                    .with("input", past_sep.unwrap_or_default())
                             })?;
                         } else if let Some(name) = delegate.last_ref.take() {
                             delegate.find_ref(name.as_bstr()).or_raise(|| {
-                                Error::new_with_input(
-                                    format!("delegate.find_ref({name}) failed"),
-                                    past_sep.unwrap_or_default(),
-                                )
+                                gix_error::validation(format!("delegate.find_ref({name}) failed"))
+                                    .with("input", past_sep.unwrap_or_default())
                             })?;
                         } else {
-                            return Err(Error::new_with_input("unconsumed input", &input[cursor..]).raise());
+                            return Err(gix_error::validation("unconsumed input")
+                                .with("input", &input[cursor..])
+                                .raise());
                         }
                         cursor += consumed;
                         let rest = input[cursor..].as_bstr();
-                        delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                        delegate
+                            .done()
+                            .or_raise(|| gix_error::validation(done_msg).with("input", rest))?;
                         return Ok(rest);
                     } else if number == 0 {
                         delegate.peel_until(delegate::PeelTo::ObjectKind(gix_object::Kind::Commit))
@@ -663,7 +674,9 @@ where
                             number.try_into().expect("positive number"),
                         ))
                     }
-                    .or_raise(|| Error::new_with_input("unknown navigation", past_sep.unwrap_or_default()))?;
+                    .or_raise(|| {
+                        gix_error::validation("unknown navigation").with("input", past_sep.unwrap_or_default())
+                    })?;
                     cursor += consumed;
                 } else if let Some((kind, _rest, consumed)) =
                     past_sep.and_then(|past_sep| parens(past_sep).transpose()).transpose()?
@@ -679,41 +692,45 @@ where
                         regex if regex.starts_with(b"/") => {
                             let (regex, negated) = parse_regex_prefix(regex[1..].as_bstr())?;
                             delegate.find(regex, negated).or_raise(|| {
-                                Error::new(format!("Delegate couldn't find '{regex}' (negated: {negated})"))
+                                gix_error::validation(format!("Delegate couldn't find '{regex}' (negated: {negated})"))
                             })?;
                             continue;
                         }
-                        invalid => return Err(Error::new_with_input("cannot peel to unknown target", invalid).raise()),
+                        invalid => {
+                            return Err(gix_error::validation("cannot peel to unknown target")
+                                .with("input", invalid)
+                                .raise());
+                        }
                     };
                     delegate.peel_until(target).or_raise(|| {
-                        Error::new_with_input(
-                            format!("delegate.peel_until({target:?}) failed"),
-                            past_sep.unwrap_or_default(),
-                        )
+                        gix_error::validation(format!("delegate.peel_until({target:?}) failed"))
+                            .with("input", past_sep.unwrap_or_default())
                     })?;
                 } else if past_sep.and_then(<[_]>::first) == Some(&b'!') {
                     let rest = input[cursor + 1..].as_bstr();
                     let kind = spec::Kind::ExcludeReachableFromParents;
+                    delegate.kind(kind).or_raise(|| {
+                        gix_error::validation(format!("delegate.kind({kind:?}) failed")).with("input", rest)
+                    })?;
                     delegate
-                        .kind(kind)
-                        .or_raise(|| Error::new_with_input(format!("delegate.kind({kind:?}) failed"), rest))?;
-                    delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                        .done()
+                        .or_raise(|| gix_error::validation(done_msg).with("input", rest))?;
                     return Ok(rest);
                 } else if past_sep.and_then(<[_]>::first) == Some(&b'@') {
                     let rest = input[cursor + 1..].as_bstr();
                     let kind = spec::Kind::IncludeReachableFromParents;
+                    delegate.kind(kind).or_raise(|| {
+                        gix_error::validation(format!("delegate.kind({kind:?}) failed")).with("input", rest)
+                    })?;
                     delegate
-                        .kind(kind)
-                        .or_raise(|| Error::new_with_input(format!("delegate.kind({kind:?}) failed"), rest))?;
-                    delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                        .done()
+                        .or_raise(|| gix_error::validation(done_msg).with("input", rest))?;
                     return Ok(rest);
                 } else {
                     let parent = delegate::Traversal::NthParent(1);
                     delegate.traverse(parent).or_raise(|| {
-                        Error::new_with_input(
-                            format!("delegate.parent({parent:?}) failed"),
-                            past_sep.unwrap_or_default(),
-                        )
+                        gix_error::validation(format!("delegate.parent({parent:?}) failed"))
+                            .with("input", past_sep.unwrap_or_default())
                     })?;
                 }
             }
@@ -721,7 +738,7 @@ where
                 let to = delegate::PeelTo::Path(input[cursor..].as_bstr());
                 delegate
                     .peel_until(to)
-                    .or_raise(|| Error::new(format!("delegate.peel_until({to:?}) failed")))?;
+                    .or_raise(|| gix_error::validation(format!("delegate.peel_until({to:?}) failed")))?;
                 return Ok("".into());
             }
             _ => return Ok(input[cursor - 1..].as_bstr()),
@@ -730,39 +747,44 @@ where
     Ok("".into())
 }
 
-fn parse_regex_prefix(regex: &BStr) -> Result<(&BStr, bool), Error> {
+fn parse_regex_prefix(regex: &BStr) -> ExnMessageResult<(&BStr, bool)> {
     Ok(match regex.strip_prefix(b"!") {
         Some(regex) if regex.first() == Some(&b'!') => (regex.as_bstr(), false),
         Some(regex) if regex.first() == Some(&b'-') => (regex[1..].as_bstr(), true),
-        Some(_regex) => return Err(Error::new_with_input("need one character after /!, typically -", regex)),
+        Some(_regex) => {
+            return Err(gix_error::validation("need one character after /!, typically -")
+                .with("input", regex)
+                .into());
+        }
         None => (regex, false),
     })
 }
 
-fn try_parse_usize(input: &BStr) -> Result<Option<(usize, usize)>, Error> {
+fn try_parse_usize(input: &BStr) -> ExnMessageResult<Option<(usize, usize)>> {
     let mut bytes = input.iter().peekable();
     if bytes.peek().filter(|&&&b| b == b'-' || b == b'+').is_some() {
-        return Err(Error::new_with_input(
-            "negative or explicitly positive numbers are invalid here",
-            input,
-        ));
+        return Err(
+            gix_error::validation("negative or explicitly positive numbers are invalid here")
+                .with("input", input)
+                .into(),
+        );
     }
     let num_digits = bytes.take_while(|b| b.is_ascii_digit()).count();
     if num_digits == 0 {
         return Ok(None);
     }
     let input = &input[..num_digits];
-    let number = try_parse(input)?.ok_or_else(|| Error::new_with_input("could not parse number", input))?;
+    let number =
+        try_parse(input)?.ok_or_else(|| gix_error::validation("could not parse number").with("input", input))?;
     Ok(Some((number, num_digits)))
 }
 
-fn try_parse_isize(input: &BStr) -> Result<Option<(isize, bool, usize)>, Error> {
+fn try_parse_isize(input: &BStr) -> ExnMessageResult<Option<(isize, bool, usize)>> {
     let mut bytes = input.iter().peekable();
     if bytes.peek().filter(|&&&b| b == b'+').is_some() {
-        return Err(Error::new_with_input(
-            "explicitly positive numbers are invalid here",
-            input,
-        ));
+        return Err(gix_error::validation("explicitly positive numbers are invalid here")
+            .with("input", input)
+            .into());
     }
     let negative = bytes.peek() == Some(&&b'-');
     let num_digits = bytes.take_while(|b| b.is_ascii_digit() || *b == &b'-').count();
@@ -772,7 +794,8 @@ fn try_parse_isize(input: &BStr) -> Result<Option<(isize, bool, usize)>, Error>
         return Ok(Some((-1, negative, num_digits)));
     }
     let input = &input[..num_digits];
-    let number = try_parse(input)?.ok_or_else(|| Error::new_with_input("could not parse number", input))?;
+    let number =
+        try_parse(input)?.ok_or_else(|| gix_error::validation("could not parse number").with("input", input))?;
     Ok(Some((number, negative, num_digits)))
 }
 
diff --git a/gix-revision/src/spec/parse/mod.rs b/gix-revision/src/spec/parse/mod.rs
index d5107dfa00c..379bdec3b0f 100644
--- a/gix-revision/src/spec/parse/mod.rs
+++ b/gix-revision/src/spec/parse/mod.rs
@@ -1,6 +1,4 @@
-use gix_error::Exn;
-/// The error returned by [`spec::parse()`](crate::spec::parse()).
-pub use gix_error::ValidationError as Error;
+use gix_error::ExnResult;
 
 ///
 pub mod delegate;
@@ -15,7 +13,7 @@ pub trait Delegate: delegate::Revision + delegate::Navigate + delegate::Kind {
     /// It can be used as a marker to finalize internal data structures.
     ///
     /// Note that it will not be called if there is unconsumed input.
-    fn done(&mut self) -> Result<(), Exn>;
+    fn done(&mut self) -> ExnResult;
 }
 
 pub(crate) mod function;
diff --git a/gix-revision/tests/revision/describe/mod.rs b/gix-revision/tests/revision/describe/mod.rs
index a39587f1370..af08d180ce3 100644
--- a/gix-revision/tests/revision/describe/mod.rs
+++ b/gix-revision/tests/revision/describe/mod.rs
@@ -1,11 +1,9 @@
-use gix_error::Exn;
 use gix_object::bstr::ByteSlice;
-use gix_revision::{
-    describe,
-    describe::{Error, Outcome},
-};
+use gix_revision::{describe, describe::Outcome};
 use std::{borrow::Cow, path::PathBuf};
 
+use gix_error::ExnMessageResult;
+
 use crate::{hex_to_id, odb_at};
 
 mod format;
@@ -13,10 +11,7 @@ mod format;
 fn run_test(
     transform_odb: impl FnOnce(gix_odb::Handle) -> gix_odb::Handle,
     options: impl Fn(gix_hash::ObjectId) -> gix_revision::describe::Options<'static>,
-    run_assertions: impl Fn(
-        Result<Option<Outcome<'static>>, Exn<Error>>,
-        gix_hash::ObjectId,
-    ) -> Result<(), gix_error::Error>,
+    run_assertions: impl Fn(ExnMessageResult<Option<Outcome<'static>>>, gix_hash::ObjectId) -> Result<(), gix_error::Error>,
 ) -> Result<(), gix_error::Error> {
     let store = branches_odb_at(".");
     let store = transform_odb(store);
diff --git a/gix-revision/tests/revision/merge_base.rs b/gix-revision/tests/revision/merge_base.rs
index 61881e1dd8e..d61d4ccaa55 100644
--- a/gix-revision/tests/revision/merge_base.rs
+++ b/gix-revision/tests/revision/merge_base.rs
@@ -1,9 +1,56 @@
+use crate::Result;
+use gix_error::ExnResult;
 use gix_revision::merge_base;
 
 use crate::odb_at;
 
 #[test]
-fn validate() -> crate::Result {
+fn lookup_failures_retain_their_causes() {
+    let mut error_snapshots = Vec::new();
+    use gix_error::{ErrorExt, ResultExt};
+
+    struct FailingLookup(std::io::ErrorKind);
+
+    impl gix_object::Find for FailingLookup {
+        fn try_find<'a>(
+            &self,
+            _id: &gix_hash::oid,
+            _buffer: &'a mut Vec<u8>,
+        ) -> ExnResult<Option<gix_object::Data<'a>>> {
+            Err(std::io::Error::from(self.0).raise_erased())
+        }
+    }
+
+    for kind in [std::io::ErrorKind::NotFound, std::io::ErrorKind::TimedOut] {
+        let mut graph = gix_revision::Graph::new(FailingLookup(kind), None);
+        let hash = gix_testtools::object_hash();
+        let err = merge_base(hash.null(), &[hash.empty_blob()], &mut graph)
+            .or_erased()
+            .expect_err("the custom object store always fails")
+            .into_error();
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert_eq!(
+            err.downcast_any_ref::<std::io::Error>().map(std::io::Error::kind),
+            Some(kind),
+            "merge-base context preserves the concrete lookup failure"
+        );
+        assert_eq!(err.is_not_found(), kind == std::io::ErrorKind::NotFound);
+        assert_eq!(err.can_retry(), kind == std::io::ErrorKind::TimedOut);
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "lookup failures retain their causes", @"
+    [
+        could not insert commit into graph
+        |
+        └─ entity not found,
+        could not insert commit into graph
+        |
+        └─ timed out,
+    ]
+    ");
+}
+
+#[test]
+fn validate() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_merge_base_repos.sh")?;
     let mut count = 0;
     let odb = odb_at(root.join(".git/objects"))?;
@@ -14,7 +61,8 @@ fn validate() -> crate::Result {
                 .then(|| gix_commitgraph::Graph::from_info_dir(&odb.store_ref().path().join("info")).unwrap());
             for expected in baseline::parse_expectations(&baseline_path)? {
                 let mut graph = gix_revision::Graph::new(&odb, cache.as_ref());
-                let actual = merge_base(expected.first, &expected.others, &mut graph)?;
+                let actual =
+                    merge_base(expected.first, &expected.others, &mut graph).map_err(gix_error::Exn::into_error)?;
                 assert_eq!(
                     actual,
                     expected.bases,
@@ -25,7 +73,8 @@ fn validate() -> crate::Result {
             }
             let mut graph = gix_revision::Graph::new(&odb, cache.as_ref());
             for expected in baseline::parse_expectations(&baseline_path)? {
-                let actual = merge_base(expected.first, &expected.others, &mut graph)?;
+                let actual =
+                    merge_base(expected.first, &expected.others, &mut graph).map_err(gix_error::Exn::into_error)?;
                 assert_eq!(
                     actual,
                     expected.bases,
@@ -41,7 +90,7 @@ fn validate() -> crate::Result {
 }
 
 #[test]
-fn exhausted_side_skips_unrelated_history() -> crate::Result {
+fn exhausted_side_skips_unrelated_history() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_merge_base_repos.sh")?;
     let odb = odb_at(root.join(".git/objects"))?;
     let tip_commit_id = tag_commit_id(&root, "PL")?;
@@ -78,7 +127,7 @@ fn exhausted_side_skips_unrelated_history() -> crate::Result {
 }
 
 #[test]
-fn unreliable_generations_do_not_allow_side_exhaustion() -> crate::Result {
+fn unreliable_generations_do_not_allow_side_exhaustion() -> Result {
     let root = gix_testtools::scripted_fixture_read_only("make_merge_base_repos.sh")?;
     let odb = odb_at(root.join(".git/objects"))?;
     // G and H share B, but clock skew visits B's ancestor E first. Missing,
@@ -107,7 +156,7 @@ fn unreliable_generations_do_not_allow_side_exhaustion() -> crate::Result {
     Ok(())
 }
 
-fn tag_commit_id(root: &std::path::Path, name: &str) -> crate::Result<gix_hash::ObjectId> {
+fn tag_commit_id(root: &std::path::Path, name: &str) -> Result<gix_hash::ObjectId> {
     Ok(gix_hash::ObjectId::from_hex(
         std::fs::read_to_string(root.join(".git/refs/tags").join(name))?
             .trim()
@@ -116,10 +165,11 @@ fn tag_commit_id(root: &std::path::Path, name: &str) -> crate::Result<gix_hash::
 }
 
 mod octopus {
+    use crate::Result;
     use crate::{hex_to_id, odb_at};
 
     #[test]
-    fn three_sequential_commits() -> crate::Result {
+    fn three_sequential_commits() -> Result {
         let odb = octopus_odb_at("three-sequential-commits")?;
         let mut graph = gix_revision::Graph::new(&odb, None);
         let first_commit = hex_to_id("e5d0542bd38431f105a8de8e982b3579647feb9f");
@@ -130,15 +180,17 @@ mod octopus {
         ];
         let mut heap = permutohedron::Heap::new(&mut heads);
         while let Some(heads) = heap.next_permutation() {
-            let actual = gix_revision::merge_base::octopus(*heads.first().unwrap(), &heads[1..], &mut graph)?
-                .expect("a merge base");
+            let actual =
+                gix_revision::merge_base::octopus(*heads.first().expect("three heads"), &heads[1..], &mut graph)
+                    .map_err(gix_error::Exn::into_error)?
+                    .expect("a merge base");
             assert_eq!(actual, first_commit);
         }
         Ok(())
     }
 
     #[test]
-    fn three_parallel_commits() -> crate::Result {
+    fn three_parallel_commits() -> Result {
         let odb = octopus_odb_at("three-parallel-commits")?;
         let mut graph = gix_revision::Graph::new(&odb, None);
         let base = hex_to_id("3ca3e3dd12585fabbef311d524a5e54678090528");
@@ -149,15 +201,17 @@ mod octopus {
         ];
         let mut heap = permutohedron::Heap::new(&mut heads);
         while let Some(heads) = heap.next_permutation() {
-            let actual = gix_revision::merge_base::octopus(*heads.first().unwrap(), &heads[1..], &mut graph)?
-                .expect("a merge base");
+            let actual =
+                gix_revision::merge_base::octopus(*heads.first().expect("three heads"), &heads[1..], &mut graph)
+                    .map_err(gix_error::Exn::into_error)?
+                    .expect("a merge base");
             assert_eq!(actual, base);
         }
         Ok(())
     }
 
     #[test]
-    fn three_forked_commits() -> crate::Result {
+    fn three_forked_commits() -> Result {
         let odb = octopus_odb_at("three-forked-commits")?;
         let mut graph = gix_revision::Graph::new(&odb, None);
         let base = hex_to_id("3ca3e3dd12585fabbef311d524a5e54678090528");
@@ -168,14 +222,16 @@ mod octopus {
         ];
         let mut heap = permutohedron::Heap::new(&mut heads);
         while let Some(heads) = heap.next_permutation() {
-            let actual = gix_revision::merge_base::octopus(*heads.first().unwrap(), &heads[1..], &mut graph)?
-                .expect("a merge base");
+            let actual =
+                gix_revision::merge_base::octopus(*heads.first().expect("three heads"), &heads[1..], &mut graph)
+                    .map_err(gix_error::Exn::into_error)?
+                    .expect("a merge base");
             assert_eq!(actual, base);
         }
         Ok(())
     }
 
-    fn octopus_odb_at(name: &str) -> crate::Result<gix_odb::Handle> {
+    fn octopus_odb_at(name: &str) -> Result<gix_odb::Handle> {
         let root = gix_testtools::scripted_fixture_read_only("merge_base_octopus_repos.sh")?;
         odb_at(root.join(name).join(".git/objects"))
     }
@@ -229,7 +285,7 @@ mod baseline {
 
     pub fn expectation_paths(root: &Path) -> std::io::Result<Vec<PathBuf>> {
         let mut out: Vec<_> = std::fs::read_dir(root)?
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .filter_map(|e| (e.path().extension() == Some(OsStr::new("baseline"))).then(|| e.path()))
             .collect();
         out.sort();
diff --git a/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs b/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
index df6e7d570f6..6a4783a900b 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
@@ -5,8 +5,8 @@ fn braces_must_be_closed() {
     for unclosed_spec in ["@{something", "@{", "@{..@"] {
         let err = try_parse(unclosed_spec).unwrap_err();
         assert_eq!(
-            err.input.as_ref().map(std::convert::AsRef::as_ref),
-            Some(&unclosed_spec.as_bytes()[1..])
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(&unclosed_spec.as_bytes()[1..]))
         );
     }
 }
@@ -76,20 +76,31 @@ fn reflog_by_unix_timestamp_for_current_branch() {
 #[test]
 fn reflog_by_date_with_date_parse_failure() {
     let err = try_parse("@{foo}").unwrap_err();
-    insta::assert_snapshot!(err, @"could not parse time for reflog lookup: \"foo\"");
+    insta::assert_snapshot!(err, @r#"could not parse time for reflog lookup, "input"="foo""#);
 }
 
 #[test]
 fn reflog_by_date_for_hash_is_invalid() {
+    let mut message_diagnostics = Vec::new();
     for (spec, full_name) in [
         ("1234@{42 +0030}", "1234"),
         ("abcd-dirty@{42 +0030}", "abcd-dirty"),
         ("v1.2.3-0-g1234@{42 +0030}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
-        assert!(err.message.contains("reflog entries require a ref name"));
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(full_name.as_bytes()))
+        );
+        message_diagnostics.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(message_diagnostics, "reflog by date for hash is invalid", @r#"
+    [
+        reflog entries require a ref name, "input"="1234",
+        reflog entries require a ref name, "input"="abcd-dirty",
+        reflog entries require a ref name, "input"="v1.2.3-0-g1234",
+    ]
+    "#);
 }
 
 #[test]
@@ -128,15 +139,26 @@ fn reflog_by_entry_for_given_ref_name() {
 
 #[test]
 fn reflog_by_entry_for_hash_is_invalid() {
+    let mut message_diagnostics = Vec::new();
     for (spec, full_name) in [
         ("1234@{0}", "1234"),
         ("abcd-dirty@{1}", "abcd-dirty"),
         ("v1.2.3-0-g1234@{2}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
-        assert!(err.message.contains("reflog entries require a ref name"));
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(full_name.as_bytes()))
+        );
+        message_diagnostics.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(message_diagnostics, "reflog by entry for hash is invalid", @r#"
+    [
+        reflog entries require a ref name, "input"="1234",
+        reflog entries require a ref name, "input"="abcd-dirty",
+        reflog entries require a ref name, "input"="v1.2.3-0-g1234",
+    ]
+    "#);
 }
 
 #[test]
@@ -175,22 +197,33 @@ fn sibling_branch_for_branch_name() {
 
 #[test]
 fn sibling_branch_for_hash_is_invalid() {
+    let mut message_diagnostics = Vec::new();
     for (spec, full_name) in [
         ("1234@{u}", "1234"),
         ("abcd-dirty@{push}", "abcd-dirty"),
         ("v1.2.3-0-g1234@{upstream}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
-        assert!(err.message.contains("sibling branches"));
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(full_name.as_bytes()))
+        );
+        message_diagnostics.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(message_diagnostics, "sibling branch for hash is invalid", @r#"
+    [
+        sibling branches like 'upstream' or 'push' require a branch name with remote configuration, "input"="1234",
+        sibling branches like 'upstream' or 'push' require a branch name with remote configuration, "input"="abcd-dirty",
+        sibling branches like 'upstream' or 'push' require a branch name with remote configuration, "input"="v1.2.3-0-g1234",
+    ]
+    "#);
 }
 
 #[test]
 fn nth_checked_out_branch_for_refname_is_invalid() {
     let err = try_parse("r1@{-1}").unwrap_err();
     // its undefined how to handle negative numbers and specified ref names
-    insta::assert_snapshot!(err, @"reference name must be followed by positive numbers in @{n}: \"-1\"");
+    insta::assert_snapshot!(err, @r#"reference name must be followed by positive numbers in @{n}, "input"="-1""#);
 }
 
 #[test]
@@ -213,7 +246,7 @@ fn nth_checked_out_branch() {
 fn numbers_within_braces_cannot_be_negative_zero() {
     let err = try_parse("@{-0}").unwrap_err();
     // negative zero is not accepted, even though it could easily be defaulted to 0 which is a valid value
-    insta::assert_snapshot!(err, @"negative zero is invalid - remove the minus sign: \"-0\"");
+    insta::assert_snapshot!(err, @r#"negative zero is invalid - remove the minus sign, "input"="-0""#);
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs b/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
index 6ed3ff26d6c..fe81069f12a 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
@@ -110,8 +110,11 @@ fn empty_top_level_regex_are_invalid() {
 #[test]
 fn regex_with_empty_exclamation_mark_prefix_is_invalid() {
     let err = try_parse(r#":/!hello"#).unwrap_err();
-    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"!hello".as_ref()));
-    insta::assert_snapshot!(err, @"need one character after /!, typically -: \"!hello\"");
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"!hello".as_ref()))
+    );
+    insta::assert_snapshot!(err, @r#"need one character after /!, typically -, "input"="!hello""#);
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/anchor/refnames.rs b/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
index 8a403ba64b0..e3496adafa2 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
@@ -35,7 +35,7 @@ fn at_in_ranges_is_allowed() {
 #[test]
 fn strange_revspecs_do_not_panic() {
     let err = try_parse(".@.").unwrap_err();
-    insta::assert_snapshot!(err, @"@ character must be standalone or followed by {<content>}: \"@.\"");
+    insta::assert_snapshot!(err, @r#"@ character must be standalone or followed by {<content>}, "input"="@.""#);
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/kind.rs b/gix-revision/tests/revision/spec/parse/kind.rs
index 43aadaf78f6..0fcee2fb86e 100644
--- a/gix-revision/tests/revision/spec/parse/kind.rs
+++ b/gix-revision/tests/revision/spec/parse/kind.rs
@@ -2,10 +2,23 @@ use crate::spec::parse::{Options, try_parse, try_parse_opts};
 
 #[test]
 fn cannot_declare_ranges_multiple_times() {
+    let mut message_diagnostics = Vec::new();
     for invalid_spec in ["^HEAD..", "^HEAD..."] {
         let err = try_parse(invalid_spec).unwrap_err().into_inner();
-        assert!(err.message.contains("cannot set spec kind more than once"));
+        message_diagnostics.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(message_diagnostics, "cannot declare ranges multiple times", @r#"
+    [
+        Message {
+            message: "cannot set spec kind more than once (was ExcludeReachable, now RangeBetween)",
+            class: Validation,
+        },
+        Message {
+            message: "cannot set spec kind more than once (was ExcludeReachable, now ReachableToMergeBase)",
+            class: Validation,
+        },
+    ]
+    "#);
 }
 
 #[test]
@@ -54,7 +67,13 @@ mod include_parents {
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
         let err = try_parse("r1^@~1").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "trailing caret exclamation mark must end the input", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("~1")},
+        }
+        "#);
     }
 }
 
@@ -99,7 +118,13 @@ mod exclude_parents {
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
         let err = try_parse("r1^!~1").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "trailing caret exclamation mark must end the input", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("~1")},
+        }
+        "#);
     }
 }
 
@@ -228,25 +253,49 @@ mod range {
     #[test]
     fn minus_with_n_omitted_has_to_end_there() {
         let err = try_parse("r1^-^").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "minus with n omitted has to end there", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("^")},
+        }
+        "#);
     }
 
     #[test]
     fn minus_with_n_has_to_end_there() {
         let err = try_parse("r1^-42^").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "minus with n has to end there", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("^")},
+        }
+        "#);
     }
 
     #[test]
     fn minus_with_n_has_to_end_there_and_handle_range_suffix() {
         let err = try_parse("r1^-42..").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "minus with n has to end there and handle range suffix", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("..")},
+        }
+        "#);
     }
 
     #[test]
     fn minus_with_n_omitted_has_to_end_there_and_handle_range_suffix() {
         let err = try_parse("r1^-..").unwrap_err().into_inner();
-        assert!(err.message.contains("unconsumed input"));
+        insta::assert_debug_snapshot!(err, "minus with n omitted has to end there and handle range suffix", @r#"
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("..")},
+        }
+        "#);
     }
 
     #[test]
diff --git a/gix-revision/tests/revision/spec/parse/mod.rs b/gix-revision/tests/revision/spec/parse/mod.rs
index df0abc3e96e..3d6684ab446 100644
--- a/gix-revision/tests/revision/spec/parse/mod.rs
+++ b/gix-revision/tests/revision/spec/parse/mod.rs
@@ -1,4 +1,4 @@
-use gix_error::{ErrorExt, Exn, bail, message};
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, bail, message};
 use gix_object::bstr::{BStr, BString};
 use gix_revision::{
     spec,
@@ -83,7 +83,7 @@ impl Recorder {
     }
 }
 
-fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T) -> Result<(), Exn> {
+fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T) -> ExnResult {
     for entry in store.iter_mut() {
         if entry.is_none() {
             *entry = Some(val);
@@ -94,16 +94,12 @@ fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T
 }
 
 impl delegate::Revision for Recorder {
-    fn find_ref(&mut self, input: &BStr) -> Result<(), Exn> {
+    fn find_ref(&mut self, input: &BStr) -> ExnResult {
         self.called(Call::FindRef);
         set_val("find_ref", &mut self.find_ref, input.into())
     }
 
-    fn disambiguate_prefix(
-        &mut self,
-        input: gix_hash::Prefix,
-        hint: Option<delegate::PrefixHint<'_>>,
-    ) -> Result<(), Exn> {
+    fn disambiguate_prefix(&mut self, input: gix_hash::Prefix, hint: Option<delegate::PrefixHint<'_>>) -> ExnResult {
         self.called(Call::DisambiguatePrefix);
         if self.opts.reject_prefix {
             bail!(message!("disambiguate_prefix rejected").raise_erased());
@@ -125,7 +121,7 @@ impl delegate::Revision for Recorder {
         Ok(())
     }
 
-    fn reflog(&mut self, entry: delegate::ReflogLookup) -> Result<(), Exn> {
+    fn reflog(&mut self, entry: delegate::ReflogLookup) -> ExnResult {
         self.called(Call::Reflog);
         set_val(
             "current_branch_reflog",
@@ -141,26 +137,26 @@ impl delegate::Revision for Recorder {
         )
     }
 
-    fn nth_checked_out_branch(&mut self, branch: usize) -> Result<(), Exn> {
+    fn nth_checked_out_branch(&mut self, branch: usize) -> ExnResult {
         assert_ne!(branch, 0);
         self.called(Call::NthCheckedOutBranch);
         set_val("nth_checked_out_branch", &mut self.nth_checked_out_branch, branch)
     }
 
-    fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Result<(), Exn> {
+    fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> ExnResult {
         self.called(Call::SiblingBranch);
         set_val("sibling_branch", &mut self.sibling_branch, format!("{kind:?}"))
     }
 }
 
 impl delegate::Navigate for Recorder {
-    fn traverse(&mut self, kind: delegate::Traversal) -> Result<(), Exn> {
+    fn traverse(&mut self, kind: delegate::Traversal) -> ExnResult {
         self.called(Call::Traverse);
         self.traversal.push(kind);
         Ok(())
     }
 
-    fn peel_until(&mut self, kind: delegate::PeelTo) -> Result<(), Exn> {
+    fn peel_until(&mut self, kind: delegate::PeelTo) -> ExnResult {
         self.called(Call::PeelUntil);
         self.peel_to.push(match kind {
             delegate::PeelTo::ObjectKind(kind) => PeelToOwned::ObjectKind(kind),
@@ -171,13 +167,13 @@ impl delegate::Navigate for Recorder {
         Ok(())
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> ExnResult {
         self.called(Call::Find);
         self.patterns.push((regex.into(), negated));
         Ok(())
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> ExnResult {
         self.called(Call::IndexLookup);
         self.index_lookups.push((path.into(), stage));
         Ok(())
@@ -185,7 +181,7 @@ impl delegate::Navigate for Recorder {
 }
 
 impl delegate::Kind for Recorder {
-    fn kind(&mut self, kind: spec::Kind) -> Result<(), Exn> {
+    fn kind(&mut self, kind: spec::Kind) -> ExnResult {
         self.called(Call::Kind);
         if self.opts.reject_kind {
             bail!(message!("kind() was rejected").raise_erased());
@@ -200,7 +196,7 @@ impl delegate::Kind for Recorder {
 }
 
 impl Delegate for Recorder {
-    fn done(&mut self) -> Result<(), Exn> {
+    fn done(&mut self) -> ExnResult {
         self.done = true;
         Ok(())
     }
@@ -210,11 +206,11 @@ fn parse(spec: &str) -> Recorder {
     try_parse_opts(spec, Options::default()).unwrap()
 }
 
-fn try_parse(spec: &str) -> Result<Recorder, Exn<spec::parse::Error>> {
+fn try_parse(spec: &str) -> ExnMessageResult<Recorder> {
     try_parse_opts(spec, Default::default())
 }
 
-fn try_parse_opts(spec: &str, options: Options) -> Result<Recorder, Exn<spec::parse::Error>> {
+fn try_parse_opts(spec: &str, options: Options) -> ExnMessageResult<Recorder> {
     let mut rec = Recorder::with(options);
     spec::parse(spec.into(), &mut rec)?;
     Ok(rec)
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 947c157cc99..f6145b20a86 100644
--- a/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
@@ -58,8 +58,17 @@ fn followed_by_zero_is_peeling_to_commit() {
 #[test]
 fn explicitly_positive_numbers_are_invalid() {
     let err = try_parse("@^+1").unwrap_err().into_inner();
-    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"+1".as_ref()));
-    assert!(err.message.contains("positive numbers are invalid"));
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"+1".as_ref()))
+    );
+    insta::assert_debug_snapshot!(err, "explicitly positive numbers are invalid", @r#"
+    Message {
+        message: "explicitly positive numbers are invalid here",
+        class: Validation,
+        values: {"input": Bytes("+1")},
+    }
+    "#);
 }
 
 #[test]
@@ -182,18 +191,35 @@ fn empty_braces_deref_a_tag() {
 #[test]
 fn invalid_object_type() {
     let err = try_parse("@^{invalid}").unwrap_err().into_inner();
-    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"invalid".as_ref()));
-    assert!(err.message.contains("cannot peel"));
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"invalid".as_ref()))
+    );
+    insta::assert_debug_snapshot!(err, "invalid object type", @r#"
+    Message {
+        message: "cannot peel to unknown target",
+        class: Validation,
+        values: {"input": Bytes("invalid")},
+    }
+    "#);
 
     let err = try_parse("@^{Commit}").unwrap_err().into_inner();
+    insta::assert_debug_snapshot!(err, "these types are case sensitive", @r#"
+    Message {
+        message: "cannot peel to unknown target",
+        class: Validation,
+        values: {"input": Bytes("Commit")},
+    }
+    "#);
     assert!(
-        err.input.as_ref().map(AsRef::as_ref) == Some(b"Commit".as_ref()) && err.message.contains("cannot peel"),
+        err.values.get("input") == Some(&gix_error::MetadataValue::from(b"Commit".as_ref())),
         "these types are case sensitive"
     );
 }
 
 #[test]
 fn invalid_caret_without_previous_refname() {
+    let mut message_diagnostics = Vec::new();
     let rec = parse(r"^^");
     assert_eq!(rec.calls, 2);
     assert_eq!(rec.kind, Some(gix_revision::spec::Kind::ExcludeReachable));
@@ -205,39 +231,100 @@ fn invalid_caret_without_previous_refname() {
 
     for revspec in ["^^^HEAD", "^^HEAD"] {
         let err = try_parse(revspec).unwrap_err().into_inner();
-        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"HEAD".as_ref()));
-        assert!(err.message.contains("unconsumed input"));
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(b"HEAD".as_ref()))
+        );
+        message_diagnostics.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(message_diagnostics, "invalid caret without previous refname", @r#"
+    [
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("HEAD")},
+        },
+        Message {
+            message: "unconsumed input",
+            class: Validation,
+            values: {"input": Bytes("HEAD")},
+        },
+    ]
+    "#);
 }
 
 #[test]
 fn incomplete_escaped_braces_in_regex_are_invalid() {
     let err = try_parse(r"@^{/a\{1}}").unwrap_err().into_inner();
-    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"}".as_ref()));
-    assert!(err.message.contains("unconsumed input"));
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"}".as_ref()))
+    );
+    insta::assert_debug_snapshot!(err, "incomplete escaped braces in regex are invalid", @r#"
+    Message {
+        message: "unconsumed input",
+        class: Validation,
+        values: {"input": Bytes("}")},
+    }
+    "#);
 
     let err = try_parse(r"@^{/a{1\}}").unwrap_err().into_inner();
+    insta::assert_debug_snapshot!(err, "incomplete escaped braces in regex are invalid", @r#"
+    Message {
+        message: "unclosed brace pair",
+        class: Validation,
+        values: {"input": Bytes("{/a{1\\}}")},
+    }
+    "#);
     assert!(
-        err.input.as_ref().map(AsRef::as_ref) == Some(br"{/a{1\}}".as_ref()) && err.message.contains("unclosed brace")
+        err.values.get("input") == Some(&gix_error::MetadataValue::from(br"{/a{1\}}".as_ref())),
+        "incomplete escaped braces in regex are invalid"
     );
 }
 
 #[test]
 fn regex_with_empty_exclamation_mark_prefix_is_invalid() {
     let err = try_parse(r#"@^{/!hello}"#).unwrap_err().into_inner();
-    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"!hello".as_ref()));
-    assert!(err.message.contains("need one character after"));
+    assert_eq!(
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(b"!hello".as_ref()))
+    );
+    insta::assert_debug_snapshot!(err, "regex with empty exclamation mark prefix is invalid", @r#"
+    Message {
+        message: "need one character after /!, typically -",
+        class: Validation,
+        values: {"input": Bytes("!hello")},
+    }
+    "#);
 }
 
 #[test]
 fn bad_escapes_can_cause_brace_mismatch() {
     let err = try_parse(r"@^{\}").unwrap_err().into_inner();
-    assert!(err.input.as_ref().map(AsRef::as_ref) == Some(br"{\}".as_ref()) && err.message.contains("unclosed brace"));
+    insta::assert_debug_snapshot!(err, "bad escapes can cause brace mismatch", @r#"
+    Message {
+        message: "unclosed brace pair",
+        class: Validation,
+        values: {"input": Bytes("{\\}")},
+    }
+    "#);
+    assert!(
+        err.values.get("input") == Some(&gix_error::MetadataValue::from(br"{\}".as_ref())),
+        "bad escapes can cause brace mismatch"
+    );
 
     let err = try_parse(r"@^{{\}}").unwrap_err().into_inner();
     // The raw string r"{{\}}" contains actual backslashes, so the input would be r"{{\}}"
+    insta::assert_debug_snapshot!(err, "bad escapes can cause brace mismatch", @r#"
+    Message {
+        message: "unclosed brace pair",
+        class: Validation,
+        values: {"input": Bytes("{{\\}}")},
+    }
+    "#);
     assert!(
-        err.input.as_ref().map(AsRef::as_ref) == Some(br"{{\}}".as_ref()) && err.message.contains("unclosed brace")
+        err.values.get("input") == Some(&gix_error::MetadataValue::from(br"{{\}}".as_ref())),
+        "bad escapes can cause brace mismatch"
     );
 }
 
diff --git a/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs b/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
index 6d314968113..0261b2eb4e1 100644
--- a/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
@@ -5,7 +5,12 @@ use crate::spec::parse::{parse, try_parse};
 #[test]
 fn without_anchor_is_invalid() {
     let err = try_parse("~").unwrap_err().into_inner();
-    assert!(err.message.contains("tilde needs to follow an anchor"));
+    insta::assert_debug_snapshot!(err, "without anchor is invalid", @r#"
+    Message {
+        message: "tilde needs to follow an anchor, like @~",
+        class: Validation,
+    }
+    "#);
 }
 
 #[test]
diff --git a/gix-revwalk/Cargo.toml b/gix-revwalk/Cargo.toml
index 10d18eeef35..e642635e42b 100644
--- a/gix-revwalk/Cargo.toml
+++ b/gix-revwalk/Cargo.toml
@@ -28,7 +28,6 @@ gix-date = { version = "^0.16.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.16.0", path = "../gix-hashtable" }
 gix-commitgraph = { version = "^0.39.0", path = "../gix-commitgraph" }
 
-thiserror = "2.0.18"
 smallvec = "1.15.1"
 
 [dev-dependencies]
diff --git a/gix-revwalk/src/graph/commit.rs b/gix-revwalk/src/graph/commit.rs
index ffb9d5b64af..7a9049a712a 100644
--- a/gix-revwalk/src/graph/commit.rs
+++ b/gix-revwalk/src/graph/commit.rs
@@ -1,4 +1,6 @@
 use gix_date::SecondsSinceUnixEpoch;
+use gix_error::ExnMessageResult;
+use gix_error::ResultExt;
 use smallvec::SmallVec;
 
 use super::LazyCommit;
@@ -18,7 +20,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
     ///
     /// This is the single-most important date for determining recency of commits.
     /// 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> {
+    pub fn committer_timestamp(&self) -> ExnMessageResult<SecondsSinceUnixEpoch> {
         Ok(match &self.backing {
             Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf, self.object_hash)
                 .committer()?
@@ -36,9 +38,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
     }
 
     /// Returns the generation of the commit and its commit-time, either from cache if available, or parsed from the object buffer.
-    pub fn generation_and_timestamp(
-        &self,
-    ) -> Result<(Option<Generation>, SecondsSinceUnixEpoch), gix_object::decode::Error> {
+    pub fn generation_and_timestamp(&self) -> ExnMessageResult<(Option<Generation>, SecondsSinceUnixEpoch)> {
         Ok(match &self.backing {
             Either::Left(buf) => (
                 None,
@@ -59,7 +59,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
 
     /// Convert ourselves into an owned version, which effectively detaches us from the underlying graph.
     /// Use `new_data()` to provide the `data` field for the owned `Commit`.
-    pub fn to_owned<T>(&self, new_data: impl FnOnce() -> T) -> Result<Commit<T>, to_owned::Error> {
+    pub fn to_owned<T>(&self, new_data: impl FnOnce() -> T) -> ExnMessageResult<Commit<T>> {
         let data = new_data();
         Ok(match &self.backing {
             Either::Left(buf) => {
@@ -68,7 +68,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
                 let mut parents = SmallVec::default();
                 let mut timestamp = None;
                 for token in iter {
-                    match token? {
+                    match token.or_raise(|| gix_error::corruption("A commit could not be decoded during traversal"))? {
                         Token::Tree { .. } => {}
                         Token::Parent { id } => parents.push(id),
                         Token::Author { .. } => {}
@@ -94,15 +94,18 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
                 let mut parents = SmallVec::default();
                 let commit = cache.commit_at(*pos);
                 for pos in commit.iter_parents() {
-                    let pos = pos?;
+                    let pos = pos.or_raise(|| {
+                        gix_error::corruption("Could not find commit position in graph when traversing parents")
+                    })?;
                     parents.push(cache.commit_at(pos).id().to_owned());
                 }
+                let actual = commit.committer_timestamp();
                 Commit {
                     parents,
-                    commit_time: commit.committer_timestamp().try_into().map_err(|_| {
-                        to_owned::Error::CommitGraphTime {
-                            actual: commit.committer_timestamp(),
-                        }
+                    commit_time: SecondsSinceUnixEpoch::try_from(actual).or_raise(|| {
+                        gix_error::corruption(format!(
+                            "Commit-graph time could not be presented as signed integer: {actual}"
+                        ))
                     })?,
                     generation: Some(commit.generation()),
                     data,
@@ -124,7 +127,7 @@ pub struct Parents<'graph, 'cache> {
 }
 
 impl Iterator for Parents<'_, '_> {
-    type Item = Result<gix_hash::ObjectId, iter_parents::Error>;
+    type Item = ExnMessageResult<gix_hash::ObjectId>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match &mut self.backing {
@@ -134,42 +137,19 @@ impl Iterator for Parents<'_, '_> {
                         Ok(gix_object::commit::ref_iter::Token::Tree { .. }) => continue,
                         Ok(gix_object::commit::ref_iter::Token::Parent { id }) => return Some(Ok(id)),
                         Ok(_unused_token) => break,
-                        Err(err) => return Some(Err(err.into())),
+                        Err(err) => {
+                            return Some(Err(
+                                err.raise(gix_error::corruption("An error occurred when parsing commit parents"))
+                            ));
+                        }
                     }
                 }
                 None
             }
-            Either::Right((cache, it)) => it
-                .next()
-                .map(|r| r.map(|pos| cache.id_at(pos).to_owned()).map_err(Into::into)),
+            Either::Right((cache, it)) => it.next().map(|r| {
+                r.map(|pos| cache.id_at(pos).to_owned())
+                    .or_raise(|| gix_error::corruption("An error occurred when parsing parents from the commit graph"))
+            }),
         }
     }
 }
-
-///
-pub mod iter_parents {
-    /// The error returned by the [`Parents`][super::Parents] iterator.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An error occurred when parsing commit parents")]
-        DecodeCommit(#[from] gix_object::decode::Error),
-        #[error("An error occurred when parsing parents from the commit graph")]
-        DecodeCommitGraph(#[from] gix_error::Message),
-    }
-}
-
-///
-pub mod to_owned {
-    /// The error returned by [`to_owned()`][crate::graph::LazyCommit::to_owned()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("A commit could not be decoded during traversal")]
-        Decode(#[from] gix_object::decode::Error),
-        #[error("Could not find commit position in graph when traversing parents")]
-        CommitGraphParent(#[from] gix_error::Message),
-        #[error("Commit-graph time could not be presented as signed integer: {actual}")]
-        CommitGraphTime { actual: u64 },
-    }
-}
diff --git a/gix-revwalk/src/graph/mod.rs b/gix-revwalk/src/graph/mod.rs
index 76501ede34e..9cfa78d0876 100644
--- a/gix-revwalk/src/graph/mod.rs
+++ b/gix-revwalk/src/graph/mod.rs
@@ -1,5 +1,6 @@
 use std::{fmt::Formatter, ops::Index};
 
+use gix_error::{ErrorExt, ExnResult, ResultExt};
 use gix_hash::oid;
 use smallvec::SmallVec;
 
@@ -11,40 +12,6 @@ pub type IdMap<T> = gix_hashtable::HashMap<gix_hash::ObjectId, T>;
 ///
 pub mod commit;
 
-mod errors {
-    ///
-    pub mod insert_parents {
-        use crate::graph::commit::iter_parents;
-
-        /// The error returned by [`insert_parents()`](crate::Graph::insert_parents()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            Lookup(#[from] gix_object::find::existing_iter::Error),
-            #[error("A commit could not be decoded during traversal")]
-            Decode(#[from] gix_object::decode::Error),
-            #[error(transparent)]
-            Parent(#[from] iter_parents::Error),
-        }
-    }
-
-    ///
-    pub mod get_or_insert_default {
-        use crate::graph::commit::to_owned;
-
-        /// The error returned by [`try_lookup_or_insert_default()`](crate::Graph::try_lookup_or_insert_default()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            Lookup(#[from] gix_object::find::existing_iter::Error),
-            #[error(transparent)]
-            ToOwned(#[from] to_owned::Error),
-        }
-    }
-}
-pub use errors::{get_or_insert_default, insert_parents};
 use gix_date::SecondsSinceUnixEpoch;
 
 /// The generation away from the HEAD of graph, useful to limit algorithms by topological depth as well.
@@ -68,7 +35,7 @@ impl<'cache, T: Default> Graph<'_, 'cache, T> {
         &mut self,
         id: gix_hash::ObjectId,
         update_data: impl FnOnce(&mut T),
-    ) -> Result<Option<LazyCommit<'_, 'cache>>, get_or_insert_default::Error> {
+    ) -> ExnResult<Option<LazyCommit<'_, 'cache>>> {
         self.try_lookup_or_insert_default(id, T::default, update_data)
     }
 }
@@ -114,7 +81,7 @@ impl<'cache, T> Graph<'_, 'cache, T> {
         mut make_data: impl FnMut(LazyCommit<'_, 'cache>) -> Result<T, E>,
     ) -> Result<Option<T>, E>
     where
-        E: From<gix_object::find::existing_iter::Error>,
+        E: From<gix_error::Exn>,
     {
         let value = make_data(self.lookup(&id).map_err(E::from)?)?;
         Ok(self.map.insert(id, value))
@@ -135,11 +102,11 @@ impl<'cache, T> Graph<'_, 'cache, T> {
         new_parent_data: &mut dyn FnMut(gix_hash::ObjectId, SecondsSinceUnixEpoch) -> T,
         update_existing: &mut dyn FnMut(gix_hash::ObjectId, &mut T),
         first_parent: bool,
-    ) -> Result<(), insert_parents::Error> {
+    ) -> ExnResult {
         let commit = self.lookup(id)?;
         let parents: SmallVec<[_; 2]> = commit.iter_parents().collect();
         for parent_id in parents {
-            let parent_id = parent_id?;
+            let parent_id = parent_id.or_erased()?;
             match self.map.entry(parent_id) {
                 gix_hashtable::hash_map::Entry::Vacant(entry) => {
                     let parent = match try_lookup(&parent_id, &*self.find, self.cache, &mut self.parent_buf)? {
@@ -173,9 +140,7 @@ impl<'cache, T> Graph<'_, 'cache, T> {
         parent_data: &mut dyn FnMut(gix_hash::ObjectId, LazyCommit<'_, 'cache>, Option<&mut T>) -> Result<T, E>,
     ) -> Result<(), E>
     where
-        E: From<gix_object::find::existing_iter::Error>
-            + From<gix_object::decode::Error>
-            + From<commit::iter_parents::Error>,
+        E: From<gix_error::Exn> + From<gix_error::Exn<gix_error::Message>>,
     {
         let commit = self.lookup(id).map_err(E::from)?;
         let parents: SmallVec<[_; 2]> = commit.iter_parents().collect();
@@ -237,7 +202,7 @@ impl<T> Graph<'_, '_, Commit<T>> {
         id: gix_hash::ObjectId,
         new_data: impl FnOnce() -> T,
         update_data: impl FnOnce(&mut T),
-    ) -> Result<Option<&mut Commit<T>>, get_or_insert_default::Error> {
+    ) -> ExnResult<Option<&mut Commit<T>>> {
         match self.map.entry(id) {
             gix_hashtable::hash_map::Entry::Vacant(entry) => {
                 let res = try_lookup(&id, &*self.find, self.cache, &mut self.buf)?;
@@ -245,7 +210,7 @@ impl<T> Graph<'_, '_, Commit<T>> {
                     None => return Ok(None),
                     Some(commit) => commit,
                 };
-                let mut commit = commit.to_owned(new_data)?;
+                let mut commit = commit.to_owned(new_data).or_erased()?;
                 update_data(&mut commit.data);
                 entry.insert(commit);
             }
@@ -276,7 +241,7 @@ impl<T: Default> Graph<'_, '_, Commit<T>> {
         &mut self,
         id: gix_hash::ObjectId,
         update_data: impl FnOnce(&mut T),
-    ) -> Result<Option<&mut Commit<T>>, get_or_insert_default::Error> {
+    ) -> ExnResult<Option<&mut Commit<T>>> {
         self.get_or_insert_commit_default(id, T::default, update_data)
     }
 
@@ -288,7 +253,7 @@ impl<T: Default> Graph<'_, '_, Commit<T>> {
         &mut self,
         id: gix_hash::ObjectId,
         update_commit: impl FnOnce(&mut Commit<T>),
-    ) -> Result<Option<&mut Commit<T>>, get_or_insert_default::Error> {
+    ) -> ExnResult<Option<&mut Commit<T>>> {
         match self.map.entry(id) {
             gix_hashtable::hash_map::Entry::Vacant(entry) => {
                 let res = try_lookup(&id, &*self.find, self.cache, &mut self.buf)?;
@@ -296,7 +261,7 @@ impl<T: Default> Graph<'_, '_, Commit<T>> {
                     None => return Ok(None),
                     Some(commit) => commit,
                 };
-                let mut commit = commit.to_owned(T::default)?;
+                let mut commit = commit.to_owned(T::default).or_erased()?;
                 update_commit(&mut commit);
                 entry.insert(commit);
             }
@@ -325,7 +290,7 @@ impl<'cache, T> Graph<'_, 'cache, T> {
         id: gix_hash::ObjectId,
         default: impl FnOnce() -> T,
         update_data: impl FnOnce(&mut T),
-    ) -> Result<Option<LazyCommit<'_, 'cache>>, get_or_insert_default::Error> {
+    ) -> ExnResult<Option<LazyCommit<'_, 'cache>>> {
         let res = try_lookup(&id, &*self.find, self.cache, &mut self.buf)?;
         Ok(res.inspect(|_commit| match self.map.entry(id) {
             gix_hashtable::hash_map::Entry::Vacant(entry) => {
@@ -343,20 +308,14 @@ impl<'cache, T> Graph<'_, 'cache, T> {
     /// or isn't a commit.
     ///
     /// It's possible that commits don't exist if the repository is shallow.
-    pub fn try_lookup(
-        &mut self,
-        id: &gix_hash::oid,
-    ) -> Result<Option<LazyCommit<'_, 'cache>>, gix_object::find::existing_iter::Error> {
+    pub fn try_lookup(&mut self, id: &gix_hash::oid) -> ExnResult<Option<LazyCommit<'_, 'cache>>> {
         try_lookup(id, &*self.find, self.cache, &mut self.buf)
     }
 
     /// Lookup `id` and return a handle to it, or fail if it doesn't exist or is no commit.
-    pub fn lookup(
-        &mut self,
-        id: &gix_hash::oid,
-    ) -> Result<LazyCommit<'_, 'cache>, gix_object::find::existing_iter::Error> {
+    pub fn lookup(&mut self, id: &gix_hash::oid) -> ExnResult<LazyCommit<'_, 'cache>> {
         self.try_lookup(id)?
-            .ok_or(gix_object::find::existing_iter::Error::NotFound { oid: id.to_owned() })
+            .ok_or_else(|| gix_error::not_found(format!("An object with id {id} could not be found")).raise_erased())
     }
 }
 
@@ -365,7 +324,7 @@ fn try_lookup<'graph, 'cache>(
     objects: &dyn gix_object::Find,
     cache: Option<&'cache gix_commitgraph::Graph>,
     buf: &'graph mut Vec<u8>,
-) -> Result<Option<LazyCommit<'graph, 'cache>>, gix_object::find::existing_iter::Error> {
+) -> ExnResult<Option<LazyCommit<'graph, 'cache>>> {
     if let Some(cache) = cache
         && let Some(pos) = cache.lookup(id)
     {
@@ -374,18 +333,13 @@ fn try_lookup<'graph, 'cache>(
             backing: Either::Right((cache, pos)),
         }));
     }
-    Ok(
-        match objects
-            .try_find(id, buf)
-            .map_err(gix_object::find::existing_iter::Error::Find)?
-        {
-            Some(data) => data.kind.is_commit().then_some(LazyCommit {
-                object_hash: data.object_hash,
-                backing: Either::Left(buf),
-            }),
-            None => None,
-        },
-    )
+    Ok(match objects.try_find(id, buf)? {
+        Some(data) => data.kind.is_commit().then_some(LazyCommit {
+            object_hash: data.object_hash,
+            backing: Either::Left(buf),
+        }),
+        None => None,
+    })
 }
 
 impl<'a, T> Index<&'a gix_hash::oid> for Graph<'_, '_, T> {
diff --git a/gix-sec/tests/sec/identity.rs b/gix-sec/tests/sec/identity.rs
index ee4c3355840..41a0ca0b388 100644
--- a/gix-sec/tests/sec/identity.rs
+++ b/gix-sec/tests/sec/identity.rs
@@ -1,5 +1,6 @@
+use crate::Result;
 #[test]
-fn is_path_owned_by_current_user() -> crate::Result {
+fn is_path_owned_by_current_user() -> Result {
     let dir = tempfile::tempdir()?;
     let file = dir.path().join("file");
     std::fs::write(&file, [])?;
@@ -13,7 +14,7 @@ fn is_path_owned_by_current_user() -> crate::Result {
 /// owned by that user even if its target is owned by someone else.
 #[test]
 #[cfg(all(unix, not(target_os = "wasi")))]
-fn symlink_ownership_checks_inspect_the_link_itself() -> crate::Result {
+fn symlink_ownership_checks_inspect_the_link_itself() -> Result {
     use std::os::unix::fs as unix_fs;
     use std::os::unix::fs::MetadataExt;
 
@@ -39,7 +40,7 @@ fn symlink_ownership_checks_inspect_the_link_itself() -> crate::Result {
 
 #[test]
 #[cfg(windows)]
-fn windows_home() -> crate::Result {
+fn windows_home() -> Result {
     let home = gix_path::env::home_dir().expect("home dir is available");
     assert!(gix_sec::identity::is_path_owned_by_current_user(&home)?);
     Ok(())
@@ -52,7 +53,7 @@ fn windows_home() -> crate::Result {
 /// first suitable path. It remains a successful no-op when the environment provides no such path.
 #[test]
 #[cfg(windows)]
-fn windows_foreign_owned_path_is_not_owned_by_current_user() -> crate::Result {
+fn windows_foreign_owned_path_is_not_owned_by_current_user() -> Result {
     use std::path::{Path, PathBuf};
 
     #[cfg(windows)]
@@ -139,7 +140,7 @@ fn windows_foreign_owned_path_is_not_owned_by_current_user() -> crate::Result {
         }
     }
 
-    fn assert_reduced(path: &Path) -> crate::Result {
+    fn assert_reduced(path: &Path) -> Result {
         eprintln!(
             "checking independently verified foreign-owned path '{}'",
             path.display()
diff --git a/gix-shallow/Cargo.toml b/gix-shallow/Cargo.toml
index 50dd8d51be7..c717a572b7f 100644
--- a/gix-shallow/Cargo.toml
+++ b/gix-shallow/Cargo.toml
@@ -26,8 +26,8 @@ serde = ["dep:serde", "gix-hash/serde", "nonempty/serialize"]
 [dependencies]
 gix-hash = { version = "^0.26.0", path = "../gix-hash" }
 gix-lock = { version = "^24.0.0", path = "../gix-lock" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 
-thiserror = "2.0.18"
 bstr = { version = "1.12.0", default-features = false }
 nonempty = "0.12.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
@@ -37,3 +37,4 @@ features = ["sha1"]
 
 [dev-dependencies]
 tempfile = "3.26.0"
+gix-hash = { path = "../gix-hash", features = ["sha1", "sha256"] }
diff --git a/gix-shallow/src/lib.rs b/gix-shallow/src/lib.rs
index 2c5d2c3b3c2..f8b65b8439e 100644
--- a/gix-shallow/src/lib.rs
+++ b/gix-shallow/src/lib.rs
@@ -3,29 +3,37 @@
 //! ## Examples
 //!
 //! ```
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 //! let first = gix_hash::ObjectId::from_hex(b"1111111111111111111111111111111111111111")?;
 //! let second = gix_hash::ObjectId::from_hex(b"2222222222222222222222222222222222222222")?;
 //! # let dir = tempfile::tempdir()?;
 //! # let shallow_file = dir.path().join("shallow");
 //! # std::fs::write(&shallow_file, format!("{first}\n"))?;
 //!
-//! let shallow = gix_shallow::read(&shallow_file)?.expect("a shallow boundary");
+//! let shallow = gix_shallow::read(&shallow_file)
+//!     .map_err(gix_error::Exn::into_error)?
+//!     .expect("a shallow boundary");
 //! let lock = gix_lock::File::acquire_to_update_resource(
 //!     &shallow_file,
 //!     gix_lock::acquire::Fail::Immediately,
 //!     None,
 //! )
 //! .map_err(|err| err.into_error())?;
-//! gix_shallow::write(lock, Some(shallow), &[gix_shallow::Update::Shallow(second)])?;
+//! gix_shallow::write(lock, Some(shallow), &[gix_shallow::Update::Shallow(second)])
+//!     .map_err(gix_error::Exn::into_error)?;
 //!
-//! let ids = gix_shallow::read(&shallow_file)?.unwrap().into_iter().collect::<Vec<_>>();
+//! let ids = gix_shallow::read(&shallow_file)
+//!     .map_err(gix_error::Exn::into_error)?
+//!     .expect("a shallow boundary")
+//!     .into_iter()
+//!     .collect::<Vec<_>>();
 //! assert_eq!(ids, vec![first, second]);
 //! # Ok(()) }
 //! ```
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
+use gix_error::ExnResult;
 /// An instruction on how to
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -41,18 +49,26 @@ pub enum Update {
 /// The list of shallow commits represents the shallow boundary, beyond which we are lacking all (parent) commits.
 /// Note that the list is never empty, as `Ok(None)` is returned in that case indicating the repository
 /// isn't a shallow clone.
-pub fn read(shallow_file: &std::path::Path) -> Result<Option<nonempty::NonEmpty<gix_hash::ObjectId>>, read::Error> {
+pub fn read(shallow_file: &std::path::Path) -> ExnResult<Option<nonempty::NonEmpty<gix_hash::ObjectId>>> {
     use bstr::ByteSlice;
+    use gix_error::{ErrorExt, ResultExt, message};
     let buf = match std::fs::read(shallow_file) {
         Ok(buf) => buf,
         Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-        Err(err) => return Err(err.into()),
+        Err(err) => {
+            return Err(err
+                .and_raise(message("Could not open shallow file for reading"))
+                .erased());
+        }
     };
 
     let mut commits = buf
         .lines()
         .map(gix_hash::ObjectId::from_hex)
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<Result<Vec<_>, _>>()
+        .or_raise_erased(|| {
+            gix_error::corruption("Could not decode a line in shallow file as hex-encoded object hash")
+        })?;
 
     commits.sort();
     Ok(nonempty::NonEmpty::from_vec(commits))
@@ -63,7 +79,8 @@ pub mod write {
     pub(crate) mod function {
         use std::io::Write;
 
-        use super::Error;
+        use gix_error::{ErrorExt, ExnMessageResult, ResultExt, message};
+
         use crate::Update;
 
         /// Write the [previously obtained](crate::read()) (possibly non-existing) `shallow_commits` to the shallow `file`
@@ -78,7 +95,7 @@ pub mod write {
             mut file: gix_lock::File,
             shallow_commits: Option<nonempty::NonEmpty<gix_hash::ObjectId>>,
             updates: &[Update],
-        ) -> Result<(), Error> {
+        ) -> ExnMessageResult {
             let mut shallow_commits = shallow_commits.map(Vec::from).unwrap_or_default();
             for update in updates {
                 match update {
@@ -92,7 +109,7 @@ pub mod write {
                 if let Err(err) = std::fs::remove_file(file.resource_path())
                     && err.kind() != std::io::ErrorKind::NotFound
                 {
-                    return Err(err.into());
+                    return Err(err.and_raise(message("Could not remove an empty shallow file")));
                 }
                 drop(file);
                 return Ok(());
@@ -100,39 +117,18 @@ pub mod write {
             shallow_commits.sort();
             let mut buf = Vec::<u8>::new();
             for commit in shallow_commits {
-                commit.write_hex_to(&mut buf).map_err(Error::Io)?;
+                commit
+                    .write_hex_to(&mut buf)
+                    .or_raise(|| message("Failed to write object id to shallow file"))?;
                 buf.push(b'\n');
             }
-            file.write_all(&buf).map_err(Error::Io)?;
-            file.flush().map_err(Error::Io)?;
-            file.commit()?;
+            file.write_all(&buf)
+                .or_raise(|| message("Failed to write object id to shallow file"))?;
+            file.flush()
+                .or_raise(|| message("Failed to write object id to shallow file"))?;
+            file.commit().or_raise(|| message("Could not commit shallow file"))?;
             Ok(())
         }
     }
-
-    /// The error returned by [`write()`](crate::write()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Commit(#[from] gix_lock::commit::Error<gix_lock::File>),
-        #[error("Could not remove an empty shallow file")]
-        RemoveEmpty(#[from] std::io::Error),
-        #[error("Failed to write object id to shallow file")]
-        Io(std::io::Error),
-    }
 }
 pub use write::function::write;
-
-///
-pub mod read {
-    /// The error returned by [`read`](crate::read()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not open shallow file for reading")]
-        Io(#[from] std::io::Error),
-        #[error("Could not decode a line in shallow file as hex-encoded object hash")]
-        DecodeHash(#[from] gix_hash::decode::Error),
-    }
-}
diff --git a/gix-status/Cargo.toml b/gix-status/Cargo.toml
index 9460bb11bbd..a62edefc9ed 100644
--- a/gix-status/Cargo.toml
+++ b/gix-status/Cargo.toml
@@ -28,6 +28,7 @@ parallel = ["gix-features/parallel"]
 gix-index = { version = "^0.55.0", path = "../gix-index" }
 gix-fs = { version = "^0.22.1", path = "../gix-fs" }
 gix-hash = { version = "^0.26.2", path = "../gix-hash" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-object = { version = "^0.64.1", path = "../gix-object" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-features = { version = "^0.49.1", path = "../gix-features", features = ["progress"] }
@@ -38,7 +39,6 @@ gix-pathspec = { version = "^0.20.0", path = "../gix-pathspec" }
 gix-dir = { version = "^0.29.1", path = "../gix-dir", optional = true }
 gix-diff = { version = "^0.67.1", path = "../gix-diff", default-features = false, features = ["blob"], optional = true }
 
-thiserror = "2.0.18"
 filetime = "0.2.29"
 bstr = { version = "1.12.0", default-features = false }
 
@@ -58,6 +58,7 @@ windows-sys = { version = "0.61.1", features = [
 ] }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-status = { path = ".", features = ["worktree-rewrites", "parallel", "sha1", "sha256"] }
 gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1", "sha256"] }
 gix-index = { path = "../gix-index" }
diff --git a/gix-status/src/index_as_worktree/function.rs b/gix-status/src/index_as_worktree/function.rs
index 30029c58bd1..e39c374c365 100644
--- a/gix-status/src/index_as_worktree/function.rs
+++ b/gix-status/src/index_as_worktree/function.rs
@@ -1,5 +1,4 @@
 use std::{
-    io,
     path::Path,
     slice::Chunks,
     sync::atomic::{AtomicUsize, Ordering},
@@ -7,6 +6,7 @@ use std::{
 
 use bstr::BStr;
 use filetime::FileTime;
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 use gix_features::parallel::{Reduce, in_parallel_if};
 use gix_filter::pipeline::convert::ToGitOutcome;
 use gix_object::FindExt;
@@ -19,7 +19,7 @@ use crate::{
     index_as_worktree::{
         Change, Conflict, Context, EntryStatus, Outcome, VisitEntry, traits,
         traits::{CompareBlobs, SubmoduleStatus, read_data::Stream},
-        types::{Error, Options},
+        types::Options,
     },
     is_dir_to_mode,
 };
@@ -52,12 +52,12 @@ use crate::{
 /// Thus, some care has to be taken to do the right thing when letting the index match the worktree by evaluating the changes observed
 /// by the `collector`.
 #[expect(clippy::too_many_arguments)]
-pub fn index_as_worktree<'index, T, U, Find, E>(
+pub fn index_as_worktree<'index, T, U, Find>(
     index: &'index gix_index::State,
     worktree: &Path,
     collector: &mut impl VisitEntry<'index, ContentChange = T, SubmoduleStatus = U>,
     compare: impl CompareBlobs<Output = T> + Send + Clone,
-    submodule: impl SubmoduleStatus<Output = U, Error = E> + Send + Clone,
+    submodule: impl SubmoduleStatus<Output = U> + Send + Clone,
     objects: Find,
     progress: &mut dyn gix_features::progress::Progress,
     Context {
@@ -67,11 +67,10 @@ pub fn index_as_worktree<'index, T, U, Find, E>(
         should_interrupt,
     }: Context<'_>,
     options: Options,
-) -> Result<Outcome, Error>
+) -> ExnResult<Outcome>
 where
     T: Send,
     U: Send,
-    E: std::error::Error + Send + Sync + 'static,
     Find: gix_object::Find + Send + Clone,
 {
     // the order is absolutely critical here we use the old timestamp to detect racy index entries
@@ -256,23 +255,22 @@ struct State<'a, 'b> {
     odb_reads: &'a AtomicUsize,
 }
 
-type StatusResult<'index, T, U> = Result<(&'index gix_index::Entry, usize, &'index BStr, EntryStatus<T, U>), Error>;
+type StatusResult<'index, T, U> = ExnResult<(&'index gix_index::Entry, usize, &'index BStr, EntryStatus<T, U>)>;
 
 impl<'index> State<'_, 'index> {
     #[expect(clippy::too_many_arguments)]
-    fn process<T, U, Find, E>(
+    fn process<T, U, Find>(
         &mut self,
         entries: &'index [gix_index::Entry],
         entry: &'index gix_index::Entry,
         entry_index: usize,
         pathspec: &mut gix_pathspec::Search,
         diff: &mut impl CompareBlobs<Output = T>,
-        submodule: &mut impl SubmoduleStatus<Output = U, Error = E>,
+        submodule: &mut impl SubmoduleStatus<Output = U>,
         objects: &Find,
         outer_entry_index: &mut usize,
     ) -> Option<StatusResult<'index, T, U>>
     where
-        E: std::error::Error + Send + Sync + 'static,
         Find: gix_object::Find,
     {
         if entry.flags.intersects(
@@ -370,16 +368,15 @@ impl<'index> State<'_, 'index> {
     /// which is a constant.
     ///
     /// Adapted from [here](https://github.com/GitoxideLabs/gitoxide/pull/805#discussion_r1164676777).
-    fn compute_status<T, U, Find, E>(
+    fn compute_status<T, U, Find>(
         &mut self,
         entry: &gix_index::Entry,
         rela_path: &BStr,
         diff: &mut impl CompareBlobs<Output = T>,
-        submodule: &mut impl SubmoduleStatus<Output = U, Error = E>,
+        submodule: &mut impl SubmoduleStatus<Output = U>,
         objects: &Find,
-    ) -> Result<Option<EntryStatus<T, U>>, Error>
+    ) -> ExnResult<Option<EntryStatus<T, U>>>
     where
-        E: std::error::Error + Send + Sync + 'static,
         Find: gix_object::Find,
     {
         let worktree_path = match self.path_stack.verified_path(gix_path::from_bstr(rela_path).as_ref()) {
@@ -388,7 +385,11 @@ impl<'index> State<'_, 'index> {
             Err(err) if gix_fs::io_err::is_not_found(err.kind(), err.raw_os_error()) => {
                 return Ok(Some(Change::Removed.into()));
             }
-            Err(err) => return Err(Error::Io(err)),
+            Err(err) => {
+                return Err(err
+                    .and_raise(gix_error::message!("Could not access worktree path {rela_path:?}"))
+                    .erased());
+            }
         };
 
         // Acquire metadata. On Windows we consult the precomputed stats first and
@@ -418,12 +419,9 @@ impl<'index> State<'_, 'index> {
         // The only exception here are submodules which are part of the index despite being directories.
         if metadata.is_dir() {
             if entry.mode.is_submodule() {
-                let status = submodule
-                    .status(entry, rela_path)
-                    .map_err(|err| Error::SubmoduleStatus {
-                        rela_path: rela_path.into(),
-                        source: Box::new(err),
-                    })?;
+                let status = submodule.status(entry, rela_path).or_raise_erased(|| {
+                    gix_error::message!("Could not determine status for submodule at '{rela_path}'")
+                })?;
                 return Ok(status.map(|status| Change::SubmoduleModification(status).into()));
             } else {
                 return Ok(Some(Change::Removed.into()));
@@ -435,9 +433,12 @@ impl<'index> State<'_, 'index> {
         }
 
         #[cfg(windows)]
-        let new_stat = metadata.to_stat()?;
+        let new_stat = metadata
+            .to_stat()
+            .or_raise_erased(|| message("The clock was off when reading file metadata"))?;
         #[cfg(not(windows))]
-        let new_stat = gix_index::entry::Stat::from_fs(&metadata)?;
+        let new_stat = gix_index::entry::Stat::from_fs(&metadata)
+            .or_raise_erased(|| message("The clock was off when reading file metadata"))?;
 
         #[cfg(windows)]
         let mode_change = metadata.mode_change(entry.mode, self.options.fs.symlink, self.options.fs.executable_bit);
@@ -550,7 +551,7 @@ impl<'index, T, U, C: VisitEntry<'index, ContentChange = T, SubmoduleStatus = U>
 
     type Output = ();
 
-    type Error = Error;
+    type Error = gix_error::Exn;
 
     fn feed(&mut self, items: Self::Input) -> Result<Self::FeedProduce, Self::Error> {
         for item in items {
@@ -590,15 +591,18 @@ impl<'a, Find> traits::ReadData<'a> for ReadDataImpl<'a, Find>
 where
     Find: gix_object::Find,
 {
-    fn read_blob(self) -> Result<&'a [u8], Error> {
-        Ok(self.objects.find_blob(self.id, self.buf).map(|b| {
-            self.odb_reads.fetch_add(1, Ordering::Relaxed);
-            self.odb_bytes.fetch_add(b.data.len() as u64, Ordering::Relaxed);
-            b.data
-        })?)
+    fn read_blob(self) -> ExnResult<&'a [u8]> {
+        self.objects
+            .find_blob(self.id, self.buf)
+            .or_raise_erased(|| message("Failed to obtain blob from object database"))
+            .map(|b| {
+                self.odb_reads.fetch_add(1, Ordering::Relaxed);
+                self.odb_bytes.fetch_add(b.data.len() as u64, Ordering::Relaxed);
+                b.data
+            })
     }
 
-    fn stream_worktree_file(self) -> Result<Stream<'a>, Error> {
+    fn stream_worktree_file(self) -> ExnResult<Stream<'a>> {
         self.buf.clear();
         // symlinks are only stored as actual symlinks if the FS supports it otherwise they are just
         // normal files with their content equal to the linked path (so can be read normally)
@@ -631,9 +635,9 @@ where
                     &mut |_path, attrs| {
                         platform.matching_attributes(attrs);
                     },
-                    &mut |buf| Ok(self.objects.find_blob(self.id, buf).map(|_| Some(()))?),
+                    &mut |buf| self.objects.find_blob(self.id, buf).map(|_| Some(())),
                 )
-                .map_err(|err| Error::Io(io::Error::other(err)))?;
+                .or_raise_erased(|| message("Could not convert worktree file to Git format"))?;
             let len = match out {
                 ToGitOutcome::Unchanged(_) => Some(self.file_len),
                 ToGitOutcome::Process(_) | ToGitOutcome::Buffer(_) => None,
@@ -728,10 +732,15 @@ impl Conflict {
     }
 }
 
-fn live_metadata(worktree_path: &Path) -> Result<Option<gix_index::fs::Metadata>, Error> {
+fn live_metadata(worktree_path: &Path) -> ExnResult<Option<gix_index::fs::Metadata>> {
     match gix_index::fs::Metadata::from_path_no_follow(worktree_path) {
         Ok(md) => Ok(Some(md)),
         Err(err) if gix_fs::io_err::is_not_found(err.kind(), err.raw_os_error()) => Ok(None),
-        Err(err) => Err(Error::Io(err)),
+        Err(err) => Err(err
+            .and_raise(gix_error::message!(
+                "Could not read metadata for worktree path '{}'",
+                worktree_path.display()
+            ))
+            .erased()),
     }
 }
diff --git a/gix-status/src/index_as_worktree/mod.rs b/gix-status/src/index_as_worktree/mod.rs
index 8c55c913ab4..f1471d69e7f 100644
--- a/gix-status/src/index_as_worktree/mod.rs
+++ b/gix-status/src/index_as_worktree/mod.rs
@@ -1,7 +1,7 @@
 //! Changes between an index and a worktree.
 ///
 mod types;
-pub use types::{Change, Conflict, ConflictIndexEntry, Context, EntryStatus, Error, Options, Outcome, VisitEntry};
+pub use types::{Change, Conflict, ConflictIndexEntry, Context, EntryStatus, Options, Outcome, VisitEntry};
 
 mod recorder;
 pub use recorder::{Record, Recorder};
diff --git a/gix-status/src/index_as_worktree/traits.rs b/gix-status/src/index_as_worktree/traits.rs
index fb1d62f7de8..95bfddbd4dd 100644
--- a/gix-status/src/index_as_worktree/traits.rs
+++ b/gix-status/src/index_as_worktree/traits.rs
@@ -1,12 +1,12 @@
 use std::{io::Read, sync::atomic::AtomicBool};
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 use gix_hash::ObjectId;
 use gix_index as index;
 use index::Entry;
 
-use crate::index_as_worktree::Error;
-
 /// Compares the content of two blobs in some way.
 pub trait CompareBlobs {
     /// Output data produced by [`compare_blobs()`][CompareBlobs::compare_blobs()].
@@ -23,18 +23,16 @@ pub trait CompareBlobs {
         worktree_blob_size: u64,
         data: impl ReadData<'a>,
         buf: &mut Vec<u8>,
-    ) -> Result<Option<Self::Output>, Error>;
+    ) -> ExnResult<Option<Self::Output>>;
 }
 
 /// Determine the status of a submodule, which always indicates that it changed if present.
 pub trait SubmoduleStatus {
     /// The status result, describing in which way the submodule changed.
     type Output;
-    /// A custom error that may occur while computing the submodule status.
-    type Error: std::error::Error + Send + Sync + 'static;
 
     /// Compute the status of the submodule at `entry` and `rela_path`, or return `None` if no change was detected.
-    fn status(&mut self, entry: &gix_index::Entry, rela_path: &BStr) -> Result<Option<Self::Output>, Self::Error>;
+    fn status(&mut self, entry: &gix_index::Entry, rela_path: &BStr) -> ExnResult<Option<Self::Output>>;
 }
 
 /// Lazy borrowed access to worktree or blob data, with streaming support for worktree files.
@@ -43,10 +41,10 @@ pub trait ReadData<'a> {
     ///
     /// This potentially performs IO and other expensive operations
     /// and should only be called when necessary.
-    fn read_blob(self) -> Result<&'a [u8], Error>;
+    fn read_blob(self) -> ExnResult<&'a [u8]>;
 
     /// Stream a worktree file in such a manner that its content matches what would be put into git.
-    fn stream_worktree_file(self) -> Result<read_data::Stream<'a>, Error>;
+    fn stream_worktree_file(self) -> ExnResult<read_data::Stream<'a>>;
 }
 
 ///
@@ -109,7 +107,7 @@ impl CompareBlobs for FastEq {
         worktree_file_size: u64,
         data: impl ReadData<'a>,
         buf: &mut Vec<u8>,
-    ) -> Result<Option<Self::Output>, Error> {
+    ) -> ExnResult<Option<Self::Output>> {
         // make sure to account for racily smudged entries here so that they don't always keep
         // showing up as modified even after their contents have changed again, to a potentially
         // unmodified state. That means that we want to ignore stat.size == 0 for non_empty_blobs.
@@ -138,7 +136,7 @@ impl CompareBlobs for HashEq {
         _worktree_blob_size: u64,
         data: impl ReadData<'a>,
         buf: &mut Vec<u8>,
-    ) -> Result<Option<Self::Output>, Error> {
+    ) -> ExnResult<Option<Self::Output>> {
         let mut stream = data.stream_worktree_file()?;
         match stream.as_bytes() {
             Some(buffer) => {
diff --git a/gix-status/src/index_as_worktree/types.rs b/gix-status/src/index_as_worktree/types.rs
index 273027db9e4..8b48f7b629c 100644
--- a/gix-status/src/index_as_worktree/types.rs
+++ b/gix-status/src/index_as_worktree/types.rs
@@ -1,36 +1,8 @@
 use std::sync::atomic::AtomicBool;
 
-use bstr::{BStr, BString};
+use bstr::BStr;
 use gix_index::entry;
 
-/// The error returned by [index_as_worktree()`](crate::index_as_worktree()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not convert path to UTF8")]
-    IllformedUtf8,
-    #[error("The clock was off when reading file related metadata after updating a file on disk")]
-    Time(#[from] std::time::SystemTimeError),
-    #[error("IO error while writing blob or reading file metadata or changing filetype")]
-    Io(#[from] std::io::Error),
-    #[error("Failed to obtain blob from object database")]
-    Find(#[from] gix_object::find::existing_object::Error),
-    #[error("Could not determine status for submodule at '{rela_path}'")]
-    SubmoduleStatus {
-        rela_path: BString,
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-}
-
-impl From<gix_hash::io::Error> for Error {
-    fn from(err: gix_hash::io::Error) -> Self {
-        let kind = err
-            .downcast_any_ref::<std::io::Error>()
-            .map_or(std::io::ErrorKind::Other, std::io::Error::kind);
-        Error::Io(std::io::Error::new(kind, err.into_error()))
-    }
-}
-
 /// Options that control how the index status with a worktree is computed.
 #[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
 pub struct Options {
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 e037616d27e..15efd073a0a 100644
--- a/gix-status/src/index_as_worktree_with_renames/mod.rs
+++ b/gix-status/src/index_as_worktree_with_renames/mod.rs
@@ -1,6 +1,6 @@
 //! Changes between the index and the worktree along with optional rename tracking.
 mod types;
-pub use types::{Context, DirwalkContext, Entry, Error, Options, Outcome, RewriteSource, Sorting, Summary, VisitEntry};
+pub use types::{Context, DirwalkContext, Entry, Options, Outcome, RewriteSource, Sorting, Summary, VisitEntry};
 
 mod recorder;
 pub use recorder::Recorder;
@@ -9,13 +9,13 @@ pub(super) mod function {
     use std::{borrow::Cow, path::Path};
 
     use bstr::ByteSlice;
+    use gix_error::{ExnResult, ResultExt, message};
     use gix_worktree::stack::State;
 
     use crate::{
         index_as_worktree::traits::{CompareBlobs, SubmoduleStatus},
         index_as_worktree_with_renames::{
-            Context, Entry, Error, Options, Outcome, RewriteSource, VisitEntry,
-            function::rewrite::ModificationOrDirwalkEntry,
+            Context, Entry, Options, Outcome, RewriteSource, VisitEntry, function::rewrite::ModificationOrDirwalkEntry,
         },
         is_dir_to_mode,
     };
@@ -45,26 +45,25 @@ pub(super) mod function {
     /// * `options`
     ///    - a way to configure both paths of the operation.
     #[expect(clippy::too_many_arguments)]
-    pub fn index_as_worktree_with_renames<'index, T, U, Find, E>(
+    pub fn index_as_worktree_with_renames<'index, T, U, Find>(
         index: &'index gix_index::State,
         worktree: &Path,
         collector: &mut impl VisitEntry<'index, ContentChange = T, SubmoduleStatus = U>,
         compare: impl CompareBlobs<Output = T> + Send + Clone,
-        submodule: impl SubmoduleStatus<Output = U, Error = E> + Send + Clone,
+        submodule: impl SubmoduleStatus<Output = U> + Send + Clone,
         objects: Find,
         progress: &mut dyn gix_features::progress::Progress,
         mut ctx: Context<'_>,
         options: Options<'_>,
-    ) -> Result<Outcome, Error>
+    ) -> ExnResult<Outcome>
     where
         T: Send + Clone,
         U: Send + Clone,
-        E: std::error::Error + Send + Sync + 'static,
         Find: gix_object::Find + gix_object::FindHeader + Send + Clone,
     {
         let mut tracked_file_modifications = options.tracked_file_modifications;
         tracked_file_modifications.fscache = options.fscache;
-        gix_features::parallel::threads(|scope| -> Result<Outcome, Error> {
+        gix_features::parallel::threads(|scope| -> ExnResult<Outcome> {
             let (tx, rx) = std::sync::mpsc::channel();
             let walk_outcome = options
                 .dirwalk
@@ -91,7 +90,7 @@ pub(super) mod function {
                                 .any(|p| !p.attributes.is_empty())
                                 .then(|| ctx.resource_cache.attr_stack.clone());
                             let mut pathspec = ctx.pathspec.clone();
-                            move || -> Result<_, Error> {
+                            move || -> ExnResult<_> {
                                 gix_dir::walk(
                                     worktree,
                                     gix_dir::walk::Context {
@@ -117,10 +116,9 @@ pub(super) mod function {
                                     options,
                                     &mut collect,
                                 )
-                                .map_err(Error::DirWalk)
                             }
                         })
-                        .map_err(Error::SpawnThread)
+                        .or_raise_erased(|| message("Failed to spawn directory-walk thread"))
                 })
                 .transpose()?;
 
@@ -141,7 +139,7 @@ pub(super) mod function {
                     let objects = objects.clone();
                     let stack = ctx.resource_cache.attr_stack.clone();
                     let filter = ctx.resource_cache.filter.worktree_filter.clone();
-                    move || -> Result<_, Error> {
+                    move || -> ExnResult<_> {
                         crate::index_as_worktree(
                             index,
                             worktree,
@@ -158,10 +156,9 @@ pub(super) mod function {
                             },
                             tracked_file_modifications,
                         )
-                        .map_err(Error::TrackedFileModifications)
                     }
                 })
-                .map_err(Error::SpawnThread)?;
+                .or_raise_erased(|| message("Failed to spawn index-worktree status thread"))?;
 
             let tracker = options
                 .rewrites
@@ -217,75 +214,79 @@ pub(super) mod function {
                         remaining
                     });
 
-                    let outcome = tracker.emit(
-                        |dest, src| {
-                            match src {
-                                None => {
-                                    let entry = rewrite::change_to_entry(dest.change, entries);
-                                    if let Some(v) = entries_for_sorting.as_mut() {
-                                        v.push(entry);
-                                    } else {
-                                        collector.visit_entry(entry);
-                                    }
-                                }
-                                Some(src) => {
-                                    let ModificationOrDirwalkEntry::DirwalkEntry {
-                                        id,
-                                        entry,
-                                        collapsed_directory_status,
-                                    } = dest.change
-                                    else {
-                                        unreachable!("BUG: only possible destinations are dirwalk entries (additions)");
-                                    };
-                                    let source = match src.change {
-                                        ModificationOrDirwalkEntry::Modification(record) => {
-                                            RewriteSource::RewriteFromIndex {
-                                                index_entries: entries,
-                                                source_entry: record.entry,
-                                                source_entry_index: record.entry_index,
-                                                source_rela_path: record.relative_path,
-                                                source_status: record.status.clone(),
-                                            }
+                    let outcome = tracker
+                        .emit(
+                            |dest, src| {
+                                match src {
+                                    None => {
+                                        let entry = rewrite::change_to_entry(dest.change, entries);
+                                        if let Some(v) = entries_for_sorting.as_mut() {
+                                            v.push(entry);
+                                        } else {
+                                            collector.visit_entry(entry);
                                         }
-                                        ModificationOrDirwalkEntry::DirwalkEntry {
+                                    }
+                                    Some(src) => {
+                                        let ModificationOrDirwalkEntry::DirwalkEntry {
                                             id,
                                             entry,
                                             collapsed_directory_status,
-                                        } => RewriteSource::CopyFromDirectoryEntry {
-                                            source_dirwalk_entry: entry.clone(),
-                                            source_dirwalk_entry_collapsed_directory_status:
-                                                *collapsed_directory_status,
-                                            source_dirwalk_entry_id: *id,
-                                        },
-                                    };
-
-                                    let entry = Entry::Rewrite {
-                                        source,
-                                        dirwalk_entry: entry,
-                                        dirwalk_entry_collapsed_directory_status: collapsed_directory_status,
-                                        dirwalk_entry_id: id,
-                                        diff: src.diff,
-                                        copy: src.kind == gix_diff::rewrites::tracker::visit::SourceKind::Copy,
-                                    };
-                                    if let Some(v) = entries_for_sorting.as_mut() {
-                                        v.push(entry);
-                                    } else {
-                                        collector.visit_entry(entry);
+                                        } = dest.change
+                                        else {
+                                            unreachable!(
+                                                "BUG: only possible destinations are dirwalk entries (additions)"
+                                            );
+                                        };
+                                        let source = match src.change {
+                                            ModificationOrDirwalkEntry::Modification(record) => {
+                                                RewriteSource::RewriteFromIndex {
+                                                    index_entries: entries,
+                                                    source_entry: record.entry,
+                                                    source_entry_index: record.entry_index,
+                                                    source_rela_path: record.relative_path,
+                                                    source_status: record.status.clone(),
+                                                }
+                                            }
+                                            ModificationOrDirwalkEntry::DirwalkEntry {
+                                                id,
+                                                entry,
+                                                collapsed_directory_status,
+                                            } => RewriteSource::CopyFromDirectoryEntry {
+                                                source_dirwalk_entry: entry.clone(),
+                                                source_dirwalk_entry_collapsed_directory_status:
+                                                    *collapsed_directory_status,
+                                                source_dirwalk_entry_id: *id,
+                                            },
+                                        };
+
+                                        let entry = Entry::Rewrite {
+                                            source,
+                                            dirwalk_entry: entry,
+                                            dirwalk_entry_collapsed_directory_status: collapsed_directory_status,
+                                            dirwalk_entry_id: id,
+                                            diff: src.diff,
+                                            copy: src.kind == gix_diff::rewrites::tracker::visit::SourceKind::Copy,
+                                        };
+                                        if let Some(v) = entries_for_sorting.as_mut() {
+                                            v.push(entry);
+                                        } else {
+                                            collector.visit_entry(entry);
+                                        }
                                     }
                                 }
-                            }
-                            std::ops::ControlFlow::Continue(())
-                        },
-                        &mut ctx.resource_cache,
-                        &objects,
-                        |_cb| {
-                            // NOTE: to make this work, we'd want to wait the index modification check to complete.
-                            //       Then it's possible to efficiently emit the tracked files along with what we already sent,
-                            //       i.e. untracked and ignored files.
-                            gix_features::trace::debug!("full-tree copy tracking isn't currently supported");
-                            Ok::<_, std::io::Error>(())
-                        },
-                    )?;
+                                std::ops::ControlFlow::Continue(())
+                            },
+                            &mut ctx.resource_cache,
+                            &objects,
+                            |_cb| {
+                                // NOTE: to make this work, we'd want to wait the index modification check to complete.
+                                //       Then it's possible to efficiently emit the tracked files along with what we already sent,
+                                //       i.e. untracked and ignored files.
+                                gix_features::trace::debug!("full-tree copy tracking isn't currently supported");
+                                Ok::<_, std::io::Error>(())
+                            },
+                        )
+                        .or_raise_erased(|| message("Could not track worktree rewrites"))?;
 
                     if let Some(mut v) = entries_for_sorting {
                         v.sort_by(|a, b| a.destination_rela_path().cmp(b.destination_rela_path()));
@@ -413,9 +414,11 @@ pub(super) mod function {
     }
 
     mod rewrite {
+        use gix_error::{ErrorExt, ExnResult, ResultExt};
+
         use crate::{
             index_as_worktree::{Change, EntryStatus},
-            index_as_worktree_with_renames::{Entry, Error},
+            index_as_worktree_with_renames::Entry,
         };
         use bstr::BStr;
         use gix_diff::{rewrites::tracker::ChangeKind, tree::visit::Relation};
@@ -512,7 +515,7 @@ pub(super) mod function {
             objects: &dyn gix_object::Find,
             buf: &mut Vec<u8>,
             should_interrupt: &std::sync::atomic::AtomicBool,
-        ) -> Result<gix_hash::ObjectId, Error> {
+        ) -> ExnResult<gix_hash::ObjectId> {
             let Some(kind) = disk_kind else {
                 return Ok(object_hash.null());
             };
@@ -523,9 +526,9 @@ pub(super) mod function {
                     return Ok(object_hash.null());
                 }
                 Kind::File => {
-                    let platform = attrs
-                        .at_entry(rela_path, None, objects)
-                        .map_err(Error::SetAttributeContext)?;
+                    let platform = attrs.at_entry(rela_path, None, objects).or_raise_erased(|| {
+                        gix_error::message!("Failed to change the attribute context for worktree path {rela_path:?}")
+                    })?;
                     let rela_path = gix_path::from_bstr(rela_path);
                     let file_path = worktree_root.join(rela_path.as_ref());
                     let file = match std::fs::File::open(&file_path) {
@@ -543,44 +546,73 @@ pub(super) mod function {
                             );
                             return Ok(object_hash.null());
                         }
-                        Err(err) => return Err(Error::OpenWorktreeFile(err)),
+                        Err(err) => {
+                            return Err(err
+                                .and_raise(gix_error::message!(
+                                    "Could not open worktree file '{}' for reading",
+                                    file_path.display()
+                                ))
+                                .erased());
+                        }
                     };
-                    let out = filter.convert_to_git(
-                        file,
-                        rela_path.as_ref(),
-                        &mut |_path, attrs| {
-                            platform.matching_attributes(attrs);
-                        },
-                        &mut |_buf| Ok(None),
-                    )?;
+                    let out = filter
+                        .convert_to_git(
+                            file,
+                            rela_path.as_ref(),
+                            &mut |_path, attrs| {
+                                platform.matching_attributes(attrs);
+                            },
+                            &mut |_buf| Ok(None),
+                        )
+                        .or_raise_erased(|| {
+                            gix_error::message!("Could not convert worktree file {rela_path:?} to Git format")
+                        })?;
                     match out {
                         ToGitOutcome::Unchanged(mut file) => gix_object::compute_stream_hash(
                             object_hash,
                             gix_object::Kind::Blob,
                             &mut file,
-                            file_path.metadata().map_err(Error::OpenWorktreeFile)?.len(),
+                            file_path
+                                .metadata()
+                                .or_raise_erased(|| {
+                                    gix_error::message!(
+                                        "Could not read metadata for worktree file '{}'",
+                                        file_path.display()
+                                    )
+                                })?
+                                .len(),
                             &mut gix_features::progress::Discard,
                             should_interrupt,
                         )
-                        .map_err(|err| Error::HashFile(std::io::Error::other(err.into_error())))?,
+                        .or_raise_erased(|| {
+                            gix_error::message!("Could not hash worktree file '{}'", file_path.display())
+                        })?,
                         ToGitOutcome::Buffer(buf) => gix_object::compute_hash(object_hash, gix_object::Kind::Blob, buf)
                             .map_err(gix_hash::io::from_hasher)
-                            .map_err(|err| Error::HashFile(std::io::Error::other(err.into_error())))?,
+                            .or_raise_erased(|| {
+                                gix_error::message!("Could not hash worktree file '{}'", file_path.display())
+                            })?,
                         ToGitOutcome::Process(mut stream) => {
                             buf.clear();
-                            stream.read_to_end(buf).map_err(Error::HashFile)?;
+                            stream.read_to_end(buf).or_raise_erased(|| {
+                                gix_error::message!("Could not read filtered worktree file '{}'", file_path.display())
+                            })?;
                             gix_object::compute_hash(object_hash, gix_object::Kind::Blob, buf)
                                 .map_err(gix_hash::io::from_hasher)
-                                .map_err(|err| Error::HashFile(std::io::Error::other(err.into_error())))?
+                                .or_raise_erased(|| {
+                                    gix_error::message!("Could not hash worktree file '{}'", file_path.display())
+                                })?
                         }
                     }
                 }
                 Kind::Symlink => {
                     let path = worktree_root.join(gix_path::from_bstr(rela_path));
-                    let target = gix_path::into_bstr(std::fs::read_link(path).map_err(Error::ReadLink)?);
+                    let target = gix_path::into_bstr(std::fs::read_link(&path).or_raise_erased(|| {
+                        gix_error::message!("Could not read worktree link '{}'", path.display())
+                    })?);
                     gix_object::compute_hash(object_hash, gix_object::Kind::Blob, &target)
                         .map_err(gix_hash::io::from_hasher)
-                        .map_err(|err| Error::HashFile(std::io::Error::other(err.into_error())))?
+                        .or_raise_erased(|| gix_error::message!("Could not hash worktree link '{}'", path.display()))?
                 }
                 Kind::Directory | Kind::Repository => object_hash.null(),
             })
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 c4ad76bac9e..6bfc3d60590 100644
--- a/gix-status/src/index_as_worktree_with_renames/types.rs
+++ b/gix-status/src/index_as_worktree_with_renames/types.rs
@@ -4,30 +4,6 @@ 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)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    TrackedFileModifications(#[from] crate::index_as_worktree::Error),
-    #[error(transparent)]
-    DirWalk(gix_dir::walk::Error),
-    #[error(transparent)]
-    SpawnThread(std::io::Error),
-    #[error("Failed to change the context for querying gitattributes to the respective path")]
-    SetAttributeContext(std::io::Error),
-    #[error("Could not open worktree file for reading")]
-    OpenWorktreeFile(std::io::Error),
-    #[error(transparent)]
-    HashFile(std::io::Error),
-    #[error("Could not read worktree link content")]
-    ReadLink(std::io::Error),
-    #[error(transparent)]
-    ConvertToGit(#[from] gix_filter::pipeline::convert::to_git::Error),
-    #[error(transparent)]
-    RewriteTracker(#[from] gix_diff::rewrites::tracker::emit::Error),
-}
-
 /// The way all output should be sorted.
 #[derive(Clone, Copy, Default, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub enum Sorting {
diff --git a/gix-status/src/stack.rs b/gix-status/src/stack.rs
index 19541ac7bf7..867491a5b67 100644
--- a/gix-status/src/stack.rs
+++ b/gix-status/src/stack.rs
@@ -4,18 +4,17 @@ use std::{
 };
 
 use bstr::BStr;
+use gix_error::Message;
 use gix_fs::{Stack, stack::ToNormalPathComponents};
 
 use crate::SymlinkCheck;
 
-#[derive(Debug, thiserror::Error)]
-#[error("Cannot step through symlink to perform an lstat")]
-struct CannotStepThroughSymlink;
+const CANNOT_STEP_THROUGH_SYMLINK: &str = "Cannot step through symlink to perform an lstat";
 
 pub(crate) fn is_symlink_step_error(err: &std::io::Error) -> bool {
     err.get_ref()
-        .and_then(|source| source.downcast_ref::<CannotStepThroughSymlink>())
-        .is_some()
+        .and_then(|source| source.downcast_ref::<Message>())
+        .is_some_and(|err| gix_error::classify(err).is_validation() && err.message == CANNOT_STEP_THROUGH_SYMLINK)
 }
 
 impl SymlinkCheck {
@@ -79,7 +78,9 @@ impl gix_fs::stack::Delegate for Delegate {
             }
 
             if stack.current().symlink_metadata()?.is_symlink() {
-                return Err(std::io::Error::other(CannotStepThroughSymlink));
+                return Err(std::io::Error::other(gix_error::validation(
+                    CANNOT_STEP_THROUGH_SYMLINK,
+                )));
             }
             Ok(())
         }
diff --git a/gix-status/tests/status/index_as_worktree.rs b/gix-status/tests/status/index_as_worktree.rs
index 9cfbbab5832..f69712025d5 100644
--- a/gix-status/tests/status/index_as_worktree.rs
+++ b/gix-status/tests/status/index_as_worktree.rs
@@ -3,6 +3,8 @@ use std::sync::{
     atomic::{AtomicBool, AtomicUsize, Ordering},
 };
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 use filetime::{FileTime, set_file_mtime};
 use gix_filter::eol::AutoCrlf;
@@ -267,9 +269,8 @@ pub(super) struct SubmoduleStatusMock {
 
 impl SubmoduleStatus for SubmoduleStatusMock {
     type Output = ();
-    type Error = std::convert::Infallible;
 
-    fn status(&mut self, _entry: &Entry, _rela_path: &BStr) -> Result<Option<Self::Output>, Self::Error> {
+    fn status(&mut self, _entry: &Entry, _rela_path: &BStr) -> ExnResult<Option<Self::Output>> {
         Ok(self.dirty.then_some(()))
     }
 }
@@ -287,6 +288,7 @@ fn status_removed() -> EntryStatus {
 
 #[test]
 fn hash_errors_preserve_io_kinds() {
+    let mut diagnostics = Vec::new();
     use std::io::ErrorKind;
 
     for (stream_len, interrupted, expected_kind) in
@@ -301,29 +303,35 @@ fn hash_errors_preserve_io_kinds() {
             &AtomicBool::new(interrupted),
         )
         .expect_err("a short stream or requested interruption prevents hashing");
-        let index_as_worktree::Error::Io(err) = err.into() else {
-            panic!("hashing I/O failures must remain I/O errors");
-        };
+        diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        let err = err
+            .downcast_any_ref::<std::io::Error>()
+            .expect("hashing I/O failures must remain I/O errors");
         assert_eq!(err.kind(), expected_kind, "callers must retain the native I/O kind");
     }
+    insta::assert_debug_snapshot!(diagnostics, "stream hashing retains premature EOF and interruption diagnostics", @"
+    [
+        failed to fill whole buffer,
+        I/O error (Interrupted)
+        |
+        └─ Interrupted,
+    ]
+    ");
 }
 
 #[test]
-fn hash_errors_without_io_causes_use_other() {
-    let err = gix_hash::io::from_hasher(gix_hash::hasher::Error::new("hash collision"));
-    let index_as_worktree::Error::Io(err) = err.into() else {
-        panic!("hashing failures must be represented by the I/O error variant");
-    };
-    assert_eq!(
-        err.kind(),
-        std::io::ErrorKind::Other,
-        "a hashing failure without an I/O cause has no native kind"
-    );
+fn hash_errors_without_io_causes_preserve_hashing_failure() {
+    let err = gix_hash::io::from_hasher(gix_error::corruption("hash collision").into());
+    assert!(err.is_corrupted(), "the hashing failure retains its corruption class");
     assert!(
-        std::iter::successors(std::error::Error::source(&err), |source| source.source())
-            .any(|source| source.to_string().contains("hash collision")),
-        "the original hashing failure remains available for diagnostics"
+        err.downcast_any_ref::<std::io::Error>().is_none(),
+        "a hashing failure without an I/O cause has no native kind"
     );
+    insta::assert_debug_snapshot!(err, "the original hashing failure remains available for diagnostics", @"
+    Failed to hash data
+    |
+    └─ hash collision
+    ");
 }
 
 #[test]
@@ -1228,7 +1236,7 @@ fn racy_git() {
             worktree_file_size: u64,
             data: impl ReadData<'a>,
             buf: &mut Vec<u8>,
-        ) -> Result<Option<Self::Output>, gix_status::index_as_worktree::Error> {
+        ) -> ExnResult<Option<Self::Output>> {
             self.0.fetch_add(1, Ordering::Relaxed);
             self.1.compare_blobs(entry, worktree_file_size, data, buf)
         }
diff --git a/gix-status/tests/status/stack.rs b/gix-status/tests/status/stack.rs
index af480a0c4e1..da428e0ad5a 100644
--- a/gix-status/tests/status/stack.rs
+++ b/gix-status/tests/status/stack.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+
 fn stack() -> gix_status::SymlinkCheck {
     stack_in("base")
 }
@@ -11,7 +13,7 @@ fn stack_in(dir: &str) -> gix_status::SymlinkCheck {
 }
 
 #[test]
-fn paths_not_going_through_symlink_directories_are_ok_and_point_to_correct_item() -> crate::Result {
+fn paths_not_going_through_symlink_directories_are_ok_and_point_to_correct_item() -> Result {
     for root in ["base", "symlink-base"] {
         let mut stack = stack_in(root);
         for (rela_path, expectation) in [
@@ -34,24 +36,25 @@ fn paths_not_going_through_symlink_directories_are_ok_and_point_to_correct_item(
 }
 
 #[test]
-fn leaf_file_does_not_have_to_exist() -> crate::Result {
+fn leaf_file_does_not_have_to_exist() -> Result {
     assert!(!stack().verified_path("dir/does-not-exist")?.exists());
     Ok(())
 }
 
 #[test]
 #[cfg(not(windows))]
-fn intermediate_directories_have_to_exist_or_not_found_error() -> crate::Result {
-    assert_eq!(
-        stack().verified_path("nonexisting-dir/file").unwrap_err().kind(),
-        std::io::ErrorKind::NotFound
-    );
+fn intermediate_directories_have_to_exist_or_not_found_error() -> Result {
+    let err = stack()
+        .verified_path("nonexisting-dir/file")
+        .expect_err("the operation must fail");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "intermediate directories have to exist or not found error", @"NotFound");
+    assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
     Ok(())
 }
 
 #[test]
 #[cfg(windows)]
-fn intermediate_directories_do_not_have_exist_for_success() -> crate::Result {
+fn intermediate_directories_do_not_have_exist_for_success() -> Result {
     assert!(stack().verified_path("nonexisting-dir/file").is_ok());
     Ok(())
 }
@@ -63,14 +66,38 @@ fn intermediate_directories_do_not_have_exist_for_success() -> crate::Result {
 )]
 fn paths_leading_through_symlinks_are_rejected() {
     let mut stack = stack();
+    let err = stack
+        .verified_path("root-dirlink/file-in-dir")
+        .expect_err("the operation must fail");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "root-dirlink is a symlink to a directory", @r#"
+    Custom {
+        kind: Other,
+        error: Message {
+            message: "Cannot step through symlink to perform an lstat",
+            class: Validation,
+        },
+    }
+    "#);
     assert_eq!(
-        stack.verified_path("root-dirlink/file-in-dir").unwrap_err().kind(),
+        err.kind(),
         std::io::ErrorKind::Other,
         "root-dirlink is a symlink to a directory"
     );
 
+    let err = stack
+        .verified_path("dir/dirlink/nothing")
+        .expect_err("the operation must fail");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "root-dirlink is a symlink to a directory", @r#"
+    Custom {
+        kind: Other,
+        error: Message {
+            message: "Cannot step through symlink to perform an lstat",
+            class: Validation,
+        },
+    }
+    "#);
     assert_eq!(
-        stack.verified_path("dir/dirlink/nothing").unwrap_err().kind(),
+        err.kind(),
         std::io::ErrorKind::Other,
         "root-dirlink is a symlink to a directory"
     );
diff --git a/gix-submodule/Cargo.toml b/gix-submodule/Cargo.toml
index 4b0f5e6e910..a5eaef6413d 100644
--- a/gix-submodule/Cargo.toml
+++ b/gix-submodule/Cargo.toml
@@ -29,9 +29,9 @@ gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-url = { version = "^0.38.0", path = "../gix-url" }
 
 bstr = { version = "1.12.0", default-features = false }
-thiserror = "2.0.18"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-testtools = { path = "../tests/tools" }
 gix-features = { path = "../gix-features", features = ["walkdir"] }
 
diff --git a/gix-submodule/src/access.rs b/gix-submodule/src/access.rs
index 33c591c0869..d88066e3c71 100644
--- a/gix-submodule/src/access.rs
+++ b/gix-submodule/src/access.rs
@@ -1,9 +1,10 @@
 use std::{collections::HashSet, path::Path};
 
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::{ErrorExt, ExnMessageResult, ResultExt};
 
 use crate::{
-    File, IsActivePlatform, config,
+    File, IsActivePlatform,
     config::{Branch, FetchRecurse, Ignore, Update},
 };
 
@@ -56,10 +57,7 @@ impl File {
         ) -> bool
                         + 'a
                 ),
-    ) -> Result<
-        impl Iterator<Item = (&'a BStr, Result<bool, gix_config::value::Error>)> + 'a,
-        crate::is_active_platform::Error,
-    > {
+    ) -> ExnMessageResult<impl Iterator<Item = (&'a BStr, ExnMessageResult<bool>)> + 'a> {
         let mut platform = self.is_active_platform(config, defaults)?;
         let iter = self
             .names()
@@ -77,19 +75,15 @@ impl File {
         &self,
         config: &gix_config::File,
         defaults: gix_pathspec::Defaults,
-    ) -> Result<IsActivePlatform, crate::is_active_platform::Error> {
+    ) -> ExnMessageResult<IsActivePlatform> {
         let search = config
             .strings("submodule.active")
-            .map(|patterns| -> Result<_, crate::is_active_platform::Error> {
+            .map(|patterns| -> ExnMessageResult<_> {
                 let patterns = patterns
                     .into_iter()
                     .map(|pattern| gix_pathspec::parse(&pattern, defaults))
-                    .collect::<Result<Vec<_>, _>>()?;
-                Ok(gix_pathspec::Search::from_specs(
-                    patterns,
-                    None,
-                    std::path::Path::new(""),
-                )?)
+                    .collect::<std::result::Result<Vec<_>, _>>()?;
+                gix_pathspec::Search::from_specs(patterns, None, std::path::Path::new(""))
             })
             .transpose()?;
         Ok(IsActivePlatform { search })
@@ -112,70 +106,76 @@ impl File {
     /// Return the path relative to the root directory of the working tree at which the submodule is expected to be checked out.
     /// It's an error if the path doesn't exist as it's the only way to associate a path in the index with additional submodule
     /// information, like the URL to fetch from.
+    /// Invalid path bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
     ///
     /// ### Deviation
     ///
     /// Git currently allows absolute paths to be used when adding submodules, but fails later as it can't find the submodule by
     /// relative path anymore. Let's play it safe here.
-    pub fn path(&self, name: &BStr) -> Result<BString, config::path::Error> {
-        let path_bstr =
-            self.config
-                .string(&format!("submodule.{name}.path"))
-                .ok_or_else(|| config::path::Error::Missing {
-                    submodule: name.to_owned(),
-                })?;
+    pub fn path(&self, name: &BStr) -> ExnMessageResult<BString> {
+        let path_bstr = self.config.string(&format!("submodule.{name}.path")).ok_or_else(|| {
+            gix_error::validation(format!(
+                "The submodule '{name}' was missing its 'path' field or it was empty"
+            ))
+        })?;
         if path_bstr.is_empty() {
-            return Err(config::path::Error::Missing {
-                submodule: name.to_owned(),
-            });
+            return Err(gix_error::validation(format!(
+                "The submodule '{name}' was missing its 'path' field or it was empty"
+            ))
+            .into());
         }
         let path = gix_path::from_bstr(path_bstr.as_bstr());
         if path.is_absolute() {
-            return Err(config::path::Error::Absolute {
-                submodule: name.to_owned(),
-                actual: path_bstr,
-            });
+            return Err(
+                gix_error::validation(format!("The path of submodule '{name}' needs to be relative"))
+                    .with("input", path_bstr)
+                    .into(),
+            );
         }
         if gix_path::normalize(path, "".as_ref()).is_none() {
-            return Err(config::path::Error::OutsideOfWorktree {
-                submodule: name.to_owned(),
-                actual: path_bstr,
-            });
+            return Err(
+                gix_error::validation("The path would lead outside of the repository worktree")
+                    .with("input", path_bstr)
+                    .into(),
+            );
         }
         Ok(path_bstr)
     }
 
     /// Retrieve the `url` field of the submodule named `name`. It's an error if it doesn't exist or is empty.
-    pub fn url(&self, name: &BStr) -> Result<gix_url::Url, config::url::Error> {
-        let url = self
-            .config
-            .string(&format!("submodule.{name}.url"))
-            .ok_or_else(|| config::url::Error::Missing {
-                submodule: name.to_owned(),
-            })?;
+    /// Parse failures include the URL bytes as `input` [metadata](gix_error::Exn::metadata()).
+    pub fn url(&self, name: &BStr) -> ExnMessageResult<gix_url::Url> {
+        let url = self.config.string(&format!("submodule.{name}.url")).ok_or_else(|| {
+            gix_error::validation(format!(
+                "The submodule '{name}' was missing its 'url' field or it was empty"
+            ))
+            .raise()
+        })?;
 
         if url.is_empty() {
-            return Err(config::url::Error::Missing {
-                submodule: name.to_owned(),
-            });
+            return Err(gix_error::validation(format!(
+                "The submodule '{name}' was missing its 'url' field or it was empty"
+            ))
+            .raise());
         }
-        gix_url::Url::from_bytes(url.as_ref()).map_err(|err| config::url::Error::Parse {
-            submodule: name.to_owned(),
-            source: err.into_error(),
+        gix_url::Url::from_bytes(url.as_ref()).or_raise(|| {
+            gix_error::validation(format!("The url of submodule '{name}' could not be parsed")).with("input", url)
         })
     }
 
     /// Retrieve the `update` field of the submodule named `name`, if present.
-    pub fn update(&self, name: &BStr) -> Result<Option<Update>, config::update::Error> {
+    /// Invalid value or command bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
+    pub fn update(&self, name: &BStr) -> ExnMessageResult<Option<Update>> {
         let mut value_is_from_modules_file = None;
         let our_meta = self.config.meta();
         let value: Update = match self.config.string_filter(&format!("submodule.{name}.update"), |meta| {
             value_is_from_modules_file = Some(std::ptr::eq(meta, our_meta));
             true
         }) {
-            Some(v) => v.as_bstr().try_into().map_err(|()| config::update::Error::Invalid {
-                submodule: name.to_owned(),
-                actual: v,
+            Some(v) => v.as_bstr().try_into().map_err(|()| {
+                gix_error::validation(format!("The 'update' field of submodule '{name}' was invalid")).with("input", v)
             })?,
             None => return Ok(None),
         };
@@ -183,10 +183,11 @@ impl File {
         if let Update::Command(cmd) = &value
             && value_is_from_modules_file.unwrap_or_default()
         {
-            return Err(config::update::Error::CommandForbiddenInModulesConfiguration {
-                submodule: name.to_owned(),
-                actual: cmd.to_owned(),
-            });
+            return Err(gix_error::validation(format!(
+                "The 'update' field of submodule '{name}' tried to set a command to be shared"
+            ))
+            .with("input", cmd.to_owned())
+            .into());
         }
         Ok(Some(value))
     }
@@ -194,52 +195,59 @@ impl File {
     /// Retrieve the `branch` field of the submodule named `name`, or `None` if unset.
     ///
     /// Note that `Default` is implemented for [`Branch`].
-    pub fn branch(&self, name: &BStr) -> Result<Option<Branch>, config::branch::Error> {
+    /// Parse failures include the branch bytes as `input` [metadata](gix_error::Exn::metadata()).
+    pub fn branch(&self, name: &BStr) -> ExnMessageResult<Option<Branch>> {
         let branch = match self.config.string(&format!("submodule.{name}.branch")) {
             Some(v) => v,
             None => return Ok(None),
         };
 
-        Branch::try_from(branch.as_ref())
-            .map(Some)
-            .map_err(|err| config::branch::Error {
-                submodule: name.to_owned(),
-                actual: branch,
-                source: err,
-            })
+        Branch::try_from(branch.as_ref()).map(Some).or_raise(|| {
+            gix_error::validation(format!(
+                "The 'branch' field of submodule '{name}' couldn't be turned into a valid fetch refspec"
+            ))
+            .with("input", branch)
+        })
     }
 
     /// Retrieve the `fetchRecurseSubmodules` field of the submodule named `name`, or `None` if unset.
     ///
     /// Note that if it's unset, it should be retrieved from `fetch.recurseSubmodules` in the configuration.
-    pub fn fetch_recurse(&self, name: &BStr) -> Result<Option<FetchRecurse>, config::Error> {
-        FetchRecurse::new(self.config.boolean(&format!("submodule.{name}.fetchRecurseSubmodules"))).map_err(|value| {
-            config::Error {
-                field: "fetchRecurseSubmodules",
-                submodule: name.to_owned(),
-                actual: value,
-            }
-        })
+    /// Invalid value bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
+    pub fn fetch_recurse(&self, name: &BStr) -> ExnMessageResult<Option<FetchRecurse>> {
+        Ok(
+            FetchRecurse::new(self.config.boolean(&format!("submodule.{name}.fetchRecurseSubmodules"))).map_err(
+                |value| {
+                    gix_error::validation(format!(
+                        "The 'fetchRecurseSubmodules' field of submodule '{name}' was invalid"
+                    ))
+                    .with("input", value)
+                },
+            )?,
+        )
     }
 
     /// Retrieve the `ignore` field of the submodule named `name`, or `None` if unset.
-    pub fn ignore(&self, name: &BStr) -> Result<Option<Ignore>, config::Error> {
-        self.config
+    /// Invalid value bytes are stored as `input` in [`gix_error::Message::values`].
+    /// After [wrapping](gix_error::Error::from_error()), inspect them with [metadata](gix_error::Error::metadata()).
+    pub fn ignore(&self, name: &BStr) -> ExnMessageResult<Option<Ignore>> {
+        Ok(self
+            .config
             .string(&format!("submodule.{name}.ignore"))
             .map(|value| {
-                Ignore::try_from(value.as_ref()).map_err(|()| config::Error {
-                    field: "ignore",
-                    submodule: name.to_owned(),
-                    actual: value,
+                Ignore::try_from(value.as_ref()).map_err(|()| {
+                    gix_error::validation(format!("The 'ignore' field of submodule '{name}' was invalid"))
+                        .with("input", value)
                 })
             })
-            .transpose()
+            .transpose()?)
     }
 
     /// Retrieve the `shallow` field of the submodule named `name`, or `None` if unset.
     ///
     /// If `true`, the submodule will be checked out with `depth = 1`. If unset, `false` is assumed.
-    pub fn shallow(&self, name: &BStr) -> Result<Option<bool>, gix_config::value::Error> {
+    pub fn shallow(&self, name: &BStr) -> ExnMessageResult<Option<bool>> {
         self.config.boolean(&format!("submodule.{name}.shallow"))
     }
 }
diff --git a/gix-submodule/src/config.rs b/gix-submodule/src/config.rs
index 29466dafcb9..45e02a0e7fe 100644
--- a/gix-submodule/src/config.rs
+++ b/gix-submodule/src/config.rs
@@ -1,4 +1,5 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
 
 /// Determine how the submodule participates in `git status` queries. This setting also affects `git diff`.
 #[derive(Default, Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -55,7 +56,7 @@ impl FetchRecurse {
     /// Check if `boolean` is set and translate it the respective variant, or check the underlying string
     /// value for non-boolean options.
     /// On error, it returns the obtained string value which would be the invalid value.
-    pub fn new(boolean: Result<Option<bool>, gix_config::value::Error>) -> Result<Option<Self>, BString> {
+    pub fn new(boolean: ExnMessageResult<Option<bool>>) -> Result<Option<Self>, BString> {
         Ok(match boolean {
             Ok(Some(value)) => Some(if value {
                 FetchRecurse::Always
@@ -64,8 +65,11 @@ impl FetchRecurse {
             }),
             Ok(None) => None,
             Err(err) => {
-                if err.input != "on-demand" {
-                    return Err(err.input);
+                let Some(gix_error::MetadataValue::Bytes(input)) = err.into_inner().values.remove("input") else {
+                    unreachable!("gix-config-value validation errors retain their input as bytes");
+                };
+                if input != "on-demand" {
+                    return Err(input);
                 }
                 Some(FetchRecurse::OnDemand)
             }
@@ -89,7 +93,7 @@ impl Default for Branch {
 }
 
 impl TryFrom<&BStr> for Branch {
-    type Error = gix_refspec::parse::Error;
+    type Error = gix_error::Exn<gix_error::Message>;
 
     fn try_from(value: &BStr) -> Result<Self, Self::Error> {
         if value == "." {
@@ -136,80 +140,3 @@ impl TryFrom<&BStr> for Update {
         })
     }
 }
-
-/// The error returned by [File::fetch_recurse()](crate::File::fetch_recurse) and [File::ignore()](crate::File::ignore).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-#[error("The '{field}' field of submodule '{submodule}' was invalid: '{actual}'")]
-pub struct Error {
-    pub field: &'static str,
-    pub submodule: BString,
-    pub actual: BString,
-}
-
-///
-pub mod branch {
-    use bstr::BString;
-
-    /// The error returned by [File::branch()](crate::File::branch).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    #[error(
-        "The value '{actual}' of the 'branch' field of submodule '{submodule}' couldn't be turned into a valid fetch refspec"
-    )]
-    pub struct Error {
-        pub submodule: BString,
-        pub actual: BString,
-        pub source: gix_refspec::parse::Error,
-    }
-}
-
-///
-pub mod update {
-    use bstr::BString;
-
-    /// The error returned by [File::update()](crate::File::update).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The 'update' field of submodule '{submodule}' tried to set command '{actual}' to be shared")]
-        CommandForbiddenInModulesConfiguration { submodule: BString, actual: BString },
-        #[error("The 'update' field of submodule '{submodule}' was invalid: '{actual}'")]
-        Invalid { submodule: BString, actual: BString },
-    }
-}
-
-///
-pub mod url {
-    use bstr::BString;
-
-    /// The error returned by [File::url()](crate::File::url).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The url of submodule '{submodule}' could not be parsed")]
-        Parse {
-            submodule: BString,
-            source: gix_error::Error,
-        },
-        #[error("The submodule '{submodule}' was missing its 'url' field or it was empty")]
-        Missing { submodule: BString },
-    }
-}
-
-///
-pub mod path {
-    use bstr::BString;
-
-    /// The error returned by [File::path()](crate::File::path).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The path '{actual}' of submodule '{submodule}' needs to be relative")]
-        Absolute { actual: BString, submodule: BString },
-        #[error("The submodule '{submodule}' was missing its 'path' field or it was empty")]
-        Missing { submodule: BString },
-        #[error("The path '{actual}' would lead outside of the repository worktree")]
-        OutsideOfWorktree { actual: BString, submodule: BString },
-    }
-}
diff --git a/gix-submodule/src/is_active_platform.rs b/gix-submodule/src/is_active_platform.rs
index e8781a6c375..b2bfd585f16 100644
--- a/gix-submodule/src/is_active_platform.rs
+++ b/gix-submodule/src/is_active_platform.rs
@@ -1,17 +1,8 @@
 use bstr::BStr;
+use gix_error::ExnMessageResult;
 
 use crate::IsActivePlatform;
 
-/// The error returned by [File::names_and_active_state](crate::File::names_and_active_state()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    NormalizePattern(#[from] gix_pathspec::normalize::Error),
-    #[error(transparent)]
-    ParsePattern(#[from] gix_pathspec::parse::Error),
-}
-
 impl IsActivePlatform {
     /// Returns `true` if the submodule named `name` is active or `false` otherwise.
     /// `config` is the configuration that was passed to the originating [modules file](crate::File).
@@ -33,7 +24,7 @@ impl IsActivePlatform {
             bool,
             &mut gix_pathspec::attributes::search::Outcome,
         ) -> bool,
-    ) -> Result<bool, gix_config::value::Error> {
+    ) -> ExnMessageResult<bool> {
         if let Some(val) = config.boolean(&format!("submodule.{name}.active"))? {
             return Ok(val);
         }
diff --git a/gix-submodule/src/lib.rs b/gix-submodule/src/lib.rs
index cb1f1b5e551..f21d284b8d5 100644
--- a/gix-submodule/src/lib.rs
+++ b/gix-submodule/src/lib.rs
@@ -2,6 +2,7 @@
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]
 
+use gix_error::ExnMessageResult;
 use std::collections::BTreeMap;
 
 use bstr::ByteSlice;
@@ -40,10 +41,7 @@ impl File {
     /// * `branch`
     ///
     /// These values aren't validated yet, which will happen upon query.
-    pub fn append_submodule_overrides(
-        &mut self,
-        config: &gix_config::File,
-    ) -> Result<&mut Self, gix_config::file::section::value::Error> {
+    pub fn append_submodule_overrides(&mut self, config: &gix_config::File) -> ExnMessageResult<&mut Self> {
         let mut values = BTreeMap::<_, Vec<_>>::new();
         for (module_name, section) in config
             .sections_by_name("submodule")
@@ -96,6 +94,8 @@ impl File {
 pub mod init {
     use std::path::PathBuf;
 
+    use gix_error::{ExnMessageResult, ResultExt};
+
     use crate::File;
 
     impl std::fmt::Debug for File {
@@ -110,21 +110,6 @@ pub mod init {
     /// A marker we use when listing names to not pick them up from overridden sections.
     pub(crate) const META_MARKER: gix_config::Source = gix_config::Source::Api;
 
-    /// Lifecycle
-    /// The error returned when parsing a submodule configuration file.
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        /// The configuration could not be parsed.
-        #[error(transparent)]
-        Parse(#[from] gix_config::parse::Error),
-        /// Applying configuration overrides exceeded the supported span size.
-        #[error(transparent)]
-        Span(#[from] gix_config::parse::span::Error),
-        /// Applying configuration overrides failed.
-        #[error(transparent)]
-        SectionValue(#[from] gix_config::file::section::value::Error),
-    }
-
     impl File {
         /// Parse `bytes` as git configuration, typically from `.gitmodules`, without doing any further validation.
         /// `path` can be provided to keep track of where the file was read from in the underlying [`config`](Self::config())
@@ -142,19 +127,21 @@ pub mod init {
             bytes: &[u8],
             path: impl Into<Option<PathBuf>>,
             config: &gix_config::File,
-        ) -> Result<Self, Error> {
+        ) -> ExnMessageResult<Self> {
             let metadata = {
                 let mut meta = gix_config::file::Metadata::from(META_MARKER);
                 meta.path = path.into();
                 meta
             };
             let modules = gix_config::File::from_parse_events_no_includes(
-                gix_config::parse::Events::from_bytes(bytes, None)?,
+                gix_config::parse::Events::from_bytes(bytes, None)
+                    .or_raise(|| gix_error::validation("Could not parse submodule configuration"))?,
                 metadata,
             );
 
             let mut res = Self { config: modules };
-            res.append_submodule_overrides(config)?;
+            res.append_submodule_overrides(config)
+                .or_raise(|| gix_error::validation("Could not apply submodule configuration overrides"))?;
             Ok(res)
         }
 
diff --git a/gix-submodule/tests/file/baseline.rs b/gix-submodule/tests/file/baseline.rs
index 513b5051af0..3237c0e9436 100644
--- a/gix-submodule/tests/file/baseline.rs
+++ b/gix-submodule/tests/file/baseline.rs
@@ -1,15 +1,16 @@
+use crate::Result;
 use std::{ffi::OsStr, path::PathBuf};
 
 use bstr::ByteSlice;
 use gix_features::fs::walkdir::Parallelism;
 
 #[test]
-fn common_values_and_names_by_path() -> crate::Result {
+fn common_values_and_names_by_path() -> Result {
     let modules = module_files()
         .map(|(path, stripped)| {
             gix_submodule::File::from_bytes(&std::fs::read(path).unwrap(), stripped, &Default::default())
         })
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(
         modules
diff --git a/gix-submodule/tests/file/mod.rs b/gix-submodule/tests/file/mod.rs
index 841999479ee..435ed0dfefc 100644
--- a/gix-submodule/tests/file/mod.rs
+++ b/gix-submodule/tests/file/mod.rs
@@ -1,11 +1,14 @@
+use crate::Result;
+
 fn submodule(bytes: &str) -> gix_submodule::File {
     gix_submodule::File::from_bytes(bytes.as_bytes(), None, &Default::default()).expect("valid module")
 }
 
 mod is_active_platform {
+    use crate::Result;
     use std::str::FromStr;
 
-    fn module_file(name: &str) -> crate::Result<gix_submodule::File> {
+    fn module_file(name: &str) -> Result<gix_submodule::File> {
         let modules = gix_testtools::scripted_fixture_read_only("basic.sh")?
             .join(name)
             .join(".gitmodules");
@@ -18,7 +21,7 @@ mod is_active_platform {
 
     use bstr::{BStr, ByteSlice};
 
-    fn multi_modules() -> crate::Result<gix_submodule::File> {
+    fn multi_modules() -> Result<gix_submodule::File> {
         module_file("multiple")
     }
 
@@ -26,7 +29,7 @@ mod is_active_platform {
         module: &'a gix_submodule::File,
         config: &'a gix_config::File,
         defaults: gix_pathspec::Defaults,
-    ) -> crate::Result<Vec<(&'a str, bool)>> {
+    ) -> Result<Vec<(&'a str, bool)>> {
         assume_valid_active_state_with_attrs(module, config, defaults, |_, _, _, _| {
             unreachable!("shouldn't be called")
         })
@@ -43,7 +46,7 @@ mod is_active_platform {
             &mut gix_pathspec::attributes::search::Outcome,
         ) -> bool
         + 'a,
-    ) -> crate::Result<Vec<(&'a str, bool)>> {
+    ) -> Result<Vec<(&'a str, bool)>> {
         let mut platform = module.is_active_platform(config, defaults)?;
         Ok(module
             .names()
@@ -57,7 +60,7 @@ mod is_active_platform {
     }
 
     #[test]
-    fn without_submodule_in_index() -> crate::Result {
+    fn without_submodule_in_index() -> Result {
         let module = module_file("not-a-submodule")?;
         assert_eq!(
             module.names().map(ToOwned::to_owned).collect::<Vec<_>>(),
@@ -68,7 +71,7 @@ mod is_active_platform {
     }
 
     #[test]
-    fn without_any_additional_settings_all_are_inactive_if_they_have_a_url() -> crate::Result {
+    fn without_any_additional_settings_all_are_inactive_if_they_have_a_url() -> Result {
         let module = multi_modules()?;
         assert_eq!(
             assume_valid_active_state(&module, &Default::default(), Default::default())?,
@@ -163,13 +166,12 @@ mod is_active_platform {
 }
 
 mod path {
-    use gix_submodule::config::path::Error;
 
     use crate::file::submodule;
 
-    fn submodule_path(value: &str) -> Error {
+    fn submodule_path(value: &str) -> gix_error::Message {
         let module = submodule(&format!("[submodule.a]\npath = {value}"));
-        module.path("a".into()).unwrap_err()
+        module.path("a".into()).unwrap_err().into_inner()
     }
 
     #[test]
@@ -181,35 +183,62 @@ mod path {
 
     #[test]
     fn validate_upon_retrieval() {
-        assert!(matches!(
-            submodule_path(if cfg!(windows) {
-                r"c:\\hello"
-            } else {
-                r"/definitely/absolute\\"
-            }),
-            Error::Absolute { .. }
-        ));
-        assert!(matches!(submodule_path(""), Error::Missing { .. }));
-        assert!(matches!(submodule_path("../attack"), Error::OutsideOfWorktree { .. }));
+        let mut message_diagnostics = Vec::new();
+        let absolute = submodule_path(if cfg!(windows) {
+            r"c:\\hello"
+        } else {
+            r"/definitely/absolute\\"
+        });
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&absolute, &[(if cfg!(windows) { r"c:\hello" } else { r"/definitely/absolute\" }, "<absolute-path>")]), "validate upon retrieval", @r#"
+        Message {
+            message: "The path of submodule 'a' needs to be relative",
+            class: Validation,
+            values: {"input": Bytes("<absolute-path>")},
+        }
+        "#);
+        insta::assert_debug_snapshot!(submodule_path(""), "validate upon retrieval", @r#"
+        Message {
+            message: "The submodule 'a' was missing its 'path' field or it was empty",
+            class: Validation,
+        }
+        "#);
+        insta::assert_debug_snapshot!(submodule_path("../attack"), "validate upon retrieval", @r#"
+        Message {
+            message: "The path would lead outside of the repository worktree",
+            class: Validation,
+            values: {"input": Bytes("../attack")},
+        }
+        "#);
 
         {
             let module = submodule("[submodule.a]\n path");
-            assert!(matches!(module.path("a".into()).unwrap_err(), Error::Missing { .. }));
+            message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &(module.path("a".into()).expect_err("the input must be rejected")),
+                &[],
+            ));
         }
 
         {
             let module = submodule("[submodule.a]\n");
-            assert!(matches!(module.path("a".into()).unwrap_err(), Error::Missing { .. }));
+            message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &(module.path("a".into()).expect_err("the input must be rejected")),
+                &[],
+            ));
         }
+        insta::assert_debug_snapshot!(message_diagnostics, "validate upon retrieval", @"
+        [
+            The submodule 'a' was missing its 'path' field or it was empty,
+            The submodule 'a' was missing its 'path' field or it was empty,
+        ]
+        ");
     }
 }
 
 mod url {
-    use gix_submodule::config::url::Error;
 
     use crate::file::submodule;
 
-    fn submodule_url(value: &str) -> Error {
+    fn submodule_url(value: &str) -> gix_error::Exn<gix_error::Message> {
         let module = submodule(&format!("[submodule.a]\nurl = {value}"));
         module.url("a".into()).unwrap_err()
     }
@@ -223,31 +252,54 @@ mod url {
 
     #[test]
     fn validate_upon_retrieval() {
-        assert!(matches!(submodule_url(""), Error::Missing { .. }));
+        let mut message_diagnostics = Vec::new();
+        insta::assert_debug_snapshot!(submodule_url(""), "validate upon retrieval", @"The submodule 'a' was missing its 'url' field or it was empty");
         {
             let module = submodule("[submodule.a]\n url");
-            assert!(matches!(module.url("a".into()).unwrap_err(), Error::Missing { .. }));
+            message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &(module.url("a".into()).expect_err("the input must be rejected").error()),
+                &[],
+            ));
         }
 
         {
             let module = submodule("[submodule.a]\n");
-            assert!(matches!(module.url("a".into()).unwrap_err(), Error::Missing { .. }));
+            message_diagnostics.push(gix_testtools::redact_debug_snapshot(
+                &(module.url("a".into()).expect_err("the input must be rejected").error()),
+                &[],
+            ));
         }
 
-        assert!(matches!(submodule_url("file://"), Error::Parse { .. }));
+        insta::assert_debug_snapshot!(submodule_url("file://"), "validate upon retrieval", @r#"
+        The url of submodule 'a' could not be parsed, "input"="file://"
+        |
+        └─ URL does not specify a path to a repository, "input"="file://"
+        "#);
+        insta::assert_debug_snapshot!(message_diagnostics, "validate upon retrieval", @r#"
+        [
+            Message {
+                message: "The submodule 'a' was missing its 'url' field or it was empty",
+                class: Validation,
+            },
+            Message {
+                message: "The submodule 'a' was missing its 'url' field or it was empty",
+                class: Validation,
+            },
+        ]
+        "#);
     }
 }
 
 mod update {
     use std::str::FromStr;
 
-    use gix_submodule::config::{Update, update::Error};
+    use gix_submodule::config::Update;
 
     use crate::file::submodule;
 
-    fn submodule_update(value: &str) -> Error {
+    fn submodule_update(value: &str) -> gix_error::Message {
         let module = submodule(&format!("[submodule.a]\nupdate = {value}"));
-        module.update("a".into()).unwrap_err()
+        module.update("a".into()).unwrap_err().into_inner()
     }
 
     #[test]
@@ -293,15 +345,27 @@ mod update {
 
     #[test]
     fn validate_upon_retrieval() {
-        assert!(matches!(submodule_update(""), Error::Invalid { .. }));
-        assert!(matches!(submodule_update("bogus"), Error::Invalid { .. }));
-        assert!(
-            matches!(
-                submodule_update("!dangerous"),
-                Error::CommandForbiddenInModulesConfiguration { .. }
-            ),
-            "forbidden unless it's an override"
-        );
+        insta::assert_debug_snapshot!(submodule_update(""), "validate upon retrieval", @r#"
+        Message {
+            message: "The 'update' field of submodule 'a' was invalid",
+            class: Validation,
+            values: {"input": Bytes("")},
+        }
+        "#);
+        insta::assert_debug_snapshot!(submodule_update("bogus"), "validate upon retrieval", @r#"
+        Message {
+            message: "The 'update' field of submodule 'a' was invalid",
+            class: Validation,
+            values: {"input": Bytes("bogus")},
+        }
+        "#);
+        insta::assert_debug_snapshot!(submodule_update("!dangerous"), "forbidden unless it's an override", @r#"
+        Message {
+            message: "The 'update' field of submodule 'a' tried to set a command to be shared",
+            class: Validation,
+            values: {"input": Bytes("dangerous")},
+        }
+        "#);
     }
 
     /// Reproducer for GHSA-f26g-jm89-4g65 and GHSA-97pq-9mjg-9fcj: `.gitmodules` may carry
@@ -316,16 +380,18 @@ mod update {
             .append_submodule_overrides(&repo_config)
             .expect("the fixture fits into the backing buffer");
 
-        assert!(
-            matches!(
-                module.update("a".into()),
-                Err(Error::CommandForbiddenInModulesConfiguration {
-                    actual,
-                    ..
-                }) if actual == "dangerous"
-            ),
-            "a same-named local section must not authorize a command that still originates from .gitmodules"
+        let err = module.update("a".into()).unwrap_err().into_inner();
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::from(b"dangerous".as_slice()))
         );
+        insta::assert_debug_snapshot!(err, "a same-named local section must not authorize a command that still originates from .gitmodules", @r#"
+        Message {
+            message: "The 'update' field of submodule 'a' tried to set a command to be shared",
+            class: Validation,
+            values: {"input": Bytes("dangerous")},
+        }
+        "#);
         Ok(())
     }
 }
@@ -377,6 +443,7 @@ mod fetch_recurse {
 }
 
 mod ignore {
+    use crate::Result;
     use gix_submodule::config::Ignore;
 
     use crate::file::submodule;
@@ -387,7 +454,7 @@ mod ignore {
     }
 
     #[test]
-    fn valid() -> crate::Result {
+    fn valid() -> Result {
         for (valid, expected) in [
             ("all", Ignore::All),
             ("dirty", Ignore::Dirty),
@@ -406,7 +473,7 @@ mod ignore {
     }
 
     #[test]
-    fn validate_upon_retrieval() -> crate::Result {
+    fn validate_upon_retrieval() -> Result {
         for invalid in ["All", ""] {
             let module = submodule(&format!("[submodule.a]\n ignore = \"{invalid}\""));
             assert!(module.ignore("a".into()).is_err());
@@ -416,12 +483,13 @@ mod ignore {
 }
 
 mod branch {
+    use crate::Result;
     use gix_submodule::config::Branch;
 
     use crate::file::submodule;
 
     #[test]
-    fn valid() -> crate::Result {
+    fn valid() -> Result {
         for (valid, expected) in [
             (".", Branch::CurrentInSuperproject),
             ("", Branch::Name("HEAD".into())),
@@ -444,7 +512,7 @@ mod branch {
     }
 
     #[test]
-    fn validate_upon_retrieval() -> crate::Result {
+    fn validate_upon_retrieval() -> Result {
         let module = submodule("[submodule.a]\n branch = /invalid");
         assert!(module.branch("a".into()).is_err());
         Ok(())
@@ -452,7 +520,7 @@ mod branch {
 }
 
 #[test]
-fn shallow() -> crate::Result {
+fn shallow() -> Result {
     let module = submodule("[submodule.a]\n shallow");
     assert_eq!(
         module.shallow("a".into())?,
@@ -463,12 +531,13 @@ fn shallow() -> crate::Result {
 }
 
 mod append_submodule_overrides {
+    use crate::Result;
     use std::str::FromStr;
 
     use crate::file::submodule;
 
     #[test]
-    fn last_of_multiple_values_wins() -> crate::Result {
+    fn last_of_multiple_values_wins() -> Result {
         let mut module = submodule("[submodule.a] url = from-module");
         let repo_config = gix_config::File::from_str(
             "[submodule.a]\n url = a\n url = b\n ignore = x\n [submodule.a]\n url = c\n[submodule.b] url = not-relevant",
diff --git a/gix-tempfile/Cargo.toml b/gix-tempfile/Cargo.toml
index 6654ef5a9d8..50a55c8f9a7 100644
--- a/gix-tempfile/Cargo.toml
+++ b/gix-tempfile/Cargo.toml
@@ -58,3 +58,7 @@ windows-sys = { version = "0.61.1", features = ["Win32_Storage_FileSystem"] }
 [package.metadata.docs.rs]
 all-features = true
 features = ["document-features"]
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
diff --git a/gix-tempfile/src/handle.rs b/gix-tempfile/src/handle.rs
index 6bde455eddb..71b6a3ef73f 100644
--- a/gix-tempfile/src/handle.rs
+++ b/gix-tempfile/src/handle.rs
@@ -280,7 +280,7 @@ pub mod persist {
 
         impl<T: Debug> std::error::Error for Error<T> {
             fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-                self.error.source()
+                Some(&self.error)
             }
         }
     }
diff --git a/gix-tempfile/tests/tempfile/handle.rs b/gix-tempfile/tests/tempfile/handle.rs
index 45245b0937d..260a1c13b74 100644
--- a/gix-tempfile/tests/tempfile/handle.rs
+++ b/gix-tempfile/tests/tempfile/handle.rs
@@ -1,8 +1,9 @@
 mod mark_path {
+    use crate::Result;
     use gix_tempfile::{AutoRemove, ContainingDirectory};
 
     #[test]
-    fn it_persists_markers_along_with_newly_created_directories() -> crate::Result {
+    fn it_persists_markers_along_with_newly_created_directories() -> Result {
         let dir = tempfile::tempdir()?;
         let target = dir.path().join("a").join("b").join("file.tmp");
         let new_filename = target.parent().unwrap().join("file.ext");
@@ -18,6 +19,10 @@ mod mark_path {
         let err = handle
             .persist(&new_filename)
             .expect_err("cannot persist onto directory");
+        assert!(
+            std::error::Error::source(&err).is_some_and(<dyn std::error::Error>::is::<std::io::Error>),
+            "the persistence error exposes its I/O cause for classification"
+        );
         let handle = err.handle;
         std::fs::remove_dir(&new_filename)?;
 
@@ -31,7 +36,7 @@ mod mark_path {
     }
 
     #[test]
-    fn it_can_create_the_containing_directory_and_remove_it_on_drop() -> crate::Result {
+    fn it_can_create_the_containing_directory_and_remove_it_on_drop() -> Result {
         let dir = tempfile::tempdir()?;
         let first_dir = "dir";
         let filename = dir.path().join(first_dir).join("subdir").join("file.tmp");
@@ -56,10 +61,11 @@ mod mark_path {
     }
 }
 mod at_path {
+    use crate::Result;
     use gix_tempfile::{AutoRemove, ContainingDirectory};
 
     #[test]
-    fn reduce_resource_usage_by_converting_files_to_markers_and_persist_them() -> crate::Result {
+    fn reduce_resource_usage_by_converting_files_to_markers_and_persist_them() -> Result {
         let dir = tempfile::tempdir()?;
         let target = dir.path().join("a").join("file.tmp");
         let new_filename = target.parent().unwrap().join("file.ext");
@@ -88,7 +94,7 @@ mod at_path {
     use std::io::{ErrorKind, Write};
 
     #[test]
-    fn it_persists_tempfiles_along_with_newly_created_directories() -> crate::Result {
+    fn it_persists_tempfiles_along_with_newly_created_directories() -> Result {
         let dir = tempfile::tempdir()?;
         let target = dir.path().join("a").join("b").join("file.tmp");
         let new_filename = target.parent().unwrap().join("file.ext");
@@ -107,6 +113,10 @@ mod at_path {
         let err = handle
             .persist(&new_filename)
             .expect_err("cannot persist onto directory");
+        assert!(
+            std::error::Error::source(&err).is_some_and(<dyn std::error::Error>::is::<std::io::Error>),
+            "the persistence error exposes its I/O cause for classification"
+        );
         let handle = err.handle;
         std::fs::remove_dir(&new_filename)?;
 
@@ -128,7 +138,7 @@ mod at_path {
 
     #[test]
     #[cfg(windows)]
-    fn persistence_replaces_readonly_files_and_retains_the_tempfiles_permissions() -> crate::Result {
+    fn persistence_replaces_readonly_files_and_retains_the_tempfiles_permissions() -> Result {
         let dir = tempfile::tempdir()?;
         let tempfile_path = dir.path().join("file.lock");
         let destination = dir.path().join("file");
@@ -157,7 +167,7 @@ mod at_path {
     }
 
     #[test]
-    fn it_can_create_the_containing_directory_and_remove_it_on_drop() -> crate::Result {
+    fn it_can_create_the_containing_directory_and_remove_it_on_drop() -> Result {
         let dir = tempfile::tempdir()?;
         let first_dir = "dir";
         let filename = dir.path().join(first_dir).join("subdir").join("file.tmp");
@@ -183,13 +193,23 @@ mod at_path {
     }
 
     #[test]
-    fn it_names_files_correctly_and_similarly_named_tempfiles_cannot_be_created() -> crate::Result {
+    fn it_names_files_correctly_and_similarly_named_tempfiles_cannot_be_created() -> Result {
         let dir = tempfile::tempdir()?;
         let filename = dir.path().join("something-specific.ext");
         let tempfile = gix_tempfile::writable_at(&filename, ContainingDirectory::Exists, AutoRemove::Tempfile)?;
         let res = gix_tempfile::writable_at(&filename, ContainingDirectory::Exists, AutoRemove::Tempfile);
+        let failure = res.expect_err("the operation must fail");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[(&filename.to_string_lossy(), "<root>/something-specific.ext")]), "only one tempfile can be created at a time, they are exclusive", @r#"
+        Custom {
+            kind: AlreadyExists,
+            error: PathError {
+                path: "<root>/something-specific.ext",
+                err: AlreadyExists,
+            },
+        }
+        "#);
         assert!(
-            matches!(res, Err(err) if err.kind() == ErrorKind::AlreadyExists),
+            matches!(failure, err if err.kind() == ErrorKind::AlreadyExists),
             "only one tempfile can be created at a time, they are exclusive"
         );
         assert!(filename.is_file(), "specified file should exist precisely");
@@ -201,6 +221,7 @@ mod at_path {
 }
 
 mod new {
+    use crate::Result;
     use std::{
         io::{ErrorKind, Write},
         path::Path,
@@ -213,7 +234,7 @@ mod new {
     }
 
     #[test]
-    fn it_can_be_kept() -> crate::Result {
+    fn it_can_be_kept() -> Result {
         let dir = tempfile::tempdir()?;
         drop(
             gix_tempfile::new(dir.path(), ContainingDirectory::Exists, AutoRemove::Tempfile)?
@@ -226,7 +247,7 @@ mod new {
     }
 
     #[test]
-    fn it_is_removed_if_it_goes_out_of_scope() -> crate::Result {
+    fn it_is_removed_if_it_goes_out_of_scope() -> Result {
         let dir = tempfile::tempdir()?;
         {
             let _keep = gix_tempfile::new(dir.path(), ContainingDirectory::Exists, AutoRemove::Tempfile)?;
@@ -237,7 +258,7 @@ mod new {
     }
 
     #[test]
-    fn it_can_create_the_containing_directory_and_remove_it_when_dropped() -> crate::Result {
+    fn it_can_create_the_containing_directory_and_remove_it_when_dropped() -> Result {
         let dir = tempfile::tempdir()?;
         let containing_dir = dir.path().join("dir");
         assert!(!containing_dir.exists());
@@ -255,14 +276,15 @@ mod new {
                 "a temp file was created, as well as the directory"
             );
             writable.with_mut(|tf| tf.write_all(b"hello world"))??;
-            assert_eq!(
-                writable
-                    .with_mut(|_tf| Err::<(), std::io::Error>(ErrorKind::Other.into()))?
-                    .unwrap_err()
-                    .kind(),
-                ErrorKind::Other,
-                "errors are propagated"
-            );
+            let err = writable
+                .with_mut(|_tf| Err::<(), std::io::Error>(ErrorKind::Other.into()))?
+                .expect_err("the write closure failed");
+            insta::assert_debug_snapshot!(err, "temporary-file access propagates the write closure's error", @"
+            Kind(
+                Other,
+            )
+            ");
+            assert_eq!(err.kind(), ErrorKind::Other, "errors are propagated");
             writable
                 .with_mut(|tf| assert!(tf.path().is_file()))
                 .expect("after seeing an error before the file still exists");
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index acd49144936..196b043a183 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -27,7 +27,7 @@ anyhow = "1.0.98"
 clap = { version = "4.5.42", features = ["derive"] }
 crossterm = { version = "0.29.0", features = ["osc52"] }
 directories = "6.0.0"
-gix = { version = "^0.87.1", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "merge", "notes", "parallel", "revision", "command", "status"] }
+gix = { version = "^0.87.1", path = "../gix", default-features = false, features = ["anyhow", "blob-diff", "mailmap", "merge", "notes", "parallel", "revision", "command", "status"] }
 notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 terminal-colorsaurus = "1.0.3"
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6de71778e17..72f877fa31f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -100,6 +100,8 @@ without trading responsiveness for metadata that is not visible.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
+- Diagnostics retain underlying causes when adding command or argument context,
+  including encoding failures when OS-string conversions fail.
 - `--quit-on-finish[=INPUTS]` exits after traversal, lane computation, and one
   completed frame, for measurement and non-interactive inspection. Optional
   characters are replayed as read-only keyboard input before the retained final
@@ -143,6 +145,8 @@ without trading responsiveness for metadata that is not visible.
 - Revisions must resolve and peel to commits. Invalid or non-commit visible
   revisions are errors. An unavailable hidden revision emits a warning and is
   ignored when another hidden revision resolves; if none resolve, startup fails.
+- References that disappear during enumeration are ignored. Other errors while
+  reading references are reported.
 - The interactive UI owns the alternate screen by default. `--no-alt-screen`
   instead draws interactively on the normal screen. Raw mode, focus reporting,
   mouse capture, and enhanced keyboard reporting are restored on every exit path.
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index c317086b767..35b618ed588 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -23,7 +23,10 @@ pub(crate) fn for_commit(repo: &gix::Repository, id: ObjectId) -> Result<ChangeI
     let object = repo
         .find_commit(id)
         .context("could not read commit for its change ID")?;
-    let commit = object.decode().context("could not decode commit for its change ID")?;
+    let commit = object
+        .decode()
+        .map_err(gix::Error::from)
+        .context("could not decode commit for its change ID")?;
     Ok(effective(id, commit.extra_headers().find_all(HEADER)))
 }
 
@@ -132,6 +135,7 @@ pub(crate) fn scan(repo: &gix::Repository, ids: &[ObjectId]) -> Result<Scan> {
             .context("could not read commit while scanning change IDs")?;
         let commit = object
             .decode()
+            .map_err(gix::Error::from)
             .context("could not decode commit while scanning change IDs")?;
         let change_id = effective(id, commit.extra_headers().find_all(HEADER));
         if change_id != ChangeId::from(id) {
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 046552332b2..e96ea5f5f66 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -484,6 +484,7 @@ fn resolve_commit(
     description: &str,
 ) -> Result<(gix::ObjectId, Option<crate::history::HistoryGraph>)> {
     let revision = gix::path::os_str_into_bstr(revision)
+        .map_err(gix::Exn::into_error)
         .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
     match crate::history::resolve_revision(repository, revision) {
         Ok((id, _reference)) => Ok((id, None)),
@@ -572,6 +573,7 @@ fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<V
         .iter()
         .map(|revision| {
             let revision = gix::path::os_str_into_bstr(revision)
+                .map_err(gix::Exn::into_error)
                 .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
             let (id, reference) = crate::history::resolve_revision(repository, revision)
                 .with_context(|| format!("could not resolve revision {revision:?}"))?;
@@ -653,6 +655,7 @@ fn resolve_spill_paths(repository: &gix::Repository, paths: &[OsString]) -> Resu
     for path in paths {
         let display = path.to_string_lossy();
         let path = gix::path::os_str_into_bstr(path)
+            .map_err(gix::Exn::into_error)
             .with_context(|| format!("path {display:?} could not be converted to a Git path"))?;
         let path = repository
             .normalize_path(path)
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index 6851159fd65..5376b1809ba 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -43,6 +43,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .as_deref()
         .map(gix::path::os_str_into_bstr)
         .transpose()
+        .map_err(gix::Exn::into_error)
         .context("author is not valid UTF-8")?;
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index bb679a3ba5b..495e8b1c9eb 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -174,8 +174,9 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
 }
 
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
-    let revision =
-        gix::path::os_str_into_bstr(revision).with_context(|| format!("{description} is not valid UTF-8"))?;
+    let revision = gix::path::os_str_into_bstr(revision)
+        .map_err(gix::Exn::into_error)
+        .with_context(|| format!("{description} is not valid UTF-8"))?;
     crate::history::resolve_revision(repo, revision)
         .with_context(|| format!("could not resolve {description}"))
         .map(|(id, _reference)| id)
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 52da6721c16..8efed53c9c6 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -53,6 +53,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .as_deref()
         .map(gix::path::os_str_into_bstr)
         .transpose()
+        .map_err(gix::Exn::into_error)
         .context("author is not valid UTF-8")?;
 
     if let Some(message) = explicit_message(&args.edit, std::io::stdin())? {
@@ -125,6 +126,7 @@ pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Resu
             }
             out.extend_from_slice(
                 gix::path::os_str_into_bstr(message)
+                    .map_err(gix::Exn::into_error)
                     .with_context(|| format!("message {} is not valid UTF-8", index + 1))?,
             );
         }
@@ -237,6 +239,25 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    #[cfg(windows)]
+    fn invalid_message_encoding_retains_its_cause() {
+        use std::{ffi::OsString, os::windows::ffi::OsStringExt};
+
+        let mut message_args = args("HEAD");
+        message_args.edit.message = vec![OsString::from_wide(&[0xd800])];
+        let err = explicit_message(&message_args.edit, &b""[..]).expect_err("lone surrogates are not UTF-8");
+        assert_eq!(err.to_string(), "message 1 is not valid UTF-8");
+        let cause = err
+            .downcast_ref::<gix::Error>()
+            .expect("the path error remains available");
+        assert!(cause.is_validation());
+        assert!(
+            cause.downcast_any_ref::<std::str::Utf8Error>().is_some(),
+            "adding command context preserves the concrete encoding error"
+        );
+    }
+
     #[test]
     fn message_bypasses_the_editor_and_rewords_head() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 3e371b9e353..0fc317ba9b2 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -76,6 +76,7 @@ fn prepare_inner(
         .context("no Git author is configured")?
         .context("could not resolve the Git author")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git author")?;
     if let Some(value) = author_override {
         author = reword::actor(value, author.time, "author")?;
@@ -85,6 +86,7 @@ fn prepare_inner(
         .context("no Git committer is configured")?
         .context("could not resolve the Git committer")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git committer")?;
     repo.commit_signing_options_if_enabled()
         .context("could not resolve commit signing configuration")?;
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 9b86b95a1df..afc84c30fe3 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -70,8 +70,10 @@ fn perform_inner(
         .find_commit(head)
         .context("could not find HEAD commit")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode HEAD commit")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own HEAD commit")?;
     repo.workdir().context("editing HEAD requires a worktree")?;
     repo.commit_signing_options_if_enabled()
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index bf5c9cae4d8..3773223b649 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -8,7 +8,7 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
     }
     let mut revisions = Vec::new();
     for reference in repo.references()?.all()? {
-        let reference = reference.map_err(|err| anyhow::anyhow!("could not read reference: {err}"))?;
+        let reference = reference.context("could not read reference")?;
         if reference.name().as_bstr().starts_with(crate::history::STASH_PREFIX)
             || reference
                 .name()
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index b772dbb73a2..e308ce1a14a 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -17,7 +17,7 @@ use gix::{
     },
 };
 
-use crate::history::HistoryGraph;
+use crate::history::{HistoryGraph, is_missing_ref};
 
 const MARKER: &[u8] = b"tix-rebase";
 const ORIGINAL_PARENT: &[u8] = b"tix-rebase-parent";
@@ -359,6 +359,7 @@ impl PersistedConflict {
             .find_commit(self.commit)
             .context("could not find the conflicting commit")?
             .tree_id()
+            .map_err(gix::Error::from)
             .context("could not read the conflicting commit tree")?
             .detach();
         let workdir = self
@@ -369,6 +370,7 @@ impl PersistedConflict {
             .context("could not check out the conflicting merge result")?;
         if let Err(err) = index
             .write(gix::index::write::Options::default())
+            .map_err(gix::Exn::into_error)
             .context("could not write the conflicting index")
         {
             return match super::forget::apply_tree_transition(workdir, self.merged_tree, ours_tree) {
@@ -407,7 +409,7 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
     for reference in repo.references()?.all()? {
         let reference = match reference {
             Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) if is_missing_ref(&err) => continue,
             Err(err) => anyhow::bail!("could not inspect a reference before editing: {err}"),
         };
         if matches!(
@@ -555,8 +557,10 @@ pub(crate) fn copy_insert_plan(
         .find_commit(source)
         .context("could not find the copy source")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode the copy source")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own the copy source")?;
     if super::review::reference(&source_commit)?.is_some() {
         anyhow::bail!("review commits cannot be copied");
@@ -1103,6 +1107,7 @@ fn perform_inner(
         .context("no Git committer is configured")?
         .context("could not resolve the Git committer")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git committer")?;
     repo = repo.with_object_memory();
 
@@ -1163,16 +1168,20 @@ fn perform_inner(
                     .find_commit(old_id)
                     .context("could not find commit to rewrite")?
                     .decode()
+                    .map_err(gix::Error::from)
                     .context("could not decode commit to rewrite")?
                     .into_owned()
+                    .map_err(gix::Error::from)
                     .context("could not own commit to rewrite")?,
             }
         } else {
             repo.find_commit(old_id)
                 .context("could not find descendant commit")?
                 .decode()
+                .map_err(gix::Error::from)
                 .context("could not decode descendant commit")?
                 .into_owned()
+                .map_err(gix::Error::from)
                 .context("could not own descendant commit")?
         };
         let new_parents: Vec<_> = old_parents
@@ -1626,12 +1635,14 @@ pub(crate) fn perform_plan_with_progress(
         .context("no Git author is configured")?
         .context("could not resolve the Git author")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git author")?;
     let committer = repo
         .committer()
         .context("no Git committer is configured")?
         .context("could not resolve the Git committer")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git committer")?;
     repo = repo.with_object_memory();
 
@@ -1710,8 +1721,10 @@ pub(crate) fn perform_plan_with_progress(
                 .find_commit(*id)
                 .context("could not find a picked commit")?
                 .decode()
+                .map_err(gix::Error::from)
                 .context("could not decode a picked commit")?
                 .into_owned()
+                .map_err(gix::Error::from)
                 .context("could not own a picked commit")?,
             PlanCommit::Resolved(planned) => {
                 let head = repo
@@ -1721,8 +1734,10 @@ pub(crate) fn perform_plan_with_progress(
                 resolved_head = Some((*planned, head.id));
                 let mut commit = head
                     .decode()
+                    .map_err(gix::Error::from)
                     .context("could not decode the conflicted HEAD commit")?
                     .into_owned()
+                    .map_err(gix::Error::from)
                     .context("could not own the conflicted HEAD commit")?;
                 let index = repo
                     .index_or_empty()
@@ -1817,8 +1832,10 @@ pub(crate) fn perform_plan_with_progress(
                 .find_commit(*id)
                 .context("could not find a squashed commit")?
                 .decode()
+                .map_err(gix::Error::from)
                 .context("could not decode a squashed commit")?
                 .into_owned()
+                .map_err(gix::Error::from)
                 .context("could not own a squashed commit")?;
             let graph_parents = graph.parents_of(*id).context("a squashed commit is incomplete")?;
             let recorded_parent = has_marker(&source).then(|| marked_parent(&source)).transpose()?;
@@ -2155,7 +2172,8 @@ impl Prepared {
         for (id, (kind, data)) in objects.iter() {
             self.repo
                 .write_buf_with_known_id(*kind, data, *id)
-                .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
+                .map_err(gix::Exn::into_error)
+                .context("could not persist a prepared rebase object")?;
         }
         self.repo.objects.set_object_memory(Default::default());
         Ok(())
@@ -2530,6 +2548,7 @@ fn reset_index_paths(repo: &gix::Repository, id: ObjectId, paths: &[BString]) ->
     index.remove_tree();
     index
         .write(gix::index::write::Options::default())
+        .map_err(gix::Exn::into_error)
         .context("could not update selected index paths")
 }
 
@@ -2793,6 +2812,7 @@ pub(crate) fn marked_parent_ref(commit: &gix::objs::CommitRef<'_>) -> Result<Opt
 
 fn parse_marked_parent(value: &BStr) -> Result<Option<ObjectId>> {
     ObjectId::from_hex(value)
+        .map_err(gix::Error::from)
         .context("pending rebase has an invalid original parent")
         .map(|id| (!id.is_null()).then_some(id))
 }
@@ -2840,7 +2860,10 @@ fn write_commit_timed(
     commit = match (signature, signing) {
         (Signature::RedoIfNeeded, Some(options)) => {
             let started = Instant::now();
-            let signed = commit.sign(options).context("could not sign rebased commit")?;
+            let signed = commit
+                .sign(options)
+                .map_err(gix::Exn::into_error)
+                .context("could not sign rebased commit")?;
             signing_time = Some(started.elapsed());
             signed
         }
@@ -2983,7 +3006,7 @@ fn update_refs(
         for reference in repo.references()?.all()? {
             let reference = match reference {
                 Ok(reference) => reference,
-                Err(err) if is_missing_ref(&*err) => continue,
+                Err(err) if is_missing_ref(&err) => continue,
                 Err(err) => anyhow::bail!("could not inspect a reference before rebasing: {err}"),
             };
             if matches!(
@@ -3126,19 +3149,6 @@ fn pin_name(
     }
 }
 
-fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
-    loop {
-        if err
-            .downcast_ref::<std::io::Error>()
-            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
-        {
-            return true;
-        }
-        let Some(source) = err.source() else { return false };
-        err = source;
-    }
-}
-
 fn ref_edit(name: gix::refs::FullName, old: Option<ObjectId>, new: Option<ObjectId>) -> RefEdit {
     match (old, new) {
         (Some(old), Some(new)) => RefEdit::update_with_log(
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 8138ce9ae65..59720eda341 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -90,8 +90,10 @@ pub(crate) fn document_with_author(
         .find_commit(id)
         .context("could not find commit to reword")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode commit to reword")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own commit to reword")?;
     if let Some(author) = author {
         commit.author = actor(author, commit.author.time, "author")?;
@@ -101,6 +103,7 @@ pub(crate) fn document_with_author(
         .context("no Git committer is configured")?
         .context("could not resolve the Git committer")?
         .to_owned()
+        .map_err(gix::Error::from)
         .context("could not own the Git committer")?;
     let enrichment = crate::enrich::load(&mut crate::enrich::open(repo)?, crate::change_id::for_commit(repo, id)?)?;
 
@@ -167,8 +170,10 @@ pub(crate) fn apply_conflict_reporting(
         .find_commit(old_id)
         .context("could not find commit after editing")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode commit after editing")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own commit after editing")?;
     let author = actor(edit.author, edit.author_time, "author")?;
     let commit_changed = author != commit.author || edit.message != commit.message;
@@ -227,8 +232,10 @@ pub(crate) fn apply_message_reporting(
         .find_commit(old_id)
         .context("could not find commit to reword")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode commit to reword")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own commit to reword")?;
     let changed_author = author
         .map(|author| actor(author, commit.author.time, "author"))
@@ -452,6 +459,7 @@ fn date(value: &[u8], field: &str) -> Result<gix::date::Time> {
 
 pub(super) fn actor(value: &[u8], time: gix::date::Time, field: &str) -> Result<gix::actor::Signature> {
     let parsed = gix::actor::SignatureRef::from_bytes(value)
+        .map_err(gix::Error::from)
         .with_context(|| format!("could not parse {field} identity"))?
         .trim();
     if parsed.name.is_empty() || parsed.email.is_empty() || !parsed.time.is_empty() {
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 34c5cc62a35..db18b3dc133 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -33,8 +33,10 @@ pub(crate) fn prepare(mut repo: gix::Repository, todo: bool) -> Result<Prepared>
         .find_commit(target)
         .context("could not find HEAD commit")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode HEAD commit")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own HEAD commit")?;
     let mut create = create::prepare_from(repo.clone(), Some(target), create::Source::Default, None, todo)?;
     repo.objects.set_object_memory(std::mem::take(&mut create.objects));
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
index e57ba1ff3d7..436eb2b2bb5 100644
--- a/gix-tix/src/edit/stash.rs
+++ b/gix-tix/src/edit/stash.rs
@@ -31,7 +31,9 @@ pub(crate) fn associated_commit(name: &BStr) -> Result<Option<ObjectId>> {
     let Some(suffix) = name.strip_prefix(crate::history::STASH_PREFIX) else {
         return Ok(None);
     };
-    let id = ObjectId::from_hex(suffix).context("tix stash reference has an invalid commit ID")?;
+    let id = ObjectId::from_hex(suffix)
+        .map_err(gix::Error::from)
+        .context("tix stash reference has an invalid commit ID")?;
     if id.to_hex().to_string().as_bytes() != suffix {
         anyhow::bail!("tix stash reference does not use a canonical full commit ID");
     }
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 9e8e8b8ef8b..c38e9a2a71b 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -498,8 +498,10 @@ fn commit_states(
         .find_commit(id)
         .context("could not load a commit state for the rebase todo")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode a commit state for the rebase todo")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own a commit state for the rebase todo")?;
     let pending = commit.extra_headers.iter().any(|(name, _)| name == "tix-rebase-parent");
     let mut empty_signature = false;
@@ -563,6 +565,7 @@ fn anchor_title(repo: &gix::Repository, id: ObjectId) -> Result<String> {
         .find_commit(id)
         .context("could not load the rebase anchor")?
         .message_raw()
+        .map_err(gix::Error::from)
         .context("could not decode the rebase anchor message")?
         .to_owned();
     let mut notes = repo.notes().context("could not open Git notes for the rebase anchor")?;
@@ -1068,6 +1071,7 @@ fn resolve_commit(repo: &gix::Repository, value: &str) -> Result<ObjectId> {
     id.object()
         .context("could not load a todo object")?
         .try_into_commit()
+        .map_err(gix::Error::from)
         .context("a todo ID does not name a commit")?;
     Ok(id.detach())
 }
diff --git a/gix-tix/src/edit/undo.rs b/gix-tix/src/edit/undo.rs
index 7e2dc02d2d6..c978f5d72d3 100644
--- a/gix-tix/src/edit/undo.rs
+++ b/gix-tix/src/edit/undo.rs
@@ -160,7 +160,7 @@ pub(crate) fn review_blocks_undo(repo: &gix::Repository) -> Result<bool> {
     {
         let reference = match reference {
             Ok(reference) => reference,
-            Err(err) if crate::history::is_missing_ref(&*err) => continue,
+            Err(err) if crate::history::is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read review reference: {err}")),
         };
         if crate::history::review_number(reference.name().as_bstr()).is_some() {
@@ -498,6 +498,7 @@ fn tree_id(repo: &gix::Repository, commit: Option<ObjectId>) -> Result<ObjectId>
             repo.find_commit(commit)
                 .context("a worktree HEAD target is not a commit")?
                 .tree_id()
+                .map_err(gix::Error::from)
                 .context("could not decode a worktree HEAD commit")
                 .map(gix::Id::detach)
         },
@@ -568,16 +569,20 @@ fn serialize_config(changes: &[RefChange]) -> Result<File> {
     config
         .new_section("undo", None)?
         .set("version", VERSION)
+        .map_err(gix::Error::from)
         .context("could not serialize the undo version")?;
     for change in changes {
         let mut section = config
             .new_section("ref", change.name.as_bstr())
+            .map_err(gix::Error::from)
             .context("could not serialize an undo reference")?;
         section
             .set("before", encode_state(&change.before))
+            .map_err(gix::Error::from)
             .context("could not serialize an undo before-state")?;
         section
             .set("after", encode_state(&change.after))
+            .map_err(gix::Error::from)
             .context("could not serialize an undo after-state")?;
     }
     Ok(config)
@@ -654,7 +659,9 @@ fn parse_state(repo: &gix::Repository, value: &BStr) -> Result<State> {
         return Ok(State::Missing);
     }
     if let Some(hex) = value.strip_prefix(b"object:") {
-        let id = ObjectId::from_hex(hex).context("an undo object ID is invalid")?;
+        let id = ObjectId::from_hex(hex)
+            .map_err(gix::Error::from)
+            .context("an undo object ID is invalid")?;
         ensure!(
             id.kind() == repo.object_hash(),
             "an undo object ID uses the wrong hash kind"
@@ -836,8 +843,10 @@ fn parse_commit(repo: &gix::Repository, id: ObjectId) -> Result<ParsedCommit> {
         .find_commit(id)
         .with_context(|| format!("could not find undo queue commit {id}"))?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode an undo queue commit")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own an undo queue commit")?;
     ensure!(
         commit.tree == ObjectId::empty_tree(repo.object_hash()),
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index 39513867774..9a6c5e16c20 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -63,6 +63,7 @@ pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Resu
     Ok(Enrichment {
         todo: config
             .boolean("commit.todo")
+            .map_err(gix::Exn::into_error)
             .context("commit.todo is not a boolean")?
             .unwrap_or(false),
         note: config.string("commit.note").filter(|note| !note.is_empty()),
@@ -76,6 +77,7 @@ pub(crate) fn load_tree(notes: &mut gix::note::Platform, tree_id: ObjectId) -> R
     Ok(TreeEnrichment {
         checks_pass: config
             .boolean("tree.checks-pass")
+            .map_err(gix::Exn::into_error)
             .context("tree.checks-pass is not a boolean")?
             .unwrap_or(false),
     })
@@ -95,6 +97,7 @@ pub(crate) fn tree_id(repo: &gix::Repository, commit_id: ObjectId) -> Result<Obj
     repo.find_commit(commit_id)
         .context("could not find the enriched commit")?
         .tree_id()
+        .map_err(gix::Error::from)
         .context("could not read the enriched commit tree")
         .map(gix::Id::detach)
 }
@@ -103,6 +106,7 @@ pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enri
     update(repo, commit_id, |config| {
         let enabled = !config
             .boolean("commit.todo")
+            .map_err(gix::Exn::into_error)
             .context("commit.todo is not a boolean")?
             .unwrap_or(false);
         set_todo(config, enabled)
@@ -120,8 +124,10 @@ pub(crate) fn ensure_todo(repo: &gix::Repository, commit_id: ObjectId, enabled:
 fn set_todo(config: &mut File, enabled: bool) -> Result<()> {
     config
         .section_mut_or_create_new("commit", None)
+        .map_err(gix::Error::from)
         .context("could not create the commit enrichment section")?
         .set("todo", if enabled { "true" } else { "false" })
+        .map_err(gix::Error::from)
         .context("could not update commit.todo")?;
     Ok(())
 }
@@ -130,10 +136,14 @@ pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option
     update(repo, commit_id, |config| {
         let mut section = config
             .section_mut_or_create_new("commit", None)
+            .map_err(gix::Error::from)
             .context("could not create the commit enrichment section")?;
         match note {
             Some(note) => {
-                section.set("note", note).context("could not update commit.note")?;
+                section
+                    .set("note", note)
+                    .map_err(gix::Error::from)
+                    .context("could not update commit.note")?;
             }
             None => {
                 section.remove("note");
@@ -148,6 +158,7 @@ pub(crate) fn toggle_checks_pass(repo: &gix::Repository, commit_id: ObjectId) ->
     update_tree(repo, tree_id, |config| {
         let enabled = !config
             .boolean("tree.checks-pass")
+            .map_err(gix::Exn::into_error)
             .context("tree.checks-pass is not a boolean")?
             .unwrap_or(false);
         set_checks_pass(config, enabled)
@@ -166,8 +177,10 @@ pub(crate) fn ensure_checks_pass(repo: &gix::Repository, commit_id: ObjectId, en
 fn set_checks_pass(config: &mut File, enabled: bool) -> Result<()> {
     config
         .section_mut_or_create_new("tree", None)
+        .map_err(gix::Error::from)
         .context("could not create the tree enrichment section")?
         .set("checks-pass", if enabled { "true" } else { "false" })
+        .map_err(gix::Error::from)
         .context("could not update tree.checks-pass")?;
     Ok(())
 }
@@ -226,13 +239,18 @@ pub(crate) fn prepare_headers(
     let mut config = load_config(&mut notes, object)?.unwrap_or_default();
     let mut section = config
         .section_mut_or_create_new("commit", None)
+        .map_err(gix::Error::from)
         .context("could not create the commit enrichment section")?;
     section
         .set("todo", if desired.todo { "true" } else { "false" })
+        .map_err(gix::Error::from)
         .context("could not update commit.todo")?;
     match desired.note.as_ref().map(|note| note.as_bstr()) {
         Some(note) => {
-            section.set("note", note).context("could not update commit.note")?;
+            section
+                .set("note", note)
+                .map_err(gix::Error::from)
+                .context("could not update commit.note")?;
         }
         None => {
             section.remove("note");
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index e32ac96dba6..50c978525c6 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1,3 +1,4 @@
+use gix::ExnMessageResult;
 use std::{
     cmp::Ordering as CmpOrdering,
     collections::{BTreeSet, HashMap, HashSet},
@@ -378,13 +379,17 @@ impl HistoryGraph {
             return Ok(index);
         }
         let commit = gix::traverse::commit::find(cache, &repo.objects, &id, buf)
+            .map_err(gix::Exn::into_error)
             .context("could not load commit for cached history traversal")?;
         let (mut parents, commit_time, generation) = match commit {
             gix::traverse::commit::Either::CommitRefIter(iter) => {
                 let mut parents = gix::traverse::commit::ParentIds::new();
                 let mut commit_time = 0;
                 for token in iter {
-                    match token.context("could not decode cached history commit")? {
+                    match token
+                        .map_err(gix::Error::from)
+                        .context("could not decode cached history commit")?
+                    {
                         Token::Tree { .. } => {}
                         Token::Parent { id } => parents.push(id),
                         Token::Committer { signature } => {
@@ -400,8 +405,9 @@ impl HistoryGraph {
                 let cache = cache.expect("cached commits originate from the provided commit-graph");
                 let mut parents = gix::traverse::commit::ParentIds::new();
                 for parent in commit.iter_parents() {
-                    let parent =
-                        parent.map_err(|err| anyhow::anyhow!("could not decode commit-graph parent: {err}"))?;
+                    let parent = parent
+                        .map_err(gix::Error::from)
+                        .context("could not decode commit-graph parent")?;
                     parents.push(cache.id_at(parent).to_owned());
                 }
                 (
@@ -956,7 +962,7 @@ fn local_refs_by_target(repo: &gix::Repository) -> Result<HashMap<ObjectId, Vec<
     for reference in refs {
         let reference = match reference {
             Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) if is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read local branch: {err}")),
         };
         out.entry(reference.id().detach())
@@ -1273,7 +1279,7 @@ pub(crate) fn ref_tree_revisions(repo: &gix::Repository, include_tags: bool) ->
     {
         let mut reference = match reference {
             Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) if is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let name = reference.name().as_bstr().to_owned();
@@ -1484,7 +1490,7 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
     {
         let mut reference = match reference {
             Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) if is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read tix {label}: {err}")),
         };
         let suffix = reference.name().as_bstr().strip_prefix(prefix).unwrap_or_default();
@@ -1574,6 +1580,7 @@ pub(crate) fn referenced_refs(
     let mut out = HashMap::new();
     for revision in revisions {
         let revision = gix::path::os_str_into_bstr(revision)
+            .map_err(gix::Exn::into_error)
             .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
         let spec = repo
             .rev_parse(revision)
@@ -1657,7 +1664,7 @@ fn decode_commit(
 }
 
 fn decode_metadata<'a>(
-    tokens: impl Iterator<Item = Result<Token<'a>, gix::objs::decode::Error>>,
+    tokens: impl Iterator<Item = ExnMessageResult<Token<'a>>>,
     authors: &mut Authors,
     attributions: &mut Vec<Attribution>,
 ) -> Result<Metadata<BString>> {
@@ -1670,14 +1677,24 @@ fn decode_metadata<'a>(
     let mut is_review = false;
     let mut signature = SignatureState::Unsigned;
     for token in tokens {
-        match token.context("could not decode commit")? {
+        match token.map_err(gix::Error::from).context("could not decode commit")? {
             Token::Author { signature } => {
-                author_time = Some(signature.time().context("could not decode author time")?);
+                author_time = Some(
+                    signature
+                        .time()
+                        .map_err(gix::Error::from)
+                        .context("could not decode author time")?,
+                );
                 let signature = signature.trim();
                 author = Some(authors.intern_author(signature.name, signature.email));
             }
             Token::Committer { signature } => {
-                committer_time = Some(signature.time().context("could not decode committer time")?);
+                committer_time = Some(
+                    signature
+                        .time()
+                        .map_err(gix::Error::from)
+                        .context("could not decode committer time")?,
+                );
             }
             Token::Message(message) => {
                 has_agent_marker = contains_agent_marker(message);
@@ -1844,6 +1861,7 @@ fn resolve_revisions(repo: &gix::Repository, revisions: &[OsString], kind: &str)
         .iter()
         .map(|revision| {
             let revision = gix::path::os_str_into_bstr(revision)
+                .map_err(gix::Exn::into_error)
                 .with_context(|| format!("{kind}revision {} is not valid UTF-8", revision.to_string_lossy()))?;
             resolve_revision(repo, revision)
                 .with_context(|| format!("could not resolve {kind}revision {revision}"))
@@ -1927,7 +1945,7 @@ pub(crate) fn decorations_excluding(
     {
         let mut reference = match reference {
             Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) if is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let full_name = reference.name().to_owned();
@@ -2082,17 +2100,8 @@ pub(crate) fn decorations_excluding(
     Ok(out)
 }
 
-pub(crate) fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
-    loop {
-        if err
-            .downcast_ref::<std::io::Error>()
-            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
-        {
-            return true;
-        }
-        let Some(source) = err.source() else { return false };
-        err = source;
-    }
+pub(crate) fn is_missing_ref(err: &gix::Error) -> bool {
+    err.is_not_found()
 }
 
 pub(crate) fn decoration_kind(name: &[u8]) -> DecorationKind {
@@ -2170,9 +2179,13 @@ mod tests {
 
     #[test]
     fn only_missing_ref_reads_are_ignored() {
-        let ref_error = |kind| gix::refs::file::iter::loose_then_packed::Error::ReadFileContents {
-            source: std::io::Error::from(kind),
-            path: "refs/heads/racing".into(),
+        let ref_error = |kind| {
+            gix::Exn::new(std::io::Error::from(kind))
+                .raise(
+                    gix::error::Message::new("Could not read reference")
+                        .with("path", std::path::Path::new("refs/heads/racing")),
+                )
+                .into_error()
         };
         assert!(
             is_missing_ref(&ref_error(std::io::ErrorKind::NotFound)),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 22d17dd049a..3ae63cfb755 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -543,6 +543,7 @@ fn set_worktree_resources(
             gix::diff::blob::ResourceKind::OldOrSource,
             repository,
         )
+        .map_err(gix::Exn::into_error)
         .context("could not prepare old worktree diff resource")?;
     let new_resource = new.unwrap_or(fallback);
     cache
@@ -553,6 +554,7 @@ fn set_worktree_resources(
             gix::diff::blob::ResourceKind::NewOrDestination,
             repository,
         )
+        .map_err(gix::Exn::into_error)
         .context("could not prepare new worktree diff resource")?;
     Ok(())
 }
@@ -569,12 +571,14 @@ fn line_counts_for_change(
             .diff(tree_cache)
             .context("could not prepare line diff")?
             .line_counts()
+            .map_err(gix::Error::from)
             .context("could not count changed lines")?,
         FileChange::Worktree { old, new } => {
             let cache = worktree_cache.context("a working tree is required to count changed lines")?;
             set_worktree_resources(repository, cache, old.as_ref(), new.as_ref())?;
             gix::object::blob::diff::Platform { resource_cache: cache }
                 .line_counts()
+                .map_err(gix::Error::from)
                 .context("could not count worktree changed lines")?
         }
         FileChange::Unavailable(_) => None,
@@ -1923,7 +1927,8 @@ fn event_loop(
                                 let result = repository.delete_local_branches(names);
                                 let changed = result.is_ok()
                                     || result.as_ref().is_err_and(|err| {
-                                        matches!(err, gix::repository::branch::delete::Error::Cleanup { .. })
+                                        err.downcast_any_ref::<gix::repository::branch::delete::CleanupError>()
+                                            .is_some()
                                     });
                                 if changed {
                                     let recorded = before
@@ -4422,8 +4427,10 @@ fn reconcile_external_conflict(
         .find_commit(replacement)
         .context("the replacement HEAD is not a commit")?
         .decode()
+        .map_err(gix::Error::from)
         .context("could not decode the replacement HEAD commit")?
         .into_owned()
+        .map_err(gix::Error::from)
         .context("could not own the replacement HEAD commit")?;
     anyhow::ensure!(
         replacement_commit.parents.as_slice() == expected.parents,
@@ -5116,6 +5123,7 @@ fn prepare_file_diff_content(
         .trusted_program(gix::config::tree::Diff::EXTERNAL)
         .map(gix::path::os_string_into_bstring)
         .transpose()
+        .map_err(gix::Exn::into_error)
         .context("external diff command is not representable on this platform")?;
     let mut resources = match change {
         FileChange::Tree(_) => repository
@@ -5144,7 +5152,10 @@ fn prepare_file_diff_content(
         }
         FileChange::Unavailable(_) => unreachable!("handled above"),
     }
-    let prepared = resources.prepare_diff().context("could not prepare selected diff")?;
+    let prepared = resources
+        .prepare_diff()
+        .map_err(gix::Error::from)
+        .context("could not prepare selected diff")?;
     match prepared.operation {
         gix::diff::blob::platform::prepare_diff::Operation::ExternalCommand { command } => {
             let counts = count_lines
@@ -5229,6 +5240,7 @@ fn prepare_external_diff(
             0,
             1,
         )
+        .map_err(gix::Exn::into_error)
         .context("could not prepare external diff command")
 }
 
@@ -6216,7 +6228,10 @@ fn load_changes_without_lines(repository: &gix::Repository, target: app::TreeDif
     };
     let commit = repository.find_commit(id).context("could not load changed paths")?;
     let marked_parent = {
-        let decoded = commit.decode().context("could not decode changed commit")?;
+        let decoded = commit
+            .decode()
+            .map_err(gix::Error::from)
+            .context("could not decode changed commit")?;
         edit::rebase::marked_parent_ref(&decoded)?
     };
     let parents: Vec<_> = commit.parent_ids().map(gix::Id::detach).collect();
@@ -6709,7 +6724,7 @@ fn load_staged_changes_without_lines(repository: &gix::Repository) -> Result<Cha
             gix::status::tree_index::TrackRenames::AsConfigured,
             |change, _, _| {
                 raw.push(change.into_owned());
-                Ok::<_, std::convert::Infallible>(std::ops::ControlFlow::Continue(()))
+                Ok::<_, gix::Exn>(std::ops::ControlFlow::Continue(()))
             },
         )
         .context("could not obtain staged status")?;
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 0d9b9f1e059..cba8091cb5c 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -825,7 +825,7 @@ pub(crate) fn pin_references_reporting(
     {
         let mut reference = match reference {
             Ok(reference) => reference,
-            Err(err) if crate::history::is_missing_ref(&*err) => continue,
+            Err(err) if crate::history::is_missing_ref(&err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference to pin: {err}")),
         };
         let name = reference.name().to_owned();
diff --git a/gix-tix/src/test_repository.rs b/gix-tix/src/test_repository.rs
index 9509ba5a559..f4ba24119e6 100644
--- a/gix-tix/src/test_repository.rs
+++ b/gix-tix/src/test_repository.rs
@@ -9,11 +9,11 @@ const DEFAULT_OVERRIDES: &[&str] = &[
     "core.editor=:",
 ];
 
-pub(crate) fn open(path: impl AsRef<Path>) -> Result<gix::Repository, gix::open::Error> {
+pub(crate) fn open(path: impl AsRef<Path>) -> Result<gix::Repository, gix::Error> {
     open_with(path, std::iter::empty::<String>())
 }
 
-pub(crate) fn open_with<I, S>(path: impl AsRef<Path>, overrides: I) -> Result<gix::Repository, gix::open::Error>
+pub(crate) fn open_with<I, S>(path: impl AsRef<Path>, overrides: I) -> Result<gix::Repository, gix::Error>
 where
     I: IntoIterator<Item = S>,
     S: Into<String>,
diff --git a/gix-transport/Cargo.toml b/gix-transport/Cargo.toml
index a8eae901043..a4b7aad48a3 100644
--- a/gix-transport/Cargo.toml
+++ b/gix-transport/Cargo.toml
@@ -109,7 +109,6 @@ bstr = { version = "1.12.0", default-features = false, features = [
     "std",
     "unicode",
 ] }
-thiserror = "2.0.18"
 parking_lot = { version = "0.12.4", optional = true }
 
 # for async-client
@@ -135,6 +134,8 @@ async-std = { version = "1.12.0", optional = true }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
+insta = "1.46.3"
 gix-transport = { path = ".", features = ["parking_lot"] }
 gix-pack = { path = "../gix-pack", default-features = false, features = [
     "sha1",
diff --git a/gix-transport/src/client/async_io/bufread_ext.rs b/gix-transport/src/client/async_io/bufread_ext.rs
index f9b25886679..b8842f9c022 100644
--- a/gix-transport/src/client/async_io/bufread_ext.rs
+++ b/gix-transport/src/client/async_io/bufread_ext.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     io,
     ops::{Deref, DerefMut},
@@ -31,9 +32,7 @@ pub trait ReadlineBufRead: AsyncBufRead {
     ///  * natural EOF
     ///  * ERR packet line encountered
     ///  * A `delimiter` packet line encountered
-    async fn readline(
-        &mut self,
-    ) -> Option<io::Result<Result<gix_packetline::PacketLineRef<'_>, gix_packetline::decode::Error>>>;
+    async fn readline(&mut self) -> Option<io::Result<ExnMessageResult<gix_packetline::PacketLineRef<'_>>>>;
 
     /// Read a line similar to `BufRead::read_line()`, but assure it doesn't try to find newlines
     /// which might concatenate multiple distinct packet lines.
@@ -51,7 +50,7 @@ pub trait ExtendedBufRead<'a>: ReadlineBufRead {
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress<'a>>);
     /// Peek the next data packet line. Maybe None if the next line is a packet we stop at, queryable using
     /// [`stopped_at()`][ExtendedBufRead::stopped_at()].
-    async fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>>;
+    async fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>>;
     /// Resets the reader to allow reading past a previous stop, and sets delimiters according to the
     /// given protocol.
     fn reset(&mut self, version: Protocol);
@@ -61,7 +60,7 @@ pub trait ExtendedBufRead<'a>: ReadlineBufRead {
 
 #[async_trait(?Send)]
 impl<T: ReadlineBufRead + ?Sized + Unpin> ReadlineBufRead for Box<T> {
-    async fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    async fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         self.deref_mut().readline().await
     }
     async fn readline_str(&mut self, line: &mut String) -> io::Result<usize> {
@@ -75,7 +74,7 @@ impl<'a, T: ExtendedBufRead<'a> + ?Sized + 'a + Unpin> ExtendedBufRead<'a> for B
         self.deref_mut().set_progress_handler(handle_progress);
     }
 
-    async fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>> {
+    async fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>> {
         self.deref_mut().peek_data_line().await
     }
 
@@ -90,7 +89,7 @@ impl<'a, T: ExtendedBufRead<'a> + ?Sized + 'a + Unpin> ExtendedBufRead<'a> for B
 
 #[async_trait(?Send)]
 impl<T: AsyncRead + Unpin> ReadlineBufRead for WithSidebands<'_, T, for<'b> fn(bool, &'b [u8]) -> ProgressAction> {
-    async fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    async fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         self.read_data_line().await
     }
     async fn readline_str(&mut self, line: &mut String) -> io::Result<usize> {
@@ -100,7 +99,7 @@ impl<T: AsyncRead + Unpin> ReadlineBufRead for WithSidebands<'_, T, for<'b> fn(b
 
 #[async_trait(?Send)]
 impl<'a, T: AsyncRead + Unpin> ReadlineBufRead for WithSidebands<'a, T, HandleProgress<'a>> {
-    async fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    async fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         self.read_data_line().await
     }
     async fn readline_str(&mut self, line: &mut String) -> io::Result<usize> {
@@ -113,7 +112,7 @@ impl<'a, T: AsyncRead + Unpin> ExtendedBufRead<'a> for WithSidebands<'a, T, Hand
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress<'a>>) {
         self.set_progress_handler(handle_progress);
     }
-    async fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>> {
+    async fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>> {
         match self.peek_data_line().await {
             Some(Ok(Ok(line))) => Some(Ok(Ok(line))),
             Some(Ok(Err(err))) => Some(Ok(Err(err.into()))),
diff --git a/gix-transport/src/client/async_io/connect.rs b/gix-transport/src/client/async_io/connect.rs
index 01669388672..1d9185e701c 100644
--- a/gix-transport/src/client/async_io/connect.rs
+++ b/gix-transport/src/client/async_io/connect.rs
@@ -1,8 +1,10 @@
-pub use crate::client::non_io_types::connect::{Error, Options};
+pub use crate::client::non_io_types::connect::Options;
 
 #[cfg(feature = "async-std")]
 pub(crate) mod function {
-    use crate::client::{async_io::Transport, git::async_io::Connection, non_io_types::connect::Error};
+    use crate::client::{async_io::Transport, git::async_io::Connection};
+    use gix_error::ExnMessageResult;
+    use gix_error::{ErrorExt, ResultExt, message};
 
     /// A general purpose connector connecting to a repository identified by the given `url`.
     ///
@@ -10,19 +12,21 @@ pub(crate) mod function {
     /// [git daemons][crate::client::git::connect()] only at the moment.
     ///
     /// Use `options` to further control specifics of the transport resulting from the connection.
-    pub async fn connect<Url, E>(url: Url, options: super::Options) -> Result<Box<dyn Transport + Send>, Error>
+    pub async fn connect<Url, E>(url: Url, options: super::Options) -> ExnMessageResult<Box<dyn Transport + Send>>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        let mut url = url.try_into().map_err(gix_error::Error::from_error)?;
+        let mut url = url.try_into().or_raise(|| message("Could not parse URL"))?;
         Ok(match url.scheme {
             gix_url::Scheme::Git => {
                 if url.user().is_some() {
-                    return Err(Error::UnsupportedUrlTokens {
-                        url: url.to_bstring(),
-                        scheme: url.scheme,
-                    });
+                    return Err(message!(
+                        "The url {:?} contains information that would not be used by the {} protocol",
+                        url.to_bstring(),
+                        url.scheme
+                    )
+                    .raise());
                 }
                 let path = std::mem::take(&mut url.path);
                 Box::new(
@@ -34,10 +38,10 @@ pub(crate) mod function {
                         options.trace,
                     )
                     .await
-                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
+                    .or_raise(|| message("connection failed"))?,
                 )
             }
-            scheme => return Err(Error::UnsupportedScheme(scheme)),
+            scheme => return Err(message!("The '{scheme}' protocol is currently unsupported").raise()),
         })
     }
 }
diff --git a/gix-transport/src/client/blocking_io/bufread_ext.rs b/gix-transport/src/client/blocking_io/bufread_ext.rs
index ac6177d29b4..ceaf2cd1b84 100644
--- a/gix-transport/src/client/blocking_io/bufread_ext.rs
+++ b/gix-transport/src/client/blocking_io/bufread_ext.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     io,
     ops::{Deref, DerefMut},
@@ -25,9 +26,7 @@ pub trait ReadlineBufRead: io::BufRead {
     ///  * natural EOF
     ///  * ERR packet line encountered
     ///  * A `delimiter` packet line encountered
-    fn readline(
-        &mut self,
-    ) -> Option<io::Result<Result<gix_packetline::PacketLineRef<'_>, gix_packetline::decode::Error>>>;
+    fn readline(&mut self) -> Option<io::Result<ExnMessageResult<gix_packetline::PacketLineRef<'_>>>>;
 
     /// Read a line similar to `BufRead::read_line()`, but assure it doesn't try to find newlines
     /// which might concatenate multiple distinct packet lines.
@@ -44,7 +43,7 @@ pub trait ExtendedBufRead<'a>: ReadlineBufRead {
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress<'a>>);
     /// Peek the next data packet line. Maybe None if the next line is a packet we stop at, queryable using
     /// [`stopped_at()`][ExtendedBufRead::stopped_at()].
-    fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>>;
+    fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>>;
     /// Resets the reader to allow reading past a previous stop, and sets delimiters according to the
     /// given protocol.
     fn reset(&mut self, version: Protocol);
@@ -53,7 +52,7 @@ pub trait ExtendedBufRead<'a>: ReadlineBufRead {
 }
 
 impl<T: ReadlineBufRead + ?Sized> ReadlineBufRead for Box<T> {
-    fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         ReadlineBufRead::readline(self.deref_mut())
     }
     fn readline_str(&mut self, line: &mut String) -> io::Result<usize> {
@@ -66,7 +65,7 @@ impl<'a, T: ExtendedBufRead<'a> + ?Sized + 'a> ExtendedBufRead<'a> for Box<T> {
         self.deref_mut().set_progress_handler(handle_progress);
     }
 
-    fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>> {
+    fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>> {
         self.deref_mut().peek_data_line()
     }
 
@@ -80,7 +79,7 @@ impl<'a, T: ExtendedBufRead<'a> + ?Sized + 'a> ExtendedBufRead<'a> for Box<T> {
 }
 
 impl<T: io::Read> ReadlineBufRead for WithSidebands<'_, T, fn(bool, &[u8]) -> ProgressAction> {
-    fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         self.read_data_line()
     }
 
@@ -90,7 +89,7 @@ impl<T: io::Read> ReadlineBufRead for WithSidebands<'_, T, fn(bool, &[u8]) -> Pr
 }
 
 impl<'a, T: io::Read> ReadlineBufRead for WithSidebands<'a, T, HandleProgress<'a>> {
-    fn readline(&mut self) -> Option<io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    fn readline(&mut self) -> Option<io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         self.read_data_line()
     }
 
@@ -103,7 +102,7 @@ impl<'a, T: io::Read> ExtendedBufRead<'a> for WithSidebands<'a, T, HandleProgres
     fn set_progress_handler(&mut self, handle_progress: Option<HandleProgress<'a>>) {
         self.set_progress_handler(handle_progress);
     }
-    fn peek_data_line(&mut self) -> Option<io::Result<Result<&[u8], Error>>> {
+    fn peek_data_line(&mut self) -> Option<io::Result<std::result::Result<&[u8], Error>>> {
         match self.peek_data_line() {
             Some(Ok(Ok(line))) => Some(Ok(Ok(line))),
             Some(Ok(Err(err))) => Some(Ok(Err(err.into()))),
diff --git a/gix-transport/src/client/blocking_io/connect.rs b/gix-transport/src/client/blocking_io/connect.rs
index 4e8ab1a569c..d4ac9fa9ac1 100644
--- a/gix-transport/src/client/blocking_io/connect.rs
+++ b/gix-transport/src/client/blocking_io/connect.rs
@@ -1,11 +1,13 @@
-pub use crate::client::non_io_types::connect::{Error, Options};
+pub use crate::client::non_io_types::connect::Options;
 
 pub(crate) mod function {
+    use crate::client::blocking_io::Transport;
     #[cfg(feature = "http-client-curl")]
     use crate::client::blocking_io::http::curl::Curl;
     #[cfg(all(feature = "http-client-reqwest", not(feature = "http-client-curl")))]
     use crate::client::blocking_io::http::reqwest::Remote as Reqwest;
-    use crate::client::{blocking_io::Transport, non_io_types::connect::Error};
+    use gix_error::ExnMessageResult;
+    use gix_error::{ErrorExt, ResultExt, message};
 
     /// A general purpose connector connecting to a repository identified by the given `url`.
     ///
@@ -16,38 +18,42 @@ pub(crate) mod function {
     /// and if compiled in connections to [git repositories over https](crate::client::blocking_io::http::connect()).
     ///
     /// Use `options` to further control specifics of the transport resulting from the connection.
-    pub fn connect<Url, E>(url: Url, options: super::Options) -> Result<Box<dyn Transport + Send>, Error>
+    pub fn connect<Url, E>(url: Url, options: super::Options) -> ExnMessageResult<Box<dyn Transport + Send>>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        let mut url = url.try_into().map_err(gix_error::Error::from_error)?;
+        let mut url = url.try_into().or_raise(|| message("Could not parse URL"))?;
         Ok(match url.scheme {
             gix_url::Scheme::Ext | gix_url::Scheme::Helper(_) | gix_url::Scheme::HelperUrl(_) => {
-                return Err(Error::UnsupportedScheme(url.scheme));
+                return Err(message!("The '{}' protocol is currently unsupported", url.scheme).raise());
             }
             gix_url::Scheme::File => {
                 if url.user().is_some() || url.password().is_some() || url.host().is_some() || url.port.is_some() {
-                    return Err(Error::UnsupportedUrlTokens {
-                        url: url.to_bstring(),
-                        scheme: url.scheme,
-                    });
+                    return Err(message!(
+                        "The url {:?} contains information that would not be used by the {} protocol",
+                        url.to_bstring(),
+                        url.scheme
+                    )
+                    .raise());
                 }
                 Box::new(
                     crate::client::blocking_io::file::connect(url.path, options.version, options.trace)
-                        .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?,
+                        .or_raise(|| message("connection failed"))?,
                 )
             }
             gix_url::Scheme::Ssh => Box::new({
                 crate::client::blocking_io::ssh::connect(url, options.version, options.ssh, options.trace)
-                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?
+                    .or_raise(|| message("connection failed"))?
             }),
             gix_url::Scheme::Git => {
                 if url.user().is_some() {
-                    return Err(Error::UnsupportedUrlTokens {
-                        url: url.to_bstring(),
-                        scheme: url.scheme,
-                    });
+                    return Err(message!(
+                        "The url {:?} contains information that would not be used by the {} protocol",
+                        url.to_bstring(),
+                        url.scheme
+                    )
+                    .raise());
                 }
                 Box::new({
                     let path = std::mem::take(&mut url.path);
@@ -58,11 +64,17 @@ pub(crate) mod function {
                         url.port,
                         options.trace,
                     )
-                    .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?
+                    .or_raise(|| message("connection failed"))?
                 })
             }
             #[cfg(not(any(feature = "http-client-curl", feature = "http-client-reqwest")))]
-            gix_url::Scheme::Https | gix_url::Scheme::Http => return Err(Error::CompiledWithoutHttp(url.scheme)),
+            gix_url::Scheme::Https | gix_url::Scheme::Http => {
+                return Err(message!(
+                    "'{}' is not compiled in. Compile with the 'http-client-curl' or 'http-client-reqwest' cargo feature",
+                    url.scheme
+                )
+                .raise());
+            }
             #[cfg(feature = "http-client-curl")]
             gix_url::Scheme::Https | gix_url::Scheme::Http => Box::new(
                 crate::client::blocking_io::http::connect::<Curl>(url, options.version, options.trace),
diff --git a/gix-transport/src/client/blocking_io/file.rs b/gix-transport/src/client/blocking_io/file.rs
index 159e2053dfd..72527e95850 100644
--- a/gix-transport/src/client/blocking_io/file.rs
+++ b/gix-transport/src/client/blocking_io/file.rs
@@ -1,12 +1,13 @@
 use std::{
     any::Any,
     borrow::Cow,
-    error::Error,
     ffi::OsString,
     io::Write,
     process::{self, Stdio},
 };
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, BString, ByteSlice, io::BufReadExt};
 
 use crate::{
@@ -177,7 +178,7 @@ impl client::TransportWithoutIO for SpawnProcessOnDemand {
         true
     }
 
-    fn configure(&mut self, _config: &dyn Any) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    fn configure(&mut self, _config: &dyn Any) -> ExnResult {
         Ok(())
     }
 }
@@ -451,6 +452,7 @@ mod tests {
 
             #[test]
             fn ambiguous_host_disallowed() {
+                let mut matched_error_diagnostics = Vec::new();
                 for url in [
                     "ssh://-oProxyCommand=open$IFS-aCalculator/foo",
                     "user@-oProxyCommand=open$IFS-aCalculator:username/repo",
@@ -461,11 +463,25 @@ mod tests {
                         disallow_shell: false,
                         kind: None,
                     };
-                    assert!(matches!(
-                        ssh::connect(url, Protocol::V1, options, false),
-                        Err(ssh::Error::AmbiguousHostName { host }) if host == "-oProxyCommand=open$IFS-aCalculator",
-                    ));
+                    let failure = ssh::connect(url, Protocol::V1, options, false)
+                        .err()
+                        .expect("the operation must fail");
+                    matched_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&failure, &[]));
+                    assert!(
+                        matches!(failure, ssh::Error::AmbiguousHostName { host } if host == "-oProxyCommand=open$IFS-aCalculator"),
+                        "ambiguous host disallowed"
+                    );
                 }
+                insta::assert_debug_snapshot!(matched_error_diagnostics, "ambiguous host disallowed", @r#"
+                [
+                    AmbiguousHostName {
+                        host: "-oProxyCommand=open$IFS-aCalculator",
+                    },
+                    AmbiguousHostName {
+                        host: "-oProxyCommand=open$IFS-aCalculator",
+                    },
+                ]
+                "#);
             }
 
             fn command_and_args(cmd: gix_command::Prepare) -> Vec<String> {
diff --git a/gix-transport/src/client/blocking_io/http/curl/mod.rs b/gix-transport/src/client/blocking_io/http/curl/mod.rs
index cb2733c74bb..d27636b0d9a 100644
--- a/gix-transport/src/client/blocking_io/http/curl/mod.rs
+++ b/gix-transport/src/client/blocking_io/http/curl/mod.rs
@@ -6,6 +6,7 @@ use std::{
     thread,
 };
 
+use gix_error::{ExnMessageResult, ExnResult, ResultExt, message};
 use gix_features::io;
 use parking_lot::Mutex;
 
@@ -22,32 +23,7 @@ pub struct Options {
     pub schannel_check_revoke: Option<bool>,
 }
 
-/// The error returned by the 'remote' helper, a purely internal construct to perform http requests.
-///
-/// It can be used for downcasting errors, which are boxed to hide the actual implementation.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Curl(#[from] curl::Error),
-    #[error(transparent)]
-    Redirect(#[from] http::redirect::Error),
-    #[error("Could not finish reading all data to post to the remote")]
-    ReadPostBody(#[from] std::io::Error),
-    #[error(transparent)]
-    Authenticate(#[from] gix_credentials::protocol::Error),
-}
-
-impl crate::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::Curl(err) => curl_is_spurious(err),
-            _ => false,
-        }
-    }
-}
-
-pub(crate) fn curl_is_spurious(err: &curl::Error) -> bool {
+pub(crate) fn curl_is_retryable(err: &curl::Error) -> bool {
     err.is_couldnt_connect()
         || err.is_couldnt_resolve_proxy()
         || err.is_couldnt_resolve_host()
@@ -64,13 +40,13 @@ pub(crate) fn curl_is_spurious(err: &curl::Error) -> bool {
 pub struct Curl {
     req: SyncSender<remote::Request>,
     res: Receiver<remote::Response>,
-    handle: Option<thread::JoinHandle<Result<(), Error>>>,
+    handle: Option<thread::JoinHandle<ExnMessageResult>>,
     config: http::Options,
     redirected_base_url: Arc<Mutex<Option<String>>>,
 }
 
 impl Curl {
-    fn restore_thread_after_failure(&mut self) -> http::Error {
+    fn restore_thread_after_failure(&mut self) -> gix_error::Exn<gix_error::Message> {
         let err_that_brought_thread_down = self
             .handle
             .take()
@@ -83,7 +59,7 @@ impl Curl {
         self.req = req;
         self.res = res;
         self.redirected_base_url = redirected_base_url;
-        err_that_brought_thread_down.into()
+        err_that_brought_thread_down
     }
 
     fn make_request(
@@ -92,10 +68,21 @@ impl Curl {
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
         upload_body_kind: Option<PostBodyDataKind>,
-    ) -> Result<http::PostResponse<io::pipe::Reader, io::pipe::Reader, io::pipe::Writer>, http::Error> {
+    ) -> ExnMessageResult<http::PostResponse<io::pipe::Reader, io::pipe::Reader, io::pipe::Writer>> {
         let mut list = curl::easy::List::new();
         for header in headers {
-            list.append(header.as_ref())?;
+            list.append(header.as_ref())
+                .map_err(|err| {
+                    if curl_is_retryable(&err) {
+                        gix_error::Error::from_error(gix_error::ClassificationMarker::with_source(
+                            gix_error::Class::Retryable,
+                            err,
+                        ))
+                    } else {
+                        gix_error::Error::from_error(err)
+                    }
+                })
+                .or_raise(|| message("Could not add HTTP header"))?;
         }
         if self
             .req
@@ -149,7 +136,7 @@ impl http::Http for Curl {
         url: &str,
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
-    ) -> Result<http::GetResponse<Self::Headers, Self::ResponseBody>, http::Error> {
+    ) -> ExnMessageResult<http::GetResponse<Self::Headers, Self::ResponseBody>> {
         self.make_request(url, base_url, headers, None).map(Into::into)
     }
 
@@ -159,14 +146,11 @@ impl http::Http for Curl {
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
         body: PostBodyDataKind,
-    ) -> Result<http::PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>, http::Error> {
+    ) -> ExnMessageResult<http::PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>> {
         self.make_request(url, base_url, headers, Some(body))
     }
 
-    fn configure(
-        &mut self,
-        config: &dyn std::any::Any,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    fn configure(&mut self, config: &dyn std::any::Any) -> ExnResult {
         if let Some(config) = config.downcast_ref::<http::Options>() {
             self.config = config.clone();
         }
diff --git a/gix-transport/src/client/blocking_io/http/curl/remote.rs b/gix-transport/src/client/blocking_io/http/curl/remote.rs
index 832992af286..8633cbfa631 100644
--- a/gix-transport/src/client/blocking_io/http/curl/remote.rs
+++ b/gix-transport/src/client/blocking_io/http/curl/remote.rs
@@ -11,18 +11,37 @@ use std::{
 
 use bstr::ByteSlice;
 use curl::easy::{Auth, Easy2};
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult, OptionExt, ResultExt, message};
 use gix_features::io::pipe;
 use parking_lot::Mutex;
 
 use crate::client::blocking_io::http::{
     self,
-    curl::Error,
-    curl::curl_is_spurious,
+    curl::curl_is_retryable,
     options::{FollowRedirects, HttpVersion, ProxyAuthMethod, SslVersion},
     redirect::{self, Action as RedirectAction},
     traits::PostBodyDataKind,
 };
 
+fn classify_curl(err: curl::Error) -> gix_error::Error {
+    if curl_is_retryable(&err) {
+        gix_error::Error::from_error(gix_error::ClassificationMarker::with_source(
+            gix_error::Class::Retryable,
+            err,
+        ))
+    } else {
+        gix_error::Error::from_error(err)
+    }
+}
+
+macro_rules! curl {
+    ($expr:expr) => {
+        $expr
+            .map_err(classify_curl)
+            .or_raise(|| message("Curl operation failed"))?
+    };
+}
+
 enum StreamOrBuffer {
     Stream(pipe::Reader),
     Buffer(std::io::Cursor<Vec<u8>>),
@@ -43,6 +62,8 @@ struct Handler {
     send_data: Option<pipe::Writer>,
     /// Provides the optional upload body to curl, either streamed from the caller or buffered for known-size uploads.
     receive_body: Option<StreamOrBuffer>,
+    /// The I/O failure that made a callback abort the active transfer.
+    io_error: Option<io::Error>,
     /// `true` once the status line of the current response header block was parsed.
     checked_status: bool,
     /// Status code of the current response header block, used to associate following headers with redirects.
@@ -67,6 +88,7 @@ struct Handler {
 
 impl Handler {
     fn reset(&mut self) {
+        self.io_error = None;
         self.checked_status = false;
         self.current_status = None;
         self.authentication.www_authenticate.clear();
@@ -76,6 +98,20 @@ impl Handler {
         self.redirect_action = RedirectAction::Stop;
     }
 
+    fn transfer_error(&mut self, err: curl::Error) -> io::Error {
+        match self.io_error.take() {
+            Some(source) => io::Error::new(source.kind(), source.and_raise(err).into_error()),
+            None => io::Error::new(
+                if curl_is_retryable(&err) {
+                    io::ErrorKind::ConnectionReset
+                } else {
+                    io::ErrorKind::Other
+                },
+                err,
+            ),
+        }
+    }
+
     fn track_redirects(
         &mut self,
         request_url: String,
@@ -89,22 +125,22 @@ impl Handler {
         self.redirect_action = redirect_action;
     }
 
-    fn parse_status_inner(data: &[u8]) -> Result<usize, Box<dyn std::error::Error + Send + Sync>> {
+    fn parse_status_inner(data: &[u8]) -> ExnResult<usize> {
         let code = data
             .split(|b| *b == b' ')
             .nth(1)
-            .ok_or("Expected HTTP/<VERSION> STATUS")?;
-        let code = std::str::from_utf8(code)?;
-        code.parse().map_err(Into::into)
+            .ok_or_raise_erased(|| message("Expected HTTP/<VERSION> STATUS"))?;
+        let code = std::str::from_utf8(code).or_erased()?;
+        code.parse::<usize>().or_erased()
     }
-    fn parse_status(data: &[u8], follow: FollowRedirects) -> Option<(usize, Box<dyn std::error::Error + Send + Sync>)> {
+    fn parse_status(data: &[u8], follow: FollowRedirects) -> Option<(usize, gix_error::Exn)> {
         let valid_end = match follow {
             FollowRedirects::Initial | FollowRedirects::All => 308,
             FollowRedirects::None => 299,
         };
         match Self::parse_status_inner(data) {
             Ok(status) if !(200..=valid_end).contains(&status) => {
-                Some((status, format!("Received HTTP status {status}").into()))
+                Some((status, message!("Received HTTP status {status}").raise_erased()))
             }
             Ok(_) => None,
             Err(err) => Some((500, err)),
@@ -259,16 +295,23 @@ impl curl::easy::Handler for Handler {
     fn write(&mut self, data: &[u8]) -> Result<usize, curl::easy::WriteError> {
         drop(self.send_header.take()); // signal header readers to stop trying
         match self.send_data.as_mut() {
-            Some(writer) => writer.write_all(data).map(|_| data.len()).or(Ok(0)),
+            Some(writer) => writer.write_all(data).map(|_| data.len()).or_else(|err| {
+                self.io_error = Some(err);
+                Ok(0)
+            }),
             None => Ok(0), // nothing more to receive, reader is done
         }
     }
     fn read(&mut self, data: &mut [u8]) -> Result<usize, curl::easy::ReadError> {
         match self.receive_body.as_mut() {
-            Some(StreamOrBuffer::Stream(reader)) => reader.read(data).map_err(|_err| curl::easy::ReadError::Abort),
-            Some(StreamOrBuffer::Buffer(cursor)) => cursor.read(data).map_err(|_err| curl::easy::ReadError::Abort),
+            Some(StreamOrBuffer::Stream(reader)) => reader.read(data),
+            Some(StreamOrBuffer::Buffer(cursor)) => cursor.read(data),
             None => Ok(0), // nothing more to read/writer depleted
         }
+        .map_err(|err| {
+            self.io_error = Some(err);
+            curl::easy::ReadError::Abort
+        })
     }
 
     fn header(&mut self, data: &[u8]) -> bool {
@@ -311,7 +354,7 @@ impl curl::easy::Handler for Handler {
                 if self.redirect_action == RedirectAction::RejectConfiguredHeaders && is_redirect_status(status) {
                     Some((
                         status,
-                        "refusing to follow redirect after request headers were configured".into(),
+                        message("refusing to follow redirect after request headers were configured").raise_erased(),
                     ))
                 } else {
                     Handler::parse_status(data, self.follow)
@@ -331,7 +374,7 @@ impl curl::easy::Handler for Handler {
                             } else {
                                 io::ErrorKind::Other
                             },
-                            err,
+                            err.into_error(),
                         )))
                         .ok();
                 }
@@ -356,7 +399,7 @@ pub struct Response {
 }
 
 type Worker = (
-    thread::JoinHandle<Result<(), Error>>,
+    thread::JoinHandle<ExnMessageResult>,
     SyncSender<Request>,
     Receiver<Response>,
     SharedRedirectedBaseUrl,
@@ -367,11 +410,11 @@ pub fn new() -> Worker {
     let redirected_base_url_shared_out = redirected_base_url_shared.clone();
     let (req_send, req_recv) = sync_channel(0);
     let (res_send, res_recv) = sync_channel(0);
-    let handle = std::thread::spawn(move || -> Result<(), Error> {
+    let handle = std::thread::spawn(move || -> ExnMessageResult {
         let mut handle = Easy2::new(Handler::default());
         // We don't wait for the possibility for pipelining to become clear, and curl tries to reuse connections by default anyway.
-        handle.pipewait(false)?;
-        handle.tcp_keepalive(true)?;
+        curl!(handle.pipewait(false));
+        curl!(handle.tcp_keepalive(true));
 
         let mut follow = None;
 
@@ -403,39 +446,39 @@ pub fn new() -> Worker {
         {
             let redirected_base_url = redirected_base_url_shared.lock().clone();
             let effective_url = redirect::swap_tails(redirected_base_url.as_deref(), &base_url, url.clone());
-            handle.url(&effective_url)?;
+            curl!(handle.url(&effective_url));
 
-            handle.post(upload_body_kind.is_some())?;
+            curl!(handle.post(upload_body_kind.is_some()));
             let has_extra_headers = !extra_headers.is_empty();
             for header in extra_headers {
-                headers.append(&header)?;
+                curl!(headers.append(&header));
             }
             // needed to avoid sending Expect: 100-continue, which adds another response and only CURL wants that
-            headers.append("Expect:")?;
-            handle.verbose(verbose)?;
+            curl!(headers.append("Expect:"));
+            curl!(handle.verbose(verbose));
 
             if let Some(ca_info) = ssl_ca_info {
-                handle.cainfo(ca_info)?;
+                curl!(handle.cainfo(ca_info));
             }
 
             if let Some(ref mut curl_options) = backend.as_ref().and_then(|backend| backend.lock().ok())
                 && let Some(opts) = curl_options.downcast_mut::<super::Options>()
                 && let Some(enabled) = opts.schannel_check_revoke
             {
-                handle.ssl_options(curl::easy::SslOpt::new().no_revoke(!enabled))?;
+                curl!(handle.ssl_options(curl::easy::SslOpt::new().no_revoke(!enabled)));
             }
 
             if let Some(ssl_version) = ssl_version {
                 let (min, max) = ssl_version.min_max();
                 if min == max {
-                    handle.ssl_version(to_curl_ssl_version(min))?;
+                    curl!(handle.ssl_version(to_curl_ssl_version(min)));
                 } else {
-                    handle.ssl_min_max_version(to_curl_ssl_version(min), to_curl_ssl_version(max))?;
+                    curl!(handle.ssl_min_max_version(to_curl_ssl_version(min), to_curl_ssl_version(max)));
                 }
             }
 
-            handle.ssl_verify_peer(ssl_verify)?;
-            handle.ssl_verify_host(ssl_verify)?;
+            curl!(handle.ssl_verify_peer(ssl_verify));
+            curl!(handle.ssl_verify_host(ssl_verify));
 
             if let Some(http_version) = http_version {
                 let version = match http_version {
@@ -451,7 +494,7 @@ pub fn new() -> Worker {
 
             let mut proxy_auth_action = None;
             if let Some(proxy) = proxy {
-                handle.proxy(&proxy)?;
+                curl!(handle.proxy(&proxy));
                 let proxy_type = if proxy.starts_with("socks5h") {
                     curl::easy::ProxyType::Socks5Hostname
                 } else if proxy.starts_with("socks5") {
@@ -463,25 +506,26 @@ pub fn new() -> Worker {
                 } else {
                     curl::easy::ProxyType::Http
                 };
-                handle.proxy_type(proxy_type)?;
+                curl!(handle.proxy_type(proxy_type));
 
                 if let Some((obtain_creds_action, authenticate)) = proxy_authenticate {
-                    let creds = authenticate.lock().expect("no panics in other threads")(obtain_creds_action)?
+                    let creds = authenticate.lock().expect("no panics in other threads")(obtain_creds_action)
+                        .or_raise(|| message("Could not obtain proxy credentials"))?
                         .expect("action to fetch credentials");
-                    handle.proxy_username(&creds.identity.username)?;
-                    handle.proxy_password(&creds.identity.password)?;
+                    curl!(handle.proxy_username(&creds.identity.username));
+                    curl!(handle.proxy_password(&creds.identity.password));
                     proxy_auth_action = Some((creds.next, authenticate));
                 }
             }
             if let Some(no_proxy) = no_proxy {
-                handle.noproxy(&no_proxy)?;
+                curl!(handle.noproxy(&no_proxy));
             }
             if let Some(user_agent) = user_agent {
-                handle.useragent(&user_agent)?;
+                curl!(handle.useragent(&user_agent));
             }
-            handle.transfer_encoding(false)?;
+            curl!(handle.transfer_encoding(false));
             if let Some(timeout) = connect_timeout {
-                handle.connect_timeout(timeout)?;
+                curl!(handle.connect_timeout(timeout));
             }
             {
                 let mut auth = Auth::new();
@@ -498,13 +542,13 @@ pub fn new() -> Worker {
                     ProxyAuthMethod::Negotiate => auth.digest_ie(true),
                     ProxyAuthMethod::Ntlm => auth.ntlm(true),
                 };
-                handle.proxy_auth(&auth)?;
+                curl!(handle.proxy_auth(&auth));
             }
-            handle.tcp_keepalive(true)?;
+            curl!(handle.tcp_keepalive(true));
 
             if low_speed_time_seconds > 0 && low_speed_limit_bytes_per_second > 0 {
-                handle.low_speed_limit(low_speed_limit_bytes_per_second)?;
-                handle.low_speed_time(Duration::from_secs(low_speed_time_seconds))?;
+                curl!(handle.low_speed_limit(low_speed_limit_bytes_per_second));
+                curl!(handle.low_speed_time(Duration::from_secs(low_speed_time_seconds)));
             }
             let (receive_data, receive_headers, send_body, mut receive_body) = {
                 let handler = handle.get_mut();
@@ -529,7 +573,7 @@ pub fn new() -> Worker {
                     redirect_action,
                 );
             }
-            handle.follow_location(redirect_action == RedirectAction::Follow)?;
+            curl!(handle.follow_location(redirect_action == RedirectAction::Follow));
 
             if *follow == FollowRedirects::Initial {
                 *follow = FollowRedirects::None;
@@ -550,29 +594,24 @@ pub fn new() -> Worker {
                 Some(PostBodyDataKind::Unbounded) | None => StreamOrBuffer::Stream(receive_body),
                 Some(PostBodyDataKind::BoundedAndFitsIntoMemory) => {
                     let mut buf = Vec::<u8>::with_capacity(512);
-                    receive_body.read_to_end(&mut buf)?;
-                    handle.post_field_size(buf.len() as u64)?;
+                    receive_body
+                        .read_to_end(&mut buf)
+                        .or_raise(|| message("Could not finish reading all data to post to the remote"))?;
+                    curl!(handle.post_field_size(buf.len() as u64));
                     drop(receive_body);
                     StreamOrBuffer::Buffer(std::io::Cursor::new(buf))
                 }
             });
-            handle.http_headers(headers)?;
+            curl!(handle.http_headers(headers));
 
             if let Err(err) = handle.perform() {
                 let handler = handle.get_mut();
+                let err = Err(handler.transfer_error(err));
                 handler.reset();
 
                 if let Some((action, authenticate)) = proxy_auth_action {
                     authenticate.lock().expect("no panics in other threads")(action.erase()).ok();
                 }
-                let err = Err(io::Error::new(
-                    if curl_is_spurious(&err) {
-                        std::io::ErrorKind::ConnectionReset
-                    } else {
-                        std::io::ErrorKind::Other
-                    },
-                    err,
-                ));
                 handler.receive_body.take();
                 match (handler.send_header.take(), handler.send_data.take()) {
                     (Some(header), mut data) => {
@@ -589,9 +628,7 @@ pub fn new() -> Worker {
                     (None, None) => {}
                 }
             } else {
-                let actual_url = handle
-                    .effective_url()?
-                    .expect("effective url is present and valid UTF-8");
+                let actual_url = curl!(handle.effective_url()).expect("effective url is present and valid UTF-8");
                 if actual_url != effective_url {
                     let new_base_url = redirect::base_url(actual_url, &base_url, url)?;
                     *redirected_base_url_shared.lock() = Some(new_base_url);
@@ -603,7 +640,8 @@ pub fn new() -> Worker {
                         action.store()
                     } else {
                         action.erase()
-                    })?;
+                    })
+                    .or_raise(|| message("Could not update proxy credentials"))?;
                 }
                 handler.reset();
                 handler.receive_body.take();
@@ -634,22 +672,6 @@ fn is_redirect_status(status: usize) -> bool {
     (300..=308).contains(&status)
 }
 
-impl From<Error> for http::Error {
-    fn from(err: Error) -> Self {
-        http::Error::Detail {
-            description: err.to_string(),
-        }
-    }
-}
-
-impl From<curl::Error> for http::Error {
-    fn from(err: curl::Error) -> Self {
-        http::Error::Detail {
-            description: err.to_string(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod authentication_tests {
     use curl::easy::Handler as _;
@@ -843,3 +865,68 @@ mod resolve_location_path_tests {
         );
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use curl::easy::Handler as _;
+
+    use super::{Handler, StreamOrBuffer, io, pipe};
+
+    #[test]
+    fn aborted_uploads_preserve_the_callback_error() {
+        let (writer, reader) = pipe::unidirectional(1);
+        writer
+            .channel
+            .send(Err(io::Error::other(gix_error::ClassificationMarker::with_source(
+                gix_error::Class::Retryable,
+                gix_error::not_found("custom upload source is unavailable"),
+            ))))
+            .expect("the upload reader is alive");
+        let mut handler = Handler {
+            receive_body: Some(StreamOrBuffer::Stream(reader)),
+            ..Default::default()
+        };
+        assert!(handler.read(&mut [0]).is_err(), "the callback aborts the transfer");
+        // CURLE_ABORTED_BY_CALLBACK is the error curl returns after ReadError::Abort.
+        let err = gix_error::Error::from_error(handler.transfer_error(curl::Error::new(42)));
+        insta::assert_debug_snapshot!(err, "the custom upload source retains its retry policy", @"
+        Custom {
+            kind: Other,
+            error: [42] Operation was aborted by an application callback
+            |
+            └─ I/O error (Other)
+            |
+            └─ custom upload source is unavailable,
+        }
+        ");
+        assert!(err.can_retry(), "the custom upload source retains its retry policy");
+        assert!(err.is_not_found(), "other callback classifications survive too");
+        assert!(err.downcast_any_ref::<curl::Error>().is_some());
+        assert!(handler.io_error.is_none(), "a later request cannot reuse this failure");
+    }
+
+    #[test]
+    fn failed_download_writes_preserve_the_pipe_error() {
+        let (writer, reader) = pipe::unidirectional(1);
+        drop(reader);
+        let mut handler = Handler {
+            send_data: Some(writer),
+            ..Default::default()
+        };
+        assert_eq!(handler.write(b"response").expect("short writes abort curl"), 0);
+        // CURLE_WRITE_ERROR is the error curl returns after a short callback write.
+        let err = handler.transfer_error(curl::Error::new(23));
+        insta::assert_debug_snapshot!(err, "failed download writes preserve the pipe error", @"
+        Custom {
+            kind: BrokenPipe,
+            error: [23] Failed writing received data to disk/application
+            |
+            └─ I/O error (BrokenPipe)
+            |
+            └─ sending on a closed channel,
+        }
+        ");
+        assert_eq!(err.kind(), io::ErrorKind::BrokenPipe);
+        assert!(gix_error::classify(&err).can_retry_lenient());
+    }
+}
diff --git a/gix-transport/src/client/blocking_io/http/mod.rs b/gix-transport/src/client/blocking_io/http/mod.rs
index fdcb04fe825..d47e8bfa6be 100644
--- a/gix-transport/src/client/blocking_io/http/mod.rs
+++ b/gix-transport/src/client/blocking_io/http/mod.rs
@@ -1,3 +1,4 @@
+use gix_error::ExnMessageResult;
 use std::{
     any::Any,
     borrow::Cow,
@@ -8,7 +9,8 @@ use std::{
 
 use base64::Engine;
 use bstr::BStr;
-pub use traits::{Error, GetResponse, Http, PostBodyDataKind, PostResponse};
+use gix_error::{ErrorExt, ExnResult, message};
+pub use traits::{GetResponse, Http, PostBodyDataKind, PostResponse};
 
 use crate::{
     Protocol, Service,
@@ -286,24 +288,35 @@ impl<H: Http + Default> Transport<H> {
 }
 
 impl<H: Http> Transport<H> {
-    fn check_content_type(service: Service, kind: &str, headers: <H as Http>::Headers) -> Result<(), client::Error> {
+    fn check_content_type(
+        service: Service,
+        kind: &str,
+        headers: <H as Http>::Headers,
+    ) -> std::result::Result<(), client::Error> {
         let wanted_content_type = format!("application/x-{}-{}", service.as_str(), kind);
-        if !headers.lines().collect::<Result<Vec<_>, _>>()?.iter().any(|l| {
-            let mut tokens = l.split(':');
-            tokens.next().zip(tokens.next()).is_some_and(|(name, value)| {
-                name.eq_ignore_ascii_case("content-type") && value.trim() == wanted_content_type
+        if !headers
+            .lines()
+            .collect::<std::result::Result<Vec<_>, _>>()?
+            .iter()
+            .any(|l| {
+                let mut tokens = l.split(':');
+                tokens.next().zip(tokens.next()).is_some_and(|(name, value)| {
+                    name.eq_ignore_ascii_case("content-type") && value.trim() == wanted_content_type
+                })
             })
-        }) {
-            return Err(client::Error::Http(Error::Detail {
-                description: format!(
+        {
+            return Err(client::Error::Http(
+                message!(
                     "Didn't find '{wanted_content_type}' header to indicate 'smart' protocol, and 'dumb' protocol is not supported."
-                ),
-            }));
+                )
+                .raise()
+                .into_error(),
+            ));
         }
         Ok(())
     }
 
-    fn add_basic_auth_if_present(&self, headers: &mut Vec<Cow<'_, str>>) -> Result<(), client::Error> {
+    fn add_basic_auth_if_present(&self, headers: &mut Vec<Cow<'_, str>>) -> std::result::Result<(), client::Error> {
         if let Some(gix_sec::identity::Account {
             username,
             password,
@@ -335,7 +348,7 @@ fn append_url(base: &str, suffix: &str) -> String {
 }
 
 impl<H: Http> client::TransportWithoutIO for Transport<H> {
-    fn set_identity(&mut self, identity: gix_sec::identity::Account) -> Result<(), client::Error> {
+    fn set_identity(&mut self, identity: gix_sec::identity::Account) -> std::result::Result<(), client::Error> {
         self.identity = Some(identity);
         Ok(())
     }
@@ -348,7 +361,7 @@ impl<H: Http> client::TransportWithoutIO for Transport<H> {
         false
     }
 
-    fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    fn configure(&mut self, config: &dyn Any) -> ExnResult {
         self.http.configure(config)
     }
 }
@@ -358,7 +371,7 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
         &mut self,
         service: Service,
         extra_parameters: &'a [(&'a str, Option<&'a str>)],
-    ) -> Result<SetServiceResponse<'_>, client::Error> {
+    ) -> std::result::Result<SetServiceResponse<'_>, client::Error> {
         let url = append_url(self.url.as_ref(), &format!("info/refs?service={}", service.as_str()));
         let static_headers = [Cow::Borrowed(self.user_agent_header)];
         let mut dynamic_headers = Vec::<Cow<'_, str>>::new();
@@ -390,7 +403,7 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
             .get(url.as_ref(), &self.url, static_headers.iter().chain(&dynamic_headers))
             .map_err(|err| {
                 self.sync_redirected_base_url();
-                client::Error::from(err)
+                client::Error::Http(err.into_error())
             })?;
         if let Err(err) = <Transport<H>>::check_content_type(service, "advertisement", headers) {
             const MAX_ERROR_BODY_DRAIN_BYTES: u64 = 1024 * 1024;
@@ -418,13 +431,15 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
 
         if let Some(announced_service) = line.as_bstr().strip_prefix(b"# service=") {
             if announced_service != service.as_str().as_bytes() {
-                return Err(client::Error::Http(Error::Detail {
-                    description: format!(
+                return Err(client::Error::Http(
+                    message!(
                         "Expected to see service {:?}, but got {:?}",
                         service.as_str(),
                         announced_service
-                    ),
-                }));
+                    )
+                    .raise()
+                    .into_error(),
+                ));
             }
 
             line_reader.as_read().read_to_end(&mut Vec::new())?;
@@ -449,7 +464,7 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
         write_mode: client::WriteMode,
         on_into_read: MessageKind,
         trace: bool,
-    ) -> Result<RequestWriter<'_>, client::Error> {
+    ) -> std::result::Result<RequestWriter<'_>, client::Error> {
         let service = self.service.ok_or(client::Error::MissingHandshake)?;
         let url = append_url(&self.url, service.as_str());
         let static_headers = &[
@@ -476,7 +491,7 @@ impl<H: Http> blocking_io::Transport for Transport<H> {
             .post(&url, &self.url, all_headers, write_mode.into())
             .map_err(|err| {
                 self.sync_redirected_base_url();
-                client::Error::from(err)
+                client::Error::Http(err.into_error())
             })?;
         self.sync_redirected_base_url();
         let line_provider = self
@@ -532,7 +547,7 @@ impl<H: Http, B: BufRead + Unpin> BufRead for HeadersThenBody<H, B> {
 }
 
 impl<H: Http, B: ReadlineBufRead + Unpin> ReadlineBufRead for HeadersThenBody<H, B> {
-    fn readline(&mut self) -> Option<std::io::Result<Result<PacketLineRef<'_>, gix_packetline::decode::Error>>> {
+    fn readline(&mut self) -> Option<std::io::Result<ExnMessageResult<PacketLineRef<'_>>>> {
         if let Err(err) = self.handle_headers() {
             return Some(Err(err));
         }
@@ -550,7 +565,7 @@ impl<'a, H: Http, B: ExtendedBufRead<'a> + Unpin> ExtendedBufRead<'a> for Header
         self.body.set_progress_handler(handle_progress);
     }
 
-    fn peek_data_line(&mut self) -> Option<std::io::Result<Result<&[u8], client::Error>>> {
+    fn peek_data_line(&mut self) -> Option<std::io::Result<std::result::Result<&[u8], client::Error>>> {
         if let Err(err) = self.handle_headers() {
             return Some(Err(err));
         }
@@ -582,3 +597,90 @@ pub fn connect<H: Http + Default>(url: gix_url::Url, desired_version: Protocol,
 
 ///
 pub mod redirect;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client::blocking_io::Transport as _;
+    use gix_error::{ExnMessageResult, ExnResult};
+
+    struct FailingHttp;
+
+    impl Http for FailingHttp {
+        type Headers = std::io::Empty;
+        type ResponseBody = std::io::Empty;
+        type PostBody = std::io::Sink;
+
+        fn get(
+            &mut self,
+            _url: &str,
+            _base_url: &str,
+            _headers: impl IntoIterator<Item = impl AsRef<str>>,
+        ) -> ExnMessageResult<GetResponse<Self::Headers, Self::ResponseBody>> {
+            Err(gix_error::ClassificationMarker::with_source(
+                gix_error::Class::Retryable,
+                message("temporary backend failure"),
+            )
+            .and_raise(message("GET failed")))
+        }
+
+        fn post(
+            &mut self,
+            _url: &str,
+            _base_url: &str,
+            _headers: impl IntoIterator<Item = impl AsRef<str>>,
+            _body: PostBodyDataKind,
+        ) -> ExnMessageResult<PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>> {
+            Err(std::io::Error::from(std::io::ErrorKind::ConnectionRefused).and_raise(message("POST failed")))
+        }
+
+        fn configure(&mut self, _config: &dyn Any) -> ExnResult {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn backend_failures_remain_http_errors() {
+        let mut transport = Transport::new_http(
+            FailingHttp,
+            "http://localhost/repo".try_into().expect("valid URL"),
+            Protocol::V2,
+            false,
+        );
+        let get_error = transport
+            .handshake(Service::UploadPack, &[])
+            .err()
+            .expect("GET fails in the backend");
+        transport.service = Some(Service::UploadPack);
+        let post_error = transport
+            .request(client::WriteMode::Binary, MessageKind::Flush, false)
+            .err()
+            .expect("POST fails in the backend");
+
+        let errors = [get_error, post_error];
+        insta::assert_debug_snapshot!(errors, "GET and POST backend failures retain HTTP context and their I/O causes", @"
+        [
+            Http(
+                GET failed
+                |
+                └─ temporary backend failure,
+            ),
+            Http(
+                POST failed
+                |
+                └─ connection refused,
+            ),
+        ]
+        ");
+        for err in errors {
+            assert!(
+                matches!(err, client::Error::Http(_)),
+                "HTTP backend failures retain their transport error variant: {err:?}"
+            );
+            assert!(
+                gix_error::classify(&err).can_retry_lenient(),
+                "retryable backend causes survive conversion: {err:?}"
+            );
+        }
+    }
+}
diff --git a/gix-transport/src/client/blocking_io/http/redirect.rs b/gix-transport/src/client/blocking_io/http/redirect.rs
index 106bd3898fb..84722ea1112 100644
--- a/gix-transport/src/client/blocking_io/http/redirect.rs
+++ b/gix-transport/src/client/blocking_io/http/redirect.rs
@@ -1,12 +1,4 @@
-/// The error provided when redirection went beyond what we deem acceptable.
-#[derive(Debug, thiserror::Error)]
-#[error(
-    "Redirect url {redirect_url:?} could not be reconciled with original url {expected_url} as the scheme is insecure or they don't share the same suffix"
-)]
-pub struct Error {
-    redirect_url: String,
-    expected_url: String,
-}
+use gix_error::{ErrorExt, ExnMessageResult, message};
 
 #[derive(Default, Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum Action {
@@ -70,21 +62,23 @@ pub(crate) fn can_reuse_identity(redirect_url: &str, original_url: &str) -> bool
     false
 }
 
-pub(crate) fn base_url(redirect_url: &str, base_url: &str, url: String) -> Result<String, Error> {
+pub(crate) fn base_url(redirect_url: &str, base_url: &str, url: String) -> ExnMessageResult<String> {
     let tail = url
         .strip_prefix(base_url)
         .expect("BUG: caller assures `base_url` is subset of `url`");
     if !scheme_is_safe(redirect_url, base_url) {
-        return Err(Error {
-            redirect_url: redirect_url.into(),
-            expected_url: url,
-        });
+        return Err(message!(
+            "Redirect url {redirect_url:?} could not be reconciled with original url {url} as the scheme is insecure or they don't share the same suffix"
+        )
+        .raise());
     }
     redirect_url
         .strip_suffix(tail)
-        .ok_or_else(|| Error {
-            redirect_url: redirect_url.into(),
-            expected_url: url,
+        .ok_or_else(|| {
+            message!(
+                "Redirect url {redirect_url:?} could not be reconciled with original url {url} as the scheme is insecure or they don't share the same suffix"
+            )
+            .raise()
         })
         .map(ToOwned::to_owned)
 }
diff --git a/gix-transport/src/client/blocking_io/http/reqwest/mod.rs b/gix-transport/src/client/blocking_io/http/reqwest/mod.rs
index 718975d33a8..aef3636a6fc 100644
--- a/gix-transport/src/client/blocking_io/http/reqwest/mod.rs
+++ b/gix-transport/src/client/blocking_io/http/reqwest/mod.rs
@@ -1,7 +1,8 @@
+use gix_error::{ExnMessageResult, ExnResult};
 /// An implementation for HTTP requests via `reqwest`.
 pub struct Remote {
     /// A worker thread which performs the actual request.
-    handle: Option<std::thread::JoinHandle<Result<(), remote::Error>>>,
+    handle: Option<std::thread::JoinHandle<ExnMessageResult>>,
     /// A channel to send requests (work) to the worker thread.
     request: std::sync::mpsc::SyncSender<remote::Request>,
     /// A channel to receive the result of the prior request.
@@ -14,10 +15,7 @@ pub struct Remote {
 
 /// A function to configure a single request prior to sending it, support most complex configuration beyond what's possible with
 /// basic `git` http configuration.
-pub type ConfigureRequestFn = dyn FnMut(&mut reqwest::blocking::Request) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
-    + Send
-    + Sync
-    + 'static;
+pub type ConfigureRequestFn = dyn FnMut(&mut reqwest::blocking::Request) -> ExnResult + Send + Sync + 'static;
 
 /// Options to configure the reqwest HTTP handler.
 #[derive(Default)]
diff --git a/gix-transport/src/client/blocking_io/http/reqwest/remote.rs b/gix-transport/src/client/blocking_io/http/reqwest/remote.rs
index 70eb70035e5..6a43afb651c 100644
--- a/gix-transport/src/client/blocking_io/http/reqwest/remote.rs
+++ b/gix-transport/src/client/blocking_io/http/reqwest/remote.rs
@@ -5,6 +5,7 @@ use std::{
     sync::Arc,
 };
 
+use gix_error::{ExnMessageResult, ExnResult, ResultExt, message};
 use gix_features::io::pipe;
 use parking_lot::Mutex;
 
@@ -16,28 +17,14 @@ use crate::client::blocking_io::http::{
     traits::PostBodyDataKind,
 };
 
-/// The error returned by the 'remote' helper, a purely internal construct to perform http requests.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Reqwest(#[from] reqwest::Error),
-    #[error("Could not finish reading all data to post to the remote")]
-    ReadPostBody(#[from] std::io::Error),
-    #[error("Request configuration failed")]
-    ConfigureRequest(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error(transparent)]
-    Redirect(#[from] redirect::Error),
-}
-
-impl crate::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::Reqwest(err) => {
-                err.is_timeout() || err.is_connect() || err.status().is_some_and(|status| status.is_server_error())
-            }
-            _ => false,
-        }
+fn classify_reqwest(err: reqwest::Error) -> gix_error::Error {
+    if err.is_timeout() || err.is_connect() || err.status().is_some_and(|status| status.is_server_error()) {
+        gix_error::Error::from_error(gix_error::ClassificationMarker::with_source(
+            gix_error::Class::Retryable,
+            err,
+        ))
+    } else {
+        gix_error::Error::from_error(err)
     }
 }
 
@@ -53,7 +40,7 @@ impl Default for Remote {
         let (res_send, res_recv) = std::sync::mpsc::sync_channel(0);
         let redirected_base_url_shared = Arc::new(Mutex::new(None));
         let redirected_base_url_shared_for_field = redirected_base_url_shared.clone();
-        let handle = std::thread::spawn(move || -> Result<(), Error> {
+        let handle = std::thread::spawn(move || -> ExnMessageResult {
             let mut follow = None;
             let redirect_action = Arc::new(Mutex::new(RedirectAction::Stop));
             let redirect_tail = Arc::new(Mutex::new(String::new()));
@@ -105,7 +92,9 @@ impl Default for Remote {
                         }
                     }
                 }))
-                .build()?;
+                .build()
+                .map_err(classify_reqwest)
+                .or_raise(|| message("Could not initialize HTTP client"))?;
 
             for Request {
                 url,
@@ -142,20 +131,25 @@ impl Default for Remote {
                 req_builder = match upload_body_kind {
                     Some(PostBodyDataKind::BoundedAndFitsIntoMemory) => {
                         let mut buf = Vec::<u8>::with_capacity(512);
-                        post_body_rx.read_to_end(&mut buf)?;
+                        post_body_rx
+                            .read_to_end(&mut buf)
+                            .or_raise(|| message("Could not finish reading all data to post to the remote"))?;
                         req_builder.body(buf)
                     }
                     Some(PostBodyDataKind::Unbounded) => req_builder.body(reqwest::blocking::Body::new(post_body_rx)),
                     None => req_builder,
                 };
-                let mut req = req_builder.build()?;
+                let mut req = req_builder
+                    .build()
+                    .map_err(classify_reqwest)
+                    .or_raise(|| message("Could not build HTTP request"))?;
                 let mut has_configure_request = false;
                 if let Some(ref mut request_options) = config.backend.as_ref().and_then(|backend| backend.lock().ok())
                     && let Some(options) = request_options.downcast_mut::<super::Options>()
                     && let Some(configure_request) = &mut options.configure_request
                 {
                     has_configure_request = true;
-                    configure_request(&mut req)?;
+                    configure_request(&mut req).or_raise(|| message("Request configuration failed"))?;
                 }
 
                 let follow = follow.get_or_insert(config.follow_redirects);
@@ -209,7 +203,7 @@ impl Default for Remote {
                             // Preserve the `reqwest::Error` as the source so the underlying cause -- e.g. a
                             // connection or TLS failure -- isn't lost. It was previously stringified, which
                             // dead-ended `source()` and hid the real reason a request failed. See #2140.
-                            None => std::io::Error::other(err),
+                            None => std::io::Error::other(classify_reqwest(err)),
                         };
                         headers_tx.channel.send(Err(err)).ok();
                         continue;
@@ -262,7 +256,7 @@ impl Default for Remote {
 
 /// utilities
 impl Remote {
-    fn restore_thread_after_failure(&mut self) -> http::Error {
+    fn restore_thread_after_failure(&mut self) -> gix_error::Exn<gix_error::Message> {
         let err_that_brought_thread_down = self
             .handle
             .take()
@@ -271,9 +265,7 @@ impl Remote {
             .expect("handler thread should never panic")
             .expect_err("something should have gone wrong with curl (we join on error only)");
         *self = Remote::default();
-        http::Error::InitHttpClient {
-            source: Box::new(err_that_brought_thread_down),
-        }
+        err_that_brought_thread_down.raise(message("Could not initialize the http client"))
     }
 
     fn make_request(
@@ -282,7 +274,7 @@ impl Remote {
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
         upload_body_kind: Option<PostBodyDataKind>,
-    ) -> Result<http::PostResponse<pipe::Reader, pipe::Reader, pipe::Writer>, http::Error> {
+    ) -> ExnMessageResult<http::PostResponse<pipe::Reader, pipe::Reader, pipe::Writer>> {
         let mut header_map = reqwest::header::HeaderMap::new();
         for header_line in headers {
             insert_header(&mut header_map, header_line.as_ref());
@@ -352,7 +344,7 @@ impl http::Http for Remote {
         url: &str,
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
-    ) -> Result<http::GetResponse<Self::Headers, Self::ResponseBody>, http::Error> {
+    ) -> ExnMessageResult<http::GetResponse<Self::Headers, Self::ResponseBody>> {
         self.make_request(url, base_url, headers, None).map(Into::into)
     }
 
@@ -362,11 +354,11 @@ impl http::Http for Remote {
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
         post_body_kind: PostBodyDataKind,
-    ) -> Result<http::PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>, http::Error> {
+    ) -> ExnMessageResult<http::PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>> {
         self.make_request(url, base_url, headers, Some(post_body_kind))
     }
 
-    fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    fn configure(&mut self, config: &dyn Any) -> ExnResult {
         if let Some(config) = config.downcast_ref::<http::Options>() {
             self.config = config.clone();
         }
diff --git a/gix-transport/src/client/blocking_io/http/traits.rs b/gix-transport/src/client/blocking_io/http/traits.rs
index 5c5009ec407..1cc8265ef57 100644
--- a/gix-transport/src/client/blocking_io/http/traits.rs
+++ b/gix-transport/src/client/blocking_io/http/traits.rs
@@ -1,39 +1,5 @@
 use crate::client::WriteMode;
-
-/// The error used by the [Http] trait.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not initialize the http client")]
-    InitHttpClient {
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-    #[error("{description}")]
-    Detail { description: String },
-    #[error("An IO error occurred while uploading the body of a POST request")]
-    PostBody(#[from] std::io::Error),
-}
-
-impl crate::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::PostBody(err) => err.is_spurious(),
-            #[cfg(any(feature = "http-client-reqwest", feature = "http-client-curl"))]
-            Error::InitHttpClient { source } => {
-                #[cfg(feature = "http-client-curl")]
-                if let Some(err) = source.downcast_ref::<crate::client::blocking_io::http::curl::Error>() {
-                    return err.is_spurious();
-                }
-                #[cfg(feature = "http-client-reqwest")]
-                if let Some(err) = source.downcast_ref::<crate::client::blocking_io::http::reqwest::remote::Error>() {
-                    return err.is_spurious();
-                }
-                false
-            }
-            _ => false,
-        }
-    }
-}
+use gix_error::{ExnMessageResult, ExnResult};
 
 /// The return value of [`Http::get()`].
 pub struct GetResponse<H, B> {
@@ -88,7 +54,6 @@ impl<A, B, C> From<PostResponse<A, B, C>> for GetResponse<A, B> {
 /// into `std::io::Error(Other)`.
 /// The 401 error should wrap [`crate::client::AuthenticationRequired`] with the response's `WWW-Authenticate` values
 /// so credential helpers can use the server's authentication hints.
-#[expect(clippy::type_complexity)]
 pub trait Http {
     /// A type providing headers line by line.
     type Headers: std::io::BufRead + Unpin;
@@ -107,7 +72,7 @@ pub trait Http {
         url: &str,
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
-    ) -> Result<GetResponse<Self::Headers, Self::ResponseBody>, Error>;
+    ) -> ExnMessageResult<GetResponse<Self::Headers, Self::ResponseBody>>;
 
     /// Initiate a `POST` request to `url` providing with the given `headers`, where `base_url` is so that `base_url + tail == url`.
     ///
@@ -123,15 +88,12 @@ pub trait Http {
         base_url: &str,
         headers: impl IntoIterator<Item = impl AsRef<str>>,
         body: PostBodyDataKind,
-    ) -> Result<PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>, Error>;
+    ) -> ExnMessageResult<PostResponse<Self::Headers, Self::ResponseBody, Self::PostBody>>;
 
     /// Pass `config` which can deserialize in the implementation's configuration, as documented separately.
     ///
     /// The caller must know how that `config` data looks like for the intended implementation.
-    fn configure(
-        &mut self,
-        config: &dyn std::any::Any,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>;
+    fn configure(&mut self, config: &dyn std::any::Any) -> ExnResult;
 
     /// Return the effective base URL after a backend accepted a redirect, if available.
     fn redirected_base_url(&self) -> Option<String> {
diff --git a/gix-transport/src/client/blocking_io/ssh/mod.rs b/gix-transport/src/client/blocking_io/ssh/mod.rs
index ce9b45e0cff..89c9fd518b6 100644
--- a/gix-transport/src/client/blocking_io/ssh/mod.rs
+++ b/gix-transport/src/client/blocking_io/ssh/mod.rs
@@ -8,16 +8,36 @@ use gix_url::{ArgumentSafety::*, Url};
 use crate::{Protocol, client::blocking_io::file::SpawnProcessOnDemand};
 
 /// The error used in [`connect()`].
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 #[expect(missing_docs)]
 pub enum Error {
-    #[error("The scheme in \"{}\" is not usable for an ssh connection", .0.to_bstring())]
     UnsupportedScheme(gix_url::Url),
-    #[error("Host name '{host}' could be mistaken for a command-line argument")]
     AmbiguousHostName { host: String },
 }
 
-impl crate::IsSpuriousError for Error {}
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::UnsupportedScheme(url) => write!(
+                f,
+                "The scheme in \"{}\" is not usable for an ssh connection",
+                url.to_bstring()
+            ),
+            Error::AmbiguousHostName { host } => {
+                write!(f, "Host name '{host}' could be mistaken for a command-line argument")
+            }
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::AmbiguousHostName { .. } => Some(const { &gix_error::ClassificationMarker::VALIDATION }),
+            Error::UnsupportedScheme(_) => None,
+        }
+    }
+}
 
 /// The kind of SSH programs we have built-in support for.
 ///
@@ -43,14 +63,15 @@ pub mod invocation {
     use std::ffi::OsString;
 
     /// The error returned when producing ssh invocation arguments based on a selected invocation kind.
-    #[derive(Debug, thiserror::Error)]
+    #[derive(Debug)]
     #[expect(missing_docs)]
     pub enum Error {
-        #[error("Username '{user}' could be mistaken for a command-line argument")]
-        AmbiguousUserName { user: String },
-        #[error("Host name '{host}' could be mistaken for a command-line argument")]
-        AmbiguousHostName { host: String },
-        #[error("The 'Simple' ssh variant doesn't support {function}")]
+        AmbiguousUserName {
+            user: String,
+        },
+        AmbiguousHostName {
+            host: String,
+        },
         Unsupported {
             /// The simple command that should have been invoked.
             command: OsString,
@@ -58,6 +79,33 @@ pub mod invocation {
             function: &'static str,
         },
     }
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Error::AmbiguousUserName { user } => {
+                    write!(f, "Username '{user}' could be mistaken for a command-line argument")
+                }
+                Error::AmbiguousHostName { host } => {
+                    write!(f, "Host name '{host}' could be mistaken for a command-line argument")
+                }
+                Error::Unsupported { function, .. } => {
+                    write!(f, "The 'Simple' ssh variant doesn't support {function}")
+                }
+            }
+        }
+    }
+
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match self {
+                Error::AmbiguousUserName { .. } | Error::AmbiguousHostName { .. } => {
+                    Some(const { &gix_error::ClassificationMarker::VALIDATION })
+                }
+                Error::Unsupported { .. } => None,
+            }
+        }
+    }
 }
 
 ///
diff --git a/gix-transport/src/client/blocking_io/ssh/tests.rs b/gix-transport/src/client/blocking_io/ssh/tests.rs
index db09d3478f1..a97bf6b0dde 100644
--- a/gix-transport/src/client/blocking_io/ssh/tests.rs
+++ b/gix-transport/src/client/blocking_io/ssh/tests.rs
@@ -147,18 +147,34 @@ mod program_kind {
 
         #[test]
         fn ambiguous_user_is_disallowed_explicit_ssh() {
-            assert!(matches!(
-                try_call(ProgramKind::Ssh, "ssh://-arg@host/p", Protocol::V2),
-                Err(ssh::invocation::Error::AmbiguousUserName { user }) if user == "-arg"
-            ));
+            let failure = try_call(ProgramKind::Ssh, "ssh://-arg@host/p", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "ambiguous user is disallowed explicit ssh", @r#"
+            AmbiguousUserName {
+                user: "-arg",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::AmbiguousUserName { user } if user == "-arg"),
+                "ambiguous user is disallowed explicit ssh"
+            );
         }
 
         #[test]
         fn ambiguous_user_is_disallowed_implicit_ssh() {
-            assert!(matches!(
-                try_call(ProgramKind::Ssh, "-arg@host:p/q", Protocol::V2),
-                Err(ssh::invocation::Error::AmbiguousUserName { user }) if user == "-arg"
-            ));
+            let failure = try_call(ProgramKind::Ssh, "-arg@host:p/q", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "ambiguous user is disallowed implicit ssh", @r#"
+            AmbiguousUserName {
+                user: "-arg",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::AmbiguousUserName { user } if user == "-arg"),
+                "ambiguous user is disallowed implicit ssh"
+            );
         }
 
         #[test]
@@ -179,34 +195,67 @@ mod program_kind {
 
         #[test]
         fn ambiguous_host_is_disallowed_without_user() {
-            assert!(matches!(
-                try_call(ProgramKind::Ssh, "ssh://-arg/p", Protocol::V2),
-                Err(ssh::invocation::Error::AmbiguousHostName { host }) if host == "-arg"
-            ));
+            let failure = try_call(ProgramKind::Ssh, "ssh://-arg/p", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "ambiguous host is disallowed without user", @r#"
+            AmbiguousHostName {
+                host: "-arg",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::AmbiguousHostName { host } if host == "-arg"),
+                "ambiguous host is disallowed without user"
+            );
         }
 
         #[test]
         fn ambiguous_user_and_host_remain_disallowed_together_explicit_ssh() {
-            assert!(matches!(
-                try_call(ProgramKind::Ssh, "ssh://-arg@host/p", Protocol::V2),
-                Err(ssh::invocation::Error::AmbiguousUserName { user }) if user == "-arg"
-            ));
+            let failure = try_call(ProgramKind::Ssh, "ssh://-arg@host/p", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "ambiguous user and host remain disallowed together explicit ssh", @r#"
+            AmbiguousUserName {
+                user: "-arg",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::AmbiguousUserName { user } if user == "-arg"),
+                "ambiguous user and host remain disallowed together explicit ssh"
+            );
         }
 
         #[test]
         fn ambiguous_user_and_host_remain_disallowed_together_implicit_ssh() {
-            assert!(matches!(
-                try_call(ProgramKind::Ssh, "-userarg@-hostarg:p/q", Protocol::V2),
-                Err(ssh::invocation::Error::AmbiguousUserName { user }) if user == "-userarg"
-            ));
+            let failure = try_call(ProgramKind::Ssh, "-userarg@-hostarg:p/q", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "ambiguous user and host remain disallowed together implicit ssh", @r#"
+            AmbiguousUserName {
+                user: "-userarg",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::AmbiguousUserName { user } if user == "-userarg"),
+                "ambiguous user and host remain disallowed together implicit ssh"
+            );
         }
 
         #[test]
         fn simple_cannot_handle_any_arguments() {
-            assert!(matches!(
-                try_call(ProgramKind::Simple, "ssh://user@host:42/p", Protocol::V2),
-                Err(ssh::invocation::Error::Unsupported { .. })
-            ));
+            let failure = try_call(ProgramKind::Simple, "ssh://user@host:42/p", Protocol::V2)
+                .err()
+                .expect("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "simple cannot handle any arguments", @r#"
+            Unsupported {
+                command: "simple",
+                function: "setting the port",
+            }
+            "#);
+            assert!(
+                matches!(failure, ssh::invocation::Error::Unsupported { .. }),
+                "simple cannot handle any arguments"
+            );
             assert_eq!(
                 call_args(ProgramKind::Simple, "ssh://user@host/p", Protocol::V2),
                 joined(&["simple", "user@host"]),
@@ -284,6 +333,7 @@ mod program_kind {
 
         #[test]
         fn all() {
+            let mut diagnostics = Vec::new();
             for (kind, line, expected) in [
                 (
                     ProgramKind::Ssh,
@@ -329,19 +379,111 @@ mod program_kind {
                     ErrorKind::NotFound,
                 ),
             ] {
-                assert_eq!(kind.line_to_err(line.into()).map(|err| err.kind()), Ok(expected));
+                let err = kind.line_to_err(line.into()).expect("the SSH diagnostic is recognized");
+                assert_eq!(err.kind(), expected);
+                diagnostics.push((kind, err));
             }
+            insta::assert_debug_snapshot!(diagnostics, "SSH diagnostics retain the server message alongside their I/O classification", @r#"
+            [
+                (
+                    Ssh,
+                    Custom {
+                        kind: PermissionDenied,
+                        error: "byron@github.com: Permission denied (publickey).",
+                    },
+                ),
+                (
+                    Ssh,
+                    Custom {
+                        kind: ConnectionRefused,
+                        error: "ssh: Could not resolve hostname hostfoobar: nodename nor servname provided, or not known",
+                    },
+                ),
+                (
+                    Ssh,
+                    Custom {
+                        kind: NotFound,
+                        error: "ssh: connect to host example.org port 22: No route to host",
+                    },
+                ),
+                (
+                    Ssh,
+                    Custom {
+                        kind: NotFound,
+                        error: "banner exchange: Connection to 127.0.0.1 port 61024: Software caused connection abort",
+                    },
+                ),
+                (
+                    Ssh,
+                    Custom {
+                        kind: NotFound,
+                        error: "Connection closed by 127.0.0.1 port 8888",
+                    },
+                ),
+                (
+                    Simple,
+                    Custom {
+                        kind: PermissionDenied,
+                        error: "something permission denied something",
+                    },
+                ),
+                (
+                    Simple,
+                    Custom {
+                        kind: ConnectionRefused,
+                        error: "something resolve hostname hostfoobar: nodename nor servname something",
+                    },
+                ),
+                (
+                    Simple,
+                    Custom {
+                        kind: NotFound,
+                        error: "something connect to host something",
+                    },
+                ),
+            ]
+            "#);
         }
 
         #[test]
         fn tortoiseplink_putty_plink() {
+            let mut diagnostics = Vec::new();
             for kind in [ProgramKind::TortoisePlink, ProgramKind::Plink, ProgramKind::Putty] {
+                let err = kind
+                    .line_to_err("publickey".into())
+                    .expect("publickey is a recognized authentication failure");
                 assert_eq!(
-                    kind.line_to_err("publickey".into()).map(|err| err.kind()),
-                    Ok(std::io::ErrorKind::PermissionDenied),
+                    err.kind(),
+                    std::io::ErrorKind::PermissionDenied,
                     "this program pops up error messages in a window, no way to extract information from it. Maybe there is other ways to use it, 'publickey' they mention all"
                 );
+                diagnostics.push((kind, err));
             }
+            insta::assert_debug_snapshot!(diagnostics, "PuTTY variants retain their public-key authentication failure", @r#"
+            [
+                (
+                    TortoisePlink,
+                    Custom {
+                        kind: PermissionDenied,
+                        error: "publickey",
+                    },
+                ),
+                (
+                    Plink,
+                    Custom {
+                        kind: PermissionDenied,
+                        error: "publickey",
+                    },
+                ),
+                (
+                    Putty,
+                    Custom {
+                        kind: PermissionDenied,
+                        error: "publickey",
+                    },
+                ),
+            ]
+            "#);
         }
     }
 }
diff --git a/gix-transport/src/client/capabilities.rs b/gix-transport/src/client/capabilities.rs
index 0e1a005e195..1fedc37bb34 100644
--- a/gix-transport/src/client/capabilities.rs
+++ b/gix-transport/src/client/capabilities.rs
@@ -1,26 +1,9 @@
 use bstr::{BStr, BString, ByteSlice};
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, message};
 
-use crate::Protocol;
 #[cfg(any(feature = "blocking-client", feature = "async-client"))]
-use crate::client;
-
-/// The error used in [`Capabilities::from_bytes()`] and [`Capabilities::from_lines()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Capabilities were missing entirely as there was no 0 byte")]
-    MissingDelimitingNullByte,
-    #[error("there was not a single capability behind the delimiter")]
-    NoCapabilities,
-    #[error("a version line was expected, but none was retrieved")]
-    MissingVersionLine,
-    #[error("expected 'version X', got {0:?}")]
-    MalformattedVersionLine(BString),
-    #[error("Got unsupported version {actual:?}, expected {}", *desired as u8)]
-    UnsupportedVersion { desired: Protocol, actual: BString },
-    #[error("An IO error occurred while reading V2 lines")]
-    Io(#[from] std::io::Error),
-}
+use crate::{Protocol, client};
 
 /// A structure to represent multiple [capabilities](Capability) or features supported by the server.
 ///
@@ -82,10 +65,12 @@ impl Capabilities {
     /// Parse capabilities from the given `bytes`.
     ///
     /// Useful in case they are encoded within a `ref` behind a null byte.
-    pub fn from_bytes(bytes: &[u8]) -> Result<(Capabilities, usize), Error> {
-        let delimiter_pos = bytes.find_byte(0).ok_or(Error::MissingDelimitingNullByte)?;
+    pub fn from_bytes(bytes: &[u8]) -> ExnMessageResult<(Capabilities, usize)> {
+        let delimiter_pos = bytes
+            .find_byte(0)
+            .ok_or_else(|| message("Capabilities were missing entirely as there was no 0 byte").raise())?;
         if delimiter_pos + 1 == bytes.len() {
-            return Err(Error::NoCapabilities);
+            return Err(message("there was not a single capability behind the delimiter").raise());
         }
         let capabilities = &bytes[delimiter_pos + 1..];
         Ok((
@@ -103,22 +88,21 @@ impl Capabilities {
     /// Useful for parsing capabilities from a data sent from a server, and to avoid having to deal with
     /// blocking and async traits for as long as possible. There is no value in parsing a few bytes
     /// in a non-blocking fashion.
-    pub fn from_lines(lines_buf: BString) -> Result<Capabilities, Error> {
+    pub fn from_lines(lines_buf: BString) -> ExnMessageResult<Capabilities> {
         let mut lines = <_ as bstr::ByteSlice>::lines(lines_buf.as_slice().trim());
-        let version_line = lines.next().ok_or(Error::MissingVersionLine)?;
+        let version_line = lines
+            .next()
+            .ok_or_else(|| message("a version line was expected, but none was retrieved").raise())?;
         let (name, value) = version_line.split_at(
             version_line
                 .find(b" ")
-                .ok_or_else(|| Error::MalformattedVersionLine(version_line.to_owned().into()))?,
+                .ok_or_else(|| message!("expected 'version X', got {version_line:?}").raise())?,
         );
         if name != b"version" {
-            return Err(Error::MalformattedVersionLine(version_line.to_owned().into()));
+            return Err(message!("expected 'version X', got {version_line:?}").raise());
         }
         if value != b" 2" {
-            return Err(Error::UnsupportedVersion {
-                desired: Protocol::V2,
-                actual: value.to_owned().into(),
-            });
+            return Err(message!("Got unsupported version {value:?}, expected 2").raise());
         }
         Ok(Capabilities {
             value_sep: b'\n',
diff --git a/gix-transport/src/client/git/async_io.rs b/gix-transport/src/client/git/async_io.rs
index 53fbfd58dd8..a2f101046b4 100644
--- a/gix-transport/src/client/git/async_io.rs
+++ b/gix-transport/src/client/git/async_io.rs
@@ -1,4 +1,6 @@
-use std::{borrow::Cow, error::Error};
+use std::borrow::Cow;
+
+use gix_error::ExnResult;
 
 use async_trait::async_trait;
 use bstr::{BStr, BString, ByteVec};
@@ -65,7 +67,7 @@ where
         true
     }
 
-    fn configure(&mut self, _config: &dyn std::any::Any) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    fn configure(&mut self, _config: &dyn std::any::Any) -> ExnResult {
         Ok(())
     }
 }
diff --git a/gix-transport/src/client/git/blocking_io.rs b/gix-transport/src/client/git/blocking_io.rs
index 28045697863..650ca0187a4 100644
--- a/gix-transport/src/client/git/blocking_io.rs
+++ b/gix-transport/src/client/git/blocking_io.rs
@@ -1,4 +1,6 @@
-use std::{any::Any, borrow::Cow, error::Error, io::Write};
+use std::{any::Any, borrow::Cow, io::Write};
+
+use gix_error::ExnResult;
 
 use bstr::{BStr, BString, ByteVec};
 
@@ -63,7 +65,7 @@ where
         true
     }
 
-    fn configure(&mut self, _config: &dyn Any) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    fn configure(&mut self, _config: &dyn Any) -> ExnResult {
         Ok(())
     }
 }
@@ -174,36 +176,20 @@ pub mod connect {
     use std::net::{TcpStream, ToSocketAddrs};
 
     use bstr::BString;
+    use gix_error::{ExnMessageResult, ResultExt, message};
 
     use super::Connection;
     use crate::client::git;
 
-    /// The error used in [`connect()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An IO error occurred when connecting to the server")]
-        Io(#[from] std::io::Error),
-        #[error("Could not parse {host:?} as virtual host with format <host>[:port]")]
-        VirtualHostInvalid { host: String },
-    }
-
-    impl crate::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::Io(err) => err.is_spurious(),
-                _ => false,
-            }
-        }
-    }
-
-    fn parse_host(input: String) -> Result<(String, Option<u16>), Error> {
+    fn parse_host(input: String) -> ExnMessageResult<(String, Option<u16>)> {
         let mut tokens = input.splitn(2, ':');
         Ok(match (tokens.next(), tokens.next()) {
             (Some(host), None) => (host.to_owned(), None),
             (Some(host), Some(port)) => (
                 host.to_owned(),
-                Some(port.parse().map_err(|_| Error::VirtualHostInvalid { host: input })?),
+                Some(port.parse::<u16>().or_raise(|| {
+                    gix_error::message!("Could not parse {input:?} as virtual host with format <host>[:port]")
+                })?),
             ),
             _ => unreachable!("we expect at least one token, the original string"),
         })
@@ -219,15 +205,19 @@ pub mod connect {
         desired_version: crate::Protocol,
         port: Option<u16>,
         trace: bool,
-    ) -> Result<Connection<TcpStream, TcpStream>, Error> {
+    ) -> ExnMessageResult<Connection<TcpStream, TcpStream>> {
         let read = TcpStream::connect_timeout(
             &(host, port.unwrap_or(9418))
-                .to_socket_addrs()?
+                .to_socket_addrs()
+                .or_raise(|| message("Could not resolve git server"))?
                 .next()
                 .expect("after successful resolution there is an IP address"),
             std::time::Duration::from_secs(5),
-        )?;
-        let write = read.try_clone()?;
+        )
+        .or_raise(|| message("Could not connect to git server"))?;
+        let write = read
+            .try_clone()
+            .or_raise(|| message("Could not clone git server connection"))?;
         let vhost = std::env::var("GIT_OVERRIDE_VIRTUAL_HOST")
             .ok()
             .map(parse_host)
diff --git a/gix-transport/src/client/non_io_types.rs b/gix-transport/src/client/non_io_types.rs
index fe391b7e064..1885f20f4ad 100644
--- a/gix-transport/src/client/non_io_types.rs
+++ b/gix-transport/src/client/non_io_types.rs
@@ -44,49 +44,6 @@ pub(crate) mod connect {
         /// If `true`, all packetlines received or sent will be passed to the facilities of the `gix-trace` crate.
         pub trace: bool,
     }
-
-    /// The error used in `connect()`.
-    ///
-    /// (Both blocking and async I/O use the same error type.)
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Url(#[from] gix_error::Error),
-        #[error("The git repository path could not be converted to UTF8")]
-        PathConversion(#[from] bstr::Utf8Error),
-        #[error("connection failed")]
-        Connection(#[from] Box<dyn std::error::Error + Send + Sync>),
-        #[error("The url {url:?} contains information that would not be used by the {scheme} protocol")]
-        UnsupportedUrlTokens {
-            url: bstr::BString,
-            scheme: gix_url::Scheme,
-        },
-        #[error("The '{0}' protocol is currently unsupported")]
-        UnsupportedScheme(gix_url::Scheme),
-        #[cfg(not(any(feature = "http-client-curl", feature = "http-client-reqwest")))]
-        #[error("'{0}' is not compiled in. Compile with the 'http-client-curl' or 'http-client-reqwest' cargo feature")]
-        CompiledWithoutHttp(gix_url::Scheme),
-    }
-
-    // TODO: maybe fix this workaround: want `IsSpuriousError`  in `Connection(…)`
-    impl crate::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::Connection(err) => {
-                    #[cfg(feature = "blocking-client")]
-                    if let Some(err) = err.downcast_ref::<crate::client::git::blocking_io::connect::Error>() {
-                        return err.is_spurious();
-                    }
-                    if let Some(err) = err.downcast_ref::<crate::client::Error>() {
-                        return err.is_spurious();
-                    }
-                    false
-                }
-                _ => false,
-            }
-        }
-    }
 }
 
 mod error {
@@ -94,18 +51,11 @@ mod error {
 
     use bstr::BString;
 
-    #[cfg(feature = "http-client")]
-    use crate::client::blocking_io::http;
     #[cfg(feature = "blocking-client")]
     use crate::client::blocking_io::ssh;
-    use crate::client::capabilities;
 
-    #[cfg(feature = "http-client")]
-    type HttpError = http::Error;
     #[cfg(feature = "blocking-client")]
     type SshInvocationError = ssh::invocation::Error;
-    #[cfg(not(feature = "http-client"))]
-    type HttpError = std::convert::Infallible;
     #[cfg(not(feature = "blocking-client"))]
     type SshInvocationError = std::convert::Infallible;
 
@@ -114,57 +64,382 @@ mod error {
     ///
     /// Callers can downcast [`std::io::Error::get_ref()`] to this type and forward the challenges
     /// to credential helpers as `wwwauth[]` attributes.
-    #[derive(Debug, Default, thiserror::Error)]
-    #[error("Received HTTP status 401")]
+    #[derive(Debug, Default)]
     pub struct AuthenticationRequired {
         /// HTTP `WWW-Authenticate` header values in the order supplied by the server.
         pub www_authenticate: Vec<BString>,
     }
 
-    /// The error used in most methods of the [`client`][crate::client] module
-    #[derive(thiserror::Error, Debug)]
+    impl std::fmt::Display for AuthenticationRequired {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str("Received HTTP status 401")
+        }
+    }
+
+    impl std::error::Error for AuthenticationRequired {}
+
+    /// The error used in most methods of the [`client`][crate::client] module.
+    ///
+    /// Sources preserve classifications when raised or converted to [`gix_error::Error`]. Unsafe arguments and
+    /// unexpected packet lines expose classification-only [`gix_error::ClassificationMarker`] sources.
+    /// Use [`gix_error::classify()`] or the classification predicates on [`gix_error::Exn`] and [`gix_error::Error`],
+    /// rather than downcasting these markers to concrete classifier errors. Use [`gix_error::classify()`] with
+    /// [`can_retry()`](gix_error::types::Classifications::can_retry) or
+    /// [`can_retry_lenient()`](gix_error::types::Classifications::can_retry_lenient) to inspect retryability directly.
+    #[derive(Debug)]
     #[expect(missing_docs)]
     pub enum Error {
-        #[error("A request was performed without performing the handshake first")]
         MissingHandshake,
-        #[error("An IO error occurred when talking to the server")]
-        Io(#[from] std::io::Error),
-        #[error("Capabilities could not be parsed")]
+        Io(std::io::Error),
         Capabilities {
-            #[from]
-            err: capabilities::Error,
+            err: gix_error::Error,
         },
-        #[error("A packet line could not be decoded")]
         LineDecode {
-            #[from]
-            err: gix_packetline::decode::Error,
+            err: gix_error::Message,
         },
-        #[error("A {0} line was expected, but there was none")]
         ExpectedLine(&'static str),
-        #[error("Expected a data line, but got a delimiter")]
         ExpectedDataLine,
-        #[error("The transport layer does not support authentication")]
         AuthenticationUnsupported,
-        #[error("The transport layer refuses to use a given identity: {0}")]
         AuthenticationRefused(&'static str),
-        #[error("The protocol version indicated by {:?} is unsupported", {0})]
         UnsupportedProtocolVersion(BString),
-        #[error("Failed to invoke program {command:?}")]
-        InvokeProgram { source: std::io::Error, command: OsString },
-        #[error(transparent)]
-        Http(#[from] HttpError),
-        #[error(transparent)]
+        InvokeProgram {
+            source: std::io::Error,
+            command: OsString,
+        },
+        #[cfg(feature = "http-client")]
+        Http(gix_error::Error),
+        #[cfg(not(feature = "http-client"))]
+        Http(std::convert::Infallible),
         SshInvocation(SshInvocationError),
-        #[error("The repository path '{path}' could be mistaken for a command-line argument")]
-        AmbiguousPath { path: BString },
+        AmbiguousPath {
+            path: BString,
+        },
     }
 
-    impl crate::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
-                Error::Io(err) => err.is_spurious(),
-                Error::Http(err) => err.is_spurious(),
-                _ => false,
+                Error::MissingHandshake => {
+                    f.write_str("A request was performed without performing the handshake first")
+                }
+                Error::Io(_) => f.write_str("An IO error occurred when talking to the server"),
+                Error::Capabilities { .. } => f.write_str("Capabilities could not be parsed"),
+                Error::LineDecode { .. } => f.write_str("A packet line could not be decoded"),
+                Error::ExpectedLine(line) => write!(f, "A {line} line was expected, but there was none"),
+                Error::ExpectedDataLine => f.write_str("Expected a data line, but got a delimiter"),
+                Error::AuthenticationUnsupported => f.write_str("The transport layer does not support authentication"),
+                Error::AuthenticationRefused(reason) => {
+                    write!(f, "The transport layer refuses to use a given identity: {reason}")
+                }
+                Error::UnsupportedProtocolVersion(version) => {
+                    write!(f, "The protocol version indicated by {version:?} is unsupported")
+                }
+                Error::InvokeProgram { command, .. } => write!(f, "Failed to invoke program {}", command.display()),
+                Error::Http(err) => std::fmt::Display::fmt(err, f),
+                Error::SshInvocation(_) => f.write_str("Failed to prepare SSH invocation"),
+                Error::AmbiguousPath { path } => {
+                    write!(
+                        f,
+                        "The repository path '{path}' could be mistaken for a command-line argument"
+                    )
+                }
+            }
+        }
+    }
+
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match self {
+                Error::Io(err) => Some(err),
+                Error::LineDecode { err } => Some(err),
+                Error::InvokeProgram { source, .. } => Some(source),
+                Error::Capabilities { err } => Some(err),
+                Error::Http(err) => Some(err),
+                Error::SshInvocation(err) => Some(err),
+                Error::AmbiguousPath { .. } => Some(const { &gix_error::ClassificationMarker::VALIDATION }),
+                Error::ExpectedLine(_) | Error::ExpectedDataLine => {
+                    Some(const { &gix_error::ClassificationMarker::CORRUPTION })
+                }
+                _ => None,
+            }
+        }
+    }
+
+    impl From<std::io::Error> for Error {
+        fn from(err: std::io::Error) -> Self {
+            Error::Io(err)
+        }
+    }
+
+    impl From<gix_error::Exn<gix_error::Message>> for Error {
+        fn from(err: gix_error::Exn<gix_error::Message>) -> Self {
+            Error::Capabilities { err: err.into_error() }
+        }
+    }
+
+    impl From<gix_error::Message> for Error {
+        fn from(err: gix_error::Message) -> Self {
+            Error::LineDecode { err }
+        }
+    }
+
+    impl From<Error> for gix_error::Error {
+        fn from(err: Error) -> Self {
+            Self::from_error(err)
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use gix_error::ErrorExt;
+        #[cfg(feature = "http-client")]
+        use gix_error::{Class, ClassificationMarker, message};
+
+        #[test]
+        fn io_classification_is_independent_of_conversion() {
+            let mut diagnostics = Vec::new();
+            for kind in [
+                std::io::ErrorKind::Interrupted,
+                std::io::ErrorKind::UnexpectedEof,
+                std::io::ErrorKind::TimedOut,
+                std::io::ErrorKind::BrokenPipe,
+                std::io::ErrorKind::AddrInUse,
+                std::io::ErrorKind::ConnectionAborted,
+                std::io::ErrorKind::ConnectionReset,
+                std::io::ErrorKind::ConnectionRefused,
+                std::io::ErrorKind::OutOfMemory,
+                std::io::ErrorKind::NotFound,
+                std::io::ErrorKind::PermissionDenied,
+            ] {
+                let make_error = || super::Error::Io(kind.into());
+                let can_retry = gix_error::classify(&make_error()).can_retry();
+                let can_retry_lenient = gix_error::classify(&make_error()).can_retry_lenient();
+                let err = gix_error::Error::from(make_error());
+                assert_eq!(
+                    err.can_retry(),
+                    can_retry,
+                    "the transport conversion preserves the conservative policy for {kind:?}"
+                );
+                assert_eq!(
+                    err.can_retry_lenient(),
+                    can_retry_lenient,
+                    "the transport conversion preserves the lenient policy for {kind:?}"
+                );
+                assert!(
+                    !err.is_retryable(),
+                    "the transport conversion does not add an explicit retry marker for {kind:?}"
+                );
+                assert_eq!(err.is_not_found(), kind == std::io::ErrorKind::NotFound);
+                assert_eq!(err.is_resource_exhausted(), kind == std::io::ErrorKind::OutOfMemory);
+                diagnostics.push((kind, gix_error::TestError::from(err)));
+            }
+            insta::assert_debug_snapshot!(diagnostics, "transport I/O errors retain the original cause and retry policy", @"
+            [
+                (
+                    Interrupted,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ operation interrupted,
+                ),
+                (
+                    UnexpectedEof,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ unexpected end of file,
+                ),
+                (
+                    TimedOut,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ timed out,
+                ),
+                (
+                    BrokenPipe,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ broken pipe,
+                ),
+                (
+                    AddrInUse,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ address in use,
+                ),
+                (
+                    ConnectionAborted,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ connection aborted,
+                ),
+                (
+                    ConnectionReset,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ connection reset,
+                ),
+                (
+                    ConnectionRefused,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ connection refused,
+                ),
+                (
+                    OutOfMemory,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ out of memory,
+                ),
+                (
+                    NotFound,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ entity not found,
+                ),
+                (
+                    PermissionDenied,
+                    An IO error occurred when talking to the server
+                    |
+                    └─ permission denied,
+                ),
+            ]
+            ");
+        }
+
+        #[cfg(feature = "http-client")]
+        #[test]
+        fn http_keeps_retryable_sources() {
+            let err = super::Error::Http(
+                std::io::Error::new(std::io::ErrorKind::BrokenPipe, "retry me")
+                    .and_raise(message("HTTP failed"))
+                    .into_error(),
+            );
+            insta::assert_debug_snapshot!(err, "http keeps retryable sources", @"
+            Http(
+                HTTP failed
+                |
+                └─ I/O error (BrokenPipe)
+                |
+                └─ retry me,
+            )
+            ");
+
+            assert!(gix_error::classify(&err).can_retry_lenient());
+            assert!(!gix_error::classify(&err).can_retry());
+            let source = std::error::Error::source(&err)
+                .and_then(|err| err.downcast_ref::<gix_error::Error>())
+                .expect("HTTP errors retain their gix-error wrapper");
+            assert!(
+                source
+                    .iter_errors()
+                    .any(<dyn std::error::Error + 'static>::is::<std::io::Error>)
+            );
+
+            let explicit = super::Error::Http(
+                ClassificationMarker::with_source(Class::Retryable, message("retry me"))
+                    .and_raise(message("HTTP failed"))
+                    .into_error(),
+            );
+            insta::assert_debug_snapshot!(explicit, "HTTP errors retain an explicit retryable source", @"
+            Http(
+                HTTP failed
+                |
+                └─ retry me,
+            )
+            ");
+            assert!(gix_error::classify(&explicit).can_retry());
+            assert!(gix_error::Error::from(explicit).is_retryable());
+
+            let out_of_memory = super::Error::Http(
+                std::io::Error::from(std::io::ErrorKind::OutOfMemory)
+                    .and_raise(message("HTTP failed"))
+                    .into_error(),
+            );
+            insta::assert_debug_snapshot!(out_of_memory, "HTTP errors retain the allocation failure as their source", @"
+            Http(
+                HTTP failed
+                |
+                └─ out of memory,
+            )
+            ");
+            assert!(!gix_error::classify(&out_of_memory).can_retry());
+            assert!(gix_error::classify(&out_of_memory).can_retry_lenient());
+            assert!(gix_error::Error::from(out_of_memory).is_resource_exhausted());
+        }
+
+        #[test]
+        fn custom_errors_expose_classifications() {
+            use gix_error::Class;
+
+            fn check<Cause: std::error::Error + 'static>(
+                err: impl std::error::Error + Send + Sync + 'static,
+                class: Class,
+            ) -> gix_error::Exn {
+                let err = err.raise();
+                assert_eq!(
+                    err.is_validation(),
+                    class == Class::Validation,
+                    "unsafe transport arguments are invalid input"
+                );
+                assert_eq!(
+                    err.is_corrupted(),
+                    class == Class::Corruption,
+                    "unexpected packet lines are malformed responses"
+                );
+                assert!(
+                    err.downcast_any_ref::<Cause>().is_some(),
+                    "the concrete transport error remains available"
+                );
+                assert!(
+                    err.probable_cause().is::<Cause>(),
+                    "the concrete transport error, not its classification marker, is the probable cause"
+                );
+                err.erased()
+            }
+
+            let mut diagnostics = vec![check::<super::Error>(
+                super::Error::AmbiguousPath { path: "-arg".into() },
+                Class::Validation,
+            )];
+            for err in [super::Error::ExpectedLine("version"), super::Error::ExpectedDataLine] {
+                diagnostics.push(check::<super::Error>(err, Class::Corruption));
+            }
+            insta::assert_debug_snapshot!(diagnostics, "unsafe paths and malformed protocol lines retain their concrete diagnostics", @"
+            [
+                The repository path '-arg' could be mistaken for a command-line argument,
+                A version line was expected, but there was none,
+                Expected a data line, but got a delimiter,
+            ]
+            ");
+
+            #[cfg(feature = "blocking-client")]
+            {
+                use crate::client::blocking_io::ssh;
+
+                let mut diagnostics = Vec::new();
+                for err in [
+                    ssh::invocation::Error::AmbiguousUserName { user: "-arg".into() },
+                    ssh::invocation::Error::AmbiguousHostName { host: "-arg".into() },
+                ] {
+                    diagnostics.push(check::<ssh::invocation::Error>(
+                        super::Error::SshInvocation(err),
+                        Class::Validation,
+                    ));
+                }
+                diagnostics.push(check::<ssh::Error>(
+                    ssh::Error::AmbiguousHostName { host: "-arg".into() },
+                    Class::Validation,
+                ));
+                insta::assert_debug_snapshot!(diagnostics, "SSH invocation context preserves the rejected argument as its cause", @"
+                [
+                    Failed to prepare SSH invocation
+                    |
+                    └─ Username '-arg' could be mistaken for a command-line argument,
+                    Failed to prepare SSH invocation
+                    |
+                    └─ Host name '-arg' could be mistaken for a command-line argument,
+                    Host name '-arg' could be mistaken for a command-line argument,
+                ]
+                ");
             }
         }
     }
diff --git a/gix-transport/src/client/traits.rs b/gix-transport/src/client/traits.rs
index 4a54fa15ee9..0cf843c65cb 100644
--- a/gix-transport/src/client/traits.rs
+++ b/gix-transport/src/client/traits.rs
@@ -4,6 +4,8 @@ use std::{
     ops::{Deref, DerefMut},
 };
 
+use gix_error::ExnResult;
+
 use bstr::BStr;
 
 use crate::{Protocol, client::Error};
@@ -48,7 +50,7 @@ pub trait TransportWithoutIO {
     /// Pass `config` can be cast and interpreted by the implementation, as documented separately.
     ///
     /// The caller must know how that `config` data looks like for the intended implementation.
-    fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>;
+    fn configure(&mut self, config: &dyn Any) -> ExnResult;
 }
 
 // Would be nice if the box implementation could auto-forward to all implemented traits.
@@ -69,7 +71,7 @@ impl<T: TransportWithoutIO + ?Sized> TransportWithoutIO for Box<T> {
         self.deref().connection_persists_across_multiple_requests()
     }
 
-    fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    fn configure(&mut self, config: &dyn Any) -> ExnResult {
         self.deref_mut().configure(config)
     }
 }
@@ -91,7 +93,7 @@ impl<T: TransportWithoutIO + ?Sized> TransportWithoutIO for &mut T {
         self.deref().connection_persists_across_multiple_requests()
     }
 
-    fn configure(&mut self, config: &dyn Any) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    fn configure(&mut self, config: &dyn Any) -> ExnResult {
         self.deref_mut().configure(config)
     }
 }
diff --git a/gix-transport/src/lib.rs b/gix-transport/src/lib.rs
index a580448e685..f55abd40ec0 100644
--- a/gix-transport/src/lib.rs
+++ b/gix-transport/src/lib.rs
@@ -60,34 +60,5 @@ impl Service {
     }
 }
 
-mod traits {
-    use std::convert::Infallible;
-
-    /// An error which can tell whether it's worth retrying to maybe succeed next time.
-    pub trait IsSpuriousError: std::error::Error {
-        /// Return `true` if retrying might result in a different outcome due to IO working out differently.
-        fn is_spurious(&self) -> bool {
-            false
-        }
-    }
-
-    impl IsSpuriousError for Infallible {}
-
-    impl IsSpuriousError for std::io::Error {
-        fn is_spurious(&self) -> bool {
-            // TODO: also include the new special Kinds (currently unstable)
-            use std::io::ErrorKind::*;
-            match self.kind() {
-                Unsupported | WriteZero | InvalidInput | InvalidData | WouldBlock | AlreadyExists
-                | AddrNotAvailable | NotConnected | Other | PermissionDenied | NotFound => false,
-                Interrupted | UnexpectedEof | OutOfMemory | TimedOut | BrokenPipe | AddrInUse | ConnectionAborted
-                | ConnectionReset | ConnectionRefused => true,
-                _ => false,
-            }
-        }
-    }
-}
-pub use traits::IsSpuriousError;
-
 ///
 pub mod client;
diff --git a/gix-transport/tests/async-transport.rs b/gix-transport/tests/async-transport.rs
index fdb06208b5c..2d08a223823 100644
--- a/gix-transport/tests/async-transport.rs
+++ b/gix-transport/tests/async-transport.rs
@@ -4,7 +4,7 @@ pub mod bisync {
 
 use std::path::PathBuf;
 
-pub type Error = Box<dyn std::error::Error>;
+pub type Error = Box<dyn std::error::Error + Send + Sync>;
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
 pub fn fixture_bytes(path: &str) -> Vec<u8> {
diff --git a/gix-transport/tests/blocking-transport-http-reqwest.rs b/gix-transport/tests/blocking-transport-http-reqwest.rs
index 9ca1d884447..9870cff2ffb 100644
--- a/gix-transport/tests/blocking-transport-http-reqwest.rs
+++ b/gix-transport/tests/blocking-transport-http-reqwest.rs
@@ -105,16 +105,19 @@ fn redirects_are_not_followed_with_configure_request_hook() -> Result<(), Box<dy
     let redirected_was_contacted_within_deadline = redirected.join().expect("thread");
 
     assert!(result.is_err(), "redirects with a request hook should fail");
-    match result {
-        Ok(_) => unreachable!("handshake must fail"),
-        Err(err) => {
-            let err = format!("{err:?}");
-            assert!(
-                err.contains("refusing to follow redirect after request headers were configured"),
-                "error should indicate that it failed due to redirection, got {err}"
-            );
-        }
-    }
+    let err = result.err().expect("the redirect must be rejected");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&gix_error::TestError::from(err), &[
+        (&redirect_addr.to_string(), "127.0.0.1:<original-port>"),
+        (&redirected_addr.to_string(), "127.0.0.1:<redirect-port>"),
+    ]), "redirects are rejected after private request headers have been configured", @"
+    An IO error occurred when talking to the server
+    |
+    └─ I/O error (Other)
+    |
+    └─ error following redirect for url (http://127.0.0.1:<original-port>/repo/info/refs?service=git-upload-pack)
+    |
+    └─ refusing to follow redirect after request headers were configured
+    ");
     assert!(
         original_get
             .iter()
@@ -233,16 +236,19 @@ fn cross_authority_redirects_are_not_followed_without_matching_tail() -> Result<
     let original_get = redirect.join().expect("thread");
     let redirected_was_contacted = redirected.join().expect("thread");
 
-    match result {
-        Ok(_) => unreachable!("tail-mismatched cross-authority redirects should fail"),
-        Err(err) => {
-            let err = format!("{err:?}");
-            assert!(
-                err.contains("not-the-request-tail"),
-                "error should indicate that it failed due to redirection, got {err}"
-            );
-        }
-    }
+    let err = result.err().expect("the redirect must be rejected");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&gix_error::TestError::from(err), &[
+        (&redirect_addr.to_string(), "127.0.0.1:<original-port>"),
+        (&redirected_addr.to_string(), "127.0.0.1:<redirect-port>"),
+    ]), "redirect rejection retains the mismatched request path", @r#"
+    An IO error occurred when talking to the server
+    |
+    └─ I/O error (Other)
+    |
+    └─ error following redirect for url (http://127.0.0.1:<original-port>/repo/info/refs?service=git-upload-pack)
+    |
+    └─ redirect url "http://127.0.0.1:<redirect-port>/not-the-request-tail" does not end with expected request suffix "/info/refs?service=git-upload-pack"
+    "#);
     assert!(
         !original_get.is_empty(),
         "the original request should still be sent before the redirect is rejected"
diff --git a/gix-transport/tests/blocking-transport-http.rs b/gix-transport/tests/blocking-transport-http.rs
index 58b67a7011d..77bfda1cc5a 100644
--- a/gix-transport/tests/blocking-transport-http.rs
+++ b/gix-transport/tests/blocking-transport-http.rs
@@ -6,7 +6,7 @@ pub mod bisync {
 
 use std::path::PathBuf;
 
-pub type Error = Box<dyn std::error::Error>;
+pub type Error = Box<dyn std::error::Error + Send + Sync>;
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
 pub fn fixture_bytes(path: &str) -> Vec<u8> {
diff --git a/gix-transport/tests/blocking-transport.rs b/gix-transport/tests/blocking-transport.rs
index a7b9846aaf1..b9f79c89ee4 100644
--- a/gix-transport/tests/blocking-transport.rs
+++ b/gix-transport/tests/blocking-transport.rs
@@ -4,7 +4,7 @@ pub mod bisync {
 
 use std::path::PathBuf;
 
-pub type Error = Box<dyn std::error::Error>;
+pub type Error = Box<dyn std::error::Error + Send + Sync>;
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
 pub fn fixture_bytes(path: &str) -> Vec<u8> {
@@ -14,6 +14,7 @@ pub fn fixture_bytes(path: &str) -> Vec<u8> {
     std::fs::read(fixture_path(path)).expect("fixture to be present and readable")
 }
 
+#[cfg(all(feature = "http-client", not(feature = "http-client-curl")))]
 mod http_helpers;
 
 #[cfg(not(feature = "http-client-curl"))]
diff --git a/gix-transport/tests/client/blocking_io/http/mod.rs b/gix-transport/tests/client/blocking_io/http/mod.rs
index 37499604b24..ed5c3b22887 100644
--- a/gix-transport/tests/client/blocking_io/http/mod.rs
+++ b/gix-transport/tests/client/blocking_io/http/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::{
     cell::RefCell,
     collections::HashSet,
@@ -32,33 +33,52 @@ type Remote = http::reqwest::Remote;
 fn assert_error_status(
     status: usize,
     kind: std::io::ErrorKind,
-) -> Result<(mock::Server, http::Transport<Remote>), crate::Error> {
+) -> std::result::Result<(mock::Server, http::Transport<Remote>, impl std::fmt::Debug), crate::Error> {
     let (server, mut client) =
         mock::serve_and_connect(&format!("http-{status}.response"), "path/not-important", Protocol::V1)?;
     let error = client
         .handshake(Service::UploadPack, &[])
         .err()
         .expect("non-200 status causes error");
-    let error = error
+    let io_error = error
         .source()
         .unwrap_or_else(|| panic!("no source() in: {error:?} "))
         .downcast_ref::<std::io::Error>()
         .expect("io error as source");
-    assert_eq!(error.kind(), kind);
-    let expected = format!("Received HTTP status {status}");
-    assert_eq!(error.to_string().get(..expected.len()), Some(expected).as_deref());
+    assert_eq!(io_error.kind(), kind);
+    let diagnostic = gix_testtools::redact_debug_snapshot(
+        &gix_error::TestError::from(error),
+        &[(&server.addr.to_string(), "127.0.0.1:<port>")],
+    );
     drop(server.received());
-    Ok((server, client))
+    Ok((server, client, diagnostic))
 }
 
 #[test]
-fn http_status_500_is_communicated_via_special_io_error() -> crate::Result {
-    assert_error_status(500, std::io::ErrorKind::ConnectionAborted)?;
+fn http_status_500_is_communicated_via_special_io_error() -> Result {
+    let (_, _, err) = assert_error_status(500, std::io::ErrorKind::ConnectionAborted)?;
+    if cfg!(feature = "http-client-curl") {
+        insta::assert_debug_snapshot!(err, "HTTP server errors report the status and retain the retryable I/O kind", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (ConnectionAborted)
+        |
+        └─ Received HTTP status 500
+        ");
+    } else {
+        insta::assert_debug_snapshot!(err, "HTTP server errors report the status and retain the retryable I/O kind", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (ConnectionAborted)
+        |
+        └─ Received HTTP status 500
+        ");
+    }
     Ok(())
 }
 
 #[test]
-fn http_identity_is_picked_up_from_url() -> crate::Result {
+fn http_identity_is_picked_up_from_url() -> Result {
     let transport = gix_transport::client::blocking_io::http::connect::<Remote>(
         "https://user:pass@example.com/repo".try_into()?,
         Protocol::V2,
@@ -85,7 +105,7 @@ fn http_will_use_pipelining() {
     fn headers(rdr: &mut dyn BufRead) -> HashSet<String> {
         let valid = ["GET", "Authorization", "Accept"];
         rdr.lines()
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .take_while(|s| s.len() > 2)
             .map(|s| s.trim().to_string())
             .filter(|s| valid.iter().any(|prefix| s.starts_with(*prefix)))
@@ -153,7 +173,18 @@ fn http_will_use_pipelining() {
     );
     match client.handshake(gix_transport::Service::UploadPack, &[]) {
         Ok(_) => unreachable!("expecting permission denied to be detected"),
-        Err(gix_transport::client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {}
+        Err(gix_transport::client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&addr.to_string(), "127.0.0.1:<port>")]), "HTTP authentication failures retain their status before and after setting credentials", @r#"
+            Custom {
+                kind: PermissionDenied,
+                error: AuthenticationRequired {
+                    www_authenticate: [
+                        "Basic realm=\"wheee\"",
+                    ],
+                },
+            }
+            "#);
+        }
         Err(err) => unreachable!("{err:?}"),
     }
     client
@@ -165,15 +196,33 @@ fn http_will_use_pipelining() {
         .unwrap();
     match client.handshake(gix_transport::Service::UploadPack, &[]) {
         Ok(_) => unreachable!("expecting permission denied to be detected"),
-        Err(gix_transport::client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {}
+        Err(gix_transport::client::Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied => {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&addr.to_string(), "127.0.0.1:<port>")]), "HTTP authentication failures retain their status before and after setting credentials", @r#"
+            Custom {
+                kind: PermissionDenied,
+                error: AuthenticationRequired {
+                    www_authenticate: [
+                        "Basic realm=\"testenv\"",
+                    ],
+                },
+            }
+            "#);
+        }
         Err(err) => unreachable!("{err:?}"),
     }
     thread.join().unwrap();
 }
 
 #[test]
-fn http_authentication_error_can_be_differentiated_and_identity_is_transmitted() -> crate::Result {
-    let (server, mut client) = assert_error_status(401, std::io::ErrorKind::PermissionDenied)?;
+fn http_authentication_error_can_be_differentiated_and_identity_is_transmitted() -> Result {
+    let (server, mut client, err) = assert_error_status(401, std::io::ErrorKind::PermissionDenied)?;
+    insta::assert_debug_snapshot!(err, "HTTP authentication failures retain the status and permission-denied cause", @"
+    An IO error occurred when talking to the server
+    |
+    └─ I/O error (PermissionDenied)
+    |
+    └─ Received HTTP status 401
+    ");
     server.next_read_and_respond_with(fixture_bytes("v1/http-handshake.response"));
     client.set_identity(gix_sec::identity::Account {
         username: "user".into(),
@@ -245,7 +294,8 @@ Authorization: Basic dXNlcjpwYXNzd29yZA==
 }
 
 #[test]
-fn authentication_challenges_are_preserved_per_response() -> crate::Result {
+fn authentication_challenges_are_preserved_per_response() -> Result {
+    let mut error_snapshots = Vec::new();
     let server = mock::Server::new(
         b"HTTP/1.1 401 Unauthorized\r\n\
           WWW-Authenticate: Basic realm=\"GitHub\" domain_hint=\"example\"\r\n\
@@ -269,6 +319,7 @@ fn authentication_challenges_are_preserved_per_response() -> crate::Result {
         let client::Error::Io(error) = error else {
             panic!("expected an I/O authentication error, got {error:?}");
         };
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(error), &[]));
         assert_eq!(
             error.kind(),
             io::ErrorKind::PermissionDenied,
@@ -289,6 +340,25 @@ fn authentication_challenges_are_preserved_per_response() -> crate::Result {
             );
         }
     }
+    insta::assert_debug_snapshot!(error_snapshots, "authentication challenges are preserved per response", @r#"
+    [
+        Custom {
+            kind: PermissionDenied,
+            error: AuthenticationRequired {
+                www_authenticate: [
+                    "Basic realm=\"GitHub\" domain_hint=\"example\"",
+                    "Bearer realm=\"example\"",
+                ],
+            },
+        },
+        Custom {
+            kind: PermissionDenied,
+            error: AuthenticationRequired {
+                www_authenticate: [],
+            },
+        },
+    ]
+    "#);
     Ok(())
 }
 
@@ -328,7 +398,7 @@ fn authentication_challenges_are_preserved_per_response() -> crate::Result {
 /// `Authorization: Basic dmljdGltLXVzZXI6c3VwZXItc2VjcmV0LXRva2Vu`, leaking them to the attacker.
 /// ```
 #[test]
-fn redirected_post_does_not_forward_basic_auth_to_the_new_host() -> crate::Result {
+fn redirected_post_does_not_forward_basic_auth_to_the_new_host() -> Result {
     fn has_authorization(lines: &[String]) -> bool {
         lines
             .iter()
@@ -479,7 +549,7 @@ fn redirected_post_does_not_forward_basic_auth_to_the_new_host() -> crate::Resul
 }
 
 #[test]
-fn redirected_unauthorized_handshake_updates_url_before_returning() -> crate::Result {
+fn redirected_unauthorized_handshake_updates_url_before_returning() -> Result {
     let redirected_listener = std::net::TcpListener::bind("127.0.0.1:0")?;
     let redirected_addr = redirected_listener.local_addr()?;
     let redirected_port = redirected_addr.port();
@@ -538,6 +608,16 @@ fn redirected_unauthorized_handshake_updates_url_before_returning() -> crate::Re
         .unwrap_or_else(|| panic!("no source() in: {error:?} "))
         .downcast_ref::<std::io::Error>()
         .expect("io error as source");
+    insta::assert_debug_snapshot!(error, "redirected unauthorized handshake updates url before returning", @r#"
+    Custom {
+        kind: PermissionDenied,
+        error: AuthenticationRequired {
+            www_authenticate: [
+                "Basic realm=\"redirected\"",
+            ],
+        },
+    }
+    "#);
     assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
     assert_eq!(
         error
@@ -568,7 +648,7 @@ fn redirected_unauthorized_handshake_updates_url_before_returning() -> crate::Re
 }
 
 #[test]
-fn relative_redirected_handshake_updates_url_before_returning() -> crate::Result {
+fn relative_redirected_handshake_updates_url_before_returning() -> Result {
     let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
     let addr = listener.local_addr()?;
     let port = addr.port();
@@ -627,7 +707,7 @@ fn relative_redirected_handshake_updates_url_before_returning() -> crate::Result
 }
 
 #[test]
-fn chained_relative_redirected_unauthorized_handshake_updates_url_from_previous_hop() -> crate::Result {
+fn chained_relative_redirected_unauthorized_handshake_updates_url_from_previous_hop() -> Result {
     let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
     let addr = listener.local_addr()?;
     let port = addr.port();
@@ -697,6 +777,14 @@ fn chained_relative_redirected_unauthorized_handshake_updates_url_from_previous_
         .unwrap_or_else(|| panic!("no source() in: {error:?} "))
         .downcast_ref::<std::io::Error>()
         .expect("io error as source");
+    insta::assert_debug_snapshot!(error, "chained relative redirected unauthorized handshake updates url from previous hop", @"
+    Custom {
+        kind: PermissionDenied,
+        error: AuthenticationRequired {
+            www_authenticate: [],
+        },
+    }
+    ");
     assert_eq!(error.kind(), std::io::ErrorKind::PermissionDenied);
 
     let (initial_get, second_get, final_get) = server.join().expect("thread");
@@ -727,7 +815,7 @@ fn chained_relative_redirected_unauthorized_handshake_updates_url_from_previous_
 }
 
 #[test]
-fn redirects_are_not_followed_with_configured_extra_headers() -> crate::Result {
+fn redirects_are_not_followed_with_configured_extra_headers() -> Result {
     let redirected_listener = std::net::TcpListener::bind("127.0.0.1:0")?;
     let redirected_addr = redirected_listener.local_addr()?;
     let redirect_listener = std::net::TcpListener::bind("127.0.0.1:0")?;
@@ -770,15 +858,31 @@ fn redirects_are_not_followed_with_configured_extra_headers() -> crate::Result {
     let original_get = redirect.join().expect("thread");
     let redirected_was_contacted = redirected.join().expect("thread");
 
-    match result {
-        Ok(_) => unreachable!("redirects with configured extra headers should fail"),
-        Err(err) => {
-            let err = format!("{err:?}");
-            assert!(
-                err.contains("refusing to follow redirect after request headers were configured"),
-                "error should indicate that it failed due to redirection, got {err}"
-            );
-        }
+    let err = result.err().expect("the redirect must be rejected");
+    if cfg!(feature = "http-client-curl") {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&gix_error::TestError::from(err), &[
+            (&redirect_addr.to_string(), "127.0.0.1:<original-port>"),
+            (&redirected_addr.to_string(), "127.0.0.1:<redirect-port>"),
+        ]), "redirects are rejected after private request headers have been configured", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (Other)
+        |
+        └─ refusing to follow redirect after request headers were configured
+        ");
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&gix_error::TestError::from(err), &[
+            (&redirect_addr.to_string(), "127.0.0.1:<original-port>"),
+            (&redirected_addr.to_string(), "127.0.0.1:<redirect-port>"),
+        ]), "redirects are rejected after private request headers have been configured", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (Other)
+        |
+        └─ error following redirect for url (http://127.0.0.1:<original-port>/repo/info/refs?service=git-upload-pack)
+        |
+        └─ refusing to follow redirect after request headers were configured
+        ");
     }
     assert!(
         original_get
@@ -794,13 +898,30 @@ fn redirects_are_not_followed_with_configured_extra_headers() -> crate::Result {
 }
 
 #[test]
-fn http_error_results_in_observable_error() -> crate::Result {
-    assert_error_status(404, std::io::ErrorKind::Other)?;
+fn http_error_results_in_observable_error() -> Result {
+    let (_, _, err) = assert_error_status(404, std::io::ErrorKind::Other)?;
+    if cfg!(feature = "http-client-curl") {
+        insta::assert_debug_snapshot!(err, "HTTP not-found responses retain their status diagnostic", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (Other)
+        |
+        └─ Received HTTP status 404
+        ");
+    } else {
+        insta::assert_debug_snapshot!(err, "HTTP not-found responses retain their status diagnostic", @"
+        An IO error occurred when talking to the server
+        |
+        └─ I/O error (Other)
+        |
+        └─ Received HTTP status 404
+        ");
+    }
     Ok(())
 }
 
 #[test]
-fn handshake_v1() -> crate::Result {
+fn handshake_v1() -> Result {
     let (server, mut c) = mock::serve_and_connect(
         "v1/http-handshake.response",
         "path/not/important/due/to/mock",
@@ -851,7 +972,7 @@ fn handshake_v1() -> crate::Result {
     let refs = refs
         .expect("v1 protocol provides refs")
         .lines()
-        .map_while(Result::ok)
+        .map_while(std::result::Result::ok)
         .collect::<Vec<_>>();
     assert_eq!(
         refs,
@@ -935,7 +1056,7 @@ User-Agent: git/oxide-{}
 }
 
 #[test]
-fn clone_v1() -> crate::Result {
+fn clone_v1() -> Result {
     let (server, mut c) = mock::serve_and_connect(
         "v1/http-handshake.response",
         "path/not/important/due/to/mock",
@@ -1016,12 +1137,12 @@ Accept: application/x-git-upload-pack-result
 }
 
 #[test]
-fn handshake_and_lsrefs_and_fetch_v2() -> crate::Result {
+fn handshake_and_lsrefs_and_fetch_v2() -> Result {
     handshake_and_lsrefs_and_fetch_v2_impl("v2/http-handshake.response")
 }
 
 #[test]
-fn handshake_and_lsrefs_and_fetch_v2_googlesource() -> crate::Result {
+fn handshake_and_lsrefs_and_fetch_v2_googlesource() -> Result {
     let (_server, mut c) = mock::serve_and_connect(
         "v2/http-no-newlines-handshake.response",
         "path/not/important/due/to/mock",
@@ -1080,12 +1201,12 @@ fn handshake_and_lsrefs_and_fetch_v2_googlesource() -> crate::Result {
 }
 
 #[test]
-fn handshake_and_lsrefs_and_fetch_v2_service_announced() -> crate::Result {
+fn handshake_and_lsrefs_and_fetch_v2_service_announced() -> Result {
     handshake_and_lsrefs_and_fetch_v2_impl("v2/http-handshake-service-announced.response")
 }
 
 #[test]
-fn handshake_v2_surfaces_sha256_object_format() -> crate::Result {
+fn handshake_v2_surfaces_sha256_object_format() -> Result {
     let (_server, mut c) = mock::serve_and_connect(
         "v2/http-handshake-sha256.response",
         "path/not/important/due/to/mock",
@@ -1121,7 +1242,7 @@ fn handshake_v2_surfaces_sha256_object_format() -> crate::Result {
     Ok(())
 }
 
-fn handshake_and_lsrefs_and_fetch_v2_impl(handshake_fixture: &str) -> crate::Result {
+fn handshake_and_lsrefs_and_fetch_v2_impl(handshake_fixture: &str) -> Result {
     let (server, mut c) = mock::serve_and_connect(handshake_fixture, "path/not/important/due/to/mock", Protocol::V2)?;
     assert!(
         !c.connection_persists_across_multiple_requests(),
@@ -1193,7 +1314,7 @@ Git-Protocol: version=2:value-only:key=value
         false,
     )?;
     assert_eq!(
-        res.lines().collect::<Result<Vec<_>, _>>()?,
+        res.lines().collect::<std::result::Result<Vec<_>, _>>()?,
         vec![
             "808e50d724f604f69ab93c6da2919c014667bedb HEAD symref-target:refs/heads/master",
             "808e50d724f604f69ab93c6da2919c014667bedb refs/heads/master"
@@ -1287,7 +1408,7 @@ Content-Length: 22
 }
 
 #[test]
-fn check_content_type_is_case_insensitive() -> crate::Result {
+fn check_content_type_is_case_insensitive() -> Result {
     let (_server, mut client) = mock::serve_and_connect(
         "v2/http-handshake-lowercase-headers.response",
         "path/not/important/due/to/mock",
diff --git a/gix-transport/tests/client/capabilities.rs b/gix-transport/tests/client/capabilities.rs
index 50276389b1c..e2cc35075fe 100644
--- a/gix-transport/tests/client/capabilities.rs
+++ b/gix-transport/tests/client/capabilities.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
 use gix_packetline::async_io::{StreamingPeekableIter, encode};
@@ -10,8 +11,9 @@ use gix_transport::client::capabilities::async_recv::Handshake;
 use gix_transport::client::capabilities::blocking_recv::Handshake;
 
 #[test]
-fn from_bytes() -> crate::Result {
-    let (caps, delim_pos) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])?;
+fn from_bytes() -> Result {
+    let (caps, delim_pos) = Capabilities::from_bytes(&b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0multi_ack thin-pack side-band side-band-64k ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag multi_ack_detailed symref=HEAD:refs/heads/master object-format=sha1 agent=git/2.28.0"[..])
+        ?;
     assert_eq!(delim_pos, 45);
     assert_eq!(
         caps.iter().map(|c| c.name().to_owned()).collect::<Vec<_>>(),
@@ -59,7 +61,7 @@ fn from_bytes() -> crate::Result {
 }
 
 #[test]
-fn from_bytes_with_sha256_object_format() -> crate::Result {
+fn from_bytes_with_sha256_object_format() -> Result {
     let (caps, _delim_pos) = Capabilities::from_bytes(
         &b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0side-band-64k object-format=sha256 agent=git/2.40.0"[..],
     )?;
@@ -78,7 +80,7 @@ fn from_bytes_with_sha256_object_format() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn from_lines_with_version_detection_v0() -> crate::Result {
+async fn from_lines_with_version_detection_v0() -> Result {
     let mut buf = Vec::<u8>::new();
     encode::flush_to_write(&mut buf).await?;
     let mut stream = StreamingPeekableIter::new(buf.as_slice(), &[gix_packetline::PacketLineRef::Flush], false);
diff --git a/gix-transport/tests/client/git.rs b/gix-transport/tests/client/git.rs
index 3539dd1f72d..0491ead3788 100644
--- a/gix-transport/tests/client/git.rs
+++ b/gix-transport/tests/client/git.rs
@@ -1,6 +1,7 @@
+use crate::Result;
 #[cfg(feature = "blocking-client")]
 use std::io::{BufRead, Write};
-use std::{error::Error, ops::Deref, sync::Arc};
+use std::{ops::Deref, sync::Arc};
 
 use bstr::ByteSlice;
 #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
@@ -23,10 +24,56 @@ use parking_lot::Mutex;
 
 use crate::fixture_bytes;
 
+#[cfg(any(feature = "blocking-client", feature = "async-std"))]
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn handshake_v1_and_request() -> crate::Result {
+async fn refused_connections_remain_retryable() -> Result {
+    #[cfg(all(feature = "async-client", not(feature = "blocking-client")))]
+    use client::async_io::connect::connect;
+    #[cfg(feature = "blocking-client")]
+    use client::blocking_io::connect::connect;
+
+    let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
+    let port = listener.local_addr()?.port();
+    drop(listener);
+    let url = format!("git://127.0.0.1:{port}/repo.git");
+    let err = connect(url.as_str(), Default::default())
+        .await
+        .err()
+        .expect("the local port has no listener");
+    if cfg!(feature = "blocking-client") {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&port.to_string(), "<port>")]), "a refused connection retains the endpoint and I/O cause", @"
+        connection failed
+        |
+        └─ Could not connect to git server
+        |
+        └─ ConnectionRefused
+        ");
+    } else {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&port.to_string(), "<port>")]), "a refused connection retains the endpoint and I/O cause", @r#"
+        connection failed
+        |
+        └─ An IO error occurred when talking to the server
+        |
+        └─ ConnectionRefused
+        "#);
+    }
+    assert_eq!(
+        err.downcast_any_ref::<std::io::Error>()
+            .expect("retain the connection failure")
+            .kind(),
+        std::io::ErrorKind::ConnectionRefused,
+        "the test must exercise a refused connection"
+    );
+    assert!(err.can_retry_lenient(), "a refused connection can succeed on retry");
+    Ok(())
+}
+
+#[crate::bisync::bisync]
+#[cfg_attr(feature = "blocking-client", test)]
+#[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
+async fn handshake_v1_and_request() -> Result {
     let mut out = Vec::new();
     let server_response = fixture_bytes("v1/clone.response");
     let c = Connection::new(
@@ -156,28 +203,23 @@ async fn handshake_v1_and_request() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn git_daemon_request_rejects_nul_and_lf() -> crate::Result {
+async fn git_daemon_request_rejects_nul_and_lf() -> Result {
+    let mut error_snapshots = Vec::new();
     for (control, name) in [(b'\0', "NUL"), (b'\n', "newline")] {
         let mut invalid_path = b"/foo.git".to_vec();
         invalid_path.push(control);
         let mut invalid_host = b"example.org".to_vec();
         invalid_host.push(control);
-        let cases: [(bstr::BString, String, &str, &str); 2] = [
-            (
-                invalid_path.into(),
-                "example.org".into(),
-                "path",
-                "git daemon repository paths must not contain NUL or LF",
-            ),
+        let cases: [(bstr::BString, String, &str); 2] = [
+            (invalid_path.into(), "example.org".into(), "path"),
             (
                 "/foo.git".into(),
                 String::from_utf8(invalid_host).expect("the test host remains UTF-8"),
                 "host",
-                "git daemon virtual hosts must not contain NUL or LF",
             ),
         ];
 
-        for (path, host, component, expected_error) in cases {
+        for (path, host, component) in cases {
             let mut out = Vec::new();
             let server_response = fixture_bytes("v1/clone.response");
             let mut connection = Connection::new(
@@ -194,22 +236,65 @@ async fn git_daemon_request_rejects_nul_and_lf() -> crate::Result {
                 .await
                 .err()
                 .expect("an invalid request must fail");
-            assert_eq!(
-                error.source().expect("the validation error is preserved").to_string(),
-                expected_error,
-                "a {name} in the {component} must prevent the request"
-            );
+            error_snapshots.push((name, component, gix_testtools::redact_debug_snapshot(&error, &[])));
             drop(connection);
-            assert!(out.is_empty(), "an invalid request must not be written");
+            assert!(
+                out.is_empty(),
+                "a {component} containing {name} is rejected before writing"
+            );
         }
     }
+    insta::assert_debug_snapshot!(error_snapshots, "git daemon request rejects nul and lf", @r#"
+    [
+        (
+            "NUL",
+            "path",
+            Io(
+                Custom {
+                    kind: InvalidInput,
+                    error: "git daemon repository paths must not contain NUL or LF",
+                },
+            ),
+        ),
+        (
+            "NUL",
+            "host",
+            Io(
+                Custom {
+                    kind: InvalidInput,
+                    error: "git daemon virtual hosts must not contain NUL or LF",
+                },
+            ),
+        ),
+        (
+            "newline",
+            "path",
+            Io(
+                Custom {
+                    kind: InvalidInput,
+                    error: "git daemon repository paths must not contain NUL or LF",
+                },
+            ),
+        ),
+        (
+            "newline",
+            "host",
+            Io(
+                Custom {
+                    kind: InvalidInput,
+                    error: "git daemon virtual hosts must not contain NUL or LF",
+                },
+            ),
+        ),
+    ]
+    "#);
     Ok(())
 }
 
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn push_v1_simulated() -> crate::Result {
+async fn push_v1_simulated() -> Result {
     let mut out = Vec::new();
     let server_response = fixture_bytes("v1/push.response");
     let mut c = Connection::new(
@@ -277,7 +362,7 @@ async fn push_v1_simulated() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn handshake_v1_process_mode() -> crate::Result {
+async fn handshake_v1_process_mode() -> Result {
     let mut out = Vec::new();
     let server_response = fixture_bytes("v1/clone.response");
     let mut c = Connection::new(
@@ -302,7 +387,7 @@ async fn handshake_v1_process_mode() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn handshake_v2_downgrade_to_v1() -> crate::Result {
+async fn handshake_v2_downgrade_to_v1() -> Result {
     let mut out = Vec::new();
     let input = fixture_bytes("v1/clone.response");
     let mut c = Connection::new(
@@ -333,14 +418,14 @@ async fn handshake_v2_downgrade_to_v1() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn handshake_v2_and_request() -> crate::Result {
+async fn handshake_v2_and_request() -> Result {
     #[crate::bisync::only_sync]
-    fn run() -> crate::Result {
+    fn run() -> Result {
         handshake_v2_and_request_inner()
     }
 
     #[crate::bisync::only_async]
-    async fn run() -> crate::Result {
+    async fn run() -> Result {
         // This simulates processing a pack received with async I/O as blocking `BufRead` without blocking the executor.
         blocking::unblock(|| futures_lite::future::block_on(handshake_v2_and_request_inner()).expect("no failure"))
             .await;
@@ -351,7 +436,7 @@ async fn handshake_v2_and_request() -> crate::Result {
 }
 
 #[crate::bisync::bisync]
-async fn handshake_v2_and_request_inner() -> crate::Result {
+async fn handshake_v2_and_request_inner() -> Result {
     let mut out = Vec::new();
     let input = fixture_bytes("v2/clone.response");
     let mut c = Connection::new(
@@ -511,7 +596,7 @@ async fn handshake_v2_and_request_inner() -> crate::Result {
 #[crate::bisync::bisync]
 #[cfg_attr(feature = "blocking-client", test)]
 #[cfg_attr(all(feature = "async-client", not(feature = "blocking-client")), async_std::test)]
-async fn handshake_v2_with_sha256_object_format() -> crate::Result {
+async fn handshake_v2_with_sha256_object_format() -> Result {
     let mut out = Vec::new();
     let input = fixture_bytes("v2/handshake-sha256.response");
     let mut c = Connection::new(
diff --git a/gix-traverse/Cargo.toml b/gix-traverse/Cargo.toml
index f42a4bc49fd..8b5c37a5016 100644
--- a/gix-traverse/Cargo.toml
+++ b/gix-traverse/Cargo.toml
@@ -22,13 +22,13 @@ sha256 = ["gix-hash/sha256"]
 
 [dependencies]
 gix-hash = { version = "^0.26.1", path = "../gix-hash" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-object = { version = "^0.64.0", path = "../gix-object" }
 gix-date = { version = "^0.16.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.16.0", path = "../gix-hashtable" }
 gix-revwalk = { version = "^0.35.0", path = "../gix-revwalk" }
 gix-commitgraph = { version = "^0.39.0", path = "../gix-commitgraph" }
 smallvec = "1.15.1"
-thiserror = "2.0.18"
 bitflags = "2"
 
 [dev-dependencies]
diff --git a/gix-traverse/src/commit/mod.rs b/gix-traverse/src/commit/mod.rs
index 7ffd65fe48f..9d6652ce9df 100644
--- a/gix-traverse/src/commit/mod.rs
+++ b/gix-traverse/src/commit/mod.rs
@@ -1,6 +1,8 @@
 //! Provide multiple traversal implementations with different performance envelopes.
 //!
 //! Use [`Simple`] for fast walks that maintain minimal state, or [`Topo`] for a more elaborate traversal.
+use gix_error::ExnMessageResult;
+use gix_error::ExnResult;
 use gix_hash::ObjectId;
 use gix_object::FindExt;
 use gix_revwalk::{PriorityQueue, graph::IdMap};
@@ -81,7 +83,7 @@ pub enum Either<'buf, 'cache> {
 impl Either<'_, '_> {
     /// Get a commit’s `tree_id` by either getting it from a [`gix_commitgraph::Graph`], if
     /// present, or a [`gix_object::CommitRefIter`] otherwise.
-    pub fn tree_id(self) -> Result<ObjectId, gix_object::decode::Error> {
+    pub fn tree_id(self) -> ExnMessageResult<ObjectId> {
         match self {
             Self::CommitRefIter(mut commit_ref_iter) => commit_ref_iter.tree_id(),
             Self::CachedCommit(commit) => Ok(commit.root_tree_id().into()),
@@ -90,7 +92,7 @@ impl Either<'_, '_> {
 
     /// Get a committer timestamp by either getting it from a [`gix_commitgraph::Graph`], if
     /// present, or a [`gix_object::CommitRefIter`] otherwise.
-    pub fn commit_time(self) -> Result<gix_date::SecondsSinceUnixEpoch, gix_object::decode::Error> {
+    pub fn commit_time(self) -> ExnMessageResult<gix_date::SecondsSinceUnixEpoch> {
         match self {
             Self::CommitRefIter(commit_ref_iter) => commit_ref_iter.committer().map(|c| c.seconds()),
             Self::CachedCommit(commit) => Ok(commit.committer_timestamp() as gix_date::SecondsSinceUnixEpoch),
@@ -105,7 +107,7 @@ pub fn find<'cache, 'buf, Find>(
     objects: Find,
     id: &gix_hash::oid,
     buf: &'buf mut Vec<u8>,
-) -> Result<Either<'buf, 'cache>, gix_object::find::existing_iter::Error>
+) -> ExnResult<Either<'buf, 'cache>>
 where
     Find: gix_object::Find,
 {
diff --git a/gix-traverse/src/commit/simple.rs b/gix-traverse/src/commit/simple.rs
index e4997d600ee..2764f24a1da 100644
--- a/gix-traverse/src/commit/simple.rs
+++ b/gix-traverse/src/commit/simple.rs
@@ -3,6 +3,8 @@ use std::{
     collections::VecDeque,
 };
 
+use gix_error::ExnResult;
+
 use gix_date::SecondsSinceUnixEpoch;
 use gix_hash::ObjectId;
 use smallvec::SmallVec;
@@ -68,18 +70,6 @@ pub enum Sorting {
     },
 }
 
-/// The error is part of the item returned by the [Ancestors](super::Simple) iterator.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Find(#[from] gix_object::find::existing_iter::Error),
-    #[error(transparent)]
-    ObjectDecode(#[from] gix_object::decode::Error),
-    #[error(transparent)]
-    HiddenGraph(#[from] gix_revwalk::graph::get_or_insert_default::Error),
-}
-
 use Result as Either;
 
 type QueueKey<T> = Either<T, Reverse<T>>;
@@ -180,7 +170,7 @@ fn compute_hidden_frontier(
     hidden_tips: &[ObjectId],
     objects: &impl gix_object::Find,
     cache: Option<&gix_commitgraph::Graph>,
-) -> Result<gix_revwalk::graph::IdMap<()>, Error> {
+) -> ExnResult<gix_revwalk::graph::IdMap<()>> {
     let mut graph = gix_revwalk::Graph::<gix_revwalk::graph::Commit<PaintFlags>>::new(objects, cache);
     let mut queue = gix_revwalk::PriorityQueue::<GenThenTime, ObjectId>::new();
 
@@ -237,10 +227,12 @@ fn compute_hidden_frontier(
 ///
 mod init {
     use super::{
-        CommitDateQueue, CommitTimeOrder, Error, Sorting, State, collect_parents, compute_hidden_frontier, to_queue_key,
+        CommitDateQueue, CommitTimeOrder, Sorting, State, collect_parents, compute_hidden_frontier, to_queue_key,
     };
     use crate::commit::{Either, Info, ParentIds, Parents, Simple};
     use gix_date::SecondsSinceUnixEpoch;
+    use gix_error::ExnResult;
+    use gix_error::ResultExt;
     use gix_hash::{ObjectId, oid};
     use gix_object::{CommitRefIter, FindExt};
     use std::{cmp::Reverse, collections::VecDeque};
@@ -300,7 +292,7 @@ mod init {
         Find: gix_object::Find,
     {
         /// Set the `sorting` method.
-        pub fn sorting(mut self, sorting: Sorting) -> Result<Self, Error> {
+        pub fn sorting(mut self, sorting: Sorting) -> ExnResult<Self> {
             self.sorting = sorting;
             match self.sorting {
                 Sorting::BreadthFirst => self.queue_to_vecdeque(),
@@ -332,7 +324,7 @@ mod init {
 
         /// Hide the given `tips`, along with all commits reachable by them so that they will not be returned
         /// by the traversal.
-        pub fn hide(mut self, tips: impl IntoIterator<Item = ObjectId>) -> Result<Self, Error> {
+        pub fn hide(mut self, tips: impl IntoIterator<Item = ObjectId>) -> ExnResult<Self> {
             self.state.hidden_tips = tips.into_iter().collect();
             Ok(self)
         }
@@ -368,7 +360,7 @@ mod init {
             out
         }
 
-        fn compute_hidden_frontier(&mut self, hidden_tips: Vec<ObjectId>) -> Result<(), Error> {
+        fn compute_hidden_frontier(&mut self, hidden_tips: Vec<ObjectId>) -> ExnResult {
             self.state.hidden.clear();
             if hidden_tips.is_empty() {
                 return Ok(());
@@ -395,9 +387,12 @@ mod init {
         queue: &mut CommitDateQueue,
         objects: &impl gix_object::Find,
         buf: &mut Vec<u8>,
-    ) -> Result<(), Error> {
+    ) -> ExnResult {
         let commit_iter = objects.find_commit_iter(&commit_id, buf)?;
-        let time = commit_iter.committer()?.seconds();
+        let time = commit_iter
+            .committer()
+            .or_raise_erased(|| gix_error::corruption("A commit could not be decoded during traversal"))?
+            .seconds();
         let key = to_queue_key(time, order);
         match (cutoff_time, order) {
             (Some(cutoff_time), _) if time >= cutoff_time => queue.insert(key, commit_id),
@@ -485,7 +480,7 @@ mod init {
         Find: gix_object::Find,
         Predicate: FnMut(&oid) -> bool,
     {
-        type Item = Result<Info, Error>;
+        type Item = ExnResult<Info>;
 
         fn next(&mut self) -> Option<Self::Item> {
             if !self.state.hidden_tips.is_empty() {
@@ -518,7 +513,7 @@ mod init {
             &mut self,
             order: CommitTimeOrder,
             cutoff: Option<SecondsSinceUnixEpoch>,
-        ) -> Option<Result<Info, Error>> {
+        ) -> Option<ExnResult<Info>> {
             let state = &mut self.state;
             let next = &mut state.queue;
 
@@ -582,11 +577,15 @@ mod init {
                                     );
                                 }
                                 Ok(_unused_token) => break,
-                                Err(err) => return Some(Err(err.into())),
+                                Err(err) => {
+                                    return Some(Err(err
+                                        .raise(gix_error::corruption("A commit could not be decoded during traversal"))
+                                        .erased()));
+                                }
                             }
                         }
                     }
-                    Err(err) => return Some(Err(err.into())),
+                    Err(err) => return Some(Err(err)),
                 }
 
                 return Some(Ok(Info {
@@ -598,7 +597,7 @@ mod init {
             }
         }
 
-        fn next_by_topology(&mut self) -> Option<Result<Info, Error>> {
+        fn next_by_topology(&mut self) -> Option<ExnResult<Info>> {
             let state = &mut self.state;
             let next = &mut state.next;
 
@@ -647,11 +646,15 @@ mod init {
                                     }
                                 }
                                 Ok(_a_token_past_the_parents) => break,
-                                Err(err) => return Some(Err(err.into())),
+                                Err(err) => {
+                                    return Some(Err(err
+                                        .raise(gix_error::corruption("A commit could not be decoded during traversal"))
+                                        .erased()));
+                                }
                             }
                         }
                     }
-                    Err(err) => return Some(Err(err.into())),
+                    Err(err) => return Some(Err(err)),
                 }
 
                 return Some(Ok(Info {
diff --git a/gix-traverse/src/commit/topo/init.rs b/gix-traverse/src/commit/topo/init.rs
index 4da731b1726..8f9daf82206 100644
--- a/gix-traverse/src/commit/topo/init.rs
+++ b/gix-traverse/src/commit/topo/init.rs
@@ -1,11 +1,12 @@
 use std::collections::HashSet;
 
+use gix_error::{ExnResult, OptionExt};
 use gix_hash::{ObjectId, oid};
 use gix_revwalk::{PriorityQueue, graph::IdMap};
 
 use crate::commit::{
     Info, Parents, Topo, find,
-    topo::{Error, Sorting, WalkFlags, iter::gen_and_commit_time},
+    topo::{Sorting, WalkFlags, iter::gen_and_commit_time},
 };
 
 /// Builder for [`Topo`].
@@ -118,7 +119,7 @@ where
     /// Build a new [`Topo`] instance.
     ///
     /// Note that merely building an instance is currently expensive.
-    pub fn build(self) -> Result<Topo<Find, Predicate>, Error> {
+    pub fn build(self) -> ExnResult<Topo<Find, Predicate>> {
         let mut w = Topo {
             commit_graph: self.commit_graph,
             find: self.find,
@@ -176,7 +177,10 @@ where
         // the tips, but then in simplify_commit() Git is told to ignore it. For
         // now the tests pass.
         for id in self.tips.iter() {
-            let i = w.indegrees.get(id).ok_or(Error::MissingIndegreeUnexpected)?;
+            let i = w
+                .indegrees
+                .get(id)
+                .ok_or_raise_erased(|| gix_error::corruption("Indegree information is missing"))?;
 
             if *i != 1 {
                 continue;
diff --git a/gix-traverse/src/commit/topo/iter.rs b/gix-traverse/src/commit/topo/iter.rs
index 8af085ea409..779ee8a0493 100644
--- a/gix-traverse/src/commit/topo/iter.rs
+++ b/gix-traverse/src/commit/topo/iter.rs
@@ -1,14 +1,24 @@
+use gix_error::ErrorExt;
+use gix_error::ExnResult;
 use gix_hash::{ObjectId, oid};
 use gix_revwalk::PriorityQueue;
 use smallvec::SmallVec;
 
 use crate::commit::{
     Either, Info, Parents, Topo, find,
-    topo::{Error, Sorting, WalkFlags},
+    topo::{Sorting, WalkFlags},
 };
 
 pub(in crate::commit) type GenAndCommitTime = (u32, i64);
 
+fn missing_indegree() -> gix_error::Exn {
+    gix_error::corruption("Indegree information is missing").raise_erased()
+}
+
+fn missing_state() -> gix_error::Exn {
+    gix_error::corruption("Internal state (bitflags) not found").raise_erased()
+}
+
 // Git's priority queue works as a LIFO stack if no compare function is set,
 // which is the case for `--topo-order.` However, even in that case the initial
 // items of the queue are sorted according to the commit time before beginning
@@ -52,7 +62,7 @@ impl<Find, Predicate> Topo<Find, Predicate>
 where
     Find: gix_object::Find,
 {
-    pub(super) fn compute_indegrees_to_depth(&mut self, gen_cutoff: u32) -> Result<(), Error> {
+    pub(super) fn compute_indegrees_to_depth(&mut self, gen_cutoff: u32) -> ExnResult {
         while let Some(((generation, _), _)) = self.indegree_queue.peek() {
             if *generation >= gen_cutoff {
                 self.indegree_walk_step()?;
@@ -64,7 +74,7 @@ where
         Ok(())
     }
 
-    fn indegree_walk_step(&mut self) -> Result<(), Error> {
+    fn indegree_walk_step(&mut self) -> ExnResult {
         if let Some(((generation, _), id)) = self.indegree_queue.pop() {
             self.explore_to_depth(generation)?;
 
@@ -72,7 +82,7 @@ where
             for (id, gen_time) in parents {
                 self.indegrees.entry(id).and_modify(|e| *e += 1).or_insert(2);
 
-                let state = self.states.get_mut(&id).ok_or(Error::MissingStateUnexpected)?;
+                let state = self.states.get_mut(&id).ok_or_else(missing_state)?;
                 if !state.contains(WalkFlags::InDegree) {
                     *state |= WalkFlags::InDegree;
                     self.indegree_queue.insert(gen_time, id);
@@ -82,7 +92,7 @@ where
         Ok(())
     }
 
-    fn explore_to_depth(&mut self, gen_cutoff: u32) -> Result<(), Error> {
+    fn explore_to_depth(&mut self, gen_cutoff: u32) -> ExnResult {
         while let Some(((generation, _), _)) = self.explore_queue.peek() {
             if *generation >= gen_cutoff {
                 self.explore_walk_step()?;
@@ -93,13 +103,13 @@ where
         Ok(())
     }
 
-    fn explore_walk_step(&mut self) -> Result<(), Error> {
+    fn explore_walk_step(&mut self) -> ExnResult {
         if let Some((_, id)) = self.explore_queue.pop() {
             let parents = self.collect_parents(&id)?;
             self.process_parents(&id, &parents)?;
 
             for (id, gen_time) in parents {
-                let state = self.states.get_mut(&id).ok_or(Error::MissingStateUnexpected)?;
+                let state = self.states.get_mut(&id).ok_or_else(missing_state)?;
 
                 if !state.contains(WalkFlags::Explored) {
                     *state |= WalkFlags::Explored;
@@ -110,12 +120,12 @@ where
         Ok(())
     }
 
-    fn expand_topo_walk(&mut self, id: &oid) -> Result<(), Error> {
+    fn expand_topo_walk(&mut self, id: &oid) -> ExnResult {
         let parents = self.collect_parents(id)?;
         self.process_parents(id, &parents)?;
 
         for (pid, (parent_gen, parent_commit_time)) in parents {
-            let parent_state = self.states.get(&pid).ok_or(Error::MissingStateUnexpected)?;
+            let parent_state = self.states.get(&pid).ok_or_else(missing_state)?;
             if parent_state.contains(WalkFlags::Uninteresting) {
                 continue;
             }
@@ -125,7 +135,7 @@ where
                 self.compute_indegrees_to_depth(self.min_gen)?;
             }
 
-            let i = self.indegrees.get_mut(&pid).ok_or(Error::MissingIndegreeUnexpected)?;
+            let i = self.indegrees.get_mut(&pid).ok_or_else(missing_indegree)?;
             *i -= 1;
             if *i != 1 {
                 continue;
@@ -146,8 +156,8 @@ where
         Ok(())
     }
 
-    fn process_parents(&mut self, id: &oid, parents: &[(ObjectId, GenAndCommitTime)]) -> Result<(), Error> {
-        let state = self.states.get_mut(id).ok_or(Error::MissingStateUnexpected)?;
+    fn process_parents(&mut self, id: &oid, parents: &[(ObjectId, GenAndCommitTime)]) -> ExnResult {
+        let state = self.states.get_mut(id).ok_or_else(missing_state)?;
         if state.contains(WalkFlags::Added) {
             return Ok(());
         }
@@ -182,7 +192,7 @@ where
         Ok(())
     }
 
-    fn collect_parents(&mut self, id: &oid) -> Result<SmallVec<[(ObjectId, GenAndCommitTime); 1]>, Error> {
+    fn collect_parents(&mut self, id: &oid) -> ExnResult<SmallVec<[(ObjectId, GenAndCommitTime); 1]>> {
         collect_parents(
             &mut self.commit_graph,
             &self.find,
@@ -193,19 +203,16 @@ where
     }
 
     // Same as collect_parents but disregards the first_parent flag
-    pub(super) fn collect_all_parents(
-        &mut self,
-        id: &oid,
-    ) -> Result<SmallVec<[(ObjectId, GenAndCommitTime); 1]>, Error> {
+    pub(super) fn collect_all_parents(&mut self, id: &oid) -> ExnResult<SmallVec<[(ObjectId, GenAndCommitTime); 1]>> {
         collect_parents(&mut self.commit_graph, &self.find, id, false, &mut self.buf)
     }
 
-    fn pop_commit(&mut self) -> Option<Result<Info, Error>> {
+    fn pop_commit(&mut self) -> Option<ExnResult<Info>> {
         let commit = self.topo_queue.pop()?;
         let i = match self.indegrees.get_mut(&commit.id) {
             Some(i) => i,
             None => {
-                return Some(Err(Error::MissingIndegreeUnexpected));
+                return Some(Err(missing_indegree()));
             }
         };
 
@@ -223,7 +230,7 @@ where
     Find: gix_object::Find,
     Predicate: FnMut(&oid) -> bool,
 {
-    type Item = Result<Info, Error>;
+    type Item = ExnResult<Info>;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -245,7 +252,7 @@ fn collect_parents<Find>(
     id: &oid,
     first_only: bool,
     buf: &mut Vec<u8>,
-) -> Result<SmallVec<[(ObjectId, GenAndCommitTime); 1]>, Error>
+) -> ExnResult<SmallVec<[(ObjectId, GenAndCommitTime); 1]>>
 where
     Find: gix_object::Find,
 {
@@ -263,7 +270,11 @@ where
                         }
                     }
                     Ok(_past_parents) => break,
-                    Err(err) => return Err(err.into()),
+                    Err(err) => {
+                        return Err(err
+                            .raise(gix_error::corruption("A commit could not be decoded during traversal"))
+                            .erased());
+                    }
                 }
             }
             // Need to check the cache again. That a commit is not in the cache
@@ -297,7 +308,7 @@ where
     Ok(parents)
 }
 
-pub(super) fn gen_and_commit_time(c: Either<'_, '_>) -> Result<GenAndCommitTime, Error> {
+pub(super) fn gen_and_commit_time(c: Either<'_, '_>) -> ExnResult<GenAndCommitTime> {
     match c {
         Either::CommitRefIter(c) => {
             let mut commit_time = 0;
@@ -312,7 +323,11 @@ pub(super) fn gen_and_commit_time(c: Either<'_, '_>) -> Result<GenAndCommitTime,
                         break;
                     }
                     Ok(_unused_token) => break,
-                    Err(err) => return Err(err.into()),
+                    Err(err) => {
+                        return Err(err
+                            .raise(gix_error::corruption("A commit could not be decoded during traversal"))
+                            .erased());
+                    }
                 }
             }
             Ok((gix_commitgraph::GENERATION_NUMBER_INFINITY, commit_time))
diff --git a/gix-traverse/src/commit/topo/mod.rs b/gix-traverse/src/commit/topo/mod.rs
index fbe9812620e..6e05ba52637 100644
--- a/gix-traverse/src/commit/topo/mod.rs
+++ b/gix-traverse/src/commit/topo/mod.rs
@@ -2,20 +2,6 @@
 
 use bitflags::bitflags;
 
-/// The errors that can occur during creation and iteration.
-#[derive(thiserror::Error, Debug)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Indegree information is missing")]
-    MissingIndegreeUnexpected,
-    #[error("Internal state (bitflags) not found")]
-    MissingStateUnexpected,
-    #[error(transparent)]
-    ObjectDecode(#[from] gix_object::decode::Error),
-    #[error(transparent)]
-    Find(#[from] gix_object::find::existing_iter::Error),
-}
-
 bitflags! {
     /// Set of flags to describe the state of a particular commit while iterating.
     // NOTE: The names correspond to the names of the flags in revision.h
diff --git a/gix-traverse/src/tree/breadthfirst.rs b/gix-traverse/src/tree/breadthfirst.rs
index 36ae5afaa87..19442c1ac75 100644
--- a/gix-traverse/src/tree/breadthfirst.rs
+++ b/gix-traverse/src/tree/breadthfirst.rs
@@ -2,19 +2,6 @@ use std::collections::VecDeque;
 
 use gix_hash::ObjectId;
 
-/// The error is part of the item returned by the [`breadthfirst()`](crate::tree::breadthfirst())  and
-///[`depthfirst()`](crate::tree::depthfirst()) functions.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Find(#[from] gix_object::find::existing_iter::Error),
-    #[error("The delegate cancelled the operation")]
-    Cancelled,
-    #[error(transparent)]
-    ObjectDecode(#[from] gix_object::decode::Error),
-}
-
 /// The state used and potentially shared by multiple tree traversals.
 #[derive(Default, Clone)]
 pub struct State {
@@ -32,9 +19,10 @@ impl State {
 pub(super) mod function {
     use std::borrow::BorrowMut;
 
+    use gix_error::{ErrorExt, ExnResult, ResultExt, message};
     use gix_object::{FindExt, TreeRefIter};
 
-    use super::{Error, State};
+    use super::State;
     use crate::tree::Visit;
 
     /// Start a breadth-first iteration over the `root` trees entries.
@@ -48,15 +36,15 @@ pub(super) mod function {
     /// * `find` - a way to lookup new object data during traversal by their `ObjectId`, writing their data into buffer and returning
     ///   an iterator over entries if the object is present and is a tree. Caching should be implemented within this function
     ///   as needed. The return value is `Option<TreeIter>` which degenerates all error information. Not finding a commit should also
-    ///   be considered an errors as all objects in the tree DAG should be present in the database. Hence [`Error::Find`] should
-    ///   be escalated into a more specific error if it's encountered by the caller.
+    ///   be considered an error as all objects in the tree DAG should be present in the database. Hence lookup errors should
+    ///   be escalated into a more specific error if encountered by the caller.
     /// * `delegate` - A way to observe entries and control the iteration while allowing the optimizer to let you pay only for what you use.
     pub fn breadthfirst<StateMut, Find, V>(
         root: TreeRefIter<'_>,
         mut state: StateMut,
         objects: Find,
         delegate: &mut V,
-    ) -> Result<(), Error>
+    ) -> ExnResult
     where
         Find: gix_object::Find,
         StateMut: BorrowMut<State>,
@@ -67,7 +55,8 @@ pub(super) mod function {
         let mut tree = root;
         loop {
             for entry in tree {
-                let entry = entry?;
+                let entry =
+                    entry.or_raise_erased(|| gix_error::corruption("A tree could not be decoded during traversal"))?;
                 if entry.mode.is_tree() {
                     delegate.push_path_component(entry.filename);
                     let action = delegate.visit_tree(&entry);
@@ -79,13 +68,13 @@ pub(super) mod function {
                             state.next.push_back(entry.oid.to_owned());
                         }
                         std::ops::ControlFlow::Break(()) => {
-                            return Err(Error::Cancelled);
+                            return Err(message("The delegate cancelled the operation").raise_erased());
                         }
                     }
                 } else {
                     delegate.push_path_component(entry.filename);
                     if delegate.visit_nontree(&entry).is_break() {
-                        return Err(Error::Cancelled);
+                        return Err(message("The delegate cancelled the operation").raise_erased());
                     }
                 }
                 delegate.pop_path_component();
diff --git a/gix-traverse/src/tree/depthfirst.rs b/gix-traverse/src/tree/depthfirst.rs
index 7c34f5d71ed..9bf76798f1c 100644
--- a/gix-traverse/src/tree/depthfirst.rs
+++ b/gix-traverse/src/tree/depthfirst.rs
@@ -1,5 +1,3 @@
-pub use super::breadthfirst::Error;
-
 /// The state used and potentially shared by multiple tree traversals, reusing memory.
 #[derive(Default, Clone)]
 pub struct State {
@@ -27,10 +25,11 @@ impl State {
 pub(super) mod function {
     use std::borrow::BorrowMut;
 
+    use gix_error::{ExnResult, ResultExt};
     use gix_hash::ObjectId;
     use gix_object::{FindExt, TreeRefIter};
 
-    use super::{Error, State};
+    use super::State;
     use crate::tree::Visit;
 
     /// A depth-first traversal of the `root` tree, that preserves the natural order of a tree while immediately descending
@@ -42,7 +41,7 @@ pub(super) mod function {
         mut state: StateMut,
         objects: Find,
         delegate: &mut V,
-    ) -> Result<(), Error>
+    ) -> ExnResult
     where
         Find: gix_object::Find,
         StateMut: BorrowMut<State>,
@@ -75,7 +74,9 @@ pub(super) mod function {
                     let mut iter = TreeRefIter::from_bytes(&buf[byte_offset_to_next_entry..], root.kind());
                     delegate.pop_back_tracked_path_and_set_current();
                     while let Some(entry) = iter.next() {
-                        let entry = entry?;
+                        let entry = entry.or_raise_erased(|| {
+                            gix_error::corruption("A tree could not be decoded during traversal")
+                        })?;
                         if entry.mode.is_tree() {
                             delegate.push_path_component(entry.filename);
                             let res = delegate.visit_tree(&entry);
diff --git a/gix-traverse/tests/traverse/commit/simple/adjusted_dates.rs b/gix-traverse/tests/traverse/commit/simple/adjusted_dates.rs
index cd7cf1349e2..a7a005bd379 100644
--- a/gix-traverse/tests/traverse/commit/simple/adjusted_dates.rs
+++ b/gix-traverse/tests/traverse/commit/simple/adjusted_dates.rs
@@ -1,16 +1,17 @@
 //! Some dates adjusted to be a year apart, but still 'c1' and 'c2' with the same date.
 use super::*;
+use crate::Result;
 use crate::util::{fixture, odb_at};
 use gix_traverse::commit::simple::CommitTimeOrder;
 
-fn adjusted_dates_repo() -> crate::Result<(std::path::PathBuf, gix_odb::Handle)> {
+fn adjusted_dates_repo() -> Result<(std::path::PathBuf, gix_odb::Handle)> {
     let dir = fixture("make_traversal_repo_for_commits_with_dates.sh")?;
     let odb = odb_at(dir.join(".git").join("objects"))?;
     Ok((dir, odb))
 }
 
 #[test]
-fn head_breadth_first() -> crate::Result {
+fn head_breadth_first() -> Result {
     let (repo_dir, odb) = adjusted_dates_repo()?;
 
     // Timestamps show b1c1 (978393600) is a year newer than c2 (946771200),
@@ -41,7 +42,7 @@ fn head_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_date_order() -> crate::Result {
+fn head_date_order() -> Result {
     let (_repo_dir, odb) = adjusted_dates_repo()?;
     // Graph with timestamps shown in `head_breadth_first`
     let tip = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170"); // m1b1
@@ -82,7 +83,7 @@ fn head_date_order() -> crate::Result {
 }
 
 #[test]
-fn head_date_order_with_cutoff() -> crate::Result {
+fn head_date_order_with_cutoff() -> Result {
     let (_repo_dir, odb) = adjusted_dates_repo()?;
     // Graph shown in `head_breadth_first`
     let tip = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170"); // m1b1
@@ -109,7 +110,7 @@ fn head_date_order_with_cutoff() -> crate::Result {
 }
 
 #[test]
-fn head_date_order_with_cutoff_disabled() -> crate::Result {
+fn head_date_order_with_cutoff_disabled() -> Result {
     let (_repo_dir, odb) = adjusted_dates_repo()?;
     // Graph shown in `head_breadth_first`
     let tip = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170"); // m1b1
@@ -157,7 +158,7 @@ fn head_date_order_with_cutoff_disabled() -> crate::Result {
 }
 
 #[test]
-fn date_order_with_cutoff_is_applied_to_starting_position() -> crate::Result {
+fn date_order_with_cutoff_is_applied_to_starting_position() -> Result {
     let (_repo_dir, odb) = adjusted_dates_repo()?;
     // Graph shown in `head_breadth_first`
     let tip = hex_to_id("9902e3c3e8f0c569b4ab295ddf473e6de763e1e7"); // c2
@@ -180,7 +181,7 @@ fn date_order_with_cutoff_is_applied_to_starting_position() -> crate::Result {
 }
 
 #[test]
-fn head_date_order_first_parent_only() -> crate::Result {
+fn head_date_order_first_parent_only() -> Result {
     let (_repo_dir, odb) = adjusted_dates_repo()?;
     // Graph shown in `head_breadth_first`
     let tip = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170"); // m1b1
diff --git a/gix-traverse/tests/traverse/commit/simple/different_date.rs b/gix-traverse/tests/traverse/commit/simple/different_date.rs
index 3a47ec22a01..801baed6d61 100644
--- a/gix-traverse/tests/traverse/commit/simple/different_date.rs
+++ b/gix-traverse/tests/traverse/commit/simple/different_date.rs
@@ -1,12 +1,13 @@
 use super::*;
+use crate::Result;
 use gix_traverse::commit::simple::CommitTimeOrder;
 
-fn simple_repo() -> crate::Result<(std::path::PathBuf, gix_odb::Handle)> {
+fn simple_repo() -> Result<(std::path::PathBuf, gix_odb::Handle)> {
     named_fixture("make_repos.sh", "simple")
 }
 
 #[test]
-fn head_breadth_first() -> crate::Result {
+fn head_breadth_first() -> Result {
     let (repo_dir, odb) = simple_repo()?;
 
     // Timestamps show branch1 commits are newer than branch2, with c5 being the newest.
@@ -49,7 +50,7 @@ fn head_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_date_order() -> crate::Result {
+fn head_date_order() -> Result {
     let (_repo_dir, odb) = simple_repo()?;
     // Graph with timestamps shown in `head_breadth_first`
     let tip = hex_to_id("f49838d84281c3988eeadd988d97dd358c9f9dc4"); // merge
diff --git a/gix-traverse/tests/traverse/commit/simple/different_date_intermixed.rs b/gix-traverse/tests/traverse/commit/simple/different_date_intermixed.rs
index 0f9f96998d2..f81cb126aa0 100644
--- a/gix-traverse/tests/traverse/commit/simple/different_date_intermixed.rs
+++ b/gix-traverse/tests/traverse/commit/simple/different_date_intermixed.rs
@@ -1,12 +1,13 @@
 use super::*;
+use crate::Result;
 use gix_traverse::commit::simple::CommitTimeOrder;
 
-fn intermixed_repo() -> crate::Result<(std::path::PathBuf, gix_odb::Handle)> {
+fn intermixed_repo() -> Result<(std::path::PathBuf, gix_odb::Handle)> {
     named_fixture("make_repos.sh", "intermixed")
 }
 
 #[test]
-fn head_breadth_first() -> crate::Result {
+fn head_breadth_first() -> Result {
     let (repo_dir, odb) = intermixed_repo()?;
 
     // Timestamps show the intermixed ordering: b1 and b2 commits are interleaved
@@ -46,7 +47,7 @@ fn head_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_date_order() -> crate::Result {
+fn head_date_order() -> Result {
     let (_repo_dir, odb) = intermixed_repo()?;
     // Graph with timestamps shown in `head_breadth_first`
     let tip = hex_to_id("58912d92944087dcb09dca79cdd2a937cc158bed"); // merge
diff --git a/gix-traverse/tests/traverse/commit/simple/hide.rs b/gix-traverse/tests/traverse/commit/simple/hide.rs
index 1e426ab8709..6446f1b784d 100644
--- a/gix-traverse/tests/traverse/commit/simple/hide.rs
+++ b/gix-traverse/tests/traverse/commit/simple/hide.rs
@@ -1,8 +1,10 @@
 use super::*;
+use crate::Result;
 use crate::util::{commit_graph, fixture, git_rev_list, odb_at};
+use gix_error::ExnResult;
 use std::{cell::Cell, rc::Rc};
 
-fn assert_simple_repo_graph(repo_dir: &std::path::Path) -> crate::Result {
+fn assert_simple_repo_graph(repo_dir: &std::path::Path) -> Result {
     let graph = git_graph(repo_dir)?;
 
     insta::allow_duplicates! {
@@ -27,7 +29,7 @@ fn assert_simple_repo_graph(repo_dir: &std::path::Path) -> crate::Result {
 }
 
 #[test]
-fn disjoint_hidden_and_interesting() -> crate::Result {
+fn disjoint_hidden_and_interesting() -> Result {
     let (repo_dir, odb) = named_fixture("make_repos.sh", "disjoint_branches")?;
 
     insta::assert_snapshot!(git_graph(&repo_dir)?, @r"
@@ -55,7 +57,7 @@ fn disjoint_hidden_and_interesting() -> crate::Result {
 }
 
 #[test]
-fn all_hidden() -> crate::Result {
+fn all_hidden() -> Result {
     let (_repo_dir, odb) = named_fixture("make_repos.sh", "disjoint_branches")?;
     let tips = [
         hex_to_id("e07cf1277ff7c43090f1acfc85a46039e7de1272"), // b3
@@ -72,7 +74,7 @@ fn all_hidden() -> crate::Result {
 }
 
 #[test]
-fn some_hidden_and_all_hidden() -> crate::Result {
+fn some_hidden_and_all_hidden() -> Result {
     let (repo_dir, odb) = named_fixture("make_repos.sh", "simple")?;
 
     assert_simple_repo_graph(&repo_dir)?;
@@ -115,7 +117,7 @@ fn some_hidden_and_all_hidden() -> crate::Result {
     Ok(())
 }
 
-fn hidden_bug_repo(name: &str) -> crate::Result<(std::path::PathBuf, gix_odb::Handle)> {
+fn hidden_bug_repo(name: &str) -> Result<(std::path::PathBuf, gix_odb::Handle)> {
     let dir = fixture("make_repo_for_hidden_bug.sh")?;
     let repo_path = dir.join(name);
     let odb = odb_at(repo_path.join(".git").join("objects"))?;
@@ -123,7 +125,7 @@ fn hidden_bug_repo(name: &str) -> crate::Result<(std::path::PathBuf, gix_odb::Ha
 }
 
 #[test]
-fn hidden_tip_with_longer_path_to_shared_ancestor() -> crate::Result {
+fn hidden_tip_with_longer_path_to_shared_ancestor() -> Result {
     // Graph:
     //   A(tip) --> shared
     //            /
@@ -166,7 +168,7 @@ fn hidden_tip_with_longer_path_to_shared_ancestor() -> crate::Result {
 }
 
 #[test]
-fn interesting_tip_with_longer_path_to_shared_ancestor() -> crate::Result {
+fn interesting_tip_with_longer_path_to_shared_ancestor() -> Result {
     // Graph:
     //   A(tip) --> B --> C --> D(shared)
     //                        /
@@ -208,7 +210,7 @@ fn interesting_tip_with_longer_path_to_shared_ancestor() -> crate::Result {
 }
 
 #[test]
-fn without_commit_graph_still_hides_single_visible_tip_correctly() -> crate::Result {
+fn without_commit_graph_still_hides_single_visible_tip_correctly() -> Result {
     let (repo_dir, odb) = named_fixture("make_repos.sh", "simple")?;
     assert_simple_repo_graph(&repo_dir)?;
     let tip_c2 = hex_to_id("ad33ff2d0c4fc77d56b5fbff6f86f332fe792d83");
@@ -220,14 +222,14 @@ fn without_commit_graph_still_hides_single_visible_tip_correctly() -> crate::Res
         .commit_graph(None)
         .hide([hidden_c5])?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert!(result.is_empty(), "c2 is reachable from hidden c5");
     Ok(())
 }
 
 #[test]
-fn commit_graph_reduces_odb_lookups_when_hidden_tips_cover_visible_tips() -> crate::Result {
+fn commit_graph_reduces_odb_lookups_when_hidden_tips_cover_visible_tips() -> Result {
     let (repo_dir, odb) = named_fixture("make_repos.sh", "simple")?;
     assert_simple_repo_graph(&repo_dir)?;
     let tips = [
@@ -250,7 +252,7 @@ fn commit_graph_reduces_odb_lookups_when_hidden_tips_cover_visible_tips() -> cra
     .commit_graph(None)
     .hide([hidden_c5])?
     .map(|res| res.map(|info| info.id))
-    .collect::<Result<Vec<_>, _>>()?;
+    .collect::<std::result::Result<Vec<_>, _>>()?;
 
     let with_graph: Vec<_> = Simple::new(
         tips,
@@ -264,7 +266,7 @@ fn commit_graph_reduces_odb_lookups_when_hidden_tips_cover_visible_tips() -> cra
     .commit_graph(commit_graph(odb.store_ref()))
     .hide([hidden_c5])?
     .map(|res| res.map(|info| info.id))
-    .collect::<Result<Vec<_>, _>>()?;
+    .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert!(
         without_graph.is_empty(),
@@ -282,7 +284,7 @@ fn commit_graph_reduces_odb_lookups_when_hidden_tips_cover_visible_tips() -> cra
 }
 
 #[test]
-fn hide_and_commit_graph_call_order_do_not_matter() -> crate::Result {
+fn hide_and_commit_graph_call_order_do_not_matter() -> Result {
     let (repo_dir, odb) = named_fixture("make_repos.sh", "simple")?;
     assert_simple_repo_graph(&repo_dir)?;
     let tip_merge = hex_to_id("f49838d84281c3988eeadd988d97dd358c9f9dc4");
@@ -297,7 +299,7 @@ fn hide_and_commit_graph_call_order_do_not_matter() -> crate::Result {
         .hide(hidden_branches)?
         .commit_graph(commit_graph(odb.store_ref()))
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     let graph_then_hide: Vec<_> = Simple::new([tip_merge], &odb)
         .sorting(Sorting::BreadthFirst)?
@@ -305,7 +307,7 @@ fn hide_and_commit_graph_call_order_do_not_matter() -> crate::Result {
         .commit_graph(commit_graph(odb.store_ref()))
         .hide(hidden_branches)?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(hide_then_graph, graph_then_hide);
     Ok(())
@@ -317,11 +319,7 @@ struct CountingFind<'a> {
 }
 
 impl gix_object::Find for CountingFind<'_> {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         self.lookups.set(self.lookups.get() + 1);
         gix_object::Find::try_find(self.inner, id, buffer)
     }
diff --git a/gix-traverse/tests/traverse/commit/simple/mod.rs b/gix-traverse/tests/traverse/commit/simple/mod.rs
index cf974898fe3..f5154e1d790 100644
--- a/gix-traverse/tests/traverse/commit/simple/mod.rs
+++ b/gix-traverse/tests/traverse/commit/simple/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use crate::hex_to_id;
 use crate::util::{commit_graph, git_graph, git_graph_with_time, named_fixture, parse_commit_names};
 use gix_hash::ObjectId;
@@ -16,16 +17,15 @@ fn traverse(
     sorting: Sorting,
     parents: Parents,
     hidden: impl IntoIterator<Item = ObjectId>,
-) -> crate::Result<Vec<ObjectId>> {
+) -> Result<Vec<ObjectId>> {
     let graph = commit_graph(odb.store_ref());
-    Simple::new(tips, odb)
+    Ok(Simple::new(tips, odb)
         .sorting(sorting)?
         .parents(parents)
         .commit_graph(graph)
         .hide(hidden)?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()
-        .map_err(Into::into)
+        .collect::<std::result::Result<Vec<_>, _>>()?)
 }
 
 /// Run a traversal with both commit-graph enabled and disabled to ensure consistency.
@@ -35,7 +35,7 @@ fn traverse_both(
     sorting: Sorting,
     parents: Parents,
     hidden: impl IntoIterator<Item = ObjectId> + Clone,
-) -> crate::Result<Vec<ObjectId>> {
+) -> Result<Vec<ObjectId>> {
     // Without commit graph
     let without_graph: Vec<_> = Simple::new(tips.clone(), odb)
         .sorting(sorting)?
@@ -43,7 +43,7 @@ fn traverse_both(
         .commit_graph(None)
         .hide(hidden.clone())?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     // With commit graph
     let graph = commit_graph(odb.store_ref());
@@ -53,7 +53,7 @@ fn traverse_both(
         .commit_graph(graph)
         .hide(hidden)?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(
         without_graph, with_graph,
diff --git a/gix-traverse/tests/traverse/commit/simple/same_date.rs b/gix-traverse/tests/traverse/commit/simple/same_date.rs
index 05d7182d92f..d20b506f080 100644
--- a/gix-traverse/tests/traverse/commit/simple/same_date.rs
+++ b/gix-traverse/tests/traverse/commit/simple/same_date.rs
@@ -1,17 +1,18 @@
 //! Same dates are somewhat special as they show how sorting-details on priority queues affects ordering
 use super::*;
+use crate::Result;
 use crate::util::{fixture, odb_at};
 use gix_hash::oid;
 use gix_traverse::commit::simple::CommitTimeOrder;
 
-fn same_date_repo() -> crate::Result<(std::path::PathBuf, gix_odb::Handle)> {
+fn same_date_repo() -> Result<(std::path::PathBuf, gix_odb::Handle)> {
     let dir = fixture("make_traversal_repo_for_commits_same_date.sh")?;
     let odb = odb_at(dir.join(".git").join("objects"))?;
     Ok((dir, odb))
 }
 
 #[test]
-fn c4_breadth_first() -> crate::Result {
+fn c4_breadth_first() -> Result {
     let (repo_dir, odb) = same_date_repo()?;
 
     insta::assert_snapshot!(git_graph(&repo_dir)?, @r"
@@ -42,7 +43,7 @@ fn c4_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_breadth_first() -> crate::Result {
+fn head_breadth_first() -> Result {
     let (_repo_dir, odb) = same_date_repo()?;
     // Graph shown in `c4_breadth_first`
     let tip = hex_to_id("01ec18a3ebf2855708ad3c9d244306bc1fae3e9b"); // m1b1
@@ -67,7 +68,7 @@ fn head_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_date_order() -> crate::Result {
+fn head_date_order() -> Result {
     let (_repo_dir, odb) = same_date_repo()?;
     // Graph shown in `c4_breadth_first`
     let tip = hex_to_id("01ec18a3ebf2855708ad3c9d244306bc1fae3e9b"); // m1b1
@@ -105,7 +106,7 @@ fn head_date_order() -> crate::Result {
 }
 
 #[test]
-fn head_first_parent_only_breadth_first() -> crate::Result {
+fn head_first_parent_only_breadth_first() -> Result {
     let (_repo_dir, odb) = same_date_repo()?;
     // Graph shown in `c4_breadth_first`
     let tip = hex_to_id("01ec18a3ebf2855708ad3c9d244306bc1fae3e9b"); // m1b1
@@ -125,7 +126,7 @@ fn head_first_parent_only_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn head_c4_breadth_first() -> crate::Result {
+fn head_c4_breadth_first() -> Result {
     let (_repo_dir, odb) = same_date_repo()?;
     // Graph shown in `c4_breadth_first`
     let tips = [
@@ -150,7 +151,7 @@ fn head_c4_breadth_first() -> crate::Result {
 }
 
 #[test]
-fn filtered_commit_does_not_block_ancestors_reachable_from_another_commit() -> crate::Result {
+fn filtered_commit_does_not_block_ancestors_reachable_from_another_commit() -> Result {
     // I don't see a use case for the predicate returning false for a commit but return true for
     // at least one of its ancestors, so this test is kind of dubious. But we do want
     // `Ancestors` to not eagerly blacklist all of a commit's ancestors when blacklisting that
@@ -177,14 +178,14 @@ fn filtered_commit_does_not_block_ancestors_reachable_from_another_commit() -> c
         .hide([])?
         .commit_graph(graph)
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(result, expected);
     Ok(())
 }
 
 #[test]
-fn predicate_only_called_once_even_if_fork_point() -> crate::Result {
+fn predicate_only_called_once_even_if_fork_point() -> Result {
     // The `self.seen` check should come before the `self.predicate` check, as we don't know how
     // expensive calling `self.predicate` may be.
     let (_repo_dir, odb) = same_date_repo()?;
@@ -215,7 +216,7 @@ fn predicate_only_called_once_even_if_fork_point() -> crate::Result {
     .hide([])?
     .commit_graph(graph)
     .map(|res| res.map(|info| info.id))
-    .collect::<Result<Vec<_>, _>>()?;
+    .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(result, expected);
     Ok(())
diff --git a/gix-traverse/tests/traverse/commit/topo.rs b/gix-traverse/tests/traverse/commit/topo.rs
index acd66c49577..a83e9b94750 100644
--- a/gix-traverse/tests/traverse/commit/topo.rs
+++ b/gix-traverse/tests/traverse/commit/topo.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use crate::hex_to_id;
 use crate::util::{commit_graph, fixture, fixture_odb};
 use gix_hash::{ObjectId, oid};
@@ -5,11 +6,11 @@ use gix_object::bstr::ByteSlice;
 use gix_traverse::commit::{Parents, topo};
 use std::path::PathBuf;
 
-fn odb() -> crate::Result<gix_odb::Handle> {
+fn odb() -> Result<gix_odb::Handle> {
     fixture_odb("make_repo_for_topo.sh")
 }
 
-fn fixture_dir() -> crate::Result<PathBuf> {
+fn fixture_dir() -> Result<PathBuf> {
     fixture("make_repo_for_topo.sh")
 }
 
@@ -20,7 +21,7 @@ fn traverse_both(
     odb: &gix_odb::Handle,
     sorting: topo::Sorting,
     parents: Parents,
-) -> crate::Result<Vec<ObjectId>> {
+) -> Result<Vec<ObjectId>> {
     // Without commit graph
     let without_graph: Vec<_> = topo::Builder::from_iters(odb, tips.clone(), Some(ends.clone()))
         .sorting(sorting)
@@ -28,7 +29,7 @@ fn traverse_both(
         .parents(parents)
         .build()?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     // With commit graph
     let graph = commit_graph(odb.store_ref());
@@ -38,7 +39,7 @@ fn traverse_both(
         .parents(parents)
         .build()?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(
         without_graph, with_graph,
@@ -55,7 +56,7 @@ fn traverse_with_predicate(
     sorting: topo::Sorting,
     parents: Parents,
     predicate: impl FnMut(&oid) -> bool + Clone,
-) -> crate::Result<Vec<ObjectId>> {
+) -> Result<Vec<ObjectId>> {
     // Without commit graph
     let without_graph: Vec<_> = topo::Builder::from_iters(odb, tips.clone(), Some(ends.clone()))
         .sorting(sorting)
@@ -64,7 +65,7 @@ fn traverse_with_predicate(
         .with_predicate(predicate.clone())
         .build()?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     // With commit graph
     let graph = commit_graph(odb.store_ref());
@@ -75,7 +76,7 @@ fn traverse_with_predicate(
         .with_predicate(predicate)
         .build()?
         .map(|res| res.map(|info| info.id))
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<std::result::Result<Vec<_>, _>>()?;
 
     assert_eq!(
         without_graph, with_graph,
@@ -85,16 +86,17 @@ fn traverse_with_predicate(
 }
 
 /// Read baseline file and parse expected commit hashes.
-fn read_baseline(fixture_dir: &std::path::Path, name: &str) -> crate::Result<Vec<String>> {
+fn read_baseline(fixture_dir: &std::path::Path, name: &str) -> Result<Vec<String>> {
     let buf = std::fs::read(fixture_dir.join(format!("{name}.baseline")))?;
     Ok(buf.lines().map(|s| s.to_str().unwrap().to_string()).collect())
 }
 
 mod basic {
     use super::*;
+    use crate::Result;
 
     #[test]
-    fn simple() -> crate::Result {
+    fn simple() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
 
@@ -131,7 +133,7 @@ mod basic {
     }
 
     #[test]
-    fn duplicate_tips_are_ignored() -> crate::Result {
+    fn duplicate_tips_are_ignored() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
 
@@ -144,7 +146,7 @@ mod basic {
     }
 
     #[test]
-    fn one_end() -> crate::Result {
+    fn one_end() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
         let end = hex_to_id("f1cce1b5c7efcdfa106e95caa6c45a2cae48a481");
@@ -170,7 +172,7 @@ mod basic {
     }
 
     #[test]
-    fn empty_range() -> crate::Result {
+    fn empty_range() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("f1cce1b5c7efcdfa106e95caa6c45a2cae48a481");
         let end = hex_to_id("eeab3243aad67bc838fc4425f759453bf0b47785");
@@ -181,7 +183,7 @@ mod basic {
     }
 
     #[test]
-    fn two_tips_two_ends() -> crate::Result {
+    fn two_tips_two_ends() -> Result {
         let odb = odb()?;
         let tips = [
             hex_to_id("d09384f312b03e4a1413160739805ff25e8fe99d"),
@@ -209,7 +211,7 @@ mod basic {
     }
 
     #[test]
-    fn with_dummy_predicate() -> crate::Result {
+    fn with_dummy_predicate() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
         let filter_out = hex_to_id("eeab3243aad67bc838fc4425f759453bf0b47785");
@@ -242,7 +244,7 @@ mod basic {
     }
 
     #[test]
-    fn end_along_first_parent() -> crate::Result {
+    fn end_along_first_parent() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("d09384f312b03e4a1413160739805ff25e8fe99d");
         let end = hex_to_id("33eb18340e4eaae3e3dcf80222b02f161cd3f966");
@@ -263,9 +265,10 @@ mod basic {
 
 mod first_parent {
     use super::*;
+    use crate::Result;
 
     #[test]
-    fn basic() -> crate::Result {
+    fn basic() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
 
@@ -298,7 +301,7 @@ mod first_parent {
     }
 
     #[test]
-    fn with_end() -> crate::Result {
+    fn with_end() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
         let end = hex_to_id("f1cce1b5c7efcdfa106e95caa6c45a2cae48a481");
@@ -320,7 +323,7 @@ mod first_parent {
     }
 
     #[test]
-    fn end_is_second_parent() -> crate::Result {
+    fn end_is_second_parent() -> Result {
         let odb = odb()?;
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
         let end = hex_to_id("3be0c4c793c634c8fd95054345d4935d10a0879a");
@@ -344,9 +347,10 @@ mod first_parent {
 
 mod date_order {
     use super::*;
+    use crate::Result;
 
     #[test]
-    fn with_ends() -> crate::Result {
+    fn with_ends() -> Result {
         let odb = odb()?;
         // Same tip and end as basic::one_end() but the order should be different.
         let tip = hex_to_id("62ed296d9986f50477e9f7b7e81cd0258939a43d");
diff --git a/gix-traverse/tests/traverse/tree.rs b/gix-traverse/tests/traverse/tree.rs
index 77b67d55626..a8f485bff2b 100644
--- a/gix-traverse/tests/traverse/tree.rs
+++ b/gix-traverse/tests/traverse/tree.rs
@@ -1,11 +1,13 @@
+use crate::Result;
 use crate::hex_to_id;
 use crate::util::fixture_odb;
 
-fn odb() -> crate::Result<gix_odb::Handle> {
+fn odb() -> Result<gix_odb::Handle> {
     fixture_odb("make_traversal_repo_for_trees.sh")
 }
 
 mod depthfirst {
+    use crate::Result;
     use gix_object::FindExt;
     use gix_testtools::normalize_debug_snapshot;
     use gix_traverse::{tree, tree::recorder::Location};
@@ -14,7 +16,7 @@ mod depthfirst {
     use crate::util::fixture_odb;
 
     #[test]
-    fn full_path_and_filename() -> crate::Result {
+    fn full_path_and_filename() -> Result {
         let db = odb()?;
         let mut state = gix_traverse::tree::depthfirst::State::default();
         let mut buf = state.pop_buf();
@@ -166,7 +168,7 @@ mod depthfirst {
     }
 
     #[test]
-    fn more_difficult_fixture() -> crate::Result {
+    fn more_difficult_fixture() -> Result {
         let db = fixture_odb("make_traversal_repo_for_trees_depthfirst.sh")?;
         let mut state = gix_traverse::tree::depthfirst::State::default();
         let mut buf = state.pop_buf();
@@ -243,6 +245,7 @@ mod depthfirst {
 }
 
 mod breadthfirst {
+    use crate::Result;
     use gix_object::bstr::BString;
     use gix_odb::pack::FindExt;
     use gix_traverse::{tree, tree::recorder::Location};
@@ -250,7 +253,7 @@ mod breadthfirst {
     use super::*;
 
     #[test]
-    fn full_path() -> crate::Result {
+    fn full_path() -> Result {
         let db = odb()?;
         let mut buf = Vec::new();
         let mut buf2 = Vec::new();
@@ -338,7 +341,7 @@ mod breadthfirst {
     }
 
     #[test]
-    fn filename_only() -> crate::Result<()> {
+    fn filename_only() -> Result<()> {
         let db = odb()?;
         let mut buf = Vec::new();
         let mut buf2 = Vec::new();
@@ -365,7 +368,7 @@ mod breadthfirst {
     }
 
     #[test]
-    fn no_location() -> crate::Result<()> {
+    fn no_location() -> Result<()> {
         let db = odb()?;
         let mut buf = Vec::new();
         let mut buf2 = Vec::new();
diff --git a/gix-url/Cargo.toml b/gix-url/Cargo.toml
index c49ee234fae..baa2cb21a12 100644
--- a/gix-url/Cargo.toml
+++ b/gix-url/Cargo.toml
@@ -30,6 +30,7 @@ percent-encoding = "2.3.1"
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 assert_matches = "1.5.0"
 gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 serde_json = "1.0.150"
diff --git a/gix-url/fuzz/Cargo.toml b/gix-url/fuzz/Cargo.toml
index c43facd03af..27287213c8d 100644
--- a/gix-url/fuzz/Cargo.toml
+++ b/gix-url/fuzz/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2024"
 cargo-fuzz = true
 
 [dependencies]
+gix-error = { path = "../../gix-error" }
 libfuzzer-sys = "0.4"
 
 [dependencies.gix-url]
diff --git a/gix-url/fuzz/fuzz_targets/parse.rs b/gix-url/fuzz/fuzz_targets/parse.rs
index a65bc5f523c..dbc862e27d8 100644
--- a/gix-url/fuzz/fuzz_targets/parse.rs
+++ b/gix-url/fuzz/fuzz_targets/parse.rs
@@ -3,7 +3,9 @@ use libfuzzer_sys::fuzz_target;
 use std::hint::black_box;
 use std::path::Path;
 
-fn fuzz(data: &[u8]) -> Result<(), gix_url::parse::Error> {
+use gix_error::{ExnMessageResult};
+
+fn fuzz(data: &[u8]) -> ExnMessageResult {
     let url = gix_url::parse(data)?;
     _ = black_box(url.user());
     _ = black_box(url.password());
diff --git a/gix-url/src/expand_path.rs b/gix-url/src/expand_path.rs
index eac2549e8a2..470bd2fce8f 100644
--- a/gix-url/src/expand_path.rs
+++ b/gix-url/src/expand_path.rs
@@ -2,7 +2,7 @@
 use std::path::{Path, PathBuf};
 
 use bstr::{BStr, BString, ByteSlice};
-use gix_error::{ErrorExt, NotFoundError, ResultExt, ValidationError};
+use gix_error::{ErrorExt, ExnResult, ResultExt};
 
 /// The user whose home directory a repository path refers to.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
@@ -23,9 +23,6 @@ impl From<ForUser> for Option<BString> {
     }
 }
 
-/// The error used by [`parse()`], [`with()`] and [`expand_path()`](crate::expand_path()).
-pub type Error = gix_error::Exn;
-
 fn path_segments(path: &BStr) -> Option<impl Iterator<Item = &[u8]>> {
     if path.starts_with(b"/") {
         Some(path[1..].split(|c| *c == b'/'))
@@ -41,7 +38,7 @@ fn path_segments(path: &BStr) -> Option<impl Iterator<Item = &[u8]>> {
 /// * `/~user/repopath` - the named user's home, returning `/repopath`.
 ///
 /// Paths without a leading slash or home marker are returned unchanged without user information.
-pub fn parse(path: &BStr) -> Result<(Option<ForUser>, BString), Error> {
+pub fn parse(path: &BStr) -> ExnResult<(Option<ForUser>, BString)> {
     Ok(path_segments(path)
         .and_then(|mut iter| {
             iter.next().map(|segment| {
@@ -96,21 +93,22 @@ pub fn for_shell(path: BString) -> BString {
 /// the resolved home directory. With no user, `path` is returned as a platform path without home expansion.
 ///
 /// For the common case consider using [`crate::expand_path()`] instead.
+/// UTF-8 conversion failures include the path bytes as `input` [metadata](gix_error::Exn::metadata()).
 pub fn with(
     user: Option<&ForUser>,
     path: &BStr,
     home_for_user: impl FnOnce(&ForUser) -> Option<PathBuf>,
-) -> Result<PathBuf, Error> {
+) -> ExnResult<PathBuf> {
     fn make_relative(path: &Path) -> PathBuf {
         path.components().skip(1).collect()
     }
     let path = gix_path::try_from_byte_slice(path).or_raise_erased(|| {
-        ValidationError::new_with_input("UTF8 conversion on non-unix system failed for path", path)
+        gix_error::validation("UTF8 conversion on non-unix system failed for path").with("input", path)
     })?;
     Ok(match user {
         Some(user) => home_for_user(user)
             .ok_or_else(|| {
-                NotFoundError::new(match user {
+                gix_error::not_found(match user {
                     ForUser::Current => "Home directory could not be obtained for current user".into(),
                     ForUser::Name(user) => format!("Home directory could not be obtained for user '{user}'"),
                 })
diff --git a/gix-url/src/lib.rs b/gix-url/src/lib.rs
index 6e6f81aa1a6..e227867e395 100644
--- a/gix-url/src/lib.rs
+++ b/gix-url/src/lib.rs
@@ -27,7 +27,7 @@
 use std::{borrow::Cow, path::PathBuf};
 
 use bstr::{BStr, BString, ByteSlice};
-use gix_error::ErrorExt;
+use gix_error::{ErrorExt, ExnMessageResult, ExnResult};
 use gix_utils::AsBStr;
 
 const HTTP_PATH_ENCODE_SET: &percent_encoding::AsciiSet = &percent_encoding::CONTROLS
@@ -57,6 +57,8 @@ mod simple_url;
 ///
 /// This accepts standard URLs, SCP-like SSH locations, remote-helper locations and local paths. URL and SCP-like
 /// inputs must be UTF-8; remote-helper addresses and local paths retain arbitrary bytes.
+/// Errors with input context include offending bytes as `input` [metadata](gix_error::Exn::metadata()).
+/// Overlong URLs may retain only a prefix of the input.
 ///
 /// Locations of the `<helper>::<address>` form described in
 /// [`gitremote-helpers`](https://git-scm.com/docs/gitremote-helpers) are recognized before any URL
@@ -73,7 +75,7 @@ mod simple_url;
 ///
 /// Also unlike Git, an empty remote-helper name as in `::address` is not accepted, as the `git-remote-` program it
 /// would name cannot meaningfully exist.
-pub fn parse(input: impl AsBStr) -> Result<Url, parse::Error> {
+pub fn parse(input: impl AsBStr) -> ExnMessageResult<Url> {
     use parse::InputScheme;
     let input = input.as_bstr();
     match parse::find_scheme(input) {
@@ -89,7 +91,7 @@ pub fn parse(input: impl AsBStr) -> Result<Url, parse::Error> {
 /// directory automatically.
 ///
 /// If more precise control of the resolution mechanism is needed, then use the [expand_path::with()] function.
-pub fn expand_path(user: Option<&expand_path::ForUser>, path: &BStr) -> Result<PathBuf, expand_path::Error> {
+pub fn expand_path(user: Option<&expand_path::ForUser>, path: &BStr) -> ExnResult<PathBuf> {
     expand_path::with(user, path, |user| match user {
         expand_path::ForUser::Current => gix_path::env::home_dir(),
         expand_path::ForUser::Name(user) => {
@@ -162,7 +164,7 @@ pub struct PathComponents<'a> {
 /// whereas [`Url::to_bstring()`] includes all URL parts.
 /// **Beware that some URLs still print secrets if they use them outside of the designated password fields.**
 ///
-/// Also note that URLs that fail to parse are typically stored in [the resulting error](parse::Error) type
+/// Also note that URLs that fail to parse are typically stored in [the resulting error](gix_error::Exn) type
 /// and printed in full using its display implementation.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
@@ -312,6 +314,8 @@ impl Url {
     /// path is normalized to `/`. Other schemes interpret `path` according to their serialized syntax.
     /// `serialize_alternative_form` merely requests alternative form; passwords, ports, and unsupported schemes force
     /// canonical URL serialization.
+    /// Invalid remote-helper names include the name bytes as `input` [metadata](gix_error::Exn::metadata());
+    /// other validation errors retain the input context documented by [`parse()`].
     ///
     /// # Panics
     ///
@@ -324,13 +328,13 @@ impl Url {
         port: Option<u16>,
         path: BString,
         serialize_alternative_form: bool,
-    ) -> Result<Self, parse::Error> {
+    ) -> ExnMessageResult<Self> {
         if let Scheme::Helper(name) = &scheme
             && !parse::is_valid_remote_helper_name(name.as_bytes())
         {
-            return Err(
-                gix_error::ValidationError::new_with_input("Invalid remote-helper name", name.as_bytes()).raise(),
-            );
+            return Err(gix_error::validation("Invalid remote-helper name")
+                .with("input", name.as_bytes())
+                .raise());
         }
         let is_http = matches!(scheme, Scheme::Http | Scheme::Https);
         let mut parsed = parse(
@@ -393,7 +397,7 @@ impl Url {
     /// Resolve the path of a file location against `current_dir` and normalize it in place.
     ///
     /// Other schemes are unchanged.
-    pub fn canonicalize(&mut self, current_dir: &std::path::Path) -> Result<(), gix_path::realpath::Error> {
+    pub fn canonicalize(&mut self, current_dir: &std::path::Path) -> ExnResult {
         if self.scheme == Scheme::File {
             let path = gix_path::from_bstr(Cow::Borrowed(self.path.as_ref()));
             let abs_path = gix_path::realpath_opts(path.as_ref(), current_dir, gix_path::realpath::MAX_SYMLINKS)?;
@@ -512,7 +516,7 @@ impl Url {
     ///
     /// url.path = "/my repo".into();
     /// assert_eq!(url.original_path(), "/my%20repo", "restoring the path reuses the original spelling");
-    /// # Ok::<(), gix_url::parse::Error>(())
+    /// # Ok::<(), gix_error::Exn<gix_error::Message>>(())
     /// ```
     pub fn original_path(&self) -> &BStr {
         self.path_with_percent_escapes().unwrap_or(self.path.as_ref())
@@ -545,7 +549,7 @@ impl Url {
     /// assert_eq!(query[0].1.as_ref(), "a&b");
     /// assert_eq!(parts.fragment, Some("fragment#one".into()));
     /// assert_eq!(url.path, "/repo#one?x=a&b#fragment#one");
-    /// # Ok::<(), gix_url::parse::Error>(())
+    /// # Ok::<(), gix_error::Exn<gix_error::Message>>(())
     /// ```
     pub fn path_query_fragment(&self) -> PathComponents<'_> {
         fn decoded_len(original: &[u8], is_encoded: bool) -> usize {
@@ -668,7 +672,7 @@ impl Url {
     /// Return a clone whose file path is resolved against `current_dir` and normalized.
     ///
     /// Other schemes are returned unchanged.
-    pub fn canonicalized(&self, current_dir: &std::path::Path) -> Result<Self, gix_path::realpath::Error> {
+    pub fn canonicalized(&self, current_dir: &std::path::Path) -> ExnResult<Self> {
         let mut res = self.clone();
         res.canonicalize(current_dir)?;
         Ok(res)
@@ -899,7 +903,8 @@ impl Url {
 /// Deserialization
 impl Url {
     /// Parse a URL from `bytes`.
-    pub fn from_bytes(bytes: &BStr) -> Result<Self, parse::Error> {
+    /// Errors retain the `input` [metadata](gix_error::Exn::metadata()) documented by [`parse()`].
+    pub fn from_bytes(bytes: &BStr) -> ExnMessageResult<Self> {
         parse(bytes)
     }
 }
diff --git a/gix-url/src/parse.rs b/gix-url/src/parse.rs
index 9c379298b1a..d76bf74a6ab 100644
--- a/gix-url/src/parse.rs
+++ b/gix-url/src/parse.rs
@@ -1,11 +1,9 @@
 use bstr::{BStr, BString, ByteSlice};
-use gix_error::{ErrorExt, ResultExt, ValidationError};
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, ResultExt};
 
 use crate::Scheme;
 
-/// The error returned by [parse()](crate::parse()).
-pub type Error = gix_error::Exn<ValidationError>;
-
 /// The syntax used to interpret an input location.
 #[derive(Debug, Clone, Copy)]
 pub enum UrlKind {
@@ -116,7 +114,7 @@ pub(crate) fn remote_helper(input: &BStr, helper_end: usize) -> crate::Url {
     }
 }
 
-pub(crate) fn url(input: &BStr, protocol_end: usize) -> Result<crate::Url, Error> {
+pub(crate) fn url(input: &BStr, protocol_end: usize) -> ExnMessageResult<crate::Url> {
     const MAX_LEN: usize = 1024;
     let input_after_protocol = &input[protocol_end + "://".len()..];
     let scheme = &input[..protocol_end];
@@ -129,14 +127,12 @@ pub(crate) fn url(input: &BStr, protocol_end: usize) -> Result<crate::Url, Error
         .unwrap_or(input_after_protocol.len());
     if bytes_to_path > MAX_LEN || protocol_end > MAX_LEN {
         let truncated_url = &input[..(protocol_end + "://".len() + MAX_LEN).min(input.len())];
-        return Err(ValidationError::new_with_input(
-            format!(
-                "The host portion of the URL is too long ({} bytes shown, {} bytes total)",
-                truncated_url.len(),
-                input.len()
-            ),
-            truncated_url,
-        )
+        return Err(gix_error::validation(format!(
+            "The host portion of the URL is too long ({} bytes shown, {} bytes total)",
+            truncated_url.len(),
+            input.len()
+        ))
+        .with("input", truncated_url)
         .raise());
     }
     let (input, url) = input_to_utf8_and_url(input, UrlKind::Url)?;
@@ -157,10 +153,11 @@ pub(crate) fn url(input: &BStr, protocol_end: usize) -> Result<crate::Url, Error
     let scheme = Scheme::from(url.scheme.as_str());
 
     if matches!(scheme, Scheme::Git | Scheme::Ssh) && url.path.is_empty() {
-        return Err(ValidationError::new_with_input(
-            format!("{} does not specify a path to a repository", UrlKind::Url.as_str()),
-            input,
-        )
+        return Err(gix_error::validation(format!(
+            "{} does not specify a path to a repository",
+            UrlKind::Url.as_str()
+        ))
+        .with("input", input.as_bytes())
         .raise());
     }
 
@@ -222,7 +219,7 @@ pub(crate) fn url(input: &BStr, protocol_end: usize) -> Result<crate::Url, Error
     })
 }
 
-pub(crate) fn scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
+pub(crate) fn scp(input: &BStr, colon: usize) -> ExnMessageResult<crate::Url> {
     let input = input_to_utf8(input, UrlKind::Scp)?;
 
     // TODO: this incorrectly splits at IPv6 addresses, check for `[]` before splitting
@@ -231,10 +228,11 @@ pub(crate) fn scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
     let path = &path[1..];
 
     if path.is_empty() {
-        return Err(ValidationError::new_with_input(
-            format!("{} does not specify a path to a repository", UrlKind::Scp.as_str()),
-            input,
-        )
+        return Err(gix_error::validation(format!(
+            "{} does not specify a path to a repository",
+            UrlKind::Scp.as_str()
+        ))
+        .with("input", input.as_bytes())
         .raise());
     }
 
@@ -250,10 +248,8 @@ pub(crate) fn scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
     // In SCP-like syntax `%` is literal host data, but the synthesized URL parser treats it as an escape introducer.
     let url_string = format!("ssh://{}", host.replace('%', "%25"));
     let url = crate::simple_url::ParsedUrl::parse(&url_string).or_raise(|| {
-        ValidationError::new_with_input(
-            format!("{} can not be parsed as valid URL", UrlKind::Scp.as_str()),
-            input,
-        )
+        gix_error::validation(format!("{} can not be parsed as valid URL", UrlKind::Scp.as_str()))
+            .with("input", input.as_bytes())
     })?;
 
     // For SCP-like SSH URLs, strip leading '/' from paths starting with '/~'
@@ -283,7 +279,7 @@ pub(crate) fn scp(input: &BStr, colon: usize) -> Result<crate::Url, Error> {
     })
 }
 
-pub(crate) fn file_url(input: &BStr, protocol_colon: usize) -> Result<crate::Url, Error> {
+pub(crate) fn file_url(input: &BStr, protocol_colon: usize) -> ExnMessageResult<crate::Url> {
     let input = input_to_utf8(input, UrlKind::Url)?;
     let input_after_protocol = &input[protocol_colon + "://".len()..];
 
@@ -291,10 +287,11 @@ pub(crate) fn file_url(input: &BStr, protocol_colon: usize) -> Result<crate::Url
         .find('/')
         .or_else(|| cfg!(windows).then(|| input_after_protocol.find('\\')).flatten())
     else {
-        return Err(ValidationError::new_with_input(
-            format!("{} does not specify a path to a repository", UrlKind::Url.as_str()),
-            input,
-        )
+        return Err(gix_error::validation(format!(
+            "{} does not specify a path to a repository",
+            UrlKind::Url.as_str()
+        ))
+        .with("input", input.as_bytes())
         .raise());
     };
 
@@ -342,15 +339,13 @@ pub(crate) fn file_url(input: &BStr, protocol_colon: usize) -> Result<crate::Url
     })
 }
 
-pub(crate) fn local(input: &BStr) -> Result<crate::Url, Error> {
+pub(crate) fn local(input: &BStr) -> ExnMessageResult<crate::Url> {
     if input.is_empty() {
-        return Err(ValidationError::new_with_input(
-            format!(
-                "{} is empty and does not specify a path to a repository",
-                UrlKind::Local.as_str()
-            ),
-            input,
-        )
+        return Err(gix_error::validation(format!(
+            "{} is empty and does not specify a path to a repository",
+            UrlKind::Local.as_str()
+        ))
+        .with("input", input.as_bytes())
         .raise());
     }
 
@@ -366,16 +361,18 @@ pub(crate) fn local(input: &BStr) -> Result<crate::Url, Error> {
     })
 }
 
-fn input_to_utf8(input: &BStr, kind: UrlKind) -> Result<&str, Error> {
+fn input_to_utf8(input: &BStr, kind: UrlKind) -> ExnMessageResult<&str> {
     let kind = kind.as_str();
-    std::str::from_utf8(input).or_raise(|| ValidationError::new_with_input(format!("{kind} is not valid UTF-8"), input))
+    std::str::from_utf8(input)
+        .or_raise(|| gix_error::validation(format!("{kind} is not valid UTF-8")).with("input", input.as_bytes()))
 }
 
-fn input_to_utf8_and_url(input: &BStr, kind: UrlKind) -> Result<(&str, crate::simple_url::ParsedUrl), Error> {
+fn input_to_utf8_and_url(input: &BStr, kind: UrlKind) -> ExnMessageResult<(&str, crate::simple_url::ParsedUrl)> {
     let input = input_to_utf8(input, kind)?;
     crate::simple_url::ParsedUrl::parse(input)
         .map(|url| (input, url))
         .or_raise(|| {
-            ValidationError::new_with_input(format!("{} can not be parsed as valid URL", kind.as_str()), input)
+            gix_error::validation(format!("{} can not be parsed as valid URL", kind.as_str()))
+                .with("input", input.as_bytes())
         })
 }
diff --git a/gix-url/src/simple_url.rs b/gix-url/src/simple_url.rs
index 9be5f19f932..189773cd19e 100644
--- a/gix-url/src/simple_url.rs
+++ b/gix-url/src/simple_url.rs
@@ -1,6 +1,6 @@
 use percent_encoding::percent_decode_str;
 
-use gix_error::{ErrorExt, Exn, OptionExt, ResultExt, ValidationError};
+use gix_error::{ErrorExt, ExnMessageResult, Message, OptionExt, ResultExt};
 
 /// A minimal URL parser that extracts only what we need for git URLs.
 /// This is a replacement for the `url` crate dependency.
@@ -16,20 +16,20 @@ pub(crate) struct ParsedUrl {
     pub path_with_percent_escapes: Option<String>,
 }
 
-fn relative_url_without_base() -> ValidationError {
-    ValidationError::new("relative URL without a base")
+fn relative_url_without_base() -> Message {
+    gix_error::validation("relative URL without a base")
 }
 
-fn invalid_port() -> ValidationError {
-    ValidationError::new("invalid port number - must be between 1-65535")
+fn invalid_port() -> Message {
+    gix_error::validation("invalid port number - must be between 1-65535")
 }
 
-fn invalid_domain_character() -> ValidationError {
-    ValidationError::new("invalid domain character")
+fn invalid_domain_character() -> Message {
+    gix_error::validation("invalid domain character")
 }
 
-fn scheme_requires_host() -> ValidationError {
-    ValidationError::new("Scheme requires host")
+fn scheme_requires_host() -> Message {
+    gix_error::validation("Scheme requires host")
 }
 
 /// Check if a character is valid in a URL scheme.
@@ -55,7 +55,7 @@ fn has_valid_percent_encoding(input: &str) -> bool {
 
 /// Decode a percent-encoded string, returning an error if the result is not valid UTF-8.
 /// Returns the original string if it contains no percent-encoding.
-fn percent_decode(s: &str) -> Result<String, Exn<ValidationError>> {
+fn percent_decode(s: &str) -> ExnMessageResult<String> {
     percent_decode_str(s)
         .decode_utf8()
         .map(std::borrow::Cow::into_owned)
@@ -63,7 +63,7 @@ fn percent_decode(s: &str) -> Result<String, Exn<ValidationError>> {
 }
 
 /// Decode percent-encoded path bytes and retain the original spelling if it contains escapes.
-fn percent_decode_path(s: &str) -> Result<(String, Option<String>), Exn<ValidationError>> {
+fn percent_decode_path(s: &str) -> ExnMessageResult<(String, Option<String>)> {
     percent_decode(s).map(|path| (path, s.contains('%').then(|| s.to_owned())))
 }
 
@@ -107,7 +107,7 @@ fn normalize_ipv6_literal(host: &str) -> Option<String> {
 impl ParsedUrl {
     /// Parse a URL string into its components.
     /// Expected format: scheme://[user[:password]@]host[:port]/path
-    pub(crate) fn parse(input: &str) -> Result<Self, Exn<ValidationError>> {
+    pub(crate) fn parse(input: &str) -> ExnMessageResult<Self> {
         // Validate that the entire URL doesn't contain any whitespace (per RFC 3986)
         if input.chars().any(char::is_whitespace) || !has_valid_percent_encoding(input) {
             return Err(invalid_domain_character().raise());
@@ -203,7 +203,7 @@ impl ParsedUrl {
         host_port: &str,
         allow_unbracketed_ipv6: bool,
         strict_authority: bool,
-    ) -> Result<(Option<String>, Option<u16>), Exn<ValidationError>> {
+    ) -> ExnMessageResult<(Option<String>, Option<u16>)> {
         if host_port.is_empty() {
             return Ok((None, None));
         }
@@ -302,7 +302,7 @@ impl ParsedUrl {
 
     /// Validate a hostname and normalize DNS-like ASCII hostnames to lowercase.
     /// Hostnames containing other permitted URL characters retain their original case.
-    fn normalize_http_hostname(host: &str) -> Result<String, Exn<ValidationError>> {
+    fn normalize_http_hostname(host: &str) -> ExnMessageResult<String> {
         if !host.bytes().all(|c| {
             c.is_ascii_alphanumeric()
                 || matches!(
@@ -337,7 +337,7 @@ impl ParsedUrl {
     ///
     /// This is separate from [`Self::normalize_http_hostname`] because Git passes the decoded host to transports, whereas
     /// HTTP and HTTPS retain escaped host spelling and apply stricter hostname validation.
-    fn normalize_git_hostname(host: &str) -> Result<String, Exn<ValidationError>> {
+    fn normalize_git_hostname(host: &str) -> ExnMessageResult<String> {
         let host = percent_decode(host)?;
         Ok(if Self::is_normalizable_hostname(&host) {
             host.to_ascii_lowercase()
@@ -374,6 +374,11 @@ mod tests {
     #[test]
     fn invalid_port_keeps_parse_error() {
         let err = ParsedUrl::parse("http://example.com:65536/path").expect_err("port is out of range");
+        insta::assert_debug_snapshot!(err, "the port parser cause remains in the error chain", @"
+        invalid port number - must be between 1-65535
+        |
+        └─ number too large to fit in target type
+        ");
         assert!(
             err.downcast_any_ref::<std::num::ParseIntError>().is_some(),
             "the port parser cause remains in the error chain"
diff --git a/gix-url/tests/url/access.rs b/gix-url/tests/url/access.rs
index c330dd0e9e9..2939ab4b3c3 100644
--- a/gix-url/tests/url/access.rs
+++ b/gix-url/tests/url/access.rs
@@ -55,7 +55,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn http_delimiters_are_recognized_before_decoding() -> crate::Result {
+    fn http_delimiters_are_recognized_before_decoding() -> gix_error::TestResult {
         for scheme in ["http", "https"] {
             for (suffix, expected) in [
                 ("/repo%23one?query=value#fragment", "/repo#one"),
@@ -102,7 +102,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn other_schemes_keep_their_stored_paths() -> crate::Result {
+    fn other_schemes_keep_their_stored_paths() -> gix_error::TestResult {
         for (input, expected) in [
             ("git@host:repo#one?two%23three", "repo#one?two%23three"),
             ("ssh://git@host/repo%23one?two", "/repo#one?two"),
@@ -127,7 +127,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn constructed_and_mutated_http_paths_are_already_decoded() -> crate::Result {
+    fn constructed_and_mutated_http_paths_are_already_decoded() -> gix_error::TestResult {
         for scheme in [Scheme::Http, Scheme::Https] {
             for (path, expected) in [
                 ("/repo%23one?query=value#fragment", "/repo%23one"),
@@ -168,7 +168,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn mutation_keeps_paths_byte_oriented_and_uses_the_current_scheme() -> crate::Result {
+    fn mutation_keeps_paths_byte_oriented_and_uses_the_current_scheme() -> gix_error::TestResult {
         let mut url = gix_url::parse("https://host/repo%23one?query=value#fragment")?;
         url.scheme = Scheme::Ssh;
         assert_eq!(
@@ -210,7 +210,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn query_pairs_and_fragments_are_split_before_decoding() -> crate::Result {
+    fn query_pairs_and_fragments_are_split_before_decoding() -> gix_error::TestResult {
         for scheme in ["http", "https"] {
             for (suffix, path, query, fragment) in [
                 (
@@ -296,7 +296,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn empty_and_absent_components_remain_distinct() -> crate::Result {
+    fn empty_and_absent_components_remain_distinct() -> gix_error::TestResult {
         for (suffix, has_query, fragment) in [
             ("", false, None),
             ("/repo", false, None),
@@ -323,7 +323,7 @@ mod path_query_fragment {
     }
 
     #[test]
-    fn constructed_and_mutated_components_keep_literal_percent_escapes() -> crate::Result {
+    fn constructed_and_mutated_components_keep_literal_percent_escapes() -> gix_error::TestResult {
         let path = "/repo%23one?x=a%26b&space=+%2B#frag%23+";
         let constructed = Url::from_parts(Scheme::Https, None, None, Some("host".into()), None, path.into(), false)?;
         let mut mutated = gix_url::parse("https://host/old%23repo?x=%26#old%23fragment")?;
@@ -354,7 +354,7 @@ mod path_query_fragment {
 
     #[cfg(feature = "serde")]
     #[test]
-    fn serde_preserves_component_boundaries() -> crate::Result {
+    fn serde_preserves_component_boundaries() -> gix_error::TestResult {
         let mut mutated = gix_url::parse("https://host/old%23repo?x=%26#old%23fragment")?;
         mutated.path = "/repo%23one?x=a%26b&space=+%2B#frag%23+".into();
         for url in [
@@ -373,7 +373,7 @@ mod path_query_fragment {
 }
 
 #[test]
-fn user() -> crate::Result {
+fn user() -> gix_error::TestResult {
     let mut url = gix_url::parse("https://user:password@host/path")?;
 
     assert_eq!(url.user(), Some("user"));
@@ -384,7 +384,7 @@ fn user() -> crate::Result {
 }
 
 #[test]
-fn password() -> crate::Result {
+fn password() -> gix_error::TestResult {
     let mut url = gix_url::parse("https://user:password@host/path")?;
 
     assert_eq!(url.password(), Some("password"));
@@ -395,7 +395,7 @@ fn password() -> crate::Result {
 }
 
 #[test]
-fn mutation_roundtrip() -> crate::Result {
+fn mutation_roundtrip() -> gix_error::TestResult {
     let mut url = gix_url::parse("https://user@host/path")?;
     url.set_user(Some("newuser".into()));
     url.set_password(Some("secret".into()));
@@ -411,7 +411,7 @@ fn mutation_roundtrip() -> crate::Result {
 }
 
 #[test]
-fn from_bytes_roundtrip() -> crate::Result {
+fn from_bytes_roundtrip() -> gix_error::TestResult {
     let original = "https://user:password@example.com:8080/path/to/repo";
     let url = gix_url::parse(original)?;
 
@@ -425,7 +425,7 @@ fn from_bytes_roundtrip() -> crate::Result {
 }
 
 #[test]
-fn from_bytes_with_non_utf8_path() -> crate::Result {
+fn from_bytes_with_non_utf8_path() -> gix_error::TestResult {
     let url = gix_url::parse(b"/path/to\xff/repo".as_slice())?;
     let bytes = url.to_bstring();
     let from_bytes = gix_url::Url::from_bytes(bytes.as_ref())?;
@@ -437,7 +437,7 @@ fn from_bytes_with_non_utf8_path() -> crate::Result {
 }
 
 #[test]
-fn user_argument_safety() -> crate::Result {
+fn user_argument_safety() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://-Fconfigfile@foo/bar")?;
 
     assert_eq!(url.user(), Some("-Fconfigfile"));
@@ -455,7 +455,7 @@ fn user_argument_safety() -> crate::Result {
 }
 
 #[test]
-fn host_argument_safety() -> crate::Result {
+fn host_argument_safety() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://-oProxyCommand=open$IFS-aCalculator/foo")?;
 
     assert_eq!(url.user(), None);
@@ -480,7 +480,7 @@ fn host_argument_safety() -> crate::Result {
 }
 
 #[test]
-fn path_argument_safety() -> crate::Result {
+fn path_argument_safety() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://foo/-oProxyCommand=open$IFS-aCalculator")?;
 
     assert_eq!(url.user(), None);
@@ -511,7 +511,7 @@ fn path_argument_safety() -> crate::Result {
 }
 
 #[test]
-fn all_argument_safety_safe() -> crate::Result {
+fn all_argument_safety_safe() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://user.name@example.com/path/to/file")?;
 
     assert_eq!(url.user(), Some("user.name"));
@@ -529,7 +529,7 @@ fn all_argument_safety_safe() -> crate::Result {
 }
 
 #[test]
-fn all_argument_safety_not_safe() -> crate::Result {
+fn all_argument_safety_not_safe() -> gix_error::TestResult {
     let all_bad = "ssh://-Fconfigfile@-oProxyCommand=open$IFS-aCalculator/-oProxyCommand=open$IFS-aCalculator";
     let url = gix_url::parse(all_bad)?;
 
diff --git a/gix-url/tests/url/expand_path.rs b/gix-url/tests/url/expand_path.rs
index 3611f526490..aca86bf6702 100644
--- a/gix-url/tests/url/expand_path.rs
+++ b/gix-url/tests/url/expand_path.rs
@@ -25,7 +25,7 @@ fn user_home(name: &str) -> std::path::PathBuf {
 }
 
 #[test]
-fn without_username() -> crate::Result {
+fn without_username() -> gix_error::TestResult {
     let (user, resolved_path) = expand_path::parse(b"/~/hello/git".as_bstr())?;
     let resolved_path = expand_path::with(user.as_ref(), resolved_path.as_ref(), |user: &ForUser| match user {
         ForUser::Current => Some(user_home("byron")),
@@ -36,7 +36,7 @@ fn without_username() -> crate::Result {
 }
 
 #[test]
-fn with_username() -> crate::Result {
+fn with_username() -> gix_error::TestResult {
     let (user, resolved_path) = expand_path::parse(b"/~byron/hello/git".as_bstr())?;
     let resolved_path = expand_path::with(user.as_ref(), resolved_path.as_ref(), |user: &ForUser| match user {
         ForUser::Current => unreachable!("we have a name"),
@@ -50,8 +50,9 @@ fn with_username() -> crate::Result {
 fn missing_home_is_not_found() {
     let user = ForUser::Current;
     let err = expand_path::with(Some(&user), b"/repo".as_bstr(), |_| None).expect_err("home is missing");
+    insta::assert_debug_snapshot!(err, "a missing home directory is classified as not found", @"Home directory could not be obtained for current user");
     assert!(
-        err.downcast_any_ref::<gix_error::NotFoundError>().is_some(),
+        err.is_not_found(),
         "a missing home directory is classified as not found"
     );
 }
diff --git a/gix-url/tests/url/main.rs b/gix-url/tests/url/main.rs
index d883999915a..41aa3a821f1 100644
--- a/gix-url/tests/url/main.rs
+++ b/gix-url/tests/url/main.rs
@@ -1,5 +1,3 @@
-pub type Result = gix_error::TestResult;
-
 mod access;
 mod baseline;
 mod expand_path;
diff --git a/gix-url/tests/url/parse/file.rs b/gix-url/tests/url/parse/file.rs
index 62d7e70523d..dec2bc3b7d6 100644
--- a/gix-url/tests/url/parse/file.rs
+++ b/gix-url/tests/url/parse/file.rs
@@ -4,7 +4,7 @@ use gix_url::Scheme;
 use crate::parse::{assert_url_roundtrip, url, url_alternate};
 
 #[test]
-fn file_path_with_protocol() -> crate::Result {
+fn file_path_with_protocol() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "file:///path/to/git",
         url(Scheme::File, None, None, None, b"/path/to/git"),
@@ -12,7 +12,7 @@ fn file_path_with_protocol() -> crate::Result {
 }
 
 #[test]
-fn file_to_root() -> crate::Result {
+fn file_to_root() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "file:///",
         url(Scheme::File, None, None, None, b"/"),
@@ -20,7 +20,7 @@ fn file_to_root() -> crate::Result {
 }
 
 #[test]
-fn file_path_without_protocol() -> crate::Result {
+fn file_path_without_protocol() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "/path/to/git",
         url_alternate(Scheme::File, None, None, None, b"/path/to/git"),
@@ -28,7 +28,7 @@ fn file_path_without_protocol() -> crate::Result {
 }
 
 #[test]
-fn file_path_with_whitespace() -> crate::Result {
+fn file_path_with_whitespace() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "/path/to/git with spaces ",
         url_alternate(Scheme::File, None, None, None, b"/path/to/git with spaces "),
@@ -36,7 +36,7 @@ fn file_path_with_whitespace() -> crate::Result {
 }
 
 #[test]
-fn no_username_expansion_for_file_paths_without_protocol() -> crate::Result {
+fn no_username_expansion_for_file_paths_without_protocol() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "~/path/to/git",
         url_alternate(Scheme::File, None, None, None, b"~/path/to/git"),
@@ -44,7 +44,7 @@ fn no_username_expansion_for_file_paths_without_protocol() -> crate::Result {
 }
 
 #[test]
-fn no_username_expansion_for_file_paths_with_protocol() -> crate::Result {
+fn no_username_expansion_for_file_paths_with_protocol() -> gix_error::TestResult {
     assert_url_roundtrip(
         "file:///~username/path/to/git",
         url(Scheme::File, None, None, None, b"/~username/path/to/git"),
@@ -56,7 +56,7 @@ fn no_username_expansion_for_file_paths_with_protocol() -> crate::Result {
 }
 
 #[test]
-fn non_utf8_file_path_without_protocol() -> crate::Result {
+fn non_utf8_file_path_without_protocol() -> gix_error::TestResult {
     let url = gix_url::parse(b"/path/to\xff/git".as_bstr())?;
     assert_eq!(url, url_alternate(Scheme::File, None, None, None, b"/path/to\xff/git"));
     let url_lossless = url.to_bstring();
@@ -70,7 +70,7 @@ fn non_utf8_file_path_without_protocol() -> crate::Result {
 }
 
 #[test]
-fn relative_file_path_without_protocol() -> crate::Result {
+fn relative_file_path_without_protocol() -> gix_error::TestResult {
     assert_url_roundtrip(
         "../../path/to/git",
         url_alternate(Scheme::File, None, None, None, b"../../path/to/git"),
@@ -82,7 +82,7 @@ fn relative_file_path_without_protocol() -> crate::Result {
 }
 
 #[test]
-fn shortest_possible_absolute_path() -> crate::Result {
+fn shortest_possible_absolute_path() -> gix_error::TestResult {
     assert_url_roundtrip("/", url_alternate(Scheme::File, None, None, None, b"/"))?;
     Ok(assert_url_roundtrip(
         "file:///",
@@ -91,7 +91,7 @@ fn shortest_possible_absolute_path() -> crate::Result {
 }
 
 #[test]
-fn shortest_possible_relative_path() -> crate::Result {
+fn shortest_possible_relative_path() -> gix_error::TestResult {
     assert_url_roundtrip("a", url_alternate(Scheme::File, None, None, None, b"a"))?;
     assert_url_roundtrip("../", url_alternate(Scheme::File, None, None, None, b"../"))?;
     assert_url_roundtrip(r"..\", url_alternate(Scheme::File, None, None, None, br"..\"))?;
@@ -102,7 +102,7 @@ fn shortest_possible_relative_path() -> crate::Result {
 }
 
 #[test]
-fn no_relative_paths_if_protocol() -> crate::Result {
+fn no_relative_paths_if_protocol() -> gix_error::TestResult {
     assert_url_roundtrip("file://../", url(Scheme::File, None, "..", None, b"/"))?;
     assert_url_roundtrip("file://./", url(Scheme::File, None, ".", None, b"/"))?;
     assert_url_roundtrip("file://a/", url(Scheme::File, None, "a", None, b"/"))?;
@@ -113,19 +113,14 @@ fn no_relative_paths_if_protocol() -> crate::Result {
             "we are just as none-sensical as git here due to special handling."
         );
     } else {
-        assert!(
-            gix_url::parse(r"file://.\")
-                .unwrap_err()
-                .message
-                .contains("does not specify a path to a repository"),
-            "DEVIATION: on windows, this parses with git into something nonsensical Diag: url=file://./ Diag: protocol=file Diag: hostandport=./ Diag: path=//./"
-        );
+        let err = gix_url::parse(r"file://.\").expect_err("the input must be rejected");
+        insta::assert_debug_snapshot!(err, "Unix requires a forward slash after the host", @r#"URL does not specify a path to a repository, "input"="file://.\\""#);
     }
     Ok(())
 }
 
 #[test]
-fn interior_relative_file_path_without_protocol() -> crate::Result {
+fn interior_relative_file_path_without_protocol() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "/abs/path/../../path/to/git",
         url_alternate(Scheme::File, None, None, None, b"/abs/path/../../path/to/git"),
@@ -133,7 +128,7 @@ fn interior_relative_file_path_without_protocol() -> crate::Result {
 }
 
 #[test]
-fn url_from_relative_path_with_colon_in_name() -> crate::Result {
+fn url_from_relative_path_with_colon_in_name() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "./weird/directory/na:me",
         url_alternate(Scheme::File, None, None, None, b"./weird/directory/na:me"),
@@ -147,7 +142,7 @@ mod windows {
     use crate::parse::{assert_url, assert_url_roundtrip, url, url_alternate};
 
     #[test]
-    fn reproduce_1063() -> crate::Result {
+    fn reproduce_1063() -> gix_error::TestResult {
         let input = r"C:\Users\RUNNER~1\AppData\Local\Temp\tmp.vIa4tyjv17";
         let url_input = r"file://C:\Users\RUNNER~1\AppData\Local\Temp\tmp.vIa4tyjv17";
         assert_url(url_input, url(Scheme::File, None, None, None, input.as_bytes()))?;
@@ -156,7 +151,7 @@ mod windows {
     }
 
     #[test]
-    fn url_from_absolute_path() -> crate::Result {
+    fn url_from_absolute_path() -> gix_error::TestResult {
         // Test with a Windows path directly instead of using url::Url::from_directory_path
         assert_url(
             r"C:\users\1\",
@@ -169,7 +164,7 @@ mod windows {
     }
 
     #[test]
-    fn file_path_without_protocol() -> crate::Result {
+    fn file_path_without_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "x:/path/to/git",
             url_alternate(Scheme::File, None, None, None, b"x:/path/to/git"),
@@ -177,7 +172,7 @@ mod windows {
     }
 
     #[test]
-    fn file_path_with_backslashes_without_protocol() -> crate::Result {
+    fn file_path_with_backslashes_without_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             r"x:\path\to\git",
             url_alternate(Scheme::File, None, None, None, br"x:\path\to\git"),
@@ -185,7 +180,7 @@ mod windows {
     }
 
     #[test]
-    fn file_path_with_protocol() -> crate::Result {
+    fn file_path_with_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "file://x:/path/to/git",
             url(Scheme::File, None, None, None, b"x:/path/to/git"),
@@ -200,7 +195,7 @@ mod unix {
     use crate::parse::{assert_url_roundtrip, url, url_alternate};
 
     #[test]
-    fn url_from_absolute_path() -> crate::Result {
+    fn url_from_absolute_path() -> gix_error::TestResult {
         // Test with a simple file path instead of using url::Url::from_directory_path
         Ok(assert_url_roundtrip(
             "/users/foo/",
@@ -209,7 +204,7 @@ mod unix {
     }
 
     #[test]
-    fn file_path_without_protocol() -> crate::Result {
+    fn file_path_without_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "x:/path/to/git",
             url_alternate(Scheme::Ssh, None, "x", None, b"/path/to/git"),
@@ -217,7 +212,7 @@ mod unix {
     }
 
     #[test]
-    fn file_path_with_backslashes_without_protocol() -> crate::Result {
+    fn file_path_with_backslashes_without_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             r"x:\path\to\git",
             url_alternate(Scheme::Ssh, None, "x", None, br"\path\to\git"),
@@ -225,7 +220,7 @@ mod unix {
     }
 
     #[test]
-    fn file_path_with_protocol() -> crate::Result {
+    fn file_path_with_protocol() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "file://x:/path/to/git",
             url(Scheme::File, None, "x:", None, b"/path/to/git"),
@@ -233,7 +228,7 @@ mod unix {
     }
 
     #[test]
-    fn file_url_with_ipv6_and_user() -> crate::Result {
+    fn file_url_with_ipv6_and_user() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "file://User@[::1]/repo",
             gix_url::Url::from_parts(
@@ -249,7 +244,7 @@ mod unix {
     }
 
     #[test]
-    fn file_url_with_ipv6() -> crate::Result {
+    fn file_url_with_ipv6() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "file://[::1]/repo",
             url(Scheme::File, None, "[::1]", None, b"/repo"),
diff --git a/gix-url/tests/url/parse/http.rs b/gix-url/tests/url/parse/http.rs
index 80b30310a14..4ffed8d6c78 100644
--- a/gix-url/tests/url/parse/http.rs
+++ b/gix-url/tests/url/parse/http.rs
@@ -12,7 +12,7 @@ fn test_password(with_dot: bool) -> String {
 }
 
 #[test]
-fn username_expansion_is_unsupported() -> crate::Result {
+fn username_expansion_is_unsupported() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "http://example.com/~byron/hello",
         url(Scheme::Http, None, "example.com", None, b"/~byron/hello"),
@@ -20,7 +20,7 @@ fn username_expansion_is_unsupported() -> crate::Result {
 }
 
 #[test]
-fn empty_user_cannot_roundtrip() -> crate::Result {
+fn empty_user_cannot_roundtrip() -> gix_error::TestResult {
     let actual = gix_url::parse("http://@example.com/~byron/hello")?;
     let expected = url(Scheme::Http, None, "example.com", None, b"/~byron/hello");
     assert_eq!(actual, expected);
@@ -33,7 +33,7 @@ fn empty_user_cannot_roundtrip() -> crate::Result {
 }
 
 #[test]
-fn username_and_password() -> crate::Result {
+fn username_and_password() -> gix_error::TestResult {
     let password = test_password(false);
     Ok(assert_url_roundtrip(
         &format!("http://user:{password}@example.com/~byron/hello"),
@@ -42,7 +42,7 @@ fn username_and_password() -> crate::Result {
 }
 
 #[test]
-fn colon_in_username_roundtrips() -> crate::Result {
+fn colon_in_username_roundtrips() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "http://a%3Ab@example.com/",
         url(Scheme::Http, "a:b", "example.com", None, b"/"),
@@ -50,7 +50,7 @@ fn colon_in_username_roundtrips() -> crate::Result {
 }
 
 #[test]
-fn colon_in_password_roundtrips() -> crate::Result {
+fn colon_in_password_roundtrips() -> gix_error::TestResult {
     let password = format!("a:{}", std::process::id());
     Ok(assert_url_roundtrip(
         &format!("http://user:{password}@example.com/"),
@@ -59,7 +59,7 @@ fn colon_in_password_roundtrips() -> crate::Result {
 }
 
 #[test]
-fn username_and_password_and_port() -> crate::Result {
+fn username_and_password_and_port() -> gix_error::TestResult {
     let password = test_password(false);
     Ok(assert_url_roundtrip(
         &format!("http://user:{password}@example.com:8080/~byron/hello"),
@@ -68,7 +68,7 @@ fn username_and_password_and_port() -> crate::Result {
 }
 
 #[test]
-fn username_and_password_with_spaces_and_port() -> crate::Result {
+fn username_and_password_with_spaces_and_port() -> gix_error::TestResult {
     let expected = gix_url::Url::from_parts(
         Scheme::Http,
         Some("user name".into()),
@@ -88,7 +88,7 @@ fn username_and_password_with_spaces_and_port() -> crate::Result {
 }
 
 #[test]
-fn only_password() -> crate::Result {
+fn only_password() -> gix_error::TestResult {
     let password = test_password(false);
     Ok(assert_url_roundtrip(
         &format!("http://:{password}@example.com/~byron/hello"),
@@ -97,7 +97,7 @@ fn only_password() -> crate::Result {
 }
 
 #[test]
-fn username_and_empty_password() -> crate::Result {
+fn username_and_empty_password() -> gix_error::TestResult {
     let actual = gix_url::parse("http://user:@example.com/~byron/hello")?;
     let expected = url(Scheme::Http, "user", "example.com", None, b"/~byron/hello");
     assert_eq!(actual, expected);
@@ -110,7 +110,7 @@ fn username_and_empty_password() -> crate::Result {
 }
 
 #[test]
-fn secure() -> crate::Result {
+fn secure() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "https://github.com/byron/gitoxide",
         url(Scheme::Https, None, "github.com", None, b"/byron/gitoxide"),
@@ -118,14 +118,14 @@ fn secure() -> crate::Result {
 }
 
 #[test]
-fn http_missing_path() -> crate::Result {
+fn http_missing_path() -> gix_error::TestResult {
     assert_url_roundtrip("http://host.xz/", url(Scheme::Http, None, "host.xz", None, b"/"))?;
     assert_url("http://host.xz", url(Scheme::Http, None, "host.xz", None, b"/"))?;
     Ok(())
 }
 
 #[test]
-fn username_with_dot_is_not_percent_encoded() -> crate::Result {
+fn username_with_dot_is_not_percent_encoded() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "http://user.name@example.com/repo",
         url(Scheme::Http, "user.name", "example.com", None, b"/repo"),
@@ -133,7 +133,7 @@ fn username_with_dot_is_not_percent_encoded() -> crate::Result {
 }
 
 #[test]
-fn password_with_dot_is_not_percent_encoded() -> crate::Result {
+fn password_with_dot_is_not_percent_encoded() -> gix_error::TestResult {
     let password = test_password(true);
     Ok(assert_url_roundtrip(
         &format!("http://user:{password}@example.com/repo"),
@@ -142,7 +142,7 @@ fn password_with_dot_is_not_percent_encoded() -> crate::Result {
 }
 
 #[test]
-fn username_and_password_with_dots_are_not_percent_encoded() -> crate::Result {
+fn username_and_password_with_dots_are_not_percent_encoded() -> gix_error::TestResult {
     let password = test_password(true);
     Ok(assert_url_roundtrip(
         &format!("http://user.name:{password}@example.com/repo"),
@@ -151,7 +151,7 @@ fn username_and_password_with_dots_are_not_percent_encoded() -> crate::Result {
 }
 
 #[test]
-fn http_with_ipv6() -> crate::Result {
+fn http_with_ipv6() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "http://[::1]/repo",
         url(Scheme::Http, None, "[::1]", None, b"/repo"),
@@ -159,7 +159,7 @@ fn http_with_ipv6() -> crate::Result {
 }
 
 #[test]
-fn http_with_ipv6_and_port() -> crate::Result {
+fn http_with_ipv6_and_port() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "http://[::1]:8080/repo",
         url(Scheme::Http, None, "[::1]", 8080, b"/repo"),
@@ -167,7 +167,7 @@ fn http_with_ipv6_and_port() -> crate::Result {
 }
 
 #[test]
-fn https_with_ipv6_user_and_port() -> crate::Result {
+fn https_with_ipv6_user_and_port() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "https://user@[2001:db8::1]:8443/repo",
         url(Scheme::Https, "user", "[2001:db8::1]", 8443, b"/repo"),
@@ -175,7 +175,7 @@ fn https_with_ipv6_user_and_port() -> crate::Result {
 }
 
 #[test]
-fn percent_encoded_path() -> crate::Result {
+fn percent_encoded_path() -> gix_error::TestResult {
     let url = gix_url::parse("https://example.com/path/with%20spaces/file")?;
     assert_eq!(url.path, "/path/with spaces/file", "paths are now decoded");
     assert_eq!(
@@ -187,14 +187,14 @@ fn percent_encoded_path() -> crate::Result {
 }
 
 #[test]
-fn percent_encoded_international_path() -> crate::Result {
+fn percent_encoded_international_path() -> gix_error::TestResult {
     let url = gix_url::parse("https://example.com/caf%C3%A9")?;
     assert_eq!(url.path, "/café", "international characters are decoded in path");
     Ok(())
 }
 
 #[test]
-fn original_path_preserves_exact_spelling() -> crate::Result {
+fn original_path_preserves_exact_spelling() -> gix_error::TestResult {
     for (input, decoded_path, original_path, message) in [
         (
             "https://example.com/plain",
@@ -230,7 +230,7 @@ fn original_path_preserves_exact_spelling() -> crate::Result {
 }
 
 #[test]
-fn reserved_percent_encoded_path_octets_remain_lossless() -> crate::Result {
+fn reserved_percent_encoded_path_octets_remain_lossless() -> gix_error::TestResult {
     for (input, expected_path, message) in [
         (
             "https://example.com/a%2Fb",
@@ -261,7 +261,7 @@ fn reserved_percent_encoded_path_octets_remain_lossless() -> crate::Result {
 }
 
 #[test]
-fn literal_percent_escape_text_from_parts_is_encoded() -> crate::Result {
+fn literal_percent_escape_text_from_parts_is_encoded() -> gix_error::TestResult {
     let url = gix_url::Url::from_parts(
         Scheme::Https,
         None,
@@ -305,7 +305,7 @@ fn literal_percent_escape_text_from_parts_is_encoded() -> crate::Result {
 }
 
 #[test]
-fn percent_encoded_path_roundtrips_in_lossless_serialization() -> crate::Result {
+fn percent_encoded_path_roundtrips_in_lossless_serialization() -> gix_error::TestResult {
     for (input, message, expected_host, expected_path) in [
         (
             "https://%20@%40.example.org/%20%25",
@@ -331,7 +331,7 @@ fn percent_encoded_path_roundtrips_in_lossless_serialization() -> crate::Result
 }
 
 #[test]
-fn query_and_fragment_delimiters_in_path_roundtrip() -> crate::Result {
+fn query_and_fragment_delimiters_in_path_roundtrip() -> gix_error::TestResult {
     assert_url_roundtrip(
         "https://host/repo.git?token=abc",
         url(Scheme::Https, None, "host", None, b"/repo.git?token=abc"),
@@ -344,7 +344,7 @@ fn query_and_fragment_delimiters_in_path_roundtrip() -> crate::Result {
 }
 
 #[test]
-fn query_and_fragment_delimiters_end_the_authority() -> crate::Result {
+fn query_and_fragment_delimiters_end_the_authority() -> gix_error::TestResult {
     for input in ["https://host?@redirected/repo", "https://host#@redirected/repo"] {
         let url = gix_url::parse(input)?;
         assert_eq!(url.host(), Some("host"), "the authority ends at the delimiter");
@@ -366,7 +366,7 @@ fn query_and_fragment_delimiters_end_the_authority() -> crate::Result {
 }
 
 #[test]
-fn authority_length_limit_excludes_the_scheme_separator() -> crate::Result {
+fn authority_length_limit_excludes_the_scheme_separator() -> gix_error::TestResult {
     let at_limit = format!("https://{}", "a".repeat(1024));
     assert_eq!(
         gix_url::parse(&at_limit)?.host().map(str::len),
@@ -374,12 +374,8 @@ fn authority_length_limit_excludes_the_scheme_separator() -> crate::Result {
         "the full authority limit is accepted"
     );
     let over_limit = format!("https://{}", "a".repeat(1025));
-    assert!(
-        gix_url::parse(over_limit)
-            .unwrap_err()
-            .message
-            .contains("host portion of the URL is too long"),
-        "one byte beyond the authority limit is rejected"
-    );
+    insta::assert_debug_snapshot!(gix_url::parse(over_limit)
+            .expect_err("the input must be rejected")
+            , "one byte beyond the authority limit is rejected", @r#"The host portion of the URL is too long (1032 bytes shown, 1033 bytes total), "input"="https://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""#);
     Ok(())
 }
diff --git a/gix-url/tests/url/parse/invalid.rs b/gix-url/tests/url/parse/invalid.rs
index d714a7debd1..6ba35edcd7d 100644
--- a/gix-url/tests/url/parse/invalid.rs
+++ b/gix-url/tests/url/parse/invalid.rs
@@ -1,57 +1,65 @@
 use crate::parse::parse;
 
-fn assert_validation(input: &str, expected_message: &str, has_cause: bool) {
-    let err = parse(input).unwrap_err();
-    assert!(
-        err.message.contains(expected_message),
-        "unexpected validation message for {input:?}: {}",
-        err.message
-    );
+fn assert_validation(input: &str, has_cause: bool) -> gix_error::Exn<gix_error::Message> {
+    let err = parse(input).expect_err("the URL must be rejected");
     assert_eq!(
-        err.input.as_ref().map(|input| input.as_slice()),
-        Some(input.as_bytes()),
+        err.values.get("input"),
+        Some(&gix_error::MetadataValue::from(input.as_bytes())),
         "the rejected URL is retained"
     );
     assert_eq!(err.iter().count() > 1, has_cause, "cause expectation for {input:?}");
+    err
 }
 
 #[test]
 fn relative_path_due_to_double_colon() {
     // Note that a non-empty name before the `::` makes this a remote-helper location instead,
     // as covered by `parse::remote_helper`.
-    assert_validation(":://host.xz/path/to/repo.git/", "can not be parsed as valid URL", true);
+    insta::assert_debug_snapshot!(assert_validation(":://host.xz/path/to/repo.git/", true), "relative path due to double colon", @r#"
+    URL can not be parsed as valid URL, "input"=":://host.xz/path/to/repo.git/"
+    |
+    └─ relative URL without a base
+    "#);
 }
 
 #[test]
 fn ssh_missing_path() {
-    assert_validation("ssh://host.xz", "does not specify a path to a repository", false);
+    insta::assert_debug_snapshot!(assert_validation("ssh://host.xz", false), "ssh missing path", @r#"URL does not specify a path to a repository, "input"="ssh://host.xz""#);
 }
 
 #[test]
 fn git_missing_path() {
-    assert_validation("git://host.xz", "does not specify a path to a repository", false);
+    insta::assert_debug_snapshot!(assert_validation("git://host.xz", false), "git missing path", @r#"URL does not specify a path to a repository, "input"="git://host.xz""#);
 }
 
 #[test]
 fn file_missing_path() {
-    assert_validation("file://", "does not specify a path to a repository", false);
+    insta::assert_debug_snapshot!(assert_validation("file://", false), "file missing path", @r#"URL does not specify a path to a repository, "input"="file://""#);
 }
 
 #[test]
 fn empty_input() {
-    assert_validation("", "does not specify a path to a repository", false);
+    insta::assert_debug_snapshot!(assert_validation("", false), "empty input", @r#"local path is empty and does not specify a path to a repository, "input"="""#);
 }
 
 #[test]
 fn file_missing_host_path_separator() {
+    let mut diagnostics = Vec::new();
     for input in ["file://..", "file://.", "file://a"] {
-        assert_validation(input, "does not specify a path to a repository", false);
+        diagnostics.push(assert_validation(input, false));
     }
+    insta::assert_debug_snapshot!(diagnostics, "file missing host path separator", @r#"
+    [
+        URL does not specify a path to a repository, "input"="file://..",
+        URL does not specify a path to a repository, "input"="file://.",
+        URL does not specify a path to a repository, "input"="file://a",
+    ]
+    "#);
 }
 
 #[test]
 fn missing_port_despite_indication() {
-    assert_validation("ssh://host.xz:", "does not specify a path to a repository", false);
+    insta::assert_debug_snapshot!(assert_validation("ssh://host.xz:", false), "missing port despite indication", @r#"URL does not specify a path to a repository, "input"="ssh://host.xz:""#);
 }
 
 #[test]
@@ -69,6 +77,7 @@ fn port_zero_is_accepted_for_git_compatibility() {
 
 #[test]
 fn textual_and_overflowing_ssh_and_git_ports_are_rejected_despite_git() {
+    let mut diagnostics = Vec::new();
     for input in [
         "ssh://host.xz:abc/path",
         "git://host.xz:abc/path",
@@ -76,75 +85,126 @@ fn textual_and_overflowing_ssh_and_git_ports_are_rejected_despite_git() {
         "ssh://host.xz:99999/path",
         "git://host.xz:65536/path",
     ] {
-        assert_validation(input, "can not be parsed as valid URL", true);
+        diagnostics.push(assert_validation(input, true));
     }
+    insta::assert_debug_snapshot!(diagnostics, "textual and overflowing ssh and git ports are rejected despite git", @r#"
+    [
+        URL can not be parsed as valid URL, "input"="ssh://host.xz:abc/path"
+        |
+        └─ invalid port number - must be between 1-65535,
+        URL can not be parsed as valid URL, "input"="git://host.xz:abc/path"
+        |
+        └─ invalid port number - must be between 1-65535,
+        URL can not be parsed as valid URL, "input"="ssh://host.xz:65536/path"
+        |
+        └─ invalid port number - must be between 1-65535
+        |
+        └─ number too large to fit in target type,
+        URL can not be parsed as valid URL, "input"="ssh://host.xz:99999/path"
+        |
+        └─ invalid port number - must be between 1-65535
+        |
+        └─ number too large to fit in target type,
+        URL can not be parsed as valid URL, "input"="git://host.xz:65536/path"
+        |
+        └─ invalid port number - must be between 1-65535
+        |
+        └─ number too large to fit in target type,
+    ]
+    "#);
 }
 
 #[test]
 fn host_with_space() {
+    let mut diagnostics = Vec::new();
     for input in [
         "http://has a space",
         "http://has a space/path",
         "https://example.com with space/path",
     ] {
-        assert_validation(input, "can not be parsed as valid URL", true);
+        diagnostics.push(assert_validation(input, true));
     }
+    insta::assert_debug_snapshot!(diagnostics, "host with space", @r#"
+    [
+        URL can not be parsed as valid URL, "input"="http://has a space"
+        |
+        └─ invalid domain character,
+        URL can not be parsed as valid URL, "input"="http://has a space/path"
+        |
+        └─ invalid domain character,
+        URL can not be parsed as valid URL, "input"="https://example.com with space/path"
+        |
+        └─ invalid domain character,
+    ]
+    "#);
 }
 
 #[test]
 fn url_with_space_in_path() {
     // Spaces in path should be rejected for http URLs per RFC 3986
-    assert_validation("http://example.com/ path", "can not be parsed as valid URL", true);
+    insta::assert_debug_snapshot!(assert_validation("http://example.com/ path", true), "url with space in path", @r#"
+    URL can not be parsed as valid URL, "input"="http://example.com/ path"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_space_in_username() {
     // Spaces in username should be rejected for http URLs per RFC 3986
-    assert_validation(
-        "http://user name@example.com/path",
-        "can not be parsed as valid URL",
-        true,
-    );
+    insta::assert_debug_snapshot!(assert_validation("http://user name@example.com/path", true), "url with space in username", @r#"
+    URL can not be parsed as valid URL, "input"="http://user name@example.com/path"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_space_in_password() {
     // Spaces in password should be rejected for http URLs per RFC 3986
-    assert_validation(
-        "http://user:pass word@example.com/path",
-        "can not be parsed as valid URL",
-        true,
-    );
+    insta::assert_debug_snapshot!(assert_validation("http://user:pass word@example.com/path", true), "url with space in password", @r#"
+    URL can not be parsed as valid URL, "input"="http://user:pass word@example.com/path"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_tab_in_path() {
     // Tabs in path should be rejected for http URLs per RFC 3986
-    assert_validation("http://example.com/\tpath", "can not be parsed as valid URL", true);
+    insta::assert_debug_snapshot!(assert_validation("http://example.com/\tpath", true), "url with tab in path", @r#"
+    URL can not be parsed as valid URL, "input"="http://example.com/\tpath"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_newline_in_path() {
     // Newlines in path should be rejected for http URLs per RFC 3986
-    assert_validation("http://example.com/\npath", "can not be parsed as valid URL", true);
+    insta::assert_debug_snapshot!(assert_validation("http://example.com/\npath", true), "url with newline in path", @r#"
+    URL can not be parsed as valid URL, "input"="http://example.com/\npath"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_tab_in_username() {
     // Tabs in username should be rejected for http URLs per RFC 3986
-    assert_validation(
-        "http://user\tname@example.com/path",
-        "can not be parsed as valid URL",
-        true,
-    );
+    insta::assert_debug_snapshot!(assert_validation("http://user\tname@example.com/path", true), "url with tab in username", @r#"
+    URL can not be parsed as valid URL, "input"="http://user\tname@example.com/path"
+    |
+    └─ invalid domain character
+    "#);
 }
 
 #[test]
 fn url_with_tab_in_password() {
     // Tabs in password should be rejected for http URLs per RFC 3986
-    assert_validation(
-        "http://user:pass\tword@example.com/path",
-        "can not be parsed as valid URL",
-        true,
-    );
+    insta::assert_debug_snapshot!(assert_validation("http://user:pass\tword@example.com/path", true), "url with tab in password", @r#"
+    URL can not be parsed as valid URL, "input"="http://user:pass\tword@example.com/path"
+    |
+    └─ invalid domain character
+    "#);
 }
diff --git a/gix-url/tests/url/parse/mod.rs b/gix-url/tests/url/parse/mod.rs
index 45d8492b2f8..06efca00475 100644
--- a/gix-url/tests/url/parse/mod.rs
+++ b/gix-url/tests/url/parse/mod.rs
@@ -1,7 +1,8 @@
 use bstr::ByteSlice;
+use gix_error::ExnMessageResult;
 use gix_url::{Scheme, parse, testing::TestUrlExtension};
 
-fn assert_url(url: &str, expected: gix_url::Url) -> Result<gix_url::Url, gix_url::parse::Error> {
+fn assert_url(url: &str, expected: gix_url::Url) -> ExnMessageResult<gix_url::Url> {
     let actual = gix_url::parse(url)?;
     assert_eq!(actual, expected);
     // Note that this must not match on the name, as `Scheme::Helper("http")` is a remote helper.
@@ -18,7 +19,7 @@ fn assert_url(url: &str, expected: gix_url::Url) -> Result<gix_url::Url, gix_url
     Ok(expected)
 }
 
-fn assert_url_roundtrip(url: &str, expected: gix_url::Url) -> Result<(), gix_url::parse::Error> {
+fn assert_url_roundtrip(url: &str, expected: gix_url::Url) -> ExnMessageResult {
     assert_eq!(assert_url(url, expected)?.to_bstring(), url);
     Ok(())
 }
@@ -89,7 +90,7 @@ mod radicle {
     use crate::parse::{assert_url_roundtrip, url};
 
     #[test]
-    fn basic() -> crate::Result {
+    fn basic() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "rad://hynkuwzskprmswzeo4qdtku7grdrs4ffj3g9tjdxomgmjzhtzpqf81@hwd1yregyf1dudqwkx85x5ps3qsrqw3ihxpx3ieopq6ukuuq597p6m8161c.git",
             url(
@@ -110,7 +111,7 @@ mod ports {
     use gix_url::Scheme;
 
     #[test]
-    fn max_valid_port() -> crate::Result {
+    fn max_valid_port() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "ssh://host.xz:65535/repo",
             url(Scheme::Ssh, None, "host.xz", 65535, b"/repo"),
@@ -118,7 +119,7 @@ mod ports {
     }
 
     #[test]
-    fn port_one() -> crate::Result {
+    fn port_one() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "ssh://host.xz:1/repo",
             url(Scheme::Ssh, None, "host.xz", 1, b"/repo"),
@@ -132,7 +133,7 @@ mod git {
     use crate::parse::{assert_url_roundtrip, url};
 
     #[test]
-    fn username_expansion_with_username() -> crate::Result {
+    fn username_expansion_with_username() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "git://example.com/~byron/hello",
             url(Scheme::Git, None, "example.com", None, b"~byron/hello"),
@@ -140,14 +141,14 @@ mod git {
     }
 
     #[test]
-    fn default_port_is_9418() -> crate::Result {
+    fn default_port_is_9418() -> gix_error::TestResult {
         let url = url(Scheme::Git, None, "example.com", None, b"/repo");
         assert_eq!(url.port_or_default(), Some(9418));
         Ok(())
     }
 
     #[test]
-    fn git_with_explicit_port() -> crate::Result {
+    fn git_with_explicit_port() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "git://example.com:1234/repo",
             url(Scheme::Git, None, "example.com", 1234, b"/repo"),
@@ -161,7 +162,7 @@ mod unknown {
     use crate::parse::{assert_url_roundtrip, url};
 
     #[test]
-    fn any_protocol_is_supported_via_a_remote_helper_url() -> crate::Result {
+    fn any_protocol_is_supported_via_a_remote_helper_url() -> gix_error::TestResult {
         Ok(assert_url_roundtrip(
             "abc://example.com/~byron/hello",
             url(
diff --git a/gix-url/tests/url/parse/remote_helper.rs b/gix-url/tests/url/parse/remote_helper.rs
index 90d96b9eda4..72dbb0b63e1 100644
--- a/gix-url/tests/url/parse/remote_helper.rs
+++ b/gix-url/tests/url/parse/remote_helper.rs
@@ -3,7 +3,7 @@ use gix_url::Scheme;
 use crate::parse::{assert_url, assert_url_roundtrip, url_alternate};
 
 #[test]
-fn address_may_contain_a_url() -> crate::Result {
+fn address_may_contain_a_url() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "codecommit::eu-central-1://myaccount@my-repo",
         helper("codecommit", b"eu-central-1://myaccount@my-repo"),
@@ -11,7 +11,7 @@ fn address_may_contain_a_url() -> crate::Result {
 }
 
 #[test]
-fn address_is_not_interpreted() -> crate::Result {
+fn address_is_not_interpreted() -> gix_error::TestResult {
     for (input, name, address) in [
         ("transport::address", "transport", &b"address"[..]),
         ("myhelper::/abs/path", "myhelper", b"/abs/path"),
@@ -29,7 +29,7 @@ fn address_is_not_interpreted() -> crate::Result {
 }
 
 #[test]
-fn ext_commands_are_normalized_and_distinguishable_from_other_helpers() -> crate::Result {
+fn ext_commands_are_normalized_and_distinguishable_from_other_helpers() -> gix_error::TestResult {
     assert_eq!(
         Scheme::from("ext"),
         Scheme::Ext,
@@ -62,14 +62,14 @@ fn ext_commands_are_normalized_and_distinguishable_from_other_helpers() -> crate
 }
 
 #[test]
-fn address_may_be_empty_or_contain_more_separators() -> crate::Result {
+fn address_may_be_empty_or_contain_more_separators() -> gix_error::TestResult {
     assert_url_roundtrip("foo::", helper("foo", b""))?;
     assert_url_roundtrip("foo::a::b", helper("foo", b"a::b"))?;
     Ok(assert_url_roundtrip("a:::b", helper("a", b":b"))?)
 }
 
 #[test]
-fn address_may_be_an_arbitrary_command_line() -> crate::Result {
+fn address_may_be_an_arbitrary_command_line() -> gix_error::TestResult {
     // Helpers can be as flexible as `git-remote-bash` running `eval "$2"`, so nothing about the
     // address may be assumed.
     Ok(assert_url_roundtrip(
@@ -82,7 +82,7 @@ fn address_may_be_an_arbitrary_command_line() -> crate::Result {
 }
 
 #[test]
-fn a_single_letter_name_is_not_a_dos_drive_letter() -> crate::Result {
+fn a_single_letter_name_is_not_a_dos_drive_letter() -> gix_error::TestResult {
     // A DOS drive letter is followed by a single `:`, so these remain remote helpers on all platforms,
     // just like in Git.
     assert_url_roundtrip("c::foo", helper("c", b"foo"))?;
@@ -90,7 +90,7 @@ fn a_single_letter_name_is_not_a_dos_drive_letter() -> crate::Result {
 }
 
 #[test]
-fn helper_names_shadow_built_in_schemes() -> crate::Result {
+fn helper_names_shadow_built_in_schemes() -> gix_error::TestResult {
     for name in ["ssh", "file", "git", "http", "https"] {
         assert_url_roundtrip(&format!("{name}::address"), helper(name, b"address"))?;
     }
@@ -98,7 +98,7 @@ fn helper_names_shadow_built_in_schemes() -> crate::Result {
 }
 
 #[test]
-fn helper_names_are_case_sensitive() -> crate::Result {
+fn helper_names_are_case_sensitive() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "CodeCommit::address",
         helper("CodeCommit", b"address"),
@@ -106,7 +106,7 @@ fn helper_names_are_case_sensitive() -> crate::Result {
 }
 
 #[test]
-fn helper_names_may_contain_special_characters_and_start_with_a_digit() -> crate::Result {
+fn helper_names_may_contain_special_characters_and_start_with_a_digit() -> gix_error::TestResult {
     for name in ["a1.2+3-4", "9foo", "foo.bar", "foo-bar", "foo+bar"] {
         assert_url_roundtrip(&format!("{name}::address"), helper(name, b"address"))?;
     }
@@ -114,7 +114,7 @@ fn helper_names_may_contain_special_characters_and_start_with_a_digit() -> crate
 }
 
 #[test]
-fn addresses_may_contain_arbitrary_bytes() -> crate::Result {
+fn addresses_may_contain_arbitrary_bytes() -> gix_error::TestResult {
     let url = gix_url::parse(bstr::BStr::new(b"foo::\xff\xfe"))?;
     assert_eq!(url.scheme, Scheme::Helper("foo".into()), "the name is always ASCII");
     assert_eq!(
@@ -131,7 +131,7 @@ fn addresses_may_contain_arbitrary_bytes() -> crate::Result {
 }
 
 #[test]
-fn transport_form_and_url_form_are_distinguishable() -> crate::Result {
+fn transport_form_and_url_form_are_distinguishable() -> gix_error::TestResult {
     let helper_form = assert_url("codecommit::my-repo", helper("codecommit", b"my-repo"))?;
     let url_form = assert_url(
         "codecommit://my-repo",
@@ -162,7 +162,7 @@ fn from_parts_rejects_invalid_helper_names() {
 }
 
 #[test]
-fn helper_form_is_always_retained() -> crate::Result {
+fn helper_form_is_always_retained() -> gix_error::TestResult {
     for alt in [false, true] {
         for input in ["9foo::address", "ssh::address", "foo::address", "ext::address"] {
             let url = gix_url::parse(input)?.with_request_alternate_form(alt);
@@ -183,7 +183,7 @@ mod not_a_remote_helper {
     use crate::parse::{assert_url, url_alternate};
 
     #[test]
-    fn names_with_characters_git_does_not_accept() -> crate::Result {
+    fn names_with_characters_git_does_not_accept() -> gix_error::TestResult {
         // `_` and `%` are not part of `[A-Za-z0-9][A-Za-z0-9+.-]*`, so Git falls back to SCP-like syntax.
         for (input, host, path) in [("foo_bar::baz", "foo_bar", &b":baz"[..]), ("f%o::bar", "f%o", b":bar")] {
             assert_url(input, url_alternate(Scheme::Ssh, None, host, None, path))?;
@@ -192,7 +192,7 @@ mod not_a_remote_helper {
     }
 
     #[test]
-    fn names_that_do_not_start_with_an_alphanumeric_character() -> crate::Result {
+    fn names_that_do_not_start_with_an_alphanumeric_character() -> gix_error::TestResult {
         assert_url(".foo::bar", url_alternate(Scheme::Ssh, None, ".foo", None, b":bar"))?;
         assert!(
             gix_url::parse("::bar").is_err(),
@@ -202,7 +202,7 @@ mod not_a_remote_helper {
     }
 
     #[test]
-    fn a_single_colon_does_not_start_an_address() -> crate::Result {
+    fn a_single_colon_does_not_start_an_address() -> gix_error::TestResult {
         // Note that the name is longer than one character on purpose, as a single one would be a DOS
         // drive letter on Windows, which is decided after this and is unrelated to remote helpers.
         assert_url("ab:b::c", url_alternate(Scheme::Ssh, None, "ab", None, b"b::c"))?;
diff --git a/gix-url/tests/url/parse/ssh.rs b/gix-url/tests/url/parse/ssh.rs
index 179327a6075..bc035342dc9 100644
--- a/gix-url/tests/url/parse/ssh.rs
+++ b/gix-url/tests/url/parse/ssh.rs
@@ -3,7 +3,7 @@ use gix_url::Scheme;
 use crate::parse::{assert_url, assert_url_roundtrip, url, url_alternate, url_with_pass};
 
 #[test]
-fn without_user_and_without_port() -> crate::Result {
+fn without_user_and_without_port() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://host.xz/path/to/repo.git/",
         url(Scheme::Ssh, None, "host.xz", None, b"/path/to/repo.git/"),
@@ -11,7 +11,7 @@ fn without_user_and_without_port() -> crate::Result {
 }
 
 #[test]
-fn without_user_and_with_port() -> crate::Result {
+fn without_user_and_with_port() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://host.xz:21/",
         url(Scheme::Ssh, None, "host.xz", 21, b"/"),
@@ -19,7 +19,7 @@ fn without_user_and_with_port() -> crate::Result {
 }
 
 #[test]
-fn host_is_ipv4() -> crate::Result {
+fn host_is_ipv4() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://127.69.0.1/hello",
         url(Scheme::Ssh, None, "127.69.0.1", None, b"/hello"),
@@ -27,7 +27,7 @@ fn host_is_ipv4() -> crate::Result {
 }
 
 #[test]
-fn username_expansion_with_username() -> crate::Result {
+fn username_expansion_with_username() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://example.com/~byron/hello/git",
         url(Scheme::Ssh, None, "example.com", None, b"~byron/hello/git"),
@@ -35,7 +35,7 @@ fn username_expansion_with_username() -> crate::Result {
 }
 
 #[test]
-fn username_expansion_without_username() -> crate::Result {
+fn username_expansion_without_username() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://example.com/~/hello/git",
         url(Scheme::Ssh, None, "example.com", None, b"~/hello/git"),
@@ -43,7 +43,7 @@ fn username_expansion_without_username() -> crate::Result {
 }
 
 #[test]
-fn scp_like_with_ssh_host_alias() -> crate::Result {
+fn scp_like_with_ssh_host_alias() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "user@alias:username/repo.git",
         url_alternate(Scheme::Ssh, "user", "alias", None, b"username/repo.git"),
@@ -51,7 +51,7 @@ fn scp_like_with_ssh_host_alias() -> crate::Result {
 }
 
 #[test]
-fn with_user_and_without_port() -> crate::Result {
+fn with_user_and_without_port() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://user@host.xz/.git",
         url(Scheme::Ssh, "user", "host.xz", None, b"/.git"),
@@ -59,7 +59,7 @@ fn with_user_and_without_port() -> crate::Result {
 }
 
 #[test]
-fn username_with_dot_is_not_percent_encoded() -> crate::Result {
+fn username_with_dot_is_not_percent_encoded() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://user.name@host.xz/.git",
         url(Scheme::Ssh, "user.name", "host.xz", None, b"/.git"),
@@ -67,7 +67,7 @@ fn username_with_dot_is_not_percent_encoded() -> crate::Result {
 }
 
 #[test]
-fn with_user_and_port_and_absolute_path() -> crate::Result {
+fn with_user_and_port_and_absolute_path() -> gix_error::TestResult {
     Ok(assert_url_roundtrip(
         "ssh://user@host.xz:42/.git",
         url(Scheme::Ssh, "user", "host.xz", 42, b"/.git"),
@@ -75,7 +75,7 @@ fn with_user_and_port_and_absolute_path() -> crate::Result {
 }
 
 #[test]
-fn ssh_alias_without_username() -> crate::Result {
+fn ssh_alias_without_username() -> gix_error::TestResult {
     let url = assert_url(
         "host:/path/to/git",
         url_alternate(Scheme::Ssh, None, "host", None, b"/path/to/git"),
@@ -86,14 +86,14 @@ fn ssh_alias_without_username() -> crate::Result {
 }
 
 #[test]
-fn default_port_is_22() -> crate::Result {
+fn default_port_is_22() -> gix_error::TestResult {
     let url = url_alternate(Scheme::Ssh, None, "host.xz", None, b"path/to/git");
     assert_eq!(url.port_or_default(), Some(22));
     Ok(())
 }
 
 #[test]
-fn scp_like_without_user() -> crate::Result {
+fn scp_like_without_user() -> gix_error::TestResult {
     let url = assert_url(
         "host.xz:path/to/git",
         url_alternate(Scheme::Ssh, None, "host.xz", None, b"path/to/git"),
@@ -104,7 +104,7 @@ fn scp_like_without_user() -> crate::Result {
 }
 
 #[test]
-fn scp_like_with_absolute_path() -> crate::Result {
+fn scp_like_with_absolute_path() -> gix_error::TestResult {
     let url = assert_url(
         "host.xz:/path/to/git",
         url_alternate(Scheme::Ssh, None, "host.xz", None, b"/path/to/git"),
@@ -115,7 +115,7 @@ fn scp_like_with_absolute_path() -> crate::Result {
 }
 
 #[test]
-fn scp_like_with_absolute_path_with_whitespace() -> crate::Result {
+fn scp_like_with_absolute_path_with_whitespace() -> gix_error::TestResult {
     let url = assert_url(
         "host.xz:/path/to/git with space",
         url_alternate(Scheme::Ssh, None, "host.xz", None, b"/path/to/git with space"),
@@ -126,7 +126,7 @@ fn scp_like_with_absolute_path_with_whitespace() -> crate::Result {
 }
 
 #[test]
-fn scp_like_without_user_and_username_expansion_without_username() -> crate::Result {
+fn scp_like_without_user_and_username_expansion_without_username() -> gix_error::TestResult {
     let url = assert_url(
         "host.xz:~/to/git",
         url_alternate(Scheme::Ssh, None, "host.xz", None, b"~/to/git"),
@@ -137,7 +137,7 @@ fn scp_like_without_user_and_username_expansion_without_username() -> crate::Res
 }
 
 #[test]
-fn scp_like_without_user_and_username_expansion_with_username() -> crate::Result {
+fn scp_like_without_user_and_username_expansion_with_username() -> gix_error::TestResult {
     let url = assert_url(
         "host.xz:~byron/to/git",
         url_alternate(Scheme::Ssh, None, "host.xz", None, b"~byron/to/git"),
@@ -148,7 +148,7 @@ fn scp_like_without_user_and_username_expansion_with_username() -> crate::Result
 }
 
 #[test]
-fn scp_like_with_user_and_relative_path_keep_relative_path() -> crate::Result {
+fn scp_like_with_user_and_relative_path_keep_relative_path() -> gix_error::TestResult {
     let url = assert_url(
         "user@host.xz:relative",
         url_alternate(Scheme::Ssh, "user", "host.xz", None, b"relative"),
@@ -187,7 +187,7 @@ fn scp_like_with_user_and_relative_path_keep_relative_path() -> crate::Result {
 }
 
 #[test]
-fn canonical_form_is_used_only_if_it_preserves_scp_path_semantics() -> crate::Result {
+fn canonical_form_is_used_only_if_it_preserves_scp_path_semantics() -> gix_error::TestResult {
     assert_eq!(
         gix_url::parse("user@host.xz:relative")?
             .with_request_alternate_form(false)
@@ -222,7 +222,7 @@ fn canonical_form_is_used_only_if_it_preserves_scp_path_semantics() -> crate::Re
 }
 
 #[test]
-fn scp_like_with_windows_path() -> crate::Result {
+fn scp_like_with_windows_path() -> gix_error::TestResult {
     let url = assert_url(
         "user@host.xz:C:/strange/absolute/path",
         url_alternate(Scheme::Ssh, "user", "host.xz", None, b"C:/strange/absolute/path"),
@@ -233,7 +233,7 @@ fn scp_like_with_windows_path() -> crate::Result {
 }
 
 #[test]
-fn scp_like_with_windows_path_and_port_thinks_port_is_part_of_path() -> crate::Result {
+fn scp_like_with_windows_path_and_port_thinks_port_is_part_of_path() -> gix_error::TestResult {
     let url = gix_url::parse("user@host.xz:42:C:/strange/absolute/path")?;
     assert_eq!(
         url.to_bstring(),
@@ -249,7 +249,7 @@ fn scp_like_with_windows_path_and_port_thinks_port_is_part_of_path() -> crate::R
 }
 
 #[test]
-fn scp_like_with_non_alphanumeric_username() -> crate::Result {
+fn scp_like_with_non_alphanumeric_username() -> gix_error::TestResult {
     let url = assert_url(
         "_user.name@host.xz:C:/path",
         url_alternate(Scheme::Ssh, "_user.name", "host.xz", None, b"C:/path"),
@@ -262,7 +262,7 @@ fn scp_like_with_non_alphanumeric_username() -> crate::Result {
 // Git passes the non-path part "user@name@host.xz" to OpenSSH, and the ssh
 // command interprets it as user = "user@name", host = "host.xz".
 #[test]
-fn scp_like_with_username_including_at() -> crate::Result {
+fn scp_like_with_username_including_at() -> gix_error::TestResult {
     let url = assert_url(
         "user@name@host.xz:path",
         url_alternate(Scheme::Ssh, "user@name", "host.xz", None, b"path"),
@@ -273,7 +273,7 @@ fn scp_like_with_username_including_at() -> crate::Result {
 }
 
 #[test]
-fn scp_like_username_with_colon_is_not_mistaken_for_a_password() -> crate::Result {
+fn scp_like_username_with_colon_is_not_mistaken_for_a_password() -> gix_error::TestResult {
     let input = "[:[@]:\x1a";
     let url = gix_url::parse(input)?;
     assert_eq!(url.user(), Some("[:["), "OpenSSH splits user and host at the last @");
@@ -287,14 +287,14 @@ fn scp_like_username_with_colon_is_not_mistaken_for_a_password() -> crate::Resul
 // I btw tested this, yes you can really clone a repository from there, just `git init`
 // in the directory above your home directory on the remote machine.
 #[test]
-fn strange_scp_like_with_host_named_file() -> crate::Result {
+fn strange_scp_like_with_host_named_file() -> gix_error::TestResult {
     let url = assert_url("file:..", url_alternate(Scheme::Ssh, None, "file", None, b".."))?;
     assert_eq!(url.to_bstring(), "file:..");
     Ok(())
 }
 
 #[test]
-fn bad_alternative_form_with_password() -> crate::Result {
+fn bad_alternative_form_with_password() -> gix_error::TestResult {
     let password = std::process::id().to_string();
     let url = url_with_pass(Scheme::Ssh, "user", password.as_str(), "host.xz", None, b"/")
         .with_request_alternate_form(true)
@@ -304,21 +304,21 @@ fn bad_alternative_form_with_password() -> crate::Result {
 }
 
 #[test]
-fn bad_alternative_form_with_port() -> crate::Result {
+fn bad_alternative_form_with_port() -> gix_error::TestResult {
     let url = url_alternate(Scheme::Ssh, None, "host.xz", 21, b"/").to_bstring();
     assert_eq!(url, "ssh://host.xz:21/");
     Ok(())
 }
 
 #[test]
-fn ipv6_address_without_port() -> crate::Result {
+fn ipv6_address_without_port() -> gix_error::TestResult {
     let url = assert_url("ssh://[::1]/repo", url(Scheme::Ssh, None, "::1", None, b"/repo"))?;
     assert_eq!(url.host(), Some("::1"), "brackets are stripped for SSH");
     Ok(())
 }
 
 #[test]
-fn ipv6_address_with_port() -> crate::Result {
+fn ipv6_address_with_port() -> gix_error::TestResult {
     let url = assert_url("ssh://[::1]:22/repo", url(Scheme::Ssh, None, "::1", 22, b"/repo"))?;
     assert_eq!(url.host(), Some("::1"));
     assert_eq!(url.port, Some(22));
@@ -326,7 +326,7 @@ fn ipv6_address_with_port() -> crate::Result {
 }
 
 #[test]
-fn ipv6_address_with_user() -> crate::Result {
+fn ipv6_address_with_user() -> gix_error::TestResult {
     let url = assert_url("ssh://user@[::1]/repo", url(Scheme::Ssh, "user", "::1", None, b"/repo"))?;
     assert_eq!(url.host(), Some("::1"));
     assert_eq!(url.user(), Some("user"));
@@ -334,7 +334,7 @@ fn ipv6_address_with_user() -> crate::Result {
 }
 
 #[test]
-fn ipv6_address_with_user_and_port() -> crate::Result {
+fn ipv6_address_with_user_and_port() -> gix_error::TestResult {
     let url = assert_url(
         "ssh://user@[::1]:22/repo",
         url(Scheme::Ssh, "user", "::1", 22, b"/repo"),
@@ -346,7 +346,7 @@ fn ipv6_address_with_user_and_port() -> crate::Result {
 }
 
 #[test]
-fn ipv6_full_address() -> crate::Result {
+fn ipv6_full_address() -> gix_error::TestResult {
     let url = assert_url(
         "ssh://[2001:db8::1]/repo",
         url(Scheme::Ssh, None, "2001:db8::1", None, b"/repo"),
@@ -356,7 +356,7 @@ fn ipv6_full_address() -> crate::Result {
 }
 
 #[test]
-fn scoped_ipv6_address() -> crate::Result {
+fn scoped_ipv6_address() -> gix_error::TestResult {
     let input = "ssh://[fe80::1%25Eth0]/repo";
     let url = gix_url::parse(input)?;
     assert_eq!(
@@ -370,7 +370,7 @@ fn scoped_ipv6_address() -> crate::Result {
 }
 
 #[test]
-fn scp_like_scoped_ipv6_address_uses_a_raw_zone_separator() -> crate::Result {
+fn scp_like_scoped_ipv6_address_uses_a_raw_zone_separator() -> gix_error::TestResult {
     let input = "[fe80::1%Eth0]:repo";
     let url = gix_url::parse(input)?;
     assert_eq!(url.host(), Some("fe80::1%Eth0"), "the raw percent sign is host data");
@@ -384,7 +384,7 @@ fn scp_like_scoped_ipv6_address_uses_a_raw_zone_separator() -> crate::Result {
 }
 
 #[test]
-fn scoped_ipv6_address_with_empty_port() -> crate::Result {
+fn scoped_ipv6_address_with_empty_port() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://[fe80::1%25Eth0]:/repo")?;
     assert_eq!(
         url.host(),
@@ -401,7 +401,7 @@ fn scoped_ipv6_address_with_empty_port() -> crate::Result {
 }
 
 #[test]
-fn bracketed_host_is_percent_decoded_once() -> crate::Result {
+fn bracketed_host_is_percent_decoded_once() -> gix_error::TestResult {
     let url = gix_url::parse("ssh://[::81ssssssssssssssssssssssssssssssssssssss%2585]:/00%2585]://")?;
     assert_eq!(
         url.host(),
@@ -413,7 +413,7 @@ fn bracketed_host_is_percent_decoded_once() -> crate::Result {
 }
 
 #[test]
-fn escaped_authority_delimiters_remain_host_data() -> crate::Result {
+fn escaped_authority_delimiters_remain_host_data() -> gix_error::TestResult {
     for (input, expected_host) in [
         ("ssh://host%3A123/repo", "host:123"),
         ("ssh://host%2Fname/repo", "host/name"),
@@ -439,7 +439,7 @@ fn escaped_authority_delimiters_remain_host_data() -> crate::Result {
 }
 
 #[test]
-fn percent_encoded_paths_are_decoded_and_the_original_is_retained() -> crate::Result {
+fn percent_encoded_paths_are_decoded_and_the_original_is_retained() -> gix_error::TestResult {
     for (input, decoded_path, original_path, message) in [
         (
             "ssh://example.com/a%2Fb",
@@ -463,14 +463,14 @@ fn percent_encoded_paths_are_decoded_and_the_original_is_retained() -> crate::Re
 }
 
 #[test]
-fn ipv6_address_scp_like() -> crate::Result {
+fn ipv6_address_scp_like() -> gix_error::TestResult {
     let url = assert_url("[::1]:repo", url_alternate(Scheme::Ssh, None, "::1", None, b"repo"))?;
     assert_eq!(url.host(), Some("::1"), "SCP-like format with IPv6");
     Ok(())
 }
 
 #[test]
-fn ipv6_address_scp_like_with_user() -> crate::Result {
+fn ipv6_address_scp_like_with_user() -> gix_error::TestResult {
     let result = gix_url::parse("user@[::1]:repo");
     assert!(
         result.is_err(),
diff --git a/gix-validate/Cargo.toml b/gix-validate/Cargo.toml
index d841a29de7e..cc0108dce75 100644
--- a/gix-validate/Cargo.toml
+++ b/gix-validate/Cargo.toml
@@ -16,7 +16,10 @@ doctest = true
 test = true
 
 [dependencies]
+gix-error = { version = "^0.3.0", path = "../gix-error" }
+
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools", default-features = false }
+insta = "1.46.3"
+gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1"] }
diff --git a/gix-validate/src/lib.rs b/gix-validate/src/lib.rs
index e5bd6a1a31e..66cdd005f31 100644
--- a/gix-validate/src/lib.rs
+++ b/gix-validate/src/lib.rs
@@ -1,5 +1,10 @@
 //! Validation for various kinds of git related items.
 //!
+//! Errors expose a classification-only [`gix_error::ClassificationMarker`] source.
+//! Use [`gix_error::classify()`] or `is_validation()` on [`gix_error::Exn`] and [`gix_error::Error`] to check the
+//! classification, without depending on the concrete diagnostic type. The concrete validation
+//! error remains available for downcasting and probable-cause selection.
+//!
 //! ## Examples
 //!
 //! ```
diff --git a/gix-validate/src/path.rs b/gix-validate/src/path.rs
index 1f5541d6c5f..9ecb33b8420 100644
--- a/gix-validate/src/path.rs
+++ b/gix-validate/src/path.rs
@@ -37,7 +37,11 @@ pub mod component {
         }
     }
 
-    impl std::error::Error for Error {}
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(const { &gix_error::ClassificationMarker::VALIDATION })
+        }
+    }
 
     /// Further specify what to check for in [`component()`](super::component())
     ///
diff --git a/gix-validate/src/reference.rs b/gix-validate/src/reference.rs
index 29c6e1a2ead..1fad7adce3d 100644
--- a/gix-validate/src/reference.rs
+++ b/gix-validate/src/reference.rs
@@ -45,7 +45,11 @@ pub mod name {
         }
     }
 
-    impl std::error::Error for Error {}
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(const { &gix_error::ClassificationMarker::VALIDATION })
+        }
+    }
 
     impl From<crate::tag::name::Error> for Error {
         fn from(err: crate::tag::name::Error) -> Self {
diff --git a/gix-validate/src/submodule.rs b/gix-validate/src/submodule.rs
index 70053d59631..639a3c4b77b 100644
--- a/gix-validate/src/submodule.rs
+++ b/gix-validate/src/submodule.rs
@@ -20,7 +20,11 @@ pub mod name {
         }
     }
 
-    impl std::error::Error for Error {}
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(const { &gix_error::ClassificationMarker::VALIDATION })
+        }
+    }
 }
 
 /// Return the original `name` if it is valid, or the respective error indicating what was wrong with it.
diff --git a/gix-validate/src/tag.rs b/gix-validate/src/tag.rs
index 9c78fa52b8d..737992a591c 100644
--- a/gix-validate/src/tag.rs
+++ b/gix-validate/src/tag.rs
@@ -46,7 +46,11 @@ pub mod name {
         }
     }
 
-    impl std::error::Error for Error {}
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(const { &gix_error::ClassificationMarker::VALIDATION })
+        }
+    }
 }
 
 /// Assure the given `input` resemble a valid git tag name, which is returned unchanged on success.
diff --git a/gix-validate/tests/validate/main.rs b/gix-validate/tests/validate/main.rs
index d1951c3d159..f1b2ae07bea 100644
--- a/gix-validate/tests/validate/main.rs
+++ b/gix-validate/tests/validate/main.rs
@@ -2,3 +2,31 @@ mod path;
 mod reference;
 mod submodule;
 mod tag;
+
+#[test]
+fn invalid_names_retain_their_classification() {
+    use bstr::ByteSlice;
+    use gix_error::ErrorExt;
+
+    fn check<E: std::error::Error + Send + Sync + 'static>(err: E) -> gix_error::Exn {
+        let err = err.raise();
+        assert!(err.is_validation(), "invalid names classify as validation failures");
+        assert!(
+            err.downcast_any_ref::<E>().is_some(),
+            "the concrete validation error remains available "
+        );
+        assert!(
+            err.probable_cause().is::<E>(),
+            "the concrete validation error, not its classification marker, is the probable cause"
+        );
+        err.erased()
+    }
+
+    insta::assert_debug_snapshot!(check(gix_validate::reference::name(b"refs//heads/main".as_bstr()).expect_err("repeated slashes are invalid")), "invalid names identify the rejected syntax", @"Reference name cannot contain repeated slashes");
+    insta::assert_debug_snapshot!(check(gix_validate::tag::name(b"v1..0".as_bstr()).expect_err("repeated dots are invalid")), "invalid names identify the rejected syntax", @"A ref must not contain '..' as it may be mistaken for a range");
+    insta::assert_debug_snapshot!(check(gix_validate::submodule::name(b"../module".as_bstr()).expect_err("parent components are invalid")), "invalid names identify the rejected syntax", @"Submodules names must not contains '..'");
+    insta::assert_debug_snapshot!(check(
+        gix_validate::path::component(b".git".as_bstr(), None, Default::default())
+            .expect_err("the Git directory cannot be a worktree entry"),
+    ), "invalid names identify the rejected syntax", @"The .git name may never be used");
+}
diff --git a/gix-validate/tests/validate/path.rs b/gix-validate/tests/validate/path.rs
index b7eb8cad171..8aa872bd7b6 100644
--- a/gix-validate/tests/validate/path.rs
+++ b/gix-validate/tests/validate/path.rs
@@ -109,171 +109,154 @@ mod component {
         use crate::path::component::{ALL_OPTS, NO_OPTS};
 
         macro_rules! mktest {
-            ($name:ident, $input:expr, $expected:pat) => {
-                mktest!($name, $input, $expected, ALL_OPTS);
+            ($name:ident, $input:expr, $expected:pat, @$snapshot:literal) => {
+                mktest!($name, $input, $expected, ALL_OPTS, @$snapshot);
             };
-            ($name:ident, $input:expr, $expected:pat, $opts:expr) => {
+            ($name:ident, $input:expr, $expected:pat, $opts:expr, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::path::component($input.as_bstr(), None, $opts) {
-                        Err($expected) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::path::component($input.as_bstr(), None, $opts).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid path components retain their specific failure", @$snapshot);
+                    assert!(matches!(err, $expected), "the failure retains its error variant");
                 }
             };
-            ($name:ident, $input:expr, $expected:pat, $mode:expr, $opts:expr) => {
+            ($name:ident, $input:expr, $expected:pat, $mode:expr, $opts:expr, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::path::component($input.as_bstr(), Some($mode), $opts) {
-                        Err($expected) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::path::component($input.as_bstr(), Some($mode), $opts).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid path components retain their specific failure", @$snapshot);
+                    assert!(matches!(err, $expected), "the failure retains its error variant");
                 }
             };
         }
 
-        mktest!(empty, b"", Error::Empty);
-        mktest!(dot_git_lower, b".git", Error::DotGitDir, NO_OPTS);
-        mktest!(dot_git_lower_hfs, ".g\u{200c}it".as_bytes(), Error::DotGitDir);
-        mktest!(dot_git_mixed_hfs_simple, b".Git", Error::DotGitDir);
-        mktest!(dot_git_upper, b".GIT", Error::DotGitDir, NO_OPTS);
+        mktest!(empty, b"", Error::Empty, @"Empty");
+        mktest!(dot_git_lower, b".git", Error::DotGitDir, NO_OPTS, @"DotGitDir");
+        mktest!(dot_git_lower_hfs, ".g\u{200c}it".as_bytes(), Error::DotGitDir, @"DotGitDir");
+        mktest!(dot_git_mixed_hfs_simple, b".Git", Error::DotGitDir, @"DotGitDir");
+        mktest!(dot_git_upper, b".GIT", Error::DotGitDir, NO_OPTS, @"DotGitDir");
         mktest!(
             starts_with_dot_git_with_backslashes_on_windows,
             br".git\hooks\pre-commit",
-            Error::PathSeparator
-        );
-        mktest!(dot_git_upper_hfs, ".GIT\u{200e}".as_bytes(), Error::DotGitDir);
-        mktest!(dot_git_upper_ntfs_8_3, b"GIT~1", Error::DotGitDir);
-        mktest!(dot_git_mixed, b".gIt", Error::DotGitDir, NO_OPTS);
-        mktest!(dot_git_mixed_ntfs_8_3, b"gIt~1", Error::DotGitDir);
+            Error::PathSeparator, @"PathSeparator");
+        mktest!(dot_git_upper_hfs, ".GIT\u{200e}".as_bytes(), Error::DotGitDir, @"DotGitDir");
+        mktest!(dot_git_upper_ntfs_8_3, b"GIT~1", Error::DotGitDir, @"DotGitDir");
+        mktest!(dot_git_mixed, b".gIt", Error::DotGitDir, NO_OPTS, @"DotGitDir");
+        mktest!(dot_git_mixed_ntfs_8_3, b"gIt~1", Error::DotGitDir, @"DotGitDir");
         mktest!(
             dot_gitmodules_mixed,
             b".gItmodules",
             Error::SymlinkedGitModules,
             Symlink,
-            NO_OPTS
-        );
-        mktest!(dot_git_mixed_hfs, "\u{206e}.gIt".as_bytes(), Error::DotGitDir);
+            NO_OPTS, @"SymlinkedGitModules");
+        mktest!(dot_git_mixed_hfs, "\u{206e}.gIt".as_bytes(), Error::DotGitDir, @"DotGitDir");
         mktest!(
             dot_git_ntfs_8_3_numbers_only,
             b"~1000000",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             dot_git_ntfs_8_3_numbers_only_too,
             b"~9999999",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             dot_gitmodules_mixed_hfs,
             "\u{206e}.gItmodules".as_bytes(),
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             dot_gitmodules_mixed_ntfs_8_3,
             b"gItMOD~1",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             dot_gitmodules_mixed_ntfs_stream,
             b".giTmodUles:$DATA",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             dot_gitmodules_lower_ntfs_stream_default_implicit,
             b".gitmodules::$DATA",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             ntfs_stream_default_implicit,
             b"file::$DATA",
-            Error::WindowsIllegalCharacter
-        );
+            Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
         mktest!(
             ntfs_stream_explicit,
             b"file:ANYTHING_REALLY:$DATA",
-            Error::WindowsIllegalCharacter
-        );
+            Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
         mktest!(
             dot_gitmodules_lower_ntfs_stream,
             b".gitmodules:$DATA:$DATA",
             Error::SymlinkedGitModules,
             Symlink,
-            ALL_OPTS
-        );
+            ALL_OPTS, @"SymlinkedGitModules");
         mktest!(
             not_gitmodules_trailing_space,
             b".gitmodules x ",
-            Error::WindowsIllegalCharacter
-        );
+            Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
         mktest!(
             not_gitmodules_trailing_stream,
             b".gitmodules,:$DATA",
-            Error::WindowsIllegalCharacter
-        );
-        mktest!(path_separator_slash_between, b"a/b", Error::PathSeparator);
-        mktest!(path_separator_slash_leading, b"/a", Error::PathSeparator);
-        mktest!(path_separator_slash_trailing, b"a/", Error::PathSeparator);
-        mktest!(path_separator_slash_only, b"/", Error::PathSeparator);
-        mktest!(slashes_on_windows, b"/", Error::PathSeparator, ALL_OPTS);
-        mktest!(backslashes_on_windows, br"\", Error::PathSeparator, ALL_OPTS);
-        mktest!(path_separator_backslash_between, br"a\b", Error::PathSeparator);
-        mktest!(path_separator_backslash_leading, br"\a", Error::PathSeparator);
-        mktest!(path_separator_backslash_trailing, br"a\", Error::PathSeparator);
-        mktest!(aux_mixed, b"Aux", Error::WindowsReservedName);
-        mktest!(aux_with_extension, b"aux.c", Error::WindowsReservedName);
-        mktest!(com_lower, b"com1", Error::WindowsReservedName);
-        mktest!(com_upper_with_extension, b"COM9.c", Error::WindowsReservedName);
-        mktest!(trailing_space, b"win32 ", Error::WindowsIllegalCharacter);
-        mktest!(trailing_dot, b"win32.", Error::WindowsIllegalCharacter);
-        mktest!(trailing_dot_dot, b"win32 . .", Error::WindowsIllegalCharacter);
-        mktest!(colon_inbetween, b"colon:separates", Error::WindowsIllegalCharacter);
-        mktest!(left_arrow, b"arrow<left", Error::WindowsIllegalCharacter);
-        mktest!(right_arrow, b"arrow>right", Error::WindowsIllegalCharacter);
-        mktest!(apostrophe, b"a\"b", Error::WindowsIllegalCharacter);
-        mktest!(pipe, b"a|b", Error::WindowsIllegalCharacter);
-        mktest!(questionmark, b"a?b", Error::WindowsIllegalCharacter);
-        mktest!(asterisk, b"a*b", Error::WindowsIllegalCharacter);
-        mktest!(lpt_mixed_with_number, b"LPt8", Error::WindowsReservedName);
-        mktest!(nul_mixed, b"NuL", Error::WindowsReservedName);
-        mktest!(prn_mixed_with_extension, b"PrN.abc", Error::WindowsReservedName);
-        mktest!(con, b"CON", Error::WindowsReservedName);
-        mktest!(con_with_extension, b"CON.abc", Error::WindowsReservedName);
-        mktest!(con_with_middle, b"CON.tar.xz", Error::WindowsReservedName);
-        mktest!(con_mixed_with_middle, b"coN.tar.xz ", Error::WindowsReservedName);
-        mktest!(dot_dot, b"..", Error::Relative);
-        mktest!(dot_dot_no_opts, b"..", Error::Relative, NO_OPTS);
-        mktest!(single_dot, b".", Error::Relative);
-        mktest!(single_dot_no_opts, b".", Error::Relative, NO_OPTS);
+            Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(path_separator_slash_between, b"a/b", Error::PathSeparator, @"PathSeparator");
+        mktest!(path_separator_slash_leading, b"/a", Error::PathSeparator, @"PathSeparator");
+        mktest!(path_separator_slash_trailing, b"a/", Error::PathSeparator, @"PathSeparator");
+        mktest!(path_separator_slash_only, b"/", Error::PathSeparator, @"PathSeparator");
+        mktest!(slashes_on_windows, b"/", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
+        mktest!(backslashes_on_windows, br"\", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
+        mktest!(path_separator_backslash_between, br"a\b", Error::PathSeparator, @"PathSeparator");
+        mktest!(path_separator_backslash_leading, br"\a", Error::PathSeparator, @"PathSeparator");
+        mktest!(path_separator_backslash_trailing, br"a\", Error::PathSeparator, @"PathSeparator");
+        mktest!(aux_mixed, b"Aux", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(aux_with_extension, b"aux.c", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(com_lower, b"com1", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(com_upper_with_extension, b"COM9.c", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(trailing_space, b"win32 ", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(trailing_dot, b"win32.", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(trailing_dot_dot, b"win32 . .", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(colon_inbetween, b"colon:separates", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(left_arrow, b"arrow<left", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(right_arrow, b"arrow>right", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(apostrophe, b"a\"b", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(pipe, b"a|b", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(questionmark, b"a?b", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(asterisk, b"a*b", Error::WindowsIllegalCharacter, @"WindowsIllegalCharacter");
+        mktest!(lpt_mixed_with_number, b"LPt8", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(nul_mixed, b"NuL", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(prn_mixed_with_extension, b"PrN.abc", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(con, b"CON", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(con_with_extension, b"CON.abc", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(con_with_middle, b"CON.tar.xz", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(con_mixed_with_middle, b"coN.tar.xz ", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(dot_dot, b"..", Error::Relative, @"Relative");
+        mktest!(dot_dot_no_opts, b"..", Error::Relative, NO_OPTS, @"Relative");
+        mktest!(single_dot, b".", Error::Relative, @"Relative");
+        mktest!(single_dot_no_opts, b".", Error::Relative, NO_OPTS, @"Relative");
         mktest!(
             conout_mixed_with_extension,
             b"ConOut$  .xyz",
-            Error::WindowsReservedName
-        );
-        mktest!(conin_mixed, b"conIn$  ", Error::WindowsReservedName);
-        mktest!(drive_letters, b"c:", Error::WindowsPathPrefix, ALL_OPTS);
+            Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(conin_mixed, b"conIn$  ", Error::WindowsReservedName, @"WindowsReservedName");
+        mktest!(drive_letters, b"c:", Error::WindowsPathPrefix, ALL_OPTS, @"WindowsPathPrefix");
         mktest!(
             virtual_drive_letters,
             "֍:".as_bytes(),
             Error::WindowsPathPrefix,
-            ALL_OPTS
-        );
-        mktest!(unc_net_path, br"\\host", Error::PathSeparator, ALL_OPTS);
-        mktest!(unc_path, br"\\?\pictures", Error::PathSeparator, ALL_OPTS);
-        mktest!(unc_device_path, br"\\.\pictures", Error::PathSeparator, ALL_OPTS);
-        mktest!(unc_nt_obj_path, br"\??\pictures", Error::PathSeparator, ALL_OPTS);
+            ALL_OPTS, @"WindowsPathPrefix");
+        mktest!(unc_net_path, br"\\host", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
+        mktest!(unc_path, br"\\?\pictures", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
+        mktest!(unc_device_path, br"\\.\pictures", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
+        mktest!(unc_nt_obj_path, br"\??\pictures", Error::PathSeparator, ALL_OPTS, @"PathSeparator");
 
         #[test]
         fn ntfs_gitmodules() {
diff --git a/gix-validate/tests/validate/reference.rs b/gix-validate/tests/validate/reference.rs
index 9a1c1c35900..8e1b6009705 100644
--- a/gix-validate/tests/validate/reference.rs
+++ b/gix-validate/tests/validate/reference.rs
@@ -86,20 +86,23 @@ mod name_partial {
         use gix_validate::reference::name::Error as RefError;
 
         macro_rules! mktest {
-            ($name:ident, $input:literal, $expected:pat) => {
+            ($name:ident, $input:literal, $expected:pat, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::reference::name_partial($input.as_bstr()) {
-                        Err($expected) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::reference::name_partial($input.as_bstr()).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid reference names retain their specific failure", @$snapshot);
+                    assert!(matches!(err, $expected), "the failure retains its error variant");
                 }
             };
         }
 
-        mktest!(refs_path_double_dot, b"refs/../somewhere", RefError::StartsWithDot);
+        mktest!(refs_path_double_dot, b"refs/../somewhere", RefError::StartsWithDot, @"StartsWithDot");
         mktests!(refs_path_double_dot_san, b"refs/../somewhere", "refs/-/somewhere");
-        mktest!(a_lone_at_sign, b"@", RefError::Reserved { .. });
+        mktest!(a_lone_at_sign, b"@", RefError::Reserved { .. }, @r#"
+        Reserved {
+            name: "@",
+        }
+        "#);
         mktests!(a_lone_at_sign_san, b"@", "-");
         // Sanitizing strips slashes first, so these collapse to a lone `@` and must be replaced
         // as well - otherwise the output wouldn't pass `name_partial()`.
@@ -109,13 +112,11 @@ mod name_partial {
         mktest!(
             refs_path_name_starts_with_dot,
             b".refs/somewhere",
-            RefError::StartsWithDot
-        );
+            RefError::StartsWithDot, @"StartsWithDot");
         mktest!(
             refs_path_name_starts_with_multi_dot,
             b"..refs/somewhere",
-            RefError::RepeatedDot
-        );
+            RefError::RepeatedDot, @"RepeatedDot");
         mktests!(
             refs_path_name_starts_with_multi_dot_san,
             b"..refs/somewhere",
@@ -129,32 +130,33 @@ mod name_partial {
         mktest!(
             refs_path_component_is_singular_dot,
             b"refs/./still-inside-but-not-cool",
-            RefError::StartsWithDot
-        );
+            RefError::StartsWithDot, @"StartsWithDot");
         mktests!(
             refs_path_component_is_singular_dot_san,
             b"refs/./still-inside-but-not-cool",
             "refs/-/still-inside-but-not-cool"
         );
-        mktest!(any_path_starts_with_slash, b"/etc/foo", RefError::StartsWithSlash);
+        mktest!(any_path_starts_with_slash, b"/etc/foo", RefError::StartsWithSlash, @"StartsWithSlash");
         mktests!(any_path_starts_with_slash_san, b"/etc/foo", "etc/foo");
-        mktest!(empty_path, b"", RefError::Empty);
+        mktest!(empty_path, b"", RefError::Empty, @"Empty");
         mktests!(empty_path_san, b"", "-");
-        mktest!(refs_starts_with_slash, b"/refs/heads/main", RefError::StartsWithSlash);
+        mktest!(refs_starts_with_slash, b"/refs/heads/main", RefError::StartsWithSlash, @"StartsWithSlash");
         mktests!(refs_starts_with_slash_san, b"/refs/heads/main", "refs/heads/main");
-        mktest!(ends_with_slash, b"refs/heads/main/", RefError::EndsWithSlash);
+        mktest!(ends_with_slash, b"refs/heads/main/", RefError::EndsWithSlash, @"EndsWithSlash");
         mktests!(ends_with_slash_san, b"refs/heads/main/", "refs/heads/main");
         mktest!(
             path_with_duplicate_slashes,
             b"refs//heads/main",
-            RefError::RepeatedSlash
-        );
+            RefError::RepeatedSlash, @"RepeatedSlash");
         mktests!(path_with_duplicate_slashes_san, b"refs//heads/main", "refs/heads/main");
         mktest!(
             path_with_spaces,
             b"refs/heads/name with spaces",
-            RefError::InvalidByte { .. }
-        );
+            RefError::InvalidByte { .. }, @r#"
+        InvalidByte {
+            byte: " ",
+        }
+        "#);
         mktests!(
             path_with_spaces_san,
             b"refs//heads////name with spaces",
@@ -163,8 +165,11 @@ mod name_partial {
         mktest!(
             path_with_backslashes,
             br"refs\heads/name with spaces",
-            RefError::InvalidByte { .. }
-        );
+            RefError::InvalidByte { .. }, @r#"
+        InvalidByte {
+            byte: "\\",
+        }
+        "#);
         mktests!(
             path_with_backslashes_san,
             br"refs\heads/name with spaces",
@@ -249,26 +254,24 @@ mod name {
         use gix_validate::reference::name::Error as RefError;
 
         macro_rules! mktest {
-            ($name:ident, $input:literal, $expected:pat) => {
+            ($name:ident, $input:literal, $expected:pat, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::reference::name($input.as_bstr()) {
-                        Err($expected) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::reference::name($input.as_bstr()).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid reference names retain their specific failure", @$snapshot);
+                    assert!(matches!(err, $expected), "the failure retains its error variant");
                 }
             };
         }
 
-        mktest!(refs_path_double_dot, b"refs/../somewhere", RefError::StartsWithDot);
+        mktest!(refs_path_double_dot, b"refs/../somewhere", RefError::StartsWithDot, @"StartsWithDot");
         mktests!(refs_path_double_dot_san, b"refs/../somewhere", "refs/-/somewhere");
-        mktest!(refs_name_special_case_upload_pack, b"(null)", RefError::SomeLowercase);
+        mktest!(refs_name_special_case_upload_pack, b"(null)", RefError::SomeLowercase, @"SomeLowercase");
         mktests!(refs_name_special_case_upload_pack_san, b"(null)", "(null)");
         mktest!(
             refs_path_name_starts_with_dot,
             b".refs/somewhere",
-            RefError::StartsWithDot
-        );
+            RefError::StartsWithDot, @"StartsWithDot");
         mktests!(
             refs_path_name_starts_with_dot_san,
             b".refs/somewhere",
@@ -278,8 +281,7 @@ mod name {
         mktest!(
             refs_path_name_starts_with_dot_in_name,
             b"refs/.somewhere",
-            RefError::StartsWithDot
-        );
+            RefError::StartsWithDot, @"StartsWithDot");
         mktests!(
             refs_path_name_starts_with_dot_in_name_san,
             b"refs/.somewhere",
@@ -288,8 +290,7 @@ mod name {
         mktest!(
             refs_path_name_ends_with_dot_in_name,
             b"refs/somewhere.",
-            RefError::EndsWithDot
-        );
+            RefError::EndsWithDot, @"EndsWithDot");
         mktests!(
             refs_path_name_ends_with_dot_in_name_san,
             b"refs/somewhere.",
@@ -298,33 +299,35 @@ mod name {
         mktest!(
             refs_path_component_is_singular_dot,
             b"refs/./still-inside-but-not-cool",
-            RefError::StartsWithDot
-        );
+            RefError::StartsWithDot, @"StartsWithDot");
         mktests!(
             refs_path_component_is_singular_dot_an,
             b"refs/./still-inside-but-not-cool",
             "refs/-/still-inside-but-not-cool"
         );
-        mktest!(a_lone_at_sign, b"@", RefError::Reserved { .. });
-        mktest!(capitalized_name_without_path, b"Main", RefError::SomeLowercase);
+        mktest!(a_lone_at_sign, b"@", RefError::Reserved { .. }, @r#"
+        Reserved {
+            name: "@",
+        }
+        "#);
+        mktest!(capitalized_name_without_path, b"Main", RefError::SomeLowercase, @"SomeLowercase");
         mktests!(capitalized_name_without_path_san, b"Main", "Main");
-        mktest!(lowercase_name_without_path, b"main", RefError::SomeLowercase);
+        mktest!(lowercase_name_without_path, b"main", RefError::SomeLowercase, @"SomeLowercase");
         mktests!(lowercase_name_without_path_san, b"main", "main");
-        mktest!(any_path_starts_with_slash, b"/etc/foo", RefError::StartsWithSlash);
+        mktest!(any_path_starts_with_slash, b"/etc/foo", RefError::StartsWithSlash, @"StartsWithSlash");
         mktests!(any_path_starts_with_slash_san, b"/etc/foo", "etc/foo");
-        mktest!(empty_path, b"", RefError::Empty);
+        mktest!(empty_path, b"", RefError::Empty, @"Empty");
         mktests!(empty_path_san, b"", "-");
-        mktest!(refs_starts_with_slash, b"/refs/heads/main", RefError::StartsWithSlash);
+        mktest!(refs_starts_with_slash, b"/refs/heads/main", RefError::StartsWithSlash, @"StartsWithSlash");
         mktests!(refs_starts_with_slash_san, b"/refs/heads/main", "refs/heads/main");
-        mktest!(ends_with_slash, b"refs/heads/main/", RefError::EndsWithSlash);
+        mktest!(ends_with_slash, b"refs/heads/main/", RefError::EndsWithSlash, @"EndsWithSlash");
         mktests!(ends_with_slash_san, b"refs/heads/main/", "refs/heads/main");
-        mktest!(ends_with_slash_multiple, b"refs/heads/main///", RefError::EndsWithSlash);
+        mktest!(ends_with_slash_multiple, b"refs/heads/main///", RefError::EndsWithSlash, @"EndsWithSlash");
         mktests!(ends_with_slash_multiple_san, b"refs/heads/main///", "refs/heads/main");
         mktest!(
             a_path_with_duplicate_slashes,
             b"refs//heads/main",
-            RefError::RepeatedSlash
-        );
+            RefError::RepeatedSlash, @"RepeatedSlash");
         mktests!(
             a_path_with_duplicate_slashes_san,
             b"refs//heads/main",
@@ -353,18 +356,28 @@ mod branch_name {
 
         #[test]
         fn refs_heads_head_is_reserved() {
-            assert!(matches!(
-                gix_validate::reference::branch_name(b"refs/heads/HEAD".as_bstr()),
-                Err(gix_validate::reference::name::Error::Reserved { name }) if name == "refs/heads/HEAD"
-            ));
+            let failure = gix_validate::reference::branch_name(b"refs/heads/HEAD".as_bstr())
+                .expect_err("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "refs heads head is reserved", @r#"
+            Reserved {
+                name: "refs/heads/HEAD",
+            }
+            "#);
+            assert!(
+                matches!(failure, gix_validate::reference::name::Error::Reserved { name } if name == "refs/heads/HEAD"),
+                "refs heads head is reserved"
+            );
         }
 
         #[test]
         fn invalid_refname_is_wrapped() {
-            assert!(matches!(
-                gix_validate::reference::branch_name(b"refs//heads/main".as_bstr()),
-                Err(gix_validate::reference::name::Error::RepeatedSlash)
-            ));
+            let failure = gix_validate::reference::branch_name(b"refs//heads/main".as_bstr())
+                .expect_err("the operation must fail");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&failure, &[]), "invalid refname is wrapped", @"RepeatedSlash");
+            assert!(
+                matches!(failure, gix_validate::reference::name::Error::RepeatedSlash),
+                "invalid refname is wrapped"
+            );
         }
     }
 }
diff --git a/gix-validate/tests/validate/submodule.rs b/gix-validate/tests/validate/submodule.rs
index 00152b0f9f7..f767488662e 100644
--- a/gix-validate/tests/validate/submodule.rs
+++ b/gix-validate/tests/validate/submodule.rs
@@ -15,44 +15,43 @@ mod invalid {
     use bstr::ByteSlice;
 
     macro_rules! mktest {
-        ($name:ident, $input:literal, $expected:ident) => {
+        ($name:ident, $input:literal, $expected:ident, @$snapshot:literal) => {
             #[test]
             fn $name() {
-                match gix_validate::submodule::name($input.as_bstr()) {
-                    Err(gix_validate::submodule::name::Error::$expected) => {}
-                    got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                }
+                let err = gix_validate::submodule::name($input.as_bstr()).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid submodule names retain their specific failure", @$snapshot);
+                    assert!(matches!(err, gix_validate::submodule::name::Error::$expected), "the failure retains its error variant");
             }
         };
     }
 
-    mktest!(empty, b"", Empty);
-    mktest!(starts_with_parent_component, b"../", ParentComponent);
-    mktest!(parent_component_in_middle, b"hi/../ho", ParentComponent);
-    mktest!(ends_with_parent_component, b"hi/ho/..", ParentComponent);
-    mktest!(only_parent_component, b"..", ParentComponent);
-    mktest!(starts_with_parent_component_backslash, br"..\", ParentComponent);
-    mktest!(parent_component_in_middle_backslash, br"hi\..\ho", ParentComponent);
-    mktest!(ends_with_parent_component_backslash, br"hi\ho\..", ParentComponent);
+    mktest!(empty, b"", Empty, @"Empty");
+    mktest!(starts_with_parent_component, b"../", ParentComponent, @"ParentComponent");
+    mktest!(parent_component_in_middle, b"hi/../ho", ParentComponent, @"ParentComponent");
+    mktest!(ends_with_parent_component, b"hi/ho/..", ParentComponent, @"ParentComponent");
+    mktest!(only_parent_component, b"..", ParentComponent, @"ParentComponent");
+    mktest!(starts_with_parent_component_backslash, br"..\", ParentComponent, @"ParentComponent");
+    mktest!(parent_component_in_middle_backslash, br"hi\..\ho", ParentComponent, @"ParentComponent");
+    mktest!(ends_with_parent_component_backslash, br"hi\ho\..", ParentComponent, @"ParentComponent");
 
     /// Reproducer for GHSA-p3hw-mv63-rf9w: a crafted submodule name can place a harmless `..`
     /// first and a real `../` traversal later, so validators that only inspect the first match
     /// accept a name that still escapes `.git/modules`.
     #[test]
     fn traversal_after_a_benign_double_dot_is_rejected() {
-        match gix_validate::submodule::name(b"a..b/../../../.git/".as_bstr()) {
-            Err(gix_validate::submodule::name::Error::ParentComponent) => {}
-            got => panic!("Wanted ParentComponent, got {got:?}"),
-        }
+        let err = gix_validate::submodule::name(b"a..b/../../../.git/".as_bstr())
+            .expect_err("the submodule name escapes its parent");
+        insta::assert_debug_snapshot!(err, "parent traversal remains invalid after a benign pair of dots", @"ParentComponent");
+        assert!(matches!(err, gix_validate::submodule::name::Error::ParentComponent));
     }
 
     /// Reproducer for GHSA-p3hw-mv63-rf9w: the same first-match bypass also applies to
     /// Windows-style separators.
     #[test]
     fn backslash_traversal_after_a_benign_double_dot_is_rejected() {
-        match gix_validate::submodule::name(br"a..b\..\..\..\.git\".as_bstr()) {
-            Err(gix_validate::submodule::name::Error::ParentComponent) => {}
-            got => panic!("Wanted ParentComponent, got {got:?}"),
-        }
+        let err = gix_validate::submodule::name(br"a..b\..\..\..\.git\".as_bstr())
+            .expect_err("the submodule name escapes its parent");
+        insta::assert_debug_snapshot!(err, "parent traversal remains invalid after a benign pair of dots", @"ParentComponent");
+        assert!(matches!(err, gix_validate::submodule::name::Error::ParentComponent));
     }
 }
diff --git a/gix-validate/tests/validate/tag.rs b/gix-validate/tests/validate/tag.rs
index c9be2e221ba..7bda0ce27a9 100644
--- a/gix-validate/tests/validate/tag.rs
+++ b/gix-validate/tests/validate/tag.rs
@@ -51,46 +51,44 @@ mod name {
         use bstr::ByteSlice;
 
         macro_rules! mktest {
-            ($name:ident, $input:literal, $expected:ident) => {
+            ($name:ident, $input:literal, $expected:ident, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::tag::name($input.as_bstr()) {
-                        Err(gix_validate::tag::name::Error::$expected) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::tag::name($input.as_bstr()).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid tag names retain their specific failure", @$snapshot);
+                    assert!(matches!(err, gix_validate::tag::name::Error::$expected), "the failure retains its error variant");
                 }
             };
         }
         macro_rules! mktestb {
-            ($name:ident, $input:literal) => {
+            ($name:ident, $input:literal, @$snapshot:literal) => {
                 #[test]
                 fn $name() {
-                    match gix_validate::tag::name($input.as_bstr()) {
-                        Err(gix_validate::tag::name::Error::InvalidByte { .. }) => {}
-                        got => panic!("Wanted {}, got {:?}", stringify!($expected), got),
-                    }
+                    let err = gix_validate::tag::name($input.as_bstr()).expect_err("the input is invalid");
+                    insta::assert_debug_snapshot!(err, "invalid tag names retain their specific failure", @$snapshot);
+                    assert!(matches!(err, gix_validate::tag::name::Error::InvalidByte { .. }), "the failure retains its error variant");
                 }
             };
         }
-        mktest!(contains_ref_log_portion, b"this_looks_like_a_@{reflog}", ReflogPortion);
+        mktest!(contains_ref_log_portion, b"this_looks_like_a_@{reflog}", ReflogPortion, @"ReflogPortion");
         mktests!(
             contains_ref_log_portion_san,
             b"this_looks_like_a_@{reflog}",
             "this_looks_like_a_@-reflog}"
         );
-        mktest!(suffix_is_dot_lock, b"prefix.lock", LockFileSuffix);
-        mktest!(too_many_dots, b"......", RepeatedDot);
+        mktest!(suffix_is_dot_lock, b"prefix.lock", LockFileSuffix, @"LockFileSuffix");
+        mktest!(too_many_dots, b"......", RepeatedDot, @"RepeatedDot");
         mktests!(too_many_dots_san, b"......", "-");
         mktests!(too_many_dots_and_slashes_san, b"//....///....///", "-/-");
         mktests!(suffix_is_dot_lock_san, b"prefix.lock", "prefix");
-        mktest!(suffix_is_dot_lock_multiple, b"prefix.lock.lock", LockFileSuffix);
+        mktest!(suffix_is_dot_lock_multiple, b"prefix.lock.lock", LockFileSuffix, @"LockFileSuffix");
         mktests!(suffix_is_dot_lock_multiple_san, b"prefix.lock.lock", "prefix");
-        mktest!(ends_with_slash, b"prefix/", EndsWithSlash);
-        mktest!(empty_component, b"prefix//suffix", RepeatedSlash);
+        mktest!(ends_with_slash, b"prefix/", EndsWithSlash, @"EndsWithSlash");
+        mktest!(empty_component, b"prefix//suffix", RepeatedSlash, @"RepeatedSlash");
         mktests!(empty_component_san, b"prefix//suffix", "prefix/suffix");
         mktests!(ends_with_slash_san, b"prefix/", "prefix");
-        mktest!(is_dot_lock, b".lock", StartsWithDot);
-        mktest!(dot_lock_in_component, b"foo.lock/baz.lock/bar", LockFileSuffix);
+        mktest!(is_dot_lock, b".lock", StartsWithDot, @"StartsWithDot");
+        mktest!(dot_lock_in_component, b"foo.lock/baz.lock/bar", LockFileSuffix, @"LockFileSuffix");
         mktests!(dot_lock_in_component_san, b"foo.lock/baz.lock/bar", "foo/baz/bar");
         mktests!(
             dot_lock_in_each_component_san,
@@ -108,59 +106,127 @@ mod name {
             "-lock/lock"
         );
         mktests!(is_dot_lock_san, b".lock", "-lock");
-        mktest!(contains_double_dot, b"with..double-dot", RepeatedDot);
+        mktest!(contains_double_dot, b"with..double-dot", RepeatedDot, @"RepeatedDot");
         mktests!(contains_double_dot_san, b"with..double-dot", "with.double-dot");
-        mktest!(starts_with_double_dot, b"..with-double-dot", RepeatedDot);
+        mktest!(starts_with_double_dot, b"..with-double-dot", RepeatedDot, @"RepeatedDot");
         mktests!(starts_with_double_dot_san, b"..with-double-dot", "-with-double-dot");
-        mktest!(ends_with_double_dot, b"with-double-dot..", RepeatedDot);
+        mktest!(ends_with_double_dot, b"with-double-dot..", RepeatedDot, @"RepeatedDot");
         mktests!(ends_with_double_dot_san, b"with-double-dot..", "with-double-dot-");
-        mktest!(starts_with_asterisk, b"*suffix", Asterisk);
+        mktest!(starts_with_asterisk, b"*suffix", Asterisk, @"Asterisk");
         mktests!(starts_with_asterisk_san, b"*suffix", "-suffix");
-        mktest!(starts_with_slash, b"/suffix", StartsWithSlash);
+        mktest!(starts_with_slash, b"/suffix", StartsWithSlash, @"StartsWithSlash");
         mktests!(starts_with_slash_san, b"/suffix", "suffix");
-        mktest!(ends_with_asterisk, b"prefix*", Asterisk);
+        mktest!(ends_with_asterisk, b"prefix*", Asterisk, @"Asterisk");
         mktests!(ends_with_asterisk_san, b"prefix*", "prefix-");
-        mktest!(contains_asterisk, b"prefix*suffix", Asterisk);
+        mktest!(contains_asterisk, b"prefix*suffix", Asterisk, @"Asterisk");
         mktests!(contains_asterisk_san, b"prefix*suffix", "prefix-suffix");
-        mktestb!(contains_null, b"prefix\0suffix");
+        mktestb!(contains_null, b"prefix\0suffix", @r#"
+        InvalidByte {
+            byte: "\0",
+        }
+        "#);
         mktests!(contains_null_san, b"prefix\0suffix", "prefix-suffix");
-        mktestb!(contains_bell, b"prefix\x07suffix");
+        mktestb!(contains_bell, b"prefix\x07suffix", @r#"
+        InvalidByte {
+            byte: "\x07",
+        }
+        "#);
         mktests!(contains_bell_san, b"prefix\x07suffix", "prefix-suffix");
-        mktestb!(contains_backspace, b"prefix\x08suffix");
+        mktestb!(contains_backspace, b"prefix\x08suffix", @r#"
+        InvalidByte {
+            byte: "\x08",
+        }
+        "#);
         mktests!(contains_backspace_san, b"prefix\x08suffix", "prefix-suffix");
-        mktestb!(contains_vertical_tab, b"prefix\x0bsuffix");
+        mktestb!(contains_vertical_tab, b"prefix\x0bsuffix", @r#"
+        InvalidByte {
+            byte: "\x0b",
+        }
+        "#);
         mktests!(contains_vertical_tab_san, b"prefix\x0bsuffix", "prefix-suffix");
-        mktestb!(contains_form_feed, b"prefix\x0csuffix");
+        mktestb!(contains_form_feed, b"prefix\x0csuffix", @r#"
+        InvalidByte {
+            byte: "\x0c",
+        }
+        "#);
         mktests!(contains_form_feed_san, b"prefix\x0csuffix", "prefix-suffix");
-        mktestb!(contains_ctrl_z, b"prefix\x1asuffix");
+        mktestb!(contains_ctrl_z, b"prefix\x1asuffix", @r#"
+        InvalidByte {
+            byte: "\x1a",
+        }
+        "#);
         mktests!(contains_ctrl_z_san, b"prefix\x1asuffix", "prefix-suffix");
-        mktestb!(contains_esc, b"prefix\x1bsuffix");
+        mktestb!(contains_esc, b"prefix\x1bsuffix", @r#"
+        InvalidByte {
+            byte: "\x1b",
+        }
+        "#);
         mktests!(contains_esc_san, b"prefix\x1bsuffix", "prefix-suffix");
-        mktestb!(contains_colon, b"prefix:suffix");
+        mktestb!(contains_colon, b"prefix:suffix", @r#"
+        InvalidByte {
+            byte: ":",
+        }
+        "#);
         mktests!(contains_colon_san, b"prefix:suffix", "prefix-suffix");
-        mktestb!(contains_questionmark, b"prefix?suffix");
+        mktestb!(contains_questionmark, b"prefix?suffix", @r#"
+        InvalidByte {
+            byte: "?",
+        }
+        "#);
         mktests!(contains_questionmark_san, b"prefix?suffix", "prefix-suffix");
-        mktestb!(contains_open_bracket, b"prefix[suffix");
+        mktestb!(contains_open_bracket, b"prefix[suffix", @r#"
+        InvalidByte {
+            byte: "[",
+        }
+        "#);
         mktests!(contains_open_bracket_san, b"prefix[suffix", "prefix-suffix");
-        mktestb!(contains_backslash, br"prefix\suffix");
+        mktestb!(contains_backslash, br"prefix\suffix", @r#"
+        InvalidByte {
+            byte: "\\",
+        }
+        "#);
         mktests!(contains_backslash_san, br"prefix\suffix", "prefix-suffix");
-        mktestb!(contains_circumflex, b"prefix^suffix");
+        mktestb!(contains_circumflex, b"prefix^suffix", @r#"
+        InvalidByte {
+            byte: "^",
+        }
+        "#);
         mktests!(contains_circumflex_san, b"prefix^suffix", "prefix-suffix");
-        mktestb!(contains_tilde, b"prefix~suffix");
+        mktestb!(contains_tilde, b"prefix~suffix", @r#"
+        InvalidByte {
+            byte: "~",
+        }
+        "#);
         mktests!(contains_tilde_san, b"prefix~suffix", "prefix-suffix");
-        mktestb!(contains_space, b"prefix suffix");
+        mktestb!(contains_space, b"prefix suffix", @r#"
+        InvalidByte {
+            byte: " ",
+        }
+        "#);
         mktests!(contains_space_san, b"prefix suffix", "prefix-suffix");
-        mktestb!(contains_tab, b"prefix\tsuffix");
+        mktestb!(contains_tab, b"prefix\tsuffix", @r#"
+        InvalidByte {
+            byte: "\t",
+        }
+        "#);
         mktests!(contains_tab_san, b"prefix\tsuffix", "prefix-suffix");
-        mktestb!(contains_newline, b"prefix\nsuffix");
+        mktestb!(contains_newline, b"prefix\nsuffix", @r#"
+        InvalidByte {
+            byte: "\n",
+        }
+        "#);
         mktests!(contains_newline_san, b"prefix\nsuffix", "prefix-suffix");
-        mktestb!(contains_carriage_return, b"prefix\rsuffix");
+        mktestb!(contains_carriage_return, b"prefix\rsuffix", @r#"
+        InvalidByte {
+            byte: "\r",
+        }
+        "#);
         mktests!(contains_carriage_return_san, b"prefix\rsuffix", "prefix-suffix");
-        mktest!(starts_with_dot, b".with-dot", StartsWithDot);
+        mktest!(starts_with_dot, b".with-dot", StartsWithDot, @"StartsWithDot");
         mktests!(starts_with_dot_san, b".with-dot", "-with-dot");
-        mktest!(ends_with_dot, b"with-dot.", EndsWithDot);
+        mktest!(ends_with_dot, b"with-dot.", EndsWithDot, @"EndsWithDot");
         mktests!(ends_with_dot_san, b"with-dot.", "with-dot-");
-        mktest!(empty, b"", Empty);
+        mktest!(empty, b"", Empty, @"Empty");
         mktests!(empty_san, b"", "-");
     }
 }
diff --git a/gix-worktree-state/Cargo.toml b/gix-worktree-state/Cargo.toml
index c4d091d9463..3e7dd873abf 100644
--- a/gix-worktree-state/Cargo.toml
+++ b/gix-worktree-state/Cargo.toml
@@ -27,15 +27,16 @@ gix-worktree = { version = "^0.56.0", path = "../gix-worktree", default-features
 gix-index = { version = "^0.55.0", path = "../gix-index" }
 gix-fs = { version = "^0.22.1", path = "../gix-fs" }
 gix-object = { version = "^0.64.1", path = "../gix-object" }
+gix-error = { version = "^0.3.0", path = "../gix-error" }
 gix-path = { version = "^0.12.6", path = "../gix-path" }
 gix-features = { version = "^0.49.1", path = "../gix-features" }
 gix-filter = { version = "^0.34.0", path = "../gix-filter" }
 
 io-close = "0.3.7"
-thiserror = "2.0.18"
 bstr = { version = "1.12.0", default-features = false }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-worktree-state = { path = ".", features = ["sha1", "sha256"] }
 gix-object = { path = "../gix-object" }
 gix-filter = { path = "../gix-filter" }
diff --git a/gix-worktree-state/src/checkout/chunk.rs b/gix-worktree-state/src/checkout/chunk.rs
index 3588bdfbd49..576e75d7d2f 100644
--- a/gix-worktree-state/src/checkout/chunk.rs
+++ b/gix-worktree-state/src/checkout/chunk.rs
@@ -4,22 +4,23 @@ use std::{
 };
 
 use bstr::{BStr, BString};
+use gix_error::{ErrorExt, ExnResult, ResultExt};
 use gix_worktree::Stack;
 
 use crate::{checkout, checkout::entry};
 
 mod reduce {
-    use crate::checkout;
 
+    use gix_error::ExnResult;
     pub struct Reduce<'entry> {
         pub aggregate: super::Outcome<'entry>,
     }
 
     impl<'entry> gix_features::parallel::Reduce for Reduce<'entry> {
-        type Input = Result<super::Outcome<'entry>, checkout::Error>;
+        type Input = ExnResult<super::Outcome<'entry>>;
         type FeedProduce = ();
         type Output = super::Outcome<'entry>;
-        type Error = checkout::Error;
+        type Error = gix_error::Exn;
 
         fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error> {
             let item = item?;
@@ -105,7 +106,7 @@ pub fn process<'entry, Find>(
     bytes: &AtomicUsize,
     delayed_filter_results: &mut Vec<DelayedFilteredStream<'entry>>,
     ctx: &mut Context<Find>,
-) -> Result<Outcome<'entry>, checkout::Error>
+) -> ExnResult<Outcome<'entry>>
 where
     Find: gix_object::Find + Clone,
 {
@@ -160,7 +161,7 @@ pub fn process_delayed_filter_results<Find>(
     bytes: &AtomicUsize,
     out: &mut Outcome<'_>,
     ctx: &mut Context<Find>,
-) -> Result<(), checkout::Error>
+) -> ExnResult
 where
     Find: gix_object::Find + Clone,
 {
@@ -179,7 +180,7 @@ where
     let mut unknown_paths = Vec::new();
     for key in keys {
         loop {
-            let rela_paths = ctx.filters.driver_state_mut().list_delayed_paths(&key)?;
+            let rela_paths = ctx.filters.driver_state_mut().list_delayed_paths(&key).or_erased()?;
             if rela_paths.is_empty() {
                 break;
             }
@@ -192,17 +193,19 @@ where
                             unknown_paths.push(rela_path);
                             continue;
                         } else {
-                            return Err(checkout::Error::FilterPathUnknown { rela_path });
+                            return Err(gix_error::corruption(format!(
+                                "The entry at path '{rela_path}' was listed as delayed by the filter process, but we never passed it"
+                            ))
+                            .raise_erased());
                         }
                     }
                 };
                 let mut read = std::io::BufReader::with_capacity(
                     512 * 1024,
-                    ctx.filters.driver_state_mut().fetch_delayed(
-                        &key,
-                        rela_path.as_ref(),
-                        gix_filter::driver::Operation::Smudge,
-                    )?,
+                    ctx.filters
+                        .driver_state_mut()
+                        .fetch_delayed(&key, rela_path.as_ref(), gix_filter::driver::Operation::Smudge)
+                        .or_erased()?,
                 );
                 let (file, executable_bit_change) = match entry::open_file(
                     &std::mem::take(&mut delayed.validated_file_path), // mark it as seen, relevant for `unprocessed_paths`
@@ -214,9 +217,15 @@ where
                     Ok(res) => res,
                     Err(err) => {
                         if !is_collision(&err, delayed.entry_path, &mut out.collisions, files) {
-                            handle_error(err, delayed.entry_path, files, &mut out.errors, ctx.options.keep_going)?;
+                            handle_error(
+                                err.raise_erased(),
+                                delayed.entry_path,
+                                files,
+                                &mut out.errors,
+                                ctx.options.keep_going,
+                            )?;
                         }
-                        std::io::copy(&mut read, &mut std::io::sink())?;
+                        std::io::copy(&mut read, &mut std::io::sink()).or_erased()?;
                         continue;
                     }
                 };
@@ -224,11 +233,15 @@ where
                     inner: std::io::BufWriter::with_capacity(512 * 1024, file),
                     progress: bytes,
                 };
-                let actual_bytes = std::io::copy(&mut read, &mut write)?;
+                let actual_bytes = std::io::copy(&mut read, &mut write).or_erased()?;
                 bytes_written += actual_bytes;
                 entry::finalize_entry(
                     delayed.entry,
-                    write.inner.into_inner().map_err(std::io::IntoInnerError::into_error)?,
+                    write
+                        .inner
+                        .into_inner()
+                        .map_err(std::io::IntoInnerError::into_error)
+                        .or_erased()?,
                     actual_bytes,
                     executable_bit_change,
                 )?;
@@ -238,15 +251,16 @@ where
         }
     }
 
-    let unprocessed_paths = delayed_filter_results
+    let unprocessed_paths: Vec<BString> = delayed_filter_results
         .into_iter()
         .filter_map(|d| (!d.validated_file_path.as_os_str().is_empty()).then(|| d.entry_path.to_owned()))
         .collect();
 
-    if !keep_going && !unknown_paths.is_empty() {
-        return Err(checkout::Error::FilterPathsUnprocessed {
-            rela_paths: unprocessed_paths,
-        });
+    if !keep_going && !unprocessed_paths.is_empty() {
+        return Err(gix_error::corruption(format!(
+            "The following paths were delayed and apparently forgotten to be processed by the filter driver: {unprocessed_paths:?}"
+        ))
+        .raise_erased());
     }
 
     out.delayed_paths_unknown = unknown_paths;
@@ -291,7 +305,7 @@ pub fn checkout_entry_handle_result<'entry, Find>(
         buf,
         options,
     }: &mut Context<Find>,
-) -> Result<entry::Outcome<'entry>, checkout::Error>
+) -> ExnResult<entry::Outcome<'entry>>
 where
     Find: gix_object::Find + Clone,
 {
@@ -314,7 +328,13 @@ where
             }
             Ok(out)
         }
-        Err(checkout::Error::Io(err)) if is_collision(&err, entry_path, collisions, files) => {
+        Err(err)
+            if err
+                .frame()
+                .error()
+                .downcast_ref::<std::io::Error>()
+                .is_some_and(|err| is_collision(err, entry_path, collisions, files)) =>
+        {
             Ok(entry::Outcome::Written { bytes: 0 })
         }
         Err(err) => handle_error(err, entry_path, files, errors, options.keep_going)
@@ -322,20 +342,17 @@ where
     }
 }
 
-fn handle_error<E>(
-    err: E,
+fn handle_error(
+    err: gix_error::Exn,
     entry_path: &BStr,
     files: &AtomicUsize,
     errors: &mut Vec<checkout::ErrorRecord>,
     keep_going: bool,
-) -> Result<(), E>
-where
-    E: std::error::Error + Send + Sync + 'static,
-{
+) -> ExnResult {
     if keep_going {
         errors.push(checkout::ErrorRecord {
             path: entry_path.into(),
-            error: Box::new(err),
+            error: err.into_error(),
         });
         files.fetch_add(1, Ordering::Relaxed);
         Ok(())
diff --git a/gix-worktree-state/src/checkout/entry.rs b/gix-worktree-state/src/checkout/entry.rs
index 297b90e32cd..691c17d0a3e 100644
--- a/gix-worktree-state/src/checkout/entry.rs
+++ b/gix-worktree-state/src/checkout/entry.rs
@@ -5,6 +5,7 @@ use std::{
 };
 
 use bstr::BStr;
+use gix_error::{ExnResult, ResultExt, message};
 use gix_filter::{
     driver::apply::MaybeDelayed,
     pipeline::convert::{ToWorktreeOutcome, to_worktree},
@@ -55,6 +56,8 @@ impl Outcome<'_> {
     }
 }
 
+/// Check out an entry, retaining invalid path or symlink target bytes as `input`
+/// [metadata](gix_error::Exn::metadata()) if UTF-8 conversion fails.
 #[cfg_attr(not(unix), allow(unused_variables))]
 pub fn checkout<'entry, Find>(
     entry: &'entry mut Entry,
@@ -76,36 +79,39 @@ pub fn checkout<'entry, Find>(
         filter_process_delay,
         ..
     }: crate::checkout::chunk::Options,
-) -> Result<Outcome<'entry>, crate::checkout::Error>
+) -> ExnResult<Outcome<'entry>>
 where
     Find: gix_object::Find,
 {
-    let dest_relative = gix_path::try_from_bstr(entry_path).map_err(|_| crate::checkout::Error::IllformedUtf8 {
-        path: entry_path.to_owned(),
-    })?;
-    let path_cache = path_cache.at_path(dest_relative.as_ref(), Some(entry.mode), &*objects)?;
+    let dest_relative = gix_path::try_from_bstr(entry_path)
+        .or_raise_erased(|| gix_error::validation("Could not convert path to UTF8").with("input", entry_path))?;
+    let path_cache = path_cache
+        .at_path(dest_relative.as_ref(), Some(entry.mode), &*objects)
+        .or_erased()?;
     let dest = path_cache.path();
 
     let object_size = match entry.mode {
         gix_index::entry::Mode::FILE | gix_index::entry::Mode::FILE_EXECUTABLE => {
-            let obj = (*objects)
-                .find_blob(&entry.id, buf)
-                .map_err(|err| crate::checkout::Error::Find {
-                    err,
-                    path: dest.to_path_buf(),
-                })?;
+            let obj = (*objects).find_blob(&entry.id, buf).or_raise_erased(|| {
+                message!(
+                    "object for checkout at {} could not be retrieved from object database",
+                    dest.display()
+                )
+            })?;
 
-            let filtered = filters.convert_to_worktree(
-                obj.data,
-                entry_path,
-                &mut |_, attrs| {
-                    path_cache.matching_attributes(attrs);
-                },
-                to_worktree::Options {
-                    can_delay: filter_process_delay,
-                    unknown_encoding: to_worktree::UnknownEncoding::Ignore,
-                },
-            )?;
+            let filtered = filters
+                .convert_to_worktree(
+                    obj.data,
+                    entry_path,
+                    &mut |_, attrs| {
+                        path_cache.matching_attributes(attrs);
+                    },
+                    to_worktree::Options {
+                        can_delay: filter_process_delay,
+                        unknown_encoding: to_worktree::UnknownEncoding::Ignore,
+                    },
+                )
+                .or_erased()?;
             let (num_bytes, file, executable_bit_change) = match filtered {
                 ToWorktreeOutcome::Unchanged(buf) | ToWorktreeOutcome::Buffer(buf) => {
                     let (mut file, flag) = open_file(
@@ -114,8 +120,9 @@ where
                         overwrite_existing,
                         executable_bit,
                         entry.mode,
-                    )?;
-                    file.write_all(buf)?;
+                    )
+                    .or_erased()?;
+                    file.write_all(buf).or_erased()?;
                     (buf.len(), file, flag)
                 }
                 ToWorktreeOutcome::Process(MaybeDelayed::Immediate(mut filtered)) => {
@@ -125,8 +132,9 @@ where
                         overwrite_existing,
                         executable_bit,
                         entry.mode,
-                    )?;
-                    let num_bytes = std::io::copy(&mut filtered, &mut file)? as usize;
+                    )
+                    .or_erased()?;
+                    let num_bytes = std::io::copy(&mut filtered, &mut file).or_erased()? as usize;
                     (num_bytes, file, flag)
                 }
                 ToWorktreeOutcome::Process(MaybeDelayed::Delayed(key)) => {
@@ -145,18 +153,18 @@ where
             num_bytes
         }
         gix_index::entry::Mode::SYMLINK => {
-            let obj = (*objects)
-                .find_blob(&entry.id, buf)
-                .map_err(|err| crate::checkout::Error::Find {
-                    err,
-                    path: dest.to_path_buf(),
-                })?;
+            let obj = (*objects).find_blob(&entry.id, buf).or_raise_erased(|| {
+                message!(
+                    "object for checkout at {} could not be retrieved from object database",
+                    dest.display()
+                )
+            })?;
             if symlink {
                 #[cfg_attr(not(windows), allow(unused_mut))]
-                let mut symlink_destination = Cow::Borrowed(
-                    gix_path::try_from_byte_slice(obj.data)
-                        .map_err(|_| crate::checkout::Error::IllformedUtf8 { path: obj.data.into() })?,
-                );
+                let mut symlink_destination =
+                    Cow::Borrowed(gix_path::try_from_byte_slice(obj.data).or_raise_erased(|| {
+                        gix_error::validation("Could not convert path to UTF8").with("input", obj.data)
+                    })?);
                 #[cfg(windows)]
                 {
                     symlink_destination = gix_path::to_native_path_on_windows(gix_path::into_bstr(symlink_destination))
@@ -164,16 +172,18 @@ where
 
                 try_op_or_unlink(dest, overwrite_existing, |p| {
                     gix_fs::symlink::create(symlink_destination.as_ref(), p)
-                })?;
+                })
+                .or_erased()?;
             } else {
                 let mut file = try_op_or_unlink(dest, overwrite_existing, |p| {
                     open_options(destination_is_initially_empty, overwrite_existing).open(p)
-                })?;
-                file.write_all(obj.data)?;
-                file.close()?;
+                })
+                .or_erased()?;
+                file.write_all(obj.data).or_erased()?;
+                file.close().or_erased()?;
             }
 
-            entry.stat = Stat::from_fs(&gix_index::fs::Metadata::from_path_no_follow(dest)?)?;
+            entry.stat = Stat::from_fs(&gix_index::fs::Metadata::from_path_no_follow(dest).or_erased()?).or_erased()?;
             obj.data.len()
         }
         gix_index::entry::Mode::DIR => {
@@ -292,27 +302,27 @@ pub(crate) fn finalize_entry(
     file: std::fs::File,
     desired_bytes: u64,
     #[cfg_attr(windows, allow(unused_variables))] executable_bit_change: ExecutableBitChange,
-) -> Result<(), crate::checkout::Error> {
+) -> ExnResult {
     // For possibly existing, overwritten files, we must change the file mode explicitly to match the index.
     #[cfg(unix)]
     match executable_bit_change {
         ExecutableBitChange::NoChange => {}
-        ExecutableBitChange::Set => adjust_executable_bits(&file, true)?,
-        ExecutableBitChange::Remove => adjust_executable_bits(&file, false)?,
+        ExecutableBitChange::Set => adjust_executable_bits(&file, true).or_erased()?,
+        ExecutableBitChange::Remove => adjust_executable_bits(&file, false).or_erased()?,
     }
 
-    let md = &gix_index::fs::Metadata::from_file(&file)?;
+    let md = &gix_index::fs::Metadata::from_file(&file).or_erased()?;
     // A last sanity check: if the file wasn't truncated upon opening, which is good in case something
     // goes wrong during writing, not everything is lost, then after writing the file is smaller than it was
     // before, it needs truncation. We do that here.
     let needs_truncation = md.len() > desired_bytes;
     if needs_truncation {
-        file.set_len(desired_bytes)?;
+        file.set_len(desired_bytes).or_erased()?;
     }
     // NOTE: we don't call `file.sync_all()` here knowing that some filesystems don't handle this well.
     //       revisit this once there is a bug to fix.
-    entry.stat = Stat::from_fs(md)?;
-    file.close()?;
+    entry.stat = Stat::from_fs(md).or_erased()?;
+    file.close().or_erased()?;
     Ok(())
 }
 
@@ -372,7 +382,11 @@ mod tests {
                     !meta.file_type().is_symlink(),
                     "the operation must not receive a symlink"
                 ),
-                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    insta::allow_duplicates! {
+                        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "forced checkout removes the terminal symlink before invoking the operation", @"NotFound");
+                    }
+                }
                 Err(err) => return Err(err),
             }
             Ok(())
diff --git a/gix-worktree-state/src/checkout/function.rs b/gix-worktree-state/src/checkout/function.rs
index 1675629b8a5..0bb4df41844 100644
--- a/gix-worktree-state/src/checkout/function.rs
+++ b/gix-worktree-state/src/checkout/function.rs
@@ -1,5 +1,6 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_error::{ExnResult, ResultExt, message};
 use gix_features::{interrupt, parallel::in_parallel_with_finalize};
 use gix_worktree::{Stack, stack};
 
@@ -23,7 +24,7 @@ pub fn checkout<Find>(
     bytes: &dyn gix_features::progress::Count,
     should_interrupt: &AtomicBool,
     options: crate::checkout::Options,
-) -> Result<crate::checkout::Outcome, crate::checkout::Error>
+) -> ExnResult<crate::checkout::Outcome>
 where
     Find: gix_object::Find + Send + Clone,
 {
@@ -43,7 +44,7 @@ fn checkout_inner<Find>(
     bytes: &dyn gix_features::progress::Count,
     should_interrupt: &AtomicBool,
     mut options: crate::checkout::Options,
-) -> Result<crate::checkout::Outcome, crate::checkout::Error>
+) -> ExnResult<crate::checkout::Outcome>
 where
     Find: gix_object::Find + Send + Clone,
 {
@@ -126,7 +127,8 @@ where
                 ctx.filters
                     .driver_state_mut()
                     .shutdown(gix_filter::driver::shutdown::Mode::WaitForProcesses)
-                    .map_err(crate::checkout::Error::FilterShutdownIo)?;
+                    .or_raise(|| message("Could not shut down filter processes"))
+                    .or_erased()?;
                 Ok(out)
             },
             chunk::Reduce {
@@ -153,7 +155,8 @@ where
     ctx.filters
         .driver_state_mut()
         .shutdown(gix_filter::driver::shutdown::Mode::WaitForProcesses)
-        .map_err(crate::checkout::Error::FilterShutdownIo)?;
+        .or_raise(|| message("Could not shut down filter processes"))
+        .or_erased()?;
 
     Ok(crate::checkout::Outcome {
         files_updated,
diff --git a/gix-worktree-state/src/checkout/mod.rs b/gix-worktree-state/src/checkout/mod.rs
index 91d0b0f3242..7949fe2f89e 100644
--- a/gix-worktree-state/src/checkout/mod.rs
+++ b/gix-worktree-state/src/checkout/mod.rs
@@ -10,13 +10,13 @@ pub struct Collision {
     pub error_kind: std::io::ErrorKind,
 }
 
-/// A path that encountered an IO error.
+/// A path that encountered an error.
 #[derive(Debug)]
 pub struct ErrorRecord {
     /// the path that encountered the error.
     pub path: BString,
-    /// The error
-    pub error: Box<dyn std::error::Error + Send + Sync + 'static>,
+    /// The error.
+    pub error: gix_error::Error,
 }
 
 /// The outcome of checking out an entire index.
@@ -74,36 +74,6 @@ pub struct Options {
     pub filter_process_delay: gix_filter::driver::apply::Delay,
 }
 
-/// The error returned by the [checkout()][crate::checkout()] function.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not convert path to UTF8: {}", .path)]
-    IllformedUtf8 { path: BString },
-    #[error("The clock was off when reading file related metadata after updating a file on disk")]
-    Time(#[from] std::time::SystemTimeError),
-    #[error("IO error while writing blob or reading file metadata or changing filetype")]
-    Io(#[from] std::io::Error),
-    #[error("object for checkout at {} could not be retrieved from object database", .path.display())]
-    Find {
-        #[source]
-        err: gix_object::find::existing_object::Error,
-        path: std::path::PathBuf,
-    },
-    #[error(transparent)]
-    Filter(#[from] gix_filter::pipeline::convert::to_worktree::Error),
-    #[error(transparent)]
-    FilterListDelayed(#[from] gix_filter::driver::delayed::list::Error),
-    #[error(transparent)]
-    FilterFetchDelayed(#[from] gix_filter::driver::delayed::fetch::Error),
-    #[error("Could not shut down filter processes")]
-    FilterShutdownIo(#[source] std::io::Error),
-    #[error("The entry at path '{rela_path}' was listed as delayed by the filter process, but we never passed it")]
-    FilterPathUnknown { rela_path: BString },
-    #[error("The following paths were delayed and apparently forgotten to be processed by the filter driver: ")]
-    FilterPathsUnprocessed { rela_paths: Vec<BString> },
-}
-
 mod chunk;
 mod entry;
 pub(crate) mod function;
diff --git a/gix-worktree-state/tests/worktree-state/checkout.rs b/gix-worktree-state/tests/worktree-state/checkout.rs
index f61e9dfd139..1f12bb45275 100644
--- a/gix-worktree-state/tests/worktree-state/checkout.rs
+++ b/gix-worktree-state/tests/worktree-state/checkout.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 #[cfg(unix)]
 use std::os::unix::prelude::{MetadataExt, PermissionsExt};
 use std::{
@@ -13,6 +14,8 @@ use gix_testtools::tempfile::TempDir;
 use gix_worktree_state::checkout::Collision;
 use std::sync::LazyLock;
 
+use gix_error::ExnResult;
+
 use crate::{fixture_path, odb_at};
 
 static DRIVER: LazyLock<PathBuf> =
@@ -32,7 +35,7 @@ fn assure_is_empty(dir: impl AsRef<Path>) -> std::io::Result<()> {
 }
 
 #[test]
-fn submodules_are_instantiated_as_directories() -> crate::Result {
+fn submodules_are_instantiated_as_directories() -> Result {
     let mut opts = opts_from_probe();
     opts.overwrite_existing = false;
     let (_source_tree, destination, _index, _outcome) = checkout_index_in_tmp_dir(opts.clone(), "make_mixed", None)?;
@@ -122,7 +125,7 @@ fn writes_through_symlinks_are_prevented_even_if_overwriting_is_allowed() {
 }
 
 #[test]
-fn nonexclusive_checkout_does_not_follow_terminal_symlinks() -> crate::Result {
+fn nonexclusive_checkout_does_not_follow_terminal_symlinks() -> Result {
     let mut opts = opts_from_probe();
     // the test needs filesystem symlink support;
     if !opts.fs.symlink {
@@ -293,7 +296,80 @@ fn delayed_symlinks_do_not_reuse_replaced_directory_prefixes() -> gix_testtools:
 }
 
 #[test]
-fn delayed_driver_process() -> crate::Result {
+fn filter_spawn_errors_are_not_collisions() -> Result {
+    let mut error_snapshots = Vec::new();
+    // A relative path with forward slashes makes spawning fail directly, without a shell.
+    let dir = gix_testtools::tempfile::tempdir_in(".")?;
+    let program = Path::new(dir.path().file_name().expect("temporary directories have a name")).join("smudge.exe");
+    // Both failures look like destination collisions, but occur while spawning the filter.
+    #[cfg(unix)]
+    std::os::unix::fs::symlink("smudge.exe", &program)?;
+    #[cfg(windows)]
+    std::fs::create_dir(&program)?;
+
+    for keep_going in [false, true] {
+        let mut opts = opts_from_probe();
+        opts.keep_going = keep_going;
+        opts.filters.options_mut().drivers = vec![gix_filter::Driver {
+            name: "arrow".into(),
+            clean: None,
+            smudge: Some(gix_path::to_unix_separators_on_windows(gix_path::into_bstr(&program)).into_owned()),
+            process: None,
+            required: true,
+        }];
+        let result = checkout_index_in_tmp_dir(opts, "make_mixed_without_submodules_and_symlinks", None);
+        let err = if keep_going {
+            let (_, _, _, outcome) = result?;
+            assert!(outcome.collisions.is_empty(), "filter failures are not collisions");
+            outcome
+                .errors
+                .into_iter()
+                .next()
+                .expect("keep-going records the required filter failure")
+                .error
+        } else {
+            *result
+                .expect_err("a required filter failure must abort checkout")
+                .downcast::<gix_error::Error>()
+                .expect("checkout retains the error chain")
+        };
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(err),
+            &[(&(program).to_string_lossy(), "<filter-program>")],
+        ));
+        assert!(
+            err.downcast_any_ref::<std::io::Error>()
+                .is_some_and(gix_fs::symlink::is_collision_error),
+            "the filter failure retains its collision-like I/O cause"
+        );
+    }
+    #[cfg(not(windows))]
+    insta::assert_debug_snapshot!(error_snapshots, "filter spawn errors are not collisions", @r#"
+    [
+        Failed to spawn driver: "<filter-program>"
+        |
+        └─ FilesystemLoop,
+        Failed to spawn driver: "<filter-program>"
+        |
+        └─ FilesystemLoop,
+    ]
+    "#);
+    #[cfg(windows)]
+    insta::assert_debug_snapshot!(error_snapshots, "filter spawn errors are not collisions", @r#"
+    [
+        Failed to spawn driver: "<filter-program>"
+        |
+        └─ PermissionDenied,
+        Failed to spawn driver: "<filter-program>"
+        |
+        └─ PermissionDenied,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn delayed_driver_process() -> Result {
     let mut opts = opts_from_probe();
     opts.filter_process_delay = gix_filter::driver::apply::Delay::Allow;
     setup_filter_pipeline(opts.filters.options_mut());
@@ -340,7 +416,7 @@ fn delayed_driver_process() -> crate::Result {
 }
 
 #[test]
-fn filter_process_failure_during_shutdown_is_ignored() -> crate::Result {
+fn filter_process_failure_during_shutdown_is_ignored() -> Result {
     let mut opts = opts_from_probe();
     setup_filter_pipeline(opts.filters.options_mut());
     opts.filters
@@ -354,9 +430,33 @@ fn filter_process_failure_during_shutdown_is_ignored() -> crate::Result {
     Ok(())
 }
 
+#[test]
+fn forgotten_delayed_path_is_a_corruption_error() {
+    let mut opts = opts_from_probe();
+    // Keep the forgotten path independent of worker scheduling.
+    opts.thread_limit = Some(1);
+    opts.filter_process_delay = gix_filter::driver::apply::Delay::Allow;
+    setup_filter_pipeline(opts.filters.options_mut());
+    opts.filters.options_mut().drivers[0].process = Some((driver_exe() + " process forget-delayed").into());
+
+    let err = checkout_index_in_tmp_dir_opts(
+        opts,
+        "make_mixed_without_submodules_and_symlinks",
+        None,
+        |_| true,
+        |_| Ok(()),
+    )
+    .expect_err("a required filter must not silently forget a delayed path");
+    let err = err
+        .downcast_ref::<gix_error::Error>()
+        .expect("checkout errors retain their classification");
+    insta::assert_debug_snapshot!(err, "forgotten delayed path is a corruption error", @r#"The following paths were delayed and apparently forgotten to be processed by the filter driver: ["dir/content"]"#);
+    assert!(err.is_corrupted());
+}
+
 #[cfg(unix)]
 #[test]
-fn delayed_driver_process_removes_obsolete_executable_bits() -> crate::Result {
+fn delayed_driver_process_removes_obsolete_executable_bits() -> Result {
     let mut opts = opts_from_probe();
     opts.destination_is_initially_empty = false;
     opts.filter_process_delay = gix_filter::driver::apply::Delay::Allow;
@@ -386,7 +486,7 @@ fn delayed_driver_process_removes_obsolete_executable_bits() -> crate::Result {
 
 #[cfg(unix)]
 #[test]
-fn nonexclusive_checkout_adjusts_executable_bits_in_both_directions() -> crate::Result {
+fn nonexclusive_checkout_adjusts_executable_bits_in_both_directions() -> Result {
     for overwrite_existing in [false, true] {
         let mut opts = opts_from_probe();
         opts.destination_is_initially_empty = false;
@@ -429,7 +529,7 @@ fn nonexclusive_checkout_adjusts_executable_bits_in_both_directions() -> crate::
 }
 
 #[test]
-fn overwriting_files_and_lone_directories_works() -> crate::Result {
+fn overwriting_files_and_lone_directories_works() -> Result {
     for delay in [
         gix_filter::driver::apply::Delay::Allow,
         gix_filter::driver::apply::Delay::Forbid,
@@ -527,7 +627,7 @@ fn overwriting_files_and_lone_directories_works() -> crate::Result {
 }
 
 #[test]
-fn symlinks_become_files_if_disabled() -> crate::Result {
+fn symlinks_become_files_if_disabled() -> Result {
     let mut opts = opts_from_probe();
     opts.fs.symlink = false;
     let (source_tree, destination, _index, outcome) =
@@ -539,7 +639,7 @@ fn symlinks_become_files_if_disabled() -> crate::Result {
 }
 
 #[test]
-fn symlinks_to_directories_are_usable() -> crate::Result {
+fn symlinks_to_directories_are_usable() -> Result {
     let opts = opts_from_probe();
     assert!(opts.fs.symlink, "The probe must detect to be able to generate symlinks");
 
@@ -568,7 +668,7 @@ fn symlinks_to_directories_are_usable() -> crate::Result {
 }
 
 #[test]
-fn dangling_symlinks_can_be_created() -> crate::Result {
+fn dangling_symlinks_can_be_created() -> Result {
     let opts = opts_from_probe();
     assert!(opts.fs.symlink, "The probe must detect to be able to generate symlinks");
 
@@ -605,7 +705,7 @@ fn dangling_symlinks_can_be_created() -> crate::Result {
 }
 
 #[test]
-fn allow_or_disallow_symlinks() -> crate::Result {
+fn allow_or_disallow_symlinks() -> Result {
     let mut opts = opts_from_probe();
     for allowed in &[false, true] {
         opts.fs.symlink = *allowed;
@@ -709,18 +809,22 @@ fn safety_checks_dotdot_trees() {
     let mut opts = opts_from_probe();
     let err =
         checkout_index_in_tmp_dir(opts.clone(), "make_traverse_trees", Some("traverse_dotdot_trees")).unwrap_err();
-    let expected_err_msg = "Input path \"../outside\" contains relative or absolute components";
-    assert_eq!(err.source().expect("inner").to_string(), expected_err_msg);
+    insta::assert_debug_snapshot!(err, "safety checks dotdot trees", @r#"
+    I/O error (Other)
+    |
+    └─ Input path "../outside" contains relative or absolute components
+    "#);
 
     opts.keep_going = true;
     let (_source_tree, _destination, _index, outcome) =
         checkout_index_in_tmp_dir(opts, "make_traverse_trees", Some("traverse_dotdot_trees"))
             .expect("keep-going checks out as much as possible");
     assert_eq!(outcome.errors.len(), 1, "one path could not be checked out");
-    assert_eq!(
-        outcome.errors[0].error.source().expect("inner").to_string(),
-        expected_err_msg
-    );
+    insta::assert_debug_snapshot!(outcome.errors[0].error, "safety checks dotdot trees", @r#"
+    I/O error (Other)
+    |
+    └─ Input path "../outside" contains relative or absolute components
+    "#);
 }
 
 #[test]
@@ -728,10 +832,11 @@ fn safety_checks_dotgit_trees() {
     let opts = opts_from_probe();
     let err =
         checkout_index_in_tmp_dir(opts.clone(), "make_traverse_trees", Some("traverse_dotgit_trees")).unwrap_err();
-    assert_eq!(
-        err.source().expect("inner").to_string(),
-        "The .git name may never be used"
-    );
+    insta::assert_debug_snapshot!(err, "safety checks dotgit trees", @"
+    I/O error (Other)
+    |
+    └─ The .git name may never be used
+    ");
 }
 
 #[test]
@@ -739,11 +844,11 @@ fn safety_checks_dotgit_ntfs_stream() {
     let opts = opts_from_probe();
     let err =
         checkout_index_in_tmp_dir(opts.clone(), "make_traverse_trees", Some("traverse_dotgit_stream")).unwrap_err();
-    assert_eq!(
-        err.source().expect("inner").to_string(),
-        "The .git name may never be used",
-        "note how it is still discovered even though the path is `.git::$INDEX_ALLOCATION`"
-    );
+    insta::assert_debug_snapshot!(err, "note how it is still discovered even though the path is `.git::$INDEX_ALLOCATION`", @"
+    I/O error (Other)
+    |
+    └─ The .git name may never be used
+    ");
 }
 
 #[test]
@@ -824,7 +929,7 @@ fn multi_threaded() -> bool {
     gix_features::parallel::num_threads(None) > 1
 }
 
-fn assert_equality(source_tree: &Path, destination: &TempDir, allow_symlinks: bool) -> crate::Result<usize> {
+fn assert_equality(source_tree: &Path, destination: &TempDir, allow_symlinks: bool) -> Result<usize> {
     let source_files = dir_structure(source_tree);
     let worktree_files = dir_structure(destination);
 
@@ -869,7 +974,7 @@ fn checkout_index_in_tmp_dir(
     opts: gix_worktree_state::checkout::Options,
     name: &str,
     subdir_name: Option<&str>,
-) -> crate::Result<(PathBuf, TempDir, gix_index::File, gix_worktree_state::checkout::Outcome)> {
+) -> Result<(PathBuf, TempDir, gix_index::File, gix_worktree_state::checkout::Outcome)> {
     checkout_index_in_tmp_dir_opts(opts, name, subdir_name, |_d| true, |_| Ok(()))
 }
 
@@ -879,7 +984,7 @@ fn checkout_index_in_tmp_dir_opts(
     subdir_name: Option<&str>,
     allow_return_object: impl FnMut(&gix_hash::oid) -> bool + Send + Clone,
     prep_dest: impl Fn(&Path) -> std::io::Result<()>,
-) -> crate::Result<(PathBuf, TempDir, gix_index::File, gix_worktree_state::checkout::Outcome)> {
+) -> Result<(PathBuf, TempDir, gix_index::File, gix_worktree_state::checkout::Outcome)> {
     let source_tree = {
         let root = fixture_path(script_name);
         if let Some(name) = subdir_name {
@@ -894,7 +999,8 @@ fn checkout_index_in_tmp_dir_opts(
         gix_testtools::object_hash(),
         false,
         Default::default(),
-    )?;
+    )
+    .map_err(gix_error::Exn::into_error)?;
     let odb = odb_at(git_dir.join("objects"))?.into_inner().into_arc()?;
     let destination = gix_testtools::tempfile::tempdir_in(std::env::current_dir()?)?;
     prep_dest(destination.path()).expect("preparation must succeed");
@@ -910,11 +1016,7 @@ fn checkout_index_in_tmp_dir_opts(
         Allow: FnMut(&gix_hash::oid) -> bool + Send + Clone,
         Find: gix_object::Find + Send + Clone,
     {
-        fn try_find<'a>(
-            &self,
-            id: &gix_hash::oid,
-            buf: &'a mut Vec<u8>,
-        ) -> Result<Option<Data<'a>>, gix_object::find::Error> {
+        fn try_find<'a>(&self, id: &gix_hash::oid, buf: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
             if (self.allow.borrow_mut())(id) {
                 self.objects.try_find(id, buf)
             } else {
@@ -935,7 +1037,8 @@ fn checkout_index_in_tmp_dir_opts(
         &progress::Discard,
         &AtomicBool::default(),
         opts,
-    )?;
+    )
+    .map_err(gix_error::Exn::into_error)?;
     Ok((source_tree, destination, index, outcome))
 }
 
@@ -943,7 +1046,7 @@ fn stripped_prefix(prefix: impl AsRef<Path>, source_files: &[PathBuf]) -> Vec<&P
     source_files.iter().flat_map(|p| p.strip_prefix(&prefix)).collect()
 }
 
-fn probe_checkout_filesystem() -> crate::Result<gix_fs::Capabilities> {
+fn probe_checkout_filesystem() -> Result<gix_fs::Capabilities> {
     let dir = gix_testtools::tempfile::tempdir_in(std::env::current_dir()?)?;
     Ok(gix_fs::Capabilities::probe_dir(dir.path()))
 }
@@ -976,7 +1079,7 @@ fn setup_filter_pipeline(opts: &mut gix_filter::pipeline::Options) {
 }
 
 #[test]
-fn checkout_truncates_existing_longer_files() -> crate::Result {
+fn checkout_truncates_existing_longer_files() -> Result {
     let mut opts = opts_from_probe();
     opts.overwrite_existing = false;
     opts.destination_is_initially_empty = false;
diff --git a/gix-worktree-stream/Cargo.toml b/gix-worktree-stream/Cargo.toml
index 6028f0fbddc..dc93e1ef893 100644
--- a/gix-worktree-stream/Cargo.toml
+++ b/gix-worktree-stream/Cargo.toml
@@ -34,6 +34,7 @@ gix-error = { version = "^0.3.2", path = "../gix-error" }
 parking_lot = "0.12.4"
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-worktree-stream = { path = ".", features = ["sha1", "sha256"] }
 gix-testtools = { path = "../tests/tools" }
 gix-hash = { path = "../gix-hash" }
diff --git a/gix-worktree-stream/src/entry.rs b/gix-worktree-stream/src/entry.rs
index f24456bceb9..ca08404f879 100644
--- a/gix-worktree-stream/src/entry.rs
+++ b/gix-worktree-stream/src/entry.rs
@@ -3,17 +3,14 @@ use std::{
     path::PathBuf,
 };
 
-use gix_error::ErrorExt;
+use gix_error::{ErrorExt, ExnMessageResult};
 use gix_object::bstr::BStr;
 
 use crate::{Entry, Stream, protocol};
 
-/// The error returned by [`next_entry()`][Stream::next_entry()].
-pub type Error = gix_error::Exn<gix_error::Message>;
-
 impl Stream {
     /// Access the next entry of the stream or `None` if there is nothing more to read.
-    pub fn next_entry(&mut self) -> Result<Option<Entry<'_>>, Error> {
+    pub fn next_entry(&mut self) -> ExnMessageResult<Option<Entry<'_>>> {
         assert!(
             self.path_buf.is_some(),
             "BUG: must consume and drop entry before getting the next one"
diff --git a/gix-worktree-stream/src/from_tree/mod.rs b/gix-worktree-stream/src/from_tree/mod.rs
index 05df4de5c4f..7a222b86422 100644
--- a/gix-worktree-stream/src/from_tree/mod.rs
+++ b/gix-worktree-stream/src/from_tree/mod.rs
@@ -2,9 +2,9 @@ use std::io::Write;
 
 use gix_object::{FindExt, bstr::BStr};
 
-use gix_error::{ResultExt, message};
+use gix_error::{ExnMessageResult, ResultExt, message};
 
-use crate::{AdditionalEntry, SharedErrorSlot, Stream, entry, entry::Error, protocol};
+use crate::{AdditionalEntry, SharedErrorSlot, Stream, entry, protocol};
 
 /// Use `objects` to traverse `tree` and fetch the contained blobs to return as [`Stream`], which makes them queryable
 /// on demand with support for streaming each entry.
@@ -84,7 +84,7 @@ fn run<Find, E>(
     out: &mut gix_features::io::pipe::Writer,
     err: SharedErrorSlot,
     additional_entries: std::sync::mpsc::Receiver<AdditionalEntry>,
-) -> Result<(), Error>
+) -> ExnMessageResult
 where
     Find: gix_object::Find + Clone,
     E: std::error::Error + Send + Sync + 'static,
diff --git a/gix-worktree-stream/src/from_tree/traverse.rs b/gix-worktree-stream/src/from_tree/traverse.rs
index 4318465321f..dd567e828b7 100644
--- a/gix-worktree-stream/src/from_tree/traverse.rs
+++ b/gix-worktree-stream/src/from_tree/traverse.rs
@@ -11,9 +11,9 @@ use gix_object::{
 };
 use gix_traverse::tree::{Visit, visit::Action};
 
-use gix_error::{ResultExt, message};
+use gix_error::{ExnMessageResult, ResultExt, message};
 
-use crate::{SharedErrorSlot, entry::Error, protocol};
+use crate::{SharedErrorSlot, protocol};
 
 pub struct Delegate<'a, AttributesFn, Find>
 where
@@ -34,7 +34,7 @@ impl<AttributesFn, Find> Delegate<'_, AttributesFn, Find>
 where
     Find: gix_object::Find,
     AttributesFn:
-        FnMut(&BStr, gix_object::tree::EntryMode, &mut gix_attributes::search::Outcome) -> Result<(), Error> + 'static,
+        FnMut(&BStr, gix_object::tree::EntryMode, &mut gix_attributes::search::Outcome) -> ExnMessageResult + 'static,
 {
     fn pop_element(&mut self) {
         if let Some(pos) = self.path.rfind_byte(b'/') {
@@ -63,7 +63,7 @@ where
             .state
     }
 
-    fn handle_entry(&mut self, entry: &tree::EntryRef<'_>) -> Result<Action, Error> {
+    fn handle_entry(&mut self, entry: &tree::EntryRef<'_>) -> ExnMessageResult<Action> {
         if !entry.mode.is_blob_or_symlink() {
             return Ok(std::ops::ControlFlow::Continue(true));
         }
@@ -122,7 +122,7 @@ impl<AttributesFn, Find> Visit for Delegate<'_, AttributesFn, Find>
 where
     Find: gix_object::Find,
     AttributesFn:
-        FnMut(&BStr, gix_object::tree::EntryMode, &mut gix_attributes::search::Outcome) -> Result<(), Error> + 'static,
+        FnMut(&BStr, gix_object::tree::EntryMode, &mut gix_attributes::search::Outcome) -> ExnMessageResult + 'static,
 {
     fn pop_back_tracked_path_and_set_current(&mut self) {
         self.path = self.path_deque.pop_back().unwrap_or_default();
diff --git a/gix-worktree-stream/src/lib.rs b/gix-worktree-stream/src/lib.rs
index 9485fce71bd..b67a2b7b6db 100644
--- a/gix-worktree-stream/src/lib.rs
+++ b/gix-worktree-stream/src/lib.rs
@@ -32,7 +32,7 @@ pub(crate) mod protocol;
 mod from_tree;
 pub use from_tree::from_tree;
 
-pub(crate) type SharedErrorSlot = Arc<parking_lot::Mutex<Option<entry::Error>>>;
+pub(crate) type SharedErrorSlot = Arc<parking_lot::Mutex<Option<gix_error::Exn<gix_error::Message>>>>;
 
 /// An entry in a stream. Note that they must be consumed fully, by reading from them till exhaustion.
 ///
diff --git a/gix-worktree-stream/src/protocol.rs b/gix-worktree-stream/src/protocol.rs
index 328ac61e819..409271c88b2 100644
--- a/gix-worktree-stream/src/protocol.rs
+++ b/gix-worktree-stream/src/protocol.rs
@@ -138,7 +138,8 @@ fn mode_to_byte(m: gix_object::tree::EntryMode) -> u8 {
 
 fn clear_and_set_len(buf: &mut Vec<u8>, len: usize) -> io::Result<()> {
     buf.clear();
-    buf.try_reserve(len).map_err(|_| ErrorKind::OutOfMemory)?;
+    buf.try_reserve(len)
+        .map_err(|err| io::Error::new(ErrorKind::OutOfMemory, err))?;
     buf.resize(len, 0);
     Ok(())
 }
diff --git a/gix-worktree-stream/tests/stream.rs b/gix-worktree-stream/tests/stream.rs
index c2b1abaafa8..795fb04e4d8 100644
--- a/gix-worktree-stream/tests/stream.rs
+++ b/gix-worktree-stream/tests/stream.rs
@@ -7,6 +7,48 @@ fn hex_to_id(hex_sha1: &str, hex_sha256: &str) -> gix_hash::ObjectId {
     }
 }
 
+#[test]
+fn impossible_path_allocation_preserves_its_source() {
+    let mut input = Vec::new();
+    input.extend_from_slice(&usize::MAX.to_le_bytes());
+    input.extend_from_slice(&0usize.to_le_bytes());
+    input.extend_from_slice(&[0, 0]);
+    input.extend_from_slice(&[0; 20]);
+
+    let err = gix_worktree_stream::Stream::from_read(std::io::Cursor::new(input))
+        .next_entry()
+        .expect_err("the declared path length cannot be allocated");
+    insta::assert_debug_snapshot!(err, "the allocation failure remains classified", @"
+    Could not read stream entry
+    |
+    └─ I/O error (OutOfMemory)
+    |
+    └─ memory allocation failed because the computed capacity exceeded the collection's maximum
+    ");
+    let io_err = err
+        .downcast_any_ref::<std::io::Error>()
+        .expect("the I/O error is retained");
+    insta::assert_debug_snapshot!(io_err, "impossible path allocation preserves its source", @"
+    Custom {
+        kind: OutOfMemory,
+        error: TryReserveError {
+            kind: CapacityOverflow,
+        },
+    }
+    ");
+    assert_eq!(io_err.kind(), std::io::ErrorKind::OutOfMemory);
+    assert!(
+        io_err
+            .get_ref()
+            .expect("the allocation error is retained")
+            .is::<std::collections::TryReserveError>(),
+        "the allocation error is retained"
+    );
+    assert!(err.is_resource_exhausted(), "the allocation failure remains classified");
+    assert!(!err.is_corrupted());
+    assert!(!err.can_retry());
+}
+
 mod from_tree {
     use std::{
         convert::Infallible,
@@ -16,6 +58,7 @@ mod from_tree {
     };
 
     use gix_attributes::glob::pattern::Case;
+    use gix_error::{ErrorExt, ExnResult};
     use gix_hash::oid;
     use gix_object::{Data, bstr::ByteSlice, tree::EntryKind};
     use gix_worktree::stack::state::attributes::Source;
@@ -27,12 +70,8 @@ mod from_tree {
     struct FailObjectRetrieval;
 
     impl gix_object::Find for FailObjectRetrieval {
-        fn try_find<'a>(
-            &self,
-            _id: &oid,
-            _buffer: &'a mut Vec<u8>,
-        ) -> Result<Option<Data<'a>>, gix_object::find::Error> {
-            Err(Box::new(Error::other("object retrieval failed")))
+        fn try_find<'a>(&self, _id: &oid, _buffer: &'a mut Vec<u8>) -> ExnResult<Option<Data<'a>>> {
+            Err(Error::other("object retrieval failed").raise_erased())
         }
     }
 
@@ -45,7 +84,13 @@ mod from_tree {
             |_, _, _| -> Result<_, Infallible> { unreachable!("must not be called") },
         );
         let err = stream.next_entry().unwrap_err();
-        assert_eq!(err.to_string(), "Could not find a tree to traverse");
+        insta::assert_debug_snapshot!(err, "can receive err if root is not found", @"
+        Could not find a tree to traverse
+        |
+        └─ I/O error (Other)
+        |
+        └─ object retrieval failed
+        ");
     }
 
     #[test]
@@ -55,10 +100,13 @@ mod from_tree {
             Err(Error::other("attribute retrieval failed"))
         });
         let err = stream.next_entry().unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Could not query attributes for path \".gitattributes\""
-        );
+        insta::assert_debug_snapshot!(err, "can receive err if attribute not found", @r#"
+        Could not query attributes for path ".gitattributes"
+        |
+        └─ I/O error (Other)
+        |
+        └─ attribute retrieval failed
+        "#);
         Ok(())
     }
 
diff --git a/gix-worktree/Cargo.toml b/gix-worktree/Cargo.toml
index c35d59ab801..04ca1fa0543 100644
--- a/gix-worktree/Cargo.toml
+++ b/gix-worktree/Cargo.toml
@@ -28,6 +28,7 @@ serde = ["dep:serde", "bstr/serde", "gix-index/serde", "gix-hash/serde", "gix-ob
 parallel = ["gix-features/parallel", "gix-attributes?/parallel"]
 
 [dependencies]
+gix-error = { version = "^0.3.2", path = "../gix-error" }
 gix-index = { version = "^0.55.0", path = "../gix-index" }
 gix-fs = { version = "^0.22.1", path = "../gix-fs" }
 gix-hash = { version = "^0.26.1", path = "../gix-hash" }
@@ -45,6 +46,7 @@ bstr = { version = "1.12.0", default-features = false }
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
+insta = "1.46.3"
 gix-hash = { path = "../gix-hash", features = ["sha1", "sha256"] }
 gix-testtools = { path = "../tests/tools", default-features = false, features = ["sha1", "sha256"] }
 gix-odb = { path = "../gix-odb", features = ["sha1", "sha256"] }
diff --git a/gix-worktree/src/stack/delegate.rs b/gix-worktree/src/stack/delegate.rs
index 83377255577..98fa7bea2c9 100644
--- a/gix-worktree/src/stack/delegate.rs
+++ b/gix-worktree/src/stack/delegate.rs
@@ -134,16 +134,19 @@ fn validate_last_component(
     mode: Option<gix_index::entry::Mode>,
     opts: gix_validate::path::component::Options,
 ) -> std::io::Result<()> {
+    use gix_error::ResultExt;
+
     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::other(format!(
+        .or_raise(|| {
+            gix_error::message!(
                 "Path component {last_component:?} of path \"{}\" contained invalid UTF-8 and could not be validated",
                 stack.current_relative().display()
-            ))
-        })?;
+            )
+        })
+        .map_err(|err| std::io::Error::other(err.into_error()))?;
 
     if let Err(err) = gix_validate::path::component(
         last_component.as_ref(),
diff --git a/gix-worktree/src/stack/state/attributes.rs b/gix-worktree/src/stack/state/attributes.rs
index 7eda457639c..d363c8fbeb9 100644
--- a/gix-worktree/src/stack/state/attributes.rs
+++ b/gix-worktree/src/stack/state/attributes.rs
@@ -106,7 +106,7 @@ impl Attributes {
                 if let Ok(idx) = attr_file_in_index {
                     let blob = objects
                         .find_blob(&id_mappings[idx].1, buf)
-                        .map_err(std::io::Error::other)?;
+                        .map_err(|err| std::io::Error::other(err.into_error()))?;
                     let attr_path = gix_path::from_bstring(attr_path_relative.into_owned());
                     self.stack.add_patterns_buffer(
                         blob.data,
@@ -145,7 +145,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(std::io::Error::other)?;
+                        .map_err(|err| std::io::Error::other(err.into_error()))?;
                     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 2d7f8c33915..be47668dd8c 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(std::io::Error::other)?;
+                            .map_err(|err| std::io::Error::other(err.into_error()))?;
                         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("")), self.parse);
@@ -209,7 +209,7 @@ impl Ignore {
                         Ok(idx) => {
                             let ignore_blob = objects
                                 .find_blob(&id_mappings[idx].1, buf)
-                                .map_err(std::io::Error::other)?;
+                                .map_err(|err| std::io::Error::other(err.into_error()))?;
                             let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned());
                             self.stack.add_patterns_buffer(
                                 ignore_blob.data,
diff --git a/gix-worktree/tests/worktree/stack/attributes.rs b/gix-worktree/tests/worktree/stack/attributes.rs
index 5f7dcd86348..cab580c84d6 100644
--- a/gix-worktree/tests/worktree/stack/attributes.rs
+++ b/gix-worktree/tests/worktree/stack/attributes.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use bstr::ByteSlice;
 use gix_attributes::search::Outcome;
 use gix_worktree::stack::state;
@@ -5,7 +6,7 @@ use gix_worktree::stack::state;
 use crate::stack::probe_case;
 
 #[test]
-fn baseline() -> crate::Result {
+fn baseline() -> Result {
     // Due to the way our setup differs from gits dynamic stack (which involves trying to read files from disk
     // by path) we can only test one case baseline, so we require multiple platforms (or filesystems) to run this.
     let case = probe_case()?;
diff --git a/gix-worktree/tests/worktree/stack/create_directory.rs b/gix-worktree/tests/worktree/stack/create_directory.rs
index 7442ed1de3f..0564db93eed 100644
--- a/gix-worktree/tests/worktree/stack/create_directory.rs
+++ b/gix-worktree/tests/worktree/stack/create_directory.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_testtools::tempfile::{TempDir, tempdir};
@@ -8,7 +9,7 @@ const IS_DIR: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::DIR)
 const IS_SYMLINK: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::SYMLINK);
 
 #[test]
-fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate::Result {
+fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> Result {
     let dir = tempdir()?;
     let mut cache = Stack::new(
         dir.path().join("non-existing-root"),
@@ -47,7 +48,7 @@ fn directory_paths_are_created_in_full() {
 }
 
 #[test]
-fn existing_directories_are_fine() -> crate::Result {
+fn existing_directories_are_fine() -> Result {
     let (mut cache, tmp) = new_cache();
     std::fs::create_dir(tmp.path().join("dir"))?;
 
@@ -59,7 +60,7 @@ fn existing_directories_are_fine() -> crate::Result {
 }
 
 #[test]
-fn validation_to_each_component() -> crate::Result {
+fn validation_to_each_component() -> Result {
     let (mut cache, tmp) = new_cache();
 
     let err = cache
@@ -71,12 +72,18 @@ fn validation_to_each_component() -> crate::Result {
         "the valid directory was created"
     );
     assert!(tmp.path().join("valid").is_dir(), "it was actually created");
-    assert_eq!(err.to_string(), "The .git name may never be used");
+    insta::assert_debug_snapshot!(err, "validation to each component", @"
+    Custom {
+        kind: Other,
+        error: DotGitDir,
+    }
+    ");
     Ok(())
 }
 
 #[test]
-fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::Result {
+fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> Result {
+    let mut inline_error_diagnostics = Vec::new();
     let (mut cache, tmp) = new_cache();
     let forbidden = tmp.path().join("forbidden");
     std::fs::create_dir(&forbidden)?;
@@ -91,13 +98,11 @@ fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::R
             *unlink_on_collision = false;
         }
         let relative_path = format!("{dirname}/file");
-        assert_eq!(
-            cache
-                .at_path(&*relative_path, IS_FILE, &gix_object::find::Never)
-                .unwrap_err()
-                .kind(),
-            std::io::ErrorKind::AlreadyExists
-        );
+        let err = cache
+            .at_path(&*relative_path, IS_FILE, &gix_object::find::Never)
+            .expect_err("the operation must fail");
+        inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+        assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
     }
     assert_eq!(
         cache.statistics().delegate.num_mkdir_calls,
@@ -124,12 +129,18 @@ fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::R
         4,
         "like before, but it unlinks what's there and tries again"
     );
+    insta::assert_debug_snapshot!(inline_error_diagnostics, "symlinks or files in path are forbidden or unlinked when forced", @"
+    [
+        AlreadyExists,
+        AlreadyExists,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
 #[cfg(windows)]
-fn terminal_symlinks_are_forbidden_without_force() -> crate::Result {
+fn terminal_symlinks_are_forbidden_without_force() -> Result {
     let (mut cache, tmp) = new_cache();
     cache.enable_terminal_symlink_check();
 
@@ -138,11 +149,16 @@ fn terminal_symlinks_are_forbidden_without_force() -> crate::Result {
     std::fs::write(&target, b"untouched")?;
     std::os::windows::fs::symlink_file(&target, &link)?;
 
+    let err = cache
+        .at_path("link", IS_FILE, &gix_object::find::Never)
+        .expect_err("the operation must fail");
+    insta::assert_debug_snapshot!(err, "the terminal symlink must be rejected", @"
+    Kind(
+        AlreadyExists,
+    )
+    ");
     assert_eq!(
-        cache
-            .at_path("link", IS_FILE, &gix_object::find::Never)
-            .unwrap_err()
-            .kind(),
+        err.kind(),
         std::io::ErrorKind::AlreadyExists,
         "the terminal symlink must be rejected"
     );
@@ -159,7 +175,7 @@ fn terminal_symlinks_are_forbidden_without_force() -> crate::Result {
 }
 
 #[test]
-fn symlink_cached_as_file_is_revalidated_before_use_as_directory() -> crate::Result {
+fn symlink_cached_as_file_is_revalidated_before_use_as_directory() -> Result {
     let (mut cache, tmp) = new_cache();
     let forbidden = tmp.path().join("forbidden");
     std::fs::create_dir(&forbidden)?;
@@ -173,6 +189,7 @@ fn symlink_cached_as_file_is_revalidated_before_use_as_directory() -> crate::Res
     let err = cache
         .at_path("link/file", IS_SYMLINK, &gix_object::find::Never)
         .unwrap_err();
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "symlink cached as file is revalidated before use as directory", @"AlreadyExists");
     assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
     assert!(
         link_path.symlink_metadata()?.file_type().is_symlink(),
@@ -182,7 +199,7 @@ fn symlink_cached_as_file_is_revalidated_before_use_as_directory() -> crate::Res
 }
 
 #[test]
-fn symlink_cached_as_file_is_unlinked_before_use_as_directory_when_forced() -> crate::Result {
+fn symlink_cached_as_file_is_unlinked_before_use_as_directory_when_forced() -> Result {
     let (mut cache, tmp) = new_cache();
     let forbidden = tmp.path().join("forbidden");
     std::fs::create_dir(&forbidden)?;
@@ -209,7 +226,8 @@ fn symlink_cached_as_file_is_unlinked_before_use_as_directory_when_forced() -> c
 }
 
 #[test]
-fn cached_directory_returned_as_terminal_is_revalidated_before_descending() -> crate::Result {
+fn cached_directory_returned_as_terminal_is_revalidated_before_descending() -> Result {
+    let mut inline_error_diagnostics = Vec::new();
     for relative in ["link", "parent/link", "parent/deeper/link"] {
         for force in [false, true] {
             let (mut cache, _tmp) = new_cache();
@@ -248,10 +266,10 @@ fn cached_directory_returned_as_terminal_is_revalidated_before_descending() -> c
                 );
                 std::fs::write(child, b"within the worktree")?;
             } else {
+                let err = result.expect_err("the replaced directory must not remain trusted");
+                inline_error_diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
                 assert_eq!(
-                    result
-                        .expect_err("the replaced directory must not remain trusted")
-                        .kind(),
+                    err.kind(),
                     std::io::ErrorKind::AlreadyExists,
                     "a symlink collision must be rejected without force"
                 );
@@ -271,23 +289,39 @@ fn cached_directory_returned_as_terminal_is_revalidated_before_descending() -> c
             );
         }
     }
+    insta::assert_debug_snapshot!(inline_error_diagnostics, "cached directory returned as terminal is revalidated before descending", @"
+    [
+        AlreadyExists,
+        AlreadyExists,
+        AlreadyExists,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn cached_terminal_is_revalidated_when_mode_changes() -> crate::Result {
+fn cached_terminal_is_revalidated_when_mode_changes() -> Result {
+    let mut error_snapshots = Vec::new();
     let (mut cache, _tmp) = new_cache();
     for relative in [".gitmodules", "parent/.gitmodules"] {
         let _ = cache.at_path(relative, IS_FILE, &gix_object::find::Never)?;
         let err = cache
             .at_path(relative, IS_SYMLINK, &gix_object::find::Never)
             .expect_err("a cached file path must still be validated with the new mode");
-        assert_eq!(
-            err.to_string(),
-            "The .gitmodules file must not be a symlink",
-            "changing the mode must apply the symlink-specific name restriction"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
     }
+    insta::assert_debug_snapshot!(error_snapshots, "cached terminal is revalidated when mode changes", @"
+    [
+        Custom {
+            kind: Other,
+            error: SymlinkedGitModules,
+        },
+        Custom {
+            kind: Other,
+            error: SymlinkedGitModules,
+        },
+    ]
+    ");
     Ok(())
 }
 
diff --git a/gix-worktree/tests/worktree/stack/ignore.rs b/gix-worktree/tests/worktree/stack/ignore.rs
index de4b8abd128..1bc5a6cb623 100644
--- a/gix-worktree/tests/worktree/stack/ignore.rs
+++ b/gix-worktree/tests/worktree/stack/ignore.rs
@@ -1,5 +1,8 @@
+use crate::Result;
 use std::fs::Metadata;
 
+use gix_error::ExnResult;
+
 use bstr::{BStr, ByteSlice};
 use gix_fs::stack::ToNormalPathComponents;
 use gix_index::entry::Mode;
@@ -56,12 +59,8 @@ fn exclude_by_dir_is_handled_just_like_git() {
     };
     struct FindError;
     impl gix_object::Find for FindError {
-        fn try_find<'a>(
-            &self,
-            _id: &gix_hash::oid,
-            _buffer: &'a mut Vec<u8>,
-        ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
-            Err(std::io::Error::other("unreachable").into())
+        fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
+            gix_object::FindExt::find(&gix_object::find::Never, id, buffer).map(Some)
         }
     }
     for (relative_entry, source_and_line) in expectations {
@@ -101,7 +100,7 @@ fn metadata_to_mode(meta: Metadata) -> Mode {
 }
 
 #[test]
-fn check_against_baseline() -> crate::Result {
+fn check_against_baseline() -> Result {
     let dir = crate::scripted_fixture_read_only("make_ignore_and_attributes_setup.sh")?;
     let worktree_dir = dir.join("repo");
     let git_dir = worktree_dir.join(".git");
diff --git a/gix-worktree/tests/worktree/stack/mod.rs b/gix-worktree/tests/worktree/stack/mod.rs
index 29c4c86db70..2dfe1497d93 100644
--- a/gix-worktree/tests/worktree/stack/mod.rs
+++ b/gix-worktree/tests/worktree/stack/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_glob::pattern::Case;
 
 mod create_directory;
@@ -5,7 +6,7 @@ mod create_directory;
 mod attributes;
 mod ignore;
 
-fn probe_case() -> crate::Result<Case> {
+fn probe_case() -> Result<Case> {
     Ok(
         if gix_fs::Capabilities::probe(
             &gix_discover::upwards(".".as_ref())?
diff --git a/gix-zlib/Cargo.toml b/gix-zlib/Cargo.toml
index d37c0714d8e..aa0b14d762b 100644
--- a/gix-zlib/Cargo.toml
+++ b/gix-zlib/Cargo.toml
@@ -24,4 +24,5 @@ zlib-rs = "0.6.2"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 [dev-dependencies]
+insta = "1.46.3"
 bstr = { version = "1.12.0", default-features = false }
diff --git a/gix-zlib/src/decompress.rs b/gix-zlib/src/decompress.rs
index e0b6bc80662..8fc4ba1cb21 100644
--- a/gix-zlib/src/decompress.rs
+++ b/gix-zlib/src/decompress.rs
@@ -1,12 +1,9 @@
 //! Implementations for [`Decompress`](crate::Decompress).
 
-use gix_error::{CorruptionError, ErrorExt, ResourceExhaustionError, ResourceExhaustionKind, ValidationError, message};
+use gix_error::{ErrorExt, ExnResult, ResourceExhaustionKind, message};
 use zlib_rs::InflateError;
 
 use crate::{Decompress, FlushDecompress, Status};
-///
-/// The error produced by [`Decompress::decompress()`].
-pub type DecompressError = gix_error::Exn;
 
 impl Default for Decompress {
     fn default() -> Self {
@@ -44,12 +41,7 @@ impl Decompress {
     }
 
     /// Decompress `input` and write all decompressed bytes into `output`, with `flush` defining some details about this.
-    pub fn decompress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushDecompress,
-    ) -> Result<Status, DecompressError> {
+    pub fn decompress(&mut self, input: &[u8], output: &mut [u8], flush: FlushDecompress) -> ExnResult<Status> {
         let inflate_flush = match flush {
             FlushDecompress::None => zlib_rs::InflateFlush::NoFlush,
             FlushDecompress::Sync => zlib_rs::InflateFlush::SyncFlush,
@@ -61,12 +53,12 @@ impl Decompress {
             .decompress(input, output, inflate_flush)
             .map_err(|err| match err {
                 InflateError::NeedDict { .. } => {
-                    ValidationError::new("Decompressing this input requires a dictionary").raise_erased()
+                    gix_error::validation("Decompressing this input requires a dictionary").raise_erased()
                 }
                 InflateError::StreamError => message("stream error").raise_erased(),
-                InflateError::DataError => CorruptionError::new("Invalid input data").raise_erased(),
+                InflateError::DataError => gix_error::corruption("Invalid input data").raise_erased(),
                 InflateError::MemError => {
-                    ResourceExhaustionError::new(ResourceExhaustionKind::AllocationFailure, "Not enough memory")
+                    gix_error::resource_exhaustion(ResourceExhaustionKind::AllocationFailure, "Not enough memory")
                         .raise_erased()
                 }
             })?;
diff --git a/gix-zlib/src/inflate.rs b/gix-zlib/src/inflate.rs
index d42c0040e69..e6c88e084e6 100644
--- a/gix-zlib/src/inflate.rs
+++ b/gix-zlib/src/inflate.rs
@@ -1,13 +1,10 @@
-use gix_error::{Message, ResultExt, message};
+use gix_error::{ExnMessageResult, ResultExt, message};
 
 use crate::{FlushDecompress, Inflate, Status};
 
-/// The error returned by various [Inflate methods][super::Inflate]
-pub type Error = gix_error::Exn<Message>;
-
 impl Inflate {
     /// Run the decompressor exactly once. Cannot be run multiple times
-    pub fn once(&mut self, input: &[u8], out: &mut [u8]) -> Result<(Status, usize, usize), Error> {
+    pub fn once(&mut self, input: &[u8], out: &mut [u8]) -> ExnMessageResult<(Status, usize, usize)> {
         let before_in = self.state.total_in();
         let before_out = self.state.total_out();
         let status = self
diff --git a/gix-zlib/src/lib.rs b/gix-zlib/src/lib.rs
index b3dddec0d26..d49cba46ecd 100644
--- a/gix-zlib/src/lib.rs
+++ b/gix-zlib/src/lib.rs
@@ -96,4 +96,3 @@ pub mod stream;
 pub mod inflate;
 
 mod decompress;
-pub use decompress::DecompressError;
diff --git a/gix-zlib/src/stream/deflate.rs b/gix-zlib/src/stream/deflate.rs
index bd92d20cddf..4b5cdfdf178 100644
--- a/gix-zlib/src/stream/deflate.rs
+++ b/gix-zlib/src/stream/deflate.rs
@@ -1,7 +1,8 @@
 //! Compression state and a [`std::io::Write`] adapter for producing zlib streams.
 
 use crate::{Compression, Status};
-use gix_error::{CorruptionError, ErrorExt, ResourceExhaustionError, ResourceExhaustionKind, message};
+use gix_error::ExnResult;
+use gix_error::{ErrorExt, ResourceExhaustionKind, message};
 use zlib_rs::DeflateError;
 
 const BUF_SIZE: usize = 4096 * 8;
@@ -58,7 +59,7 @@ impl Compress {
     }
 
     /// Compress `input` and write compressed bytes to `output`, with `flush` controlling additional characteristics.
-    pub fn compress(&mut self, input: &[u8], output: &mut [u8], flush: FlushCompress) -> Result<Status, CompressError> {
+    pub fn compress(&mut self, input: &[u8], output: &mut [u8], flush: FlushCompress) -> ExnResult<Status> {
         let flush = match flush {
             FlushCompress::None => zlib_rs::DeflateFlush::NoFlush,
             FlushCompress::Partial => zlib_rs::DeflateFlush::PartialFlush,
@@ -68,9 +69,9 @@ impl Compress {
         };
         let status = self.0.compress(input, output, flush).map_err(|err| match err {
             DeflateError::StreamError => message("stream error").raise_erased(),
-            DeflateError::DataError => CorruptionError::new("The input is not a valid deflate stream.").raise_erased(),
+            DeflateError::DataError => gix_error::corruption("The input is not a valid deflate stream.").raise_erased(),
             DeflateError::MemError => {
-                ResourceExhaustionError::new(ResourceExhaustionKind::AllocationFailure, "Not enough memory")
+                gix_error::resource_exhaustion(ResourceExhaustionKind::AllocationFailure, "Not enough memory")
                     .raise_erased()
             }
         })?;
@@ -82,9 +83,6 @@ impl Compress {
     }
 }
 
-/// The error produced by [`Compress::compress()`].
-pub type CompressError = gix_error::Exn;
-
 /// Values which indicate the form of flushing to be used when compressing
 /// in-memory data.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
diff --git a/gix-zlib/src/stream/inflate.rs b/gix-zlib/src/stream/inflate.rs
index 5016a353c75..7330417aeeb 100644
--- a/gix-zlib/src/stream/inflate.rs
+++ b/gix-zlib/src/stream/inflate.rs
@@ -38,14 +38,12 @@ pub fn read(rd: &mut impl BufRead, state: &mut Decompress, mut dst: &mut [u8]) -
             Ok(Status::Ok | Status::BufError) => unreachable!("Definitely a bug somewhere"),
             // Keep the underlying zlib error so callers can tell a checksum mismatch
             // (`incorrect data check`) apart from genuine stream corruption.
-            Err(err) if err.downcast_any_ref::<gix_error::ResourceExhaustionError>().is_some() => {
+            Err(err) if err.is_resource_exhausted() => {
                 return Err(io::Error::other(err.into_error()));
             }
             Err(err) => {
                 let cause = state.error_message().map_or_else(|| err.to_string(), String::from);
-                let err = err.raise(gix_error::CorruptionError::new(format!(
-                    "corrupt deflate stream: {cause}"
-                )));
+                let err = err.raise(gix_error::corruption(format!("corrupt deflate stream: {cause}")));
                 return Err(io::Error::new(io::ErrorKind::InvalidInput, err.into_error()));
             }
         }
diff --git a/gix-zlib/tests/zlib/inflate.rs b/gix-zlib/tests/zlib/inflate.rs
index 6f0506c3e4b..3e0f99da75f 100644
--- a/gix-zlib/tests/zlib/inflate.rs
+++ b/gix-zlib/tests/zlib/inflate.rs
@@ -27,9 +27,13 @@ fn corrupt_streams_keep_classification_and_context() {
         .once(&input, &mut [0; 64])
         .expect_err("the corrupt header must be rejected");
 
-    assert_eq!(err, "Could not decode zip stream");
+    insta::assert_debug_snapshot!(err, "corrupt streams keep classification and context", @"
+    Could not decode zip stream
+    |
+    └─ Invalid input data
+    ");
     assert!(
-        err.downcast_any_ref::<gix_error::CorruptionError>().is_some(),
+        err.is_corrupted(),
         "the underlying invalid stream should be classified as corruption"
     );
 }
diff --git a/gix-zlib/tests/zlib/stream/deflate.rs b/gix-zlib/tests/zlib/stream/deflate.rs
index a88ac861324..251f733fba6 100644
--- a/gix-zlib/tests/zlib/stream/deflate.rs
+++ b/gix-zlib/tests/zlib/stream/deflate.rs
@@ -8,8 +8,6 @@ use bstr::ByteSlice;
 use gix_zlib::stream::deflate::{self, Compress, FlushCompress};
 use gix_zlib::{Compression, Decompress};
 
-type TestResult = gix_error::TestResult;
-
 pub(crate) fn compressed(data: &[u8]) -> Vec<u8> {
     let mut writer = deflate::Write::new(Vec::new(), Compression::BEST_SPEED);
     writer.write_all(data).expect("in-memory writes never fail");
@@ -46,7 +44,7 @@ where
 }
 
 #[test]
-fn small_file_decompress() -> TestResult {
+fn small_file_decompress() -> gix_error::TestResult {
     fn fixture_path(path: &str) -> std::path::PathBuf {
         std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
             .join("../gix-odb/tests/fixtures")
@@ -64,7 +62,7 @@ fn small_file_decompress() -> TestResult {
 }
 
 #[test]
-fn all_at_once() -> TestResult {
+fn all_at_once() -> gix_error::TestResult {
     let mut w = deflate::Write::new(Vec::new(), Compression::BEST_SPEED);
     assert_eq!(w.write(b"hello")?, 5);
     w.flush()?;
@@ -84,7 +82,7 @@ fn assert_deflate_buffer(out: Vec<u8>, expected: &[u8]) -> io::Result<()> {
 }
 
 #[test]
-fn higher_levels_compress_better() -> TestResult {
+fn higher_levels_compress_better() -> gix_error::TestResult {
     let data: Vec<u8> = (0..128 * 1024).map(|i| (i % 100) as u8).collect();
     let mut sizes = Vec::new();
     for level in [Compression::NONE, Compression::BEST_SPEED, Compression::DEFAULT] {
@@ -103,7 +101,7 @@ fn higher_levels_compress_better() -> TestResult {
 }
 
 #[test]
-fn big_file_small_writes() -> TestResult {
+fn big_file_small_writes() -> gix_error::TestResult {
     let mut w = deflate::Write::new(Vec::new(), Compression::BEST_SPEED);
     let bytes = include_bytes!(
         "../../../../gix-odb/tests/fixtures/objects/pack/pack-11fdfa9e156ab73caae3b6da867192221f2089c2.pack"
@@ -118,7 +116,7 @@ fn big_file_small_writes() -> TestResult {
 }
 
 #[test]
-fn big_file_a_few_big_writes() -> TestResult {
+fn big_file_a_few_big_writes() -> gix_error::TestResult {
     let mut w = deflate::Write::new(Vec::new(), Compression::BEST_SPEED);
     let bytes = include_bytes!(
         "../../../../gix-odb/tests/fixtures/objects/pack/pack-11fdfa9e156ab73caae3b6da867192221f2089c2.pack"
@@ -133,7 +131,7 @@ fn big_file_a_few_big_writes() -> TestResult {
 }
 
 #[test]
-fn compressor_lifecycle_counters_and_flush_modes() -> TestResult {
+fn compressor_lifecycle_counters_and_flush_modes() -> gix_error::TestResult {
     for flush in [
         FlushCompress::None,
         FlushCompress::Partial,
@@ -169,7 +167,7 @@ fn compressor_lifecycle_counters_and_flush_modes() -> TestResult {
 }
 
 #[test]
-fn writer_clone_and_reset() -> TestResult {
+fn writer_clone_and_reset() -> gix_error::TestResult {
     let original = deflate::Write::new(Vec::new(), Compression::BEST_SPEED);
     let mut cloned = original.clone();
     cloned.write_all(b"clone owns a fresh compressor")?;
diff --git a/gix-zlib/tests/zlib/stream/inflate.rs b/gix-zlib/tests/zlib/stream/inflate.rs
index f62e43c8364..a1bbf635bd3 100644
--- a/gix-zlib/tests/zlib/stream/inflate.rs
+++ b/gix-zlib/tests/zlib/stream/inflate.rs
@@ -11,13 +11,27 @@ fn errors_keep_the_underlying_cause() {
     let err = inflate::read(&mut checksum_mismatch.as_slice(), &mut Decompress::new(), &mut [0; 128])
         .expect_err("an invalid checksum must fail");
     assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-    assert_eq!(err.to_string(), "corrupt deflate stream: incorrect data check");
+    insta::assert_debug_snapshot!(err, "errors keep the underlying cause", @"
+    Custom {
+        kind: InvalidInput,
+        error: corrupt deflate stream: incorrect data check
+        |
+        └─ Invalid input data,
+    }
+    ");
 
     let mut corrupt_header = deflated(b"the header check protects this data");
     corrupt_header[0] = 0xff;
     let err = inflate::read(&mut corrupt_header.as_slice(), &mut Decompress::new(), &mut [0; 128])
         .expect_err("a corrupt stream must fail");
-    assert_eq!(err.to_string(), "corrupt deflate stream: incorrect header check");
+    insta::assert_debug_snapshot!(err, "errors keep the underlying cause", @"
+    Custom {
+        kind: InvalidInput,
+        error: corrupt deflate stream: incorrect header check
+        |
+        └─ Invalid input data,
+    }
+    ");
 }
 
 fn deflated(data: &[u8]) -> Vec<u8> {
diff --git a/gix/Cargo.toml b/gix/Cargo.toml
index 73534a643e1..545c6b7b223 100644
--- a/gix/Cargo.toml
+++ b/gix/Cargo.toml
@@ -296,6 +296,9 @@ max-performance = ["max-performance-safe"]
 ## All [`gix::Error`](crate::Error) will produce error chains, which makes them work as expected in conjunction with `anyhow`.
 auto-chain-error = ["gix-error/auto-chain-error"]
 
+## Allow [`gix::Exn`](crate::Exn) to convert directly into `anyhow::Error`.
+anyhow = ["gix-error/anyhow"]
+
 ## The opposite of `auto-chain-error`. Use it to override `auto-chain-error`.
 tree-error = ["gix-error/tree-error"]
 
@@ -403,7 +406,6 @@ gix-transport = { version = "^0.59.2", path = "../gix-transport", optional = tru
 # Just to get the progress-tree feature
 prodash = { version = "31.0.0", optional = true, features = ["progress-tree"] }
 signal-hook = { version = "0.4.3", default-features = false, optional = true }
-thiserror = "2.0.18"
 nonempty = "0.12.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = [
     "derive",
@@ -440,7 +442,7 @@ anyhow = "1"
 serial_test = { version = "3.4.0", default-features = false }
 async-std = { version = "1.12.0", features = ["attributes"] }
 termtree = "1.0.0"
-insta = "1.46.3"
+insta = { version = "1.46.3", features = ["filters"] }
 
 [package.metadata.docs.rs]
 features = [
diff --git a/gix/examples/init-repo-and-commit.rs b/gix/examples/init-repo-and-commit.rs
index 79129ebbe4f..5e44e6be320 100644
--- a/gix/examples/init-repo-and-commit.rs
+++ b/gix/examples/init-repo-and-commit.rs
@@ -20,8 +20,12 @@ fn main() -> anyhow::Result<()> {
     let empty_tree_id = repo.write_object(&tree)?.detach();
 
     let mut config = repo.config_snapshot_mut();
-    config.set_raw_value(Author::NAME, "Maria Sanchez")?;
-    config.set_raw_value(Author::EMAIL, "maria@example.com")?;
+    config
+        .set_raw_value(Author::NAME, "Maria Sanchez")
+        .map_err(gix::Exn::into_error)?;
+    config
+        .set_raw_value(Author::EMAIL, "maria@example.com")
+        .map_err(gix::Exn::into_error)?;
     {
         let repo = config.commit_auto_rollback()?;
         let initial_commit_id = repo.commit("HEAD", "initial commit", empty_tree_id, gix::commit::NO_PARENT_IDS)?;
diff --git a/gix/examples/stats.rs b/gix/examples/stats.rs
index c9c32ce6c1f..d79359d835e 100644
--- a/gix/examples/stats.rs
+++ b/gix/examples/stats.rs
@@ -2,7 +2,7 @@ use std::io::Write;
 
 use gix::{Reference, prelude::ObjectIdExt};
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let mut repo = gix::discover(".")?;
     println!("Repo: {}", repo.workdir().unwrap_or_else(|| repo.git_dir()).display());
     let mut max_parents = 0;
diff --git a/gix/src/clone/access.rs b/gix/src/clone/access.rs
index 0ba03f9e587..cc951342c90 100644
--- a/gix/src/clone/access.rs
+++ b/gix/src/clone/access.rs
@@ -1,5 +1,5 @@
 use crate::{
-    Repository,
+    ExnResult, Repository, Result,
     bstr::{BString, ByteSlice},
     clone::PrepareFetch,
 };
@@ -18,7 +18,7 @@ impl PrepareFetch {
     /// Otherwise, a clone is configured to be complete and fetches all tags, not only those reachable from all branches.
     pub fn configure_remote(
         mut self,
-        f: impl FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, Box<dyn std::error::Error + Send + Sync>> + 'static,
+        f: impl FnMut(crate::Remote<'_>) -> ExnResult<crate::Remote<'_>> + 'static,
     ) -> Self {
         self.configure_remote = Some(Box::new(f));
         self
@@ -28,7 +28,7 @@ impl PrepareFetch {
     /// [`configure_remote()`](Self::configure_remote()).
     ///
     /// If not set here, it defaults to `origin` or the value of `clone.defaultRemoteName`.
-    pub fn with_remote_name(mut self, name: impl Into<BString>) -> Result<Self, crate::remote::name::Error> {
+    pub fn with_remote_name(mut self, name: impl Into<BString>) -> Result<Self> {
         self.remote_name = Some(crate::remote::name::validated(name)?);
         Ok(self)
     }
@@ -55,7 +55,7 @@ impl PrepareFetch {
     ///
     /// Setting `name` to `Some(_)` clears a revision previously set with [`with_revision()`](Self::with_revision).
     /// Passing `None` leaves the revision unchanged.
-    pub fn with_ref_name<'a, Name, E>(mut self, name: Option<Name>) -> Result<Self, E>
+    pub fn with_ref_name<'a, Name, E>(mut self, name: Option<Name>) -> std::result::Result<Self, E>
     where
         Name: TryInto<&'a gix_ref::PartialNameRef, Error = E>,
     {
@@ -77,7 +77,7 @@ impl PrepareFetch {
     pub fn with_revision(
         mut self,
         revision: Option<impl Into<BString>>,
-    ) -> Result<Self, crate::clone::with_revision::Error> {
+    ) -> std::result::Result<Self, crate::clone::with_revision::Error> {
         self.revision = revision
             .map(|revision| {
                 let revision = revision.into();
diff --git a/gix/src/clone/checkout.rs b/gix/src/clone/checkout.rs
index d2296203cac..dea4159a55c 100644
--- a/gix/src/clone/checkout.rs
+++ b/gix/src/clone/checkout.rs
@@ -2,40 +2,11 @@ use crate::{Repository, clone::PrepareCheckout};
 
 ///
 pub mod main_worktree {
-    use std::{path::PathBuf, sync::atomic::AtomicBool};
-
-    use crate::{Progress, Repository, clone::PrepareCheckout};
-
-    /// The error returned by [`PrepareCheckout::main_worktree()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Repository at \"{}\" is a bare repository and cannot have a main worktree checkout", git_dir.display())]
-        BareRepository { git_dir: PathBuf },
-        #[error("The object pointed to by HEAD is not a treeish")]
-        NoHeadTree(#[from] crate::object::peel::to_kind::Error),
-        #[error("Could not create index from tree at {id}")]
-        IndexFromTree {
-            id: gix_hash::ObjectId,
-            source: gix_index::init::from_tree::Error,
-        },
-        #[error("Couldn't obtain configuration for core.protect*")]
-        BooleanConfig(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        WriteIndex(#[from] gix_index::file::write::Error),
-        #[error(transparent)]
-        CheckoutOptions(#[from] crate::config::checkout_options::Error),
-        #[error(transparent)]
-        IndexCheckout(#[from] gix_worktree_state::checkout::Error),
-        #[error(transparent)]
-        Peel(#[from] crate::reference::peel::Error),
-        #[error("Failed to reopen object database as Arc (only if thread-safety wasn't compiled in)")]
-        OpenArcOdb(#[from] std::io::Error),
-        #[error("The HEAD reference could not be located")]
-        FindHead(#[from] crate::reference::find::existing::Error),
-        #[error("The HEAD reference could not be located")]
-        PeelHeadToId(#[from] crate::head::peel::Error),
-    }
+    use std::sync::atomic::AtomicBool;
+
+    use gix_error::ResultExt;
+
+    use crate::{Error, Progress, Repository, Result, clone::PrepareCheckout};
 
     /// The progress ids used in [`PrepareCheckout::main_worktree()`].
     ///
@@ -74,7 +45,7 @@ pub mod main_worktree {
             &mut self,
             mut progress: P,
             should_interrupt: &AtomicBool,
-        ) -> Result<(Repository, gix_worktree_state::checkout::Outcome), Error>
+        ) -> Result<(Repository, gix_worktree_state::checkout::Outcome)>
         where
             P: gix_features::progress::NestedProgress,
             P::SubProgress: gix_features::progress::NestedProgress + 'static,
@@ -86,23 +57,41 @@ pub mod main_worktree {
             &mut self,
             progress: &mut dyn gix_features::progress::DynNestedProgress,
             should_interrupt: &AtomicBool,
-        ) -> Result<(Repository, gix_worktree_state::checkout::Outcome), Error> {
+        ) -> Result<(Repository, gix_worktree_state::checkout::Outcome)> {
             let _span = gix_trace::coarse!("gix::clone::PrepareCheckout::main_worktree()");
             let repo = self
                 .repo
                 .as_ref()
                 .expect("BUG: this method may only be called until it is successful");
-            let workdir = repo.workdir().ok_or_else(|| Error::BareRepository {
-                git_dir: repo.git_dir().to_owned(),
+            let workdir = repo.workdir().ok_or_else(|| {
+                Error::from_error(gix_error::message!(
+                    "Repository at \"{}\" is a bare repository and cannot have a main worktree checkout",
+                    repo.git_dir().display()
+                ))
             })?;
 
             let root_tree_id = match &self.ref_name {
-                Some(reference_val) => Some(repo.find_reference(reference_val)?.peel_to_id()?),
-                None => repo.head()?.try_peel_to_id()?,
+                Some(reference_val) => Some(
+                    repo.find_reference(reference_val)
+                        .or_raise(|| gix_error::message("The HEAD reference could not be located"))?
+                        .peel_to_id()
+                        .or_erased()?,
+                ),
+                None => repo
+                    .head()
+                    .or_raise(|| gix_error::message("The HEAD reference could not be located"))?
+                    .try_peel_to_id()
+                    .or_raise(|| gix_error::message("The HEAD reference could not be located"))?,
             };
 
             let root_tree = match root_tree_id {
-                Some(id) => id.object().expect("downloaded from remote").peel_to_tree()?.id,
+                Some(id) => {
+                    id.object()
+                        .expect("downloaded from remote")
+                        .peel_to_tree()
+                        .or_raise(|| gix_error::message("The object pointed to by HEAD is not a treeish"))?
+                        .id
+                }
                 None => {
                     return Ok((
                         self.repo.take().expect("still present"),
@@ -111,11 +100,12 @@ pub mod main_worktree {
                 }
             };
 
-            let index = gix_index::State::from_tree(&root_tree, &repo.objects, repo.config.protect_options()?)
-                .map_err(|err| Error::IndexFromTree {
-                    id: root_tree,
-                    source: err,
-                })?;
+            let protect_options = repo
+                .config
+                .protect_options()
+                .or_raise(|| gix_error::message("Couldn't obtain configuration for core.protect*"))?;
+            let index = gix_index::State::from_tree(&root_tree, &repo.objects, protect_options)
+                .or_raise(|| gix_error::message!("Could not create index from tree at {root_tree}"))?;
             let mut index = gix_index::File::from_state(index, repo.index_path());
 
             let mut opts = repo.checkout_options(gix_worktree::stack::state::attributes::Source::IdMapping)?;
@@ -131,7 +121,11 @@ pub mod main_worktree {
             let outcome = gix_worktree_state::checkout(
                 &mut index,
                 workdir,
-                repo.objects.clone().into_arc()?,
+                repo.objects.clone().into_arc().or_raise(|| {
+                    gix_error::message(
+                        "Failed to reopen object database as Arc (only if thread-safety wasn't compiled in)",
+                    )
+                })?,
                 &files,
                 &bytes,
                 should_interrupt,
diff --git a/gix/src/clone/fetch/mod.rs b/gix/src/clone/fetch/mod.rs
index a989f292cde..f0908f6f062 100644
--- a/gix/src/clone/fetch/mod.rs
+++ b/gix/src/clone/fetch/mod.rs
@@ -1,89 +1,11 @@
-use crate::{
-    bstr::{BStr, BString, ByteSlice},
-    clone::PrepareFetch,
-};
+use crate::{Error, Result, bstr::BStr, clone::PrepareFetch};
+use gix_error::ResultExt;
 use gix_ref::Category;
 
 use crate::config::tree::Key;
 
-/// The error returned by [`PrepareFetch::fetch_only()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Connect(#[from] crate::remote::connect::Error),
-    #[error(transparent)]
-    PrepareFetch(#[from] crate::remote::fetch::prepare::Error),
-    #[error(transparent)]
-    Fetch(#[from] crate::remote::fetch::Error),
-    #[error(transparent)]
-    RemoteInit(#[from] crate::remote::init::Error),
-    #[error("Custom configuration of remote to clone from failed")]
-    RemoteConfiguration(#[source] Box<dyn std::error::Error + Send + Sync>),
-    #[error("Custom configuration of connection to use when cloning failed")]
-    RemoteConnection(#[source] Box<dyn std::error::Error + Send + Sync>),
-    #[error(transparent)]
-    RemoteName(#[from] crate::config::remote::symbolic_name::Error),
-    #[error(transparent)]
-    ParseConfig(#[from] crate::config::overrides::Error),
-    #[error(transparent)]
-    ApplyConfig(#[from] crate::config::Error),
-    #[error(transparent)]
-    Span(#[from] gix_config::parse::span::Error),
-    #[error(transparent)]
-    ConfigValue(#[from] gix_config::file::section::value::Error),
-    #[error("Failed to load repo-local git configuration before writing")]
-    LoadConfig(#[from] gix_config::file::init::from_paths::Error),
-    #[error("Failed to store configured remote in memory")]
-    SaveConfig(#[from] crate::remote::save::AsError),
-    #[error("Failed to write repository configuration to disk")]
-    SaveConfigIo(#[from] std::io::Error),
-    #[error("Failed to acquire lock to write repository configuration to disk")]
-    SaveConfigLockAcquire(#[source] gix_error::Error),
-    #[error("Failed to commit lock after writing repository configuration to disk")]
-    SaveConfigLockCommit(#[from] gix_lock::commit::Error<gix_lock::File>),
-    #[error("The remote HEAD points to a reference named {head_ref_name:?} which is invalid.")]
-    InvalidHeadRef {
-        source: gix_validate::reference::name::Error,
-        head_ref_name: crate::bstr::BString,
-    },
-    #[error("Failed to update HEAD with values from remote")]
-    HeadUpdate(#[from] crate::reference::edit::Error),
-    #[error("The remote didn't have any ref that matched '{}'", wanted.as_ref().as_bstr())]
-    RefNameMissing { wanted: gix_ref::PartialName },
-    #[error("The remote has {} refs for '{}', try to use a specific name: {}", candidates.len(), wanted.as_ref().as_bstr(), candidates.iter().filter_map(|n| n.to_str().ok()).collect::<Vec<_>>().join(", "))]
-    RefNameAmbiguous {
-        wanted: gix_ref::PartialName,
-        candidates: Vec<BString>,
-    },
-    #[error("The remote didn't have the requested revision {wanted:?}")]
-    RevisionMissing { wanted: BString },
-    #[error("The requested revision could not be read")]
-    FindRevision(#[from] crate::object::find::existing::Error),
-    #[error("The requested revision did not peel to a commit")]
-    PeelRevision(#[from] crate::object::peel::to_kind::Error),
-    #[error(transparent)]
-    CommitterOrFallback(#[from] crate::config::commit_signature::Error),
-    #[error(transparent)]
-    RefMap(#[from] crate::remote::ref_map::Error),
-    #[error(transparent)]
-    ReferenceName(#[from] gix_validate::reference::name::Error),
-    #[error(
-        "Remote now uses {remote} even though the local repository was reconfigured to {local} \
-        to match the remote's previously advertised object format. The server is advertising \
-        inconsistent formats; if the correct one is known, pass `create::Options {{ \
-        object_hash: Some(gix_hash::Kind::{remote:?}), .. }}` to `PrepareFetch::new` to pin it."
-    )]
-    IncompatibleObjectHash {
-        local: gix_hash::Kind,
-        remote: gix_hash::Kind,
-    },
-    #[cfg(feature = "sha256")]
-    #[error("Failed to reopen the local repository after adopting the remote's object format")]
-    ReopenWithObjectHash(#[from] crate::open::Error),
-    #[cfg(feature = "sha256")]
-    #[error("Failed to transfer in-memory configuration after adopting the remote's object format")]
-    TransferInMemoryConfig(#[from] gix_config::file::init::Error),
+fn mapping_validation(err: &Error) -> Option<&gix_refspec::match_group::validate::Error> {
+    err.downcast_any_ref()
 }
 
 /// Modification
@@ -107,7 +29,7 @@ impl PrepareFetch {
         &mut self,
         mut progress: P,
         should_interrupt: &std::sync::atomic::AtomicBool,
-    ) -> Result<(crate::Repository, crate::remote::fetch::Outcome), Error>
+    ) -> Result<(crate::Repository, crate::remote::fetch::Outcome)>
     where
         P: crate::NestedProgress,
         P::SubProgress: 'static,
@@ -120,11 +42,13 @@ impl PrepareFetch {
             .expect("user error: multiple calls are allowed only until it succeeds")
             .clone();
 
-        repo.committer_or_set_generic_fallback()?;
+        repo.committer_or_set_generic_fallback().or_erased()?;
 
         if !self.config_overrides.is_empty() {
             let mut snapshot = repo.config_snapshot_mut();
-            snapshot.append_config(&self.config_overrides, gix_config::Source::Api)?;
+            snapshot
+                .append_config(&self.config_overrides, gix_config::Source::Api)
+                .or_erased()?;
         }
 
         let remote_name = match self.remote_name.as_ref() {
@@ -151,13 +75,15 @@ impl PrepareFetch {
             && self.fetch_options.extra_refspecs.is_empty()
             && self.revision.is_none();
 
-        let target_ref = if use_single_branch_for_shallow {
+        let target_ref: Option<gix_ref::FullName> = if use_single_branch_for_shallow {
             // Determine target branch from user-specified ref_name or default branch
             if let Some(ref_name) = &self.ref_name {
                 let prev_tags = std::mem::replace(&mut remote.fetch_tags, remote::fetch::Tags::None);
                 let mut connection = remote.connect(remote::Direction::Fetch).await?;
                 if let Some(f) = self.configure_connection.as_mut() {
-                    f(&mut connection).map_err(Error::RemoteConnection)?;
+                    f(&mut connection).or_raise(|| {
+                        gix_error::message("Custom configuration of connection to use when cloning failed")
+                    })?;
                 }
                 let (refmap, _) = connection
                     .ref_map(
@@ -174,14 +100,16 @@ impl PrepareFetch {
                     .await?;
                 let (_target, full_ref_name) = util::find_custom_refname(&refmap, ref_name)?;
                 remote.fetch_tags = prev_tags;
-                Some(full_ref_name.try_into()?)
+                Some(gix_ref::FullName::try_from(full_ref_name).or_erased()?)
             } else {
                 // For shallow clones without a specified ref, we need to determine the ref to clone.
                 // Just fetch HEAD for that.
                 let prev_tags = std::mem::replace(&mut remote.fetch_tags, remote::fetch::Tags::None);
                 let mut connection = remote.connect(remote::Direction::Fetch).await?;
                 if let Some(f) = self.configure_connection.as_mut() {
-                    f(&mut connection).map_err(Error::RemoteConnection)?;
+                    f(&mut connection).or_raise(|| {
+                        gix_error::message("Custom configuration of connection to use when cloning failed")
+                    })?;
                 }
                 let (refmap, _) = connection
                     .ref_map(
@@ -208,17 +136,18 @@ impl PrepareFetch {
                         | gix_protocol::handshake::Ref::Unborn {
                             full_ref_name, target, ..
                         } if full_ref_name == "HEAD" => gix_ref::FullName::try_from(target)
-                            .map_err(|err| Error::InvalidHeadRef {
-                                head_ref_name: target.clone(),
-                                source: err,
+                            .or_raise(|| {
+                                gix_error::validation(format!(
+                                    "The remote HEAD points to a reference named {target:?} which is invalid."
+                                ))
                             })
                             .into(),
                         _ => None,
                     })
                     .transpose()?;
 
-                let target = target.ok_or_else(|| Error::RefNameMissing {
-                    wanted: "HEAD".try_into().expect("valid partial name"),
+                let target = target.ok_or_else(|| {
+                    Error::from_error(gix_error::not_found("The remote didn't have a ref that matched 'HEAD'"))
                 })?;
 
                 remote.fetch_tags = prev_tags;
@@ -259,7 +188,8 @@ impl PrepareFetch {
 
         let mut clone_fetch_tags = None;
         if let Some(f) = self.configure_remote.as_mut() {
-            remote = f(remote).map_err(Error::RemoteConfiguration)?;
+            remote =
+                f(remote).or_raise(|| gix_error::message("Custom configuration of remote to clone from failed"))?;
         } else if self.revision.is_none() {
             clone_fetch_tags = remote::fetch::Tags::All.into();
         }
@@ -298,7 +228,8 @@ impl PrepareFetch {
             // For shallow clones, we already connected once, so we need to connect again
             let mut connection = remote.connect(remote::Direction::Fetch).await?;
             if let Some(f) = self.configure_connection.as_mut() {
-                f(&mut connection).map_err(Error::RemoteConnection)?;
+                f(&mut connection)
+                    .or_raise(|| gix_error::message("Custom configuration of connection to use when cloning failed"))?;
             }
             let connection = connection.into_detached();
             let mut fetch_opts = {
@@ -322,17 +253,18 @@ impl PrepareFetch {
             };
             match connection.prepare_fetch(&repo, &mut progress, fetch_opts.clone()).await {
                 Ok(prepare) => prepare,
-                Err(remote::fetch::prepare::Error::RefMap(remote::ref_map::Error::InitRefMap(
-                    gix_protocol::fetch::refmap::init::Error::MappingValidation(err),
-                ))) if err.issues.len() == 1
-                    && fetch_opts.extra_refspecs.contains(&head_refspec)
-                    && matches!(
-                        err.issues.first(),
-                        Some(gix_refspec::match_group::validate::Issue::Conflict {
-                            destination_full_ref_name,
-                            ..
-                        }) if *destination_full_ref_name == head_local_tracking_branch
-                    ) =>
+                Err(err)
+                    if fetch_opts.extra_refspecs.contains(&head_refspec)
+                        && mapping_validation(&err).is_some_and(|err| {
+                            err.issues.len() == 1
+                                && matches!(
+                                    err.issues.first(),
+                                    Some(gix_refspec::match_group::validate::Issue::Conflict {
+                                        destination_full_ref_name,
+                                        ..
+                                    }) if destination_full_ref_name.as_slice() == head_local_tracking_branch.as_bytes()
+                                )
+                        }) =>
                 {
                     let head_refspec_idx = fetch_opts
                         .extra_refspecs
@@ -348,7 +280,7 @@ impl PrepareFetch {
                     fetch_opts.extra_refspecs.remove(head_refspec_idx);
                     connection.prepare_fetch(&repo, &mut progress, fetch_opts).await?
                 }
-                Err(err) => return Err(err.into()),
+                Err(err) => return Err(err),
             }
         };
         drop(remote);
@@ -368,9 +300,12 @@ impl PrepareFetch {
             let remote_object_hash = pending_pack.ref_map().object_hash;
             if remote_object_hash != repo.object_hash() {
                 let mut in_memory_config = Vec::new();
-                repo.config.resolved.write_to_filter(&mut in_memory_config, |section| {
-                    section.meta().source == gix_config::Source::Api
-                })?;
+                repo.config
+                    .resolved
+                    .write_to_filter(&mut in_memory_config, |section| {
+                        section.meta().source == gix_config::Source::Api
+                    })
+                    .or_erased()?;
                 // Reopen the still-empty repo with the remote's format; on error the original is kept for a retry.
                 repo = util::reinitialize_with_object_hash(&repo, remote_object_hash)?;
                 let mut resolved_config = repo.config.resolved.as_ref().clone();
@@ -380,11 +315,17 @@ impl PrepareFetch {
                 // TODO: make this much easier - we go from parsed-to-buffer-to-parsed.
                 //       Maybe make API changes available as overlay, just as utility over
                 //       Api sections.
-                resolved_config.append(gix_config::File::from_bytes_owned(
-                    &mut in_memory_config,
-                    gix_config::file::Metadata::api(),
-                    Default::default(),
-                )?)?;
+                resolved_config
+                    .append(gix_config::File::from_bytes_owned(
+                        &mut in_memory_config,
+                        gix_config::file::Metadata::api(),
+                        Default::default(),
+                    )?)
+                    .or_raise(|| {
+                        gix_error::message(
+                            "Failed to transfer in-memory configuration after adopting the remote's object format",
+                        )
+                    })?;
                 repo.config
                     .reread_values_and_clear_caches_replacing_config(resolved_config.into())?;
                 config = None;
@@ -407,7 +348,7 @@ impl PrepareFetch {
         // Before finalisation, the current repo handle still needs to
         // learn about the remote config written after it was opened.
         if let Some(config) = config {
-            util::append_config_to_repo_config(&mut repo, config)?;
+            util::append_config_to_repo_config(&mut repo, config).or_erased()?;
         }
         util::update_head(
             &mut repo,
@@ -428,7 +369,7 @@ impl PrepareFetch {
         &mut self,
         progress: P,
         should_interrupt: &std::sync::atomic::AtomicBool,
-    ) -> Result<(crate::clone::PrepareCheckout, crate::remote::fetch::Outcome), Error>
+    ) -> Result<(crate::clone::PrepareCheckout, crate::remote::fetch::Outcome)>
     where
         P: crate::NestedProgress,
         P::SubProgress: 'static,
diff --git a/gix/src/clone/fetch/util.rs b/gix/src/clone/fetch/util.rs
index f1a9a171eca..268b230244d 100644
--- a/gix/src/clone/fetch/util.rs
+++ b/gix/src/clone/fetch/util.rs
@@ -1,13 +1,13 @@
 use std::io::Write;
 
+use gix_error::{ExnMessageResult, ResultExt};
 use gix_ref::{
     Category, FullNameRef, PartialName,
     transaction::{LogChange, RefLog},
 };
 
-use super::Error;
 use crate::{
-    Repository,
+    Error, Repository, Result,
     bstr::{BStr, BString, ByteSlice},
 };
 
@@ -15,19 +15,17 @@ enum WriteMode {
     Overwrite,
     Append,
 }
-
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 pub fn append_remote_to_local_config_file(
     remote: &mut crate::Remote<'_>,
     remote_name: BString,
-) -> Result<gix_config::File, Error> {
+) -> Result<gix_config::File> {
     let mut config = gix_config::File::new(local_config_meta(remote.repo));
-    remote.save_as_to(remote_name, &mut config)?;
+    remote
+        .save_as_to(remote_name, &mut config)
+        .or_raise(|| gix_error::message("Failed to store configured remote in memory"))?;
 
-    write_to_local_config(&config, WriteMode::Append)?;
+    write_to_local_config(&config, WriteMode::Append)
+        .or_raise(|| gix_error::message("Failed to write repository configuration to disk"))?;
     Ok(config)
 }
 
@@ -51,33 +49,43 @@ pub fn append_remote_to_local_config_file(
 pub(super) fn reinitialize_with_object_hash(
     repo: &crate::Repository,
     object_hash: gix_hash::Kind,
-) -> Result<crate::Repository, Error> {
+) -> Result<crate::Repository> {
     let git_dir = repo.git_dir();
     let config_path = git_dir.join("config");
 
-    let mut config = gix_config::File::from_path_no_includes(config_path.clone(), gix_config::Source::Local)?;
+    let mut config = gix_config::File::from_path_no_includes(config_path.clone(), gix_config::Source::Local)
+        .or_raise(|| gix_error::message("Failed to load repo-local git configuration before writing"))?;
     // Mirror what `crate::create` writes at init time: only SHA-256 repositories get
     // `repositoryformatversion = 1` along with the `objectformat` extension.
     let is_sha256 = object_hash == gix_hash::Kind::Sha256;
     config
         .section_mut("core", None)
         .expect("freshly initialized repository has a core section")
-        .set("repositoryformatversion", if is_sha256 { "1" } else { "0" })?;
+        .set("repositoryformatversion", if is_sha256 { "1" } else { "0" })
+        .or_erased()?;
     if is_sha256 {
         config
             .section_mut_or_create_new("extensions", None)
             .expect("valid section name")
-            .set("objectformat", object_hash.to_string())?;
+            .set("objectformat", object_hash.to_string())
+            .or_erased()?;
     } else {
         // In a freshly initialized repository, this section exists solely to carry `objectformat`.
         config.remove_section("extensions", None);
     }
     let mut lock = gix_lock::File::acquire_to_update_resource(&config_path, gix_lock::acquire::Fail::Immediately, None)
-        .map_err(|err| Error::SaveConfigLockAcquire(err.into_error()))?;
-    config.write_to_filter(&mut lock, |section| section.meta().source == gix_config::Source::Local)?;
-    lock.commit()?;
+        .or_raise(|| gix_error::message("Failed to acquire lock to write repository configuration to disk"))?;
+    config
+        .write_to_filter(&mut lock, |section| section.meta().source == gix_config::Source::Local)
+        .or_raise(|| gix_error::message("Failed to write repository configuration to disk"))?;
+    lock.commit()
+        .or_raise(|| gix_error::message("Failed to commit lock after writing repository configuration to disk"))?;
 
-    Ok(crate::ThreadSafeRepository::open_opts(git_dir, repo.options.clone())?.to_thread_local())
+    Ok(crate::ThreadSafeRepository::open_opts(git_dir, repo.options.clone())
+        .or_raise(|| {
+            gix_error::message("Failed to reopen the local repository after adopting the remote's object format")
+        })?
+        .to_thread_local())
 }
 
 fn local_config_meta(repo: &Repository) -> gix_config::file::Metadata {
@@ -110,10 +118,7 @@ fn write_to_local_config(config: &gix_config::File, mode: WriteMode) -> std::io:
 /// This is used after writing clone-specific local configuration to `.git/config`,
 /// as the `repo` handle was opened before that write and won't observe it until
 /// it is either updated in memory or reopened.
-pub fn append_config_to_repo_config(
-    repo: &mut Repository,
-    config: gix_config::File,
-) -> Result<(), gix_config::parse::span::Error> {
+pub fn append_config_to_repo_config(repo: &mut Repository, config: gix_config::File) -> ExnMessageResult {
     let repo_config = gix_features::threading::OwnShared::make_mut(&mut repo.config.resolved);
     repo_config.append(config)?;
     Ok(())
@@ -129,15 +134,18 @@ pub fn update_head(
     remote_name: &BStr,
     ref_name: Option<&PartialName>,
     revision: Option<&gix_refspec::RefSpec>,
-) -> Result<(), Error> {
+) -> Result<()> {
     use gix_ref::transaction::{PreviousValue, RefEdit};
     let revision_head_id = revision
-        .map(|revision| -> Result<gix_hash::ObjectId, Error> {
+        .map(|revision| -> Result<gix_hash::ObjectId> {
             let mapping = find_revision(ref_map, revision)?;
-            let id = mapping.remote.peeled_id().ok_or_else(|| Error::RevisionMissing {
-                wanted: revision.to_ref().source().expect("validated revision").to_owned(),
-            })?;
-            Ok(repo.find_object(id)?.peel_to_commit()?.id)
+            let id = mapping.remote.peeled_id().ok_or_else(|| revision_missing(revision))?;
+            Ok(repo
+                .find_object(id)
+                .or_raise(|| gix_error::message("The requested revision could not be read"))?
+                .peel_to_commit()
+                .or_raise(|| gix_error::message("The requested revision did not peel to a commit"))?
+                .id)
         })
         .transpose()?;
     let head_info = match revision_head_id.as_ref() {
@@ -178,9 +186,10 @@ pub fn update_head(
     };
     match head_ref {
         Some(referent) => {
-            let referent: gix_ref::FullName = referent.try_into().map_err(|err| Error::InvalidHeadRef {
-                head_ref_name: referent.to_owned(),
-                source: err,
+            let referent: gix_ref::FullName = gix_ref::FullName::try_from(referent).or_raise(|| {
+                gix_error::validation(format!(
+                    "The remote HEAD points to a reference named {referent:?} which is invalid."
+                ))
             })?;
             repo.refs
                 .transaction()
@@ -208,13 +217,13 @@ pub fn update_head(
                     gix_lock::acquire::Fail::Immediately,
                     gix_lock::acquire::Fail::Immediately,
                 )
-                .map_err(crate::reference::edit::Error::from)?
+                .or_raise(|| gix_error::message("Failed to update HEAD with values from remote"))?
                 .commit(
                     repo.committer()
                         .transpose()
-                        .map_err(|err| Error::HeadUpdate(crate::reference::edit::Error::ParseCommitterTime(err)))?,
+                        .or_raise(|| gix_error::message("Failed to update HEAD with values from remote"))?,
                 )
-                .map_err(crate::reference::edit::Error::from)?;
+                .or_raise(|| gix_error::message("Failed to update HEAD with values from remote"))?;
 
             if let Some(head_peeled_id) = head_peeled_id {
                 let mut log = reflog_message();
@@ -224,7 +233,8 @@ pub fn update_head(
                     head_peeled_id.to_owned(),
                     PreviousValue::Any,
                     log,
-                ))?;
+                ))
+                .or_raise(|| gix_error::message("Failed to update HEAD with values from remote"))?;
             }
 
             setup_branch_config(repo, referent.as_ref(), head_peeled_id, remote_name)?;
@@ -237,7 +247,8 @@ pub fn update_head(
                     .to_owned(),
                 PreviousValue::Any,
                 reflog_message(),
-            ))?;
+            ))
+            .or_raise(|| gix_error::message("Failed to update HEAD with values from remote"))?;
         }
     }
     Ok(())
@@ -245,11 +256,11 @@ pub fn update_head(
 
 /// Find the mapping produced by the exact refspec used to request `revision`.
 ///
-/// Returns [`Error::RevisionMissing`] if the remote did not map that refspec.
+/// Returns an error if the remote did not map that refspec.
 pub(super) fn find_revision<'a>(
     ref_map: &'a crate::remote::fetch::RefMap,
     revision: &gix_refspec::RefSpec,
-) -> Result<&'a gix_protocol::fetch::refmap::Mapping, Error> {
+) -> Result<&'a gix_protocol::fetch::refmap::Mapping> {
     ref_map
         .mappings
         .iter()
@@ -259,19 +270,25 @@ pub(super) fn find_revision<'a>(
                 .get(&ref_map.refspecs, &ref_map.extra_refspecs)
                 .is_some_and(|spec| spec == revision)
         })
-        .ok_or_else(|| Error::RevisionMissing {
-            wanted: revision.to_ref().source().expect("validated revision").to_owned(),
-        })
+        .ok_or_else(|| revision_missing(revision))
+}
+
+fn revision_missing(revision: &gix_refspec::RefSpec) -> Error {
+    Error::from_error(gix_error::not_found(format!(
+        "The remote didn't have the requested revision {:?}",
+        revision.to_ref().source().expect("validated revision")
+    )))
 }
 
 /// Resolve `ref_name` to its object ID and full name among the mapped remote references.
 ///
 /// Full names match directly. Partial names prefer branches over tags, then use normal refspec matching.
-/// Returns [`Error::RefNameMissing`] or [`Error::RefNameAmbiguous`] when there is no unique match.
+/// Returns an error when there is no unique match.
+/// Ambiguous matches include the requested reference name bytes as `input` [metadata](gix_error::Error::metadata()).
 pub(super) fn find_custom_refname<'a>(
     ref_map: &'a crate::remote::fetch::RefMap,
     ref_name: &PartialName,
-) -> Result<(&'a gix_hash::oid, &'a BStr), Error> {
+) -> Result<(&'a gix_hash::oid, &'a BStr)> {
     let group = gix_refspec::MatchGroup::from_fetch_specs(Some(
         gix_refspec::parse(ref_name.as_ref().as_bstr(), gix_refspec::parse::Operation::Fetch)
             .expect("partial names are valid refs"),
@@ -294,12 +311,12 @@ pub(super) fn find_custom_refname<'a>(
         return Ok((item.target, item.full_ref_name));
     }
     if !requested_name.starts_with(b"refs/") {
-        let branch_name = Category::LocalBranch.to_full_name(requested_name)?;
+        let branch_name = Category::LocalBranch.to_full_name(requested_name).or_erased()?;
         if let Some(item) = find_item(branch_name.as_bstr()) {
             return Ok((item.target, item.full_ref_name));
         }
 
-        let tag_name = Category::Tag.to_full_name(requested_name)?;
+        let tag_name = Category::Tag.to_full_name(requested_name).or_erased()?;
         if let Some(item) = find_item(tag_name.as_bstr()) {
             return Ok((item.target, item.full_ref_name));
         }
@@ -307,26 +324,37 @@ pub(super) fn find_custom_refname<'a>(
 
     let res = group.match_lhs(filtered_items.iter().copied());
     match res.mappings.len() {
-        0 => Err(Error::RefNameMissing {
-            wanted: ref_name.clone(),
-        }),
+        0 => Err(Error::from_error(gix_error::not_found(format!(
+            "The remote didn't have any ref that matched '{requested_name}'"
+        )))),
         1 => {
             let item = filtered_items[res.mappings[0]
                 .item_index
                 .expect("we map by name only and have no object-id in refspec")];
             Ok((item.target, item.full_ref_name))
         }
-        _ => Err(Error::RefNameAmbiguous {
-            wanted: ref_name.clone(),
-            candidates: res
+        _ => {
+            let candidates = res
                 .mappings
                 .into_iter()
                 .filter_map(|m| match m.lhs {
                     gix_refspec::match_group::SourceRef::FullName(name) => Some(name.into_owned()),
                     gix_refspec::match_group::SourceRef::ObjectId(_) => None,
                 })
-                .collect(),
-        }),
+                .collect::<Vec<_>>();
+            Err(Error::from_error(
+                gix_error::validation(format!(
+                    "The remote has {} refs for '{requested_name}', try to use a specific name: {}",
+                    candidates.len(),
+                    candidates
+                        .iter()
+                        .filter_map(|name| name.to_str().ok())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ))
+                .with("input", ref_name.as_ref().as_bstr().to_owned()),
+            ))
+        }
     }
 }
 
@@ -338,7 +366,7 @@ fn setup_branch_config(
     branch: &FullNameRef,
     branch_id: Option<&gix_hash::oid>,
     remote_name: &BStr,
-) -> Result<(), Error> {
+) -> Result<()> {
     let short_name = match branch.category_and_short_name() {
         Some((gix_ref::Category::LocalBranch, shortened)) => match shortened.to_str() {
             Ok(s) => s,
@@ -364,9 +392,9 @@ fn setup_branch_config(
         let mut section = config
             .new_section("branch", short_name)
             .expect("section header name is always valid per naming rules, our input branch name is valid");
-        section.push("remote", remote_name)?;
-        section.push("merge", branch.as_bstr())?;
-        write_to_local_config(&config, WriteMode::Overwrite)?;
+        section.push("remote", remote_name).or_erased()?;
+        section.push("merge", branch.as_bstr()).or_erased()?;
+        write_to_local_config(&config, WriteMode::Overwrite).or_erased()?;
         config.commit().expect("configuration we set is valid");
     }
     Ok(())
diff --git a/gix/src/clone/mod.rs b/gix/src/clone/mod.rs
index c0262e81158..477bb8dd6c1 100644
--- a/gix/src/clone/mod.rs
+++ b/gix/src/clone/mod.rs
@@ -1,19 +1,17 @@
 #![allow(clippy::result_large_err)]
-use crate::{bstr::BString, remote};
+use gix_error::{ExnResult, ResultExt};
+
+use crate::{Result, bstr::BString, remote};
 
 #[cfg(feature = "async-network-client")]
 use gix_transport::client::async_io::Transport;
 #[cfg(feature = "blocking-network-client")]
 use gix_transport::client::blocking_io::Transport;
 
-type ConfigureRemoteFn =
-    Box<dyn FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, Box<dyn std::error::Error + Send + Sync>>>;
+type ConfigureRemoteFn = Box<dyn FnMut(crate::Remote<'_>) -> ExnResult<crate::Remote<'_>>>;
 #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
-type ConfigureConnectionFn = Box<
-    dyn FnMut(
-        &mut remote::Connection<'_, '_, '_, Box<dyn Transport + Send>>,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>,
->;
+type ConfigureConnectionFn =
+    Box<dyn FnMut(&mut remote::Connection<'_, '_, '_, Box<dyn Transport + Send>>) -> ExnResult>;
 
 /// A utility to collect configuration on how to fetch from a remote and initiate a fetch operation. It will delete the newly
 /// created repository on when dropped without successfully finishing a fetch.
@@ -52,33 +50,39 @@ pub struct PrepareFetch {
 /// Errors returned by [`PrepareFetch::with_revision()`].
 pub mod with_revision {
     /// An invalid revision for a single-revision clone.
-    #[derive(Debug, thiserror::Error)]
+    #[derive(Debug)]
     #[expect(missing_docs)]
     pub enum Error {
-        #[error(transparent)]
-        Parse(#[from] gix_refspec::parse::Error),
-        #[error("A clone revision must be HEAD, a full reference name, or a full object ID, got {revision:?}")]
+        Parse(gix_error::Error),
         Invalid { revision: crate::bstr::BString },
     }
-}
 
-/// The error returned by [`PrepareFetch::new()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Config(#[from] crate::config::Error),
-    #[error(transparent)]
-    Init(#[from] crate::init::Error),
-    #[error(transparent)]
-    CommitterOrFallback(#[from] crate::config::commit_signature::Error),
-    #[error(transparent)]
-    UrlParse(#[from] gix_error::Error),
-    #[error("Failed to turn a the relative file url \"{}\" into an absolute one", url.to_bstring())]
-    CanonicalizeUrl {
-        url: gix_url::Url,
-        source: gix_path::realpath::Error,
-    },
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Error::Parse(err) => err.fmt(f),
+                Error::Invalid { revision } => write!(
+                    f,
+                    "A clone revision must be HEAD, a full reference name, or a full object ID, got {revision:?}"
+                ),
+            }
+        }
+    }
+
+    impl std::error::Error for Error {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match self {
+                Error::Parse(err) => Some(err),
+                Error::Invalid { .. } => None,
+            }
+        }
+    }
+
+    impl From<gix_error::Exn<gix_error::Message>> for Error {
+        fn from(err: gix_error::Exn<gix_error::Message>) -> Self {
+            Error::Parse(err.into_error())
+        }
+    }
 }
 
 /// Instantiation
@@ -93,41 +97,26 @@ impl PrepareFetch {
     ///
     /// Similar to `git`, a missing user name and email configuration is not terminal and we will fill it in with dummy values. However,
     /// instead of deriving values from the system, ours are hardcoded to indicate what happened.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
     pub fn new<Url, E>(
         url: Url,
         path: impl AsRef<std::path::Path>,
         kind: crate::create::Kind,
         create_opts: crate::create::Options,
         open_opts: crate::open::Options,
-    ) -> Result<Self, Error>
+    ) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        Self::new_inner(
-            url.try_into().map_err(gix_error::Error::from_error)?,
-            path.as_ref(),
-            kind,
-            create_opts,
-            open_opts,
-        )
+        Self::new_inner(url.try_into().or_erased()?, path.as_ref(), kind, create_opts, open_opts)
     }
-
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
     fn new_inner(
         mut url: gix_url::Url,
         path: &std::path::Path,
         kind: crate::create::Kind,
         mut create_opts: crate::create::Options,
         mut open_opts: crate::open::Options,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         if create_opts.destination_must_be_empty.is_none() {
             create_opts.destination_must_be_empty = Some(true);
         }
@@ -157,11 +146,12 @@ impl PrepareFetch {
         };
 
         let mut repo = crate::ThreadSafeRepository::init_opts(path, kind, create_opts, open_opts)?.to_thread_local();
-        url.canonicalize(repo.options.current_dir_or_empty())
-            .map_err(|err| Error::CanonicalizeUrl {
-                url: url.clone(),
-                source: err,
-            })?;
+        url.canonicalize(repo.options.current_dir_or_empty()).map_err(|err| {
+            err.raise(gix_error::message!(
+                "Failed to turn the relative file url {:?} into an absolute one",
+                url.to_bstring()
+            ))
+        })?;
         repo.committer_or_set_generic_fallback()?;
         Ok(PrepareFetch {
             url,
@@ -213,6 +203,7 @@ fn cleanup_clone_destination_on_drop(repo: &crate::Repository, remove_worktree_o
 #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
 mod access_feat {
     use super::Transport;
+    use crate::ExnResult;
     use crate::clone::PrepareFetch;
 
     /// Builder
@@ -223,10 +214,7 @@ mod access_feat {
         // TODO: tests
         pub fn configure_connection(
             mut self,
-            f: impl FnMut(
-                &mut crate::remote::Connection<'_, '_, '_, Box<dyn Transport + Send>>,
-            ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
-            + 'static,
+            f: impl FnMut(&mut crate::remote::Connection<'_, '_, '_, Box<dyn Transport + Send>>) -> ExnResult + 'static,
         ) -> Self {
             self.configure_connection = Some(Box::new(f));
             self
diff --git a/gix/src/commit/mod.rs b/gix/src/commit/mod.rs
index 5e7e8cad9a7..40bdf960e5e 100644
--- a/gix/src/commit/mod.rs
+++ b/gix/src/commit/mod.rs
@@ -1,8 +1,8 @@
 //!
 #![allow(clippy::empty_docs)]
 
-use std::convert::Infallible;
-
+#[cfg(feature = "command")]
+use crate::Result;
 /// Commit signing errors.
 #[cfg(feature = "command")]
 pub mod sign;
@@ -14,7 +14,7 @@ pub mod verify;
 fn signature_program(
     config: &crate::config::Snapshot<'_>,
     format: gix_object::signature::Format,
-) -> Result<std::ffi::OsString, gix_config::path::interpolate::Error> {
+) -> Result<std::ffi::OsString> {
     use crate::config::tree::{Gpg, Key, gpg};
     use gix_object::signature::Format;
 
@@ -44,39 +44,15 @@ fn signature_program(
 /// An empty array of a type usable with the `gix::easy` API to help declaring no parents should be used
 pub const NO_PARENT_IDS: [gix_hash::ObjectId; 0] = [];
 
-/// The error returned by [`commit(…)`](crate::Repository::commit()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    ParseTime(#[from] crate::config::time::Error),
-    #[error("Committer identity is not configured")]
-    CommitterMissing,
-    #[error("Author identity is not configured")]
-    AuthorMissing,
-    #[error(transparent)]
-    ReferenceNameValidation(#[from] gix_ref::name::Error),
-    #[error(transparent)]
-    WriteObject(#[from] crate::object::write::Error),
-    #[error(transparent)]
-    ReferenceEdit(#[from] crate::reference::edit::Error),
-}
-
-impl From<std::convert::Infallible> for Error {
-    fn from(_value: Infallible) -> Self {
-        unreachable!("cannot be invoked")
-    }
-}
-
 ///
 #[cfg(feature = "revision")]
 pub mod describe {
-    use gix_error::Exn;
+    use gix_error::ResultExt;
     use gix_hash::ObjectId;
     use gix_hashtable::HashMap;
     use std::borrow::Cow;
 
-    use crate::{Repository, bstr::BStr, ext::ObjectIdExt};
+    use crate::{Repository, Result, bstr::BStr, ext::ObjectIdExt};
 
     /// The result of [`try_resolve()`][Platform::try_resolve()].
     pub struct Resolution<'repo> {
@@ -88,8 +64,11 @@ pub mod describe {
 
     impl Resolution<'_> {
         /// Turn this instance into something displayable.
-        pub fn format(self) -> Result<gix_revision::describe::Format<'static>, Error> {
-            let prefix = self.id.shorten()?;
+        pub fn format(self) -> Result<gix_revision::describe::Format<'static>> {
+            let prefix = self
+                .id
+                .shorten()
+                .or_raise(|| gix_error::message("Could not produce an unambiguous shortened id for formatting."))?;
             Ok(self.outcome.into_format(prefix.hex_len()))
         }
 
@@ -103,8 +82,11 @@ pub mod describe {
         pub fn format_with_dirty_suffix(
             self,
             dirty_suffix: impl Into<Option<String>>,
-        ) -> Result<gix_revision::describe::Format<'static>, Error> {
-            let prefix = self.id.shorten()?;
+        ) -> Result<gix_revision::describe::Format<'static>> {
+            let prefix = self
+                .id
+                .shorten()
+                .or_raise(|| gix_error::message("Could not produce an unambiguous shortened id for formatting."))?;
             let mut dirty_suffix = dirty_suffix.into();
             if dirty_suffix.is_some() && !self.id.repo.is_dirty()? {
                 dirty_suffix.take();
@@ -115,25 +97,6 @@ pub mod describe {
         }
     }
 
-    /// The error returned by [`try_format()`][Platform::try_format()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        Describe(#[from] gix_revision::describe::Error),
-        #[error("Could not produce an unambiguous shortened id for formatting.")]
-        ShortId(#[from] crate::id::shorten::Error),
-        #[error(transparent)]
-        RefIter(#[from] crate::reference::iter::Error),
-        #[error(transparent)]
-        RefIterInit(#[from] crate::reference::iter::init::Error),
-        #[error(transparent)]
-        #[cfg(feature = "status")]
-        DetermineIsDirty(#[from] crate::status::is_dirty::Error),
-    }
-
     /// A selector to choose what kind of references should contribute to names.
     #[derive(Default, Debug, Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
     pub enum SelectRef {
@@ -147,8 +110,8 @@ pub mod describe {
     }
 
     impl SelectRef {
-        fn names(&self, repo: &Repository) -> Result<HashMap<ObjectId, Cow<'static, BStr>>, Error> {
-            let platform = repo.references()?;
+        fn names(&self, repo: &Repository) -> Result<HashMap<ObjectId, Cow<'static, BStr>>> {
+            let platform = repo.references().or_erased()?;
 
             Ok(match self {
                 SelectRef::AllTags | SelectRef::AllRefs => {
@@ -157,7 +120,7 @@ pub mod describe {
                         SelectRef::AllTags => platform.tags()?,
                         _ => unreachable!(),
                     }
-                    .filter_map(Result::ok)
+                    .filter_map(std::result::Result::ok)
                     .filter_map(|mut r: crate::Reference<'_>| {
                         let target_id = r.target().try_id().map(ToOwned::to_owned);
                         let peeled_id = r.peel_to_id().ok()?;
@@ -193,7 +156,7 @@ pub mod describe {
                 SelectRef::AnnotatedTags => {
                     let mut peeled_commits_and_tag_date: Vec<_> = platform
                         .tags()?
-                        .filter_map(Result::ok)
+                        .filter_map(std::result::Result::ok)
                         .filter_map(|r: crate::Reference<'_>| {
                             // 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.
@@ -255,7 +218,7 @@ pub mod describe {
 
         /// Try to find a name for the configured commit id using all prior configuration, returning `Some(describe::Format)`
         /// if one was found, or `None` if that wasn't the case.
-        pub fn try_format(&self) -> Result<Option<gix_revision::describe::Format<'static>>, Error> {
+        pub fn try_format(&self) -> Result<Option<gix_revision::describe::Format<'static>>> {
             self.try_resolve()?.map(Resolution::format).transpose()
         }
 
@@ -271,7 +234,7 @@ pub mod describe {
         pub fn try_resolve_with_cache(
             &self,
             cache: Option<&'_ gix_commitgraph::Graph>,
-        ) -> Result<Option<Resolution<'repo>>, Error> {
+        ) -> Result<Option<Resolution<'repo>>> {
             let mut graph = self.repo.revision_graph(cache);
             let outcome = gix_revision::describe(
                 &self.id,
@@ -282,8 +245,7 @@ pub mod describe {
                     first_parent: self.first_parent,
                     max_candidates: self.max_candidates,
                 },
-            )
-            .map_err(Exn::into_inner)?;
+            )?;
 
             Ok(outcome.map(|outcome| Resolution {
                 outcome,
@@ -296,13 +258,13 @@ pub mod describe {
         /// # Performance
         ///
         /// Prefer to use the [`Self::try_resolve_with_cache()`] method when processing more than one commit at a time.
-        pub fn try_resolve(&self) -> Result<Option<Resolution<'repo>>, Error> {
+        pub fn try_resolve(&self) -> Result<Option<Resolution<'repo>>> {
             let cache = self.repo.commit_graph_if_enabled()?;
             self.try_resolve_with_cache(cache.as_ref())
         }
 
         /// Like [`try_format()`](Self::try_format()), but turns `id_as_fallback()` on to always produce a format.
-        pub fn format(&mut self) -> Result<gix_revision::describe::Format<'static>, Error> {
+        pub fn format(&mut self) -> Result<gix_revision::describe::Format<'static>> {
             self.id_as_fallback = true;
             Ok(self.try_format()?.expect("BUG: fallback must always produce a format"))
         }
diff --git a/gix/src/commit/sign.rs b/gix/src/commit/sign.rs
index 724f13c05e0..354fd8553eb 100644
--- a/gix/src/commit/sign.rs
+++ b/gix/src/commit/sign.rs
@@ -1,91 +1,58 @@
 use std::{ffi::OsString, path::PathBuf, process::Stdio};
 
 use crate::{
-    bstr::{BString, ByteSlice},
+    Error, Result,
+    bstr::ByteSlice,
     config::tree::{Gpg, Key, User, gpg},
 };
+use gix_error::ResultExt;
 
 use gix_object::signature::sign::is_literal_ssh_key;
 pub use gix_object::signature::{Format, sign::Options};
 
-/// Errors encountered when applying resolved signing options to a commit.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Options(#[from] options::Error),
-    #[error(transparent)]
-    Decode(#[from] gix_object::decode::Error),
-    #[error(transparent)]
-    Sign(#[from] gix_object::signature::sign::Error),
-    #[error(transparent)]
-    WriteObject(#[from] crate::object::write::Error),
-    #[error(transparent)]
-    FindCommit(#[from] crate::object::find::existing::with_conversion::Error),
-}
-
-/// Errors encountered when resolving commit-signing options.
-pub mod options {
-    use std::ffi::OsString;
-
-    use crate::bstr::BString;
-
-    /// The error returned by [`crate::Repository::commit_signing_options()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ConfigBoolean(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        ParseTime(#[from] crate::config::time::Error),
-        #[error("Unsupported value for gpg.format: {0:?}")]
-        UnsupportedFormat(BString),
-        #[error("Committer identity is not configured and user.signingKey is unset")]
-        MissingCommitter,
-        #[error("user.signingKey or gpg.ssh.defaultKeyCommand must provide an SSH signing key")]
-        MissingSshSigningKey,
-        #[error("Could not interpolate a configured commit-signing path")]
-        ConfiguredPath(#[from] gix_config::path::interpolate::Error),
-        #[error("Could not execute gpg.ssh.defaultKeyCommand {program:?}")]
-        DefaultKeyCommand {
-            program: OsString,
-            #[source]
-            source: std::io::Error,
-        },
-        #[error("gpg.ssh.defaultKeyCommand failed: {0:?}")]
-        DefaultKeyCommandFailed(BString),
-        #[error("gpg.ssh.defaultKeyCommand returned an invalid key: {0:?}")]
-        InvalidDefaultKey(BString),
-    }
-}
-
-pub(crate) fn sign<'repo>(commit: &crate::Commit<'repo>) -> Result<crate::Commit<'repo>, Error> {
+pub(crate) fn sign<'repo>(commit: &crate::Commit<'repo>) -> Result<crate::Commit<'repo>> {
     let options = commit.repo.commit_signing_options()?;
-    let signed = commit.decode()?.sign(options)?;
+    let signed = commit
+        .decode()
+        .or_raise(|| gix_error::message("Could not decode the commit before signing"))?
+        .sign(options)
+        .or_raise(|| gix_error::message("Could not sign the commit"))?;
     let id = commit.repo.write_object(&signed)?;
-    Ok(commit.repo.find_commit(id)?)
+    commit.repo.find_commit(id)
 }
 
-pub(crate) fn signing_options(repo: &crate::Repository) -> Result<Options, options::Error> {
-    use options::Error;
-
+pub(crate) fn signing_options(repo: &crate::Repository) -> Result<Options> {
     let config = repo.config_snapshot();
     let format = config
         .string(Gpg::FORMAT)
         .unwrap_or_else(|| Gpg::FORMAT.default_value_or_panic().into());
-    let format = parse_format(format.trim()).ok_or(Error::UnsupportedFormat(format))?;
-    let program = super::signature_program(&config, format)?;
+    let format = parse_format(format.trim())
+        .ok_or_else(|| Error::from_error(gix_error::message!("Unsupported value for gpg.format: {format:?}")))?;
+    let program = super::signature_program(&config, format)
+        .or_raise(|| gix_error::message("Could not interpolate the configured signing program path"))?;
     let signing_key = match config
         .plumbing()
         .string_filter(User::SIGNING_KEY, &mut repo.filter_config_section())
     {
         Some(key) if !key.is_empty() && format == Format::Ssh && is_literal_ssh_key(&key).is_none() => config
-            .trusted_path(User::SIGNING_KEY)?
+            .trusted_path(User::SIGNING_KEY)
+            .or_raise(|| gix_error::message("Could not interpolate the configured commit-signing key path"))?
             .map_or_else(|| gix_path::from_bstring(key).into_os_string(), PathBuf::into_os_string),
         Some(key) if !key.is_empty() => gix_path::from_bstring(key).into_os_string(),
-        _ if format == Format::Ssh => default_ssh_key(&config)?.ok_or(Error::MissingSshSigningKey)?,
+        _ if format == Format::Ssh => default_ssh_key(&config)?.ok_or_else(|| {
+            Error::from_error(gix_error::message(
+                "user.signingKey or gpg.ssh.defaultKeyCommand must provide an SSH signing key",
+            ))
+        })?,
         _ => {
-            let committer = repo.committer().ok_or(Error::MissingCommitter)??;
+            let committer = repo
+                .committer()
+                .ok_or_else(|| {
+                    Error::from_error(gix_error::message(
+                        "Committer identity is not configured and user.signingKey is unset",
+                    ))
+                })?
+                .or_raise(|| gix_error::message("Could not parse the committer time for commit signing"))?;
             let mut identity = committer.name.to_owned();
             identity.extend_from_slice(b" <");
             identity.extend_from_slice(committer.email);
@@ -102,11 +69,13 @@ pub(crate) fn signing_options(repo: &crate::Repository) -> Result<Options, optio
     })
 }
 
-pub(crate) fn signing_options_if_enabled(repo: &crate::Repository) -> Result<Option<Options>, options::Error> {
-    repo.config
-        .may_sign_commits()?
-        .then(|| signing_options(repo))
-        .transpose()
+pub(crate) fn signing_options_if_enabled(repo: &crate::Repository) -> Result<Option<Options>> {
+    let enabled = repo
+        .config
+        .may_sign_commits()
+        .or_raise(|| gix_error::message("Could not determine whether commit signing is enabled"))?
+        .then(|| signing_options(repo));
+    enabled.transpose()
 }
 
 fn parse_format(value: &[u8]) -> Option<Format> {
@@ -121,9 +90,7 @@ fn parse_format(value: &[u8]) -> Option<Format> {
     }
 }
 
-fn default_ssh_key(config: &crate::config::Snapshot<'_>) -> Result<Option<OsString>, options::Error> {
-    use options::Error;
-
+fn default_ssh_key(config: &crate::config::Snapshot<'_>) -> Result<Option<OsString>> {
     let Some(program) = config.trusted_program(gpg::Ssh::DEFAULT_KEY_COMMAND) else {
         return Ok(None);
     };
@@ -133,21 +100,20 @@ fn default_ssh_key(config: &crate::config::Snapshot<'_>) -> Result<Option<OsStri
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .spawn()
-        .map_err(|source| Error::DefaultKeyCommand {
-            program: program.clone(),
-            source,
-        })?
+        .or_raise(|| gix_error::message!("Could not execute gpg.ssh.defaultKeyCommand {program:?}"))?
         .wait_with_output()
-        .map_err(|source| Error::DefaultKeyCommand {
-            program: program.clone(),
-            source,
-        })?;
+        .or_raise(|| gix_error::message!("Could not execute gpg.ssh.defaultKeyCommand {program:?}"))?;
     if !output.status.success() {
-        return Err(Error::DefaultKeyCommandFailed(output.stderr.into()));
+        return Err(Error::from_error(gix_error::message!(
+            "gpg.ssh.defaultKeyCommand failed: {:?}",
+            output.stderr.as_bstr()
+        )));
     }
     let key = output.stdout.as_bstr().lines().next().unwrap_or_default().trim();
     if is_literal_ssh_key(key).is_none() {
-        return Err(Error::InvalidDefaultKey(BString::from(key)));
+        return Err(Error::from_error(gix_error::message!(
+            "gpg.ssh.defaultKeyCommand returned an invalid key: {key:?}"
+        )));
     }
     Ok(Some(gix_path::from_bstr(key.as_bstr()).into_owned().into_os_string()))
 }
diff --git a/gix/src/commit/verify.rs b/gix/src/commit/verify.rs
index 0fcb617c2a1..6e2cae91fc9 100644
--- a/gix/src/commit/verify.rs
+++ b/gix/src/commit/verify.rs
@@ -1,42 +1,34 @@
 use std::path::PathBuf;
 
-use crate::config::tree::{Gpg, gpg};
+use crate::{
+    Error, Result,
+    config::tree::{Gpg, gpg},
+};
+use gix_error::ResultExt;
 
 pub use gix_object::signature::{
     Format,
     verify::{Outcome, Status, TrustLevel},
 };
 
-/// The error returned by [`crate::Commit::verify_signature()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Decode(#[from] gix_object::decode::Error),
-    #[error(transparent)]
-    Commit(#[from] crate::object::commit::Error),
-    #[error(transparent)]
-    InvalidTrustLevel(#[from] crate::config::key::GenericErrorWithValue),
-    #[error("Could not interpolate a configured signature-verification path")]
-    ConfiguredPath(#[from] gix_config::path::interpolate::Error),
-    #[error("gpg.ssh.allowedSignersFile must be configured for SSH signature verification")]
-    MissingAllowedSigners,
-    #[error(transparent)]
-    Verify(#[from] gix_object::signature::verify::Error),
-}
-
-pub(crate) fn verify(commit: &crate::Commit<'_>) -> Result<Option<Outcome>, Error> {
-    let Some((signature, signed_data)) = commit.signature()? else {
+pub(crate) fn verify(commit: &crate::Commit<'_>) -> Result<Option<Outcome>> {
+    let Some((signature, signed_data)) = commit
+        .signature()
+        .or_raise(|| gix_error::message("Could not decode the commit signature"))?
+    else {
         return Ok(None);
     };
     let config = commit.repo.config_snapshot();
     let minimum_trust = config
         .string(Gpg::MIN_TRUST_LEVEL)
         .map(|value| Gpg::MIN_TRUST_LEVEL.try_into_trust_level(value))
-        .transpose()?
+        .transpose()
+        .or_raise(|| gix_error::message("The configured minimum signature trust level is invalid"))?
         .unwrap_or_default();
-    let format = Format::from_signature(&signature).ok_or(gix_object::signature::verify::Error::UnsupportedFormat)?;
-    let program = super::signature_program(&config, format)?;
+    let format = Format::from_signature(&signature)
+        .ok_or_else(|| Error::from_error(gix_error::corruption("The signature format is unsupported")))?;
+    let program = super::signature_program(&config, format)
+        .or_raise(|| gix_error::message("Could not interpolate the configured signature-verification program path"))?;
     let options = match format {
         Format::OpenPgp => gix_object::signature::verify::Options::OpenPgp {
             program,
@@ -52,10 +44,16 @@ pub(crate) fn verify(commit: &crate::Commit<'_>) -> Result<Option<Outcome>, Erro
         },
         Format::Ssh => {
             let allowed_signers = config
-                .trusted_path(gpg::Ssh::ALLOWED_SIGNERS_FILE)?
-                .ok_or(Error::MissingAllowedSigners)?;
+                .trusted_path(gpg::Ssh::ALLOWED_SIGNERS_FILE)
+                .or_raise(|| gix_error::message("Could not interpolate a configured signature-verification path"))?
+                .ok_or_else(|| {
+                    Error::from_error(gix_error::message(
+                        "gpg.ssh.allowedSignersFile must be configured for SSH signature verification",
+                    ))
+                })?;
             let revocation_file = config
-                .trusted_path(gpg::Ssh::REVOCATION_FILE)?
+                .trusted_path(gpg::Ssh::REVOCATION_FILE)
+                .or_raise(|| gix_error::message("Could not interpolate a configured signature-verification path"))?
                 .filter(|path| path.exists());
             gix_object::signature::verify::Options::Ssh {
                 program,
@@ -68,7 +66,10 @@ pub(crate) fn verify(commit: &crate::Commit<'_>) -> Result<Option<Outcome>, Erro
             }
         }
     };
-    signed_data.verify(&signature, options).map(Some).map_err(Into::into)
+    let outcome = signed_data
+        .verify(&signature, options)
+        .or_raise(|| gix_error::message("Could not verify the commit signature"))?;
+    Ok(Some(outcome))
 }
 
 fn resolve_relative_to_repository(repo: &crate::Repository, path: PathBuf) -> PathBuf {
diff --git a/gix/src/config/cache/access.rs b/gix/src/config/cache/access.rs
index 4c3b88da631..d518e8bfcfa 100644
--- a/gix/src/config/cache/access.rs
+++ b/gix/src/config/cache/access.rs
@@ -2,12 +2,18 @@
 use std::{path::PathBuf, time::Duration};
 
 use gix_config::file::Metadata;
+#[cfg(feature = "blob-diff")]
+use gix_error::ErrorExt;
+#[cfg(any(feature = "attributes", feature = "excludes"))]
+use gix_error::ResultExt;
 use gix_lock::acquire::Fail;
 
+#[cfg(feature = "attributes")]
+use crate::ExnMessageResult;
 use crate::{
-    config,
+    ExnResult, Result, config,
     config::{
-        Cache, boolean,
+        Cache,
         cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
         tree::{Core, Key},
     },
@@ -18,7 +24,9 @@ use crate::{
 /// Access
 impl Cache {
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn diff_algorithm(&self) -> Result<gix_diff::blob::Algorithm, config::diff::algorithm::Error> {
+    pub(crate) fn diff_algorithm(
+        &self,
+    ) -> std::result::Result<gix_diff::blob::Algorithm, config::diff::algorithm::Error> {
         use crate::config::{cache::util::ApplyLeniencyDefault, diff::algorithm::Error, tree::Diff};
         self.diff_algorithm
             .get_or_try_init(|| {
@@ -38,7 +46,7 @@ impl Cache {
     }
 
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn diff_drivers(&self) -> Result<Vec<gix_diff::blob::Driver>, config::diff::drivers::Error> {
+    pub(crate) fn diff_drivers(&self) -> Result<Vec<gix_diff::blob::Driver>> {
         use crate::config::cache::util::ApplyLeniencyDefault;
         let mut out = Vec::<gix_diff::blob::Driver>::new();
         for section in self
@@ -67,10 +75,11 @@ impl Cache {
                 driver.is_binary = config::tree::Diff::DRIVER_BINARY
                     .try_into_binary(binary)
                     .with_leniency(self.lenient_config)
-                    .map_err(|err| config::diff::drivers::Error {
-                        name: driver.name.clone(),
-                        attribute: "binary",
-                        source: Box::new(err),
+                    .map_err(|err| {
+                        err.and_raise(gix_error::message!(
+                            "Failed to parse value of 'diff.{}.binary'",
+                            driver.name
+                        ))
                     })?;
             }
             if let Some(command) = section.value(config::tree::Diff::DRIVER_COMMAND.name) {
@@ -89,10 +98,11 @@ impl Cache {
                         err => Err(err),
                     })
                     .with_lenient_default(self.lenient_config)
-                    .map_err(|err| config::diff::drivers::Error {
-                        name: driver.name.clone(),
-                        attribute: "algorithm",
-                        source: Box::new(err),
+                    .map_err(|err| {
+                        err.and_raise(gix_error::message!(
+                            "Failed to parse value of 'diff.{}.algorithm'",
+                            driver.name
+                        ))
                     })?
                     .into();
             }
@@ -101,7 +111,7 @@ impl Cache {
     }
 
     #[cfg(feature = "merge")]
-    pub(crate) fn merge_drivers(&self) -> Result<Vec<gix_merge::blob::Driver>, config::merge::drivers::Error> {
+    pub(crate) fn merge_drivers(&self) -> Result<Vec<gix_merge::blob::Driver>> {
         let mut out = Vec::<gix_merge::blob::Driver>::new();
         for section in self
             .resolved
@@ -137,18 +147,14 @@ impl Cache {
     }
 
     #[cfg(feature = "merge")]
-    pub(crate) fn merge_pipeline_options(
-        &self,
-    ) -> Result<gix_merge::blob::pipeline::Options, config::merge::pipeline_options::Error> {
+    pub(crate) fn merge_pipeline_options(&self) -> Result<gix_merge::blob::pipeline::Options> {
         Ok(gix_merge::blob::pipeline::Options {
             large_file_threshold_bytes: self.big_file_threshold()?,
         })
     }
 
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn diff_pipeline_options(
-        &self,
-    ) -> Result<gix_diff::blob::pipeline::Options, config::diff::pipeline_options::Error> {
+    pub(crate) fn diff_pipeline_options(&self) -> Result<gix_diff::blob::pipeline::Options> {
         Ok(gix_diff::blob::pipeline::Options {
             large_file_threshold_bytes: self.big_file_threshold()?,
             fs: self.fs_capabilities()?,
@@ -156,13 +162,13 @@ impl Cache {
     }
 
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn diff_renames(&self) -> Result<(Option<gix_diff::Rewrites>, bool), crate::diff::new_rewrites::Error> {
+    pub(crate) fn diff_renames(&self) -> Result<(Option<gix_diff::Rewrites>, bool)> {
         self.diff_renames
             .get_or_try_init(|| crate::diff::new_rewrites(&self.resolved, self.lenient_config))
             .copied()
     }
 
-    pub(crate) fn big_file_threshold(&self) -> Result<u64, config::unsigned_integer::Error> {
+    pub(crate) fn big_file_threshold(&self) -> Result<u64> {
         Ok(Core::BIG_FILE_THRESHOLD
             .try_into_u64(self.resolved.integer("core.bigFileThreshold"))
             .with_leniency(self.lenient_config)?
@@ -206,12 +212,12 @@ impl Cache {
     }
 
     #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-    pub(crate) fn url_scheme(&self) -> Result<&remote::url::SchemePermission, remote::url::scheme_permission::Error> {
+    pub(crate) fn url_scheme(&self) -> Result<&remote::url::SchemePermission> {
         self.url_scheme
             .get_or_try_init(|| remote::url::SchemePermission::from_config(&self.resolved, self.filter_config_section))
     }
 
-    pub(crate) fn may_use_commit_graph(&self) -> Result<bool, config::boolean::Error> {
+    pub(crate) fn may_use_commit_graph(&self) -> Result<bool> {
         const DEFAULT: bool = true;
         Ok(Core::COMMIT_GRAPH
             .enrich_error(self.resolved.boolean("core.commitGraph"))
@@ -220,7 +226,7 @@ impl Cache {
     }
 
     #[cfg(feature = "command")]
-    pub(crate) fn may_sign_commits(&self) -> Result<bool, config::boolean::Error> {
+    pub(crate) fn may_sign_commits(&self) -> Result<bool> {
         use crate::config::tree::Commit;
 
         let default = gix_config::Boolean::try_from(Commit::GPG_SIGN.default_value_or_panic())
@@ -233,9 +239,7 @@ impl Cache {
     }
 
     /// Returns (file-timeout, pack-refs timeout)
-    pub(crate) fn lock_timeout(
-        &self,
-    ) -> Result<(gix_lock::acquire::Fail, gix_lock::acquire::Fail), config::lock_timeout::Error> {
+    pub(crate) fn lock_timeout(&self) -> Result<(gix_lock::acquire::Fail, gix_lock::acquire::Fail)> {
         let mut out: [gix_lock::acquire::Fail; 2] = Default::default();
         for (idx, (key, default_ms)) in [(&Core::FILES_REF_LOCK_TIMEOUT, 100), (&Core::PACKED_REFS_TIMEOUT, 1000)]
             .into_iter()
@@ -252,22 +256,19 @@ impl Cache {
         Ok((out[0], out[1]))
     }
 
-    pub(crate) fn config_lock_timeout(&self) -> Result<gix_lock::acquire::Fail, config::lock_timeout::Error> {
+    pub(crate) fn config_lock_timeout(&self) -> Result<gix_lock::acquire::Fail> {
         config_lock_timeout(&self.resolved, self.lenient_config, self.filter_config_section)
     }
 
     /// The path to the user-level excludes file to ignore certain files in the worktree.
     #[cfg(feature = "excludes")]
-    pub(crate) fn excludes_file(&self) -> Result<Option<PathBuf>, gix_config::path::interpolate::Error> {
+    pub(crate) fn excludes_file(&self) -> ExnResult<Option<PathBuf>> {
         self.trusted_file_path(Core::EXCLUDES_FILE)
     }
 
     /// A helper to obtain a file from trusted configuration at `section_name`, `subsection_name`, and `key`, which is interpolated
     /// if present.
-    pub(crate) fn trusted_file_path(
-        &self,
-        key: impl gix_config::AsKey,
-    ) -> Result<Option<PathBuf>, gix_config::path::interpolate::Error> {
+    pub(crate) fn trusted_file_path(&self, key: impl gix_config::AsKey) -> ExnResult<Option<PathBuf>> {
         trusted_file_path(
             &self.resolved,
             key,
@@ -277,11 +278,14 @@ impl Cache {
         )
     }
 
-    pub(crate) fn apply_leniency<T, E>(&self, res: Result<Option<T>, E>) -> Result<Option<T>, E> {
+    pub(crate) fn apply_leniency<T, E>(
+        &self,
+        res: std::result::Result<Option<T>, E>,
+    ) -> std::result::Result<Option<T>, E> {
         res.with_leniency(self.lenient_config)
     }
 
-    pub(crate) fn fs_capabilities(&self) -> Result<gix_fs::Capabilities, boolean::Error> {
+    pub(crate) fn fs_capabilities(&self) -> Result<gix_fs::Capabilities> {
         Ok(gix_fs::Capabilities {
             precompose_unicode: boolean(self, "core.precomposeUnicode", &Core::PRECOMPOSE_UNICODE, false)?,
             ignore_case: boolean(self, "core.ignoreCase", &Core::IGNORE_CASE, false)?,
@@ -291,7 +295,7 @@ impl Cache {
     }
 
     #[cfg(feature = "index")]
-    pub(crate) fn stat_options(&self) -> Result<gix_index::entry::stat::Options, config::stat_options::Error> {
+    pub(crate) fn stat_options(&self) -> Result<gix_index::entry::stat::Options> {
         use crate::config::tree::gitoxide;
         Ok(gix_index::entry::stat::Options {
             trust_ctime: boolean(self, "core.trustCTime", &Core::TRUST_C_TIME, true)?,
@@ -308,7 +312,7 @@ impl Cache {
         })
     }
 
-    pub(crate) fn protect_options(&self) -> Result<gix_validate::path::component::Options, config::boolean::Error> {
+    pub(crate) fn protect_options(&self) -> Result<gix_validate::path::component::Options> {
         const IS_WINDOWS: bool = cfg!(windows);
         const IS_MACOS: bool = cfg!(target_os = "macos");
         const ALWAYS_ON_FOR_SAFETY: bool = true;
@@ -336,7 +340,7 @@ impl Cache {
         &self,
         repo: &crate::Repository,
         attributes_source: gix_worktree::stack::state::attributes::Source,
-    ) -> Result<gix_worktree_state::checkout::Options, config::checkout_options::Error> {
+    ) -> Result<gix_worktree_state::checkout::Options> {
         use crate::config::tree::gitoxide;
         let git_dir = repo.git_dir();
         let thread_limit = self.apply_leniency(
@@ -378,17 +382,12 @@ impl Cache {
             destination_is_initially_empty: false,
             overwrite_existing: false,
             keep_going: false,
-            stat_options: self.stat_options().map_err(|err| match err {
-                config::stat_options::Error::ConfigCheckStat(err) => {
-                    config::checkout_options::Error::ConfigCheckStat(err)
-                }
-                config::stat_options::Error::ConfigBoolean(err) => config::checkout_options::Error::ConfigBoolean(err),
-            })?,
+            stat_options: self.stat_options()?,
         })
     }
 
     #[cfg(feature = "excludes")]
-    pub(crate) fn ignore_pattern_parser(&self) -> Result<gix_ignore::search::Ignore, config::boolean::Error> {
+    pub(crate) fn ignore_pattern_parser(&self) -> Result<gix_ignore::search::Ignore> {
         Ok(gix_ignore::search::Ignore {
             support_precious: boolean(
                 self,
@@ -406,15 +405,20 @@ impl Cache {
         overrides: Option<gix_ignore::Search>,
         source: gix_worktree::stack::state::ignore::Source,
         buf: &mut Vec<u8>,
-    ) -> Result<gix_worktree::stack::state::Ignore, config::exclude_stack::Error> {
-        let excludes_file = match self.excludes_file()? {
+    ) -> Result<gix_worktree::stack::state::Ignore> {
+        let excludes_file = match self.excludes_file().map_err(|err| {
+            err.raise(gix_error::message(
+                "The value for `core.excludesFile` could not be read from configuration",
+            ))
+        })? {
             Some(user_path) => Some(user_path),
-            None => self.xdg_config_path("ignore")?,
+            None => self.xdg_config_path("ignore").or_erased()?,
         };
         let parse_ignore = self.ignore_pattern_parser()?;
         Ok(gix_worktree::stack::state::Ignore::new(
             overrides.unwrap_or_default(),
-            gix_ignore::Search::from_git_dir(git_dir, excludes_file, buf, parse_ignore)?,
+            gix_ignore::Search::from_git_dir(git_dir, excludes_file, buf, parse_ignore)
+                .or_raise(|| gix_error::message("Could not read repository exclude"))?,
             None,
             source,
             parse_ignore,
@@ -427,9 +431,11 @@ impl Cache {
         git_dir: &std::path::Path,
         source: gix_worktree::stack::state::attributes::Source,
         attributes: crate::open::permissions::Attributes,
-    ) -> Result<(gix_worktree::stack::state::Attributes, Vec<u8>), config::attribute_stack::Error> {
+    ) -> Result<(gix_worktree::stack::state::Attributes, Vec<u8>)> {
         use gix_attributes::Source;
-        let configured_or_user_attributes = match self.trusted_file_path(Core::ATTRIBUTES_FILE)? {
+        let configured_or_user_attributes = match self.trusted_file_path(Core::ATTRIBUTES_FILE).or_raise(|| {
+            gix_error::message("Failed to interpolate the attribute file configured at `core.attributesFile`")
+        })? {
             Some(attributes) => Some(attributes),
             None => {
                 if attributes.git {
@@ -452,7 +458,8 @@ impl Cache {
         let mut buf = Vec::new();
         let mut collection = gix_attributes::search::MetadataCollection::default();
         let state = gix_worktree::stack::state::Attributes::new(
-            gix_attributes::Search::new_globals(attribute_files, &mut buf, &mut collection)?,
+            gix_attributes::Search::new_globals(attribute_files, &mut buf, &mut collection)
+                .or_raise(|| gix_error::message("An attribute file could not be read"))?,
             Some(info_attributes_path),
             source,
             collection,
@@ -461,9 +468,7 @@ impl Cache {
     }
 
     #[cfg(feature = "attributes")]
-    pub(crate) fn pathspec_defaults(
-        &self,
-    ) -> Result<gix_pathspec::Defaults, gix_pathspec::defaults::from_environment::Error> {
+    pub(crate) fn pathspec_defaults(&self) -> ExnMessageResult<gix_pathspec::Defaults> {
         use crate::config::tree::gitoxide;
         let res = gix_pathspec::Defaults::from_environment(&mut |name| {
             let key = [
@@ -490,7 +495,7 @@ impl Cache {
     pub(crate) fn xdg_config_path(
         &self,
         resource_file_name: &str,
-    ) -> Result<Option<PathBuf>, gix_sec::permission::Error<PathBuf>> {
+    ) -> std::result::Result<Option<PathBuf>, gix_sec::permission::Error<PathBuf>> {
         std::env::var_os("XDG_CONFIG_HOME")
             .map(|path| (PathBuf::from(path), &self.environment.xdg_config_home))
             .or_else(|| {
@@ -528,7 +533,7 @@ pub(crate) fn config_lock_timeout(
     config: &gix_config::File,
     lenient: bool,
     mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<Fail, config::lock_timeout::Error> {
+) -> Result<Fail> {
     Core::CONFIG_LOCK_TIMEOUT
         .try_into_lock_timeout(config.integer_filter(Core::CONFIG_LOCK_TIMEOUT, &mut filter_config_section))
         .with_leniency(lenient)
@@ -541,7 +546,7 @@ fn compression(
     mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
     key: &'static config::tree::keys::Compression,
     default: gix_zlib::Compression,
-) -> Result<gix_zlib::Compression, config::Error> {
+) -> Result<gix_zlib::Compression> {
     let level = match key
         .try_into_compression(config.integer_filter(key, &mut filter_config_section))
         .with_leniency(lenient)?
@@ -558,7 +563,7 @@ pub(crate) fn loose_compression(
     config: &gix_config::File,
     lenient: bool,
     filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<gix_zlib::Compression, config::Error> {
+) -> Result<gix_zlib::Compression> {
     compression(
         config,
         lenient,
@@ -572,7 +577,7 @@ pub(crate) fn pack_compression(
     config: &gix_config::File,
     lenient: bool,
     filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<gix_zlib::Compression, config::Error> {
+) -> Result<gix_zlib::Compression> {
     compression(
         config,
         lenient,
@@ -588,7 +593,7 @@ pub(crate) fn trusted_file_path(
     filter: impl FnMut(&Metadata) -> bool,
     lenient_config: bool,
     environment: crate::open::permissions::Environment,
-) -> Result<Option<PathBuf>, gix_config::path::interpolate::Error> {
+) -> ExnResult<Option<PathBuf>> {
     let Some(path) = config.path_filter(key, filter) else {
         return Ok(None);
     };
@@ -624,12 +629,7 @@ pub(crate) fn home_dir(environment: crate::open::permissions::Environment) -> Op
     gix_path::env::home_dir().and_then(|path| environment.home.check_opt(path))
 }
 
-fn boolean(
-    me: &Cache,
-    full_key: &str,
-    key: &'static config::tree::keys::Boolean,
-    default: bool,
-) -> Result<bool, boolean::Error> {
+fn boolean(me: &Cache, full_key: &str, key: &'static config::tree::keys::Boolean, default: bool) -> Result<bool> {
     debug_assert_eq!(
         full_key,
         key.logical_name(),
diff --git a/gix/src/config/cache/incubate.rs b/gix/src/config/cache/incubate.rs
index aca00b906e4..2daebfba78d 100644
--- a/gix/src/config/cache/incubate.rs
+++ b/gix/src/config/cache/incubate.rs
@@ -1,10 +1,14 @@
 #![allow(clippy::result_large_err)]
 
-use super::{Error, util};
-use crate::config::{
-    cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
-    tree::{Core, Extensions, gitoxide},
+use super::util;
+use crate::{
+    Error, Result,
+    config::{
+        cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
+        tree::{Core, Extensions, gitoxide},
+    },
 };
+use gix_error::{ErrorExt, ResultExt};
 
 /// 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`.
@@ -28,7 +32,7 @@ impl StageOne {
         git_dir_trust: gix_sec::Trust,
         lossy: bool,
         lenient: bool,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let mut buf = Vec::with_capacity(512);
         let mut config = load_config(
             common_dir.join("config"),
@@ -46,9 +50,17 @@ impl StageOne {
         let object_hash = match (repo_format_version, config.string(Extensions::OBJECT_FORMAT)) {
             // objectFormat is a repository format version 1 extension.
             (1, Some(format)) => Extensions::OBJECT_FORMAT.try_into_object_format(format)?,
-            (0, Some(_)) => return Err(Error::ObjectFormatRequiresV1),
+            (0, Some(_)) => {
+                return Err(Error::from_error(gix_error::validation(
+                    "extensions.objectFormat is a v1-only extension, but the repository format version is 0; set core.repositoryFormatVersion=1 to use it, or remove extensions.objectFormat to fall back to the default Sha1 format (if supported by this build)",
+                )));
+            }
             (0 | 1, None) => legacy_object_hash()?,
-            (version, _) => return Err(Error::UnsupportedRepositoryFormatVersion { version }),
+            (version, _) => {
+                return Err(Error::from_error(gix_error::validation(format!(
+                    "Unsupported repository format version {version}; only versions 0 and 1 are supported"
+                ))));
+            }
         };
 
         let extension_worktree = util::config_bool(
@@ -67,12 +79,11 @@ impl StageOne {
                 lossy,
                 lenient,
             )?;
-            config.append(worktree_config)?;
+            config.append(worktree_config).or_erased()?;
         }
         let precompose_unicode = Core::PRECOMPOSE_UNICODE
             .enrich_error(config.boolean(Core::PRECOMPOSE_UNICODE))
-            .with_leniency(lenient)
-            .map_err(Error::ConfigBoolean)?
+            .with_leniency(lenient)?
             .unwrap_or_default();
 
         const IS_WINDOWS: bool = cfg!(windows);
@@ -100,14 +111,16 @@ impl StageOne {
 /// Git interprets a missing objectFormat as the original Sha1 layout, so we return
 /// gix_hash::Kind::Sha1 whenever this build can handle it.
 /// In Sha256-only builds we cannot open such a repository, so return an error instead.
-fn legacy_object_hash() -> Result<gix_hash::Kind, Error> {
+fn legacy_object_hash() -> Result<gix_hash::Kind> {
     #[cfg(feature = "sha1")]
     {
         Ok(gix_hash::Kind::Sha1)
     }
     #[cfg(not(feature = "sha1"))]
     {
-        Err(Error::UnsupportedObjectFormat { name: "sha1".into() })
+        Err(Error::from_error(gix_error::validation(
+            "Cannot handle objects formatted as \"sha1\"",
+        )))
     }
 }
 
@@ -118,7 +131,7 @@ fn load_config(
     git_dir_trust: gix_sec::Trust,
     lossy: bool,
     lenient: bool,
-) -> Result<gix_config::File, Error> {
+) -> Result<gix_config::File> {
     let metadata = gix_config::file::Metadata::from(source)
         .at(&config_path)
         .with(git_dir_trust);
@@ -126,10 +139,10 @@ fn load_config(
         Ok(f) => f,
         Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(gix_config::File::new(metadata)),
         Err(err) => {
-            let err = Error::Io {
-                source: err,
-                path: config_path,
-            };
+            let err = Error::from(err.and_raise(gix_error::message!(
+                "Could not read configuration file at \"{}\"",
+                config_path.display()
+            )));
             if lenient {
                 gix_trace::warn!("ignoring: {err:#?}");
                 return Ok(gix_config::File::new(metadata));
@@ -141,10 +154,10 @@ fn load_config(
 
     buf.clear();
     if let Err(err) = std::io::copy(&mut file, buf) {
-        let err = Error::Io {
-            source: err,
-            path: config_path,
-        };
+        let err = Error::from(err.and_raise(gix_error::message!(
+            "Could not read configuration file at \"{}\"",
+            config_path.display()
+        )));
         if lenient {
             gix_trace::warn!("ignoring: {err:#?}");
             buf.clear();
diff --git a/gix/src/config/cache/init.rs b/gix/src/config/cache/init.rs
index c5788cfc632..d7e2fcbecc6 100644
--- a/gix/src/config/cache/init.rs
+++ b/gix/src/config/cache/init.rs
@@ -1,10 +1,12 @@
 #![allow(clippy::result_large_err)]
 use std::ffi::OsString;
 
+use gix_error::{ErrorExt, ResultExt};
 use gix_sec::Permission;
 
-use super::{Error, StageOne, interpolate_context, util};
+use super::{StageOne, interpolate_context, util};
 use crate::{
+    Result,
     bstr::BString,
     config,
     config::{
@@ -44,7 +46,7 @@ impl Cache {
         api_config_overrides: &[BString],
         cli_config_overrides: &[BString],
         use_repository_local_environment: bool,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let config = load(
             Some(git_dir_config),
             &mut buf,
@@ -119,7 +121,7 @@ impl Cache {
     /// However, those that are lazily read won't be re-evaluated right away and might thus pass now but fail later.
     ///
     /// Note that we unconditionally re-read all values.
-    pub fn reread_values_and_clear_caches_replacing_config(&mut self, config: crate::Config) -> Result<(), Error> {
+    pub fn reread_values_and_clear_caches_replacing_config(&mut self, config: crate::Config) -> Result<()> {
         let prev = std::mem::replace(&mut self.resolved, config);
         match self.reread_values_and_clear_caches() {
             Err(err) => {
@@ -132,7 +134,7 @@ impl Cache {
 
     /// Similar to `reread_values_and_clear_caches_replacing_config()`, but works on the existing configuration instead of a passed
     /// in one that it them makes the default.
-    pub fn reread_values_and_clear_caches(&mut self) -> Result<(), Error> {
+    pub fn reread_values_and_clear_caches(&mut self) -> Result<()> {
         let config = &self.resolved;
         let hex_len = util::parse_core_abbrev(config, self.object_hash).with_leniency(self.lenient_config)?;
 
@@ -275,7 +277,7 @@ pub(crate) fn load(
     api_config_overrides: &[BString],
     cli_config_overrides: &[BString],
     use_repository_local_environment: bool,
-) -> Result<gix_config::File, Error> {
+) -> Result<gix_config::File> {
     let options = gix_config::file::init::Options {
         includes: if use_includes {
             gix_config::file::includes::Options::follow(
@@ -320,34 +322,36 @@ pub(crate) fn load(
             includes: gix_config::file::includes::Options::no_follow(),
             ..options
         },
-    )
-    .map_err(|err| match err {
-        gix_config::file::init::from_paths::Error::Init(err) => Error::from(err),
-        gix_config::file::init::from_paths::Error::Io { source, path } => Error::Io { source, path },
-    })?
+    )?
     .unwrap_or_default();
 
     let local_meta = git_dir_config.as_ref().map(gix_config::File::meta_owned);
     if let Some(git_dir_config) = git_dir_config {
-        globals.append(git_dir_config)?;
+        globals.append(git_dir_config).or_erased()?;
     }
     globals.resolve_includes(options)?;
     if use_env {
-        globals.append(gix_config::File::from_env(options)?.unwrap_or_default())?;
+        globals
+            .append(gix_config::File::from_env(options)?.unwrap_or_default())
+            .or_erased()?;
     }
     if !cli_config_overrides.is_empty() {
         config::overrides::append(&mut globals, cli_config_overrides, gix_config::Source::Cli, |_| None).map_err(
-            |err| Error::ConfigOverrides {
-                err,
-                source: gix_config::Source::Cli,
+            |err| {
+                err.and_raise(gix_error::message!(
+                    "{:?} configuration overrides at open or init time could not be applied.",
+                    gix_config::Source::Cli
+                ))
             },
         )?;
     }
     if !api_config_overrides.is_empty() {
         config::overrides::append(&mut globals, api_config_overrides, gix_config::Source::Api, |_| None).map_err(
-            |err| Error::ConfigOverrides {
-                err,
-                source: gix_config::Source::Api,
+            |err| {
+                err.and_raise(gix_error::message!(
+                    "{:?} configuration overrides at open or init time could not be applied.",
+                    gix_config::Source::Api
+                ))
             },
         )?;
     }
@@ -368,10 +372,7 @@ pub(crate) fn load(
 
 impl crate::Repository {
     /// Replace our own configuration with `config` and re-read all cached values, and apply them to select in-memory instances.
-    pub(crate) fn reread_values_and_clear_caches_replacing_config(
-        &mut self,
-        config: crate::Config,
-    ) -> Result<(), Error> {
+    pub(crate) fn reread_values_and_clear_caches_replacing_config(&mut self, config: crate::Config) -> Result<()> {
         let (
             previous_static_pack_cache_limit_bytes,
             previous_pack_cache_bytes,
@@ -413,7 +414,7 @@ fn apply_environment_overrides(
     identity: Permission,
     objects: Permission,
     use_repository_local_environment: bool,
-) -> Result<(), Error> {
+) -> Result<()> {
     fn env(key: &'static dyn config::tree::Key) -> &'static str {
         key.the_environment_override()
     }
@@ -757,7 +758,9 @@ fn apply_environment_overrides(
             .expect("statically known valid section name");
         for (var, key) in data {
             if let Some(value) = var_as_bstring(var, permission) {
-                section.push_with_comment(*key, value, format!("from {var}"))?;
+                section
+                    .push_with_comment(*key, value, format!("from {var}"))
+                    .or_erased()?;
             }
         }
         if section.num_values() == 0 {
@@ -786,7 +789,9 @@ fn apply_environment_overrides(
             },
         ] {
             if let Some(value) = var_as_bstring(var, permission) {
-                section.push_with_comment(key, value, format!("from {var}"))?;
+                section
+                    .push_with_comment(key, value, format!("from {var}"))
+                    .or_erased()?;
             }
         }
 
@@ -797,7 +802,7 @@ fn apply_environment_overrides(
     }
 
     if !env_override.is_void() {
-        config.append(env_override)?;
+        config.append(env_override).or_erased()?;
     }
     Ok(())
 }
diff --git a/gix/src/config/cache/mod.rs b/gix/src/config/cache/mod.rs
index ef618963d4d..f3539e0d027 100644
--- a/gix/src/config/cache/mod.rs
+++ b/gix/src/config/cache/mod.rs
@@ -1,4 +1,4 @@
-use super::{Cache, Error};
+use super::Cache;
 
 mod incubate;
 pub(crate) use incubate::StageOne;
diff --git a/gix/src/config/cache/util.rs b/gix/src/config/cache/util.rs
index 83125cd36a2..d22a4eaf847 100644
--- a/gix/src/config/cache/util.rs
+++ b/gix/src/config/cache/util.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::result_large_err)]
-use super::Error;
+
 use crate::{
-    config,
+    Result, config,
     config::tree::{Core, gitoxide},
 };
 
@@ -31,7 +31,7 @@ pub(crate) fn config_bool(
     key_str: &str,
     default: bool,
     lenient: bool,
-) -> Result<bool, Error> {
+) -> Result<bool> {
     use config::tree::Key;
     debug_assert_eq!(
         key_str,
@@ -40,7 +40,6 @@ pub(crate) fn config_bool(
     );
     Ok(key
         .enrich_error(config.boolean(key_str))
-        .map_err(Error::from)
         .with_lenient_default(lenient)?
         .unwrap_or(default))
 }
@@ -50,33 +49,30 @@ pub(crate) fn config_bool_opt(
     key: &'static config::tree::keys::Boolean,
     key_str: &str,
     lenient: bool,
-) -> Result<Option<bool>, Error> {
+) -> Result<Option<bool>> {
     use config::tree::Key;
     debug_assert_eq!(
         key_str,
         key.logical_name(),
         "BUG: key name and hardcoded name must match"
     );
-    key.enrich_error(config.boolean(key_str))
-        .map_err(Error::from)
-        .with_leniency(lenient)
+    key.enrich_error(config.boolean(key_str)).with_leniency(lenient)
 }
 
 pub(crate) fn query_refupdates(
     config: &gix_config::File,
     lenient_config: bool,
-) -> Result<Option<gix_ref::store::WriteReflog>, Error> {
+) -> Result<Option<gix_ref::store::WriteReflog>> {
     let key = "core.logAllRefUpdates";
     Core::LOG_ALL_REF_UPDATES
         .try_into_ref_updates(config.boolean(key))
         .with_leniency(lenient_config)
-        .map_err(Into::into)
 }
 
 pub(crate) fn query_refs_namespace(
     config: &gix_config::File,
     lenient_config: bool,
-) -> Result<Option<gix_ref::Namespace>, config::refs_namespace::Error> {
+) -> Result<Option<gix_ref::Namespace>> {
     let key = "gitoxide.core.refsNamespace";
     config
         .string(key)
@@ -103,7 +99,7 @@ pub(crate) fn parse_object_caches(
     config: &gix_config::File,
     lenient: bool,
     mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<ObjectCaches, Error> {
+) -> Result<ObjectCaches> {
     let static_pack_cache_limit = gitoxide::Core::DEFAULT_PACK_CACHE_MEMORY_LIMIT
         .try_into_usize(config.integer_filter("gitoxide.core.deltaBaseCacheLimit", &mut filter_config_section))
         .with_leniency(lenient)?;
@@ -125,10 +121,7 @@ pub(crate) fn parse_object_caches(
     ))
 }
 
-pub(crate) fn parse_core_abbrev(
-    config: &gix_config::File,
-    object_hash: gix_hash::Kind,
-) -> Result<Option<usize>, Error> {
+pub(crate) fn parse_core_abbrev(config: &gix_config::File, object_hash: gix_hash::Kind) -> Result<Option<usize>> {
     Ok(config
         .string("core.abbrev")
         .map(|abbrev| Core::ABBREV.try_into_abbreviation(abbrev, object_hash))
@@ -140,7 +133,7 @@ pub(crate) fn parse_core_abbrev(
 pub(crate) fn disambiguate_hint(
     config: &gix_config::File,
     lenient_config: bool,
-) -> Result<Option<crate::revision::spec::parse::ObjectKindHint>, config::key::GenericErrorWithValue> {
+) -> Result<Option<crate::revision::spec::parse::ObjectKindHint>> {
     match config.string("core.disambiguate") {
         None => Ok(None),
         Some(value) => Core::DISAMBIGUATE
@@ -162,7 +155,7 @@ pub trait ApplyLeniencyDefaultValue<T> {
     fn with_lenient_default_value(self, is_lenient: bool, default: T) -> Self;
 }
 
-impl<T, E> ApplyLeniency for Result<Option<T>, E> {
+impl<T, E> ApplyLeniency for std::result::Result<Option<T>, E> {
     fn with_leniency(self, is_lenient: bool) -> Self {
         match self {
             Ok(v) => Ok(v),
@@ -172,7 +165,7 @@ impl<T, E> ApplyLeniency for Result<Option<T>, E> {
     }
 }
 
-impl<T, E> ApplyLeniencyDefault for Result<T, E>
+impl<T, E> ApplyLeniencyDefault for std::result::Result<T, E>
 where
     T: Default,
 {
@@ -185,7 +178,7 @@ where
     }
 }
 
-impl<T, E> ApplyLeniencyDefaultValue<T> for Result<T, E> {
+impl<T, E> ApplyLeniencyDefaultValue<T> for std::result::Result<T, E> {
     fn with_lenient_default_value(self, is_lenient: bool, default: T) -> Self {
         match self {
             Ok(v) => Ok(v),
diff --git a/gix/src/config/file_mut.rs b/gix/src/config/file_mut.rs
index a272d810a76..be0e88cd4b7 100644
--- a/gix/src/config/file_mut.rs
+++ b/gix/src/config/file_mut.rs
@@ -5,49 +5,10 @@ use std::{
     ops::{Deref, DerefMut},
 };
 
-use super::FileTransaction;
+use gix_error::{ErrorExt, ResultExt, message};
 
-/// The error produced by [`crate::config_path()`] or when opening or committing a [`FileTransaction`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Configuration source {0:?} requires a repository or has no physical file")]
-    UnsupportedSource(gix_config::Source),
-    #[error("Configuration source {0:?} has no available path with these options")]
-    SourceUnavailable(gix_config::Source),
-    #[error("Could not load global configuration")]
-    Config(#[from] super::Error),
-    #[error("Could not obtain the current directory for a relative configuration path")]
-    CurrentDir(#[source] std::io::Error),
-    #[error(transparent)]
-    LockTimeout(#[from] super::lock_timeout::Error),
-    #[error(transparent)]
-    InvalidSharedRepository(#[from] crate::config::key::GenericErrorWithValue),
-    #[error("Could not acquire the lock for the configuration file")]
-    AcquireLock(#[from] gix_lock::acquire::Error),
-    #[error("Could not read metadata of the configuration file at {path:?}")]
-    Metadata {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error("Could not read the configuration file at {path:?}")]
-    Read {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error("Could not parse the configuration file at {path:?}")]
-    Parse {
-        source: gix_config::file::init::Error,
-        path: std::path::PathBuf,
-    },
-    #[error("Could not write the configuration file at {path:?}")]
-    Write {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error("Could not commit the configuration file lock")]
-    CommitLock(#[from] gix_lock::commit::Error<gix_lock::File>),
-}
+use super::FileTransaction;
+use crate::Result;
 
 impl FileTransaction {
     pub(crate) fn open(
@@ -56,7 +17,7 @@ impl FileTransaction {
         trust: gix_sec::Trust,
         lock_mode: gix_lock::acquire::Fail,
         shared_repository_permissions: i32,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let adjust_permissions =
             |permissions| gix_fs::adjust_shared_repository_permissions(permissions, shared_repository_permissions);
         let adjust_permissions: Option<&dyn Fn(std::fs::Permissions) -> std::fs::Permissions> =
@@ -67,52 +28,48 @@ impl FileTransaction {
             None,
             Some(&gix_lock::acquire::resolve_symlink),
             adjust_permissions,
-        )?;
+        )
+        .or_raise(|| message("Could not acquire the lock for the configuration file"))?;
         let path = lock.resource_path();
         let config = match std::fs::File::open(&path) {
             Ok(mut file) => {
                 let permissions = file
                     .metadata()
-                    .map_err(|source| Error::Metadata {
-                        source,
-                        path: path.clone(),
-                    })?
+                    .or_raise(|| message!("Could not read metadata of the configuration file at {path:?}"))?
                     .permissions();
                 lock.with_mut(|file| file.set_permissions(permissions))
-                    .map_err(|source| Error::Write {
-                        source,
-                        path: path.clone(),
-                    })?;
+                    .or_raise(|| message!("Could not write the configuration file at {path:?}"))?;
                 let mut bytes = Vec::new();
-                file.read_to_end(&mut bytes).map_err(|source| Error::Read {
-                    source,
-                    path: path.clone(),
-                })?;
+                file.read_to_end(&mut bytes)
+                    .or_raise(|| message!("Could not read the configuration file at {path:?}"))?;
                 gix_config::File::from_bytes_no_includes(
                     &bytes,
                     gix_config::file::Metadata::from(source).at(path.clone()).with(trust),
                     Default::default(),
                 )
-                .map_err(|source| Error::Parse {
-                    source,
-                    path: path.clone(),
-                })?
+                .or_raise(|| message!("Could not parse the configuration file at {path:?}"))?
             }
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
                 gix_config::File::new(gix_config::file::Metadata::from(source).at(path).with(trust))
             }
-            Err(source) => return Err(Error::Read { source, path }),
+            Err(err) => {
+                return Err(err
+                    .and_raise(message!("Could not read the configuration file at {path:?}"))
+                    .into());
+            }
         };
         Ok(FileTransaction { lock, config })
     }
 
     /// Write this physical file atomically without changing any repository instance.
-    pub fn commit(mut self) -> Result<(), Error> {
+    pub fn commit(mut self) -> Result<()> {
         let path = self.lock.resource_path();
         self.config
             .write_to(&mut self.lock)
-            .map_err(|source| Error::Write { source, path })?;
-        self.lock.commit()?;
+            .or_raise(|| message!("Could not write the configuration file at {path:?}"))?;
+        self.lock
+            .commit()
+            .or_raise(|| message("Could not commit the configuration file lock"))?;
         Ok(())
     }
 }
@@ -140,7 +97,7 @@ impl FileTransaction {
 pub(crate) fn shared_repository_permissions(
     config: &gix_config::File,
     filter: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<i32, Error> {
+) -> Result<i32> {
     let value = config.sections_by_name_and_filter("core", filter).and_then(|sections| {
         sections
             .filter(|section| section.header().subsection_name().is_none())
@@ -148,9 +105,7 @@ pub(crate) fn shared_repository_permissions(
             .last()
     });
     let Some(value) = value else { return Ok(0) };
-    crate::config::tree::Core::SHARED_REPOSITORY
-        .try_into_shared_repository(value)
-        .map_err(Into::into)
+    crate::config::tree::Core::SHARED_REPOSITORY.try_into_shared_repository(value)
 }
 
 impl Deref for FileTransaction {
diff --git a/gix/src/config/mod.rs b/gix/src/config/mod.rs
index 405dfc3bb4a..db7336d8ab1 100644
--- a/gix/src/config/mod.rs
+++ b/gix/src/config/mod.rs
@@ -1,7 +1,7 @@
 pub use gix_config::*;
 use gix_features::threading::OnceCell;
 
-use crate::{Repository, bstr::BString, repository::identity};
+use crate::{Repository, repository::identity};
 
 pub(crate) mod cache;
 pub mod file_mut;
@@ -63,103 +63,6 @@ pub mod section {
     }
 }
 
-///
-pub mod set_value {
-    /// The error produced when calling [`SnapshotMut::set(_subsection)?_value()`][crate::config::SnapshotMut::set_value()]
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        SetRaw(#[from] gix_config::file::set_raw_value::Error),
-        #[error(transparent)]
-        Validate(#[from] crate::config::tree::key::validate::Error),
-        #[error("The key needs a subsection parameter to be valid.")]
-        SubSectionRequired,
-        #[error("The key must not be used with a subsection")]
-        SubSectionForbidden,
-    }
-}
-
-/// The error returned when failing to initialize the repository configuration.
-///
-/// This configuration is on the critical path when opening a repository.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    ConfigBoolean(#[from] boolean::Error),
-    #[error(transparent)]
-    ConfigUnsigned(#[from] unsigned_integer::Error),
-    #[error(transparent)]
-    ConfigTypedString(#[from] key::GenericErrorWithValue),
-    #[error(transparent)]
-    ConfigCompression(#[from] key::GenericError),
-    #[error(transparent)]
-    RefsNamespace(#[from] refs_namespace::Error),
-    #[error("Cannot handle objects formatted as {:?}", .name)]
-    UnsupportedObjectFormat { name: BString },
-    #[error(
-        "extensions.objectFormat is a v1-only extension, but the repository format version is 0; \
-         set core.repositoryFormatVersion=1 to use it, or remove extensions.objectFormat to fall back to the default Sha1 format (if supported by this build)"
-    )]
-    ObjectFormatRequiresV1,
-    #[error("Unsupported repository format version {version}; only versions 0 and 1 are supported")]
-    UnsupportedRepositoryFormatVersion { version: usize },
-    #[error(transparent)]
-    CoreAbbrev(#[from] abbrev::Error),
-    #[error("Could not read configuration file at \"{}\"", path.display())]
-    Io {
-        source: std::io::Error,
-        path: std::path::PathBuf,
-    },
-    #[error(transparent)]
-    Init(#[from] gix_config::file::init::Error),
-    #[error(transparent)]
-    ResolveIncludes(#[from] gix_config::file::includes::Error),
-    #[error(transparent)]
-    Span(#[from] gix_config::parse::span::Error),
-    #[error(transparent)]
-    ConfigValue(#[from] gix_config::file::section::value::Error),
-    #[error(transparent)]
-    FromEnv(#[from] gix_config::file::init::from_env::Error),
-    #[error("The path {path:?} at the 'core.worktree' configuration could not be interpolated")]
-    PathInterpolation {
-        path: BString,
-        source: gix_config::path::interpolate::Error,
-    },
-    #[error("{source:?} configuration overrides at open or init time could not be applied.")]
-    ConfigOverrides {
-        #[source]
-        err: overrides::Error,
-        source: gix_config::Source,
-    },
-}
-
-///
-pub mod merge {
-    ///
-    pub mod pipeline_options {
-        /// The error produced when obtaining options needed to fill in [gix_merge::blob::pipeline::Options].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            BigFileThreshold(#[from] crate::config::unsigned_integer::Error),
-        }
-    }
-
-    ///
-    pub mod drivers {
-        /// The error produced when obtaining a list of [Drivers](gix_merge::blob::Driver).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            ConfigBoolean(#[from] crate::config::boolean::Error),
-        }
-    }
-}
-
 ///
 pub mod diff {
     ///
@@ -167,449 +70,114 @@ pub mod diff {
         use crate::bstr::BString;
 
         /// The error produced when obtaining `diff.algorithm`.
-        #[derive(Debug, thiserror::Error)]
+        #[derive(Debug)]
         #[expect(missing_docs)]
         pub enum Error {
-            #[error("Unknown diff algorithm named '{name}'")]
             Unknown { name: BString },
-            #[error("The '{name}' algorithm is not yet implemented")]
             Unimplemented { name: BString },
         }
-    }
-
-    ///
-    pub mod pipeline_options {
-        /// The error produced when obtaining options needed to fill in [gix_diff::blob::pipeline::Options].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            FilesystemCapabilities(#[from] crate::config::boolean::Error),
-            #[error(transparent)]
-            BigFileThreshold(#[from] crate::config::unsigned_integer::Error),
-        }
-    }
 
-    ///
-    pub mod drivers {
-        use crate::bstr::BString;
-
-        /// The error produced when obtaining a list of [Drivers](gix_diff::blob::Driver).
-        #[derive(Debug, thiserror::Error)]
-        #[error("Failed to parse value of 'diff.{name}.{attribute}'")]
-        pub struct Error {
-            /// The name of the driver.
-            pub name: BString,
-            /// The name of the attribute we tried to parse.
-            pub attribute: &'static str,
-            /// The actual error that occurred.
-            pub source: Box<dyn std::error::Error + Send + Sync + 'static>,
+        impl std::fmt::Display for Error {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    Error::Unknown { name } => write!(f, "Unknown diff algorithm named '{name}'"),
+                    Error::Unimplemented { name } => write!(f, "The '{name}' algorithm is not yet implemented"),
+                }
+            }
         }
-    }
-}
-
-///
-pub mod stat_options {
-    /// The error produced when collecting stat information, and returned by [Repository::stat_options()](crate::Repository::stat_options()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ConfigCheckStat(#[from] super::key::GenericErrorWithValue),
-        #[error(transparent)]
-        ConfigBoolean(#[from] super::boolean::Error),
-    }
-}
 
-///
-#[cfg(feature = "attributes")]
-pub mod checkout_options {
-    /// The error produced when collecting all information needed for checking out files into a worktree.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ConfigCheckStat(#[from] super::key::GenericErrorWithValue),
-        #[error(transparent)]
-        ConfigBoolean(#[from] super::boolean::Error),
-        #[error(transparent)]
-        CheckoutWorkers(#[from] super::checkout::workers::Error),
-        #[error(transparent)]
-        Attributes(#[from] super::attribute_stack::Error),
-        #[error(transparent)]
-        FilterPipelineOptions(#[from] crate::filter::pipeline::options::Error),
-        #[error(transparent)]
-        CommandContext(#[from] crate::config::command_context::Error),
+        impl std::error::Error for Error {}
     }
 }
 
+/// Configuration-key diagnostics and their shared metadata.
 ///
-#[cfg(feature = "command")]
-pub mod command_context {
-    use crate::config;
-
-    /// The error produced when collecting all information relevant to spawned commands,
-    /// obtained via [Repository::command_context()](crate::Repository::command_context()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Boolean(#[from] config::boolean::Error),
-        #[error(transparent)]
-        ParseBool(#[from] gix_config::value::Error),
-    }
-}
-
-///
-pub mod exclude_stack {
-    use crate::config;
-    use std::path::PathBuf;
-
-    /// The error produced when setting up a stack to query `gitignore` information.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not read repository exclude")]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        EnvironmentPermission(#[from] gix_sec::permission::Error<PathBuf>),
-        #[error("The value for `core.excludesFile` could not be read from configuration")]
-        ExcludesFilePathInterpolation(#[from] gix_config::path::interpolate::Error),
-        #[error(transparent)]
-        ParsePreciousEnabled(#[from] config::boolean::Error),
-    }
-}
+/// Errors from configuration conversions expose the logical `key` name and, when available, the
+/// offending `input` and a possible `environment_override` through [`crate::Error::metadata()`].
+pub(crate) mod key {
+    use gix_error::{Message, MetadataValue};
 
-///
-pub mod attribute_stack {
-    /// The error produced when setting up the attribute stack to query `gitattributes`.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("An attribute file could not be read")]
-        Io(#[from] std::io::Error),
-        #[error("Failed to interpolate the attribute file configured at `core.attributesFile`")]
-        AttributesFileInterpolation(#[from] gix_config::path::interpolate::Error),
-    }
-}
+    use super::tree;
 
-///
-pub mod protocol {
+    /// Create a validation diagnostic with `message` and the metadata describing `key`.
     ///
-    pub mod allow {
-        use crate::bstr::BString;
-
-        /// The error returned when obtaining the permission for a particular scheme.
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        #[error("The value {value:?} must be allow|deny|user in configuration key protocol{0}.allow", scheme.as_ref().map(|s| format!(".{s}")).unwrap_or_default())]
-        pub struct Error {
-            pub scheme: Option<String>,
-            pub value: BString,
+    /// `key` is its logical name as a string, including placeholders for parameterized subsections.
+    /// `environment_override` is included as a string if an override is declared on this key or a
+    /// fallback key. It describes a possible override, not the actual source of the invalid value.
+    pub fn error(key: &dyn tree::Key, message: &'static str) -> Message {
+        let mut error = gix_error::validation(message).with("key", key.logical_name());
+        if let Some(environment) = key.environment_override() {
+            error = error.with("environment_override", environment);
         }
+        error
     }
-}
 
-///
-pub mod ssh_connect_options {
-    /// The error produced when obtaining ssh connection configuration.
-    #[derive(Debug, thiserror::Error)]
-    #[error(transparent)]
-    pub struct Error(#[from] super::key::GenericErrorWithValue);
-}
-
-///
-pub mod key {
-    use crate::bstr::BString;
-
-    const fn prefix(kind: char) -> &'static str {
-        match kind {
-            'n' => "",                         // nothing
-            'k' => "The value of key",         // generic key
-            't' => "The date format at key",   // time
-            'i' => "The timeout at key",       // timeout
-            'd' => "The duration [ms] at key", // duration
-            'b' => "The boolean at key",       // boolean
-            'v' => "The key",                  // generic key with value
-            'r' => "The refspec at",           // refspec
-            's' => "The ssl version at",       // ssl-version
-            'u' => "The url at",               // url
-            'w' => "The utf-8 string at",      // string
-            _ => panic!("BUG: invalid prefix kind - add a case for it here"),
-        }
-    }
-    const fn suffix(kind: char) -> &'static str {
-        match kind {
-            'd' => "could not be decoded",                    // decoding
-            'i' => "was invalid",                             // invalid
-            'u' => "could not be parsed as unsigned integer", // unsigned integer
-            'p' => "could not be parsed",                     // parsing
-            _ => panic!("BUG: invalid suffix kind - add a case for it here"),
-        }
-    }
-    /// A generic error suitable to produce decent messages for all kinds of configuration errors with config-key granularity.
+    /// Create a validation diagnostic with the metadata from [`error()`] and `value` as `input`.
     ///
-    /// This error is meant to be reusable and help produce uniform error messages related to parsing any configuration key.
-    #[derive(Debug, thiserror::Error)]
-    #[error("{} \"{key}{}\"{} {}", prefix(PREFIX), value.as_ref().map(|v| format!("={v}")).unwrap_or_default(), environment_override.as_deref().map(|var| format!(" (possibly from {var})")).unwrap_or_default(), suffix(SUFFIX))]
-    pub struct Error<E: std::error::Error + Send + Sync + 'static, const PREFIX: char, const SUFFIX: char> {
-        /// The configuration key that contained the value.
-        pub key: BString,
-        /// The value that was assigned to `key`.
-        pub value: Option<BString>,
-        /// The associated environment variable that would override this value.
-        pub environment_override: Option<&'static str>,
-        /// The source of the error if there was one.
-        pub source: Option<E>,
+    /// Pass raw configuration values as byte strings to preserve non-UTF-8 input. Parsed numbers
+    /// retain their numeric type. An empty value is distinct from the absent input in [`error()`].
+    pub fn error_with_value(key: &dyn tree::Key, message: &'static str, value: impl Into<MetadataValue>) -> Message {
+        error(key, message).with("input", value)
     }
 
-    /// Initialization
-    /// Instantiate a new error from the given `key`.
-    ///
-    /// Note that specifics of the error message are defined by the `PREFIX` and `SUFFIX` which is usually defined by a typedef.
-    impl<T, E, const PREFIX: char, const SUFFIX: char> From<&'static T> for Error<E, PREFIX, SUFFIX>
-    where
-        E: std::error::Error + Send + Sync + 'static,
-        T: super::tree::Key,
-    {
-        fn from(key: &'static T) -> Self {
-            Error {
-                key: key.logical_name().into(),
-                value: None,
-                environment_override: key.environment_override(),
-                source: None,
+    #[cfg(test)]
+    mod tests {
+        use super::{MetadataValue, error, error_with_value};
+        use crate::{
+            Error,
+            bstr::ByteSlice,
+            config::tree::{Core, Key, Remote, keys},
+        };
+
+        #[test]
+        fn helpers_cover_key_value_and_environment_metadata() {
+            let fallback = keys::Any::new("fallback", &Core).with_fallback(&Core::DELTA_BASE_CACHE_LIMIT);
+            for (key, name, environment) in [
+                (&Core::BARE as &dyn Key, "core.bare", None),
+                (&Remote::URL, "remote.<name>.url", None),
+                (
+                    &Core::DELTA_BASE_CACHE_LIMIT,
+                    "core.deltaBaseCacheLimit",
+                    Some("GIX_PACK_CACHE_MEMORY"),
+                ),
+                (&fallback, "core.fallback", Some("GIX_PACK_CACHE_MEMORY")),
+            ] {
+                let empty = b"".as_bstr();
+                for (message, input) in [
+                    (error(key, "Invalid configuration value"), None),
+                    (
+                        error_with_value(key, "Invalid configuration value", empty),
+                        Some(MetadataValue::from(empty)),
+                    ),
+                ] {
+                    let error = Error::from_error(message);
+                    assert!(
+                        error.is_validation(),
+                        "invalid configuration is classified as validation"
+                    );
+                    let metadata = error.metadata().next().expect("a configuration error has metadata");
+                    assert_eq!(
+                        metadata.get("key"),
+                        Some(&MetadataValue::from(name)),
+                        "the context identifies the key"
+                    );
+                    assert_eq!(
+                        metadata.get("input"),
+                        input.as_ref(),
+                        "the context retains the available input"
+                    );
+                    assert_eq!(
+                        metadata.get("environment_override"),
+                        environment.map(MetadataValue::from).as_ref(),
+                        "the context identifies the possible environment override"
+                    );
+                }
             }
-        }
-    }
-
-    /// Initialization
-    impl<E, const PREFIX: char, const SUFFIX: char> Error<E, PREFIX, SUFFIX>
-    where
-        E: std::error::Error + Send + Sync + 'static,
-    {
-        /// Instantiate an error with all data from `key` along with the `value` of the key.
-        pub fn from_value(key: &'static impl super::tree::Key, value: BString) -> Self {
-            Error::from(key).with_value(value)
-        }
-    }
-
-    /// Builder
-    impl<E, const PREFIX: char, const SUFFIX: char> Error<E, PREFIX, SUFFIX>
-    where
-        E: std::error::Error + Send + Sync + 'static,
-    {
-        /// Attach the given `err` as source.
-        pub fn with_source(mut self, err: E) -> Self {
-            self.source = Some(err);
-            self
-        }
-
-        /// Attach the given `value` as value we observed when the error was produced.
-        pub fn with_value(mut self, value: BString) -> Self {
-            self.value = Some(value);
-            self
-        }
-    }
-
-    /// A generic key error for use when it doesn't seem worth it say more than 'key is invalid' along with meta-data.
-    pub type GenericError<E = gix_config::value::Error> = Error<E, 'k', 'i'>;
-
-    /// A generic key error which will also contain a value.
-    pub type GenericErrorWithValue<E = gix_config::value::Error> = Error<E, 'v', 'i'>;
-}
-
-///
-pub mod encoding {
-    use crate::bstr::BString;
-
-    /// The error produced when failing to parse the `core.checkRoundTripEncoding` key.
-    #[derive(Debug, thiserror::Error)]
-    #[error("The encoding named '{encoding}' seen in key '{key}={value}' is unsupported")]
-    pub struct Error {
-        /// The configuration key that contained the value.
-        pub key: BString,
-        /// The value that was assigned to `key`.
-        pub value: BString,
-        /// The encoding that failed.
-        pub encoding: BString,
-    }
-}
-
-///
-pub mod checkout {
-    ///
-    pub mod workers {
-        use crate::config;
-
-        /// The error produced when failing to parse the `checkout.workers` key.
-        pub type Error = config::key::Error<gix_config::value::Error, 'n', 'd'>;
-    }
-}
-
-///
-pub mod abbrev {
-    use crate::bstr::BString;
-
-    /// The error describing an incorrect `core.abbrev` value.
-    #[derive(Debug, thiserror::Error)]
-    #[error("Invalid value for 'core.abbrev' = '{}'. It must be between 4 and {}", .value, .max)]
-    pub struct Error {
-        /// The value found in the git configuration
-        pub value: BString,
-        /// The maximum abbreviation length, the length of an object hash.
-        pub max: u8,
-    }
-}
-
-///
-pub mod remote {
-    ///
-    pub mod symbolic_name {
-        /// The error produced when failing to produce a symbolic remote name from configuration.
-        pub type Error = super::super::key::Error<crate::remote::name::Error, 'v', 'i'>;
-    }
-}
-
-///
-pub mod time {
-    /// The error produced when failing to parse time from configuration.
-    pub type Error = super::key::Error<gix_date::Error, 't', 'i'>;
-}
-
-///
-pub mod commit_signature {
-    /// The error produced when obtaining or installing a fallback commit signature.
-    #[derive(Debug, thiserror::Error)]
-    #[allow(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Time(#[from] super::time::Error),
-        #[error(transparent)]
-        SetValue(#[from] gix_config::file::set_raw_value::Error),
-        #[error(transparent)]
-        Span(#[from] gix_config::parse::span::Error),
-    }
-}
-
-///
-pub mod lock_timeout {
-    /// The error produced when failing to parse timeout for locks.
-    pub type Error = super::key::Error<gix_config::value::Error, 'i', 'i'>;
-}
-
-///
-pub mod duration {
-    /// The error produced when failing to parse durations (in milliseconds).
-    pub type Error = super::key::Error<gix_config::value::Error, 'd', 'i'>;
-}
-
-///
-pub mod boolean {
-    /// The error produced when failing to parse time from configuration.
-    pub type Error = super::key::Error<gix_config::value::Error, 'b', 'i'>;
-}
-
-///
-pub mod unsigned_integer {
-    /// The error produced when failing to parse a signed integer from configuration.
-    pub type Error = super::key::Error<gix_config::value::Error, 'k', 'u'>;
-}
-
-///
-pub mod url {
-    /// The error produced when failing to parse a url from the configuration.
-    pub type Error = super::key::Error<gix_error::Error, 'u', 'p'>;
-}
-
-///
-pub mod string {
-    /// The error produced when failing to interpret configuration as UTF-8 encoded string.
-    pub type Error = super::key::Error<crate::bstr::Utf8Error, 'w', 'd'>;
-}
-
-///
-pub mod refspec {
-    /// The error produced when failing to parse a refspec from the configuration.
-    pub type Error = super::key::Error<gix_refspec::parse::Error, 'r', 'p'>;
-}
-
-///
-pub mod refs_namespace {
-    /// The error produced when failing to parse a refspec from the configuration.
-    pub type Error = super::key::Error<gix_validate::reference::name::Error, 'v', 'i'>;
-}
-
-///
-pub mod ssl_version {
-    /// The error produced when failing to parse a refspec from the configuration.
-    pub type Error = super::key::Error<std::convert::Infallible, 's', 'i'>;
-}
-
-///
-pub mod transport {
-    use crate::bstr::BString;
-
-    /// The error produced when configuring a transport for a particular protocol.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(
-            "Could not interpret configuration key {key:?} as {kind} integer of desired range with value: {actual}"
-        )]
-        InvalidInteger {
-            key: &'static str,
-            kind: &'static str,
-            actual: i64,
-        },
-        #[error("Could not interpret configuration key {key:?}")]
-        ConfigValue {
-            source: gix_config::value::Error,
-            key: &'static str,
-        },
-        #[error("Could not interpolate path at key {key:?}")]
-        InterpolatePath {
-            source: gix_config::path::interpolate::Error,
-            key: &'static str,
-        },
-        #[error("Could not decode value at key {key:?} as UTF-8 string")]
-        IllformedUtf8 {
-            key: BString,
-            source: crate::config::string::Error,
-        },
-        #[error("Invalid URL passed for configuration")]
-        ParseUrl(#[from] gix_error::Error),
-        #[error("Could obtain configuration for an HTTP url")]
-        Http(#[from] http::Error),
-    }
-
-    ///
-    pub mod http {
-        use crate::bstr::BString;
-
-        /// The error produced when configuring a HTTP transport.
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            Boolean(#[from] crate::config::boolean::Error),
-            #[error(transparent)]
-            UnsignedInteger(#[from] crate::config::unsigned_integer::Error),
-            #[error(transparent)]
-            ConnectTimeout(#[from] crate::config::duration::Error),
-            #[error("The proxy authentication at key `{key}` is invalid")]
-            InvalidProxyAuthMethod {
-                source: crate::config::key::GenericErrorWithValue,
-                key: BString,
-            },
-            #[error("Could not configure the credential helpers for the authenticated proxy url")]
-            #[cfg(feature = "credentials")]
-            ConfigureProxyAuthenticate(#[from] crate::config::snapshot::credential_helpers::Error),
-            #[error(transparent)]
-            InvalidSslVersion(#[from] crate::config::ssl_version::Error),
-            #[error("The HTTP version must be 'HTTP/2' or 'HTTP/1.1'")]
-            InvalidHttpVersion(#[from] crate::config::key::GenericErrorWithValue),
-            #[error("The follow redirects value 'initial', or boolean true or false")]
-            InvalidFollowRedirects(#[source] crate::config::key::GenericErrorWithValue),
+            assert_eq!(
+                error_with_value(&Core::BARE, "Invalid boolean", b"bad".as_bstr()).to_string(),
+                "Invalid boolean, \"input\"=\"bad\", \"key\"=\"core.bare\"",
+                "the standard message display includes its diagnostic metadata"
+            );
         }
     }
 }
@@ -677,16 +245,14 @@ pub(crate) struct Cache {
 
 /// Utilities shared privately across the crate, for lack of a better place.
 pub(crate) mod shared {
-    use crate::{
-        config,
-        config::{cache::util::ApplyLeniency, tree::Core},
-    };
+    use crate::Result;
+    use crate::config::{cache::util::ApplyLeniency, tree::Core};
 
     pub fn is_replace_refs_enabled(
         config: &gix_config::File,
         lenient: bool,
         mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-    ) -> Result<Option<bool>, config::boolean::Error> {
+    ) -> Result<Option<bool>> {
         Core::USE_REPLACE_REFS
             .enrich_error(config.boolean_filter("core.useReplaceRefs", &mut filter_config_section))
             .with_leniency(lenient)
diff --git a/gix/src/config/overrides.rs b/gix/src/config/overrides.rs
index 2249450c8bf..1b9236d79eb 100644
--- a/gix/src/config/overrides.rs
+++ b/gix/src/config/overrides.rs
@@ -1,40 +1,39 @@
-use crate::bstr::{BStr, BString, ByteSlice};
+use gix_error::ResultExt;
 
-/// The error returned by [`SnapshotMut::apply_cli_overrides()`][crate::config::SnapshotMut::append_config()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("{input:?} is not a valid configuration key. Examples are 'core.abbrev' or 'remote.origin.url'")]
-    InvalidKey { input: BString },
-    #[error(transparent)]
-    SectionHeader(#[from] gix_config::parse::section::header::Error),
-    #[error(transparent)]
-    Span(#[from] gix_config::parse::span::Error),
-    #[error(transparent)]
-    ConfigValue(#[from] gix_config::file::section::value::Error),
-}
+use crate::{
+    Error, Result,
+    bstr::{BStr, BString, ByteSlice},
+};
 
 pub(crate) fn append(
     config: &mut gix_config::File,
     values: impl IntoIterator<Item = impl gix_utils::AsBStr>,
     source: gix_config::Source,
     mut make_comment: impl FnMut(&BStr) -> Option<BString>,
-) -> Result<(), Error> {
+) -> Result<()> {
     let mut file = gix_config::File::new(gix_config::file::Metadata::from(source));
     for key_value in values {
         let key_value = key_value.as_bstr();
         let mut tokens = key_value.splitn(2, |b| *b == b'=').map(ByteSlice::trim);
         let key = tokens.next().expect("always one value").as_bstr();
         let value = tokens.next();
-        let key = gix_config::KeyRef::parse_unvalidated(key).ok_or_else(|| Error::InvalidKey { input: key.into() })?;
-        let mut section = file.section_mut_or_create_new(key.section_name, key.subsection_name)?;
+        let key = gix_config::KeyRef::parse_unvalidated(key).ok_or_else(|| {
+            let input: BString = key.into();
+            Error::from_error(gix_error::message!(
+                "{input:?} is not a valid configuration key. Examples are 'core.abbrev' or 'remote.origin.url'"
+            ))
+        })?;
+        let mut section = file
+            .section_mut_or_create_new(key.section_name, key.subsection_name)
+            .or_erased()?;
         let comment = make_comment(key_value);
         let value = value.map(ByteSlice::as_bstr);
         match comment {
             Some(comment) => section.push_with_comment(key.value_name, value, &**comment),
             None => section.push(key.value_name, value),
-        }?;
+        }
+        .or_erased()?;
     }
-    config.append(file)?;
+    config.append(file).or_erased()?;
     Ok(())
 }
diff --git a/gix/src/config/snapshot/access.rs b/gix/src/config/snapshot/access.rs
index 0e0a2438f9d..fa2af496c10 100644
--- a/gix/src/config/snapshot/access.rs
+++ b/gix/src/config/snapshot/access.rs
@@ -4,6 +4,7 @@ use std::ffi::OsString;
 use gix_features::threading::OwnShared;
 
 use crate::{
+    Error, Result,
     bstr::{BString, ByteSlice},
     config::{CommitAutoRollback, Snapshot, SnapshotMut},
 };
@@ -25,8 +26,8 @@ impl Snapshot<'_> {
     }
 
     /// Like [`boolean()`][Self::boolean()], but it will report an error if the value couldn't be interpreted as boolean.
-    pub fn try_boolean(&self, key: impl gix_config::AsKey) -> Result<Option<bool>, gix_config::value::Error> {
-        self.repo.config.resolved.boolean(key)
+    pub fn try_boolean(&self, key: impl gix_config::AsKey) -> Result<Option<bool>> {
+        self.repo.config.resolved.boolean(key).map_err(Into::into)
     }
 
     /// Return the resolved integer at `key`, or `None` if there is no such value or if the value can't be interpreted as
@@ -40,8 +41,8 @@ impl Snapshot<'_> {
     }
 
     /// Like [`integer()`][Self::integer()], but it will report an error if the value couldn't be interpreted as boolean.
-    pub fn try_integer(&self, key: impl gix_config::AsKey) -> Result<Option<i64>, gix_config::value::Error> {
-        self.repo.config.resolved.integer(key)
+    pub fn try_integer(&self, key: impl gix_config::AsKey) -> Result<Option<i64>> {
+        self.repo.config.resolved.integer(key).map_err(Into::into)
     }
 
     /// Return the string at `key`, or `None` if there is no such value.
@@ -60,11 +61,8 @@ impl Snapshot<'_> {
     /// The path can be prefixed with `:(optional)` which means it won't be returned if the interpolated
     /// path couldn't be accessed. Note also that this is different from Git, which ignores it only if
     /// it doesn't exist.
-    pub fn trusted_path(
-        &self,
-        key: impl gix_config::AsKey,
-    ) -> Result<Option<std::path::PathBuf>, gix_config::path::interpolate::Error> {
-        self.repo.config.trusted_file_path(key)
+    pub fn trusted_path(&self, key: impl gix_config::AsKey) -> Result<Option<std::path::PathBuf>> {
+        self.repo.config.trusted_file_path(key).map_err(Into::into)
     }
 
     /// Return the trusted string at `key` for launching using [command::prepare()](gix_command::prepare()),
@@ -100,7 +98,7 @@ impl<'repo> SnapshotMut<'repo> {
         &mut self,
         values: impl IntoIterator<Item = impl gix_utils::AsBStr>,
         source: gix_config::Source,
-    ) -> Result<&mut Self, crate::config::overrides::Error> {
+    ) -> Result<&mut Self> {
         crate::config::overrides::append(&mut self.config, values, source, |v| Some(format!("-c {v}").into()))?;
         Ok(self)
     }
@@ -108,7 +106,7 @@ impl<'repo> SnapshotMut<'repo> {
     ///
     /// Note that this would also happen once this instance is dropped, but using this method may be more intuitive and won't squelch errors
     /// in case the new configuration is partially invalid.
-    pub fn commit(mut self) -> Result<&'repo mut crate::Repository, crate::config::Error> {
+    pub fn commit(mut self) -> Result<&'repo mut crate::Repository> {
         let repo = self.repo.take().expect("always present here");
         self.commit_inner(repo)
     }
@@ -119,9 +117,11 @@ impl<'repo> SnapshotMut<'repo> {
         &mut self,
         key: &'static dyn crate::config::tree::Key,
         new_value: impl gix_utils::AsBStr,
-    ) -> Result<Option<BString>, crate::config::set_value::Error> {
+    ) -> Result<Option<BString>> {
         if let Some(crate::config::tree::SubSectionRequirement::Parameter(_)) = key.subsection_requirement() {
-            return Err(crate::config::set_value::Error::SubSectionRequired);
+            return Err(Error::from_error(gix_error::validation(
+                "The key needs a subsection parameter to be valid.",
+            )));
         }
         let value = new_value.as_bstr();
         key.validate(value)?;
@@ -142,9 +142,11 @@ impl<'repo> SnapshotMut<'repo> {
         key: &'static dyn crate::config::tree::Key,
         subsection: impl gix_utils::AsBStr,
         new_value: impl gix_utils::AsBStr,
-    ) -> Result<Option<BString>, crate::config::set_value::Error> {
+    ) -> Result<Option<BString>> {
         if let Some(crate::config::tree::SubSectionRequirement::Never) = key.subsection_requirement() {
-            return Err(crate::config::set_value::Error::SubSectionForbidden);
+            return Err(Error::from_error(gix_error::validation(
+                "The key must not be used with a subsection",
+            )));
         }
         let value = new_value.as_bstr();
         key.validate(value)?;
@@ -160,16 +162,13 @@ impl<'repo> SnapshotMut<'repo> {
         Ok(current)
     }
 
-    pub(crate) fn commit_inner(
-        &mut self,
-        repo: &'repo mut crate::Repository,
-    ) -> Result<&'repo mut crate::Repository, crate::config::Error> {
+    pub(crate) fn commit_inner(&mut self, repo: &'repo mut crate::Repository) -> Result<&'repo mut crate::Repository> {
         repo.reread_values_and_clear_caches_replacing_config(std::mem::take(&mut self.config).into())?;
         Ok(repo)
     }
 
     /// Create a structure the temporarily commits the changes, but rolls them back when dropped.
-    pub fn commit_auto_rollback(mut self) -> Result<CommitAutoRollback<'repo>, crate::config::Error> {
+    pub fn commit_auto_rollback(mut self) -> Result<CommitAutoRollback<'repo>> {
         let repo = self.repo.take().expect("this only runs once on consumption");
         let prev_config = OwnShared::clone(&repo.config.resolved);
 
@@ -189,7 +188,7 @@ impl<'repo> SnapshotMut<'repo> {
 /// Utilities
 impl<'repo> CommitAutoRollback<'repo> {
     /// Rollback the changes previously applied and all values before the change.
-    pub fn rollback(mut self) -> Result<&'repo mut crate::Repository, crate::config::Error> {
+    pub fn rollback(mut self) -> Result<&'repo mut crate::Repository> {
         let repo = self.repo.take().expect("still present, consumed only once");
         self.rollback_inner(repo)
     }
@@ -197,7 +196,7 @@ impl<'repo> CommitAutoRollback<'repo> {
     pub(crate) fn rollback_inner(
         &mut self,
         repo: &'repo mut crate::Repository,
-    ) -> Result<&'repo mut crate::Repository, crate::config::Error> {
+    ) -> Result<&'repo mut crate::Repository> {
         repo.reread_values_and_clear_caches_replacing_config(OwnShared::clone(&self.prev_config))?;
         Ok(repo)
     }
diff --git a/gix/src/config/snapshot/credential_helpers.rs b/gix/src/config/snapshot/credential_helpers.rs
index e3b07f1fe65..2b2b47eae03 100644
--- a/gix/src/config/snapshot/credential_helpers.rs
+++ b/gix/src/config/snapshot/credential_helpers.rs
@@ -1,25 +1,4 @@
-pub use error::Error;
-
-use crate::config::Snapshot;
-
-mod error {
-    use crate::bstr::BString;
-
-    /// The error returned by [`Snapshot::credential_helpers()`][super::Snapshot::credential_helpers()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not parse 'useHttpPath' key in section {section}")]
-        InvalidUseHttpPath {
-            section: BString,
-            source: gix_config::value::Error,
-        },
-        #[error("core.askpass could not be read")]
-        CoreAskpass(#[from] gix_config::path::interpolate::Error),
-        #[error(transparent)]
-        BooleanConfig(#[from] crate::config::boolean::Error),
-    }
-}
+use crate::{Result, config::Snapshot};
 
 impl Snapshot<'_> {
     /// Returns the configuration for all git-credential helpers from trusted configuration that apply
@@ -28,14 +7,11 @@ impl Snapshot<'_> {
     pub fn credential_helpers(
         &self,
         url: gix_url::Url,
-    ) -> Result<
-        (
-            gix_credentials::helper::Cascade,
-            gix_credentials::helper::Action,
-            gix_prompt::Options,
-        ),
-        Error,
-    > {
+    ) -> Result<(
+        gix_credentials::helper::Cascade,
+        gix_credentials::helper::Action,
+        gix_prompt::Options,
+    )> {
         let repo = self.repo;
         function::credential_helpers(
             url,
@@ -49,11 +25,13 @@ impl Snapshot<'_> {
 }
 
 pub(super) mod function {
+    use gix_error::ResultExt;
+
     use crate::{
+        Result,
         bstr::{ByteSlice, ByteVec},
         config::{
             cache::util::ApplyLeniency,
-            credential_helpers::Error,
             tree::{Core, Credential, credential, gitoxide::Credentials},
         },
     };
@@ -95,14 +73,11 @@ pub(super) mod function {
         mut filter: impl FnMut(&gix_config::file::Metadata) -> bool,
         environment: crate::open::permissions::Environment,
         mut use_http_path: bool,
-    ) -> Result<
-        (
-            gix_credentials::helper::Cascade,
-            gix_credentials::helper::Action,
-            gix_prompt::Options,
-        ),
-        Error,
-    > {
+    ) -> Result<(
+        gix_credentials::helper::Cascade,
+        gix_credentials::helper::Action,
+        gix_prompt::Options,
+    )> {
         let mut programs = Vec::new();
         let mut context_options = gix_credentials::protocol::ContextOptions::default();
         let url_had_user_initially = url.user().is_some();
@@ -168,9 +143,11 @@ pub(super) mod function {
                         .value(use_http_path_key.name)
                         .map(|val| {
                             gix_config::Boolean::try_from(val)
-                                .map_err(|err| Error::InvalidUseHttpPath {
-                                    source: err,
-                                    section: section.header().to_bstring(),
+                                .map_err(|err| {
+                                    err.raise(gix_error::validation(format!(
+                                        "Could not parse 'useHttpPath' key in section {}",
+                                        section.header().to_bstring()
+                                    )))
                                 })
                                 .map(|b| b.0)
                         })
@@ -200,10 +177,10 @@ pub(super) mod function {
                 config,
                 Core::ASKPASS,
                 &mut filter,
-                is_lenient_config,
+                true, // An empty core.askpass is allowed even with strict configuration.
                 environment,
             )
-            .ignore_empty()?,
+            .or_raise(|| gix_error::message("core.askpass could not be read"))?,
             mode: Credentials::TERMINAL_PROMPT
                 .enrich_error(config.boolean(Credentials::TERMINAL_PROMPT))
                 .with_leniency(is_lenient_config)?
@@ -275,18 +252,4 @@ pub(super) mod function {
         }
         gix_url::parse(pattern).ok()
     }
-
-    trait IgnoreEmptyPath {
-        fn ignore_empty(self) -> Self;
-    }
-
-    impl IgnoreEmptyPath for Result<Option<std::path::PathBuf>, gix_config::path::interpolate::Error> {
-        fn ignore_empty(self) -> Self {
-            match self {
-                Ok(maybe_path) => Ok(maybe_path),
-                Err(gix_config::path::interpolate::Error::Missing { .. }) => Ok(None),
-                Err(err) => Err(err),
-            }
-        }
-    }
 }
diff --git a/gix/src/config/tree/keys.rs b/gix/src/config/tree/keys.rs
index f93fc153078..405c747caca 100644
--- a/gix/src/config/tree/keys.rs
+++ b/gix/src/config/tree/keys.rs
@@ -1,12 +1,10 @@
-#![allow(clippy::result_large_err)]
-use std::{
-    error::Error,
-    fmt::{Debug, Formatter},
-};
+use std::fmt::{Debug, Formatter};
 
 use gix_config::KeyRef;
+use gix_error::ResultExt;
 
 use crate::{
+    ExnResult, Result,
     bstr::{BStr, ByteSlice},
     config,
     config::tree::{Key, Link, Note, Section, SubSectionRequirement},
@@ -105,23 +103,20 @@ impl<T: Validate> Any<T> {
         &'static self,
         value: impl gix_utils::AsBStr,
         op: gix_refspec::parse::Operation,
-    ) -> Result<gix_refspec::RefSpec, config::refspec::Error> {
+    ) -> Result<gix_refspec::RefSpec> {
         let value = value.as_bstr();
-        gix_refspec::parse(value.as_bstr(), op)
+        Ok(gix_refspec::parse(value.as_bstr(), op)
             .map(|spec| spec.to_owned())
-            .map_err(|err| config::refspec::Error::from_value(self, value.into()).with_source(err))
+            .or_raise(|| config::key::error_with_value(self, "Could not parse refspec", value))?)
     }
 
     /// Try to interpret `value` as UTF-8 encoded string.
-    pub fn try_into_string(
-        &'static self,
-        value: impl gix_utils::AsBStr,
-    ) -> Result<std::string::String, config::string::Error> {
-        use crate::bstr::ByteVec;
-        Vec::from(value.as_bstr().to_owned()).into_string().map_err(|err| {
-            let utf8_err = err.utf8_error().clone();
-            config::string::Error::from_value(self, err.into_vec().into()).with_source(utf8_err)
-        })
+    pub fn try_into_string(&'static self, value: impl gix_utils::AsBStr) -> Result<std::string::String> {
+        let value = value.as_bstr();
+        Ok(value
+            .to_str()
+            .or_raise(|| config::key::error_with_value(self, "Could not decode UTF-8 string", value))?
+            .to_owned())
     }
 }
 
@@ -142,8 +137,11 @@ impl<T: Validate> Key for Any<T> {
         self.name
     }
 
-    fn validate(&self, value: &BStr) -> Result<(), config::tree::key::validate::Error> {
-        Ok(self.validate.validate(value)?)
+    fn validate(&self, value: &BStr) -> Result<()> {
+        self.validate
+            .validate(value)
+            .or_raise(|| config::key::error_with_value(self, "Invalid configuration value", value))?;
+        Ok(())
     }
 
     fn section(&self) -> &dyn Section {
@@ -244,8 +242,10 @@ pub type FetchRefSpec = Any<validate::FetchRefSpec>;
 mod duration {
     use std::time::Duration;
 
+    use gix_error::ResultExt;
+
     use crate::{
-        config,
+        ExnMessageResult, Result, config,
         config::tree::{Section, keys::DurationInMilliseconds},
     };
 
@@ -258,9 +258,9 @@ mod duration {
         /// Return a valid duration as parsed from an integer that is interpreted as milliseconds.
         pub fn try_into_duration(
             &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<std::time::Duration>, config::duration::Error> {
-            let Some(value) = value.map_err(|err| config::duration::Error::from(self).with_source(err))? else {
+            value: ExnMessageResult<Option<i64>>,
+        ) -> Result<Option<std::time::Duration>> {
+            let Some(value) = value.or_raise(|| config::key::error(self, "Invalid duration in milliseconds"))? else {
                 return Ok(None);
             };
             Ok(Some(match value {
@@ -274,10 +274,11 @@ mod duration {
 mod lock_timeout {
     use std::time::Duration;
 
+    use gix_error::ResultExt;
     use gix_lock::acquire::Fail;
 
     use crate::{
-        config,
+        ExnMessageResult, Result, config,
         config::tree::{Section, keys::LockTimeout},
     };
 
@@ -290,9 +291,9 @@ mod lock_timeout {
         /// Return information on how long to wait for locked files.
         pub fn try_into_lock_timeout(
             &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<gix_lock::acquire::Fail>, config::lock_timeout::Error> {
-            let Some(value) = value.map_err(|err| config::lock_timeout::Error::from(self).with_source(err))? else {
+            value: ExnMessageResult<Option<i64>>,
+        ) -> Result<Option<gix_lock::acquire::Fail>> {
+            let Some(value) = value.or_raise(|| config::key::error(self, "Invalid lock timeout"))? else {
                 return Ok(None);
             };
             Ok(Some(match value {
@@ -307,8 +308,10 @@ mod lock_timeout {
 }
 
 mod compression {
+    use gix_error::{ErrorExt, ResultExt};
+
     use crate::{
-        config,
+        ExnMessageResult, Result, config,
         config::tree::{Section, keys::Compression},
     };
 
@@ -322,9 +325,9 @@ mod compression {
         /// zlib default, just like `git` does.
         pub fn try_into_compression(
             &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<gix_zlib::Compression>, config::key::GenericError> {
-            let Some(value) = value.map_err(|err| config::key::GenericError::from(self).with_source(err))? else {
+            value: ExnMessageResult<Option<i64>>,
+        ) -> Result<Option<gix_zlib::Compression>> {
+            let Some(value) = value.or_raise(|| config::key::error(self, "Invalid compression level"))? else {
                 return Ok(None);
             };
             match value {
@@ -333,7 +336,11 @@ mod compression {
                     .ok()
                     .and_then(gix_zlib::Compression::new)
                     .map(Some)
-                    .ok_or_else(|| config::key::GenericError::from(self)),
+                    .ok_or_else(|| {
+                        config::key::error_with_value(self, "Invalid compression level", level)
+                            .raise()
+                            .into()
+                    }),
             }
         }
     }
@@ -361,7 +368,10 @@ mod refspecs {
 }
 
 mod url {
+    use gix_error::ResultExt;
+
     use crate::{
+        Result,
         bstr::ByteSlice,
         config,
         config::tree::{
@@ -377,10 +387,10 @@ mod url {
         }
 
         /// Try to parse `value` as URL.
-        pub fn try_into_url(&'static self, value: impl gix_utils::AsBStr) -> Result<gix_url::Url, config::url::Error> {
+        pub fn try_into_url(&'static self, value: impl gix_utils::AsBStr) -> Result<gix_url::Url> {
             let value = value.as_bstr();
-            gix_url::parse(value.as_bstr())
-                .map_err(|err| config::url::Error::from_value(self, value.into()).with_source(err.into_error()))
+            Ok(gix_url::parse(value.as_bstr())
+                .or_raise(|| config::key::error_with_value(self, "Could not parse URL", value))?)
         }
     }
 }
@@ -414,7 +424,13 @@ impl Path {
 }
 
 mod workers {
-    use crate::config::tree::{Section, keys::UnsignedInteger};
+    use gix_error::ResultExt;
+
+    use crate::{
+        ExnMessageResult, Result,
+        config::key,
+        config::tree::{Section, keys::UnsignedInteger},
+    };
 
     impl UnsignedInteger {
         /// Create a new instance.
@@ -422,62 +438,52 @@ mod workers {
             Self::new_with_validate(name, section, super::validate::UnsignedInteger)
         }
 
-        /// Convert `value` into a `usize` or wrap it into a specialized error.
-        pub fn try_into_usize(
-            &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<usize>, crate::config::unsigned_integer::Error> {
-            let value = value.map_err(|err| crate::config::unsigned_integer::Error::from(self).with_source(err))?;
-            value
+        /// Convert `value` into a `usize`, attaching key metadata on failure.
+        pub fn try_into_usize(&'static self, value: ExnMessageResult<Option<i64>>) -> Result<Option<usize>> {
+            let value = value.or_raise(|| key::error(self, "Could not parse an unsigned integer"))?;
+            Ok(value
                 .map(|value| {
-                    value
-                        .try_into()
-                        .map_err(|_| crate::config::unsigned_integer::Error::from(self))
+                    usize::try_from(value)
+                        .or_raise(|| key::error_with_value(self, "Could not parse an unsigned integer", value))
                 })
-                .transpose()
+                .transpose()?)
         }
 
-        /// Convert `value` into a `u64` or wrap it into a specialized error.
-        pub fn try_into_u64(
-            &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<u64>, crate::config::unsigned_integer::Error> {
-            let value = value.map_err(|err| crate::config::unsigned_integer::Error::from(self).with_source(err))?;
-            value
+        /// Convert `value` into a `u64`, attaching key metadata on failure.
+        pub fn try_into_u64(&'static self, value: ExnMessageResult<Option<i64>>) -> Result<Option<u64>> {
+            let value = value.or_raise(|| key::error(self, "Could not parse an unsigned integer"))?;
+            Ok(value
                 .map(|value| {
-                    value
-                        .try_into()
-                        .map_err(|_| crate::config::unsigned_integer::Error::from(self))
+                    u64::try_from(value)
+                        .or_raise(|| key::error_with_value(self, "Could not parse an unsigned integer", value))
                 })
-                .transpose()
+                .transpose()?)
         }
 
-        /// Convert `value` into a `u32` or wrap it into a specialized error.
-        pub fn try_into_u32(
-            &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<u32>, crate::config::unsigned_integer::Error> {
-            let value = value.map_err(|err| crate::config::unsigned_integer::Error::from(self).with_source(err))?;
-            value
+        /// Convert `value` into a `u32`, attaching key metadata on failure.
+        pub fn try_into_u32(&'static self, value: ExnMessageResult<Option<i64>>) -> Result<Option<u32>> {
+            let value = value.or_raise(|| key::error(self, "Could not parse an unsigned integer"))?;
+            Ok(value
                 .map(|value| {
-                    value
-                        .try_into()
-                        .map_err(|_| crate::config::unsigned_integer::Error::from(self))
+                    u32::try_from(value)
+                        .or_raise(|| key::error_with_value(self, "Could not parse an unsigned integer", value))
                 })
-                .transpose()
+                .transpose()?)
         }
     }
 }
 
 mod time {
     use crate::{
+        ExnMessageResult,
         bstr::ByteSlice,
+        config::key,
         config::tree::{
             Section,
             keys::{Time, validate},
         },
     };
-    use gix_error::Exn;
+    use gix_error::ResultExt;
 
     impl Time {
         /// Create a new instance.
@@ -486,26 +492,31 @@ mod time {
         }
 
         /// Convert the `value` into a date if possible, with `now` as reference time for relative dates.
+        /// Failures include the [key metadata](crate::config::tree::Key::validate) and the value bytes as `input`.
+        /// Date parsing failures retain the cause documented by [`gix_date::parse()`].
         pub fn try_into_time(
             &self,
             value: impl gix_utils::AsBStr,
             now: Option<gix_date::Zoned>,
-        ) -> Result<gix_date::Time, Exn<gix_date::Error>> {
+        ) -> ExnMessageResult<gix_date::Time> {
             let value = value.as_bstr();
             gix_date::parse(
                 value
                     .as_bstr()
                     .to_str()
-                    .map_err(|_| gix_date::Error::new_with_input("UTF8 conversion failed", value))?,
+                    .or_raise(|| key::error_with_value(self, "Could not decode date as UTF-8", value))?,
                 now,
             )
+            .or_raise(|| key::error_with_value(self, "Could not parse date", value))
         }
     }
 }
 
 mod boolean {
+    use gix_error::ResultExt;
+
     use crate::{
-        config,
+        ExnMessageResult, Result, config,
         config::tree::{
             Section,
             keys::{Boolean, validate},
@@ -521,17 +532,17 @@ mod boolean {
         /// Process the `value` into a result with an improved error message.
         ///
         /// `value` is expected to be provided by [`gix_config::File::boolean()`].
-        pub fn enrich_error(
-            &'static self,
-            value: Result<Option<bool>, gix_config::value::Error>,
-        ) -> Result<Option<bool>, config::boolean::Error> {
-            value.map_err(|err| config::boolean::Error::from(self).with_source(err))
+        pub fn enrich_error(&'static self, value: ExnMessageResult<Option<bool>>) -> Result<Option<bool>> {
+            Ok(value.or_raise(|| config::key::error(self, "Invalid boolean"))?)
         }
     }
 }
 
 mod remote_name {
+    use gix_error::ResultExt;
+
     use crate::{
+        Result,
         bstr::BString,
         config,
         config::tree::{Section, keys::RemoteName},
@@ -544,12 +555,10 @@ mod remote_name {
         }
 
         /// Try to validate `name` as symbolic remote name and return it.
-        pub fn try_into_symbolic_name(
-            &'static self,
-            name: impl gix_utils::AsBStr,
-        ) -> Result<BString, config::remote::symbolic_name::Error> {
-            crate::remote::name::validated(name.as_bstr().to_owned())
-                .map_err(|err| config::remote::symbolic_name::Error::from(self).with_source(err))
+        pub fn try_into_symbolic_name(&'static self, name: impl gix_utils::AsBStr) -> Result<BString> {
+            let name = name.as_bstr();
+            Ok(crate::remote::name::validated(name.to_owned())
+                .or_raise(|| config::key::error_with_value(self, "Invalid remote name", name))?)
         }
     }
 }
@@ -557,14 +566,18 @@ mod remote_name {
 /// Provide a way to validate a value, or decode a value from `git-config`.
 pub trait Validate {
     /// Validate `value` or return an error.
-    fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>>;
+    /// Errors with input context include invalid value bytes as `input` [metadata](gix_error::Exn::metadata()).
+    fn validate(&self, value: &BStr) -> ExnResult;
 }
 
 /// various implementations of the `Validate` trait.
 pub mod validate {
-    use std::{borrow::Cow, error::Error};
+    use std::borrow::Cow;
+
+    use gix_error::{ErrorExt, ResultExt, message};
 
     use crate::{
+        ExnResult,
         bstr::{BStr, ByteSlice},
         config::tree::keys::Validate,
         remote,
@@ -575,7 +588,7 @@ pub mod validate {
     pub struct All;
 
     impl Validate for All {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             Ok(())
         }
     }
@@ -585,8 +598,8 @@ pub mod validate {
     pub struct Time;
 
     impl Validate for Time {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            gix_date::parse(value.to_str()?, gix_date::Zoned::now().into()).map_err(gix_error::Exn::into_inner)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            gix_date::parse(value.to_str().or_erased()?, gix_date::Zoned::now().into()).or_erased()?;
             Ok(())
         }
     }
@@ -596,13 +609,14 @@ pub mod validate {
     pub struct UnsignedInteger;
 
     impl Validate for UnsignedInteger {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             usize::try_from(
-                gix_config::Integer::try_from(value)?
+                gix_config::Integer::try_from(value)
+                    .or_erased()?
                     .to_decimal()
-                    .ok_or_else(|| format!("integer {value} cannot be represented as `usize`"))?,
+                    .ok_or_else(|| message!("integer {value} cannot be represented as `usize`").raise_erased())?,
             )
-            .map_err(|_| "cannot use sign for unsigned integer")?;
+            .or_raise_erased(|| gix_error::validation("unsigned integer is out of range").with("input", value))?;
             Ok(())
         }
     }
@@ -612,8 +626,8 @@ pub mod validate {
     pub struct Boolean;
 
     impl Validate for Boolean {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            gix_config::Boolean::try_from(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            gix_config::Boolean::try_from(value).or_erased()?;
             Ok(())
         }
     }
@@ -637,9 +651,9 @@ pub mod validate {
     }
 
     impl Validate for FullNameRef {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             if !self.allow_empty || !value.is_empty() {
-                gix_ref::FullName::try_from(value.to_owned())?;
+                gix_ref::FullName::try_from(value.to_owned()).or_erased()?;
             }
             Ok(())
         }
@@ -649,9 +663,12 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct RemoteName;
     impl Validate for RemoteName {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            remote::Name::try_from(Cow::Borrowed(value))
-                .map_err(|_| format!("Illformed UTF-8 in remote name: \"{}\"", value.to_str_lossy()))?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            remote::Name::try_from(Cow::Borrowed(value)).map_err(|invalid| {
+                gix_error::validation("Illformed UTF-8 in remote name")
+                    .with("input", invalid.into_owned())
+                    .raise_erased()
+            })?;
             Ok(())
         }
     }
@@ -660,7 +677,7 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct Program;
     impl Validate for Program {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             Ok(())
         }
     }
@@ -669,7 +686,7 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct Executable;
     impl Validate for Executable {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             Ok(())
         }
     }
@@ -678,8 +695,8 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct Url;
     impl Validate for Url {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            gix_url::parse(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            gix_url::parse(value).or_erased()?;
             Ok(())
         }
     }
@@ -688,8 +705,8 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct PushRefSpec;
     impl Validate for PushRefSpec {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            gix_refspec::parse(value, gix_refspec::parse::Operation::Push)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            gix_refspec::parse(value, gix_refspec::parse::Operation::Push).or_erased()?;
             Ok(())
         }
     }
@@ -698,8 +715,8 @@ pub mod validate {
     #[derive(Default, Clone, Copy)]
     pub struct FetchRefSpec;
     impl Validate for FetchRefSpec {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            gix_refspec::parse(value, gix_refspec::parse::Operation::Fetch)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            gix_refspec::parse(value, gix_refspec::parse::Operation::Fetch).or_erased()?;
             Ok(())
         }
     }
@@ -708,11 +725,14 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct LockTimeout;
     impl Validate for LockTimeout {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            let value = gix_config::Integer::try_from(value)?
+        fn validate(&self, value: &BStr) -> ExnResult {
+            let value = gix_config::Integer::try_from(value)
+                .or_erased()?
                 .to_decimal()
-                .ok_or_else(|| format!("integer {value} cannot be represented as integer"));
-            super::super::Core::FILES_REF_LOCK_TIMEOUT.try_into_lock_timeout(Ok(Some(value?)))?;
+                .ok_or_else(|| message!("integer {value} cannot be represented as integer").raise_erased())?;
+            super::super::Core::FILES_REF_LOCK_TIMEOUT
+                .try_into_lock_timeout(Ok(Some(value)))
+                .or_erased()?;
             Ok(())
         }
     }
@@ -721,11 +741,14 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct Compression;
     impl Validate for Compression {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            let value = gix_config::Integer::try_from(value)?
+        fn validate(&self, value: &BStr) -> ExnResult {
+            let value = gix_config::Integer::try_from(value)
+                .or_erased()?
                 .to_decimal()
-                .ok_or_else(|| format!("integer {value} cannot be represented as integer"));
-            super::super::Core::COMPRESSION.try_into_compression(Ok(Some(value?)))?;
+                .ok_or_else(|| message!("integer {value} cannot be represented as integer").raise_erased())?;
+            super::super::Core::COMPRESSION
+                .try_into_compression(Ok(Some(value)))
+                .or_erased()?;
             Ok(())
         }
     }
@@ -734,11 +757,14 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct DurationInMilliseconds;
     impl Validate for DurationInMilliseconds {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            let value = gix_config::Integer::try_from(value)?
+        fn validate(&self, value: &BStr) -> ExnResult {
+            let value = gix_config::Integer::try_from(value)
+                .or_erased()?
                 .to_decimal()
-                .ok_or_else(|| format!("integer {value} cannot be represented as integer"));
-            super::super::gitoxide::Http::CONNECT_TIMEOUT.try_into_duration(Ok(Some(value?)))?;
+                .ok_or_else(|| message!("integer {value} cannot be represented as integer").raise_erased())?;
+            super::super::gitoxide::Http::CONNECT_TIMEOUT
+                .try_into_duration(Ok(Some(value)))
+                .or_erased()?;
             Ok(())
         }
     }
@@ -747,8 +773,8 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct String;
     impl Validate for String {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            value.to_str()?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            value.to_str().or_erased()?;
             Ok(())
         }
     }
@@ -757,7 +783,7 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct Path;
     impl Validate for Path {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/mod.rs b/gix/src/config/tree/mod.rs
index 7472d2388c9..642812a5e6c 100644
--- a/gix/src/config/tree/mod.rs
+++ b/gix/src/config/tree/mod.rs
@@ -127,31 +127,5 @@ pub use sections::{Status, status};
 /// Generic value implementations for static instantiation.
 pub mod keys;
 
-///
-pub mod key {
-    ///
-    pub mod validate {
-        /// The error returned by [`Key::validate()`][crate::config::tree::Key::validate()].
-        #[derive(Debug, thiserror::Error)]
-        #[error(transparent)]
-        pub struct Error {
-            #[from]
-            source: Box<dyn std::error::Error + Send + Sync + 'static>,
-        }
-    }
-    ///
-    pub mod validate_assignment {
-        /// The error returned by [`Key::validated_assignment`*()][crate::config::tree::Key::validated_assignment_fmt()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Failed to validate the value to be assigned to this key")]
-            Validate(#[from] super::validate::Error),
-            #[error("{message}")]
-            Name { message: String },
-        }
-    }
-}
-
 mod traits;
 pub use traits::{Key, Link, Note, Section, SubSectionRequirement};
diff --git a/gix/src/config/tree/sections/checkout.rs b/gix/src/config/tree/sections/checkout.rs
index b3490e37674..fae64cca39b 100644
--- a/gix/src/config/tree/sections/checkout.rs
+++ b/gix/src/config/tree/sections/checkout.rs
@@ -23,20 +23,18 @@ impl Section for Checkout {
 }
 
 mod workers {
-    use crate::config::tree::checkout::Workers;
+    use gix_error::ResultExt;
+
+    use crate::{ExnMessageResult, Result, config::tree::checkout::Workers};
 
     impl Workers {
         /// Return the amount of threads to use for checkout, with `0` meaning all available ones, after decoding our integer value from `config`,
         /// or `None` if the value isn't set which is typically interpreted as "as many threads as available"
-        pub fn try_from_workers(
-            &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<usize>, crate::config::checkout::workers::Error> {
-            match value {
-                Ok(Some(v)) if v < 0 => Ok(Some(0)),
-                Ok(Some(v)) => Ok(Some(v.try_into().expect("positive i64 can always be usize on 64 bit"))),
-                Ok(None) => Ok(None),
-                Err(err) => Err(crate::config::key::Error::from(&super::Checkout::WORKERS).with_source(err)),
+        pub fn try_from_workers(&'static self, value: ExnMessageResult<Option<i64>>) -> Result<Option<usize>> {
+            match value.or_raise(|| crate::config::key::error(self, "Could not decode checkout workers"))? {
+                Some(v) if v < 0 => Ok(Some(0)),
+                Some(v) => Ok(Some(v.try_into().expect("positive i64 can always be usize on 64 bit"))),
+                None => Ok(None),
             }
         }
     }
@@ -44,19 +42,25 @@ mod workers {
 
 ///
 pub mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::{ErrorExt, ResultExt};
 
     pub struct Workers;
     impl keys::Validate for Workers {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Checkout::WORKERS.try_from_workers(
-                gix_config::Integer::try_from(value)
-                    .and_then(|i| {
-                        i.to_decimal()
-                            .ok_or_else(|| gix_config::value::Error::new("Integer overflow", value.to_owned()))
-                    })
-                    .map(Some),
-            )?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Checkout::WORKERS
+                .try_from_workers(
+                    gix_config::Integer::try_from(value)
+                        .and_then(|i| {
+                            i.to_decimal().ok_or_else(|| {
+                                gix_error::validation("Integer overflow")
+                                    .with("input", value.to_owned())
+                                    .raise()
+                            })
+                        })
+                        .map(Some),
+                )
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/core.rs b/gix/src/config/tree/sections/core.rs
index f3f72107f4a..92789e1007b 100644
--- a/gix/src/config/tree/sections/core.rs
+++ b/gix/src/config/tree/sections/core.rs
@@ -202,8 +202,8 @@ mod filter {
 
     mod check_round_trip_encoding {
         use crate::{
+            Error, Result,
             bstr::ByteSlice,
-            config,
             config::tree::{Key, core::CheckRoundTripEncoding},
         };
 
@@ -213,7 +213,7 @@ mod filter {
             pub fn try_into_encodings(
                 &'static self,
                 value: Option<impl gix_utils::AsBStr>,
-            ) -> Result<Vec<&'static gix_filter::encoding::Encoding>, config::encoding::Error> {
+            ) -> Result<Vec<&'static gix_filter::encoding::Encoding>> {
                 Ok(match value {
                     None => vec![gix_filter::encoding::SHIFT_JIS],
                     Some(value) => {
@@ -226,11 +226,11 @@ mod filter {
                         {
                             out.push(
                                 gix_filter::encoding::Encoding::for_label(encoding.trim()).ok_or_else(|| {
-                                    config::encoding::Error {
-                                        key: self.logical_name().into(),
-                                        value: value.into(),
-                                        encoding: encoding.into(),
-                                    }
+                                    Error::from_error(gix_error::validation(format!(
+                                        "The encoding named '{}' seen in key '{}={value}' is unsupported",
+                                        encoding.as_bstr(),
+                                        self.logical_name()
+                                    )))
                                 })?,
                             );
                         }
@@ -242,7 +242,7 @@ mod filter {
     }
 
     mod eol {
-        use crate::{bstr::ByteSlice, config, config::tree::core::Eol};
+        use crate::{Error, Result, bstr::ByteSlice, config, config::tree::core::Eol};
 
         impl Eol {
             /// Convert `value` into the default end-of-line mode.
@@ -250,39 +250,39 @@ mod filter {
             /// ### Deviation
             ///
             /// git will allow any value and silently leaves it unset, we will fail if the value is not known.
-            pub fn try_into_eol(
-                &'static self,
-                value: impl gix_utils::AsBStr,
-            ) -> Result<gix_filter::eol::Mode, config::key::GenericErrorWithValue> {
+            pub fn try_into_eol(&'static self, value: impl gix_utils::AsBStr) -> Result<gix_filter::eol::Mode> {
                 let value = value.as_bstr();
                 Ok(match value.as_bstr().to_str_lossy().as_ref() {
                     "lf" => gix_filter::eol::Mode::Lf,
                     "crlf" => gix_filter::eol::Mode::CrLf,
                     "native" => gix_filter::eol::Mode::default(),
-                    _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                    _ => {
+                        return Err(Error::from_error(config::key::error_with_value(
+                            self,
+                            "Invalid configuration value",
+                            value,
+                        )));
+                    }
                 })
             }
         }
     }
 
     mod safecrlf {
+        use gix_error::ResultExt;
         use gix_filter::pipeline::CrlfRoundTripCheck;
 
-        use crate::{bstr::ByteSlice, config, config::tree::core::SafeCrlf};
+        use crate::{Result, bstr::ByteSlice, config, config::tree::core::SafeCrlf};
 
         impl SafeCrlf {
             /// Convert `value` into the safe-crlf enumeration, if possible.
-            pub fn try_into_safecrlf(
-                &'static self,
-                value: impl gix_utils::AsBStr,
-            ) -> Result<CrlfRoundTripCheck, config::key::GenericErrorWithValue> {
+            pub fn try_into_safecrlf(&'static self, value: impl gix_utils::AsBStr) -> Result<CrlfRoundTripCheck> {
                 let value = value.as_bstr();
                 if value.as_bstr() == "warn" {
                     return Ok(CrlfRoundTripCheck::Warn);
                 }
-                let value = gix_config::Boolean::try_from(value.as_bstr()).map_err(|err| {
-                    config::key::GenericErrorWithValue::from_value(self, value.into()).with_source(err)
-                })?;
+                let value = gix_config::Boolean::try_from(value.as_bstr())
+                    .or_raise(|| config::key::error_with_value(self, "Invalid configuration value", value))?;
                 Ok(if value.into() {
                     CrlfRoundTripCheck::Fail
                 } else {
@@ -293,23 +293,20 @@ mod filter {
     }
 
     mod autocrlf {
+        use gix_error::ResultExt;
         use gix_filter::eol;
 
-        use crate::{bstr::ByteSlice, config, config::tree::core::AutoCrlf};
+        use crate::{Result, bstr::ByteSlice, config, config::tree::core::AutoCrlf};
 
         impl AutoCrlf {
             /// Convert `value` into the safe-crlf enumeration, if possible.
-            pub fn try_into_autocrlf(
-                &'static self,
-                value: impl gix_utils::AsBStr,
-            ) -> Result<eol::AutoCrlf, config::key::GenericErrorWithValue> {
+            pub fn try_into_autocrlf(&'static self, value: impl gix_utils::AsBStr) -> Result<eol::AutoCrlf> {
                 let value = value.as_bstr();
                 if value.as_bstr() == "input" {
                     return Ok(eol::AutoCrlf::Input);
                 }
-                let value = gix_config::Boolean::try_from(value.as_bstr()).map_err(|err| {
-                    config::key::GenericErrorWithValue::from_value(self, value.into()).with_source(err)
-                })?;
+                let value = gix_config::Boolean::try_from(value.as_bstr())
+                    .or_raise(|| config::key::error_with_value(self, "Invalid configuration value", value))?;
                 Ok(if value.into() {
                     eol::AutoCrlf::Enabled
                 } else {
@@ -323,7 +320,9 @@ mod filter {
 pub use filter::*;
 
 mod shared_repository {
-    use crate::{bstr::ByteSlice, config, config::tree::core::SharedRepository};
+    use gix_error::ResultExt;
+
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::core::SharedRepository};
 
     impl SharedRepository {
         /// Parse `value` as Git's `core.sharedRepository` permission policy.
@@ -331,10 +330,7 @@ mod shared_repository {
         /// `None` represents a bare key (without value) and is treated as boolean `true`, equivalent to `group`. The result uses Git's
         /// compact encoding: `0` leaves permissions to the process umask, a positive mode ORs in permission bits after the
         /// umask, and a negative mode replaces the permission bits.
-        pub fn try_into_shared_repository(
-            &'static self,
-            value: Option<impl gix_utils::AsBStr>,
-        ) -> Result<i32, config::key::GenericErrorWithValue> {
+        pub fn try_into_shared_repository(&'static self, value: Option<impl gix_utils::AsBStr>) -> Result<i32> {
             let Some(value) = value else { return Ok(0o660) };
             let value = value.as_bstr();
             match value.as_bytes() {
@@ -350,27 +346,33 @@ mod shared_repository {
                     1 => Ok(0o660),
                     2 => Ok(0o664),
                     mode if mode & 0o600 == 0o600 => Ok(-((mode & 0o666) as i32)),
-                    _ => Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                    _ => Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    ))),
                 };
             }
 
-            gix_config::Boolean::try_from(value)
+            Ok(gix_config::Boolean::try_from(value)
                 .map(|value| if value.0 { 0o660 } else { 0 })
-                .map_err(|err| config::key::GenericErrorWithValue::from_value(self, value.into()).with_source(err))
+                .or_raise(|| config::key::error_with_value(self, "Invalid configuration value", value))?)
         }
     }
 }
 
 #[cfg(feature = "revision")]
 mod disambiguate {
-    use crate::{bstr::ByteSlice, config, config::tree::core::Disambiguate, revision::spec::parse::ObjectKindHint};
+    use crate::{
+        Error, Result, bstr::ByteSlice, config, config::tree::core::Disambiguate, revision::spec::parse::ObjectKindHint,
+    };
 
     impl Disambiguate {
         /// Convert a disambiguation marker into the respective enum.
         pub fn try_into_object_kind_hint(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<Option<ObjectKindHint>, config::key::GenericErrorWithValue> {
+        ) -> Result<Option<ObjectKindHint>> {
             let value = value.as_bstr();
             let hint = match value.as_bstr().as_bytes() {
                 b"none" => return Ok(None),
@@ -379,7 +381,13 @@ mod disambiguate {
                 b"tree" => ObjectKindHint::Tree,
                 b"treeish" => ObjectKindHint::Treeish,
                 b"blob" => ObjectKindHint::Blob,
-                _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
+                }
             };
             Ok(Some(hint))
         }
@@ -387,7 +395,7 @@ mod disambiguate {
 }
 
 mod log_all_ref_updates {
-    use crate::{config, config::tree::core::LogAllRefUpdates};
+    use crate::{ExnMessageResult, Result, bstr::ByteSlice, config, config::tree::core::LogAllRefUpdates};
 
     impl LogAllRefUpdates {
         /// Returns the mode for ref-updates as parsed from `value`. If `value` is not a boolean, we try
@@ -395,18 +403,26 @@ mod log_all_ref_updates {
         /// the interpretation of booleans in special in `git-config`, i.e. we can't just treat it as string.
         pub fn try_into_ref_updates(
             &'static self,
-            value: Result<Option<bool>, gix_config::value::Error>,
-        ) -> Result<Option<gix_ref::store::WriteReflog>, config::key::GenericErrorWithValue> {
+            value: ExnMessageResult<Option<bool>>,
+        ) -> Result<Option<gix_ref::store::WriteReflog>> {
             match value {
                 Ok(Some(bool)) => Ok(Some(if bool {
                     gix_ref::store::WriteReflog::Normal
                 } else {
                     gix_ref::store::WriteReflog::Disable
                 })),
-                Err(err) => match err.input {
-                    val if val.eq_ignore_ascii_case(b"always") => Ok(Some(gix_ref::store::WriteReflog::Always)),
-                    val => Err(config::key::GenericErrorWithValue::from_value(self, val)),
-                },
+                Err(err) => {
+                    let Some(gix_error::MetadataValue::Bytes(value)) = err.error().values.get("input") else {
+                        return Err(err.into());
+                    };
+                    if value.eq_ignore_ascii_case(b"always") {
+                        Ok(Some(gix_ref::store::WriteReflog::Always))
+                    } else {
+                        let context =
+                            config::key::error_with_value(self, "Invalid configuration value", value.as_bstr());
+                        Err(err.raise(context).into())
+                    }
+                }
                 Ok(None) => Ok(None),
             }
         }
@@ -414,20 +430,21 @@ mod log_all_ref_updates {
 }
 
 mod check_stat {
-    use crate::{bstr::ByteSlice, config, config::tree::core::CheckStat};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::core::CheckStat};
 
     impl CheckStat {
         /// Returns true if the full set of stat entries should be checked, and it's just as lenient as git.
-        pub fn try_into_checkstat(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<bool, config::key::GenericErrorWithValue> {
+        pub fn try_into_checkstat(&'static self, value: impl gix_utils::AsBStr) -> Result<bool> {
             let value = value.as_bstr();
             Ok(match value.as_bstr().as_bytes() {
                 b"minimal" => false,
                 b"default" => true,
                 _ => {
-                    return Err(config::key::GenericErrorWithValue::from_value(self, value.into()));
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
                 }
             })
         }
@@ -435,9 +452,9 @@ mod check_stat {
 }
 
 mod abbrev {
-    use config::abbrev::Error;
+    use gix_error::ResultExt;
 
-    use crate::{bstr::ByteSlice, config, config::tree::core::Abbrev};
+    use crate::{Error, Result, bstr::ByteSlice, config::tree::core::Abbrev};
 
     impl Abbrev {
         /// Convert the given `hex_len_str` into the amount of characters that a short hash should have.
@@ -446,14 +463,16 @@ mod abbrev {
             &'static self,
             hex_len_str: impl gix_utils::AsBStr,
             object_hash: gix_hash::Kind,
-        ) -> Result<Option<usize>, Error> {
+        ) -> Result<Option<usize>> {
             let hex_len_str = hex_len_str.as_bstr();
             let max = object_hash.len_in_hex() as u8;
+            let invalid = || {
+                Error::from_error(gix_error::validation(format!(
+                    "Invalid value for 'core.abbrev' = '{hex_len_str}'. It must be between 4 and {max}"
+                )))
+            };
             if hex_len_str.trim().is_empty() {
-                return Err(Error {
-                    value: hex_len_str.into(),
-                    max,
-                });
+                return Err(invalid());
             }
             if hex_len_str.trim().eq_ignore_ascii_case(b"auto") {
                 Ok(None)
@@ -463,20 +482,11 @@ mod abbrev {
                     Ok(object_hash.len_in_hex().into())
                 } else {
                     let value = gix_config::Integer::try_from(value_bytes)
-                        .map_err(|_| Error {
-                            value: hex_len_str.into(),
-                            max,
-                        })?
+                        .or_raise(invalid)?
                         .to_decimal()
-                        .ok_or_else(|| Error {
-                            value: hex_len_str.into(),
-                            max,
-                        })?;
+                        .ok_or_else(&invalid)?;
                     if value < 4 || value as usize > object_hash.len_in_hex() {
-                        return Err(Error {
-                            value: hex_len_str.into(),
-                            max,
-                        });
+                        return Err(invalid());
                     }
                     Ok(Some(value as usize))
                 }
@@ -486,15 +496,17 @@ mod abbrev {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::ResultExt;
 
     #[derive(Clone, Copy)]
     pub struct Disambiguate;
     impl keys::Validate for Disambiguate {
-        #[cfg_attr(not(feature = "revision"), allow(unused_variables))]
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(feature = "revision")]
-            super::Core::DISAMBIGUATE.try_into_object_kind_hint(value)?;
+            super::Core::DISAMBIGUATE
+                .try_into_object_kind_hint(_value)
+                .or_erased()?;
             Ok(())
         }
     }
@@ -502,9 +514,10 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct LogAllRefUpdates;
     impl keys::Validate for LogAllRefUpdates {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             super::Core::LOG_ALL_REF_UPDATES
-                .try_into_ref_updates(gix_config::Boolean::try_from(value).map(|b| Some(b.0)))?;
+                .try_into_ref_updates(gix_config::Boolean::try_from(value).map(|b| Some(b.0)))
+                .or_erased()?;
             Ok(())
         }
     }
@@ -512,8 +525,8 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct CheckStat;
     impl keys::Validate for CheckStat {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::CHECK_STAT.try_into_checkstat(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::CHECK_STAT.try_into_checkstat(value).or_erased()?;
             Ok(())
         }
     }
@@ -521,12 +534,14 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct Abbrev;
     impl keys::Validate for Abbrev {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             // The keys::Validate trait API doesn't take a hash kind, and passing one through
             // would touch ~50 impl sites. The repo-aware check with the actual hash runs in
             // config::cache::util::parse_core_abbrev, so here we just use Kind::longest()
             // to allow the most permissive upper bound.
-            super::Core::ABBREV.try_into_abbreviation(value, gix_hash::Kind::longest())?;
+            super::Core::ABBREV
+                .try_into_abbreviation(value, gix_hash::Kind::longest())
+                .or_erased()?;
             Ok(())
         }
     }
@@ -534,8 +549,10 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct SharedRepository;
     impl keys::Validate for SharedRepository {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::SHARED_REPOSITORY.try_into_shared_repository(Some(value))?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::SHARED_REPOSITORY
+                .try_into_shared_repository(Some(value))
+                .or_erased()?;
             Ok(())
         }
     }
@@ -545,8 +562,8 @@ mod validate {
     pub struct SafeCrlf;
     #[cfg(feature = "attributes")]
     impl keys::Validate for SafeCrlf {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::SAFE_CRLF.try_into_safecrlf(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::SAFE_CRLF.try_into_safecrlf(value).or_erased()?;
             Ok(())
         }
     }
@@ -556,8 +573,8 @@ mod validate {
     pub struct AutoCrlf;
     #[cfg(feature = "attributes")]
     impl keys::Validate for AutoCrlf {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::AUTO_CRLF.try_into_autocrlf(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::AUTO_CRLF.try_into_autocrlf(value).or_erased()?;
             Ok(())
         }
     }
@@ -567,8 +584,8 @@ mod validate {
     pub struct Eol;
     #[cfg(feature = "attributes")]
     impl keys::Validate for Eol {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::EOL.try_into_eol(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::EOL.try_into_eol(value).or_erased()?;
             Ok(())
         }
     }
@@ -578,8 +595,10 @@ mod validate {
     pub struct CheckRoundTripEncoding;
     #[cfg(feature = "attributes")]
     impl keys::Validate for CheckRoundTripEncoding {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Core::CHECK_ROUND_TRIP_ENCODING.try_into_encodings(Some(value))?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::CHECK_ROUND_TRIP_ENCODING
+                .try_into_encodings(Some(value))
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/diff.rs b/gix/src/config/tree/sections/diff.rs
index d4a4c9802e5..8b1587d9308 100644
--- a/gix/src/config/tree/sections/diff.rs
+++ b/gix/src/config/tree/sections/diff.rs
@@ -81,24 +81,26 @@ pub type Binary = keys::Any<validate::Binary>;
 
 mod algorithm {
     use crate::{
+        Error, Result,
         bstr::ByteSlice,
         config,
         config::{
             diff::algorithm,
-            key,
             tree::sections::diff::{Algorithm, Ignore},
         },
     };
 
     impl Ignore {
         /// See if `value` is an actual ignore
-        pub fn try_into_ignore(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<gix_submodule::config::Ignore, key::GenericErrorWithValue> {
+        pub fn try_into_ignore(&'static self, value: impl gix_utils::AsBStr) -> Result<gix_submodule::config::Ignore> {
             let value = value.as_bstr();
-            gix_submodule::config::Ignore::try_from(value.as_bstr())
-                .map_err(|()| key::GenericErrorWithValue::from_value(self, value.into()))
+            gix_submodule::config::Ignore::try_from(value.as_bstr()).map_err(|()| {
+                Error::from_error(config::key::error_with_value(
+                    self,
+                    "Invalid configuration value",
+                    value,
+                ))
+            })
         }
     }
 
@@ -107,7 +109,7 @@ mod algorithm {
         pub fn try_into_algorithm(
             &self,
             name: impl gix_utils::AsBStr,
-        ) -> Result<gix_diff::blob::Algorithm, algorithm::Error> {
+        ) -> std::result::Result<gix_diff::blob::Algorithm, algorithm::Error> {
             let name = name.as_bstr();
             let algo = if name.eq_ignore_ascii_case(b"myers") || name.eq_ignore_ascii_case(b"default") {
                 gix_diff::blob::Algorithm::Myers
@@ -126,16 +128,15 @@ mod algorithm {
 }
 
 mod binary {
-    use crate::{bstr::ByteSlice, config::tree::diff::Binary};
+    use gix_error::ResultExt;
+
+    use crate::{Result, bstr::ByteSlice, config::tree::diff::Binary};
 
     impl Binary {
         /// Convert `value` into a tri-state boolean that can take the special value `auto`, resulting in `None`, or is a boolean.
         /// If `None` is given, it's treated as implicit boolean `true`, as this method is made to be used
         /// with [`gix_config::file::section::BodyRef::value_implicit()`].
-        pub fn try_into_binary(
-            &'static self,
-            value: Option<impl gix_utils::AsBStr>,
-        ) -> Result<Option<bool>, crate::config::key::GenericErrorWithValue> {
+        pub fn try_into_binary(&'static self, value: Option<impl gix_utils::AsBStr>) -> Result<Option<bool>> {
             Ok(match value {
                 None => Some(true),
                 Some(value) => {
@@ -146,9 +147,8 @@ mod binary {
                         Some(
                             gix_config::Boolean::try_from(value.as_bstr())
                                 .map(|b| b.0)
-                                .map_err(|err| {
-                                    crate::config::key::GenericErrorWithValue::from_value(self, value.into())
-                                        .with_source(err)
+                                .or_raise(|| {
+                                    crate::config::key::error_with_value(self, "Invalid configuration value", value)
                                 })?,
                         )
                     }
@@ -160,9 +160,10 @@ mod binary {
 
 mod renames {
     use crate::{
+        ExnMessageResult, Result,
         bstr::ByteSlice,
         config::{
-            key::GenericError,
+            key,
             tree::{Section, keys, sections::diff::Renames},
         },
         diff::rename::Tracking,
@@ -175,19 +176,21 @@ mod renames {
         }
         /// Try to convert the configuration into a valid rename tracking variant. Use `value` and if it's an error, interpret
         /// the boolean as string
-        pub fn try_into_renames(
-            &'static self,
-            value: Result<Option<bool>, gix_config::value::Error>,
-        ) -> Result<Option<Tracking>, GenericError> {
+        pub fn try_into_renames(&'static self, value: ExnMessageResult<Option<bool>>) -> Result<Option<Tracking>> {
             Ok(match value {
                 Ok(Some(true)) => Some(Tracking::Renames),
                 Ok(Some(false)) => Some(Tracking::Disabled),
                 Ok(None) => None,
                 Err(err) => {
-                    let value = &err.input;
+                    let Some(gix_error::MetadataValue::Bytes(value)) = err.error().values.get("input") else {
+                        return Err(err.into());
+                    };
                     match value.as_bytes() {
                         b"copy" | b"copies" => Some(Tracking::RenamesAndCopies),
-                        _ => return Err(GenericError::from_value(self, value.clone()).with_source(err)),
+                        _ => {
+                            let context = key::error_with_value(self, "Invalid configuration value", value.as_bstr());
+                            return Err(err.raise(context).into());
+                        }
                     }
                 }
             })
@@ -196,7 +199,10 @@ mod renames {
 }
 
 pub(super) mod validate {
+    use gix_error::{ErrorExt, ResultExt, message};
+
     use crate::{
+        ExnResult,
         bstr::BStr,
         config::tree::{Diff, keys},
     };
@@ -204,9 +210,9 @@ pub(super) mod validate {
     #[derive(Copy, Clone)]
     pub struct Ignore;
     impl keys::Validate for Ignore {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             gix_submodule::config::Ignore::try_from(value)
-                .map_err(|()| format!("Value '{value}' is not a valid submodule 'ignore' value"))?;
+                .map_err(|()| message!("Value '{value}' is not a valid submodule 'ignore' value").raise_erased())?;
             Ok(())
         }
     }
@@ -214,8 +220,8 @@ pub(super) mod validate {
     #[derive(Copy, Clone)]
     pub struct Algorithm;
     impl keys::Validate for Algorithm {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            Diff::ALGORITHM.try_into_algorithm(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            Diff::ALGORITHM.try_into_algorithm(value).or_erased()?;
             Ok(())
         }
     }
@@ -223,9 +229,9 @@ pub(super) mod validate {
     #[derive(Copy, Clone)]
     pub struct Renames;
     impl keys::Validate for Renames {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             let boolean = gix_config::Boolean::try_from(value).map(|b| Some(b.0));
-            Diff::RENAMES.try_into_renames(boolean)?;
+            Diff::RENAMES.try_into_renames(boolean).or_erased()?;
             Ok(())
         }
     }
@@ -233,8 +239,8 @@ pub(super) mod validate {
     #[derive(Copy, Clone)]
     pub struct Binary;
     impl keys::Validate for Binary {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            Diff::DRIVER_BINARY.try_into_binary(Some(value))?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            Diff::DRIVER_BINARY.try_into_binary(Some(value)).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/extensions.rs b/gix/src/config/tree/sections/extensions.rs
index f163fd3a3dd..2613139e49b 100644
--- a/gix/src/config/tree/sections/extensions.rs
+++ b/gix/src/config/tree/sections/extensions.rs
@@ -17,13 +17,10 @@ impl Extensions {
 pub type ObjectFormat = keys::Any<validate::ObjectFormat>;
 
 mod object_format {
-    use crate::{bstr::ByteSlice, config, config::tree::sections::extensions::ObjectFormat};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::sections::extensions::ObjectFormat};
 
     impl ObjectFormat {
-        pub fn try_into_object_format(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<gix_hash::Kind, config::key::GenericErrorWithValue> {
+        pub fn try_into_object_format(&'static self, value: impl gix_utils::AsBStr) -> Result<gix_hash::Kind> {
             let value = value.as_bstr();
             #[cfg(feature = "sha1")]
             if value.as_bstr().eq_ignore_ascii_case(b"sha1") {
@@ -35,7 +32,11 @@ mod object_format {
                 return Ok(gix_hash::Kind::Sha256);
             }
 
-            Err(config::key::GenericErrorWithValue::from_value(self, value.into()))
+            Err(Error::from_error(config::key::error_with_value(
+                self,
+                "Invalid configuration value",
+                value,
+            )))
         }
     }
 }
@@ -51,14 +52,17 @@ impl Section for Extensions {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::ResultExt;
 
     #[derive(Clone, Copy)]
     pub struct ObjectFormat;
 
     impl keys::Validate for ObjectFormat {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Extensions::OBJECT_FORMAT.try_into_object_format(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Extensions::OBJECT_FORMAT
+                .try_into_object_format(value)
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/fetch.rs b/gix/src/config/tree/sections/fetch.rs
index 72a492dbef1..cecdf2aa5eb 100644
--- a/gix/src/config/tree/sections/fetch.rs
+++ b/gix/src/config/tree/sections/fetch.rs
@@ -38,13 +38,17 @@ pub type NegotiationAlgorithm = keys::Any<validate::NegotiationAlgorithm>;
 pub type RecurseSubmodules = keys::Any<validate::RecurseSubmodules>;
 
 mod algorithm {
+    #[cfg(feature = "attributes")]
+    use crate::ExnMessageResult;
+    #[cfg(any(feature = "credentials", feature = "attributes"))]
+    use crate::{Error, Result};
     #[cfg(feature = "credentials")]
     impl crate::config::tree::sections::fetch::NegotiationAlgorithm {
         /// Derive the negotiation algorithm identified by `name`, case-sensitively.
         pub fn try_into_negotiation_algorithm(
             &'static self,
             name: impl gix_utils::AsBStr,
-        ) -> Result<crate::remote::fetch::negotiate::Algorithm, crate::config::key::GenericErrorWithValue> {
+        ) -> Result<crate::remote::fetch::negotiate::Algorithm> {
             use crate::{bstr::ByteSlice, remote::fetch::negotiate::Algorithm};
 
             let name = name.as_bstr();
@@ -53,7 +57,11 @@ mod algorithm {
                 b"consecutive" | b"default" => Algorithm::Consecutive,
                 b"skipping" => Algorithm::Skipping,
                 _ => {
-                    return Err(crate::config::key::GenericErrorWithValue::from_value(self, name.into()));
+                    return Err(Error::from_error(crate::config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        name,
+                    )));
                 }
             })
         }
@@ -64,24 +72,33 @@ mod algorithm {
         /// Obtain the way submodules should be updated.
         pub fn try_into_recurse_submodules(
             &'static self,
-            value: Result<Option<bool>, gix_config::value::Error>,
-        ) -> Result<Option<gix_submodule::config::FetchRecurse>, crate::config::key::GenericErrorWithValue> {
-            gix_submodule::config::FetchRecurse::new(value)
-                .map_err(|err| crate::config::key::GenericErrorWithValue::from_value(self, err))
+            value: ExnMessageResult<Option<bool>>,
+        ) -> Result<Option<gix_submodule::config::FetchRecurse>> {
+            gix_submodule::config::FetchRecurse::new(value).map_err(|input| {
+                Error::from_error(crate::config::key::error_with_value(
+                    self,
+                    "Invalid configuration value",
+                    input,
+                ))
+            })
         }
     }
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    #[cfg(any(feature = "credentials", feature = "attributes"))]
+    use gix_error::ResultExt;
 
     #[derive(Clone, Copy)]
     pub struct NegotiationAlgorithm;
     impl keys::Validate for NegotiationAlgorithm {
         #[cfg_attr(not(feature = "credentials"), allow(unused_variables))]
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             #[cfg(feature = "credentials")]
-            crate::config::tree::Fetch::NEGOTIATION_ALGORITHM.try_into_negotiation_algorithm(value)?;
+            crate::config::tree::Fetch::NEGOTIATION_ALGORITHM
+                .try_into_negotiation_algorithm(value)
+                .or_erased()?;
             Ok(())
         }
     }
@@ -91,10 +108,12 @@ mod validate {
     pub struct RecurseSubmodules;
     #[cfg(feature = "attributes")]
     impl keys::Validate for RecurseSubmodules {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             {
                 let boolean = gix_config::Boolean::try_from(value).map(|b| Some(b.0));
-                crate::config::tree::Fetch::RECURSE_SUBMODULES.try_into_recurse_submodules(boolean)?;
+                crate::config::tree::Fetch::RECURSE_SUBMODULES
+                    .try_into_recurse_submodules(boolean)
+                    .or_erased()?;
             }
             Ok(())
         }
diff --git a/gix/src/config/tree/sections/gitoxide.rs b/gix/src/config/tree/sections/gitoxide.rs
index 5138902e96d..02be62be05a 100644
--- a/gix/src/config/tree/sections/gitoxide.rs
+++ b/gix/src/config/tree/sections/gitoxide.rs
@@ -87,6 +87,7 @@ impl Section for Gitoxide {
 
 mod subsections {
     use crate::{
+        Result,
         bstr::ByteSlice,
         config::{
             Tree,
@@ -105,13 +106,12 @@ mod subsections {
 
     impl RefsNamespace {
         /// Derive the negotiation algorithm identified by `name`, case-sensitively.
-        pub fn try_into_refs_namespace(
-            &'static self,
-            name: impl gix_utils::AsBStr,
-        ) -> Result<gix_ref::Namespace, crate::config::refs_namespace::Error> {
+        pub fn try_into_refs_namespace(&'static self, name: impl gix_utils::AsBStr) -> Result<gix_ref::Namespace> {
+            use gix_error::ResultExt;
+
             let name = name.as_bstr();
-            gix_ref::namespace::expand(name.as_bstr())
-                .map_err(|err| crate::config::key::Error::from_value(self, name.into()).with_source(err))
+            Ok(gix_ref::namespace::expand(name.as_bstr())
+                .or_raise(|| crate::config::key::error_with_value(self, "Invalid reference namespace", name))?)
         }
     }
 
@@ -614,16 +614,15 @@ mod subsections {
 pub use subsections::{Allow, Author, Commit, Committer, Core, Credentials, Http, Https, Objects, Pathspec, Ssh, User};
 
 pub mod validate {
-    use gix_error::ValidationError;
-    use std::error::Error;
+    use gix_error::{ErrorExt, ResultExt};
 
-    use crate::{bstr::BStr, config::tree::keys::Validate};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys::Validate};
 
     #[derive(Clone, Copy)]
     pub struct RefsNamespace;
     impl Validate for RefsNamespace {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            super::Core::REFS_NAMESPACE.try_into_refs_namespace(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Core::REFS_NAMESPACE.try_into_refs_namespace(value).or_erased()?;
             Ok(())
         }
     }
@@ -631,9 +630,9 @@ pub mod validate {
     #[derive(Clone, Copy)]
     pub struct NonEmptyPath;
     impl Validate for NonEmptyPath {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             if value.is_empty() {
-                return Err(ValidationError::new("index file path must not be empty").into());
+                return Err(gix_error::validation("index file path must not be empty").raise_erased());
             }
             Ok(())
         }
diff --git a/gix/src/config/tree/sections/gpg.rs b/gix/src/config/tree/sections/gpg.rs
index f0895a5537f..746f5d8707b 100644
--- a/gix/src/config/tree/sections/gpg.rs
+++ b/gix/src/config/tree/sections/gpg.rs
@@ -2,6 +2,8 @@ use crate::config::{
     self,
     tree::{Key, Section, keys},
 };
+#[cfg(feature = "command")]
+use crate::{Error, Result};
 
 impl super::Gpg {
     /// The `gpg.format` key.
@@ -29,12 +31,17 @@ impl MinTrustLevel {
     pub fn try_into_trust_level(
         &'static self,
         value: impl gix_utils::AsBStr,
-    ) -> Result<gix_object::signature::verify::TrustLevel, config::key::GenericErrorWithValue> {
+    ) -> Result<gix_object::signature::verify::TrustLevel> {
         use crate::bstr::ByteSlice;
 
         let value = value.as_bstr();
-        gix_object::signature::verify::TrustLevel::from_bytes(value.trim())
-            .ok_or_else(|| config::key::GenericErrorWithValue::from_value(self, value.into()))
+        gix_object::signature::verify::TrustLevel::from_bytes(value.trim()).ok_or_else(|| {
+            Error::from_error(config::key::error_with_value(
+                self,
+                "Invalid signature trust level",
+                value,
+            ))
+        })
     }
 }
 
@@ -135,25 +142,30 @@ impl Section for Ssh {
 
 mod validate {
     use crate::{
+        ExnResult,
         bstr::BStr,
         config::tree::{Gpg, keys},
     };
+    #[cfg(not(feature = "command"))]
+    use gix_error::ErrorExt;
+    #[cfg(feature = "command")]
+    use gix_error::ResultExt;
 
     #[derive(Copy, Clone)]
     pub struct MinTrustLevel;
 
     impl keys::Validate for MinTrustLevel {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, value: &BStr) -> ExnResult {
             #[cfg(feature = "command")]
             {
-                Gpg::MIN_TRUST_LEVEL.try_into_trust_level(value)?;
+                Gpg::MIN_TRUST_LEVEL.try_into_trust_level(value).or_erased()?;
                 Ok(())
             }
             #[cfg(not(feature = "command"))]
             {
-                let err: crate::config::key::GenericErrorWithValue =
-                    crate::config::key::GenericErrorWithValue::from_value(&Gpg::MIN_TRUST_LEVEL, value.into());
-                Err(Box::new(err))
+                let err =
+                    crate::config::key::error_with_value(&Gpg::MIN_TRUST_LEVEL, "Invalid signature trust level", value);
+                Err(err.raise_erased())
             }
         }
     }
diff --git a/gix/src/config/tree/sections/http.rs b/gix/src/config/tree/sections/http.rs
index c57ba4cf2c5..a91ffab23b7 100644
--- a/gix/src/config/tree/sections/http.rs
+++ b/gix/src/config/tree/sections/http.rs
@@ -93,11 +93,24 @@ pub type ProxyAuthMethod = keys::Any<validate::ProxyAuthMethod>;
 pub type Version = keys::Any<validate::Version>;
 
 mod key_impls {
-    use crate::config::tree::{
-        Section,
-        http::{ProxyAuthMethod, SslVersion},
-        keys,
+    #[cfg(any(
+        feature = "blocking-http-transport-reqwest",
+        feature = "blocking-http-transport-curl"
+    ))]
+    use crate::Error;
+    use crate::{
+        Result,
+        config::tree::{
+            Section,
+            http::{ProxyAuthMethod, SslVersion},
+            keys,
+        },
     };
+    #[cfg(any(
+        feature = "blocking-http-transport-reqwest",
+        feature = "blocking-http-transport-curl"
+    ))]
+    use gix_error::{ExnResult, ResultExt};
 
     impl SslVersion {
         pub const fn new_ssl_version(name: &'static str, section: &'static dyn Section) -> Self {
@@ -124,18 +137,15 @@ mod key_impls {
         pub fn try_into_follow_redirects(
             &'static self,
             value: impl gix_utils::AsBStr,
-            boolean: impl FnOnce() -> Result<Option<bool>, gix_config::value::Error>,
-        ) -> Result<
-            crate::protocol::transport::client::blocking_io::http::options::FollowRedirects,
-            crate::config::key::GenericErrorWithValue,
-        > {
+            boolean: impl FnOnce() -> ExnResult<Option<bool>>,
+        ) -> Result<crate::protocol::transport::client::blocking_io::http::options::FollowRedirects> {
             use crate::{bstr::ByteSlice, protocol::transport::client::blocking_io::http::options::FollowRedirects};
             let value = value.as_bstr();
             Ok(if value.as_bstr().as_bytes() == b"initial" {
                 FollowRedirects::Initial
-            } else if let Some(value) = boolean().map_err(|err| {
-                crate::config::key::GenericErrorWithValue::from_value(self, value.into()).with_source(err)
-            })? {
+            } else if let Some(value) = boolean()
+                .or_raise(|| crate::config::key::error_with_value(self, "Invalid configuration value", value))?
+            {
                 if value {
                     FollowRedirects::All
                 } else {
@@ -149,10 +159,7 @@ mod key_impls {
 
     impl super::ExtraHeader {
         /// Convert a list of values into extra-headers, while failing entirely on illformed UTF-8.
-        pub fn try_into_extra_header(
-            &'static self,
-            values: Vec<impl gix_utils::AsBStr>,
-        ) -> Result<Vec<String>, crate::config::string::Error> {
+        pub fn try_into_extra_header(&'static self, values: Vec<impl gix_utils::AsBStr>) -> Result<Vec<String>> {
             let mut out = Vec::with_capacity(values.len());
             for value in values {
                 let value = value.as_bstr();
@@ -174,10 +181,7 @@ mod key_impls {
         pub fn try_into_http_version(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<
-            gix_protocol::transport::client::blocking_io::http::options::HttpVersion,
-            crate::config::key::GenericErrorWithValue,
-        > {
+        ) -> Result<gix_protocol::transport::client::blocking_io::http::options::HttpVersion> {
             use gix_protocol::transport::client::blocking_io::http::options::HttpVersion;
 
             use crate::bstr::ByteSlice;
@@ -186,10 +190,11 @@ mod key_impls {
                 b"HTTP/1.1" => HttpVersion::V1_1,
                 b"HTTP/2" => HttpVersion::V2,
                 _ => {
-                    return Err(crate::config::key::GenericErrorWithValue::from_value(
+                    return Err(Error::from_error(crate::config::key::error_with_value(
                         self,
-                        value.into(),
-                    ));
+                        "Invalid configuration value",
+                        value,
+                    )));
                 }
             })
         }
@@ -203,10 +208,7 @@ mod key_impls {
         pub fn try_into_proxy_auth_method(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<
-            gix_protocol::transport::client::blocking_io::http::options::ProxyAuthMethod,
-            crate::config::key::GenericErrorWithValue,
-        > {
+        ) -> Result<gix_protocol::transport::client::blocking_io::http::options::ProxyAuthMethod> {
             use gix_protocol::transport::client::blocking_io::http::options::ProxyAuthMethod;
 
             use crate::bstr::ByteSlice;
@@ -218,10 +220,11 @@ mod key_impls {
                 b"negotiate" => ProxyAuthMethod::Negotiate,
                 b"ntlm" => ProxyAuthMethod::Ntlm,
                 _ => {
-                    return Err(crate::config::key::GenericErrorWithValue::from_value(
+                    return Err(Error::from_error(crate::config::key::error_with_value(
                         self,
-                        value.into(),
-                    ));
+                        "Invalid configuration value",
+                        value,
+                    )));
                 }
             })
         }
@@ -235,10 +238,7 @@ mod key_impls {
         pub fn try_into_ssl_version(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<
-            gix_protocol::transport::client::blocking_io::http::options::SslVersion,
-            crate::config::ssl_version::Error,
-        > {
+        ) -> Result<gix_protocol::transport::client::blocking_io::http::options::SslVersion> {
             use gix_protocol::transport::client::blocking_io::http::options::SslVersion::*;
 
             use crate::bstr::ByteSlice;
@@ -252,28 +252,35 @@ mod key_impls {
                 b"tlsv1.1" => TlsV1_1,
                 b"tlsv1.2" => TlsV1_2,
                 b"tlsv1.3" => TlsV1_3,
-                _ => return Err(crate::config::ssl_version::Error::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(crate::config::key::error_with_value(
+                        self,
+                        "Invalid SSL version",
+                        value,
+                    )));
+                }
             })
         }
     }
 }
 
 pub mod validate {
-    use std::error::Error;
+    use gix_error::ResultExt;
 
     use crate::{
+        ExnResult,
         bstr::{BStr, ByteSlice},
         config::tree::keys::Validate,
     };
 
     pub struct SslVersion;
     impl Validate for SslVersion {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(any(
                 feature = "blocking-http-transport-reqwest",
                 feature = "blocking-http-transport-curl"
             ))]
-            super::Http::SSL_VERSION.try_into_ssl_version(_value)?;
+            super::Http::SSL_VERSION.try_into_ssl_version(_value).or_erased()?;
 
             Ok(())
         }
@@ -281,12 +288,14 @@ pub mod validate {
 
     pub struct ProxyAuthMethod;
     impl Validate for ProxyAuthMethod {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(any(
                 feature = "blocking-http-transport-reqwest",
                 feature = "blocking-http-transport-curl"
             ))]
-            super::Http::PROXY_AUTH_METHOD.try_into_proxy_auth_method(_value)?;
+            super::Http::PROXY_AUTH_METHOD
+                .try_into_proxy_auth_method(_value)
+                .or_erased()?;
 
             Ok(())
         }
@@ -294,12 +303,12 @@ pub mod validate {
 
     pub struct Version;
     impl Validate for Version {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(any(
                 feature = "blocking-http-transport-reqwest",
                 feature = "blocking-http-transport-curl"
             ))]
-            super::Http::VERSION.try_into_http_version(_value)?;
+            super::Http::VERSION.try_into_http_version(_value).or_erased()?;
 
             Ok(())
         }
@@ -307,21 +316,24 @@ pub mod validate {
 
     pub struct ExtraHeader;
     impl Validate for ExtraHeader {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            value.to_str()?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            value.to_str().or_erased()?;
             Ok(())
         }
     }
 
     pub struct FollowRedirects;
     impl Validate for FollowRedirects {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(any(
                 feature = "blocking-http-transport-reqwest",
                 feature = "blocking-http-transport-curl"
             ))]
             super::Http::FOLLOW_REDIRECTS
-                .try_into_follow_redirects(_value, || gix_config::Boolean::try_from(_value).map(|b| Some(b.0)))?;
+                .try_into_follow_redirects(_value, || {
+                    gix_config::Boolean::try_from(_value).map(|b| Some(b.0)).or_erased()
+                })
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/index.rs b/gix/src/config/tree/sections/index.rs
index c567b072451..42e832063c1 100644
--- a/gix/src/config/tree/sections/index.rs
+++ b/gix/src/config/tree/sections/index.rs
@@ -16,19 +16,12 @@ impl Index {
 pub type IndexThreads = keys::Any<validate::IndexThreads>;
 
 mod index_threads {
-    use crate::{
-        bstr::ByteSlice,
-        config,
-        config::{key::GenericErrorWithValue, tree::index::IndexThreads},
-    };
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::index::IndexThreads};
 
     impl IndexThreads {
         /// Parse `value` into the amount of threads to use, with `1` being single-threaded, or `0` indicating
         /// to select the amount of threads, with any other number being the specific amount of threads to use.
-        pub fn try_into_index_threads(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<usize, config::key::GenericErrorWithValue> {
+        pub fn try_into_index_threads(&'static self, value: impl gix_utils::AsBStr) -> Result<usize> {
             let value = value.as_bstr();
             gix_config::Integer::try_from(value.as_bstr())
                 .ok()
@@ -38,7 +31,13 @@ mod index_threads {
                         .ok()
                         .map(|b| if b.0 { 0 } else { 1 })
                 })
-                .ok_or_else(|| GenericErrorWithValue::from_value(self, value.into()))
+                .ok_or_else(|| {
+                    Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    ))
+                })
         }
     }
 }
@@ -54,13 +53,14 @@ impl Section for Index {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::ResultExt;
 
     #[derive(Clone, Copy)]
     pub struct IndexThreads;
     impl keys::Validate for IndexThreads {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Index::THREADS.try_into_index_threads(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Index::THREADS.try_into_index_threads(value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/merge.rs b/gix/src/config/tree/sections/merge.rs
index f93dc968969..9b8c2bd1763 100644
--- a/gix/src/config/tree/sections/merge.rs
+++ b/gix/src/config/tree/sections/merge.rs
@@ -66,14 +66,11 @@ pub type ConflictStyle = keys::Any<validate::ConflictStyle>;
 mod conflict_style {
     use gix_merge::blob::builtin_driver::text;
 
-    use crate::{bstr::ByteSlice, config, config::tree::sections::merge::ConflictStyle};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::sections::merge::ConflictStyle};
 
     impl ConflictStyle {
         /// Derive the diff algorithm identified by `name`, case-insensitively.
-        pub fn try_into_conflict_style(
-            &'static self,
-            name: impl gix_utils::AsBStr,
-        ) -> Result<text::ConflictStyle, config::key::GenericErrorWithValue> {
+        pub fn try_into_conflict_style(&'static self, name: impl gix_utils::AsBStr) -> Result<text::ConflictStyle> {
             let name = name.as_bstr();
             let style = if name.as_bstr() == "merge" {
                 text::ConflictStyle::Merge
@@ -82,7 +79,11 @@ mod conflict_style {
             } else if name.as_bstr() == "zdiff3" {
                 text::ConflictStyle::ZealousDiff3
             } else {
-                return Err(config::key::GenericErrorWithValue::from_value(self, name.into()));
+                return Err(Error::from_error(config::key::error_with_value(
+                    self,
+                    "Invalid configuration value",
+                    name,
+                )));
             };
             Ok(style)
         }
@@ -91,7 +92,10 @@ mod conflict_style {
 
 #[cfg(feature = "merge")]
 mod validate {
+    use gix_error::ResultExt;
+
     use crate::{
+        ExnResult,
         bstr::BStr,
         config::tree::{Merge, keys},
     };
@@ -99,8 +103,8 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct ConflictStyle;
     impl keys::Validate for ConflictStyle {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            Merge::CONFLICT_STYLE.try_into_conflict_style(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            Merge::CONFLICT_STYLE.try_into_conflict_style(value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/notes.rs b/gix/src/config/tree/sections/notes.rs
index 2847bd8d0d8..09787dffcba 100644
--- a/gix/src/config/tree/sections/notes.rs
+++ b/gix/src/config/tree/sections/notes.rs
@@ -1,4 +1,5 @@
 use crate::{
+    Error, Result,
     bstr::{BString, ByteSlice},
     config,
     config::tree::{Key, Notes, Section, keys},
@@ -28,10 +29,7 @@ impl DisplayRef {
     /// Parse and validate `value` as literal notes references or glob patterns.
     ///
     /// An item containing `*`, `?`, or `[` is a glob; all other items must be fully qualified references.
-    pub fn try_into_display_refs(
-        &'static self,
-        value: impl gix_utils::AsBStr,
-    ) -> Result<Vec<BString>, config::key::GenericErrorWithValue> {
+    pub fn try_into_display_refs(&'static self, value: impl gix_utils::AsBStr) -> Result<Vec<BString>> {
         let value = value.as_bstr();
         let refs = value
             .split(|byte| *byte == b':')
@@ -45,23 +43,27 @@ impl DisplayRef {
             pattern.has_wildcard() || <&gix_ref::FullNameRef>::try_from(reference.as_bstr()).is_ok()
         });
         if !is_valid {
-            return Err(config::key::GenericErrorWithValue::from_value(self, value.into()));
+            return Err(Error::from_error(config::key::error_with_value(
+                self,
+                "Invalid configuration value",
+                value,
+            )));
         }
         Ok(refs)
     }
 }
 
 mod validate {
-    use std::error::Error;
+    use gix_error::ResultExt;
 
-    use crate::{bstr::BStr, config::tree::keys::Validate};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys::Validate};
 
     #[derive(Clone, Copy)]
     pub struct DisplayRef;
 
     impl Validate for DisplayRef {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            super::Notes::DISPLAY_REF.try_into_display_refs(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Notes::DISPLAY_REF.try_into_display_refs(value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/pack.rs b/gix/src/config/tree/sections/pack.rs
index 9ab23b52fd9..77f2d96311d 100644
--- a/gix/src/config/tree/sections/pack.rs
+++ b/gix/src/config/tree/sections/pack.rs
@@ -21,21 +21,29 @@ impl Pack {
 pub type IndexVersion = keys::Any<validate::IndexVersion>;
 
 mod index_version {
-    use crate::{config, config::tree::sections::pack::IndexVersion};
+    use gix_error::ResultExt;
+
+    use crate::{Error, ExnMessageResult, Result, config, config::tree::sections::pack::IndexVersion};
 
     impl IndexVersion {
         /// Try to interpret an integer value as index version.
         pub fn try_into_index_version(
             &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<Option<gix_pack::index::Version>, config::key::GenericError> {
-            let Some(value) = value.map_err(|err| config::key::GenericError::from(self).with_source(err))? else {
+            value: ExnMessageResult<Option<i64>>,
+        ) -> Result<Option<gix_pack::index::Version>> {
+            let Some(value) = value.or_raise(|| config::key::error(self, "Invalid pack index version"))? else {
                 return Ok(None);
             };
             Ok(Some(match value {
                 1 => gix_pack::index::Version::V1,
                 2 => gix_pack::index::Version::V2,
-                _ => return Err(config::key::GenericError::from(self)),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid pack index version",
+                        value,
+                    )));
+                }
             }))
         }
     }
@@ -52,20 +60,26 @@ impl Section for Pack {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::{ErrorExt, ResultExt};
 
     #[derive(Clone, Copy)]
     pub struct IndexVersion;
     impl keys::Validate for IndexVersion {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Pack::INDEX_VERSION.try_into_index_version(
-                gix_config::Integer::try_from(value)
-                    .and_then(|int| {
-                        int.to_decimal()
-                            .ok_or_else(|| gix_config::value::Error::new("integer out of range", value))
-                    })
-                    .map(Some),
-            )?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Pack::INDEX_VERSION
+                .try_into_index_version(
+                    gix_config::Integer::try_from(value)
+                        .and_then(|int| {
+                            int.to_decimal().ok_or_else(|| {
+                                gix_error::validation("integer out of range")
+                                    .with("input", value)
+                                    .raise()
+                            })
+                        })
+                        .map(Some),
+                )
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/protocol.rs b/gix/src/config/tree/sections/protocol.rs
index f7b558fa62c..529bd2e6427 100644
--- a/gix/src/config/tree/sections/protocol.rs
+++ b/gix/src/config/tree/sections/protocol.rs
@@ -21,7 +21,7 @@ pub type Version = keys::Any<validate::Version>;
 
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 mod allow {
-    use crate::{bstr::ByteSlice, config, config::tree::protocol::Allow, remote::url::scheme_permission};
+    use crate::{Error, Result, bstr::ByteSlice, config::tree::protocol::Allow, remote::url::scheme_permission};
 
     impl Allow {
         /// Convert `value` into its respective `Allow` variant, possibly informing about the `scheme` we are looking at in the error.
@@ -29,11 +29,13 @@ mod allow {
             &'static self,
             value: impl gix_utils::AsBStr,
             scheme: Option<&str>,
-        ) -> Result<scheme_permission::Allow, config::protocol::allow::Error> {
+        ) -> Result<scheme_permission::Allow> {
             let value = value.as_bstr();
-            scheme_permission::Allow::try_from(value.as_bstr()).map_err(|value| config::protocol::allow::Error {
-                value,
-                scheme: scheme.map(ToOwned::to_owned),
+            scheme_permission::Allow::try_from(value.as_bstr()).map_err(|value| {
+                Error::from_error(gix_error::validation(format!(
+                    "The value {value:?} must be allow|deny|user in configuration key protocol{}.allow",
+                    scheme.map(|scheme| format!(".{scheme}")).unwrap_or_default()
+                )))
             })
         }
     }
@@ -76,31 +78,30 @@ impl Section for Protocol {
 }
 
 mod key_impls {
+    #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
+    use crate::{Error, ExnMessageResult, Result};
     impl super::Version {
         /// Convert `value` into the corresponding protocol version, possibly applying the correct default.
         #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
         pub fn try_into_protocol_version(
             &'static self,
-            value: Result<Option<i64>, gix_config::value::Error>,
-        ) -> Result<gix_protocol::transport::Protocol, crate::config::key::GenericErrorWithValue> {
-            let value = match value {
-                Ok(None) => return Ok(gix_protocol::transport::Protocol::V2),
-                Ok(Some(value)) => value,
-                Err(err) => {
-                    return Err(
-                        crate::config::key::GenericErrorWithValue::from_value(self, "unknown".into()).with_source(err),
-                    );
-                }
+            value: ExnMessageResult<Option<i64>>,
+        ) -> Result<gix_protocol::transport::Protocol> {
+            use gix_error::ResultExt;
+
+            let Some(value) = value.or_raise(|| crate::config::key::error(self, "Invalid protocol version"))? else {
+                return Ok(gix_protocol::transport::Protocol::V2);
             };
             Ok(match value {
                 0 => gix_protocol::transport::Protocol::V0,
                 1 => gix_protocol::transport::Protocol::V1,
                 2 => gix_protocol::transport::Protocol::V2,
                 other => {
-                    return Err(crate::config::key::GenericErrorWithValue::from_value(
+                    return Err(Error::from_error(crate::config::key::error_with_value(
                         self,
-                        other.to_string().into(),
-                    ));
+                        "Invalid protocol version",
+                        other,
+                    )));
                 }
             })
         }
@@ -108,14 +109,15 @@ mod key_impls {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::{ErrorExt, ResultExt, message};
 
     #[derive(Clone, Copy)]
     pub struct Allow;
     impl keys::Validate for Allow {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-            super::Protocol::ALLOW.try_into_allow(_value, None)?;
+            super::Protocol::ALLOW.try_into_allow(_value, None).or_erased()?;
             Ok(())
         }
     }
@@ -123,13 +125,14 @@ mod validate {
     #[derive(Clone, Copy)]
     pub struct Version;
     impl keys::Validate for Version {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            let value = gix_config::Integer::try_from(value)?
+        fn validate(&self, value: &BStr) -> ExnResult {
+            let value = gix_config::Integer::try_from(value)
+                .or_erased()?
                 .to_decimal()
-                .ok_or_else(|| format!("integer {value} cannot be represented as integer"))?;
+                .ok_or_else(|| message!("integer {value} cannot be represented as integer").raise_erased())?;
             match value {
                 0..=2 => Ok(()),
-                _ => Err(format!("protocol version {value} is unknown").into()),
+                _ => Err(message!("protocol version {value} is unknown").raise_erased()),
             }
         }
     }
diff --git a/gix/src/config/tree/sections/push.rs b/gix/src/config/tree/sections/push.rs
index 0c2c28ff135..e578ec5cacd 100644
--- a/gix/src/config/tree/sections/push.rs
+++ b/gix/src/config/tree/sections/push.rs
@@ -22,14 +22,11 @@ impl Section for Push {
 pub type Default = keys::Any<validate::Default>;
 
 mod default {
-    use crate::{bstr::ByteSlice, config, config::tree::push::Default, push};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::push::Default, push};
 
     impl Default {
         /// Try to interpret `value` as `push.default`.
-        pub fn try_into_default(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<push::Default, config::key::GenericErrorWithValue> {
+        pub fn try_into_default(&'static self, value: impl gix_utils::AsBStr) -> Result<push::Default> {
             let value = value.as_bstr();
             Ok(match value.as_bstr().as_bytes() {
                 b"nothing" => push::Default::Nothing,
@@ -37,7 +34,13 @@ mod default {
                 b"upstream" | b"tracking" => push::Default::Upstream,
                 b"simple" => push::Default::Simple,
                 b"matching" => push::Default::Matching,
-                _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
+                }
             })
         }
     }
@@ -46,13 +49,13 @@ mod default {
 mod validate {
     #[derive(Clone, Copy)]
     pub struct Default;
-    use std::error::Error;
+    use gix_error::ResultExt;
 
-    use crate::{bstr::BStr, config::tree::keys::Validate};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys::Validate};
 
     impl Validate for Default {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            super::Push::DEFAULT.try_into_default(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Push::DEFAULT.try_into_default(value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/remote.rs b/gix/src/config/tree/sections/remote.rs
index f419af1bb4b..f0d6cd3f644 100644
--- a/gix/src/config/tree/sections/remote.rs
+++ b/gix/src/config/tree/sections/remote.rs
@@ -56,7 +56,7 @@ impl Section for Remote {
 pub type TagOpt = keys::Any<validate::TagOpt>;
 
 mod tag_opts {
-    use crate::{bstr::ByteSlice, config, config::tree::remote::TagOpt, remote};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::remote::TagOpt, remote};
 
     impl TagOpt {
         /// Try to interpret `value` as tag option.
@@ -66,29 +66,32 @@ mod tag_opts {
         /// It's heavily biased towards the git command-line unfortunately, and the only
         /// value of its kind. Maybe in future more values will be supported which are less
         /// about passing them to a sub-process.
-        pub fn try_into_tag_opt(
-            &'static self,
-            value: impl gix_utils::AsBStr,
-        ) -> Result<remote::fetch::Tags, config::key::GenericErrorWithValue> {
+        pub fn try_into_tag_opt(&'static self, value: impl gix_utils::AsBStr) -> Result<remote::fetch::Tags> {
             let value = value.as_bstr();
             Ok(match value.as_bstr().as_bytes() {
                 b"--tags" => remote::fetch::Tags::All,
                 b"--no-tags" => remote::fetch::Tags::None,
-                _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
+                }
             })
         }
     }
 }
 
 pub mod validate {
-    use std::error::Error;
+    use gix_error::ResultExt;
 
-    use crate::{bstr::BStr, config::tree::keys::Validate};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys::Validate};
 
     pub struct TagOpt;
     impl Validate for TagOpt {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            super::Remote::TAG_OPT.try_into_tag_opt(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Remote::TAG_OPT.try_into_tag_opt(value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/ssh.rs b/gix/src/config/tree/sections/ssh.rs
index c65262c1d7e..9ae8e4b43b4 100644
--- a/gix/src/config/tree/sections/ssh.rs
+++ b/gix/src/config/tree/sections/ssh.rs
@@ -15,16 +15,13 @@ pub type Variant = keys::Any<validate::Variant>;
 
 #[cfg(feature = "blocking-network-client")]
 mod variant {
-    use crate::{bstr::ByteSlice, config, config::tree::ssh::Variant};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::ssh::Variant};
 
     impl Variant {
         pub fn try_into_variant(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<
-            Option<gix_protocol::transport::client::blocking_io::ssh::ProgramKind>,
-            config::key::GenericErrorWithValue,
-        > {
+        ) -> Result<Option<gix_protocol::transport::client::blocking_io::ssh::ProgramKind>> {
             use gix_protocol::transport::client::blocking_io::ssh::ProgramKind;
 
             let value = value.as_bstr();
@@ -35,7 +32,13 @@ mod variant {
                 b"putty" => ProgramKind::Putty,
                 b"tortoiseplink" => ProgramKind::TortoisePlink,
                 b"simple" => ProgramKind::Simple,
-                _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
+                }
             }))
         }
     }
@@ -52,13 +55,15 @@ impl Section for Ssh {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    #[cfg(feature = "blocking-network-client")]
+    use gix_error::ResultExt;
 
     pub struct Variant;
     impl keys::Validate for Variant {
-        fn validate(&self, _value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+        fn validate(&self, _value: &BStr) -> ExnResult {
             #[cfg(feature = "blocking-network-client")]
-            super::Ssh::VARIANT.try_into_variant(_value)?;
+            super::Ssh::VARIANT.try_into_variant(_value).or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/sections/status.rs b/gix/src/config/tree/sections/status.rs
index 6a8680bb711..56ef60cb2cf 100644
--- a/gix/src/config/tree/sections/status.rs
+++ b/gix/src/config/tree/sections/status.rs
@@ -26,19 +26,25 @@ impl Status {
 pub type ShowUntrackedFiles = keys::Any<validate::ShowUntrackedFiles>;
 
 mod show_untracked_files {
-    use crate::{bstr::ByteSlice, config, config::tree::status::ShowUntrackedFiles, status};
+    use crate::{Error, Result, bstr::ByteSlice, config, config::tree::status::ShowUntrackedFiles, status};
 
     impl ShowUntrackedFiles {
         pub fn try_into_show_untracked_files(
             &'static self,
             value: impl gix_utils::AsBStr,
-        ) -> Result<status::UntrackedFiles, config::key::GenericErrorWithValue> {
+        ) -> Result<status::UntrackedFiles> {
             let value = value.as_bstr();
             Ok(match value.as_bstr().as_bytes() {
                 b"no" => status::UntrackedFiles::None,
                 b"normal" => status::UntrackedFiles::Collapsed,
                 b"all" => status::UntrackedFiles::Files,
-                _ => return Err(config::key::GenericErrorWithValue::from_value(self, value.into())),
+                _ => {
+                    return Err(Error::from_error(config::key::error_with_value(
+                        self,
+                        "Invalid configuration value",
+                        value,
+                    )));
+                }
             })
         }
     }
@@ -55,13 +61,16 @@ impl Section for Status {
 }
 
 mod validate {
-    use crate::{bstr::BStr, config::tree::keys};
+    use crate::{ExnResult, bstr::BStr, config::tree::keys};
+    use gix_error::ResultExt;
 
     #[derive(Clone, Copy)]
     pub struct ShowUntrackedFiles;
     impl keys::Validate for ShowUntrackedFiles {
-        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-            super::Status::SHOW_UNTRACKED_FILES.try_into_show_untracked_files(value)?;
+        fn validate(&self, value: &BStr) -> ExnResult {
+            super::Status::SHOW_UNTRACKED_FILES
+                .try_into_show_untracked_files(value)
+                .or_erased()?;
             Ok(())
         }
     }
diff --git a/gix/src/config/tree/traits.rs b/gix/src/config/tree/traits.rs
index 9c076f5da1f..c0cde0ace3a 100644
--- a/gix/src/config/tree/traits.rs
+++ b/gix/src/config/tree/traits.rs
@@ -1,6 +1,6 @@
 use crate::{
+    Error, Result,
     bstr::{BStr, BString, ByteVec},
-    config::tree::key::validate_assignment,
 };
 
 /// Provide information about a configuration section.
@@ -53,7 +53,11 @@ pub trait Key: std::fmt::Debug {
     /// The key's name, like `url` in `remote.origin.url`.
     fn name(&self) -> &str;
     /// See if `value` is allowed as value of this key, or return a descriptive error if it is not.
-    fn validate(&self, value: &BStr) -> Result<(), crate::config::tree::key::validate::Error>;
+    ///
+    /// Built-in keys include the logical `key` name and invalid value bytes as `input` in
+    /// [`crate::Error::metadata()`]. If a key or its fallback declares an environment override,
+    /// `environment_override` names this possible override, not the actual source of the value.
+    fn validate(&self, value: &BStr) -> Result<()>;
     /// The section containing this key. Git configuration has no free-standing keys, they are always underneath a section.
     fn section(&self) -> &dyn Section;
     /// The return value encodes three possible states to indicate subsection requirements
@@ -133,7 +137,7 @@ pub trait Key: std::fmt::Debug {
     /// The full name of the key for use in configuration overrides, like `core.bare`, or `remote.<subsection>.url` if `subsection` is
     /// not `None`.
     /// May fail if this key needs a subsection, or may not have a subsection.
-    fn full_name(&self, subsection: Option<&BStr>) -> Result<BString, String> {
+    fn full_name(&self, subsection: Option<&BStr>) -> std::result::Result<BString, String> {
         let section = self.section();
         let mut buf = BString::default();
         let subsection = match self.subsection_requirement() {
@@ -175,11 +179,11 @@ pub trait Key: std::fmt::Debug {
 
     /// Return an assignment with the keys full name to `value`, suitable for [configuration overrides][crate::open::Options::config_overrides()].
     /// Note that this will fail if the key requires a subsection name.
-    fn validated_assignment(&self, value: &BStr) -> Result<BString, validate_assignment::Error> {
+    fn validated_assignment(&self, value: &BStr) -> Result<BString> {
         self.validate(value)?;
         let mut key = self
             .full_name(None)
-            .map_err(|message| validate_assignment::Error::Name { message })?;
+            .map_err(|message| Error::from_error(gix_error::validation(message)))?;
         key.push(b'=');
         key.push_str(value);
         Ok(key)
@@ -187,25 +191,18 @@ pub trait Key: std::fmt::Debug {
 
     /// Return an assignment with the keys full name to `value`, suitable for [configuration overrides][crate::open::Options::config_overrides()].
     /// Note that this will fail if the key requires a subsection name.
-    fn validated_assignment_fmt(
-        &self,
-        value: &dyn std::fmt::Display,
-    ) -> Result<BString, crate::config::tree::key::validate_assignment::Error> {
+    fn validated_assignment_fmt(&self, value: &dyn std::fmt::Display) -> Result<BString> {
         let value = value.to_string();
         self.validated_assignment(value.as_str().into())
     }
 
     /// Return an assignment to `value` with the keys full name within `subsection`, suitable for [configuration overrides][crate::open::Options::config_overrides()].
     /// Note that this is only valid if this key supports parameterized sub-sections, or else an error is returned.
-    fn validated_assignment_with_subsection(
-        &self,
-        value: &BStr,
-        subsection: &BStr,
-    ) -> Result<BString, crate::config::tree::key::validate_assignment::Error> {
+    fn validated_assignment_with_subsection(&self, value: &BStr, subsection: &BStr) -> Result<BString> {
         self.validate(value)?;
         let mut key = self
             .full_name(Some(subsection))
-            .map_err(|message| validate_assignment::Error::Name { message })?;
+            .map_err(|message| Error::from_error(gix_error::validation(message)))?;
         key.push(b'=');
         key.push_str(value);
         Ok(key)
diff --git a/gix/src/create.rs b/gix/src/create.rs
index 5eff998329c..71c56566563 100644
--- a/gix/src/create.rs
+++ b/gix/src/create.rs
@@ -5,27 +5,14 @@ use std::{
 };
 
 use gix_discover::DOT_GIT_DIR;
+use gix_error::{ErrorExt, ResultExt};
 
-/// The error used in [`into()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not obtain the current directory")]
-    CurrentDir(#[from] std::io::Error),
-    #[error("Could not open data at '{}'", .path.display())]
-    IoOpen { source: std::io::Error, path: PathBuf },
-    #[error("Could not write data at '{}'", .path.display())]
-    IoWrite { source: std::io::Error, path: PathBuf },
-    #[error("Refusing to initialize the existing '{}' directory", .path.display())]
-    DirectoryExists { path: PathBuf },
-    #[error("Refusing to initialize the non-empty directory as '{}'", .path.display())]
-    DirectoryNotEmpty { path: PathBuf },
-    #[error("Could not create directory at '{}'", .path.display())]
-    CreateDirectory { source: std::io::Error, path: PathBuf },
-    #[error(transparent)]
-    Span(#[from] gix_config::parse::span::Error),
-    #[error(transparent)]
-    ConfigValue(#[from] gix_config::file::section::value::Error),
+use crate::{Error, Result};
+
+fn io_error(source: std::io::Error, action: &str, path: &Path) -> Error {
+    source
+        .and_raise(gix_error::message!("{action} at '{}'", path.display()))
+        .into()
 }
 
 /// The kind of repository to create.
@@ -64,7 +51,7 @@ impl PathCursor<'_> {
 }
 
 impl NewDir<'_> {
-    fn at(self, component: &str) -> Result<Self, Error> {
+    fn at(self, component: &str) -> Result<Self> {
         self.0.push(component);
         create_dir(self.0)?;
         Ok(self)
@@ -86,28 +73,20 @@ impl Drop for PathCursor<'_> {
     }
 }
 
-fn write_file(data: &[u8], path: &Path) -> Result<(), Error> {
+fn write_file(data: &[u8], path: &Path) -> Result<()> {
     let mut file = OpenOptions::new()
         .write(true)
         .create(true)
         .truncate(true)
         .append(false)
         .open(path)
-        .map_err(|e| Error::IoOpen {
-            source: e,
-            path: path.to_owned(),
-        })?;
-    file.write_all(data).map_err(|e| Error::IoWrite {
-        source: e,
-        path: path.to_owned(),
-    })
+        .map_err(|err| io_error(err, "Could not open data", path))?;
+    file.write_all(data)
+        .map_err(|err| io_error(err, "Could not write data", path))
 }
 
-fn create_dir(p: &Path) -> Result<(), Error> {
-    fs::create_dir_all(p).map_err(|e| Error::CreateDirectory {
-        source: e,
-        path: p.to_owned(),
-    })
+fn create_dir(p: &Path) -> Result<()> {
+    fs::create_dir_all(p).map_err(|err| io_error(err, "Could not create directory", p))
 }
 
 /// Options for use in [`into()`];
@@ -167,11 +146,10 @@ fn default_object_hash() -> Option<gix_hash::Kind> {
 /// Note that this is a simple template-based initialization routine which should be accompanied with additional corrections
 /// to respect git configuration, which is accomplished by [its callers][crate::ThreadSafeRepository::init_opts()]
 /// that return a [Repository][crate::Repository].
-pub fn into(
-    directory: impl Into<PathBuf>,
-    kind: Kind,
-    options: Options,
-) -> Result<gix_discover::repository::Path, Error> {
+/// Rejected non-empty destinations or existing `.git` directories include the display-formatted path as `input` bytes
+/// in
+/// [metadata](gix_error::Error::metadata()).
+pub fn into(directory: impl Into<PathBuf>, kind: Kind, options: Options) -> Result<gix_discover::repository::Path> {
     into_with_capabilities(directory, kind, options).map(|(path, _)| path)
 }
 
@@ -183,7 +161,7 @@ pub(crate) fn into_with_capabilities(
         destination_must_be_empty,
         object_hash,
     }: Options,
-) -> Result<(gix_discover::repository::Path, gix_fs::Capabilities), Error> {
+) -> Result<(gix_discover::repository::Path, gix_fs::Capabilities)> {
     let mut dot_git = directory.into();
     let bare = matches!(kind, Kind::Bare);
 
@@ -196,13 +174,13 @@ pub(crate) fn into_with_capabilities(
                     Err(err)
                 }
             })
-            .map_err(|err| Error::IoOpen {
-                source: err,
-                path: dot_git.clone(),
-            })?
+            .map_err(|err| io_error(err, "Could not open data", &dot_git))?
             .count();
         if num_entries_in_dot_git != 0 {
-            return Err(Error::DirectoryNotEmpty { path: dot_git });
+            return Err(Error::from_error(
+                gix_error::validation("Refusing to initialize the non-empty directory as")
+                    .with("input", dot_git.display().to_string().into_bytes()),
+            ));
         }
     }
 
@@ -210,7 +188,10 @@ pub(crate) fn into_with_capabilities(
         dot_git.push(DOT_GIT_DIR);
 
         if dot_git.is_dir() {
-            return Err(Error::DirectoryExists { path: dot_git });
+            return Err(Error::from_error(
+                gix_error::validation("Refusing to initialize an existing directory")
+                    .with("input", dot_git.display().to_string().into_bytes()),
+            ));
         }
     }
     create_dir(&dot_git)?;
@@ -259,32 +240,38 @@ pub(crate) fn into_with_capabilities(
         let (mut config_file, config_path) = {
             let mut cursor = PathCursor(&mut dot_git);
             let config_path = cursor.at("config");
-            (fs::File::create(config_path)?, config_path.to_owned())
+            (
+                fs::File::create(config_path).map_err(|err| io_error(err, "Could not create data", config_path))?,
+                config_path.to_owned(),
+            )
         };
         let mut config = gix_config::File::default();
         let caps = {
             let caps = fs_capabilities.unwrap_or_else(|| gix_fs::Capabilities::probe(&dot_git));
             let mut core = config.new_section("core", None).expect("valid section name");
 
-            core.push("filemode", bool(caps.executable_bit))?;
-            core.push("bare", bool(bare))?;
-            core.push("logallrefupdates", bool(!bare))?;
+            core.push("filemode", bool(caps.executable_bit)).or_erased()?;
+            core.push("bare", bool(bare)).or_erased()?;
+            core.push("logallrefupdates", bool(!bare)).or_erased()?;
             if !caps.symlink {
-                core.push("symlinks", bool(false))?;
+                core.push("symlinks", bool(false)).or_erased()?;
             }
-            core.push("ignorecase", bool(caps.ignore_case))?;
-            core.push("precomposeunicode", bool(caps.precompose_unicode))?;
+            core.push("ignorecase", bool(caps.ignore_case)).or_erased()?;
+            core.push("precomposeunicode", bool(caps.precompose_unicode))
+                .or_erased()?;
 
             match object_hash {
                 #[cfg(feature = "sha256")]
                 Some(gix_hash::Kind::Sha256) => {
-                    core.push("repositoryformatversion", "1")?;
+                    core.push("repositoryformatversion", "1").or_erased()?;
 
                     let mut extensions = config.new_section("extensions", None).expect("valid section name");
-                    extensions.push("objectformat", gix_hash::Kind::Sha256.to_string())?;
+                    extensions
+                        .push("objectformat", gix_hash::Kind::Sha256.to_string())
+                        .or_erased()?;
                 }
                 _ => {
-                    core.push("repositoryformatversion", "0")?;
+                    core.push("repositoryformatversion", "0").or_erased()?;
                 }
             }
 
@@ -292,10 +279,7 @@ pub(crate) fn into_with_capabilities(
         };
         config_file
             .write_all(&config.to_bstring())
-            .map_err(|err| Error::IoWrite {
-                source: err,
-                path: config_path,
-            })?;
+            .map_err(|err| io_error(err, "Could not write data", &config_path))?;
         caps
     };
 
@@ -307,7 +291,8 @@ pub(crate) fn into_with_capabilities(
             } else {
                 gix_discover::repository::Kind::WorkTree { linked_git_dir: None }
             },
-            &gix_fs::current_dir(caps.precompose_unicode)?,
+            &gix_fs::current_dir(caps.precompose_unicode)
+                .or_raise(|| gix_error::message("Could not obtain the current directory"))?,
         )
         .expect("by now the `dot_git` dir is valid as we have accessed it"),
         caps,
diff --git a/gix/src/diff.rs b/gix/src/diff.rs
index 5c4cc72379f..ab9a58db6af 100644
--- a/gix/src/diff.rs
+++ b/gix/src/diff.rs
@@ -1,20 +1,11 @@
 use gix_diff::tree::recorder::Location;
 pub use gix_diff::*;
 
-///
-pub mod options {
-    ///
-    pub mod init {
-        /// The error returned when instantiating [diff options](crate::diff::Options).
-        #[derive(Debug, thiserror::Error)]
-        #[cfg_attr(feature = "blob-diff", expect(missing_docs))]
-        pub enum Error {
-            #[cfg(feature = "blob-diff")]
-            #[error(transparent)]
-            RewritesConfiguration(#[from] crate::diff::new_rewrites::Error),
-        }
-    }
-}
+#[cfg(feature = "blob-diff")]
+use crate::Result;
+
+#[cfg(feature = "blob-diff")]
+pub use utils::{new_rewrites, resource_cache};
 
 /// General diff-related options for configuring rename-tracking and blob diffs.
 #[derive(Debug, Copy, Clone)]
@@ -48,7 +39,7 @@ impl From<Options> for gix_diff::tree_with_rewrites::Options {
 /// Lifecycle
 impl Options {
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn from_configuration(config: &crate::config::Cache) -> Result<Self, options::init::Error> {
+    pub(crate) fn from_configuration(config: &crate::config::Cache) -> Result<Self> {
         Ok(Options {
             location: Some(Location::Path),
             rewrites: {
@@ -131,53 +122,19 @@ pub mod rename {
 #[cfg(feature = "blob-diff")]
 pub(crate) mod utils {
     use gix_diff::{Rewrites, rewrites::Copies};
+    use gix_error::ResultExt;
 
     use crate::{
-        Repository,
+        Repository, Result,
         config::{cache::util::ApplyLeniency, tree::Diff},
         diff::rename::Tracking,
     };
 
-    ///
-    pub mod new_rewrites {
-        /// The error returned by [`new_rewrites()`](super::new_rewrites()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            ConfigDiffRenames(#[from] crate::config::key::GenericError),
-            #[error(transparent)]
-            ConfigDiffRenameLimit(#[from] crate::config::unsigned_integer::Error),
-        }
-    }
-
-    ///
-    pub mod resource_cache {
-        /// The error returned by [`resource_cache()`](super::resource_cache()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            DiffAlgorithm(#[from] crate::config::diff::algorithm::Error),
-            #[error(transparent)]
-            WorktreeFilterOptions(#[from] crate::filter::pipeline::options::Error),
-            #[error(transparent)]
-            DiffDrivers(#[from] crate::config::diff::drivers::Error),
-            #[error(transparent)]
-            DiffPipelineOptions(#[from] crate::config::diff::pipeline_options::Error),
-            #[error(transparent)]
-            CommandContext(#[from] crate::config::command_context::Error),
-        }
-    }
-
     /// Create an instance by reading all relevant information from the `config`uration, while being `lenient` or not.
     /// Returns `Ok((None, false))` if nothing is configured, or `Ok((None, true))` if it's configured and disabled.
     ///
     /// Note that missing values will be defaulted similar to what git does.
-    pub fn new_rewrites(
-        config: &gix_config::File,
-        lenient: bool,
-    ) -> Result<(Option<Rewrites>, bool), new_rewrites::Error> {
+    pub fn new_rewrites(config: &gix_config::File, lenient: bool) -> Result<(Option<Rewrites>, bool)> {
         new_rewrites_inner(config, lenient, &Diff::RENAMES, &Diff::RENAME_LIMIT)
     }
 
@@ -186,10 +143,11 @@ pub(crate) mod utils {
         lenient: bool,
         renames: &'static crate::config::tree::diff::Renames,
         rename_limit: &'static crate::config::tree::keys::UnsignedInteger,
-    ) -> Result<(Option<Rewrites>, bool), new_rewrites::Error> {
+    ) -> Result<(Option<Rewrites>, bool)> {
         let copies = match renames
             .try_into_renames(config.boolean(renames))
-            .with_leniency(lenient)?
+            .with_leniency(lenient)
+            .or_erased()?
         {
             Some(renames) => match renames {
                 Tracking::Disabled => return Ok((None, true)),
@@ -205,7 +163,8 @@ pub(crate) mod utils {
                 copies,
                 limit: rename_limit
                     .try_into_usize(config.integer(rename_limit))
-                    .with_leniency(lenient)?
+                    .with_leniency(lenient)
+                    .or_erased()?
                     .unwrap_or(default.limit),
                 ..default
             }
@@ -228,8 +187,8 @@ pub(crate) mod utils {
         mode: gix_diff::blob::pipeline::Mode,
         attr_stack: gix_worktree::Stack,
         roots: gix_diff::blob::pipeline::WorktreeRoots,
-    ) -> Result<gix_diff::blob::Platform, resource_cache::Error> {
-        let diff_algo = repo.config.diff_algorithm()?;
+    ) -> Result<gix_diff::blob::Platform> {
+        let diff_algo = repo.config.diff_algorithm().or_erased()?;
         let diff_cache = gix_diff::blob::Platform::new(
             gix_diff::blob::platform::Options {
                 algorithm: Some(diff_algo),
@@ -247,5 +206,3 @@ pub(crate) mod utils {
         Ok(diff_cache)
     }
 }
-#[cfg(feature = "blob-diff")]
-pub use utils::{new_rewrites, resource_cache};
diff --git a/gix/src/dirwalk/iter.rs b/gix/src/dirwalk/iter.rs
index 7cd369c9b72..7a8e2b1025c 100644
--- a/gix/src/dirwalk/iter.rs
+++ b/gix/src/dirwalk/iter.rs
@@ -1,8 +1,10 @@
+use gix_error::ResultExt;
+
 use std::path::PathBuf;
 
 use super::Iter;
 use crate::{
-    PathspecDetached, Repository, bstr::BString, dirwalk, util::OwnedOrStaticAtomicBool,
+    PathspecDetached, Repository, Result, bstr::BString, dirwalk, util::OwnedOrStaticAtomicBool,
     worktree::IndexPersistedOrInMemory,
 };
 
@@ -41,21 +43,6 @@ pub struct Outcome {
     pub dirwalk: gix_dir::walk::Outcome,
 }
 
-/// The error returned by [Repository::dirwalk_iter()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to spawn producer thread")]
-    #[cfg(feature = "parallel")]
-    SpawnThread(#[from] std::io::Error),
-    #[error(transparent)]
-    #[cfg(not(feature = "parallel"))]
-    Dirwalk(#[from] dirwalk::Error),
-    #[error(transparent)]
-    #[cfg(not(feature = "parallel"))]
-    DetachPathSpec(#[from] std::io::Error),
-}
-
 /// Lifecycle
 impl Iter {
     pub(crate) fn new(
@@ -64,7 +51,7 @@ impl Iter {
         patterns: Vec<BString>,
         should_interrupt: OwnedOrStaticAtomicBool,
         options: dirwalk::Options,
-    ) -> Result<Iter, Error> {
+    ) -> Result<Iter> {
         #[cfg(feature = "parallel")]
         {
             let repo = repo.clone().into_sync();
@@ -73,24 +60,20 @@ impl Iter {
                 .name("gix::dirwalk::iter::producer".into())
                 .spawn({
                     let should_interrupt = should_interrupt.clone();
-                    move || -> Result<Outcome, dirwalk::Error> {
+                    move || -> Result<Outcome> {
                         let repo: Repository = repo.into();
                         let mut collect = Collect { tx };
                         let out = repo.dirwalk(&index, patterns, &should_interrupt, options, &mut collect)?;
                         Ok(Outcome {
                             index,
                             excludes: out.excludes.detach(),
-                            pathspec: out.pathspec.detach().map_err(|err| {
-                                dirwalk::Error::Walk(gix_dir::walk::Error::ReadDir {
-                                    path: repo.git_dir().to_owned(),
-                                    source: err,
-                                })
-                            })?,
+                            pathspec: out.pathspec.detach().or_erased()?,
                             traversal_root: out.traversal_root,
                             dirwalk: out.dirwalk,
                         })
                     }
-                })?;
+                })
+                .or_erased()?;
 
             Ok(Iter {
                 rx_and_join: Some((rx, handle)),
@@ -105,7 +88,7 @@ impl Iter {
             let out = Outcome {
                 index,
                 excludes: out.excludes.detach(),
-                pathspec: out.pathspec.detach()?,
+                pathspec: out.pathspec.detach().or_erased()?,
                 traversal_root: out.traversal_root,
                 dirwalk: out.dirwalk,
             };
@@ -133,7 +116,7 @@ impl Iter {
 }
 
 impl Iterator for Iter {
-    type Item = Result<Item, dirwalk::Error>;
+    type Item = Result<Item>;
 
     fn next(&mut self) -> Option<Self::Item> {
         #[cfg(feature = "parallel")]
diff --git a/gix/src/dirwalk/mod.rs b/gix/src/dirwalk/mod.rs
index 63d427e8f5b..13127ee6ca3 100644
--- a/gix/src/dirwalk/mod.rs
+++ b/gix/src/dirwalk/mod.rs
@@ -2,7 +2,9 @@ use std::path::PathBuf;
 
 use gix_dir::walk::{CollapsedEntriesEmissionMode, EmissionMode, ForDeletionMode};
 
-use crate::{AttributeStack, Pathspec, config};
+#[cfg(feature = "parallel")]
+use crate::Result;
+use crate::{AttributeStack, Pathspec};
 
 mod options;
 
@@ -24,10 +26,9 @@ pub mod iter;
 /// to interrupt unless the interrupt flag is set from another thread.
 pub struct Iter {
     #[cfg(feature = "parallel")]
-    #[expect(clippy::type_complexity)]
     rx_and_join: Option<(
         std::sync::mpsc::Receiver<iter::Item>,
-        std::thread::JoinHandle<Result<iter::Outcome, Error>>,
+        std::thread::JoinHandle<Result<iter::Outcome>>,
     )>,
     #[cfg(feature = "parallel")]
     should_interrupt: crate::util::OwnedOrStaticAtomicBool,
@@ -38,26 +39,6 @@ pub struct Iter {
     out: Option<iter::Outcome>,
 }
 
-/// The error returned by [dirwalk()](crate::Repository::dirwalk()).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Walk(#[from] gix_dir::walk::Error),
-    #[error("A working tree is required to perform a directory walk")]
-    MissingWorkDir,
-    #[error(transparent)]
-    Excludes(#[from] config::exclude_stack::Error),
-    #[error(transparent)]
-    Pathspec(#[from] crate::pathspec::init::Error),
-    #[error(transparent)]
-    Prefix(#[from] gix_path::realpath::Error),
-    #[error(transparent)]
-    FilesystemOptions(#[from] config::boolean::Error),
-    #[error("Could not list worktrees to assure they are no candidates for deletion")]
-    ListWorktrees(#[from] std::io::Error),
-}
-
 /// The outcome of the [dirwalk()](crate::Repository::dirwalk).
 pub struct Outcome<'repo> {
     /// The excludes stack used for the dirwalk, for access of `.gitignore` information.
diff --git a/gix/src/discover.rs b/gix/src/discover.rs
index 37e28fa98ca..2defc37176c 100644
--- a/gix/src/discover.rs
+++ b/gix/src/discover.rs
@@ -1,24 +1,16 @@
 #![allow(clippy::result_large_err)]
 use std::path::Path;
 
-pub use gix_discover::*;
+use gix_error::{ErrorExt, message};
 
-use crate::{ThreadSafeRepository, bstr::BString};
+pub use gix_discover::*;
 
-/// The error returned by [`crate::discover()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Discover(#[from] upwards::Error),
-    #[error(transparent)]
-    Open(#[from] crate::open::Error),
-}
+use crate::{Result, ThreadSafeRepository, bstr::BString};
 
 impl ThreadSafeRepository {
     /// Try to open a git repository in `directory` and search upwards through its parents until one is found,
     /// using default trust options which matters in case the found repository isn't owned by the current user.
-    pub fn discover(directory: impl AsRef<Path>) -> Result<Self, Error> {
+    pub fn discover(directory: impl AsRef<Path>) -> Result<Self> {
         Self::discover_opts(directory, Default::default(), Default::default())
     }
 
@@ -34,15 +26,18 @@ impl ThreadSafeRepository {
         directory: impl AsRef<Path>,
         options: upwards::Options<'_>,
         trust_map: gix_sec::trust::Mapping<crate::open::Options>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let _span = gix_trace::coarse!("ThreadSafeRepository::discover()");
         let (path, trust) = upwards_opts(directory.as_ref(), options)?;
         let (git_dir, worktree_dir) = path.into_repository_and_work_tree_directories();
         let mut options = trust_map.into_value_by_level(trust);
         options.git_dir_trust = trust.into();
         // Note that we will adjust the `current_dir` later so it matches the value of `core.precomposeUnicode`.
-        options.current_dir = Some(gix_fs::current_dir(false).map_err(upwards::Error::CurrentDir)?);
-        Self::open_from_paths(git_dir, worktree_dir, options, None).map_err(Into::into)
+        options.current_dir = Some(
+            gix_fs::current_dir(false)
+                .map_err(|err| err.and_raise(message("Could not obtain the current working directory")))?,
+        );
+        Self::open_from_paths(git_dir, worktree_dir, options, None)
     }
 
     /// Try to open a git repository directly from the environment.
@@ -50,7 +45,7 @@ impl ThreadSafeRepository {
     /// while applying discovery options from the environment.
     ///
     /// For more, see [`ThreadSafeRepository::discover_with_environment_overrides_opts()`].
-    pub fn discover_with_environment_overrides(directory: impl AsRef<Path>) -> Result<Self, Error> {
+    pub fn discover_with_environment_overrides(directory: impl AsRef<Path>) -> Result<Self> {
         Self::discover_with_environment_overrides_opts(directory, Default::default(), Default::default())
     }
 
@@ -85,7 +80,7 @@ impl ThreadSafeRepository {
         directory: impl AsRef<Path>,
         mut options: upwards::Options<'_>,
         trust_map: gix_sec::trust::Mapping<crate::open::Options>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         fn apply_additional_environment(mut opts: upwards::Options<'_>) -> upwards::Options<'_> {
             use crate::bstr::ByteVec;
 
@@ -99,7 +94,7 @@ impl ThreadSafeRepository {
         }
 
         if std::env::var_os("GIT_DIR").is_some() {
-            return Self::open_with_environment_overrides(directory.as_ref(), trust_map).map_err(Error::Open);
+            return Self::open_with_environment_overrides(directory.as_ref(), trust_map);
         }
 
         options = apply_additional_environment(options.apply_environment());
diff --git a/gix/src/env.rs b/gix/src/env.rs
index 1d633c86723..4d5522297e9 100644
--- a/gix/src/env.rs
+++ b/gix/src/env.rs
@@ -36,98 +36,3 @@ pub fn args_os_opt(precompose_unicode: bool) -> impl Iterator<Item = OsString> {
 pub fn os_str_to_bstring(input: &OsStr) -> Option<BString> {
     Vec::from_os_string(input.into()).map(Into::into).ok()
 }
-
-/// Utilities to collate errors of common operations into one error type.
-///
-/// This is useful as this type can present an API to answer common questions, like whether a network request seems to have failed
-/// spuriously or if the underlying repository seems to be corrupted.
-/// Error collation supports all operations, including opening the repository.
-///
-/// ### Usage
-///
-/// The caller may define a function that specifies the result type as `Result<T, gix::env::collate::{operation}::Error>` to collect
-/// errors into a well-known error type which provides an API for simple queries.
-pub mod collate {
-
-    ///
-    pub mod fetch {
-        /// An error which combines all possible errors when opening a repository, finding remotes and using them to fetch.
-        ///
-        /// It can be used to detect if the repository is likely be corrupted in some way, or if the fetch failed spuriously
-        /// and thus can be retried.
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error<E: std::error::Error + Send + Sync + 'static = std::convert::Infallible> {
-            #[error(transparent)]
-            Open(#[from] crate::open::Error),
-            #[error(transparent)]
-            FindExistingReference(#[from] crate::reference::find::existing::Error),
-            #[error(transparent)]
-            RemoteInit(#[from] crate::remote::init::Error),
-            #[error(transparent)]
-            FindExistingRemote(#[from] crate::remote::find::existing::Error),
-            #[error(transparent)]
-            #[cfg(feature = "credentials")]
-            CredentialHelperConfig(#[from] crate::config::credential_helpers::Error),
-            #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-            #[error(transparent)]
-            Connect(#[from] crate::remote::connect::Error),
-            #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-            #[error(transparent)]
-            PrepareFetch(#[from] crate::remote::fetch::prepare::Error),
-            #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-            #[error(transparent)]
-            Fetch(#[from] crate::remote::fetch::Error),
-            #[error(transparent)]
-            Other(E),
-        }
-
-        #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
-        impl<E> crate::protocol::transport::IsSpuriousError for Error<E>
-        where
-            E: std::error::Error + Send + Sync + 'static,
-        {
-            fn is_spurious(&self) -> bool {
-                match self {
-                    Error::Open(_)
-                    | Error::CredentialHelperConfig(_)
-                    | Error::RemoteInit(_)
-                    | Error::FindExistingReference(_)
-                    | Error::FindExistingRemote(_)
-                    | Error::Other(_) => false,
-                    Error::Connect(err) => err.is_spurious(),
-                    Error::PrepareFetch(err) => err.is_spurious(),
-                    Error::Fetch(err) => err.is_spurious(),
-                }
-            }
-        }
-
-        /// Queries
-        impl<E> Error<E>
-        where
-            E: std::error::Error + Send + Sync + 'static,
-        {
-            /// Return true if repository corruption caused the failure.
-            pub fn is_corrupted(&self) -> bool {
-                match self {
-                    Error::Open(crate::open::Error::NotARepository { .. } | crate::open::Error::Config(_)) => true,
-                    #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
-                    Error::PrepareFetch(crate::remote::fetch::prepare::Error::RefMap(
-                        // Configuration couldn't be accessed or was incomplete.
-                        crate::remote::ref_map::Error::GatherTransportConfig { .. }
-                        | crate::remote::ref_map::Error::ConfigureCredentials(_),
-                    )) => true,
-                    // Maybe the value of the configuration was corrupted, or a file couldn't be removed.
-                    #[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
-                    Error::Fetch(
-                        crate::remote::fetch::Error::PackThreads(_)
-                        | crate::remote::fetch::Error::PackIndexVersion(_)
-                        | crate::remote::fetch::Error::RemovePackKeepFile { .. }
-                        | crate::remote::fetch::Error::Fetch(gix_protocol::fetch::Error::Negotiate(_)),
-                    ) => true,
-                    _ => false,
-                }
-            }
-        }
-    }
-}
diff --git a/gix/src/ext/tree.rs b/gix/src/ext/tree.rs
index dc357c2cc5b..be0a2b135a2 100644
--- a/gix/src/ext/tree.rs
+++ b/gix/src/ext/tree.rs
@@ -3,6 +3,8 @@ use std::borrow::BorrowMut;
 use gix_object::TreeRefIter;
 use gix_traverse::tree::breadthfirst;
 
+use crate::Result;
+
 pub trait Sealed {}
 
 /// An extension trait for tree iterators
@@ -12,12 +14,7 @@ pub trait TreeIterExt: Sealed {
     ///
     /// The `delegate` implements a way to store details about the traversal to allow paying only for what's actually used.
     /// Since it is expected to store the operation result, _unit_ is returned.
-    fn traverse<StateMut, Find, V>(
-        &self,
-        state: StateMut,
-        objects: Find,
-        delegate: &mut V,
-    ) -> Result<(), breadthfirst::Error>
+    fn traverse<StateMut, Find, V>(&self, state: StateMut, objects: Find, delegate: &mut V) -> Result<()>
     where
         Find: gix_object::Find,
         StateMut: BorrowMut<breadthfirst::State>,
@@ -27,18 +24,13 @@ pub trait TreeIterExt: Sealed {
 impl Sealed for TreeRefIter<'_> {}
 
 impl TreeIterExt for TreeRefIter<'_> {
-    fn traverse<StateMut, Find, V>(
-        &self,
-        state: StateMut,
-        objects: Find,
-        delegate: &mut V,
-    ) -> Result<(), breadthfirst::Error>
+    fn traverse<StateMut, Find, V>(&self, state: StateMut, objects: Find, delegate: &mut V) -> Result<()>
     where
         Find: gix_object::Find,
         StateMut: BorrowMut<breadthfirst::State>,
         V: gix_traverse::tree::Visit,
     {
-        breadthfirst(*self, state, objects, delegate)
+        breadthfirst(*self, state, objects, delegate).map_err(gix_error::Exn::into_error)
     }
 }
 
diff --git a/gix/src/filter.rs b/gix/src/filter.rs
index 2f2be0926d1..8fea2a34b51 100644
--- a/gix/src/filter.rs
+++ b/gix/src/filter.rs
@@ -1,9 +1,10 @@
 //! lower-level access to filters which are applied to create working tree checkouts or to 'clean' working tree contents for storage in git.
+use gix_error::{ErrorExt, ResultExt};
 pub use gix_filter as plumbing;
 use gix_object::Find;
 
 use crate::{
-    Repository,
+    Error, ExnResult, Repository, Result,
     bstr::BStr,
     config::{
         cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
@@ -12,76 +13,6 @@ use crate::{
     prelude::ObjectIdExt,
 };
 
-///
-pub mod pipeline {
-    ///
-    pub mod options {
-        use crate::{bstr::BString, config};
-
-        /// The error returned by [Pipeline::options()](crate::filter::Pipeline::options()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            CheckRoundTripEncodings(#[from] config::encoding::Error),
-            #[error(transparent)]
-            SafeCrlf(#[from] config::key::GenericErrorWithValue),
-            #[error("Could not interpret 'filter.{name}.required' configuration")]
-            Driver {
-                name: BString,
-                source: gix_config::value::Error,
-            },
-            #[error(transparent)]
-            CommandContext(#[from] config::command_context::Error),
-        }
-    }
-
-    ///
-    pub mod convert_to_git {
-        /// The error returned by [Pipeline::convert_to_git()](crate::filter::Pipeline::convert_to_git()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Failed to prime attributes to the path at which the data resides")]
-            WorktreeCacheAtPath(#[from] std::io::Error),
-            #[error(transparent)]
-            Convert(#[from] gix_filter::pipeline::convert::to_git::Error),
-        }
-    }
-
-    ///
-    pub mod convert_to_worktree {
-        /// The error returned by [Pipeline::convert_to_worktree()](crate::filter::Pipeline::convert_to_worktree()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Failed to prime attributes to the path at which the data resides")]
-            WorktreeCacheAtPath(#[from] std::io::Error),
-            #[error(transparent)]
-            Convert(#[from] gix_filter::pipeline::convert::to_worktree::Error),
-        }
-    }
-
-    ///
-    pub mod worktree_file_to_object {
-        use std::path::PathBuf;
-
-        /// The error returned by [Pipeline::worktree_file_to_object()](crate::filter::Pipeline::worktree_file_to_object()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Cannot add worktree files in bare repositories")]
-            MissingWorktree,
-            #[error("Failed to perform IO for object creation for '{}'", path.display())]
-            IO { source: std::io::Error, path: PathBuf },
-            #[error(transparent)]
-            WriteBlob(#[from] crate::object::write::Error),
-            #[error(transparent)]
-            ConvertToGit(#[from] crate::filter::pipeline::convert_to_git::Error),
-        }
-    }
-}
-
 /// A git pipeline for transforming data *to-git* and *to-worktree*, based
 /// [on git configuration and attributes](https://git-scm.com/docs/gitattributes).
 #[derive(Clone)]
@@ -95,10 +26,11 @@ pub struct Pipeline<'repo> {
 /// Lifecycle
 impl<'repo> Pipeline<'repo> {
     /// Extract options from `repo` that are needed to properly drive a standard git filter pipeline.
-    pub fn options(repo: &'repo Repository) -> Result<gix_filter::pipeline::Options, pipeline::options::Error> {
+    pub fn options(repo: &'repo Repository) -> Result<gix_filter::pipeline::Options> {
         let config = &repo.config.resolved;
-        let encodings =
-            Core::CHECK_ROUND_TRIP_ENCODING.try_into_encodings(config.string("core.checkRoundtripEncoding"))?;
+        let encodings = Core::CHECK_ROUND_TRIP_ENCODING
+            .try_into_encodings(config.string("core.checkRoundtripEncoding"))
+            .or_erased()?;
         let safe_crlf = config
             .string("core.safecrlf")
             .map(|value| Core::SAFE_CRLF.try_into_safecrlf(value))
@@ -108,17 +40,20 @@ impl<'repo> Pipeline<'repo> {
                 repo.config.lenient_config,
                 // in lenient mode, we prefer the safe option, instead of just (trying) to output warnings.
                 gix_filter::pipeline::CrlfRoundTripCheck::Fail,
-            )?;
+            )
+            .or_erased()?;
         let auto_crlf = config
             .string("core.autocrlf")
             .map(|value| Core::AUTO_CRLF.try_into_autocrlf(value))
             .transpose()
-            .with_leniency(repo.config.lenient_config)?
+            .with_leniency(repo.config.lenient_config)
+            .or_erased()?
             .unwrap_or_default();
         let eol = config
             .string("core.eol")
             .map(|value| Core::EOL.try_into_eol(value))
-            .transpose()?;
+            .transpose()
+            .or_erased()?;
         let drivers = extract_drivers(repo)?;
         Ok(gix_filter::pipeline::Options {
             drivers,
@@ -131,7 +66,7 @@ impl<'repo> Pipeline<'repo> {
 
     /// Create a new instance by extracting all necessary information and configuration from a `repo` along with `cache` for accessing
     /// attributes. The `index` is used for some filters which may access it under very specific circumstances.
-    pub fn new(repo: &'repo Repository, cache: gix_worktree::Stack) -> Result<Self, pipeline::options::Error> {
+    pub fn new(repo: &'repo Repository, cache: gix_worktree::Stack) -> Result<Self> {
         let pipeline = gix_filter::Pipeline::new(repo.command_context()?, Self::options(repo)?);
         Ok(Pipeline {
             inner: pipeline,
@@ -158,28 +93,33 @@ impl Pipeline<'_> {
         src: R,
         rela_path: &std::path::Path,
         index: &gix_index::State,
-    ) -> Result<gix_filter::pipeline::convert::ToGitOutcome<'_, R>, pipeline::convert_to_git::Error>
+    ) -> Result<gix_filter::pipeline::convert::ToGitOutcome<'_, R>>
     where
         R: std::io::Read,
     {
-        let entry = self.cache.at_path(rela_path, None, &self.repo.objects)?;
-        Ok(self.inner.convert_to_git(
-            src,
-            rela_path,
-            &mut |_, attrs| {
-                entry.matching_attributes(attrs);
-            },
-            &mut |buf| -> Result<_, gix_object::find::Error> {
-                let entry = match index
-                    .entry_by_path(gix_path::to_unix_separators_on_windows(gix_path::into_bstr(rela_path)).as_ref())
-                {
-                    None => return Ok(None),
-                    Some(entry) => entry,
-                };
-                let obj = self.repo.objects.try_find(&entry.id, buf)?;
-                Ok(obj.filter(|obj| obj.kind == gix_object::Kind::Blob).map(|_| ()))
-            },
-        )?)
+        let entry = self
+            .cache
+            .at_path(rela_path, None, &self.repo.objects)
+            .or_raise(|| gix_error::message("Failed to prime attributes to the path at which the data resides"))?;
+        self.inner
+            .convert_to_git(
+                src,
+                rela_path,
+                &mut |_, attrs| {
+                    entry.matching_attributes(attrs);
+                },
+                &mut |buf| -> ExnResult<_> {
+                    let entry = match index
+                        .entry_by_path(gix_path::to_unix_separators_on_windows(gix_path::into_bstr(rela_path)).as_ref())
+                    {
+                        None => return Ok(None),
+                        Some(entry) => entry,
+                    };
+                    let obj = self.repo.objects.try_find(&entry.id, buf)?;
+                    Ok(obj.filter(|obj| obj.kind == gix_object::Kind::Blob).map(|_| ()))
+                },
+            )
+            .map_err(Error::from)
     }
 
     /// Convert a `src` buffer located at `rela_path` (in the index) from what's in `git` to the worktree representation.
@@ -195,9 +135,8 @@ impl Pipeline<'_> {
         src: &'input [u8],
         rela_path: &BStr,
         options: gix_filter::pipeline::convert::to_worktree::Options,
-    ) -> Result<gix_filter::pipeline::convert::ToWorktreeOutcome<'input, '_>, pipeline::convert_to_worktree::Error>
-    {
-        let entry = self.cache.at_entry(rela_path, None, &self.repo.objects)?;
+    ) -> Result<gix_filter::pipeline::convert::ToWorktreeOutcome<'input, '_>> {
+        let entry = self.cache.at_entry(rela_path, None, &self.repo.objects).or_erased()?;
         Ok(self.inner.convert_to_worktree(
             src,
             rela_path,
@@ -221,15 +160,12 @@ impl Pipeline<'_> {
         &mut self,
         rela_path: &BStr,
         index: &gix_index::State,
-    ) -> Result<
-        Option<(gix_hash::ObjectId, gix_object::tree::EntryKind, std::fs::Metadata)>,
-        pipeline::worktree_file_to_object::Error,
-    > {
-        use pipeline::worktree_file_to_object::Error;
-
+    ) -> Result<Option<(gix_hash::ObjectId, gix_object::tree::EntryKind, std::fs::Metadata)>> {
         let rela_path_as_path = gix_path::from_bstr(rela_path);
         let repo = self.repo;
-        let worktree_dir = repo.workdir().ok_or(Error::MissingWorktree)?;
+        let worktree_dir = repo
+            .workdir()
+            .ok_or_else(|| Error::from_error(gix_error::message("Cannot add worktree files in bare repositories")))?;
         let path = worktree_dir.join(&rela_path_as_path);
         let md = match std::fs::symlink_metadata(&path) {
             Ok(md) => md,
@@ -237,18 +173,31 @@ impl Pipeline<'_> {
                 if gix_fs::io_err::is_not_found(err.kind(), err.raw_os_error()) {
                     return Ok(None);
                 } else {
-                    return Err(Error::IO { source: err, path });
+                    return Err(Error::from(err.and_raise(gix_error::message!(
+                        "Failed to perform IO for object creation for '{}'",
+                        path.display()
+                    ))));
                 }
             }
         };
         let (id, kind) = if md.is_symlink() {
-            let target = std::fs::read_link(&path).map_err(|source| Error::IO { source, path })?;
-            let id = repo.write_blob(gix_path::into_bstr(target).as_ref())?;
+            let target = std::fs::read_link(&path).map_err(|source| {
+                source.and_raise(gix_error::message!(
+                    "Failed to perform IO for object creation for '{}'",
+                    path.display()
+                ))
+            })?;
+            let id = repo.write_blob(gix_path::into_bstr(target).as_ref()).or_erased()?;
             (id, gix_object::tree::EntryKind::Link)
         } else if md.is_file() {
             use gix_filter::pipeline::convert::ToGitOutcome;
 
-            let file = std::fs::File::open(&path).map_err(|source| Error::IO { source, path })?;
+            let file = std::fs::File::open(&path).map_err(|source| {
+                source.and_raise(gix_error::message!(
+                    "Failed to perform IO for object creation for '{}'",
+                    path.display()
+                ))
+            })?;
             let file_for_git = self.convert_to_git(file, rela_path_as_path.as_ref(), index)?;
             let id = match file_for_git {
                 ToGitOutcome::Unchanged(mut file) => repo.write_blob_stream(&mut file)?,
@@ -288,7 +237,7 @@ impl Pipeline<'_> {
 }
 
 /// Obtain a list of all configured driver, but ignore those in sections that we don't trust enough.
-fn extract_drivers(repo: &Repository) -> Result<Vec<gix_filter::Driver>, pipeline::options::Error> {
+fn extract_drivers(repo: &Repository) -> Result<Vec<gix_filter::Driver>> {
     let mut drivers = Vec::<gix_filter::Driver>::new();
     for section in repo
         .config
@@ -325,9 +274,10 @@ fn extract_drivers(repo: &Repository) -> Result<Vec<gix_filter::Driver>, pipelin
         }
         if let Some(value) = section.value("required") {
             driver.required = gix_config::Boolean::try_from(BStr::new(&value))
-                .map_err(|source| pipeline::options::Error::Driver {
-                    name: name.to_owned(),
-                    source,
+                .map_err(|err| {
+                    err.raise(gix_error::message!(
+                        "Could not interpret 'filter.{name}.required' configuration"
+                    ))
                 })?
                 .into();
         }
diff --git a/gix/src/head/mod.rs b/gix/src/head/mod.rs
index da8027d361b..a1bf2064887 100644
--- a/gix/src/head/mod.rs
+++ b/gix/src/head/mod.rs
@@ -124,7 +124,7 @@ impl<'repo> Head<'repo> {
 
 mod remote {
     use super::Head;
-    use crate::{Remote, remote};
+    use crate::{Remote, Result, remote};
 
     /// Remote
     impl<'repo> Head<'repo> {
@@ -139,10 +139,7 @@ mod remote {
         /// handle detached heads, i.e. obtain a remote even in case of detached heads,
         /// or call [`Repository::find_fetch_remote(…)`](crate::Repository::find_fetch_remote()) for the highest-level way of finding
         /// the right remote, just like `git fetch` does.
-        pub fn into_remote(
-            self,
-            direction: remote::Direction,
-        ) -> Option<Result<Remote<'repo>, remote::find::existing::Error>> {
+        pub fn into_remote(self, direction: remote::Direction) -> Option<Result<Remote<'repo>>> {
             let repo = self.repo;
             self.try_into_referent()?
                 .remote(direction)
diff --git a/gix/src/head/peel.rs b/gix/src/head/peel.rs
index b8d416b6d51..1d02c5a701c 100644
--- a/gix/src/head/peel.rs
+++ b/gix/src/head/peel.rs
@@ -1,80 +1,22 @@
+use gix_error::ResultExt;
+
 use crate::{
-    Head,
+    Error, Head, Result,
     ext::{ObjectIdExt, ReferenceExt},
     head::Kind,
 };
 
-mod error {
-    use crate::{object, reference};
-
-    /// The error returned by [`Head::peel_to_id()`](super::Head::try_peel_to_id()) and
-    /// [`Head::into_fully_peeled_id()`](super::Head::try_into_peeled_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FindExistingObject(#[from] object::find::existing::Error),
-        #[error(transparent)]
-        PeelReference(#[from] reference::peel::Error),
-    }
-}
-
-pub use error::Error;
-
-///
-pub mod into_id {
-    use crate::object;
-
-    /// The error returned by [`Head::into_peeled_id()`](super::Head::into_peeled_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Peel(#[from] super::Error),
-        #[error("Branch '{name}' does not have any commits")]
-        Unborn { name: gix_ref::FullName },
-        #[error(transparent)]
-        ObjectKind(#[from] object::try_into::Error),
-    }
-}
-
-///
-pub mod to_commit {
-    use crate::object;
-
-    /// The error returned by [`Head::peel_to_commit()`](super::Head::peel_to_commit()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        PeelToObject(#[from] super::to_object::Error),
-        #[error(transparent)]
-        ObjectKind(#[from] object::try_into::Error),
-    }
-}
-
-///
-pub mod to_object {
-    /// The error returned by [`Head::peel_to_object()`](super::Head::peel_to_object()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Peel(#[from] super::Error),
-        #[error("Branch '{name}' does not have any commits")]
-        Unborn { name: gix_ref::FullName },
-    }
-}
-
 impl<'repo> Head<'repo> {
     /// Peel this instance and consume it to make obtaining its final target id possible, while returning an error on unborn heads.
     ///
     /// The final target is obtained by following symbolic references and peeling tags to their final destination, which
     /// typically is a commit, but can be any object.
-    pub fn into_peeled_id(mut self) -> Result<crate::Id<'repo>, into_id::Error> {
+    pub fn into_peeled_id(mut self) -> Result<crate::Id<'repo>> {
         self.try_peel_to_id()?;
         self.id().ok_or_else(|| match self.kind {
-            Kind::Symbolic(gix_ref::Reference { name, .. }) | Kind::Unborn(name) => into_id::Error::Unborn { name },
+            Kind::Symbolic(gix_ref::Reference { name, .. }) | Kind::Unborn(name) => Error::from_error(
+                gix_error::not_found(format!("Branch '{name}' does not have any commits")),
+            ),
             Kind::Detached { .. } => unreachable!("id can be returned after peeling"),
         })
     }
@@ -83,7 +25,7 @@ impl<'repo> Head<'repo> {
     ///
     /// The final target is obtained by following symbolic references and peeling tags to their final destination, which
     /// typically is a commit, but can be any object as well.
-    pub fn into_peeled_object(mut self) -> Result<crate::Object<'repo>, to_object::Error> {
+    pub fn into_peeled_object(mut self) -> Result<crate::Object<'repo>> {
         self.peel_to_object()
     }
 
@@ -92,7 +34,7 @@ impl<'repo> Head<'repo> {
     ///
     /// The final target is obtained by following symbolic references and peeling tags to their final destination, which
     /// typically is a commit, but can be any object.
-    pub fn try_into_peeled_id(mut self) -> Result<Option<crate::Id<'repo>>, Error> {
+    pub fn try_into_peeled_id(mut self) -> Result<Option<crate::Id<'repo>>> {
         self.try_peel_to_id()
     }
 
@@ -104,7 +46,7 @@ impl<'repo> Head<'repo> {
     /// The final target is obtained by following symbolic references and peeling tags to their final destination, which
     /// typically is a commit, but can be any object.
     #[deprecated = "Use `try_peel_to_id()` instead"]
-    pub fn try_peel_to_id_in_place(&mut self) -> Result<Option<crate::Id<'repo>>, Error> {
+    pub fn try_peel_to_id_in_place(&mut self) -> Result<Option<crate::Id<'repo>>> {
         self.try_peel_to_id()
     }
 
@@ -117,7 +59,7 @@ impl<'repo> Head<'repo> {
     /// typically is a commit, but can be any object.
     ///
     /// Note that this method mutates `self` in place.
-    pub fn try_peel_to_id(&mut self) -> Result<Option<crate::Id<'repo>>, Error> {
+    pub fn try_peel_to_id(&mut self) -> Result<Option<crate::Id<'repo>>> {
         Ok(Some(match &mut self.kind {
             Kind::Unborn(_name) => return Ok(None),
             Kind::Detached {
@@ -142,7 +84,7 @@ impl<'repo> Head<'repo> {
                 let mut nr = r.clone().attach(self.repo);
                 let peeled = nr.peel_to_id();
                 *r = nr.detach();
-                peeled?
+                peeled.or_erased()?
             }
         }))
     }
@@ -152,7 +94,7 @@ impl<'repo> Head<'repo> {
     ///
     /// Returns an error if the head is unborn or if it doesn't point to a commit.
     #[deprecated = "Use `peel_to_object()` instead"]
-    pub fn peel_to_object_in_place(&mut self) -> Result<crate::Object<'repo>, to_object::Error> {
+    pub fn peel_to_object_in_place(&mut self) -> Result<crate::Object<'repo>> {
         self.peel_to_object()
     }
 
@@ -162,12 +104,14 @@ impl<'repo> Head<'repo> {
     /// Returns an error if the head is unborn or if it doesn't point to a commit.
     ///
     /// Note that this method mutates `self` in place.
-    pub fn peel_to_object(&mut self) -> Result<crate::Object<'repo>, to_object::Error> {
-        let id = self.try_peel_to_id()?.ok_or_else(|| to_object::Error::Unborn {
-            name: self.referent_name().expect("unborn").to_owned(),
+    pub fn peel_to_object(&mut self) -> Result<crate::Object<'repo>> {
+        let id = self.try_peel_to_id()?.ok_or_else(|| {
+            Error::from_error(gix_error::not_found(format!(
+                "Branch '{}' does not have any commits",
+                self.referent_name().expect("unborn")
+            )))
         })?;
         id.object()
-            .map_err(|err| to_object::Error::Peel(Error::FindExistingObject(err)))
     }
 
     /// Follow the symbolic reference of this head until its target object and peel it by following tag objects until there is no
@@ -175,7 +119,7 @@ impl<'repo> Head<'repo> {
     ///
     /// Returns an error if the head is unborn or if it doesn't point to a commit.
     #[deprecated = "Use `peel_to_commit()` instead"]
-    pub fn peel_to_commit_in_place(&mut self) -> Result<crate::Commit<'repo>, to_commit::Error> {
+    pub fn peel_to_commit_in_place(&mut self) -> Result<crate::Commit<'repo>> {
         self.peel_to_commit()
     }
 
@@ -185,7 +129,7 @@ impl<'repo> Head<'repo> {
     /// Returns an error if the head is unborn or if it doesn't point to a commit.
     ///
     /// Note that this method mutates `self` in place.
-    pub fn peel_to_commit(&mut self) -> Result<crate::Commit<'repo>, to_commit::Error> {
-        Ok(self.peel_to_object()?.try_into_commit()?)
+    pub fn peel_to_commit(&mut self) -> Result<crate::Commit<'repo>> {
+        Ok(self.peel_to_object()?.try_into_commit().or_erased()?)
     }
 }
diff --git a/gix/src/id.rs b/gix/src/id.rs
index 90a9bb86566..62e09a828bd 100644
--- a/gix/src/id.rs
+++ b/gix/src/id.rs
@@ -4,7 +4,7 @@ use std::ops::Deref;
 
 use gix_hash::{ObjectId, oid};
 
-use crate::{Id, Object, object::find};
+use crate::{Error, Id, Object, Result};
 
 /// An [object id][ObjectId] infused with a [`Repository`][crate::Repository].
 impl<'repo> Id<'repo> {
@@ -13,14 +13,14 @@ impl<'repo> Id<'repo> {
     /// # Note
     ///
     /// There can only be one `ObjectRef` per `Easy`. To increase that limit, clone the `Easy`.
-    pub fn object(&self) -> Result<Object<'repo>, find::existing::Error> {
+    pub fn object(&self) -> Result<Object<'repo>> {
         self.repo.find_object(self.inner)
     }
 
     /// Find the [`header`][gix_odb::find::Header] associated with this object id, or an error if it doesn't exist.
     ///
     /// Use this method if there is no interest in the contents of the object, which generally is much faster to obtain.
-    pub fn header(&self) -> Result<gix_odb::find::Header, find::existing::Error> {
+    pub fn header(&self) -> Result<gix_odb::find::Header> {
         self.repo.find_header(self.inner)
     }
 
@@ -29,19 +29,19 @@ impl<'repo> Id<'repo> {
     /// # Note
     ///
     /// There can only be one `ObjectRef` per `Easy`. To increase that limit, clone the `Easy`.
-    pub fn try_object(&self) -> Result<Option<Object<'repo>>, find::Error> {
+    pub fn try_object(&self) -> Result<Option<Object<'repo>>> {
         self.repo.try_find_object(self.inner)
     }
 
     /// Find the [`header`][gix_odb::find::Header] associated with this object id, or return `None` if it doesn't exist.
     ///
     /// Use this method if there is no interest in the contents of the object, which generally is much faster to obtain.
-    pub fn try_header(&self) -> Result<Option<gix_odb::find::Header>, find::Error> {
+    pub fn try_header(&self) -> Result<Option<gix_odb::find::Header>> {
         self.repo.try_find_header(self.inner)
     }
 
     /// Turn this object id into a shortened id with a length in hex as configured by `core.abbrev`.
-    pub fn shorten(&self) -> Result<gix_hash::Prefix, shorten::Error> {
+    pub fn shorten(&self) -> Result<gix_hash::Prefix> {
         let hex_len = self.repo.config.hex_len.map_or_else(
             || self.repo.objects.packed_object_count().map(calculate_auto_hex_len),
             Ok,
@@ -49,10 +49,12 @@ impl<'repo> Id<'repo> {
 
         let prefix = gix_odb::store::prefix::disambiguate::Candidate::new(self.inner, hex_len)
             .expect("BUG: internal hex-len must always be valid");
-        self.repo
-            .objects
-            .disambiguate_prefix(prefix)?
-            .ok_or(shorten::Error::NotFound { oid: self.inner })
+        self.repo.objects.disambiguate_prefix(prefix)?.ok_or_else(|| {
+            Error::from_error(gix_error::message!(
+                "Id could not be shortened as the object with id {} could not be found",
+                self.inner
+            ))
+        })
     }
 
     /// Turn this object id into a shortened id with a length in hex as configured by `core.abbrev`, or default
@@ -68,21 +70,6 @@ fn calculate_auto_hex_len(num_packed_objects: u64) -> usize {
     len.max(7) as usize
 }
 
-///
-pub mod shorten {
-    /// Returned by [`Id::prefix()`][super::Id::shorten()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        PackedObjectsCount(#[from] gix_odb::store::load_index::Error),
-        #[error(transparent)]
-        DisambiguatePrefix(#[from] gix_odb::store::prefix::disambiguate::Error),
-        #[error("Id could not be shortened as the object with id {} could not be found", .oid)]
-        NotFound { oid: gix_hash::ObjectId },
-    }
-}
-
 impl Deref for Id<'_> {
     type Target = oid;
 
diff --git a/gix/src/init.rs b/gix/src/init.rs
index 5c1992c110f..422df246593 100644
--- a/gix/src/init.rs
+++ b/gix/src/init.rs
@@ -1,17 +1,15 @@
 #![allow(clippy::result_large_err)]
 use std::path::Path;
 
+use gix_error::ErrorExt;
 use gix_ref::{
     Category, FullName,
     store::WriteReflog,
     transaction::{PreviousValue, RefEdit},
 };
 
-use crate::{
-    ThreadSafeRepository,
-    bstr::{BString, ByteSlice},
-    config::tree::Init,
-};
+use crate::{Result, ThreadSafeRepository, bstr::ByteSlice, config::tree::Init};
+use gix_error::ResultExt;
 
 /// The name of the branch to use if non is configured via git configuration.
 ///
@@ -20,25 +18,6 @@ use crate::{
 /// We use `main` instead of `master`.
 pub const DEFAULT_BRANCH_NAME: &str = "main";
 
-/// The error returned by [`crate::init()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Could not obtain the current directory")]
-    CurrentDir(#[from] std::io::Error),
-    #[error(transparent)]
-    Init(#[from] crate::create::Error),
-    #[error(transparent)]
-    Open(#[from] crate::open::Error),
-    #[error("Invalid default branch name: {name:?}")]
-    InvalidBranchName {
-        name: BString,
-        source: gix_validate::reference::name::Error,
-    },
-    #[error("Could not edit HEAD reference with new default name")]
-    EditHeadForDefaultBranch(#[from] crate::reference::edit::Error),
-}
-
 impl ThreadSafeRepository {
     /// Create a repository with work-tree within `directory`, creating intermediate directories as needed.
     ///
@@ -50,13 +29,14 @@ impl ThreadSafeRepository {
         directory: impl AsRef<Path>,
         kind: crate::create::Kind,
         options: crate::create::Options,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         use gix_sec::trust::DefaultForLevel;
         let open_options = crate::open::Options::default_for_level(gix_sec::Trust::Full);
         Self::init_opts(directory, kind, options, open_options)
     }
 
     /// Similar to [`init`][Self::init()], but allows to determine how exactly to open the newly created repository.
+    /// Invalid `init.defaultBranch` values include their bytes as `input` [metadata](gix_error::Error::metadata()).
     ///
     /// # Deviation
     ///
@@ -67,7 +47,7 @@ impl ThreadSafeRepository {
         kind: crate::create::Kind,
         create_options: crate::create::Options,
         mut open_options: crate::open::Options,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let (path, capabilities) = crate::create::into_with_capabilities(directory.as_ref(), kind, create_options)?;
         if !capabilities.symlink {
             open_options.api_config_overrides.push("core.symlinks=false".into());
@@ -75,7 +55,9 @@ impl ThreadSafeRepository {
         let (git_dir, worktree_dir) = path.into_repository_and_work_tree_directories();
         open_options.git_dir_trust = Some(gix_sec::Trust::Full);
         // The repo will use `core.precomposeUnicode` to adjust the value as needed.
-        open_options.current_dir = gix_fs::current_dir(false)?.into();
+        open_options.current_dir = gix_fs::current_dir(false)
+            .or_raise(|| gix_error::message("Could not obtain the current directory"))?
+            .into();
         let repo = ThreadSafeRepository::open_from_paths(git_dir, worktree_dir, open_options, None)?;
 
         let branch_name = repo
@@ -87,13 +69,16 @@ impl ThreadSafeRepository {
             let configured_branch_name = branch_name;
             let sym_ref: FullName = Category::LocalBranch
                 .to_full_name(configured_branch_name.as_bstr())
-                .map_err(|err| Error::InvalidBranchName {
-                    name: configured_branch_name.clone(),
-                    source: err,
+                .map_err(|err| {
+                    err.and_raise(
+                        gix_error::validation("Invalid default branch name")
+                            .with("input", configured_branch_name.clone()),
+                    )
                 })?;
-            gix_validate::reference::branch_name(sym_ref.as_bstr()).map_err(|err| Error::InvalidBranchName {
-                name: configured_branch_name,
-                source: err,
+            gix_validate::reference::branch_name(sym_ref.as_bstr()).map_err(|err| {
+                err.and_raise(
+                    gix_error::validation("Invalid default branch name").with("input", configured_branch_name),
+                )
             })?;
             let mut repo = repo.to_thread_local();
             let prev_write_reflog = repo.refs.write_reflog;
@@ -103,7 +88,8 @@ impl ThreadSafeRepository {
                 sym_ref,
                 PreviousValue::Any,
                 "",
-            ))?;
+            ))
+            .or_raise(|| gix_error::message("Could not edit HEAD reference with new default name"))?;
             repo.refs.write_reflog = prev_write_reflog;
         }
 
diff --git a/gix/src/lib.rs b/gix/src/lib.rs
index 77fab36e8a9..22f5501544c 100644
--- a/gix/src/lib.rs
+++ b/gix/src/lib.rs
@@ -163,7 +163,7 @@ pub use gix_validate as validate;
 pub use gix_zlib as zlib;
 pub use hash::{ObjectId, oid};
 
-pub use gix_error::{Error, Exn};
+pub use gix_error::{Error, Exn, ExnMessageResult, ExnResult, Result};
 
 pub mod interrupt;
 
@@ -255,26 +255,18 @@ pub mod merge;
 /// assert!(repo.workdir_path("this").expect("non-bare").is_file());
 /// # Ok(()) }
 /// ```
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn discover(directory: impl AsRef<std::path::Path>) -> Result<Repository, discover::Error> {
+pub fn discover(directory: impl AsRef<std::path::Path>) -> Result<Repository> {
     ThreadSafeRepository::discover(directory).map(Into::into)
 }
 
 /// Try to open a git repository in `directory` and search upwards through its parents until one is found,
 /// using `open_options` regardless of the trust level of the discovered repository.
 /// The detected trust level is retained, so repositories with reduced trust still restrict their behavior accordingly.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 pub fn discover_opts(
     directory: impl AsRef<std::path::Path>,
     options: discover::upwards::Options<'_>,
     open_options: open::Options,
-) -> Result<Repository, discover::Error> {
+) -> Result<Repository> {
     ThreadSafeRepository::discover_opts(
         directory,
         options,
@@ -289,24 +281,14 @@ pub fn discover_opts(
 /// Try to discover a git repository directly from the environment.
 ///
 /// For details, see [`ThreadSafeRepository::discover_with_environment_overrides_opts()`].
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn discover_with_environment_overrides(
-    directory: impl AsRef<std::path::Path>,
-) -> Result<Repository, discover::Error> {
+pub fn discover_with_environment_overrides(directory: impl AsRef<std::path::Path>) -> Result<Repository> {
     ThreadSafeRepository::discover_with_environment_overrides(directory).map(Into::into)
 }
 
 /// Try to open a git repository directly from the environment.
 ///
 /// See [`ThreadSafeRepository::open_with_environment_overrides()`].
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn open_with_environment_overrides(directory: impl Into<std::path::PathBuf>) -> Result<Repository, open::Error> {
+pub fn open_with_environment_overrides(directory: impl Into<std::path::PathBuf>) -> Result<Repository> {
     ThreadSafeRepository::open_with_environment_overrides(directory, Default::default()).map(Into::into)
 }
 
@@ -325,20 +307,12 @@ pub fn open_with_environment_overrides(directory: impl Into<std::path::PathBuf>)
 /// assert!(repo.head()?.is_unborn());
 /// # Ok(()) }
 /// ```
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn init(directory: impl AsRef<std::path::Path>) -> Result<Repository, init::Error> {
+pub fn init(directory: impl AsRef<std::path::Path>) -> Result<Repository> {
     ThreadSafeRepository::init(directory, create::Kind::WithWorktree, create::Options::default()).map(Into::into)
 }
 
 /// See [`ThreadSafeRepository::init()`], but returns a [`Repository`] instead.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn init_bare(directory: impl AsRef<std::path::Path>) -> Result<Repository, init::Error> {
+pub fn init_bare(directory: impl AsRef<std::path::Path>) -> Result<Repository> {
     ThreadSafeRepository::init(directory, create::Kind::Bare, create::Options::default()).map(Into::into)
 }
 
@@ -346,14 +320,7 @@ pub fn init_bare(directory: impl AsRef<std::path::Path>) -> Result<Repository, i
 /// amended with using configuration from the git installation to ensure all authentication options are honored).
 ///
 /// See [`clone::PrepareFetch::new()`] for a function to take full control over all options.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn prepare_clone_bare<Url, E>(
-    url: Url,
-    path: impl AsRef<std::path::Path>,
-) -> Result<clone::PrepareFetch, clone::Error>
+pub fn prepare_clone_bare<Url, E>(url: Url, path: impl AsRef<std::path::Path>) -> Result<clone::PrepareFetch>
 where
     Url: std::convert::TryInto<gix_url::Url, Error = E>,
     E: std::error::Error + Send + Sync + 'static,
@@ -371,11 +338,7 @@ where
 /// (but amended with using configuration from the git installation to ensure all authentication options are honored).
 ///
 /// See [`clone::PrepareFetch::new()`] for a function to take full control over all options.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
-pub fn prepare_clone<Url, E>(url: Url, path: impl AsRef<std::path::Path>) -> Result<clone::PrepareFetch, clone::Error>
+pub fn prepare_clone<Url, E>(url: Url, path: impl AsRef<std::path::Path>) -> Result<clone::PrepareFetch>
 where
     Url: std::convert::TryInto<gix_url::Url, Error = E>,
     E: std::error::Error + Send + Sync + 'static,
@@ -410,22 +373,14 @@ fn open_opts_with_git_binary_config() -> open::Options {
 /// assert_eq!(repo.head_commit()?.decode()?.message, "c2\n");
 /// # Ok(()) }
 /// ```
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 #[doc(alias = "git2")]
-pub fn open(directory: impl Into<std::path::PathBuf>) -> Result<Repository, open::Error> {
+pub fn open(directory: impl Into<std::path::PathBuf>) -> Result<Repository> {
     ThreadSafeRepository::open(directory).map(Into::into)
 }
 
 /// See [`ThreadSafeRepository::open_opts()`], but returns a [`Repository`] instead.
-#[expect(
-    clippy::result_large_err,
-    reason = "will be removed once `gix-error` is used consistently"
-)]
 #[doc(alias = "open_ext", alias = "git2")]
-pub fn open_opts(directory: impl Into<std::path::PathBuf>, options: open::Options) -> Result<Repository, open::Error> {
+pub fn open_opts(directory: impl Into<std::path::PathBuf>, options: open::Options) -> Result<Repository> {
     ThreadSafeRepository::open_opts(directory, options).map(Into::into)
 }
 
@@ -433,7 +388,7 @@ pub fn open_opts(directory: impl Into<std::path::PathBuf>, options: open::Option
 ///
 /// `git_dir` supplies context for `includeIf.gitdir` conditions and does not have to exist. Without it, these
 /// conditions aren't matched. Repository-local and branch-dependent configuration isn't available at this stage.
-pub fn config(git_dir: Option<&std::path::Path>, options: &open::Options) -> Result<config::File, config::Error> {
+pub fn config(git_dir: Option<&std::path::Path>, options: &open::Options) -> Result<config::File> {
     let environment = options.permissions.env;
     let git_install_dir = path::install_dir().ok();
     let home = gix_path::env::home_dir().and_then(|home| environment.home.check_opt(home));
@@ -469,17 +424,18 @@ pub fn config(git_dir: Option<&std::path::Path>, options: &open::Options) -> Res
 /// Use this to inspect, prepare or load the file before calling [`config_mut()`]. The file and its parent directories
 /// do not have to exist. No configuration transaction is opened, no lock is acquired, and no directories are created.
 /// Discovering the Git installation path, or the system path on Windows, may invoke Git.
-pub fn config_path(
-    source: config::Source,
-    options: &open::Options,
-) -> Result<std::path::PathBuf, config::file_mut::Error> {
-    use config::file_mut::Error;
+pub fn config_path(source: config::Source, options: &open::Options) -> Result<std::path::PathBuf> {
+    use gix_error::{ErrorExt, ResultExt, message};
 
     if !matches!(
         source,
         config::Source::GitInstallation | config::Source::System | config::Source::Git | config::Source::User
     ) {
-        return Err(Error::UnsupportedSource(source));
+        return Err(
+            message!("Configuration source {source:?} requires a repository or has no physical file")
+                .raise()
+                .into(),
+        );
     }
     let path = config::cache::source_path(
         source,
@@ -488,11 +444,13 @@ pub fn config_path(
         options.permissions.config,
         &mut config::Cache::make_source_env(options.permissions.env),
     )
-    .ok_or(Error::SourceUnavailable(source))?;
+    .ok_or_else(|| message!("Configuration source {source:?} has no available path with these options").raise())?;
     Ok(if path.is_absolute() {
         path
     } else {
-        std::env::current_dir().map_err(Error::CurrentDir)?.join(path)
+        std::env::current_dir()
+            .or_raise(|| message("Could not obtain the current directory for a relative configuration path"))?
+            .join(path)
     })
 }
 
@@ -513,16 +471,15 @@ pub fn config_path(
 /// ```no_run
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// let mut file = gix::config_mut(gix::config::Source::User, &gix::open::Options::default())?;
-/// file.set_raw_value("user.name", "Ada Lovelace")?;
+/// file.set_raw_value("user.name", "Ada Lovelace").map_err(|err| err.into_error())?;
 /// file.commit()?;
 /// # Ok(()) }
 /// ```
-pub fn config_mut(
-    source: config::Source,
-    options: &open::Options,
-) -> Result<config::FileTransaction, config::file_mut::Error> {
+pub fn config_mut(source: config::Source, options: &open::Options) -> Result<config::FileTransaction> {
+    use gix_error::{ResultExt, message};
+
     let path = config_path(source, options)?;
-    let resolved = config(None, options)?;
+    let resolved = config(None, options).or_raise(|| message("Could not load global configuration"))?;
     let filter = options.filter_config_section.unwrap_or(config::section::is_trusted);
     let lock_mode = config::cache::access::config_lock_timeout(&resolved, options.lenient_config, filter)?;
     let shared_repository_permissions = config::file_mut::shared_repository_permissions(&resolved, filter)?;
diff --git a/gix/src/mailmap.rs b/gix/src/mailmap.rs
index fcc78c0c1a0..5a8acac1a20 100644
--- a/gix/src/mailmap.rs
+++ b/gix/src/mailmap.rs
@@ -1,18 +1 @@
 pub use gix_mailmap::*;
-
-///
-pub mod load {
-    /// The error returned by [`crate::Repository::open_mailmap_into()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The mailmap file declared in `mailmap.file` could not be read")]
-        Io(#[from] std::io::Error),
-        #[error("The configured mailmap.blob could not be parsed")]
-        BlobSpec(#[from] crate::revision::spec::parse::single::Error),
-        #[error(transparent)]
-        PathInterpolate(#[from] gix_config::path::interpolate::Error),
-        #[error("Could not find object configured in `mailmap.blob`")]
-        FindExisting(#[from] crate::object::find::existing::Error),
-    }
-}
diff --git a/gix/src/note.rs b/gix/src/note.rs
index b94e6b008da..c6ae8020f12 100644
--- a/gix/src/note.rs
+++ b/gix/src/note.rs
@@ -8,7 +8,7 @@ pub use gix_note as plumbing;
 use gix_error::{ErrorExt, ResultExt, message};
 
 use crate::{
-    Blob, Id, Repository,
+    Blob, ExnResult, Id, Repository, Result,
     bstr::{BStr, BString, ByteSlice, ByteVec},
     config::tree::{Core, Key, Notes},
     ext::ObjectIdExt,
@@ -45,7 +45,7 @@ struct EditRoot {
 }
 
 impl<'repo> Platform<'repo> {
-    pub(crate) fn new(repo: &'repo Repository) -> Result<Self, crate::Error> {
+    pub(crate) fn new(repo: &'repo Repository) -> Result<Self> {
         let config = repo.config_snapshot();
         let value = config
             .string(Core::NOTES_REF)
@@ -85,7 +85,7 @@ impl Platform<'_> {
     /// glob pattern. An item containing `*`, `?`, or `[` is treated as a glob and expanded against
     /// existing references. A literal reference may be absent and is then treated as containing no
     /// notes. Duplicate references are ignored and the resulting order is preserved.
-    pub fn with_refs(mut self, refs: impl IntoIterator<Item = impl Into<BString>>) -> Result<Self, crate::Error> {
+    pub fn with_refs(mut self, refs: impl IntoIterator<Item = impl Into<BString>>) -> Result<Self> {
         let mut selected = Vec::new();
         for pattern in refs {
             let pattern = pattern.into();
@@ -133,7 +133,7 @@ impl<'repo> Platform<'repo> {
     pub fn get<'platform>(
         &'platform mut self,
         object: impl Into<gix_hash::ObjectId>,
-    ) -> Result<Vec<Note<'platform, 'repo>>, crate::Error> {
+    ) -> Result<Vec<Note<'platform, 'repo>>> {
         let annotated_object_id = object.into();
         let mut out = Vec::new();
         let repo = self.repo;
@@ -170,7 +170,7 @@ impl<'repo> Platform<'repo> {
         notes_ref: N,
         object: impl Into<gix_hash::ObjectId>,
         data: impl AsRef<[u8]>,
-    ) -> Result<Option<Id<'repo>>, crate::Error>
+    ) -> Result<Option<Id<'repo>>>
     where
         N: TryInto<PartialName>,
         N::Error: std::error::Error + Send + Sync + 'static,
@@ -191,7 +191,7 @@ impl<'repo> Platform<'repo> {
         notes_ref: &gix_ref::FullNameRef,
         object: impl Into<gix_hash::ObjectId>,
         data: impl AsRef<[u8]>,
-    ) -> Result<Option<Id<'repo>>, crate::Error> {
+    ) -> Result<Option<Id<'repo>>> {
         let EditRoot {
             root_tree_id,
             parent_commit_id,
@@ -226,11 +226,7 @@ impl<'repo> Platform<'repo> {
     ///   preserved. Removing the last note from an existing reference retains it, pointing to
     ///   a new commit with an empty tree.
     /// * `object` identifies the Git object whose note should be removed.
-    pub fn remove<N>(
-        &mut self,
-        notes_ref: N,
-        object: impl Into<gix_hash::ObjectId>,
-    ) -> Result<Option<Id<'repo>>, crate::Error>
+    pub fn remove<N>(&mut self, notes_ref: N, object: impl Into<gix_hash::ObjectId>) -> Result<Option<Id<'repo>>>
     where
         N: TryInto<PartialName>,
         N::Error: std::error::Error + Send + Sync + 'static,
@@ -257,7 +253,7 @@ impl<'repo> Platform<'repo> {
     }
 
     /// Return the notes tree and commit to edit, and the direct reference to update.
-    fn lookup_edit_root(&self, notes_ref: &gix_ref::FullNameRef) -> Result<EditRoot, crate::Error> {
+    fn lookup_edit_root(&self, notes_ref: &gix_ref::FullNameRef) -> Result<EditRoot> {
         match self
             .repo
             .try_find_reference(notes_ref)
@@ -300,7 +296,7 @@ impl<'repo> Platform<'repo> {
         parent_commit_id: Option<gix_hash::ObjectId>,
         edit: gix_note::Edit,
         default_message: &str,
-    ) -> Result<(), crate::Error> {
+    ) -> Result<()> {
         let message = self.commit_message.as_deref().unwrap_or(default_message);
         let commit = self
             .repo
@@ -326,7 +322,7 @@ fn state_for<'a>(
     states: &'a mut Vec<gix_note::State>,
     root_tree_id: gix_hash::ObjectId,
     repo: &Repository,
-) -> Result<&'a mut gix_note::State, crate::Error> {
+) -> Result<&'a mut gix_note::State> {
     if let Some(index) = states.iter().position(|state| state.root_tree_id() == root_tree_id) {
         return Ok(&mut states[index]);
     }
@@ -355,7 +351,7 @@ impl Root {
         }
     }
 
-    fn tree_id(&mut self, repo: &Repository) -> Result<Option<gix_hash::ObjectId>, crate::Error> {
+    fn tree_id(&mut self, repo: &Repository) -> Result<Option<gix_hash::ObjectId>> {
         if let Some(root_tree_id) = self.tree_id {
             return Ok(root_tree_id);
         }
@@ -378,7 +374,7 @@ impl Root {
     }
 }
 
-fn add_refs(repo: &Repository, pattern: &BStr, out: &mut Vec<FullName>) -> Result<(), crate::Error> {
+fn add_refs(repo: &Repository, pattern: &BStr, out: &mut Vec<FullName>) -> Result<()> {
     let mut push_unique = |reference| {
         if !out.contains(&reference) {
             out.push(reference);
@@ -400,9 +396,7 @@ fn add_refs(repo: &Repository, pattern: &BStr, out: &mut Vec<FullName>) -> Resul
             .all()
             .or_raise(|| message!("Could not iterate notes references matching {pattern}"))?;
         for reference in references {
-            let reference = reference
-                .map_err(gix_error::Error::from_boxed)
-                .or_raise(|| message!("Could not read notes reference matching {pattern}"))?;
+            let reference = reference.or_raise(|| message!("Could not read notes reference matching {pattern}"))?;
             if parsed.matches(reference.name().as_bstr(), gix_glob::wildmatch::Mode::empty()) {
                 push_unique(reference.inner.name);
             }
@@ -416,7 +410,7 @@ fn add_refs(repo: &Repository, pattern: &BStr, out: &mut Vec<FullName>) -> Resul
     Ok(())
 }
 
-fn expand_notes_ref(name: &PartialNameRef) -> Result<Cow<'_, FullNameRef>, gix_error::Exn<gix_ref::name::Error>> {
+fn expand_notes_ref(name: &PartialNameRef) -> ExnResult<Cow<'_, FullNameRef>, gix_ref::name::Error> {
     let name = name.as_bstr();
     if name.starts_with_str("refs/notes/") {
         return Ok(Cow::Borrowed(name.try_into()?));
diff --git a/gix/src/object/blob.rs b/gix/src/object/blob.rs
index 17860f16fdc..b0fa307f740 100644
--- a/gix/src/object/blob.rs
+++ b/gix/src/object/blob.rs
@@ -4,8 +4,10 @@ use crate::{Blob, ObjectDetached};
 #[cfg(feature = "blob-diff")]
 pub mod diff {
     use gix_diff::blob::platform::prepare_diff::Operation;
+    use gix_error::ExnMessageResult;
+    use gix_error::ResultExt;
 
-    use crate::bstr::ByteSlice;
+    use crate::{Error, Result, bstr::ByteSlice};
 
     /// A platform to keep temporary information to perform line diffs on modified blobs.
     ///
@@ -14,29 +16,10 @@ pub mod diff {
         pub resource_cache: &'a mut gix_diff::blob::Platform,
     }
 
-    ///
-    pub mod init {
-        /// The error returned by [`object::tree::diff::Change::diff`](crate::object::tree::diff::Change::diff()).
-        pub type Error = gix_diff::blob::platform::set_resource::Error;
-    }
-
     ///
     pub mod lines {
         use crate::bstr::BStr;
 
-        /// The error returned by [Platform::lines()](super::Platform::lines()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error<E>
-        where
-            E: std::error::Error + Send + Sync + 'static,
-        {
-            #[error(transparent)]
-            ProcessHunk(E),
-            #[error(transparent)]
-            PrepareDiff(#[from] gix_diff::blob::platform::prepare_diff::Error),
-        }
-
         /// A change to a hunk of lines.
         pub enum Change<'a, 'data> {
             /// Lines were added.
@@ -68,14 +51,14 @@ pub mod diff {
         pub fn lines<FnH, E>(
             &mut self,
             mut process_hunk: FnH,
-        ) -> Result<gix_diff::blob::platform::prepare_diff::Outcome<'_>, lines::Error<E>>
+        ) -> Result<gix_diff::blob::platform::prepare_diff::Outcome<'_>>
         where
-            FnH: FnMut(lines::Change<'_, '_>) -> Result<(), E>,
+            FnH: FnMut(lines::Change<'_, '_>) -> std::result::Result<(), E>,
             E: std::error::Error + Send + Sync + 'static,
         {
             self.resource_cache.options.skip_internal_diff_if_external_is_configured = false;
 
-            let prep = self.resource_cache.prepare_diff()?;
+            let prep = self.resource_cache.prepare_diff().or_erased()?;
             match prep.operation {
                 Operation::InternalDiff { algorithm } => {
                     let input = prep.interned_input();
@@ -117,7 +100,7 @@ pub mod diff {
                     }
 
                     if let Some(err) = err {
-                        return Err(lines::Error::ProcessHunk(err));
+                        return Err(Error::from_error(err));
                     }
                 }
                 Operation::ExternalCommand { .. } => {
@@ -130,9 +113,7 @@ pub mod diff {
 
         /// Count the amount of removed and inserted lines efficiently.
         /// Note that nothing will happen if one of the inputs is binary, and `None` will be returned.
-        pub fn line_counts(
-            &mut self,
-        ) -> Result<Option<gix_diff::blob::DiffLineStats>, gix_diff::blob::platform::prepare_diff::Error> {
+        pub fn line_counts(&mut self) -> ExnMessageResult<Option<gix_diff::blob::DiffLineStats>> {
             self.resource_cache.options.skip_internal_diff_if_external_is_configured = false;
 
             let prep = self.resource_cache.prepare_diff()?;
diff --git a/gix/src/object/commit.rs b/gix/src/object/commit.rs
index 880345c8925..199ee9e9b7f 100644
--- a/gix/src/object/commit.rs
+++ b/gix/src/object/commit.rs
@@ -1,26 +1,6 @@
-use crate::{Commit, ObjectDetached, Tree, bstr, bstr::BStr};
-
-mod error {
-    use crate::object;
-
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        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::Error),
-        #[error("Expected object of type {}, but got {}", .expected, .actual)]
-        ObjectKind {
-            expected: gix_object::Kind,
-            actual: gix_object::Kind,
-        },
-    }
-}
-
-pub use error::Error;
+use crate::{Commit, ObjectDetached, Result, Tree, bstr, bstr::BStr};
+use gix_error::ExnMessageResult;
+use gix_error::ResultExt;
 
 /// Remove Lifetime
 impl Commit<'_> {
@@ -63,13 +43,13 @@ impl<'repo> Commit<'repo> {
     /// assert_eq!(short_id.to_string(), "3189cd3");
     /// # Ok(()) }
     /// ```
-    pub fn short_id(&self) -> Result<gix_hash::Prefix, crate::id::shorten::Error> {
+    pub fn short_id(&self) -> Result<gix_hash::Prefix> {
         use crate::ext::ObjectIdExt;
         self.id.attach(self.repo).shorten()
     }
 
     /// Parse the commits message into a [`MessageRef`][gix_object::commit::MessageRef]
-    pub fn message(&self) -> Result<gix_object::commit::MessageRef<'_>, gix_object::decode::Error> {
+    pub fn message(&self) -> ExnMessageResult<gix_object::commit::MessageRef<'_>> {
         Ok(gix_object::commit::MessageRef::from_bytes(self.message_raw()?))
     }
     /// Decode the commit object until the message and return it.
@@ -85,7 +65,7 @@ impl<'repo> Commit<'repo> {
     /// assert_eq!(commit.message_raw()?, "c2\n");
     /// # Ok(()) }
     /// ```
-    pub fn message_raw(&self) -> Result<&'_ BStr, gix_object::decode::Error> {
+    pub fn message_raw(&self) -> ExnMessageResult<&'_ BStr> {
         gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind()).message()
     }
     /// Obtain the message by using intricate knowledge about the encoding, which is fastest and
@@ -102,8 +82,12 @@ impl<'repo> Commit<'repo> {
     /// Decode the commit and obtain the time at which the commit was created.
     ///
     /// For the time at which it was authored, refer to `.author()?.time()`.
-    pub fn time(&self) -> Result<gix_date::Time, Error> {
-        Ok(self.committer()?.time()?)
+    pub fn time(&self) -> Result<gix_date::Time> {
+        self.committer()
+            .or_raise(|| gix_error::message("The commit could not be decoded fully or partially"))?
+            .time()
+            .or_raise(|| gix_error::message("The commit date could not be parsed"))
+            .map_err(Into::into)
     }
 
     /// Decode the entire commit object and return it for accessing all commit information.
@@ -113,7 +97,7 @@ impl<'repo> Commit<'repo> {
     /// Note that the returned commit object does make lookup easy and should be
     /// used for successive calls to string-ish information to avoid decoding the object
     /// more than once.
-    pub fn decode(&self) -> Result<gix_object::CommitRef<'_>, gix_object::decode::Error> {
+    pub fn decode(&self) -> ExnMessageResult<gix_object::CommitRef<'_>> {
         gix_object::CommitRef::from_bytes(&self.data, self.id.kind())
     }
 
@@ -123,14 +107,14 @@ impl<'repo> Commit<'repo> {
     }
 
     /// Return the commits author, with surrounding whitespace trimmed.
-    pub fn author(&self) -> Result<gix_actor::SignatureRef<'_>, gix_object::decode::Error> {
+    pub fn author(&self) -> ExnMessageResult<gix_actor::SignatureRef<'_>> {
         gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .author()
             .map(|s| s.trim())
     }
 
     /// Return the commits committer. with surrounding whitespace trimmed.
-    pub fn committer(&self) -> Result<gix_actor::SignatureRef<'_>, gix_object::decode::Error> {
+    pub fn committer(&self) -> ExnMessageResult<gix_actor::SignatureRef<'_>> {
         gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .committer()
             .map(|s| s.trim())
@@ -173,15 +157,12 @@ impl<'repo> Commit<'repo> {
     /// assert_eq!(tree.id, repo.head_tree_id()?);
     /// # Ok(()) }
     /// ```
-    pub fn tree(&self) -> Result<Tree<'repo>, Error> {
-        match self.tree_id()?.object()?.try_into_tree() {
-            Ok(tree) => Ok(tree),
-            Err(crate::object::try_into::Error { actual, expected, .. }) => Err(Error::ObjectKind { actual, expected }),
-        }
+    pub fn tree(&self) -> Result<Tree<'repo>> {
+        Ok(self.tree_id().or_erased()?.object()?.try_into_tree().or_erased()?)
     }
 
     /// Parse the commit and return the tree id it points to.
-    pub fn tree_id(&self) -> Result<crate::Id<'repo>, gix_object::decode::Error> {
+    pub fn tree_id(&self) -> ExnMessageResult<crate::Id<'repo>> {
         gix_object::CommitRefIter::from_bytes(&self.data, self.id.kind())
             .tree_id()
             .map(|id| crate::Id::from_id(id, self.repo))
@@ -216,8 +197,7 @@ impl<'repo> Commit<'repo> {
     // TODO: make it possible to verify the signature, probably by wrapping `SignedData`. It's quite some work to do it properly.
     pub fn signature(
         &self,
-    ) -> Result<Option<(std::borrow::Cow<'_, BStr>, gix_object::signature::SignedData<'_>)>, gix_object::decode::Error>
-    {
+    ) -> ExnMessageResult<Option<(std::borrow::Cow<'_, BStr>, gix_object::signature::SignedData<'_>)>> {
         gix_object::CommitRefIter::signature(&self.data, self.id.kind())
     }
 
@@ -228,7 +208,7 @@ impl<'repo> Commit<'repo> {
     /// signer identity, and verifier output. A successful call does not necessarily mean that the signature is valid;
     /// use [`Outcome::is_valid()`](crate::commit::verify::Outcome::is_valid) to determine whether Git would accept it.
     #[cfg(feature = "command")]
-    pub fn verify_signature(&self) -> Result<Option<crate::commit::verify::Outcome>, crate::commit::verify::Error> {
+    pub fn verify_signature(&self) -> Result<Option<crate::commit::verify::Outcome>> {
         crate::commit::verify::verify(self)
     }
 
@@ -237,7 +217,7 @@ impl<'repo> Commit<'repo> {
     ///
     /// An existing signature for the repository's object format is replaced.
     #[cfg(feature = "command")]
-    pub fn signed(&self) -> Result<Commit<'repo>, crate::commit::sign::Error> {
+    pub fn signed(&self) -> Result<Commit<'repo>> {
         crate::commit::sign::sign(self)
     }
 }
diff --git a/gix/src/object/errors.rs b/gix/src/object/errors.rs
index b8f352bac5b..e3753121b53 100644
--- a/gix/src/object/errors.rs
+++ b/gix/src/object/errors.rs
@@ -1,50 +1,3 @@
-///
-pub mod conversion {
-
-    /// The error returned by [`crate::object::try_to_()`][crate::Object::try_to_commit_ref()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Decode(#[from] gix_object::decode::Error),
-        #[error("Expected object type {}, but got {}", .expected, .actual)]
-        UnexpectedType {
-            expected: gix_object::Kind,
-            actual: gix_object::Kind,
-        },
-    }
-}
-
-///
-pub mod find {
-    /// Indicate that an error occurred when trying to find an object.
-    #[derive(Debug, thiserror::Error)]
-    #[error(transparent)]
-    pub struct Error(#[from] pub gix_object::find::Error);
-
-    ///
-    pub mod existing {
-        /// An object could not be found in the database, or an error occurred when trying to obtain it.
-        pub type Error = gix_object::find::existing::Error;
-        ///
-        pub mod with_conversion {
-            /// The error returned by [Repository::find_commit()](crate::Repository::find_commit).
-            #[derive(Debug, thiserror::Error)]
-            #[expect(missing_docs)]
-            pub enum Error {
-                #[error(transparent)]
-                Find(#[from] crate::object::find::existing::Error),
-                #[error(transparent)]
-                Convert(#[from] crate::object::try_into::Error),
-            }
-        }
-    }
-}
-
-///
-pub mod write {
-    /// An error to indicate writing to the loose object store failed.
-    #[derive(Debug, thiserror::Error)]
-    #[error(transparent)]
-    pub struct Error(#[from] pub gix_object::write::Error);
+pub(crate) fn existing_error(err: gix_error::Exn) -> gix_error::Error {
+    err.into_error()
 }
diff --git a/gix/src/object/mod.rs b/gix/src/object/mod.rs
index 34d31f4c868..8b88dfda041 100644
--- a/gix/src/object/mod.rs
+++ b/gix/src/object/mod.rs
@@ -1,15 +1,19 @@
 //!
 #![allow(clippy::empty_docs)]
+use gix_error::ExnMessageResult;
+use gix_error::{ErrorExt, ResultExt};
+
 use gix_hash::ObjectId;
 pub use gix_object::Kind;
 
-use crate::{Blob, Commit, Id, Object, ObjectDetached, Tag, Tree};
+use crate::{Blob, Commit, Error, Id, Object, ObjectDetached, Result, Tag, Tree};
 
 mod errors;
 pub(crate) mod cache {
     pub use gix_pack::cache::object::MemoryCappedHashmap;
 }
-pub use errors::{conversion, find, write};
+pub(crate) use errors::existing_error;
+
 ///
 pub mod blob;
 ///
@@ -20,18 +24,6 @@ mod tag;
 ///
 pub mod tree;
 
-///
-pub mod try_into {
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    #[error("Object named {id} was supposed to be of kind {expected}, but was kind {actual}.")]
-    pub struct Error {
-        pub actual: gix_object::Kind,
-        pub expected: gix_object::Kind,
-        pub id: gix_hash::ObjectId,
-    }
-}
-
 impl ObjectDetached {
     /// Infuse this owned object with `repo` access.
     pub fn attach(self, repo: &crate::Repository) -> Object<'_> {
@@ -106,38 +98,54 @@ impl<'repo> Object<'repo> {
     }
 
     /// Transform this object into a commit, or return it as part of the `Err` if it is no commit.
-    pub fn try_into_commit(self) -> Result<Commit<'repo>, try_into::Error> {
-        self.try_into().map_err(|this: Self| try_into::Error {
-            id: this.id,
-            actual: this.kind,
-            expected: gix_object::Kind::Commit,
+    pub fn try_into_commit(self) -> ExnMessageResult<Commit<'repo>> {
+        self.try_into().map_err(|this: Self| {
+            gix_error::validation(format!(
+                "Object named {} was supposed to be of kind {}, but was kind {}.",
+                this.id,
+                gix_object::Kind::Commit,
+                this.kind
+            ))
+            .raise()
         })
     }
 
     /// Transform this object into a tag, or return it as part of the `Err` if it is no commit.
-    pub fn try_into_tag(self) -> Result<Tag<'repo>, try_into::Error> {
-        self.try_into().map_err(|this: Self| try_into::Error {
-            id: this.id,
-            actual: this.kind,
-            expected: gix_object::Kind::Commit,
+    pub fn try_into_tag(self) -> ExnMessageResult<Tag<'repo>> {
+        self.try_into().map_err(|this: Self| {
+            gix_error::validation(format!(
+                "Object named {} was supposed to be of kind {}, but was kind {}.",
+                this.id,
+                gix_object::Kind::Tag,
+                this.kind
+            ))
+            .raise()
         })
     }
 
     /// Transform this object into a tree, or return it as part of the `Err` if it is no tree.
-    pub fn try_into_tree(self) -> Result<Tree<'repo>, try_into::Error> {
-        self.try_into().map_err(|this: Self| try_into::Error {
-            id: this.id,
-            actual: this.kind,
-            expected: gix_object::Kind::Tree,
+    pub fn try_into_tree(self) -> ExnMessageResult<Tree<'repo>> {
+        self.try_into().map_err(|this: Self| {
+            gix_error::validation(format!(
+                "Object named {} was supposed to be of kind {}, but was kind {}.",
+                this.id,
+                gix_object::Kind::Tree,
+                this.kind
+            ))
+            .raise()
         })
     }
 
     /// Transform this object into a blob, or return it as part of the `Err` if it is no blob.
-    pub fn try_into_blob(self) -> Result<Blob<'repo>, try_into::Error> {
-        self.try_into().map_err(|this: Self| try_into::Error {
-            id: this.id,
-            actual: this.kind,
-            expected: gix_object::Kind::Blob,
+    pub fn try_into_blob(self) -> ExnMessageResult<Blob<'repo>> {
+        self.try_into().map_err(|this: Self| {
+            gix_error::validation(format!(
+                "Object named {} was supposed to be of kind {}, but was kind {}.",
+                this.id,
+                gix_object::Kind::Blob,
+                this.kind
+            ))
+            .raise()
         })
     }
 }
@@ -171,13 +179,17 @@ impl<'repo> Object<'repo> {
     }
 
     /// Obtain a fully parsed commit whose fields reference our data buffer.
-    pub fn try_to_commit_ref(&self) -> Result<gix_object::CommitRef<'_>, conversion::Error> {
+    pub fn try_to_commit_ref(&self) -> Result<gix_object::CommitRef<'_>> {
         gix_object::Data::new(&self.data, self.kind, self.id.kind())
-            .decode()?
+            .decode()
+            .or_erased()?
             .into_commit()
-            .ok_or(conversion::Error::UnexpectedType {
-                expected: gix_object::Kind::Commit,
-                actual: self.kind,
+            .ok_or_else(|| {
+                Error::from_error(gix_error::validation(format!(
+                    "Expected object type {}, but got {}",
+                    gix_object::Kind::Commit,
+                    self.kind
+                )))
             })
     }
 
@@ -228,13 +240,17 @@ impl<'repo> Object<'repo> {
     }
 
     /// Obtain a fully parsed tag object whose fields reference our data buffer.
-    pub fn try_to_tag_ref(&self) -> Result<gix_object::TagRef<'_>, conversion::Error> {
+    pub fn try_to_tag_ref(&self) -> Result<gix_object::TagRef<'_>> {
         gix_object::Data::new(&self.data, self.kind, self.id.kind())
-            .decode()?
+            .decode()
+            .or_erased()?
             .into_tag()
-            .ok_or(conversion::Error::UnexpectedType {
-                expected: gix_object::Kind::Tag,
-                actual: self.kind,
+            .ok_or_else(|| {
+                Error::from_error(gix_error::validation(format!(
+                    "Expected object type {}, but got {}",
+                    gix_object::Kind::Tag,
+                    self.kind
+                )))
             })
     }
 
diff --git a/gix/src/object/peel.rs b/gix/src/object/peel.rs
index 3156688d3a3..e69793a0548 100644
--- a/gix/src/object/peel.rs
+++ b/gix/src/object/peel.rs
@@ -1,32 +1,6 @@
 //!
 #![allow(clippy::empty_docs)]
-use crate::{
-    Commit, Object, Tree, object,
-    object::{Kind, peel},
-};
-
-///
-pub mod to_kind {
-    mod error {
-
-        use crate::object;
-
-        /// The error returned by [`Object::peel_to_kind()`][crate::Object::peel_to_kind()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            FindExistingObject(#[from] object::find::existing::Error),
-            #[error("Last encountered object {oid} was {actual} while trying to peel to {expected}")]
-            NotFound {
-                oid: gix_hash::Prefix,
-                actual: object::Kind,
-                expected: object::Kind,
-            },
-        }
-    }
-    pub use error::Error;
-}
+use crate::{Commit, Error, Object, Result, Tree, object::Kind};
 
 impl<'repo> Object<'repo> {
     // TODO: tests
@@ -34,7 +8,7 @@ impl<'repo> Object<'repo> {
     ///
     /// Note that this object doesn't necessarily have to be the end of the chain.
     /// Typical values are [`Kind::Commit`] or [`Kind::Tree`].
-    pub fn peel_to_kind(mut self, kind: Kind) -> Result<Self, peel::to_kind::Error> {
+    pub fn peel_to_kind(mut self, kind: Kind) -> Result<Self> {
         loop {
             match self.kind {
                 our_kind if kind == our_kind => {
@@ -57,11 +31,11 @@ impl<'repo> Object<'repo> {
                     self = repo.find_object(target_id)?;
                 }
                 Kind::Tree | Kind::Blob => {
-                    return Err(peel::to_kind::Error::NotFound {
-                        oid: self.id().shorten().unwrap_or_else(|_| self.id.into()),
-                        actual: self.kind,
-                        expected: kind,
-                    });
+                    return Err(Error::from_error(gix_error::validation(format!(
+                        "Last encountered object {} was {} while trying to peel to {kind}",
+                        self.id().shorten().unwrap_or_else(|_| self.id.into()),
+                        self.kind,
+                    ))));
                 }
             }
         }
@@ -70,14 +44,14 @@ impl<'repo> Object<'repo> {
     /// Peel this object into a tree and return it, if this is possible.
     ///
     /// This will follow tag objects and commits until their tree is reached.
-    pub fn peel_to_tree(self) -> Result<Tree<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_tree(self) -> Result<Tree<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Tree)?.into_tree())
     }
 
     /// Peel this object into a commit and return it, if this is possible.
     ///
     /// This will follow tag objects until a commit is reached.
-    pub fn peel_to_commit(self) -> Result<Commit<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_commit(self) -> Result<Commit<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Commit)?.into_commit())
     }
 
@@ -86,7 +60,7 @@ impl<'repo> Object<'repo> {
     ///
     /// Note that this method is different from [`peel_to_kind(…)`][Object::peel_to_kind()] as it won't
     /// peel commits to their tree, but handles tags only.
-    pub fn peel_tags_to_end(mut self) -> Result<Self, object::find::existing::Error> {
+    pub fn peel_tags_to_end(mut self) -> Result<Self> {
         loop {
             match self.kind {
                 Kind::Commit | Kind::Tree | Kind::Blob => break Ok(self),
diff --git a/gix/src/object/tag.rs b/gix/src/object/tag.rs
index df7da2bb50d..1b2f86b0cbb 100644
--- a/gix/src/object/tag.rs
+++ b/gix/src/object/tag.rs
@@ -1,4 +1,5 @@
 use crate::{ObjectDetached, Tag, ext::ObjectIdExt};
+use gix_error::ExnMessageResult;
 
 impl<'repo> Tag<'repo> {
     /// Decode the entire tag object and return it for accessing all tag information.
@@ -8,19 +9,19 @@ impl<'repo> Tag<'repo> {
     /// Note that the returned commit object does make lookup easy and should be
     /// used for successive calls to string-ish information to avoid decoding the object
     /// more than once.
-    pub fn decode(&self) -> Result<gix_object::TagRef<'_>, gix_object::decode::Error> {
+    pub fn decode(&self) -> ExnMessageResult<gix_object::TagRef<'_>> {
         gix_object::TagRef::from_bytes(&self.data, self.id.kind())
     }
 
     /// Decode this tag partially and return the id of its target.
-    pub fn target_id(&self) -> Result<crate::Id<'repo>, gix_object::decode::Error> {
+    pub fn target_id(&self) -> ExnMessageResult<crate::Id<'repo>> {
         gix_object::TagRefIter::from_bytes(&self.data, self.id.kind())
             .target_id()
             .map(|id| id.attach(self.repo))
     }
 
     /// Decode this tag partially and return the tagger, if the field exists.
-    pub fn tagger(&self) -> Result<Option<gix_actor::SignatureRef<'_>>, gix_object::decode::Error> {
+    pub fn tagger(&self) -> ExnMessageResult<Option<gix_actor::SignatureRef<'_>>> {
         gix_object::TagRefIter::from_bytes(&self.data, self.id.kind()).tagger()
     }
 }
diff --git a/gix/src/object/tree/diff/change.rs b/gix/src/object/tree/diff/change.rs
index fee7c827a2a..184594d68ef 100644
--- a/gix/src/object/tree/diff/change.rs
+++ b/gix/src/object/tree/diff/change.rs
@@ -1,6 +1,6 @@
 use super::ChangeDetached;
 use crate::{
-    Repository,
+    Repository, Result,
     bstr::{BStr, ByteSlice},
     ext::ObjectIdExt,
     object::tree::diff::Change,
@@ -20,7 +20,7 @@ impl Change<'_, '_, '_> {
     pub fn diff<'b>(
         &self,
         resource_cache: &'b mut gix_diff::blob::Platform,
-    ) -> Result<crate::object::blob::diff::Platform<'b>, crate::object::blob::diff::init::Error> {
+    ) -> Result<crate::object::blob::diff::Platform<'b>> {
         resource_cache.set_resource_by_change((*self).into(), &self.id().repo.objects)?;
         Ok(crate::object::blob::diff::Platform { resource_cache })
     }
diff --git a/gix/src/object/tree/diff/for_each.rs b/gix/src/object/tree/diff/for_each.rs
index 43ae7b0f34a..bbcc0f9489e 100644
--- a/gix/src/object/tree/diff/for_each.rs
+++ b/gix/src/object/tree/diff/for_each.rs
@@ -1,21 +1,8 @@
+use gix_error::ResultExt;
 use gix_object::TreeRefIter;
 
 use super::{Action, Change, Platform};
-use crate::{Tree, diff::rewrites::tracker};
-
-/// The error return by methods on the [diff platform][Platform].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Diff(#[from] gix_diff::tree_with_rewrites::Error),
-    #[error("The user-provided callback failed")]
-    ForEach(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error(transparent)]
-    ResourceCache(#[from] crate::repository::diff_resource_cache::Error),
-    #[error("Failure during rename tracking")]
-    RenameTracking(#[from] tracker::emit::Error),
-}
+use crate::{ExnResult, Result, Tree};
 
 /// Add the item to compare to.
 impl<'old> Platform<'_, 'old> {
@@ -23,14 +10,11 @@ impl<'old> Platform<'_, 'old> {
     ///
     /// `other` could also be created with the [`empty_tree()`][crate::Repository::empty_tree()] method to handle the first commit
     /// in a repository - it doesn't have a parent, equivalent to compare 'nothing' to something.
-    pub fn for_each_to_obtain_tree<'new, E>(
+    pub fn for_each_to_obtain_tree<'new>(
         &mut self,
         other: &Tree<'new>,
-        for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
-    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
-    where
-        E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-    {
+        for_each: impl FnMut(Change<'_, 'old, 'new>) -> ExnResult<Action>,
+    ) -> Result<Option<gix_diff::rewrites::Outcome>> {
         self.for_each_to_obtain_tree_inner(other, for_each, None)
     }
 
@@ -44,27 +28,21 @@ impl<'old> Platform<'_, 'old> {
     ///
     /// Note that to do rename tracking like `git` does, one has to configure the `resource_cache` with
     /// a conversion pipeline that uses [`gix_diff::blob::pipeline::Mode::ToGit`].
-    pub fn for_each_to_obtain_tree_with_cache<'new, E>(
+    pub fn for_each_to_obtain_tree_with_cache<'new>(
         &mut self,
         other: &Tree<'new>,
         resource_cache: &mut gix_diff::blob::Platform,
-        for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
-    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
-    where
-        E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-    {
+        for_each: impl FnMut(Change<'_, 'old, 'new>) -> ExnResult<Action>,
+    ) -> Result<Option<gix_diff::rewrites::Outcome>> {
         self.for_each_to_obtain_tree_inner(other, for_each, Some(resource_cache))
     }
 
-    fn for_each_to_obtain_tree_inner<'new, E>(
+    fn for_each_to_obtain_tree_inner<'new>(
         &mut self,
         other: &Tree<'new>,
-        mut for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
+        mut for_each: impl FnMut(Change<'_, 'old, 'new>) -> ExnResult<Action>,
         resource_cache: Option<&mut gix_diff::blob::Platform>,
-    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
-    where
-        E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-    {
+    ) -> Result<Option<gix_diff::rewrites::Outcome>> {
         let repo = self.lhs.repo;
         let mut storage;
         let cache = match resource_cache {
@@ -88,6 +66,7 @@ impl<'old> Platform<'_, 'old> {
                 })
             },
             opts,
-        )?)
+        )
+        .or_erased()?)
     }
 }
diff --git a/gix/src/object/tree/diff/mod.rs b/gix/src/object/tree/diff/mod.rs
index 44fadfc390c..e484ad44d5f 100644
--- a/gix/src/object/tree/diff/mod.rs
+++ b/gix/src/object/tree/diff/mod.rs
@@ -1,6 +1,6 @@
 use gix_diff::tree;
 
-use crate::{Id, Tree, bstr::BStr};
+use crate::{Id, Result, Tree, bstr::BStr};
 
 /// Returned by the `for_each` function to control flow.
 ///
@@ -124,12 +124,8 @@ impl<'repo> Tree<'repo> {
     /// Note that if a clone with `--filter=blob=none` was created, rename tracking may fail as it might
     /// try to access blobs to compute a similarity metric. Thus, it's more compatible to turn rewrite tracking off
     /// using [`Options::track_rewrites()`](crate::diff::Options::track_rewrites()).
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
     #[doc(alias = "diff_tree_to_tree", alias = "git2")]
-    pub fn changes<'a>(&'a self) -> Result<Platform<'a, 'repo>, crate::diff::options::init::Error> {
+    pub fn changes<'a>(&'a self) -> Result<Platform<'a, 'repo>> {
         Ok(Platform {
             state: Default::default(),
             lhs: self,
@@ -168,19 +164,6 @@ pub struct Stats {
     pub files_changed: u64,
 }
 
-///
-pub mod stats {
-    /// The error returned by [`stats()`](super::Platform::stats()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        CreateResourceCache(#[from] crate::repository::diff_resource_cache::Error),
-        #[error(transparent)]
-        ForEachChange(#[from] crate::object::tree::diff::for_each::Error),
-    }
-}
-
 /// Convenience
 impl Platform<'_, '_> {
     /// Calculate statistics about the lines of the diff between our current and the `other` tree.
@@ -191,7 +174,7 @@ impl Platform<'_, '_> {
     /// rename tracking, an operation that doesn't affect the statistics currently.
     /// As diffed resources aren't cached, if highly repetitive blobs are expected, performance
     /// may be diminished. In real-world scenarios where blobs are mostly unique, that's not an issue though.
-    pub fn stats(&mut self, other: &Tree<'_>) -> Result<Stats, stats::Error> {
+    pub fn stats(&mut self, other: &Tree<'_>) -> Result<Stats> {
         // let (mut number_of_files, mut lines_added, mut lines_removed) = (0, 0, 0);
         let mut resource_cache = self.lhs.repo.diff_resource_cache_for_tree_diff()?;
 
@@ -209,7 +192,7 @@ impl Platform<'_, '_> {
             }
 
             resource_cache.clear_resource_cache_keep_allocation();
-            Ok::<_, std::convert::Infallible>(std::ops::ControlFlow::Continue(()))
+            Ok::<_, gix_error::Exn>(std::ops::ControlFlow::Continue(()))
         })?;
 
         Ok(Stats {
diff --git a/gix/src/object/tree/editor.rs b/gix/src/object/tree/editor.rs
index 4f4bdf042fb..7f5cb867d44 100644
--- a/gix/src/object/tree/editor.rs
+++ b/gix/src/object/tree/editor.rs
@@ -1,51 +1,13 @@
+use gix_error::{ErrorExt, ResultExt};
 use gix_hash::ObjectId;
 use gix_object::tree::EntryKind;
 
 use crate::{
-    Id, Repository,
+    Error, Id, Repository, Result,
     bstr::{BStr, BString},
     prelude::ObjectIdExt,
 };
 
-///
-pub mod init {
-    /// The error returned by [`Editor::new()](crate::object::tree::Editor::new()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        DecodeTree(#[from] gix_object::decode::Error),
-        #[error(transparent)]
-        ValidationOptions(#[from] crate::config::boolean::Error),
-    }
-}
-
-///
-pub mod write {
-    use crate::bstr::BString;
-
-    /// The error returned by [`Editor::write()](crate::object::tree::Editor::write()) and [`Cursor::write()](super::Cursor::write).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        WriteTree(#[from] crate::object::write::Error),
-        #[error("The object {} ({}) at '{}' could not be found", id, kind.as_octal_str(), filename)]
-        MissingObject {
-            filename: BString,
-            kind: gix_object::tree::EntryKind,
-            id: gix_hash::ObjectId,
-        },
-        #[error("The object {} ({}) has an invalid filename: '{}'", id, kind.as_octal_str(), filename)]
-        InvalidFilename {
-            filename: BString,
-            kind: gix_object::tree::EntryKind,
-            id: gix_hash::ObjectId,
-            source: gix_validate::path::component::Error,
-        },
-    }
-}
-
 /// A cursor at a specific portion of a tree to [edit](super::Editor).
 pub struct Cursor<'a, 'repo> {
     inner: gix_object::tree::editor::Cursor<'a, 'repo>,
@@ -56,10 +18,10 @@ pub struct Cursor<'a, 'repo> {
 /// Lifecycle
 impl<'repo> super::Editor<'repo> {
     /// Initialize a new editor from the given `tree`.
-    pub fn new(tree: &crate::Tree<'repo>) -> Result<Self, init::Error> {
-        let tree_ref = tree.decode()?;
+    pub fn new(tree: &crate::Tree<'repo>) -> Result<Self> {
+        let tree_ref = tree.decode().or_erased()?;
         let repo = tree.repo;
-        let validate = repo.config.protect_options()?;
+        let validate = repo.config.protect_options().or_erased()?;
         Ok(super::Editor {
             inner: gix_object::tree::Editor::new(tree_ref.into(), &repo.objects, repo.object_hash()),
             validate,
@@ -78,7 +40,7 @@ impl<'repo> super::Editor<'repo> {
 impl<'repo> crate::Tree<'repo> {
     /// Start editing a new tree based on this one.
     #[doc(alias = "treebuilder", alias = "git2")]
-    pub fn edit(&self) -> Result<super::Editor<'repo>, init::Error> {
+    pub fn edit(&self) -> Result<super::Editor<'repo>> {
         super::Editor::new(self)
     }
 }
@@ -145,10 +107,7 @@ impl<'repo> super::Editor<'repo> {
     ///
     /// The returned cursor will then allow applying edits to the tree at `rela_path` as root.
     /// If `rela_path` is a single empty string, it is equivalent to using the current instance itself.
-    pub fn cursor_at(
-        &mut self,
-        rela_path: impl ToComponents,
-    ) -> Result<Cursor<'_, 'repo>, gix_object::tree::editor::Error> {
+    pub fn cursor_at(&mut self, rela_path: impl ToComponents) -> Result<Cursor<'_, 'repo>> {
         Ok(Cursor {
             inner: self.inner.cursor_at(rela_path.to_components())?,
             validate: self.validate,
@@ -164,25 +123,25 @@ impl<'repo> Cursor<'_, 'repo> {
         rela_path: impl ToComponents,
         kind: EntryKind,
         id: impl Into<ObjectId>,
-    ) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    ) -> Result<&mut Self> {
         self.inner.upsert(rela_path.to_components(), kind, id.into())?;
         Ok(self)
     }
 
     /// Like [`Editor::remove()`](super::Editor::remove), but with the constraint of only editing in this cursor's tree.
-    pub fn remove(&mut self, rela_path: impl ToComponents) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    pub fn remove(&mut self, rela_path: impl ToComponents) -> Result<&mut Self> {
         self.inner.remove(rela_path.to_components())?;
         Ok(self)
     }
 
     /// Like [`Editor::remove_leaf()`](super::Editor::remove_leaf), but with the constraint of only editing in this cursor's tree.
-    pub fn remove_leaf(&mut self, rela_path: impl ToComponents) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    pub fn remove_leaf(&mut self, rela_path: impl ToComponents) -> Result<&mut Self> {
         self.inner.remove_leaf(rela_path.to_components())?;
         Ok(self)
     }
 
     /// Like [`Editor::write()`](super::Editor::write()), but will write only the subtree of the cursor.
-    pub fn write(&mut self) -> Result<Id<'repo>, write::Error> {
+    pub fn write(&mut self) -> Result<Id<'repo>> {
         write_cursor(self)
     }
 
@@ -209,7 +168,7 @@ impl<'repo> super::Editor<'repo> {
     /// Note that this erases all previous edits.
     ///
     /// This is useful if the same editor is re-used for various trees.
-    pub fn set_root(&mut self, root: &crate::Tree<'repo>) -> Result<&mut Self, init::Error> {
+    pub fn set_root(&mut self, root: &crate::Tree<'repo>) -> Result<&mut Self> {
         let new_editor = super::Editor::new(root)?;
         self.inner = new_editor.inner;
         self.repo = new_editor.repo;
@@ -230,20 +189,20 @@ impl<'repo> super::Editor<'repo> {
     /// `id` can also be an empty tree, along with [the respective `kind`](EntryKind::Tree), even though that's normally not allowed
     /// in Git trees.
     ///
-    /// Validation of path-components will not be performed here, but when [writing the tree](Self::write()).
+    /// Validation of path-components will not be performed here, but when [writing](Self::write()).
     pub fn upsert(
         &mut self,
         rela_path: impl ToComponents,
         kind: EntryKind,
         id: impl Into<ObjectId>,
-    ) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    ) -> Result<&mut Self> {
         self.inner.upsert(rela_path.to_components(), kind, id.into())?;
         Ok(self)
     }
 
     /// Remove the entry at `rela_path`, loading all trees on the path accordingly.
     /// It's no error if the entry doesn't exist, or if `rela_path` doesn't lead to an existing entry at all.
-    pub fn remove(&mut self, rela_path: impl ToComponents) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    pub fn remove(&mut self, rela_path: impl ToComponents) -> Result<&mut Self> {
         self.inner.remove(rela_path.to_components())?;
         Ok(self)
     }
@@ -252,7 +211,7 @@ impl<'repo> super::Editor<'repo> {
     /// It's no error if the entry doesn't exist, or if `rela_path` doesn't lead to an existing entry at all.
     ///
     /// Return an error if the entry exists and is a tree, as that would otherwise also remove all entries below it.
-    pub fn remove_leaf(&mut self, rela_path: impl ToComponents) -> Result<&mut Self, gix_object::tree::editor::Error> {
+    pub fn remove_leaf(&mut self, rela_path: impl ToComponents) -> Result<&mut Self> {
         self.inner.remove_leaf(rela_path.to_components())?;
         Ok(self)
     }
@@ -271,7 +230,7 @@ impl<'repo> super::Editor<'repo> {
     ///
     /// Before writing a tree, all of its entries (not only added ones), will be validated to assure they are
     /// correct. The objects pointed to by entries also have to exist already.
-    pub fn write(&mut self) -> Result<Id<'repo>, write::Error> {
+    pub fn write(&mut self) -> Result<Id<'repo>> {
         write_cursor(&mut self.to_cursor())
     }
 
@@ -291,11 +250,12 @@ impl<'repo> super::Editor<'repo> {
     }
 }
 
-fn write_cursor<'repo>(cursor: &mut Cursor<'_, 'repo>) -> Result<Id<'repo>, write::Error> {
+fn write_cursor<'repo>(cursor: &mut Cursor<'_, 'repo>) -> Result<Id<'repo>> {
     cursor
         .inner
-        .write(|tree| -> Result<ObjectId, write::Error> {
+        .write(|tree| -> Result<ObjectId> {
             for entry in &tree.entries {
+                let kind: EntryKind = entry.mode.into();
                 gix_validate::path::component(
                     entry.filename.as_ref(),
                     entry
@@ -304,21 +264,24 @@ fn write_cursor<'repo>(cursor: &mut Cursor<'_, 'repo>) -> Result<Id<'repo>, writ
                         .then_some(gix_validate::path::component::Mode::Symlink),
                     cursor.validate,
                 )
-                .map_err(|err| write::Error::InvalidFilename {
-                    filename: entry.filename.clone(),
-                    kind: entry.mode.into(),
-                    id: entry.oid,
-                    source: err,
+                .map_err(|err| {
+                    err.and_raise(gix_error::message!(
+                        "The object {} ({}) has an invalid filename: '{}'",
+                        entry.oid,
+                        kind.as_octal_str(),
+                        entry.filename
+                    ))
                 })?;
                 if !entry.mode.is_commit() && !cursor.repo.has_object(entry.oid) {
-                    return Err(write::Error::MissingObject {
-                        filename: entry.filename.clone(),
-                        kind: entry.mode.into(),
-                        id: entry.oid,
-                    });
+                    return Err(Error::from_error(gix_error::message!(
+                        "The object {} ({}) at '{}' could not be found",
+                        entry.oid,
+                        kind.as_octal_str(),
+                        entry.filename
+                    )));
                 }
             }
-            Ok(cursor.repo.write_object(tree)?.detach())
+            Ok(cursor.repo.write_object(tree).or_erased()?.detach())
         })
         .map(|id| id.attach(cursor.repo))
 }
diff --git a/gix/src/object/tree/entry.rs b/gix/src/object/tree/entry.rs
index 16085f14d95..948cb942aac 100644
--- a/gix/src/object/tree/entry.rs
+++ b/gix/src/object/tree/entry.rs
@@ -1,5 +1,5 @@
 use crate::object::tree::EntryRef;
-use crate::{bstr::BStr, ext::ObjectIdExt, object::tree::Entry};
+use crate::{Result, bstr::BStr, ext::ObjectIdExt, object::tree::Entry};
 
 /// Access
 impl<'repo> Entry<'repo> {
@@ -19,7 +19,7 @@ impl<'repo> Entry<'repo> {
     }
 
     /// Return the object this entry points to.
-    pub fn object(&self) -> Result<crate::Object<'repo>, crate::object::find::existing::Error> {
+    pub fn object(&self) -> Result<crate::Object<'repo>> {
         self.id().object()
     }
 
@@ -69,7 +69,7 @@ impl<'repo, 'a> EntryRef<'repo, 'a> {
     }
 
     /// Return the object this entry points to.
-    pub fn object(&self) -> Result<crate::Object<'repo>, crate::object::find::existing::Error> {
+    pub fn object(&self) -> Result<crate::Object<'repo>> {
         self.id().object()
     }
 
diff --git a/gix/src/object/tree/mod.rs b/gix/src/object/tree/mod.rs
index e887fe6f9d2..ac6ca08be44 100644
--- a/gix/src/object/tree/mod.rs
+++ b/gix/src/object/tree/mod.rs
@@ -1,10 +1,11 @@
+use gix_error::ExnMessageResult;
 use std::ops::ControlFlow;
 
 use gix_hash::ObjectId;
 pub use gix_object::tree::{EntryKind, EntryMode};
 use gix_object::{FindExt, TreeRefIter, bstr::BStr, tree::next_entry};
 
-use crate::{Id, ObjectDetached, Repository, Tree, object::find};
+use crate::{Id, ObjectDetached, Repository, Result, Tree};
 
 /// All state needed to conveniently edit a tree, using only [update-or-insert](Editor::upsert()) and [removals](Editor::remove()).
 #[derive(Clone)]
@@ -35,7 +36,7 @@ impl<'repo> Tree<'repo> {
     }
 
     /// Parse our tree data and return the parse tree for direct access to its entries.
-    pub fn decode(&self) -> Result<gix_object::TreeRef<'_>, gix_object::decode::Error> {
+    pub fn decode(&self) -> ExnMessageResult<gix_object::TreeRef<'_>> {
         gix_object::TreeRef::from_bytes(&self.data, self.id.kind())
     }
 
@@ -55,7 +56,7 @@ impl<'repo> Tree<'repo> {
     /// ```
     pub fn find_entry(&self, name: impl PartialEq<BStr>) -> Option<EntryRef<'repo, '_>> {
         TreeRefIter::from_bytes(&self.data, self.id.kind())
-            .filter_map(Result::ok)
+            .filter_map(std::result::Result::ok)
             .find(|entry| name.eq(entry.filename))
             .map(|entry| EntryRef {
                 inner: entry,
@@ -72,7 +73,7 @@ impl<'repo> Tree<'repo> {
     /// to reuse a vector and use a binary search instead, which might be able to improve performance over all.
     /// However, a benchmark should be created first to have some data and see which trade-off to choose here.
     ///
-    pub fn lookup_entry<I, P>(&self, path: I) -> Result<Option<Entry<'repo>>, find::existing::Error>
+    pub fn lookup_entry<I, P>(&self, path: I) -> Result<Option<Entry<'repo>>>
     where
         I: IntoIterator<Item = P>,
         P: PartialEq<BStr>,
@@ -85,7 +86,7 @@ impl<'repo> Tree<'repo> {
 
         loop {
             data = match next_entry(&mut iter, data) {
-                ControlFlow::Continue(oid) => self.repo.find(&oid, buf)?,
+                ControlFlow::Continue(oid) => self.repo.find(&oid, buf).map_err(crate::object::existing_error)?,
                 ControlFlow::Break(entry) => {
                     let mapped = entry.map(|e| Entry {
                         inner: e.into(),
@@ -108,7 +109,7 @@ impl<'repo> Tree<'repo> {
     /// Searching tree entries is currently done in sequence, which allows to the search to be allocation free.
     /// This is beneficial for most 'common' repositiries, but for other cases an allocation might be preferable
     /// to allow a bisect.
-    pub fn peel_to_entry<I, P>(&mut self, path: I) -> Result<Option<Entry<'repo>>, find::existing::Error>
+    pub fn peel_to_entry<I, P>(&mut self, path: I) -> Result<Option<Entry<'repo>>>
     where
         I: IntoIterator<Item = P>,
         P: PartialEq<BStr>,
@@ -120,7 +121,10 @@ impl<'repo> Tree<'repo> {
         loop {
             data = match next_entry(&mut iter, data) {
                 ControlFlow::Continue(id) => {
-                    let res = self.repo.find(&id, &mut self.data)?;
+                    let res = self
+                        .repo
+                        .find(&id, &mut self.data)
+                        .map_err(crate::object::existing_error)?;
                     data_id = id;
                     if res.kind.is_tree() {
                         self.id = data_id;
@@ -132,7 +136,9 @@ impl<'repo> Tree<'repo> {
                         let inner = e.into();
                         if e.mode.is_tree() {
                             data_id = e.oid.to_owned();
-                            self.repo.find(&data_id, &mut self.data)?;
+                            self.repo
+                                .find(&data_id, &mut self.data)
+                                .map_err(crate::object::existing_error)?;
                             self.id = data_id;
                         }
 
@@ -143,7 +149,9 @@ impl<'repo> Tree<'repo> {
 
                     if data_id != self.id {
                         // Ensure that our data always matches our id, even if this means an extra lookup.
-                        self.repo.find(&self.id, &mut self.data)?;
+                        self.repo
+                            .find(&self.id, &mut self.data)
+                            .map_err(crate::object::existing_error)?;
                     }
 
                     break Ok(entry);
@@ -171,10 +179,7 @@ impl<'repo> Tree<'repo> {
     /// assert_eq!(entry.filename(), "c");
     /// # Ok(()) }
     /// ```
-    pub fn lookup_entry_by_path(
-        &self,
-        relative_path: impl AsRef<std::path::Path>,
-    ) -> Result<Option<Entry<'repo>>, find::existing::Error> {
+    pub fn lookup_entry_by_path(&self, relative_path: impl AsRef<std::path::Path>) -> Result<Option<Entry<'repo>>> {
         self.lookup_entry(
             relative_path
                 .as_ref()
@@ -192,7 +197,7 @@ impl<'repo> Tree<'repo> {
     pub fn peel_to_entry_by_path(
         &mut self,
         relative_path: impl AsRef<std::path::Path>,
-    ) -> Result<Option<Entry<'repo>>, find::existing::Error> {
+    ) -> Result<Option<Entry<'repo>>> {
         self.peel_to_entry(
             relative_path
                 .as_ref()
@@ -215,10 +220,11 @@ pub mod traverse;
 ///
 mod iter {
     use super::{EntryRef, Tree};
+    use gix_error::ExnMessageResult;
 
     impl<'repo> Tree<'repo> {
         /// Return an iterator over tree entries to obtain information about files and directories this tree contains.
-        pub fn iter(&self) -> impl Iterator<Item = Result<EntryRef<'repo, '_>, gix_object::decode::Error>> {
+        pub fn iter(&self) -> impl Iterator<Item = ExnMessageResult<EntryRef<'repo, '_>>> {
             let repo = self.repo;
             gix_object::TreeRefIter::from_bytes(&self.data, self.id.kind())
                 .map(move |e| e.map(|entry| EntryRef { inner: entry, repo }))
@@ -252,11 +258,12 @@ mod entry;
 
 mod _impls {
     use crate::Tree;
+    use gix_error::{Exn, Message};
 
     impl TryFrom<Tree<'_>> for gix_object::Tree {
-        type Error = gix_object::decode::Error;
+        type Error = Exn<Message>;
 
-        fn try_from(t: Tree<'_>) -> Result<Self, Self::Error> {
+        fn try_from(t: Tree<'_>) -> std::result::Result<Self, Self::Error> {
             t.decode().map(Into::into)
         }
     }
diff --git a/gix/src/object/tree/traverse.rs b/gix/src/object/tree/traverse.rs
index 444bd859a2e..dd4fde75641 100644
--- a/gix/src/object/tree/traverse.rs
+++ b/gix/src/object/tree/traverse.rs
@@ -1,4 +1,4 @@
-use crate::Tree;
+use crate::{Result, Tree};
 
 /// Traversal
 impl<'repo> Tree<'repo> {
@@ -28,7 +28,7 @@ pub struct BreadthFirstPresets<'a, 'repo> {
 
 impl BreadthFirstPresets<'_, '_> {
     /// Returns all entries and their file paths, recursively, as reachable from this tree.
-    pub fn files(&self) -> Result<Vec<gix_traverse::tree::recorder::Entry>, gix_traverse::tree::breadthfirst::Error> {
+    pub fn files(&self) -> Result<Vec<gix_traverse::tree::recorder::Entry>> {
         let mut recorder = gix_traverse::tree::Recorder::default();
         Platform {
             root: self.root,
@@ -46,13 +46,14 @@ impl Platform<'_, '_> {
     ///
     /// - Results are returned in sort order as per tree-sorting rules, files first, then directories, one level at a time.
     /// - for obtaining the direct children of the tree, use [Tree::iter()] instead.
-    pub fn breadthfirst<V>(&self, delegate: &mut V) -> Result<(), gix_traverse::tree::breadthfirst::Error>
+    pub fn breadthfirst<V>(&self, delegate: &mut V) -> Result<()>
     where
         V: gix_traverse::tree::Visit,
     {
         let root = gix_object::TreeRefIter::from_bytes(&self.root.data, self.root.id.kind());
         let state = gix_traverse::tree::breadthfirst::State::default();
         gix_traverse::tree::breadthfirst(root, state, &self.root.repo.objects, delegate)
+            .map_err(gix_error::Exn::into_error)
     }
 
     /// Start a depth-first, recursive traversal using `delegate`, for which a [`Recorder`](gix_traverse::tree::Recorder) can be used to get started.
@@ -60,11 +61,12 @@ impl Platform<'_, '_> {
     /// # Note
     ///
     /// For obtaining the direct children of the tree, use [Tree::iter()] instead.
-    pub fn depthfirst<V>(&self, delegate: &mut V) -> Result<(), gix_traverse::tree::breadthfirst::Error>
+    pub fn depthfirst<V>(&self, delegate: &mut V) -> Result<()>
     where
         V: gix_traverse::tree::Visit,
     {
         let state = gix_traverse::tree::depthfirst::State::default();
         gix_traverse::tree::depthfirst(self.root.id, state, &self.root.repo.objects, delegate)
+            .map_err(gix_error::Exn::into_error)
     }
 }
diff --git a/gix/src/open/mod.rs b/gix/src/open/mod.rs
index 9b15d26e471..043e988c772 100644
--- a/gix/src/open/mod.rs
+++ b/gix/src/open/mod.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use crate::{bstr::BString, config};
+use crate::bstr::BString;
 
 /// Permissions associated with various resources of a git repository
 #[derive(Copy, Clone, Ord, PartialOrd, PartialEq, Eq, Debug, Hash)]
@@ -50,27 +50,6 @@ pub struct Options {
     pub(crate) current_dir: Option<PathBuf>,
 }
 
-/// The error returned by [`crate::open()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("Failed to load the git configuration")]
-    Config(#[from] config::Error),
-    #[error("\"{path}\" does not appear to be a git repository")]
-    NotARepository {
-        source: gix_discover::is_git::Error,
-        path: PathBuf,
-    },
-    #[error(transparent)]
-    Io(#[from] std::io::Error),
-    #[error("The git directory at '{}' is considered unsafe as it's not owned by the current user.", .path.display())]
-    UnsafeGitDir { path: PathBuf },
-    #[error(transparent)]
-    EnvironmentAccessDenied(#[from] gix_sec::permission::Error<std::path::PathBuf>),
-    #[error(transparent)]
-    PrefixNotRelative(#[from] gix_path::relative_path::Error),
-}
-
 mod options;
 pub mod permissions;
 mod repository;
diff --git a/gix/src/open/options.rs b/gix/src/open/options.rs
index bb3a995cd99..abd050907cc 100644
--- a/gix/src/open/options.rs
+++ b/gix/src/open/options.rs
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
-use super::{Error, Options};
-use crate::{ThreadSafeRepository, bstr::BString, config, open::Permissions};
+use super::Options;
+use crate::{Result, ThreadSafeRepository, bstr::BString, config, open::Permissions};
 
 impl Default for Options {
     fn default() -> Self {
@@ -168,11 +168,7 @@ impl Options {
     }
 
     /// Open a repository at `path` with the options set so far.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
-    pub fn open(self, path: impl Into<PathBuf>) -> Result<ThreadSafeRepository, Error> {
+    pub fn open(self, path: impl Into<PathBuf>) -> Result<ThreadSafeRepository> {
         ThreadSafeRepository::open_opts(path, self)
     }
 }
diff --git a/gix/src/open/repository.rs b/gix/src/open/repository.rs
index e57c965aa02..c995a677ace 100644
--- a/gix/src/open/repository.rs
+++ b/gix/src/open/repository.rs
@@ -1,5 +1,6 @@
 #![allow(clippy::result_large_err)]
 use gix_config::file::Metadata;
+use gix_error::{ErrorExt, ResultExt};
 use gix_features::threading::OwnShared;
 use gix_object::bstr::ByteSlice;
 use gix_path::RelativePath;
@@ -11,9 +12,9 @@ use std::{
     path::PathBuf,
 };
 
-use super::{Error, Options};
+use super::Options;
 use crate::{
-    ThreadSafeRepository,
+    Error, Result, ThreadSafeRepository,
     bstr::BString,
     config,
     config::{
@@ -23,6 +24,15 @@ use crate::{
     open::Permissions,
 };
 
+fn not_a_repository(source: gix_error::Exn, path: PathBuf) -> Error {
+    source
+        .raise(gix_error::not_found(format!(
+            "\"{}\" does not appear to be a git repository",
+            path.display()
+        )))
+        .into_error()
+}
+
 #[derive(Default, Clone)]
 pub(crate) struct EnvironmentOverrides {
     /// An override of the worktree typically from the environment, and overrides even worktree dirs set as parameter.
@@ -36,7 +46,7 @@ pub(crate) struct EnvironmentOverrides {
 }
 
 impl EnvironmentOverrides {
-    fn from_env() -> Result<Self, gix_sec::permission::Error<std::path::PathBuf>> {
+    fn from_env() -> std::result::Result<Self, gix_sec::permission::Error<std::path::PathBuf>> {
         let mut worktree_dir = None;
         if let Some(path) = std::env::var_os(Core::WORKTREE.the_environment_override()) {
             worktree_dir = PathBuf::from(path).into();
@@ -51,12 +61,13 @@ impl EnvironmentOverrides {
 
 impl ThreadSafeRepository {
     /// Open a git repository at the given `path`, possibly expanding it to `path/.git` if `path` is a work tree dir.
-    pub fn open(path: impl Into<PathBuf>) -> Result<Self, Error> {
+    pub fn open(path: impl Into<PathBuf>) -> Result<Self> {
         Self::open_opts(path, Options::default())
     }
 
     /// Open a git repository at the given `path`, possibly expanding it to `path/.git` if `path` is a work tree dir, and use
     /// `options` for fine-grained control.
+    /// Empty `core.worktree` values include their bytes as `input` [metadata](gix_error::Error::metadata()).
     ///
     /// Note that you should use [`crate::discover()`] if security should be adjusted by ownership.
     ///
@@ -67,7 +78,7 @@ impl ThreadSafeRepository {
     ///
     /// Note that opening a repository for implementing custom hooks is also handle specifically in
     /// [`open_with_environment_overrides()`][Self::open_with_environment_overrides()].
-    pub fn open_opts(path: impl Into<PathBuf>, mut options: Options) -> Result<Self, Error> {
+    pub fn open_opts(path: impl Into<PathBuf>, mut options: Options) -> Result<Self> {
         let _span = gix_trace::coarse!("ThreadSafeRepository::open()");
         let (path, kind) = {
             let path = path.into();
@@ -82,25 +93,25 @@ impl ThreadSafeRepository {
                     Ok(kind) => (candidate, kind),
                     Err(_) => match gix_discover::is_git(&path) {
                         Ok(kind) => (path, kind),
-                        Err(err) => return Err(Error::NotARepository { source: err, path }),
+                        Err(err) => return Err(not_a_repository(err, path)),
                     },
                 },
                 None => match gix_discover::is_git(&path) {
                     Ok(kind) => (path, kind),
                     Err(err) => {
-                        return Err(Error::NotARepository { source: err, path });
+                        return Err(not_a_repository(err, path));
                     }
                 },
             }
         };
 
         // To be altered later based on `core.precomposeUnicode`.
-        let cwd = gix_fs::current_dir(false)?;
+        let cwd = gix_fs::current_dir(false).or_erased()?;
         let (git_dir, worktree_dir) = gix_discover::repository::Path::from_dot_git_dir(path, kind, &cwd)
             .expect("we have sanitized path with is_git()")
             .into_repository_and_work_tree_directories();
         if options.git_dir_trust.is_none() {
-            options.git_dir_trust = gix_sec::Trust::from_path_ownership(&git_dir)?.into();
+            options.git_dir_trust = gix_sec::Trust::from_path_ownership(&git_dir).or_erased()?.into();
         }
         options.current_dir = Some(cwd);
         ThreadSafeRepository::open_from_paths(git_dir, worktree_dir, options, None)
@@ -114,6 +125,7 @@ impl ThreadSafeRepository {
     ///
     /// Note that this will read various `GIT_*` environment variables to check for overrides, and is probably most useful when implementing
     /// custom hooks.
+    /// Empty `core.worktree` values include their bytes as `input` [metadata](gix_error::Error::metadata()).
     // TODO: tests, with hooks, GIT_QUARANTINE for ref-log and transaction control (needs gix-sec support to remove write access in gix-ref)
     // TODO: The following vars should end up as overrides of the respective configuration values (see git-config).
     //       GIT_PROXY_SSL_CERT, GIT_PROXY_SSL_KEY, GIT_PROXY_SSL_CERT_PASSWORD_PROTECTED.
@@ -122,35 +134,29 @@ impl ThreadSafeRepository {
     pub fn open_with_environment_overrides(
         fallback_directory: impl Into<PathBuf>,
         trust_map: gix_sec::trust::Mapping<Options>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let _span = gix_trace::coarse!("ThreadSafeRepository::open_with_environment_overrides()");
-        let overrides = EnvironmentOverrides::from_env()?;
+        let overrides = EnvironmentOverrides::from_env().or_erased()?;
         let (path, path_kind): (PathBuf, _) = match overrides.git_dir {
             Some(git_dir) => gix_discover::is_git(&git_dir)
-                .map_err(|err| Error::NotARepository {
-                    source: err,
-                    path: git_dir.clone(),
-                })
+                .map_err(|err| not_a_repository(err, git_dir.clone()))
                 .map(|kind| (git_dir, kind))?,
             None => {
                 let fallback_directory = fallback_directory.into();
                 gix_discover::is_git(&fallback_directory)
-                    .map_err(|err| Error::NotARepository {
-                        source: err,
-                        path: fallback_directory.clone(),
-                    })
+                    .map_err(|err| not_a_repository(err, fallback_directory.clone()))
                     .map(|kind| (fallback_directory, kind))?
             }
         };
 
         // To be altered later based on `core.precomposeUnicode`.
-        let cwd = gix_fs::current_dir(false)?;
+        let cwd = gix_fs::current_dir(false).or_erased()?;
         let (git_dir, worktree_dir) = gix_discover::repository::Path::from_dot_git_dir(path, path_kind, &cwd)
             .expect("we have sanitized path with is_git()")
             .into_repository_and_work_tree_directories();
         let worktree_dir = worktree_dir.or(overrides.worktree_dir);
 
-        let git_dir_trust = gix_sec::Trust::from_path_ownership(&git_dir)?;
+        let git_dir_trust = gix_sec::Trust::from_path_ownership(&git_dir).or_erased()?;
         let mut options = trust_map.into_value_by_level(git_dir_trust);
         options.git_dir_trust = git_dir_trust.into();
         options.current_dir = Some(cwd);
@@ -162,7 +168,7 @@ impl ThreadSafeRepository {
         mut worktree_dir: Option<PathBuf>,
         mut options: Options,
         known_common_dir: Option<PathBuf>,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let _span = gix_trace::detail!("open_from_paths()");
         options.open_path_as_is = false;
         let Options {
@@ -191,7 +197,8 @@ impl ThreadSafeRepository {
         let mut common_dir = match known_common_dir {
             Some(common_dir) => Some(common_dir),
             None => gix_discover::path::from_plain_file(git_dir.join("commondir").as_ref())
-                .transpose()?
+                .transpose()
+                .or_erased()?
                 .map(|cd| git_dir.join(cd)),
         };
         let repo_config = config::cache::StageOne::new(
@@ -200,7 +207,11 @@ impl ThreadSafeRepository {
             *git_dir_trust,
             lossy_config,
             lenient_config,
-        )?;
+        )
+        .map_err(|err| {
+            use gix_error::ErrorExt;
+            err.and_raise(gix_error::corruption("Repository configuration could not be loaded"))
+        })?;
 
         if repo_config.precompose_unicode {
             git_dir = gix_utils::str::precompose_path(git_dir.into()).into_owned();
@@ -266,7 +277,8 @@ impl ThreadSafeRepository {
             api_config_overrides,
             cli_config_overrides,
             use_repository_local_environment,
-        )?;
+        )
+        .or_raise(|| gix_error::message("Repository configuration could not be loaded"))?;
         // Git's precedence is: GIT_WORK_TREE, core.bare, core.worktree, inferred worktree.
         let configured_worktree = config
             .resolved
@@ -282,11 +294,14 @@ impl ThreadSafeRepository {
 
         if let Some((worktree, source)) = configured_worktree.filter(|_| may_use_configured_worktree) {
             if worktree.is_empty() {
-                return Err(config::Error::PathInterpolation {
-                    path: worktree,
-                    source: gix_config::path::interpolate::Error::Missing { what: "path" },
-                }
-                .into());
+                return Err(gix_error::not_found("path is missing")
+                    .and_raise(
+                        gix_error::validation(
+                            "The path at the 'core.worktree' configuration could not be interpolated",
+                        )
+                        .with("input", worktree),
+                    )
+                    .into_error());
             }
             // Git treats core.worktree as a literal path, without tilde or prefix interpolation.
             let worktree = gix_path::from_bstr(worktree.as_bstr()).into_owned();
@@ -319,15 +334,12 @@ impl ThreadSafeRepository {
                 .boolean_filter(Core::WORKTREE, |section| {
                     is_eligible_worktree_config_section(section, &git_dir, current_dir, &mut filter_config_section)
                 })
-                .map_err(|err| {
-                    Error::from(config::Error::ConfigTypedString(
-                        config::key::GenericErrorWithValue::from(&Core::WORKTREE).with_source(err),
-                    ))
-                })?
+                .or_raise(|| config::key::error(&Core::WORKTREE, "Invalid configuration value"))?
                 .is_some()
         {
-            return Err(Error::from(config::Error::ConfigTypedString(
-                config::key::GenericErrorWithValue::from(&Core::WORKTREE),
+            return Err(Error::from_error(config::key::error(
+                &Core::WORKTREE,
+                "Invalid configuration value",
             )));
         }
 
@@ -426,12 +438,7 @@ impl ThreadSafeRepository {
             .string_filter(gitoxide::Core::INDEX_FILE, &mut filter_config_section)
         {
             Some(value) => {
-                gitoxide::Core::INDEX_FILE.validate(value.as_bstr()).map_err(|_| {
-                    config::Error::ConfigTypedString(config::key::GenericErrorWithValue::from_value(
-                        &gitoxide::Core::INDEX_FILE,
-                        value.clone(),
-                    ))
-                })?;
+                gitoxide::Core::INDEX_FILE.validate(value.as_bstr())?;
                 gix_path::from_bstr(value).into_owned()
             }
             None => git_dir.join("index"),
@@ -450,7 +457,7 @@ impl ThreadSafeRepository {
                     Ok(Some(value)) => value,
                     Ok(None) => gitoxide::Objects::ALLOC_LIMIT_IF_REDUCED_TRUST_DEFAULT,
                     Err(_) if config.lenient_config => gitoxide::Objects::ALLOC_LIMIT_IF_REDUCED_TRUST_DEFAULT,
-                    Err(err) => return Err(Error::from(config::Error::from(err))),
+                    Err(err) => return Err(err),
                 };
             if alloc_limit_if_reduced_trust != 0 {
                 config.alloc_limit_bytes = Some(alloc_limit_if_reduced_trust);
@@ -475,7 +482,7 @@ impl ThreadSafeRepository {
                     let platform = refs.iter().ok()?;
                     let iter = platform.prefixed(prefix).ok()?;
                     let replacements = iter
-                        .filter_map(Result::ok)
+                        .filter_map(std::result::Result::ok)
                         .filter_map(|r: gix_ref::Reference| {
                             let target = r.target.try_id()?.to_owned();
                             let source =
@@ -491,18 +498,21 @@ impl ThreadSafeRepository {
         let replacements = replacements.unwrap_or_default();
 
         Ok(ThreadSafeRepository {
-            objects: OwnShared::new(gix_odb::Store::at_opts(
-                common_dir_ref.join("objects"),
-                config.object_hash,
-                &mut replacements.into_iter(),
-                gix_odb::store::init::Options {
-                    slots: object_store_slots,
-                    use_multi_pack_index: config.use_multi_pack_index,
-                    alloc_limit_bytes: config.alloc_limit_bytes,
-                    loose_compression: config.loose_compression,
-                    current_dir: current_dir.to_owned().into(),
-                },
-            )?),
+            objects: OwnShared::new(
+                gix_odb::Store::at_opts(
+                    common_dir_ref.join("objects"),
+                    config.object_hash,
+                    &mut replacements.into_iter(),
+                    gix_odb::store::init::Options {
+                        slots: object_store_slots,
+                        use_multi_pack_index: config.use_multi_pack_index,
+                        alloc_limit_bytes: config.alloc_limit_bytes,
+                        loose_compression: config.loose_compression,
+                        current_dir: current_dir.to_owned().into(),
+                    },
+                )
+                .or_erased()?,
+            ),
             common_dir,
             refs,
             work_tree: worktree_dir,
@@ -592,10 +602,8 @@ fn replacement_objects_refs_prefix(
     config: &gix_config::File,
     lenient: bool,
     mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<Option<BString>, Error> {
-    let is_disabled = config::shared::is_replace_refs_enabled(config, lenient, filter_config_section)
-        .map_err(config::Error::ConfigBoolean)?
-        .unwrap_or(true);
+) -> Result<Option<BString>> {
+    let is_disabled = config::shared::is_replace_refs_enabled(config, lenient, filter_config_section)?.unwrap_or(true);
 
     if is_disabled {
         return Ok(None);
@@ -617,7 +625,7 @@ fn check_safe_directories(
     current_dir: &std::path::Path,
     home: Option<&std::path::Path>,
     safe_dirs: &[BString],
-) -> Result<(), Error> {
+) -> Result<()> {
     let mut is_safe = false;
     let realpath_or_original = |path: &std::path::Path| {
         std::fs::canonicalize(path)
@@ -661,6 +669,9 @@ fn check_safe_directories(
     if is_safe {
         Ok(())
     } else {
-        Err(Error::UnsafeGitDir { path: path_to_test })
+        Err(Error::from_error(gix_error::validation(format!(
+            "The git directory at '{}' is considered unsafe as it's not owned by the current user.",
+            path_to_test.display()
+        ))))
     }
 }
diff --git a/gix/src/pathspec.rs b/gix/src/pathspec.rs
index c76ad3d770a..a4bbf750e43 100644
--- a/gix/src/pathspec.rs
+++ b/gix/src/pathspec.rs
@@ -1,26 +1,8 @@
 //! Pathspec plumbing and abstractions
 pub use gix_pathspec::*;
 
-use crate::{AttributeStack, Pathspec, PathspecDetached, Repository, bstr::BStr};
-
-///
-pub mod init {
-    /// The error returned by [`Pathspec::new()`](super::Pathspec::new()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        MakeAttributes(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-        #[error(transparent)]
-        Defaults(#[from] crate::repository::pathspec_defaults_ignore_case::Error),
-        #[error(transparent)]
-        ParseSpec(#[from] gix_pathspec::parse::Error),
-        #[error("Could not obtain the repository prefix as the relative path of the CWD as seen from the working tree")]
-        NormalizeSpec(#[from] gix_pathspec::normalize::Error),
-        #[error(transparent)]
-        RepoPrefix(#[from] gix_path::realpath::Error),
-    }
-}
+use crate::{AttributeStack, ExnResult, Pathspec, PathspecDetached, Repository, Result, bstr::BStr};
+use gix_error::ResultExt;
 
 /// Lifecycle
 impl<'repo> Pathspec<'repo> {
@@ -41,13 +23,14 @@ impl<'repo> Pathspec<'repo> {
         empty_patterns_match_prefix: bool,
         patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
         inherit_ignore_case: bool,
-        make_attributes: impl FnOnce() -> Result<gix_worktree::Stack, Box<dyn std::error::Error + Send + Sync + 'static>>,
-    ) -> Result<Self, init::Error> {
+        make_attributes: impl FnOnce() -> ExnResult<gix_worktree::Stack>,
+    ) -> Result<Self> {
         let defaults = repo.pathspec_defaults_inherit_ignore_case(inherit_ignore_case)?;
         let patterns = patterns
             .into_iter()
             .map(move |p| parse(p.as_ref(), defaults))
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect::<std::result::Result<Vec<_>, _>>()
+            .or_erased()?;
         let needs_cache = patterns.iter().any(|p| !p.attributes.is_empty());
         let prefix = if patterns.is_empty() && !empty_patterns_match_prefix {
             None
@@ -62,7 +45,12 @@ impl<'repo> Pathspec<'repo> {
                 repo.options.current_dir_or_empty(),
                 gix_path::realpath::MAX_SYMLINKS,
             )?,
-        )?;
+        )
+        .or_raise(|| {
+            gix_error::message(
+                "Could not obtain the repository prefix as the relative path of the CWD as seen from the working tree",
+            )
+        })?;
         let cache = needs_cache.then(make_attributes).transpose()?;
 
         gix_trace::debug!(
diff --git a/gix/src/reference/edits.rs b/gix/src/reference/edits.rs
index c10fcd13c46..a5ab837c60c 100644
--- a/gix/src/reference/edits.rs
+++ b/gix/src/reference/edits.rs
@@ -2,22 +2,7 @@
 pub mod set_target_id {
     use gix_ref::{Target, transaction::PreviousValue};
 
-    use crate::{Reference, bstr::BString};
-
-    mod error {
-        use gix_ref::FullName;
-
-        /// The error returned by [`Reference::set_target_id()`][super::Reference::set_target_id()].
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error("Cannot change symbolic reference {name:?} into a direct one by setting it to an id")]
-            SymbolicReference { name: FullName },
-            #[error(transparent)]
-            ReferenceEdit(#[from] crate::reference::edit::Error),
-        }
-    }
-    pub use error::Error;
+    use crate::{Error, Reference, Result, bstr::BString};
 
     impl Reference<'_> {
         /// Set the id of this direct reference to `id` and use `reflog_message` for the reflog (if enabled in the repository).
@@ -31,9 +16,13 @@ pub mod set_target_id {
             &mut self,
             id: impl Into<gix_hash::ObjectId>,
             reflog_message: impl Into<BString>,
-        ) -> Result<(), Error> {
+        ) -> Result<()> {
             match &self.inner.target {
-                Target::Symbolic(name) => return Err(Error::SymbolicReference { name: name.clone() }),
+                Target::Symbolic(name) => {
+                    return Err(Error::from_error(gix_error::message!(
+                        "Cannot change symbolic reference {name:?} into a direct one by setting it to an id"
+                    )));
+                }
                 Target::Object(current_id) => {
                     let changed = self.repo.reference(
                         self.name(),
@@ -51,6 +40,7 @@ pub mod set_target_id {
 
 ///
 pub mod delete {
+    use crate::Result;
     use gix_ref::transaction::{PreviousValue, RefEdit};
 
     use crate::Reference;
@@ -58,7 +48,7 @@ pub mod delete {
     impl Reference<'_> {
         /// Delete this reference or fail if it was changed since last observed.
         /// Note that this instance remains available in memory but probably shouldn't be used anymore.
-        pub fn delete(&self) -> Result<(), crate::reference::edit::Error> {
+        pub fn delete(&self) -> Result<()> {
             self.repo
                 .edit_reference(RefEdit::delete(
                     self.inner.name.clone(),
diff --git a/gix/src/reference/errors.rs b/gix/src/reference/errors.rs
deleted file mode 100644
index eb8d7a4cede..00000000000
--- a/gix/src/reference/errors.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-///
-pub mod edit {
-    use crate::config;
-
-    /// The error returned by [`edit_references(…)`][crate::Repository::edit_references()], and others
-    /// which ultimately create a reference.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FileTransactionPrepare(#[from] gix_ref::file::transaction::prepare::Error),
-        #[error(transparent)]
-        FileTransactionCommit(#[from] gix_ref::file::transaction::commit::Error),
-        #[error(transparent)]
-        NameValidation(#[from] gix_validate::reference::name::Error),
-        #[error(
-            "Could not interpret core.filesRefLockTimeout or core.packedRefsTimeout, it must be the number in milliseconds to wait for locks or negative to wait forever"
-        )]
-        LockTimeoutConfiguration(#[from] config::lock_timeout::Error),
-        #[error(transparent)]
-        ParseCommitterTime(#[from] crate::config::time::Error),
-    }
-}
-
-///
-pub mod peel {
-    /// The error returned by [`Reference::peel_to_id()`](crate::Reference::peel_to_id()) and
-    /// [`Reference::into_fully_peeled_id()`](crate::Reference::into_fully_peeled_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ToId(#[from] gix_ref::peel::to_id::Error),
-        #[error(transparent)]
-        PackedRefsOpen(#[from] gix_ref::packed::buffer::open::Error),
-    }
-
-    ///
-    pub mod to_kind {
-        /// The error returned by [`Reference::peel_to_kind(…)`](crate::Reference::peel_to_kind()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            FollowToObject(#[from] gix_ref::peel::to_object::Error),
-            #[error(transparent)]
-            PackedRefsOpen(#[from] gix_ref::packed::buffer::open::Error),
-            #[error(transparent)]
-            FindObject(#[from] crate::object::find::existing::Error),
-            #[error(transparent)]
-            PeelObject(#[from] crate::object::peel::to_kind::Error),
-        }
-    }
-}
-
-///
-pub mod follow {
-    ///
-    pub mod to_object {
-        /// The error returned by [`Reference::follow_to_object(…)`](crate::Reference::follow_to_object()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            FollowToObject(#[from] gix_ref::peel::to_object::Error),
-            #[error(transparent)]
-            PackedRefsOpen(#[from] gix_ref::packed::buffer::open::Error),
-        }
-    }
-}
-
-///
-pub mod head_id {
-    /// The error returned by [`Repository::head_id(…)`](crate::Repository::head_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Head(#[from] crate::reference::find::existing::Error),
-        #[error(transparent)]
-        PeelToId(#[from] crate::head::peel::into_id::Error),
-    }
-}
-
-///
-pub mod head_commit {
-    /// The error returned by [`Repository::head_commit`(…)](crate::Repository::head_commit()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Head(#[from] crate::reference::find::existing::Error),
-        #[error(transparent)]
-        PeelToCommit(#[from] crate::head::peel::to_commit::Error),
-    }
-}
-
-///
-pub mod head_tree_id {
-    /// The error returned by [`Repository::head_tree_id`(…)](crate::Repository::head_tree_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        HeadCommit(#[from] crate::reference::head_commit::Error),
-        #[error(transparent)]
-        DecodeCommit(#[from] gix_object::decode::Error),
-    }
-}
-
-///
-pub mod head_tree {
-    /// The error returned by [`Repository::head_tree`(…)](crate::Repository::head_tree()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        HeadCommit(#[from] crate::reference::head_commit::Error),
-        #[error(transparent)]
-        CommitTree(#[from] crate::object::commit::Error),
-    }
-}
-
-///
-pub mod find {
-    ///
-    pub mod existing {
-        use gix_ref::PartialName;
-
-        /// The error returned by [`find_reference(…)`][crate::Repository::find_reference()], and others.
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            Find(#[from] crate::reference::find::Error),
-            #[error("The reference '{}' did not exist", name.as_ref().as_bstr())]
-            NotFound { name: PartialName },
-        }
-    }
-
-    /// The error returned by [`try_find_reference(…)`][crate::Repository::try_find_reference()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Find(#[from] gix_ref::file::find::Error),
-    }
-}
diff --git a/gix/src/reference/iter.rs b/gix/src/reference/iter.rs
index 1db0cf65435..a760b0a6194 100644
--- a/gix/src/reference/iter.rs
+++ b/gix/src/reference/iter.rs
@@ -1,9 +1,13 @@
 //!
 #![allow(clippy::empty_docs)]
 
+use gix_error::ResultExt;
+
 use gix_path::RelativePath;
 use gix_ref::file::ReferenceExt;
 
+use crate::Result;
+
 /// A platform to create iterators over references.
 #[must_use = "Iterators should be obtained from this iterator platform"]
 pub struct Platform<'r> {
@@ -37,8 +41,8 @@ impl<'repo> Platform<'repo> {
     ///
     /// Even broken or otherwise unparsable or inaccessible references are returned and have to be handled by the caller on a
     /// case by case basis.
-    pub fn all(&self) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.all()?))
+    pub fn all(&self) -> Result<Iter<'_, 'repo>> {
+        Ok(Iter::new(self.repo, self.platform.all().or_erased()?))
     }
 
     /// Return an iterator over all references that match the given `prefix`.
@@ -46,44 +50,42 @@ impl<'repo> Platform<'repo> {
     /// These are of the form `refs/heads/` or `refs/remotes/origin`, and must not contain relative paths components like `.` or `..`.
     pub fn prefixed<'a>(
         &self,
-        prefix: impl TryInto<&'a RelativePath, Error = gix_path::relative_path::Error>,
-    ) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(prefix.try_into()?)?))
+        prefix: impl TryInto<&'a RelativePath, Error = gix_error::Exn<gix_error::Message>>,
+    ) -> Result<Iter<'_, 'repo>> {
+        let prefix = prefix.try_into()?;
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix).or_erased()?))
     }
 
     /// Return an iterator over all references that are tags.
     ///
     /// They are all prefixed with `refs/tags`.
-    pub fn tags(&self) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(b"refs/tags/".try_into()?)?))
+    pub fn tags(&self) -> Result<Iter<'_, 'repo>> {
+        let prefix = b"refs/tags/".try_into()?;
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix).or_erased()?))
     }
 
     // TODO: tests
     /// Return an iterator over all local branches.
     ///
     /// They are all prefixed with `refs/heads`.
-    pub fn local_branches(&self) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(
-            self.repo,
-            self.platform.prefixed(b"refs/heads/".try_into()?)?,
-        ))
+    pub fn local_branches(&self) -> Result<Iter<'_, 'repo>> {
+        let prefix = b"refs/heads/".try_into()?;
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix).or_erased()?))
     }
 
     // TODO: tests
     /// Return an iterator over all local pseudo references.
-    pub fn pseudo(&self) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.pseudo()?))
+    pub fn pseudo(&self) -> Result<Iter<'_, 'repo>> {
+        Ok(Iter::new(self.repo, self.platform.pseudo().or_erased()?))
     }
 
     // TODO: tests
     /// Return an iterator over all remote branches.
     ///
     /// They are all prefixed with `refs/remotes`.
-    pub fn remote_branches(&self) -> Result<Iter<'_, 'repo>, init::Error> {
-        Ok(Iter::new(
-            self.repo,
-            self.platform.prefixed(b"refs/remotes/".try_into()?)?,
-        ))
+    pub fn remote_branches(&self) -> Result<Iter<'_, 'repo>> {
+        let prefix = b"refs/remotes/".try_into()?;
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix).or_erased()?))
     }
 }
 
@@ -96,7 +98,7 @@ impl Iter<'_, '_> {
     ///
     /// Doing this is necessary as the packed-refs buffer is already held by the iterator, disallowing the consumer of the iterator
     /// to peel the returned references themselves.
-    pub fn peeled(mut self) -> Result<Self, gix_ref::packed::buffer::open::Error> {
+    pub fn peeled(mut self) -> Result<Self> {
         self.peel_with_packed = self.repo.refs.cached_packed_buffer()?;
         self.peel = true;
         Ok(self)
@@ -104,38 +106,19 @@ impl Iter<'_, '_> {
 }
 
 impl<'r> Iterator for Iter<'_, 'r> {
-    type Item = Result<crate::Reference<'r>, Box<dyn std::error::Error + Send + Sync + 'static>>;
+    type Item = Result<crate::Reference<'r>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|res| {
-            res.map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)
-                .and_then(|mut r| {
-                    if self.peel {
-                        let repo = &self.repo;
-                        r.peel_to_id_packed(&repo.refs, &repo.objects, self.peel_with_packed.as_ref().map(|p| &***p))
-                            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)
-                            .map(|_| r)
-                    } else {
-                        Ok(r)
-                    }
-                })
-                .map(|r| crate::Reference::from_ref(r, self.repo))
+            let mut r = res?;
+            if self.peel {
+                r.peel_to_id_packed(
+                    &self.repo.refs,
+                    &self.repo.objects,
+                    self.peel_with_packed.as_ref().map(|p| &***p),
+                )?;
+            }
+            Ok(crate::Reference::from_ref(r, self.repo))
         })
     }
 }
-
-///
-pub mod init {
-    /// The error returned by [`Platform::all()`](super::Platform::all()) or [`Platform::prefixed()`](super::Platform::prefixed()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Io(#[from] std::io::Error),
-        #[error(transparent)]
-        RelativePath(#[from] gix_path::relative_path::Error),
-    }
-}
-
-/// The error returned by [references()][crate::Repository::references()].
-pub type Error = gix_ref::packed::buffer::open::Error;
diff --git a/gix/src/reference/mod.rs b/gix/src/reference/mod.rs
index 7e7da382931..8693eaee1a0 100644
--- a/gix/src/reference/mod.rs
+++ b/gix/src/reference/mod.rs
@@ -2,10 +2,10 @@
 #![allow(clippy::empty_docs)]
 
 use crate::ext::ObjectIdExt;
-use gix_ref::file;
+use gix_error::ResultExt;
 use gix_ref::file::ReferenceExt;
 
-use crate::{Blob, Commit, Id, Object, Reference, Tag, Tree};
+use crate::{Blob, Commit, Id, Object, Reference, Result, Tag, Tree};
 
 pub use gix_ref::{Category, Kind};
 
@@ -13,9 +13,6 @@ pub mod iter;
 ///
 pub mod remote;
 
-mod errors;
-pub use errors::{edit, find, follow, head_commit, head_id, head_tree, head_tree_id, peel};
-
 pub mod log;
 
 mod edits;
@@ -79,8 +76,8 @@ impl<'repo> Reference<'repo> {
     /// This is useful to learn where this reference is ultimately pointing to after following
     /// the chain of symbolic refs and annotated tags.
     #[deprecated = "Use `peel_to_id()` instead"]
-    pub fn peel_to_id_in_place(&mut self) -> Result<Id<'repo>, peel::Error> {
-        let oid = self.inner.peel_to_id(&self.repo.refs, &self.repo.objects)?;
+    pub fn peel_to_id_in_place(&mut self) -> Result<Id<'repo>> {
+        let oid = self.inner.peel_to_id(&self.repo.refs, &self.repo.objects).or_erased()?;
         Ok(Id::from_id(oid, self.repo))
     }
 
@@ -108,8 +105,8 @@ impl<'repo> Reference<'repo> {
     /// assert_eq!(peeled_id, repo.find_reference("b")?.id());
     /// # Ok(()) }
     /// ```
-    pub fn peel_to_id(&mut self) -> Result<Id<'repo>, peel::Error> {
-        let oid = self.inner.peel_to_id(&self.repo.refs, &self.repo.objects)?;
+    pub fn peel_to_id(&mut self) -> Result<Id<'repo>> {
+        let oid = self.inner.peel_to_id(&self.repo.refs, &self.repo.objects).or_erased()?;
         Ok(Id::from_id(oid, self.repo))
     }
 
@@ -119,13 +116,11 @@ impl<'repo> Reference<'repo> {
     /// This is useful to learn where this reference is ultimately pointing to after following
     /// the chain of symbolic refs and annotated tags.
     #[deprecated = "Use `peel_to_id_packed()` instead"]
-    pub fn peel_to_id_in_place_packed(
-        &mut self,
-        packed: Option<&gix_ref::packed::Buffer>,
-    ) -> Result<Id<'repo>, peel::Error> {
+    pub fn peel_to_id_in_place_packed(&mut self, packed: Option<&gix_ref::packed::Buffer>) -> Result<Id<'repo>> {
         let oid = self
             .inner
-            .peel_to_id_packed(&self.repo.refs, &self.repo.objects, packed)?;
+            .peel_to_id_packed(&self.repo.refs, &self.repo.objects, packed)
+            .or_erased()?;
         Ok(Id::from_id(oid, self.repo))
     }
 
@@ -137,15 +132,16 @@ impl<'repo> Reference<'repo> {
     ///
     /// Note that this method mutates `self` in place if it does not already point to a
     /// non-symbolic object.
-    pub fn peel_to_id_packed(&mut self, packed: Option<&gix_ref::packed::Buffer>) -> Result<Id<'repo>, peel::Error> {
+    pub fn peel_to_id_packed(&mut self, packed: Option<&gix_ref::packed::Buffer>) -> Result<Id<'repo>> {
         let oid = self
             .inner
-            .peel_to_id_packed(&self.repo.refs, &self.repo.objects, packed)?;
+            .peel_to_id_packed(&self.repo.refs, &self.repo.objects, packed)
+            .or_erased()?;
         Ok(Id::from_id(oid, self.repo))
     }
 
     /// Similar to [`peel_to_id()`](Reference::peel_to_id()), but consumes this instance.
-    pub fn into_fully_peeled_id(mut self) -> Result<Id<'repo>, peel::Error> {
+    pub fn into_fully_peeled_id(mut self) -> Result<Id<'repo>> {
         self.peel_to_id()
     }
 
@@ -158,12 +154,8 @@ impl<'repo> Reference<'repo> {
     /// Note that `git2::Reference::peel` does not "peel in place", but returns a new object
     /// instead.
     #[doc(alias = "peel", alias = "git2")]
-    pub fn peel_to_kind(&mut self, kind: gix_object::Kind) -> Result<Object<'repo>, peel::to_kind::Error> {
-        let packed = self.repo.refs.cached_packed_buffer().map_err(|err| {
-            peel::to_kind::Error::FollowToObject(gix_ref::peel::to_object::Error::Follow(
-                file::find::existing::Error::Find(file::find::Error::PackedOpen(err)),
-            ))
-        })?;
+    pub fn peel_to_kind(&mut self, kind: gix_object::Kind) -> Result<Object<'repo>> {
+        let packed = self.repo.refs.cached_packed_buffer().or_erased()?;
         self.peel_to_kind_packed(kind, packed.as_ref().map(|p| &***p))
     }
 
@@ -183,21 +175,21 @@ impl<'repo> Reference<'repo> {
     /// assert_eq!(commit.message_raw()?, "c2\n");
     /// # Ok(()) }
     /// ```
-    pub fn peel_to_commit(&mut self) -> Result<Commit<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_commit(&mut self) -> Result<Commit<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Commit)?.into_commit())
     }
 
     /// Peel this ref until the first annotated tag.
     ///
     /// For details, see [`peel_to_kind`()](Self::peel_to_kind()).
-    pub fn peel_to_tag(&mut self) -> Result<Tag<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_tag(&mut self) -> Result<Tag<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Tag)?.into_tag())
     }
 
     /// Peel this ref until the first tree.
     ///
     /// For details, see [`peel_to_kind`()](Self::peel_to_kind()).
-    pub fn peel_to_tree(&mut self) -> Result<Tree<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_tree(&mut self) -> Result<Tree<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Tree)?.into_tree())
     }
 
@@ -205,7 +197,7 @@ impl<'repo> Reference<'repo> {
     /// as it would require an annotated tag to point to a blob, instead of a commit.
     ///
     /// For details, see [`peel_to_kind`()](Self::peel_to_kind()).
-    pub fn peel_to_blob(&mut self) -> Result<Blob<'repo>, peel::to_kind::Error> {
+    pub fn peel_to_blob(&mut self) -> Result<Blob<'repo>> {
         Ok(self.peel_to_kind(gix_object::Kind::Blob)?.into_blob())
     }
 
@@ -215,12 +207,13 @@ impl<'repo> Reference<'repo> {
         &mut self,
         kind: gix_object::Kind,
         packed: Option<&gix_ref::packed::Buffer>,
-    ) -> Result<Object<'repo>, peel::to_kind::Error> {
+    ) -> Result<Object<'repo>> {
         let target = self
             .inner
-            .follow_to_object_packed(&self.repo.refs, packed)?
+            .follow_to_object_packed(&self.repo.refs, packed)
+            .or_erased()?
             .attach(self.repo);
-        Ok(target.object()?.peel_to_kind(kind)?)
+        target.object()?.peel_to_kind(kind)
     }
 
     /// Follow all symbolic references we point to up to the first object, which is typically (but not always) a tag,
@@ -228,25 +221,19 @@ impl<'repo> Reference<'repo> {
     /// After this call, this ref will be pointing to an object directly, but may still not consider itself 'peeled' unless
     /// a symbolic target ref was looked up from packed-refs.
     #[doc(alias = "resolve", alias = "git2")]
-    pub fn follow_to_object(&mut self) -> Result<Id<'repo>, follow::to_object::Error> {
-        let packed = self.repo.refs.cached_packed_buffer().map_err(|err| {
-            follow::to_object::Error::FollowToObject(gix_ref::peel::to_object::Error::Follow(
-                file::find::existing::Error::Find(file::find::Error::PackedOpen(err)),
-            ))
-        })?;
+    pub fn follow_to_object(&mut self) -> Result<Id<'repo>> {
+        let packed = self.repo.refs.cached_packed_buffer().or_erased()?;
         self.follow_to_object_packed(packed.as_ref().map(|p| &***p))
     }
 
     /// Like [`follow_to_object`](Self::follow_to_object), but can be used for repeated calls as it won't
     /// look up `packed` each time, but can reuse it instead.
     #[doc(alias = "resolve", alias = "git2")]
-    pub fn follow_to_object_packed(
-        &mut self,
-        packed: Option<&gix_ref::packed::Buffer>,
-    ) -> Result<Id<'repo>, follow::to_object::Error> {
+    pub fn follow_to_object_packed(&mut self, packed: Option<&gix_ref::packed::Buffer>) -> Result<Id<'repo>> {
         Ok(self
             .inner
-            .follow_to_object_packed(&self.repo.refs, packed)?
+            .follow_to_object_packed(&self.repo.refs, packed)
+            .or_erased()?
             .attach(self.repo))
     }
 
@@ -266,12 +253,13 @@ impl<'repo> Reference<'repo> {
     /// assert_eq!(branch, "refs/heads/main");
     /// # Ok(()) }
     /// ```
-    pub fn follow(&self) -> Option<Result<Reference<'repo>, gix_ref::file::find::existing::Error>> {
+    pub fn follow(&self) -> Option<Result<Reference<'repo>>> {
         self.inner.follow(&self.repo.refs).map(|res| {
             res.map(|r| Reference {
                 inner: r,
                 repo: self.repo,
             })
+            .map_err(gix_error::Exn::into_error)
         })
     }
 }
diff --git a/gix/src/reference/remote.rs b/gix/src/reference/remote.rs
index 850116e7a7c..db138962eb8 100644
--- a/gix/src/reference/remote.rs
+++ b/gix/src/reference/remote.rs
@@ -1,10 +1,9 @@
 use gix_ref::{Category, FullName};
 
 use crate::{
-    Reference,
+    Reference, Result,
     bstr::{BStr, ByteSlice},
     remote,
-    repository::{branch_remote_ref_name, branch_remote_tracking_ref_name},
 };
 
 /// Remotes
@@ -34,10 +33,7 @@ impl<'repo> Reference<'repo> {
     /// Find the remote along with all configuration associated with it suitable for handling this reference.
     ///
     /// See also [`Repository::branch_remote()`](crate::Repository::branch_remote()) for more details.
-    pub fn remote(
-        &self,
-        direction: remote::Direction,
-    ) -> Option<Result<crate::Remote<'repo>, remote::find::existing::Error>> {
+    pub fn remote(&self, direction: remote::Direction) -> Option<Result<crate::Remote<'repo>>> {
         self.repo.branch_remote(self.name().shorten(), direction)
     }
 
@@ -45,10 +41,7 @@ impl<'repo> Reference<'repo> {
     ///
     /// See [`Repository::branch_remote_ref_name()`](crate::Repository::branch_remote_ref_name()) for details.
     #[doc(alias = "upstream", alias = "git2")]
-    pub fn remote_ref_name(
-        &self,
-        direction: remote::Direction,
-    ) -> Option<Result<FullName, branch_remote_ref_name::Error>> {
+    pub fn remote_ref_name(&self, direction: remote::Direction) -> Option<Result<FullName>> {
         self.repo.branch_remote_ref_name(self.name(), direction)
     }
 
@@ -56,10 +49,7 @@ impl<'repo> Reference<'repo> {
     ///
     /// See [`Repository::branch_remote_tracking_ref_name()`](crate::Repository::branch_remote_tracking_ref_name()) for details.
     #[doc(alias = "upstream", alias = "git2")]
-    pub fn remote_tracking_ref_name(
-        &self,
-        direction: remote::Direction,
-    ) -> Option<Result<FullName, branch_remote_tracking_ref_name::Error>> {
+    pub fn remote_tracking_ref_name(&self, direction: remote::Direction) -> Option<Result<FullName>> {
         self.repo.branch_remote_tracking_ref_name(self.name(), direction)
     }
 }
diff --git a/gix/src/remote/access.rs b/gix/src/remote/access.rs
index 1d1949f6d36..4070aeb7132 100644
--- a/gix/src/remote/access.rs
+++ b/gix/src/remote/access.rs
@@ -2,7 +2,7 @@ use gix_refspec::RefSpec;
 
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 use crate::types::RemoteDetached;
-use crate::{Remote, bstr::BStr, remote};
+use crate::{Remote, Result, bstr::BStr, remote};
 
 /// Access
 impl<'repo> Remote<'repo> {
@@ -98,7 +98,7 @@ impl Remote<'_> {
     /// Every URL is attempted non-destructively: successful rewrites remain effective if another rewritten URL is malformed,
     /// while a failed entry keeps using its original URL. The first error is returned in fetch, push-fallback, explicit-push
     /// order. See [`urls()`](Self::urls()) for which rules apply to each category.
-    pub fn rewrite_urls(&mut self) -> Result<&mut Self, remote::init::Error> {
+    pub fn rewrite_urls(&mut self) -> Result<&mut Self> {
         let (url_aliases, url_err) =
             remote::init::rewrite_url_aliases_non_destructive(&self.repo.config, &self.urls, remote::Direction::Fetch);
         self.url_aliases = url_aliases;
@@ -136,7 +136,7 @@ impl Remote<'_> {
         &mut self,
         specs: impl IntoIterator<Item = Spec>,
         direction: remote::Direction,
-    ) -> Result<(), gix_refspec::parse::Error>
+    ) -> Result
     where
         Spec: AsRef<BStr>,
     {
@@ -153,7 +153,7 @@ impl Remote<'_> {
                 )
                 .map(|url| url.to_owned())
             })
-            .collect::<Result<_, _>>()?;
+            .collect::<std::result::Result<_, _>>()?;
         let dst = match direction {
             Push => &mut self.push_specs,
             Fetch => &mut self.fetch_specs,
diff --git a/gix/src/remote/build.rs b/gix/src/remote/build.rs
index 829636ce31b..86a09cd9518 100644
--- a/gix/src/remote/build.rs
+++ b/gix/src/remote/build.rs
@@ -1,33 +1,35 @@
-use crate::{Remote, bstr::BStr, remote};
+use gix_error::ResultExt;
+
+use crate::{Remote, Result, bstr::BStr, remote};
 
 /// Builder methods
 impl Remote<'_> {
     /// Override the `url` to be used when fetching data from a remote.
     ///
     /// Note that this URL is typically set during instantiation with [`crate::Repository::remote_at()`].
-    pub fn with_url<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn with_url<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        self.url_inner(url.try_into().map_err(gix_error::Error::from_error)?, true)
+        self.url_inner(url.try_into().or_erased()?, true)
     }
 
     /// Set the `url` to be used when fetching data from a remote, without applying rewrite rules in case these could be faulty,
     /// eliminating one failure mode.
     ///
     /// Note that this URL is typically set during instantiation with [`crate::Repository::remote_at_without_url_rewrite()`].
-    pub fn with_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn with_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        self.url_inner(url.try_into().map_err(gix_error::Error::from_error)?, false)
+        self.url_inner(url.try_into().or_erased()?, false)
     }
 
     /// Set the `url` to be used when pushing data to a remote.
     #[deprecated = "Use `with_push_url()` instead"]
-    pub fn push_url<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn push_url<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
@@ -39,18 +41,18 @@ impl Remote<'_> {
     ///
     /// Explicit push URLs are rewritten with `url.<base>.insteadOf`; `pushInsteadOf` only applies when a fetch URL is used
     /// as the push fallback because no explicit push URL is configured.
-    pub fn with_push_url<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn with_push_url<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        self.push_url_inner(url.try_into().map_err(gix_error::Error::from_error)?, true)
+        self.push_url_inner(url.try_into().or_erased()?, true)
     }
 
     /// Set the `url` to be used when pushing data to a remote, without applying rewrite rules in case these could be faulty,
     /// eliminating one failure mode.
     #[deprecated = "Use `with_push_url_without_rewrite()` instead"]
-    pub fn push_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn push_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
@@ -60,12 +62,12 @@ impl Remote<'_> {
 
     /// Set the `url` to be used when pushing data to a remote, without applying rewrite rules in case these could be faulty,
     /// eliminating one failure mode.
-    pub fn with_push_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self, remote::init::Error>
+    pub fn with_push_url_without_url_rewrite<Url, E>(self, url: Url) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        self.push_url_inner(url.try_into().map_err(gix_error::Error::from_error)?, false)
+        self.push_url_inner(url.try_into().or_erased()?, false)
     }
 
     /// Configure how tags should be handled when fetching from the remote.
@@ -74,11 +76,7 @@ impl Remote<'_> {
         self
     }
 
-    fn push_url_inner(
-        mut self,
-        push_url: gix_url::Url,
-        should_rewrite_urls: bool,
-    ) -> Result<Self, remote::init::Error> {
+    fn push_url_inner(mut self, push_url: gix_url::Url, should_rewrite_urls: bool) -> Result<Self> {
         self.push_urls = vec![push_url];
 
         self.push_url_aliases = if should_rewrite_urls {
@@ -96,7 +94,7 @@ impl Remote<'_> {
         Ok(self)
     }
 
-    fn url_inner(mut self, url: gix_url::Url, should_rewrite_urls: bool) -> Result<Self, remote::init::Error> {
+    fn url_inner(mut self, url: gix_url::Url, should_rewrite_urls: bool) -> Result<Self> {
         self.urls = vec![url];
 
         self.url_aliases = if should_rewrite_urls {
@@ -124,7 +122,7 @@ impl Remote<'_> {
         mut self,
         specs: impl IntoIterator<Item = Spec>,
         direction: remote::Direction,
-    ) -> Result<Self, gix_refspec::parse::Error>
+    ) -> Result<Self>
     where
         Spec: AsRef<BStr>,
     {
@@ -141,7 +139,7 @@ impl Remote<'_> {
                 )
                 .map(|s| s.to_owned())
             })
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect::<std::result::Result<Vec<_>, _>>()?;
         let specs = match direction {
             Push => &mut self.push_specs,
             Fetch => &mut self.fetch_specs,
diff --git a/gix/src/remote/connect.rs b/gix/src/remote/connect.rs
index dd970b1f7b8..df157cfa897 100644
--- a/gix/src/remote/connect.rs
+++ b/gix/src/remote/connect.rs
@@ -2,55 +2,13 @@
 
 use std::borrow::Cow;
 
+use gix_error::{ErrorExt, ResultExt};
 #[cfg(feature = "async-network-client")]
 use gix_transport::client::async_io::{Transport, connect};
 #[cfg(feature = "blocking-network-client")]
 use gix_transport::client::blocking_io::{Transport, connect};
 
-use crate::{Remote, config::tree::Protocol, remote::Connection};
-
-mod error {
-    use super::connect;
-    use crate::{bstr::BString, config, remote};
-
-    /// The error returned by [connect()][crate::Remote::connect()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not obtain options for connecting via ssh")]
-        SshOptions(#[from] config::ssh_connect_options::Error),
-        #[error("Could not obtain the current directory")]
-        CurrentDir(#[from] std::io::Error),
-        #[error("Could not access remote repository at \"{}\"", directory.display())]
-        InvalidRemoteRepositoryPath { directory: std::path::PathBuf },
-        #[error(transparent)]
-        SchemePermission(#[from] remote::url::scheme_permission::Error),
-        #[error("Protocol {scheme:?} of url {url:?} is denied per configuration")]
-        ProtocolDenied { url: BString, scheme: gix_url::Scheme },
-        #[error(transparent)]
-        Connect(#[from] connect::Error),
-        #[error("The {} url was missing - don't know where to establish a connection to", direction.as_str())]
-        MissingUrl { direction: remote::Direction },
-        #[error("The given protocol version was invalid. Choose between 1 and 2")]
-        UnknownProtocol { source: config::key::GenericErrorWithValue },
-        #[error("Could not verify that \"{}\" url is a valid git directory before attempting to use it", url.to_bstring())]
-        FileUrl {
-            source: Box<gix_discover::is_git::Error>,
-            url: gix_url::Url,
-        },
-    }
-
-    impl gix_protocol::transport::IsSpuriousError for Error {
-        /// Return `true` if retrying might result in a different outcome due to IO working out differently.
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::Connect(err) => err.is_spurious(),
-                _ => false,
-            }
-        }
-    }
-}
-pub use error::Error;
+use crate::{Error, Remote, Result, config::tree::Protocol, remote::Connection};
 
 /// Establishing connections to remote hosts (without performing a git-handshake).
 impl<'repo> Remote<'repo> {
@@ -86,7 +44,7 @@ impl<'repo> Remote<'repo> {
     pub async fn connect(
         &self,
         direction: crate::remote::Direction,
-    ) -> Result<Connection<'_, 'static, 'repo, Box<dyn Transport + Send>>, Error> {
+    ) -> Result<Connection<'_, 'static, 'repo, Box<dyn Transport + Send>>> {
         let (url, version) = self.sanitized_url_and_version(direction)?;
         #[cfg(feature = "blocking-network-client")]
         let scheme_is_ssh = url.scheme == gix_url::Scheme::Ssh;
@@ -97,7 +55,8 @@ impl<'repo> Remote<'repo> {
                 #[cfg(feature = "blocking-network-client")]
                 ssh: scheme_is_ssh
                     .then(|| self.repo.ssh_connect_options())
-                    .transpose()?
+                    .transpose()
+                    .or_raise(|| gix_error::message("Could not obtain options for connecting via ssh"))?
                     .unwrap_or_default(),
                 trace: self.repo.config.trace_packet(),
             },
@@ -109,11 +68,13 @@ impl<'repo> Remote<'repo> {
     /// Produce the sanitized URL and protocol version to use as obtained by querying the repository configuration.
     ///
     /// This can be useful when using custom transports to allow additional configuration.
+    /// Repository path resolution failures and denied protocols include the path or URL bytes as `input`
+    /// [metadata](gix_error::Error::metadata()).
     pub fn sanitized_url_and_version(
         &self,
         direction: crate::remote::Direction,
-    ) -> Result<(gix_url::Url, gix_protocol::transport::Protocol), Error> {
-        fn sanitize(mut url: gix_url::Url) -> Result<gix_url::Url, Error> {
+    ) -> Result<(gix_url::Url, gix_protocol::transport::Protocol)> {
+        fn sanitize(mut url: gix_url::Url) -> Result<gix_url::Url> {
             if url.scheme == gix_url::Scheme::File {
                 let mut dir = gix_path::to_native_path_on_windows(Cow::Borrowed(url.path.as_ref()));
                 let kind = gix_discover::is_git(dir.as_ref())
@@ -121,19 +82,25 @@ impl<'repo> Remote<'repo> {
                         dir.to_mut().push(gix_discover::DOT_GIT_DIR);
                         gix_discover::is_git(dir.as_ref())
                     })
-                    .map_err(|err| Error::FileUrl {
-                        source: err.into(),
-                        url: url.clone(),
+                    .map_err(|err| {
+                        err.raise(gix_error::message!(
+                            "Could not verify that {:?} is a valid git directory before attempting to use it",
+                            url.to_bstring()
+                        ))
                     })?;
                 let (git_dir, _work_dir) = gix_discover::repository::Path::from_dot_git_dir(
                     dir.clone().into_owned(),
                     kind,
                     // precomposed unicode doesn't matter here as long as the produced path is accessible,
                     // which is a given either way.
-                    &gix_fs::current_dir(false)?,
+                    &gix_fs::current_dir(false)
+                        .or_raise(|| gix_error::message("Could not obtain the current directory"))?,
                 )
-                .ok_or_else(|| Error::InvalidRemoteRepositoryPath {
-                    directory: dir.into_owned(),
+                .ok_or_else(|| {
+                    Error::from_error(
+                        gix_error::validation("Could not access remote repository")
+                            .with("input", gix_path::into_bstr(dir.clone().into_owned()).into_owned()),
+                    )
                 })?
                 .into_repository_and_work_tree_directories();
                 url.path = gix_path::into_bstr(git_dir).into_owned();
@@ -143,14 +110,26 @@ impl<'repo> Remote<'repo> {
 
         let version = crate::config::tree::Protocol::VERSION
             .try_into_protocol_version(self.repo.config.resolved.integer(Protocol::VERSION))
-            .map_err(|err| Error::UnknownProtocol { source: err })?;
+            .map_err(|err| {
+                err.and_raise(gix_error::validation(
+                    "The given protocol version was invalid. Choose between 1 and 2",
+                ))
+            })?;
 
-        let url = self.url(direction).ok_or(Error::MissingUrl { direction })?.to_owned();
-        if !self.repo.config.url_scheme()?.allow(&url.scheme) {
-            return Err(Error::ProtocolDenied {
-                url: url.to_bstring(),
-                scheme: url.scheme,
-            });
+        let url = self
+            .url(direction)
+            .ok_or_else(|| {
+                Error::from_error(gix_error::validation(format!(
+                    "The {} url was missing - don't know where to establish a connection to",
+                    direction.as_str()
+                )))
+            })?
+            .to_owned();
+        if !self.repo.config.url_scheme().or_erased()?.allow(&url.scheme) {
+            return Err(Error::from_error(
+                gix_error::validation(format!("Protocol {:?} is denied per configuration", url.scheme))
+                    .with("input", url.to_bstring()),
+            ));
         }
         Ok((sanitize(url)?, version))
     }
diff --git a/gix/src/remote/connection/access.rs b/gix/src/remote/connection/access.rs
index 8d1e3f0d768..77145bec286 100644
--- a/gix/src/remote/connection/access.rs
+++ b/gix/src/remote/connection/access.rs
@@ -1,7 +1,8 @@
 use crate::{
-    Remote,
+    Remote, Result,
     remote::{Connection, connection::AuthenticateFn, connection::ConnectionDetached},
 };
+use gix_error::{OptionExt, ResultExt};
 #[cfg(feature = "async-network-client")]
 use gix_transport::client::async_io::Transport;
 #[cfg(feature = "blocking-network-client")]
@@ -91,10 +92,7 @@ where
     ///
     /// It's meant to be used by users of the [`with_credentials()`](Self::with_credentials()) builder to gain access to the
     /// default way of handling credentials, which they can call as fallback.
-    pub fn configured_credentials(
-        &self,
-        url: gix_url::Url,
-    ) -> Result<AuthenticateFn<'static>, crate::config::credential_helpers::Error> {
+    pub fn configured_credentials(&self, url: gix_url::Url) -> Result<AuthenticateFn<'static>> {
         let (mut cascade, _action_with_normalized_url, prompt_opts) =
             self.remote.repo.config_snapshot().credential_helpers(url)?;
         Ok(Box::new(move |action| cascade.invoke(action, prompt_opts.clone())) as AuthenticateFn<'_>)
@@ -146,13 +144,13 @@ fn configured_credentials_for_current_url(repo: crate::Repository) -> Authentica
             let url = action
                 .context()
                 .and_then(|ctx| ctx.url.clone().or_else(|| ctx.to_url()))
-                .ok_or(gix_credentials::protocol::Error::UrlMissing)?;
+                .ok_or_raise_erased(|| {
+                    gix_error::validation("Either 'url' field or both 'protocol' and 'host' fields must be provided")
+                })?;
             let (mut cascade, _action_with_normalized_url, prompt_opts) = repo
                 .config_snapshot()
-                .credential_helpers(gix_url::parse(&url).map_err(gix_error::Exn::into_error)?)
-                .map_err(|source| gix_credentials::protocol::Error::ConfigureCredentialHelpers {
-                    source: Box::new(source),
-                })?;
+                .credential_helpers(gix_url::parse(&url).or_erased()?)
+                .or_raise_erased(|| gix_error::corruption("Credential helper configuration is invalid"))?;
             let outcome = cascade.invoke(action, prompt_opts.clone());
             previous_cascade_and_prompt = Some((cascade, prompt_opts));
             outcome
diff --git a/gix/src/remote/connection/fetch/config.rs b/gix/src/remote/connection/fetch/config.rs
index 1ff1c2ca0f6..779eb4b3fdd 100644
--- a/gix/src/remote/connection/fetch/config.rs
+++ b/gix/src/remote/connection/fetch/config.rs
@@ -1,22 +1,24 @@
-use super::Error;
 use crate::{
-    Repository,
+    Error, Repository, Result,
     config::{cache::util::ApplyLeniency, tree::Pack},
 };
+use gix_error::ErrorExt;
 
-pub fn index_threads(repo: &Repository) -> Result<Option<usize>, Error> {
-    Ok(Pack::THREADS
+pub fn index_threads(repo: &Repository) -> Result<Option<usize>> {
+    Pack::THREADS
         .try_into_usize(
             repo.config
                 .resolved
                 .integer_filter(Pack::THREADS, &mut repo.filter_config_section()),
         )
-        .with_leniency(repo.options.lenient_config)?)
+        .with_leniency(repo.options.lenient_config)
+        .map_err(|err| Error::from(err.and_raise(gix_error::corruption("The configured pack thread count is invalid"))))
 }
 
-pub fn pack_index_version(repo: &Repository) -> Result<gix_pack::index::Version, Error> {
+pub fn pack_index_version(repo: &Repository) -> Result<gix_pack::index::Version> {
     Ok(Pack::INDEX_VERSION
         .try_into_index_version(repo.config.resolved.integer(Pack::INDEX_VERSION))
-        .with_leniency(repo.options.lenient_config)?
+        .with_leniency(repo.options.lenient_config)
+        .map_err(|err| err.and_raise(gix_error::corruption("The configured pack index version is invalid")))?
         .unwrap_or(gix_pack::index::Version::V2))
 }
diff --git a/gix/src/remote/connection/fetch/error.rs b/gix/src/remote/connection/fetch/error.rs
deleted file mode 100644
index bd06a1306da..00000000000
--- a/gix/src/remote/connection/fetch/error.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use crate::config;
-
-/// The error returned by [`receive()`](super::Prepare::receive()).
-// TODO: remove unused variants
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    Fetch(#[from] gix_protocol::fetch::Error),
-    #[error("The value to configure pack threads should be 0 to auto-configure or the amount of threads to use")]
-    PackThreads(#[from] config::unsigned_integer::Error),
-    #[error("The value to configure the pack index version should be 1 or 2")]
-    PackIndexVersion(#[from] config::key::GenericError),
-    #[error("Cannot fetch from a remote that uses {remote} while local repository uses {local} for object hashes")]
-    IncompatibleObjectHash {
-        local: gix_hash::Kind,
-        remote: gix_hash::Kind,
-    },
-    #[error(transparent)]
-    LoadAlternates(#[from] gix_odb::store::load_index::Error),
-    #[error(transparent)]
-    Client(#[from] gix_protocol::transport::client::Error),
-    #[error(transparent)]
-    UpdateRefs(#[from] super::refs::update::Error),
-    #[error("Failed to remove .keep file at \"{}\"", path.display())]
-    RemovePackKeepFile {
-        path: std::path::PathBuf,
-        source: std::io::Error,
-    },
-    #[error("None of the refspec(s) {} matched any of the {num_remote_refs} refs on the remote", refspecs.iter().map(|r| r.to_ref().instruction().to_bstring().to_string()).collect::<Vec<_>>().join(", "))]
-    NoMapping {
-        refspecs: Vec<gix_refspec::RefSpec>,
-        num_remote_refs: usize,
-    },
-    #[error("Could not obtain configuration to learn if shallow remotes should be rejected")]
-    RejectShallowRemoteConfig(#[from] config::boolean::Error),
-    #[error(transparent)]
-    NegotiationAlgorithmConfig(#[from] config::key::GenericErrorWithValue),
-}
-
-impl gix_protocol::transport::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::Fetch(err) => err.is_spurious(),
-            Error::Client(err) => err.is_spurious(),
-            _ => false,
-        }
-    }
-}
diff --git a/gix/src/remote/connection/fetch/mod.rs b/gix/src/remote/connection/fetch/mod.rs
index ace1a506cff..35e72efb540 100644
--- a/gix/src/remote/connection/fetch/mod.rs
+++ b/gix/src/remote/connection/fetch/mod.rs
@@ -4,7 +4,7 @@ use gix_transport::client::async_io::Transport;
 use gix_transport::client::blocking_io::Transport;
 
 use crate::{
-    Progress,
+    Error, Progress, Result,
     bstr::BString,
     remote,
     remote::{
@@ -15,9 +15,6 @@ use crate::{
     },
 };
 
-mod error;
-pub use error::Error;
-
 use crate::remote::fetch::WritePackedRefs;
 
 /// The way reflog messages should be composed whenever a ref is written with recent objects from a remote.
@@ -99,28 +96,6 @@ pub mod outcome {
 
 pub use gix_protocol::fetch::ProgressId;
 
-///
-pub mod prepare {
-    /// The error returned by [`prepare_fetch()`][super::Connection::prepare_fetch()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Cannot perform a meaningful fetch operation without any configured ref-specs")]
-        MissingRefSpecs,
-        #[error(transparent)]
-        RefMap(#[from] crate::remote::ref_map::Error),
-    }
-
-    impl gix_protocol::transport::IsSpuriousError for Error {
-        fn is_spurious(&self) -> bool {
-            match self {
-                Error::RefMap(err) => err.is_spurious(),
-                _ => false,
-            }
-        }
-    }
-}
-
 impl<'auth, 'repo, T> Connection<'_, 'auth, 'repo, T>
 where
     T: Transport,
@@ -142,7 +117,7 @@ where
         self,
         progress: impl Progress,
         options: ref_map::Options,
-    ) -> Result<Prepare<'auth, 'repo, T>, prepare::Error> {
+    ) -> Result<Prepare<'auth, 'repo, T>> {
         let repo = self.remote.repo;
         let inner = self.into_detached().prepare_fetch(repo, progress, options).await?;
         Ok(Prepare { inner, repo })
@@ -159,9 +134,11 @@ where
         repo: &crate::Repository,
         progress: impl Progress,
         options: ref_map::Options,
-    ) -> Result<PrepareDetached<'remote, T>, prepare::Error> {
+    ) -> Result<PrepareDetached<'remote, T>> {
         if self.remote.fetch_refspecs().is_empty() && options.extra_refspecs.is_empty() {
-            return Err(prepare::Error::MissingRefSpecs);
+            return Err(Error::from_error(gix_error::validation(
+                "Cannot perform a meaningful fetch operation without any configured ref-specs",
+            )));
         }
         let ref_map = self.ref_map_by_ref(repo, progress, options).await?;
         Ok(PrepareDetached {
diff --git a/gix/src/remote/connection/fetch/receive_pack.rs b/gix/src/remote/connection/fetch/receive_pack.rs
index 6ff2e0fc75d..f98676336df 100644
--- a/gix/src/remote/connection/fetch/receive_pack.rs
+++ b/gix/src/remote/connection/fetch/receive_pack.rs
@@ -1,5 +1,6 @@
 use std::{ops::DerefMut, path::PathBuf, sync::atomic::AtomicBool};
 
+use gix_error::{ResultExt, message};
 use gix_odb::store::RefreshMode;
 use gix_protocol::fetch::{Arguments, negotiate};
 #[cfg(feature = "async-network-client")]
@@ -8,6 +9,7 @@ use gix_transport::client::async_io::Transport;
 use gix_transport::client::blocking_io::Transport;
 
 use crate::{
+    Error, ExnMessageResult, ExnResult, Result,
     config::{
         cache::util::ApplyLeniency,
         tree::{Clone, Fetch},
@@ -15,7 +17,7 @@ use crate::{
     remote::{
         connection::fetch::{PrepareDetached, config},
         fetch,
-        fetch::{Error, Outcome, Prepare, RefLogMessage, Status, negotiate::Algorithm, outcome, refs},
+        fetch::{Outcome, Prepare, RefLogMessage, Status, negotiate::Algorithm, outcome, refs},
     },
 };
 
@@ -70,7 +72,7 @@ where
     /// - `gitoxide.userAgent` is read to obtain the application user agent for git servers and for HTTP servers as well.
     ///
     #[gix_protocol::bisync::bisync]
-    pub async fn receive<P>(self, progress: P, should_interrupt: &AtomicBool) -> Result<Outcome, Error>
+    pub async fn receive<P>(self, progress: P, should_interrupt: &AtomicBool) -> Result<Outcome>
     where
         P: gix_features::progress::NestedProgress,
         P::SubProgress: 'static,
@@ -90,7 +92,7 @@ where
         repo: &crate::Repository,
         progress: P,
         should_interrupt: &AtomicBool,
-    ) -> Result<Outcome, Error>
+    ) -> Result<Outcome>
     where
         P: gix_features::progress::NestedProgress,
         P::SubProgress: 'static,
@@ -99,10 +101,15 @@ where
         if ref_map.is_missing_required_mapping() {
             let mut specs = ref_map.refspecs.clone();
             specs.extend(ref_map.extra_refspecs.clone());
-            return Err(Error::NoMapping {
-                refspecs: specs,
-                num_remote_refs: ref_map.remote_refs.len(),
-            });
+            return Err(Error::from_error(gix_error::validation(format!(
+                "None of the refspec(s) {} matched any of the {} refs on the remote",
+                specs
+                    .iter()
+                    .map(|spec| spec.to_ref().instruction().to_bstring().to_string())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+                ref_map.remote_refs.len()
+            ))));
         }
 
         let mut con = self.con.take().expect("receive() can only be called once");
@@ -110,10 +117,10 @@ where
 
         let expected_object_hash = repo.object_hash();
         if ref_map.object_hash != expected_object_hash {
-            return Err(Error::IncompatibleObjectHash {
-                local: expected_object_hash,
-                remote: ref_map.object_hash,
-            });
+            return Err(Error::from_error(gix_error::validation(format!(
+                "Cannot fetch from a remote that uses {} while local repository uses {expected_object_hash} for object hashes",
+                ref_map.object_hash
+            ))));
         }
 
         let fetch_options = gix_protocol::fetch::Options {
@@ -125,7 +132,10 @@ where
                     repo.config
                         .resolved
                         .boolean_filter("clone.rejectShallow", &mut repo.filter_config_section()),
-                )?
+                )
+                .or_raise(|| {
+                    gix_error::message("Could not obtain configuration to learn if shallow remotes should be rejected")
+                })?
                 .unwrap_or(false),
         };
         let context = gix_protocol::fetch::Context {
@@ -178,7 +188,7 @@ where
 
         let res = gix_protocol::fetch(
             &mut negotiate,
-            |reader, progress, should_interrupt| -> Result<bool, gix_pack::bundle::write::Error> {
+            |reader, progress, should_interrupt| -> ExnResult<bool> {
                 let mut may_read_to_end = false;
                 write_pack_bundle = if matches!(self.dry_run, fetch::DryRun::No) {
                     let res = gix_pack::Bundle::write_to_directory(
@@ -192,7 +202,8 @@ where
                         })),
                         repo.object_hash(),
                         write_pack_options,
-                    )?;
+                    )
+                    .or_raise_erased(|| message("Failed to write the received pack"))?;
                     may_read_to_end = true;
                     Some(res)
                 } else {
@@ -234,7 +245,7 @@ where
             && (!update_refs.edits.is_empty() || bundle.index.num_objects == 0)
             && let Some(path) = bundle.keep_path.take()
         {
-            std::fs::remove_file(&path).map_err(|err| Error::RemovePackKeepFile { path, source: err })?;
+            std::fs::remove_file(&path).or_raise(|| message!("Failed to remove .keep file at {:?}", path.display()))?;
         }
 
         let out = Outcome {
@@ -270,14 +281,14 @@ struct Negotiate<'a, 'b, 'c> {
 }
 
 impl gix_protocol::fetch::Negotiate for Negotiate<'_, '_, '_> {
-    fn mark_complete_and_common_ref(&mut self) -> Result<negotiate::Action, negotiate::Error> {
+    fn mark_complete_and_common_ref(&mut self) -> ExnMessageResult<negotiate::Action> {
         negotiate::mark_complete_and_common_ref(
             &self.objects,
             self.refs,
             {
                 let alternates = std::mem::take(&mut self.alternates);
                 let open_options = self.open_options.clone();
-                move || -> Result<_, std::convert::Infallible> {
+                move || {
                     Ok(alternates
                         .into_iter()
                         .filter_map(move |path| {
@@ -312,7 +323,7 @@ impl gix_protocol::fetch::Negotiate for Negotiate<'_, '_, '_> {
         state: &mut negotiate::one_round::State,
         arguments: &mut Arguments,
         previous_response: Option<&gix_protocol::fetch::Response>,
-    ) -> Result<(negotiate::Round, bool), negotiate::Error> {
+    ) -> ExnMessageResult<(negotiate::Round, bool)> {
         negotiate::one_round(
             self.negotiator.deref_mut(),
             &mut *self.graph,
diff --git a/gix/src/remote/connection/fetch/update_refs/mod.rs b/gix/src/remote/connection/fetch/update_refs/mod.rs
index 4c72f937adb..4254ed260e5 100644
--- a/gix/src/remote/connection/fetch/update_refs/mod.rs
+++ b/gix/src/remote/connection/fetch/update_refs/mod.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::result_large_err)]
+use gix_error::{ErrorExt, ResultExt};
 use gix_object::Exists;
 use gix_ref::{
     Target, TargetRef,
@@ -6,7 +7,7 @@ use gix_ref::{
 };
 
 use crate::{
-    Repository,
+    Error, Repository, Result,
     ext::ObjectIdExt,
     remote::{
         fetch,
@@ -68,21 +69,13 @@ pub(crate) fn update(
     fetch_tags: fetch::Tags,
     dry_run: fetch::DryRun,
     write_packed_refs: fetch::WritePackedRefs,
-) -> Result<update::Outcome, update::Error> {
+) -> Result<update::Outcome> {
     let _span = gix_trace::detail!("update_refs()", mappings = mappings.len());
     let mut edits = Vec::new();
     let mut updates = Vec::new();
     let mut edit_indices_to_validate = Vec::new();
 
-    let mut checked_out_branches = repo.checked_out_branches().map_err(|err| match err {
-        crate::repository::worktree::CheckedOutBranchesError::WorktreeListing(err) => {
-            update::Error::WorktreeListing(err)
-        }
-        crate::repository::worktree::CheckedOutBranchesError::OpenWorktreeRepo(err) => {
-            update::Error::OpenWorktreeRepo(err)
-        }
-        crate::repository::worktree::CheckedOutBranchesError::FollowSymref(err) => update::Error::FollowSymref(err),
-    })?;
+    let mut checked_out_branches = repo.checked_out_branches()?;
     let implicit_tag_refspec = fetch_tags
         .to_refspec()
         .filter(|_| matches!(fetch_tags, crate::remote::fetch::Tags::Included));
@@ -135,6 +128,13 @@ pub(crate) fn update(
                         match existing
                             .try_id()
                             .map_or_else(|| existing.clone().peel_to_id(), Ok)
+                            .map_err(|err| {
+                                Error::from(
+                                    err.and_raise(gix_error::message(
+                                        "Could not peel symbolic local reference to its ID",
+                                    )),
+                                )
+                            })
                             .map(crate::Id::detach)
                         {
                             Ok(local_id) => {
@@ -160,31 +160,52 @@ pub(crate) fn update(
                                     let mut force = spec.allow_non_fast_forward();
                                     let is_fast_forward = match dry_run {
                                         fetch::DryRun::No => {
-                                            let ancestors = repo
-                                                .find_object(local_id)?
-                                                .try_into_commit()
-                                                .map_err(|_| ())
-                                                .and_then(|c| c.committer().map(|a| a.seconds()).map_err(|_| ()))
-                                                .and_then(|local_commit_time| {
-                                                    remote_id
-                                                        .to_owned()
-                                                        .ancestors(&repo.objects)
-                                                        .sorting(
-                                                            gix_traverse::commit::simple::Sorting::ByCommitTimeCutoff {
-                                                                order: Default::default(),
-                                                                seconds: local_commit_time,
-                                                            },
+                                            let local = repo.find_object(local_id).or_raise(|| {
+                                                gix_error::message(
+                                                    "Could not find local commit for fast-forward ancestor check",
+                                                )
+                                            })?;
+                                            if local.kind == gix_object::Kind::Commit
+                                                && repo.find_header(remote_id)?.kind() == gix_object::Kind::Commit
+                                            {
+                                                let local_commit_time = local
+                                                    .into_commit()
+                                                    .committer()
+                                                    .or_raise(|| {
+                                                        gix_error::message(
+                                                            "Could not read local commit time for fast-forward ancestor check",
                                                         )
-                                                        .map_err(|_| ())
-                                                });
-                                            match ancestors {
-                                                Ok(mut ancestors) => {
-                                                    ancestors.any(|cid| cid.is_ok_and(|c| c.id == local_id))
-                                                }
-                                                Err(_) => {
-                                                    force = true;
-                                                    false
-                                                }
+                                                    })?
+                                                    .seconds();
+                                                let mut ancestors = remote_id
+                                                    .to_owned()
+                                                    .ancestors(&repo.objects)
+                                                    .sorting(
+                                                        gix_traverse::commit::simple::Sorting::ByCommitTimeCutoff {
+                                                            order: Default::default(),
+                                                            seconds: local_commit_time,
+                                                        },
+                                                    )
+                                                    .or_raise(|| {
+                                                        gix_error::message(
+                                                            "Could not start fast-forward ancestor check",
+                                                        )
+                                                    })?;
+                                                // Stop at either a matching ancestor or the first traversal error.
+                                                ancestors
+                                                    .find(|entry| {
+                                                        entry.as_ref().map_or(true, |entry| entry.id == local_id)
+                                                    })
+                                                    .transpose()
+                                                    .or_raise(|| {
+                                                        gix_error::message(
+                                                            "Could not traverse commits for fast-forward ancestor check",
+                                                        )
+                                                    })?
+                                                    .is_some()
+                                            } else {
+                                                force = true;
+                                                false
                                             }
                                         }
                                         fetch::DryRun::Yes => true,
@@ -210,9 +231,7 @@ pub(crate) fn update(
                                     PreviousValue::MustExistAndMatch(existing.target().into_owned()),
                                 )
                             }
-                            Err(crate::reference::peel::Error::ToId(gix_ref::peel::to_id::Error::FollowToObject(
-                                gix_ref::peel::to_object::Error::Follow(_),
-                            ))) => {
+                            Err(err) if err.downcast_any_ref::<gix_ref::file::find::NotFound>().is_some() => {
                                 // An unborn reference, always allow it to be changed to whatever the remote wants.
                                 (
                                     if existing.target().try_name().map(gix_ref::FullNameRef::as_bstr)
@@ -227,11 +246,16 @@ pub(crate) fn update(
                                     PreviousValue::MustExistAndMatch(existing.target().into_owned()),
                                 )
                             }
-                            Err(err) => return Err(err.into()),
+                            Err(err) => return Err(err),
                         }
                     }
                     None => {
-                        let name: gix_ref::FullName = name.try_into()?;
+                        let name = gix_ref::FullName::try_from(name).or_raise(|| {
+                            gix_error::message(
+                                "A remote reference had a name that wasn't considered valid. \
+                                 Corrupt remote repo or insufficient checks on remote?",
+                            )
+                        })?;
                         let reflog_msg = match name.category() {
                             Some(gix_ref::Category::Tag) => "storing tag",
                             Some(gix_ref::Category::LocalBranch) => "storing head",
@@ -316,10 +340,9 @@ pub(crate) fn update(
     let edits = match dry_run {
         fetch::DryRun::No => {
             let _span = gix_trace::detail!("apply", edits = edits.len());
-            let (file_lock_fail, packed_refs_lock_fail) = repo
-                .config
-                .lock_timeout()
-                .map_err(crate::reference::edit::Error::from)?;
+            let (file_lock_fail, packed_refs_lock_fail) = repo.config.lock_timeout().or_raise(|| {
+                gix_error::message("Failed to update references to their new position to match their remote locations")
+            })?;
             repo.refs
                 .transaction()
                 .packed_refs(
@@ -330,9 +353,25 @@ pub(crate) fn update(
                     }
                 )
                 .prepare(edits, file_lock_fail, packed_refs_lock_fail)
-                .map_err(crate::reference::edit::Error::from)?
-                .commit(repo.committer().transpose().map_err(|err| update::Error::EditReferences(crate::reference::edit::Error::ParseCommitterTime(err)))?)
-                .map_err(crate::reference::edit::Error::from)?
+                .or_raise(|| {
+                    gix_error::message(
+                        "Failed to update references to their new position to match their remote locations",
+                    )
+                })?
+                .commit(
+                    repo.committer()
+                        .transpose()
+                        .or_raise(|| {
+                            gix_error::message(
+                                "Failed to update references to their new position to match their remote locations",
+                            )
+                        })?,
+                )
+                .or_raise(|| {
+                    gix_error::message(
+                        "Failed to update references to their new position to match their remote locations",
+                    )
+                })?
         }
         fetch::DryRun::Yes => edits,
     };
@@ -387,7 +426,7 @@ fn update_needs_adjustment_as_edits_symbolic_target_is_missing(
 ///
 /// Born symbolic remote refs are written as direct refs to the advertised target object id.
 /// Unborn remote refs remain symbolic as there is no object id to write.
-fn new_value_by_remote(remote: &Source) -> Result<Target, update::Error> {
+fn new_value_by_remote(remote: &Source) -> Result<Target> {
     let remote_id = remote.as_id();
     Ok(
         if let Source::Ref(
@@ -397,7 +436,12 @@ fn new_value_by_remote(remote: &Source) -> Result<Target, update::Error> {
             match remote_id {
                 Some(desired_id) => Target::Object(desired_id.to_owned()),
                 // Unborn branches we create as such, with the location they point to on the remote which helps mirroring.
-                None => Target::Symbolic(target.try_into()?),
+                None => Target::Symbolic(gix_ref::FullName::try_from(target).or_raise(|| {
+                    gix_error::message(
+                        "A remote reference had a name that wasn't considered valid. \
+                         Corrupt remote repo or insufficient checks on remote?",
+                    )
+                })?),
             }
         } else {
             Target::Object(remote_id.expect("unborn case handled earlier").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 b7a029a11c0..00d7d01d648 100644
--- a/gix/src/remote/connection/fetch/update_refs/tests.rs
+++ b/gix/src/remote/connection/fetch/update_refs/tests.rs
@@ -341,6 +341,15 @@ mod update {
     #[test]
     fn unborn_remote_branches_can_update_local_unborn_branches() -> Result {
         let repo = named_repo("unborn");
+        let peel_err = repo
+            .find_reference("refs/heads/existing-unborn-symbolic")?
+            .peel_to_id()
+            .expect_err("the local symbolic reference points to a missing branch");
+        insta::assert_debug_snapshot!(peel_err, "the missing reference remains available for update recovery", @r#"The ref partially named "refs/heads/main" could not be found"#);
+        assert!(
+            peel_err.downcast_any_ref::<gix_ref::file::find::NotFound>().is_some(),
+            "the missing reference remains available for update recovery"
+        );
         let (mappings, specs) = mapping_from_spec("HEAD:refs/heads/existing-unborn-symbolic", &repo);
         assert_eq!(mappings.len(), 1);
         let out = fetch::refs::update(
@@ -510,6 +519,111 @@ mod update {
         Ok(())
     }
 
+    #[test]
+    fn symbolic_tags_with_malformed_referents_are_not_unborn() -> Result {
+        let mut diagnostics = Vec::new();
+        let (repo, _tmp) = repo_rw("two-origins");
+        std::fs::write(repo.git_dir().join("refs/tags/broken"), b"ref: refs/tags/malformed\n")?;
+        let (mappings, specs) = mapping_from_spec("refs/heads/main:refs/tags/broken", &repo);
+        std::fs::write(repo.git_dir().join("refs/tags/malformed"), b"invalid")?;
+        for dry_run in [fetch::DryRun::Yes, fetch::DryRun::No] {
+            let err = fetch::refs::update(
+                &repo,
+                prefixed("action"),
+                &mappings,
+                &specs,
+                &[],
+                fetch::Tags::None,
+                dry_run,
+                fetch::WritePackedRefs::Never,
+            )
+            .expect_err("malformed referents must not be treated as unborn");
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+            assert!(err.is_corrupted(), "the original decode failure is propagated");
+            assert!(err.downcast_any_ref::<gix_ref::file::find::ReferenceDecode>().is_some());
+        }
+        assert_eq!(
+            repo.find_reference("refs/tags/broken")?.target().into_owned(),
+            Target::Symbolic("refs/tags/malformed".try_into()?),
+            "the failed update preserves the symbolic tag"
+        );
+        insta::assert_debug_snapshot!(diagnostics, "symbolic tags with malformed referents are not unborn", @r#"
+        [
+            Could not peel symbolic local reference to its ID
+            |
+            └─ The reference at "refs/tags/malformed" could not be decoded
+            |
+            └─ Reference content could not be parsed, "input"="invalid",
+            Could not peel symbolic local reference to its ID
+            |
+            └─ The reference at "refs/tags/malformed" could not be decoded
+            |
+            └─ Reference content could not be parsed, "input"="invalid",
+        ]
+        "#);
+        Ok(())
+    }
+
+    #[test]
+    fn symbolic_tags_with_missing_objects_are_not_unborn() -> Result {
+        let mut diagnostics = Vec::new();
+        let (repo, _tmp) = repo_rw("two-origins");
+        let worktree = repo.workdir().expect("fixture has a worktree");
+        let missing_id = hex_to_id(&"1".repeat(repo.object_hash().len_in_hex()));
+        std::fs::write(repo.git_dir().join("refs/tags/broken"), b"ref: refs/tags/missing\n")?;
+        std::fs::write(repo.git_dir().join("refs/tags/missing"), format!("{missing_id}\n"))?;
+
+        let output = gix_testtools::git_command(worktree)
+            .args(["fetch", "--no-tags", "origin", "refs/heads/main:refs/tags/broken"])
+            .output()?;
+        assert!(
+            !output.status.success(),
+            "Git rejects replacing the broken tag without force"
+        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&format_args!("{}", String::from_utf8_lossy(&output.stderr)), &[(&_tmp.path().canonicalize()?.to_string_lossy(), "<fixture>"), (&_tmp.path().to_string_lossy(), "<fixture>")]), "Git rejects the fetch because the symbolic tag points to a missing object", @"
+        fatal: bad object refs/tags/broken
+        error: <fixture>/base did not send all necessary objects
+        ");
+
+        let (mappings, specs) = mapping_from_spec("refs/heads/main:refs/tags/broken", &repo);
+        for dry_run in [fetch::DryRun::Yes, fetch::DryRun::No] {
+            let err = fetch::refs::update(
+                &repo,
+                prefixed("action"),
+                &mappings,
+                &specs,
+                &[],
+                fetch::Tags::None,
+                dry_run,
+                fetch::WritePackedRefs::Never,
+            )
+            .expect_err("a missing object is a peeling failure, not an unborn reference");
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+            assert!(
+                err.is_not_found()
+                    && err.metadata().any(|details| details.get("object_id")
+                        == Some(&gix_error::MetadataValue::from(missing_id.to_string()))),
+                "the missing-object peeling error is propagated: {err:?}"
+            );
+        }
+        assert_eq!(
+            repo.find_reference("refs/tags/broken")?.target().into_owned(),
+            Target::Symbolic("refs/tags/missing".try_into()?),
+            "the symbolic tag is preserved"
+        );
+        insta::assert_debug_snapshot!(diagnostics, "both dry-run and real fetches retain the missing-object peeling failure", @r#"
+        [
+            Could not peel symbolic local reference to its ID
+            |
+            └─ Could not peel reference to an object: object could not be found, "object_id"="Oid(1)", "reference"="refs/tags/missing",
+            Could not peel symbolic local reference to its ID
+            |
+            └─ Could not peel reference to an object: object could not be found, "object_id"="Oid(1)", "reference"="refs/tags/missing",
+        ]
+        "#);
+        Ok(())
+    }
+
     #[test]
     fn local_symbolic_refs_can_be_overwritten() {
         let repo = repo("two-origins");
@@ -900,6 +1014,83 @@ mod update {
         }
     }
 
+    #[test]
+    fn malformed_commits_cannot_force_reference_updates() -> Result {
+        let mut diagnostics = Vec::new();
+        use gix_object::Write;
+
+        let (repo, _tmp) = repo_rw("two-origins");
+        let malformed_commit_id = repo
+            .objects
+            .write_buf(gix_object::Kind::Commit, b"malformed commit")
+            .map_err(gix_error::Exn::into_error)?;
+        let commit_id = repo.head_id()?;
+        let name = "refs/remotes/origin/broken";
+        for (local_id, remote_id) in [
+            (malformed_commit_id, commit_id.into()),
+            (commit_id.into(), malformed_commit_id),
+        ] {
+            repo.reference(name, local_id, PreviousValue::Any, "install local target")?;
+            let (mappings, specs) = mapping_from_spec(&format!("{remote_id}:{name}"), &repo);
+            let err = fetch::refs::update(
+                &repo,
+                prefixed("fetch"),
+                &mappings,
+                &specs,
+                &[],
+                fetch::Tags::None,
+                fetch::DryRun::No,
+                fetch::WritePackedRefs::Never,
+            )
+            .expect_err("a failed ancestry check must not authorize a forced update");
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+            assert!(err.is_validation(), "the commit parser's cause survives");
+            assert_eq!(
+                repo.find_reference(name)?.id(),
+                local_id,
+                "the failed check cannot change the ref"
+            );
+        }
+        insta::assert_debug_snapshot!(diagnostics, "malformed commits cannot force reference updates", @"
+        [
+            Could not read local commit time for fast-forward ancestor check
+            |
+            └─ object parsing failed,
+            Could not start fast-forward ancestor check
+            |
+            └─ A commit could not be decoded during traversal
+            |
+            └─ object parsing failed,
+        ]
+        ");
+        Ok(())
+    }
+
+    #[test]
+    fn non_commit_targets_can_still_be_updated() -> Result {
+        let (repo, _tmp) = repo_rw("two-origins");
+        let blob_id = repo.write_blob(b"valid blob")?;
+        let commit_id = repo.head_id()?;
+        let name = "refs/remotes/origin/non-commit";
+        for (local_id, remote_id) in [(blob_id, commit_id), (commit_id, blob_id)] {
+            repo.reference(name, local_id, PreviousValue::Any, "install local target")?;
+            let (mappings, specs) = mapping_from_spec(&format!("{remote_id}:{name}"), &repo);
+            let out = fetch::refs::update(
+                &repo,
+                prefixed("fetch"),
+                &mappings,
+                &specs,
+                &[],
+                fetch::Tags::None,
+                fetch::DryRun::No,
+                fetch::WritePackedRefs::Never,
+            )?;
+            assert_eq!(out.updates[0].mode, fetch::refs::update::Mode::Forced);
+            assert_eq!(repo.find_reference(name)?.id(), remote_id);
+        }
+        Ok(())
+    }
+
     #[test]
     fn fast_forwards_are_called_out_even_if_force_is_given() {
         let (repo, _tmp) = repo_rw("two-origins");
diff --git a/gix/src/remote/connection/fetch/update_refs/update.rs b/gix/src/remote/connection/fetch/update_refs/update.rs
index bda67480a15..51354c62a68 100644
--- a/gix/src/remote/connection/fetch/update_refs/update.rs
+++ b/gix/src/remote/connection/fetch/update_refs/update.rs
@@ -2,36 +2,6 @@ use std::path::PathBuf;
 
 use crate::remote::fetch;
 
-mod error {
-    /// The error returned when updating references.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FindReference(#[from] crate::reference::find::Error),
-        #[error(
-            "A remote reference had a name that wasn't considered valid. Corrupt remote repo or insufficient checks on remote?"
-        )]
-        InvalidRefName(#[from] gix_validate::reference::name::Error),
-        #[error("Failed to update references to their new position to match their remote locations")]
-        EditReferences(#[from] crate::reference::edit::Error),
-        #[error("Failed to read or iterate worktree dir")]
-        WorktreeListing(#[from] std::io::Error),
-        #[error("Could not open worktree repository")]
-        OpenWorktreeRepo(#[from] crate::open::Error),
-        #[error("Could not find local commit for fast-forward ancestor check")]
-        FindCommit(#[from] crate::object::find::existing::Error),
-        #[error("Could not peel symbolic local reference to its ID")]
-        PeelToId(#[from] crate::reference::peel::Error),
-        #[error("Failed to follow a symbolic reference to assure worktree isn't affected")]
-        FollowSymref(#[from] gix_ref::file::find::existing::Error),
-        #[error(transparent)]
-        FindObject(#[from] crate::object::find::Error),
-    }
-}
-
-pub use error::Error;
-
 /// The outcome of the refs-update operation at the end of a fetch.
 #[derive(Debug, Clone)]
 pub struct Outcome {
@@ -54,7 +24,11 @@ pub enum Mode {
     NoChangeNeeded,
     /// The old ref's commit was an ancestor of the new one, allowing for a fast-forward without a merge.
     FastForward,
-    /// The ref was set to point to the new commit from the remote without taking into consideration its ancestry.
+    /// The ref was set to the new target from the remote without requiring a fast-forward.
+    ///
+    /// An explicitly forced ref-spec (with a leading `+`) permits non-fast-forward updates and replacing existing tags.
+    /// This mode can also occur without `+` when a non-tag ref's old or new target is not a commit (e.g. a tree or blob),
+    /// or when the local ref is unborn: in these cases, there is no commit ancestry to compare.
     Forced,
     /// A new ref has been created as there was none before.
     New,
diff --git a/gix/src/remote/connection/ref_map.rs b/gix/src/remote/connection/ref_map.rs
index 1a5afe55026..c959e24e405 100644
--- a/gix/src/remote/connection/ref_map.rs
+++ b/gix/src/remote/connection/ref_map.rs
@@ -1,3 +1,4 @@
+use gix_error::{ErrorExt, ResultExt};
 use gix_features::progress::Progress;
 #[cfg(feature = "async-network-client")]
 use gix_transport::client::async_io::Transport;
@@ -5,41 +6,10 @@ use gix_transport::client::async_io::Transport;
 use gix_transport::client::blocking_io::Transport;
 
 use crate::{
-    bstr::BString,
+    Result,
     remote::{Connection, connection::ConnectionDetached, fetch},
 };
 
-/// The error returned by [`Connection::ref_map()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    InitRefMap(#[from] gix_protocol::fetch::refmap::init::Error),
-    #[error("Failed to configure the transport before connecting to {url:?}")]
-    GatherTransportConfig {
-        url: BString,
-        source: crate::config::transport::Error,
-    },
-    #[error("Failed to configure the transport layer")]
-    ConfigureTransport(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
-    #[error(transparent)]
-    Handshake(#[from] gix_protocol::handshake::Error),
-    #[error(transparent)]
-    Transport(#[from] gix_protocol::transport::client::Error),
-    #[error(transparent)]
-    ConfigureCredentials(#[from] crate::config::credential_helpers::Error),
-}
-
-impl gix_protocol::transport::IsSpuriousError for Error {
-    fn is_spurious(&self) -> bool {
-        match self {
-            Error::Transport(err) => err.is_spurious(),
-            Error::Handshake(err) => err.is_spurious(),
-            _ => false,
-        }
-    }
-}
-
 /// For use in [`Connection::ref_map()`].
 #[derive(Debug, Clone)]
 pub struct Options {
@@ -91,7 +61,7 @@ where
         self,
         progress: impl Progress,
         options: Options,
-    ) -> Result<(fetch::RefMap, gix_protocol::Handshake), Error> {
+    ) -> Result<(fetch::RefMap, gix_protocol::Handshake)> {
         let repo = self.remote.repo;
         self.into_detached().ref_map(repo, progress, options).await
     }
@@ -107,7 +77,7 @@ where
         repo: &crate::Repository,
         progress: impl Progress,
         options: Options,
-    ) -> Result<(fetch::RefMap, gix_protocol::Handshake), Error> {
+    ) -> Result<(fetch::RefMap, gix_protocol::Handshake)> {
         let refmap = self.ref_map_by_ref(repo, progress, options).await?;
         let handshake = self
             .handshake
@@ -125,7 +95,7 @@ where
             handshake_parameters,
             mut extra_refspecs,
         }: Options,
-    ) -> Result<fetch::RefMap, Error> {
+    ) -> Result<fetch::RefMap> {
         let _span = gix_trace::coarse!("remote::Connection::ref_map()");
         if let Some(tag_spec) = self.remote.fetch_tags.to_refspec().map(|spec| spec.to_owned())
             && !extra_refspecs.contains(&tag_spec)
@@ -145,13 +115,17 @@ where
         if self.transport_options.is_none() {
             self.transport_options = repo
                 .transport_options(url.as_ref(), self.remote.name().map(crate::remote::Name::as_bstr))
-                .map_err(|err| Error::GatherTransportConfig {
-                    source: err,
-                    url: url.into_owned(),
+                .map_err(|err| {
+                    err.and_raise(gix_error::corruption(format!(
+                        "Failed to configure the transport before connecting to {url:?}"
+                    )))
                 })?;
         }
         if let Some(config) = self.transport_options.as_ref() {
-            self.transport.inner.configure(&**config)?;
+            self.transport
+                .inner
+                .configure(&**config)
+                .or_raise(|| gix_error::message("Failed to configure the transport layer"))?;
         }
         let mut handshake = gix_protocol::handshake(
             &mut self.transport.inner,
diff --git a/gix/src/remote/errors.rs b/gix/src/remote/errors.rs
deleted file mode 100644
index 6dbb3e38cb7..00000000000
--- a/gix/src/remote/errors.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-///
-pub mod find {
-    use crate::{bstr::BString, config, remote};
-
-    /// The error returned by [`Repository::find_remote(…)`](crate::Repository::find_remote()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The value for 'remote.<name>.tagOpt` is invalid and must either be '--tags' or '--no-tags'")]
-        TagOpt(#[from] config::key::GenericErrorWithValue),
-        #[error("{kind} ref-spec under `remote.{remote_name}` was invalid")]
-        RefSpec {
-            kind: &'static str,
-            remote_name: BString,
-            source: config::refspec::Error,
-        },
-        #[error("The {kind} url under `remote.{remote_name}` was invalid")]
-        Url {
-            kind: &'static str,
-            remote_name: BString,
-            source: config::url::Error,
-        },
-        #[error(transparent)]
-        Init(#[from] remote::init::Error),
-    }
-
-    ///
-    pub mod existing {
-        use crate::bstr::BString;
-
-        /// The error returned by [`Repository::find_remote(…)`](crate::Repository::find_remote()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            Find(#[from] super::Error),
-            #[error("remote name could not be parsed as URL")]
-            UrlParse(#[from] gix_error::Error),
-            #[error("The remote named {name:?} did not exist")]
-            NotFound { name: BString },
-        }
-    }
-
-    ///
-    pub mod for_fetch {
-        /// The error returned by [`Repository::find_fetch_remote(…)`](crate::Repository::find_fetch_remote()).
-        #[derive(Debug, thiserror::Error)]
-        #[expect(missing_docs)]
-        pub enum Error {
-            #[error(transparent)]
-            FindExisting(#[from] super::existing::Error),
-            #[error(transparent)]
-            FindExistingReferences(#[from] crate::reference::find::existing::Error),
-            #[error("Could not initialize a URL remote")]
-            Init(#[from] crate::remote::init::Error),
-            #[error("remote name could not be parsed as URL")]
-            UrlParse(#[from] gix_error::Error),
-            #[error("No configured remote could be found, or too many were available")]
-            ExactlyOneRemoteNotAvailable,
-        }
-    }
-}
diff --git a/gix/src/remote/fetch.rs b/gix/src/remote/fetch.rs
index 4e28ea2ba56..115dea179e3 100644
--- a/gix/src/remote/fetch.rs
+++ b/gix/src/remote/fetch.rs
@@ -2,14 +2,10 @@
 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;
 }
 
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
-pub use super::connection::fetch::{
-    Error, Outcome, Prepare, ProgressId, RefLogMessage, Status, outcome, prepare, refs,
-};
+pub use super::connection::fetch::{Outcome, Prepare, ProgressId, RefLogMessage, Status, outcome, refs};
 
 /// If `Yes`, don't really make changes but do as much as possible to get an idea of what would be done.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
diff --git a/gix/src/remote/init.rs b/gix/src/remote/init.rs
index 28521df0ac7..7a182337513 100644
--- a/gix/src/remote/init.rs
+++ b/gix/src/remote/init.rs
@@ -1,25 +1,8 @@
-use gix_refspec::RefSpec;
-
-use crate::{Remote, Repository, config, remote};
+use gix_error::ResultExt;
 
-mod error {
-    use crate::bstr::BString;
+use gix_refspec::RefSpec;
 
-    /// The error returned by [`Repository::remote_at(…)`][crate::Repository::remote_at()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Url(#[from] gix_error::Error),
-        #[error("The rewritten {kind} url {rewritten_url:?} failed to parse")]
-        RewrittenUrlInvalid {
-            kind: &'static str,
-            rewritten_url: BString,
-            source: gix_error::Error,
-        },
-    }
-}
-pub use error::Error;
+use crate::{Error, Remote, Repository, Result, config, remote};
 
 use crate::bstr::BString;
 
@@ -38,7 +21,7 @@ impl<'repo> Remote<'repo> {
         should_rewrite_urls: bool,
         fetch_tags: remote::fetch::Tags,
         repo: &'repo Repository,
-    ) -> Result<Self, Error> {
+    ) -> Result<Self> {
         let (url_aliases, url_push_aliases, push_url_aliases) = if should_rewrite_urls {
             rewrite_urls(&repo.config, &urls, &push_urls)
         } else {
@@ -62,27 +45,15 @@ impl<'repo> Remote<'repo> {
         })
     }
 
-    pub(crate) fn from_fetch_url<Url, E>(
-        url: Url,
-        should_rewrite_urls: bool,
-        repo: &'repo Repository,
-    ) -> Result<Self, Error>
+    pub(crate) fn from_fetch_url<Url, E>(url: Url, should_rewrite_urls: bool, repo: &'repo Repository) -> Result<Self>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        Self::from_fetch_url_inner(
-            url.try_into().map_err(gix_error::Error::from_error)?,
-            should_rewrite_urls,
-            repo,
-        )
+        Self::from_fetch_url_inner(url.try_into().or_erased()?, should_rewrite_urls, repo)
     }
 
-    fn from_fetch_url_inner(
-        url: gix_url::Url,
-        should_rewrite_urls: bool,
-        repo: &'repo Repository,
-    ) -> Result<Self, Error> {
+    fn from_fetch_url_inner(url: gix_url::Url, should_rewrite_urls: bool, repo: &'repo Repository) -> Result<Self> {
         let urls = vec![url];
         let (url_aliases, url_push_aliases, _) = if should_rewrite_urls {
             rewrite_urls(&repo.config, &urls, &[])
@@ -109,18 +80,17 @@ pub(crate) fn rewrite_url(
     url: &gix_url::Url,
     direction: remote::Direction,
     error_kind: remote::Direction,
-) -> Result<Option<gix_url::Url>, Error> {
+) -> Result<Option<gix_url::Url>> {
     config
         .url_rewrite()
         .longest(url, direction)
         .map(|url| {
-            gix_url::parse(&url).map_err(|err| Error::RewrittenUrlInvalid {
-                kind: match error_kind {
+            gix_url::parse(&url).map_err(|err| {
+                let kind = match error_kind {
                     remote::Direction::Fetch => "fetch",
                     remote::Direction::Push => "push",
-                },
-                source: err.into_error(),
-                rewritten_url: url,
+                };
+                Error::from(err.raise(gix_error::message!("The rewritten {kind} url {url:?} failed to parse")))
             })
         })
         .transpose()
@@ -130,7 +100,7 @@ pub(crate) fn rewrite_url_aliases(
     config: &config::Cache,
     urls: &[gix_url::Url],
     direction: remote::Direction,
-) -> Result<Vec<Option<gix_url::Url>>, Error> {
+) -> Result<Vec<Option<gix_url::Url>>> {
     rewrite_url_aliases_with_error_kind(config, urls, direction, direction)
 }
 
@@ -139,7 +109,7 @@ pub(crate) fn rewrite_url_aliases_with_error_kind(
     urls: &[gix_url::Url],
     direction: remote::Direction,
     error_kind: remote::Direction,
-) -> Result<Vec<Option<gix_url::Url>>, Error> {
+) -> Result<Vec<Option<gix_url::Url>>> {
     urls.iter()
         .map(|url| rewrite_url(config, url, direction, error_kind))
         .collect()
@@ -204,7 +174,7 @@ pub(crate) fn rewrite_urls(
     config: &config::Cache,
     urls: &[gix_url::Url],
     push_urls: &[gix_url::Url],
-) -> Result<UrlRewriteAliases, Error> {
+) -> Result<UrlRewriteAliases> {
     let url_aliases = rewrite_url_aliases(config, urls, remote::Direction::Fetch)?;
     let url_push_aliases = if push_urls.is_empty() {
         rewrite_url_aliases_with_fallback_non_destructive(
diff --git a/gix/src/remote/mod.rs b/gix/src/remote/mod.rs
index 94bdf58cecb..64e3ba11a8d 100644
--- a/gix/src/remote/mod.rs
+++ b/gix/src/remote/mod.rs
@@ -40,9 +40,6 @@ pub mod name;
 
 mod build;
 
-mod errors;
-pub use errors::find;
-
 ///
 pub mod init;
 
diff --git a/gix/src/remote/name.rs b/gix/src/remote/name.rs
index 8a5fc2d0c81..234c91327bf 100644
--- a/gix/src/remote/name.rs
+++ b/gix/src/remote/name.rs
@@ -1,28 +1,28 @@
 use std::borrow::Cow;
 
 use super::Name;
-use crate::bstr::{BStr, BString, ByteSlice, ByteVec};
-
-/// The error returned by [validated()].
-#[derive(Debug, thiserror::Error)]
-#[error("remote names must be valid within refspecs for fetching: {name:?}")]
-#[expect(missing_docs)]
-pub struct Error {
-    pub source: gix_refspec::parse::Error,
-    pub name: BString,
-}
+use crate::{
+    Error, Result,
+    bstr::{BStr, BString, ByteSlice, ByteVec},
+};
 
 /// Return `name` if it is valid as symbolic remote name.
 ///
 /// This means it has to be valid within a the ref path of a tracking branch.
-pub fn validated(name: impl Into<BString>) -> Result<BString, Error> {
+/// Errors include the remote name bytes as `input` [metadata](gix_error::Error::metadata()).
+pub fn validated(name: impl Into<BString>) -> Result<BString> {
     let name = name.into();
     match gix_refspec::parse(
         format!("refs/heads/test:refs/remotes/{name}/test").as_str().into(),
         gix_refspec::parse::Operation::Fetch,
     ) {
         Ok(_) => Ok(name),
-        Err(err) => Err(Error { source: err, name }),
+        Err(err) => Err(Error::from(
+            err.raise(
+                gix_error::validation("remote names must be valid within refspecs for fetching")
+                    .with("input", name.clone()),
+            ),
+        )),
     }
 }
 
@@ -63,7 +63,7 @@ impl Name<'_> {
 impl<'a> TryFrom<Cow<'a, BStr>> for Name<'a> {
     type Error = Cow<'a, BStr>;
 
-    fn try_from(name: Cow<'a, BStr>) -> Result<Self, Self::Error> {
+    fn try_from(name: Cow<'a, BStr>) -> std::result::Result<Self, Self::Error> {
         if name.contains(&b'/') || name.as_ref() == "." {
             Ok(Name::Url(name))
         } else {
diff --git a/gix/src/remote/save.rs b/gix/src/remote/save.rs
index 90a56c35b29..335fd6fac69 100644
--- a/gix/src/remote/save.rs
+++ b/gix/src/remote/save.rs
@@ -1,29 +1,7 @@
-use crate::{Remote, bstr::BStr, config, remote};
-use gix_utils::AsBStr;
-
-/// The error returned by [`Remote::save_to()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("The remote pointing to {} is anonymous and can't be saved.", url.to_bstring())]
-    NameMissing { url: gix_url::Url },
-    #[error(transparent)]
-    Span(#[from] gix_config::parse::span::Error),
-    #[error(transparent)]
-    ConfigValue(#[from] gix_config::file::section::value::Error),
-}
+use gix_error::ResultExt;
 
-/// The error returned by [`Remote::save_as_to()`].
-///
-/// Note that this type should rather be in the `as` module, but cannot be as it's part of the Rust syntax.
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum AsError {
-    #[error(transparent)]
-    Save(#[from] Error),
-    #[error(transparent)]
-    Name(#[from] crate::remote::name::Error),
-}
+use crate::{Error, Remote, Result, bstr::BStr, config, remote};
+use gix_utils::AsBStr;
 
 /// Serialize into git-config.
 impl Remote<'_> {
@@ -32,18 +10,17 @@ impl Remote<'_> {
     /// Note that all sections named `remote "<name>"` will be cleared of all values we are about to write,
     /// and the last `remote "<name>"` section will be containing all relevant values so that reloading the remote
     /// from `config` would yield the same in-memory state.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
-    pub fn save_to(&self, config: &mut gix_config::File) -> Result<(), Error> {
-        let name = self.name().ok_or_else(|| Error::NameMissing {
-            url: self
+    pub fn save_to(&self, config: &mut gix_config::File) -> Result<()> {
+        let name = self.name().ok_or_else(|| {
+            let url = self
                 .urls
                 .first()
                 .or_else(|| self.push_urls.first())
                 .expect("one url is always set")
-                .to_owned(),
+                .to_bstring();
+            Error::from_error(gix_error::message!(
+                "The remote pointing to {url} is anonymous and can't be saved."
+            ))
         })?;
         let target_meta = config.meta().clone();
         let mut needs_url_reset = false;
@@ -104,26 +81,30 @@ impl Remote<'_> {
                 .expect("section name is validated and 'remote' is acceptable")
         };
         if needs_url_reset {
-            section.push(config::tree::Remote::URL.name, "")?;
+            section.push(config::tree::Remote::URL.name, "").or_erased()?;
         }
         for url in &self.urls {
-            section.push("url", url.to_bstring())?;
+            section.push("url", url.to_bstring()).or_erased()?;
         }
         if needs_push_url_reset {
-            section.push(config::tree::Remote::PUSH_URL.name, "")?;
+            section.push(config::tree::Remote::PUSH_URL.name, "").or_erased()?;
         }
         for url in &self.push_urls {
-            section.push("pushurl", url.to_bstring())?;
+            section.push("pushurl", url.to_bstring()).or_erased()?;
         }
         if self.fetch_tags != Default::default() {
-            section.push(
-                config::tree::Remote::TAG_OPT.name,
-                BStr::new(match self.fetch_tags {
-                    remote::fetch::Tags::All => "--tags",
-                    remote::fetch::Tags::None => "--no-tags",
-                    remote::fetch::Tags::Included => unreachable!("BUG: the default shouldn't be written and we try"),
-                }),
-            )?;
+            section
+                .push(
+                    config::tree::Remote::TAG_OPT.name,
+                    BStr::new(match self.fetch_tags {
+                        remote::fetch::Tags::All => "--tags",
+                        remote::fetch::Tags::None => "--no-tags",
+                        remote::fetch::Tags::Included => {
+                            unreachable!("BUG: the default shouldn't be written and we try")
+                        }
+                    }),
+                )
+                .or_erased()?;
         }
         for (key, spec) in self
             .fetch_specs
@@ -131,7 +112,7 @@ impl Remote<'_> {
             .map(|spec| ("fetch", spec))
             .chain(self.push_specs.iter().map(|spec| ("push", spec)))
         {
-            section.push(key, spec.to_ref().to_bstring())?;
+            section.push(key, spec.to_ref().to_bstring()).or_erased()?;
         }
         Ok(())
     }
@@ -141,17 +122,12 @@ impl Remote<'_> {
     /// Note that this sets a name for anonymous remotes, but overwrites the name for those who were named before.
     /// If this name is different from the current one, the git configuration will still contain the previous name,
     /// and the caller should account for that.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
-    pub fn save_as_to(&mut self, name: impl AsBStr, config: &mut gix_config::File) -> Result<(), AsError> {
+    pub fn save_as_to(&mut self, name: impl AsBStr, config: &mut gix_config::File) -> Result<()> {
         let name = crate::remote::name::validated(name.as_bstr().to_owned())?;
         let prev_name = self.name.take();
         self.name = Some(name.into());
-        self.save_to(config).map_err(|err| {
+        self.save_to(config).inspect_err(|_| {
             self.name = prev_name;
-            err.into()
         })
     }
 }
diff --git a/gix/src/remote/url/scheme_permission.rs b/gix/src/remote/url/scheme_permission.rs
index 103c51ea8ff..6df6af5bdbf 100644
--- a/gix/src/remote/url/scheme_permission.rs
+++ b/gix/src/remote/url/scheme_permission.rs
@@ -1,8 +1,10 @@
+use gix_error::ResultExt;
+
 use std::collections::BTreeMap;
 
 use crate::{
+    Result,
     bstr::{BStr, BString, ByteSlice},
-    config,
     config::tree::{Protocol, gitoxide},
 };
 
@@ -17,17 +19,6 @@ pub enum Allow {
     User,
 }
 
-/// The error returned when obtaining transport permissions from configuration.
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    /// The value of `protocol[.<name>].allow` was invalid.
-    #[error(transparent)]
-    Allow(#[from] config::protocol::allow::Error),
-    /// `GIT_PROTOCOL_FROM_USER` was not a valid Git boolean.
-    #[error(transparent)]
-    ProtocolFromUser(#[from] config::boolean::Error),
-}
-
 impl Allow {
     /// Return true if we represent something like 'allow == true'.
     pub fn to_bool(self, user_allowed: Option<bool>) -> bool {
@@ -42,7 +33,7 @@ impl Allow {
 impl TryFrom<&BStr> for Allow {
     type Error = BString;
 
-    fn try_from(v: &BStr) -> Result<Self, Self::Error> {
+    fn try_from(v: &BStr) -> std::result::Result<Self, Self::Error> {
         Ok(match v.as_bytes() {
             b"never" => Allow::Never,
             b"always" => Allow::Always,
@@ -65,10 +56,7 @@ pub(crate) struct SchemePermission {
 /// Init
 impl SchemePermission {
     /// NOTE: _intentionally without leniency_
-    pub fn from_config(
-        config: &gix_config::File,
-        mut filter: fn(&gix_config::file::Metadata) -> bool,
-    ) -> Result<Self, Error> {
+    pub fn from_config(config: &gix_config::File, mut filter: fn(&gix_config::file::Metadata) -> bool) -> Result<Self> {
         if let Some(allow_protocol) = config.string_filter(gitoxide::Allow::PROTOCOL, &mut filter) {
             return Ok(SchemePermission {
                 user_allowed: None,
@@ -107,7 +95,8 @@ impl SchemePermission {
         };
 
         let user_allowed = gitoxide::Allow::PROTOCOL_FROM_USER
-            .enrich_error(config.boolean_filter(gitoxide::Allow::PROTOCOL_FROM_USER, &mut filter))?;
+            .enrich_error(config.boolean_filter(gitoxide::Allow::PROTOCOL_FROM_USER, &mut filter))
+            .or_erased()?;
         Ok(SchemePermission {
             allow,
             allow_per_scheme,
diff --git a/gix/src/repository/attributes.rs b/gix/src/repository/attributes.rs
index ea62cea328e..114fdbeeb43 100644
--- a/gix/src/repository/attributes.rs
+++ b/gix/src/repository/attributes.rs
@@ -1,15 +1,7 @@
 //! exclude information
-use crate::{AttributeStack, Repository, config};
+use gix_error::ResultExt;
 
-/// The error returned by [`Repository::attributes()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    ConfigureAttributes(#[from] config::attribute_stack::Error),
-    #[error(transparent)]
-    ConfigureExcludes(#[from] config::exclude_stack::Error),
-}
+use crate::{AttributeStack, Repository, Result};
 
 impl Repository {
     /// Configure a file-system cache for accessing git attributes *and* excludes on a per-path basis.
@@ -32,20 +24,24 @@ impl Repository {
         attributes_source: gix_worktree::stack::state::attributes::Source,
         ignore_source: gix_worktree::stack::state::ignore::Source,
         exclude_overrides: Option<gix_ignore::Search>,
-    ) -> Result<AttributeStack<'_>, Error> {
+    ) -> Result<AttributeStack<'_>> {
         let case = if self.config.ignore_case {
             gix_glob::pattern::Case::Fold
         } else {
             gix_glob::pattern::Case::Sensitive
         };
-        let (attributes, mut buf) = self.config.assemble_attribute_globals(
-            self.common_dir(),
-            attributes_source,
-            self.options.permissions.attributes,
-        )?;
-        let ignore =
-            self.config
-                .assemble_exclude_globals(self.common_dir(), exclude_overrides, ignore_source, &mut buf)?;
+        let (attributes, mut buf) = self
+            .config
+            .assemble_attribute_globals(
+                self.common_dir(),
+                attributes_source,
+                self.options.permissions.attributes,
+            )
+            .or_erased()?;
+        let ignore = self
+            .config
+            .assemble_exclude_globals(self.common_dir(), exclude_overrides, ignore_source, &mut buf)
+            .or_erased()?;
         let state = gix_worktree::stack::State::AttributesAndIgnoreStack { attributes, ignore };
         let attribute_list = state.id_mappings_from_index(index, index.path_backing(), case);
         Ok(AttributeStack::new(
@@ -67,7 +63,7 @@ impl Repository {
         &self,
         index: &gix_index::State,
         attributes_source: gix_worktree::stack::state::attributes::Source,
-    ) -> Result<AttributeStack<'_>, config::attribute_stack::Error> {
+    ) -> Result<AttributeStack<'_>> {
         let case = if self.config.ignore_case {
             gix_glob::pattern::Case::Fold
         } else {
@@ -113,7 +109,7 @@ impl Repository {
         index: &gix_index::State,
         overrides: Option<gix_ignore::Search>,
         source: gix_worktree::stack::state::ignore::Source,
-    ) -> Result<AttributeStack<'_>, config::exclude_stack::Error> {
+    ) -> Result<AttributeStack<'_>> {
         let case = if self.config.ignore_case {
             gix_glob::pattern::Case::Fold
         } else {
diff --git a/gix/src/repository/blame.rs b/gix/src/repository/blame.rs
index 4f3177f4fb0..1d182b0309f 100644
--- a/gix/src/repository/blame.rs
+++ b/gix/src/repository/blame.rs
@@ -1,8 +1,10 @@
+use gix_error::ResultExt;
+
 use gix_blame::Start;
 use gix_hash::ObjectId;
 use gix_ref::bstr::BStr;
 
-use crate::{Repository, repository::blame_file};
+use crate::{Repository, Result, repository::blame_file};
 
 impl Repository {
     /// Produce a list of consecutive [`gix_blame::BlameEntry`] instances. Each `BlameEntry`
@@ -15,7 +17,7 @@ impl Repository {
         file_path: &BStr,
         suspect: impl Into<ObjectId>,
         options: blame_file::Options,
-    ) -> Result<gix_blame::Outcome, blame_file::Error> {
+    ) -> Result<gix_blame::Outcome> {
         let cache = self.commit_graph_if_enabled()?;
         let mut resource_cache = self.diff_resource_cache_for_tree_diff()?;
 
@@ -27,7 +29,7 @@ impl Repository {
         } = options;
         let diff_algorithm = match diff_algorithm {
             Some(diff_algorithm) => diff_algorithm,
-            None => self.diff_algorithm()?,
+            None => self.diff_algorithm().or_erased()?,
         };
 
         let options = gix_blame::Options {
diff --git a/gix/src/repository/branch.rs b/gix/src/repository/branch.rs
index 8f291f9b93d..e9768477296 100644
--- a/gix/src/repository/branch.rs
+++ b/gix/src/repository/branch.rs
@@ -1,3 +1,5 @@
+use crate::Result;
+use gix_error::{ErrorExt, ResultExt};
 use gix_ref::{
     Category, FullName,
     transaction::{PreviousValue, RefEdit},
@@ -9,58 +11,52 @@ pub mod delete {
 
     use gix_ref::FullName;
 
+    /// A branch-deletion rejection because the branch is checked out in a worktree.
+    #[derive(Debug)]
+    pub struct CheckedOutError {
+        /// The local branch whose checkout prevents deletion.
+        pub name: FullName,
+        /// The worktree directories in which the branch is checked out.
+        pub worktree_dirs: Vec<PathBuf>,
+    }
+
+    impl std::fmt::Display for CheckedOutError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(
+                f,
+                "The local branch {:?} is checked out in {:?}",
+                self.name, self.worktree_dirs
+            )
+        }
+    }
+
+    impl std::error::Error for CheckedOutError {}
+
     /// A configuration-cleanup failure after all requested references were made absent.
-    #[derive(Debug, thiserror::Error)]
-    pub enum CleanupError {
-        /// The updated configuration could not be written to its lock file; the existing config file is unchanged.
-        #[error("Could not write the updated local configuration")]
-        Write(#[source] std::io::Error),
-        /// The lock file containing the updated configuration could not replace the existing config file.
-        #[error("Could not commit the updated local configuration")]
-        Commit(#[source] std::io::Error),
+    #[derive(Debug)]
+    pub struct CleanupError {
+        /// Every requested reference name, including names which were already missing before the call.
+        ///
+        /// All of these references and their reflogs are guaranteed to be absent. Their `branch.<name>` configuration
+        /// sections may remain.
+        pub references: Vec<FullName>,
+        /// The branches actually deleted, as would have been returned on success.
+        ///
+        /// Names are sorted and deduplicated; branches missing when locked for deletion are excluded.
+        pub deleted: Vec<FullName>,
     }
 
-    /// The error returned by [`Repository::delete_local_branches()`][crate::Repository::delete_local_branches()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("{name:?} is not a local branch")]
-        NotLocal { name: FullName },
-
-        #[error("The local branch {name:?} is checked out in {worktree_dirs:?}")]
-        CheckedOut {
-            name: FullName,
-            worktree_dirs: Vec<PathBuf>,
-        },
-        #[error("Failed to read or iterate worktree directories")]
-        WorktreeListing(#[source] std::io::Error),
-        #[error("Could not open a worktree repository")]
-        OpenWorktreeRepo(#[source] crate::open::Error),
-        #[error("Failed to follow a symbolic reference while inspecting worktrees")]
-        FollowSymref(#[source] gix_ref::file::find::existing::Error),
-        #[error("Could not acquire the local configuration lock")]
-        ConfigLock(#[source] gix_error::Error),
-        #[error("Could not read the local configuration")]
-        ConfigRead(#[source] gix_config::file::init::from_paths::Error),
-        #[error("Could not delete local branches")]
-        EditReferences(#[from] crate::reference::edit::Error),
-        /// Reference deletion succeeded, but configuration cleanup failed.
-        #[error("References {references:?} are absent, but local branch configuration cleanup failed")]
-        Cleanup {
-            /// Every requested reference name, including names which were already missing before the call.
-            ///
-            /// All of these references and their reflogs are guaranteed to be absent. Their `branch.<name>` configuration
-            /// sections may remain; inspect `source` to determine which cleanup phase failed.
-            references: Vec<FullName>,
-            /// The branches actually deleted, as would have been returned on success.
-            ///
-            /// Names are sorted and deduplicated; branches missing when locked for deletion are excluded.
-            deleted: Vec<FullName>,
-            /// The configuration cleanup phase that failed.
-            #[source]
-            source: CleanupError,
-        },
+    impl std::fmt::Display for CleanupError {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(
+                f,
+                "References {:?} are absent, but local branch configuration cleanup failed",
+                self.references
+            )
+        }
     }
+
+    impl std::error::Error for CleanupError {}
 }
 
 impl crate::Repository {
@@ -70,19 +66,19 @@ impl crate::Repository {
     /// any name belongs to another reference category or is checked out in any worktree. Missing branches are accepted so any
     /// associated local configuration is still removed. **It deliberately performs no merged-state check**.
     ///
+    /// A checked-out branch rejection contains [`delete::CheckedOutError`] in its error chain, identifying the branch and
+    /// the worktree directories that prevented deletion.
+    ///
     /// On success, every requested reference and its reflog is absent, and every matching `branch.<name>` section has been
     /// removed from the local configuration. Return the sorted, deduplicated names of branches that existed when locked for
     /// deletion. Missing branches are omitted from the returned vector, but their configuration is still removed.
     ///
     /// Reference deletion and configuration cleanup cannot be one atomic transaction. Once reference deletion succeeds, a
-    /// configuration write or commit failure is returned as [`delete::Error::Cleanup`]. Its `references` field contains
-    /// every requested name—including names which were missing initially—and guarantees only that their references and reflogs
-    /// are absent. Its `deleted` field contains the branches actually deleted, just as in the success case.
-    /// See [`delete::CleanupError`] to determine whether the on-disk configuration was updated.
-    pub fn delete_local_branches(
-        &mut self,
-        names: impl IntoIterator<Item = FullName>,
-    ) -> Result<Vec<FullName>, delete::Error> {
+    /// configuration write or commit failure contains [`delete::CleanupError`] in its error chain. Its `references` field
+    /// contains every requested name—including names which were missing initially—and guarantees only that their references and
+    /// reflogs are absent. Its `deleted` field contains the branches actually deleted, just as in the success case.
+    /// The remaining error chain identifies the failed cleanup phase.
+    pub fn delete_local_branches(&mut self, names: impl IntoIterator<Item = FullName>) -> Result<Vec<FullName>> {
         let mut names: Vec<_> = names.into_iter().collect();
         names.sort();
         names.dedup();
@@ -92,21 +88,19 @@ impl crate::Repository {
 
         for name in &names {
             if name.category_and_short_name().map(|(category, _)| category) != Some(Category::LocalBranch) {
-                return Err(delete::Error::NotLocal { name: name.clone() });
+                return Err(gix_error::message!("{name:?} is not a local branch").raise().into());
             }
         }
 
-        let checked_out = self.checked_out_branches().map_err(|err| match err {
-            super::worktree::CheckedOutBranchesError::WorktreeListing(err) => delete::Error::WorktreeListing(err),
-            super::worktree::CheckedOutBranchesError::OpenWorktreeRepo(err) => delete::Error::OpenWorktreeRepo(err),
-            super::worktree::CheckedOutBranchesError::FollowSymref(err) => delete::Error::FollowSymref(err),
-        })?;
+        let checked_out = self.checked_out_branches()?;
         for name in &names {
             if let Some(worktree_dirs) = checked_out.get(name) {
-                return Err(delete::Error::CheckedOut {
+                return Err(delete::CheckedOutError {
                     name: name.clone(),
                     worktree_dirs: worktree_dirs.clone(),
-                });
+                }
+                .raise()
+                .into());
             }
         }
 
@@ -118,23 +112,23 @@ impl crate::Repository {
         let config_path = self.common_dir().join("config");
         let mut config_lock =
             gix_lock::File::acquire_to_update_resource(&config_path, gix_lock::acquire::Fail::Immediately, None)
-                .map_err(|err| delete::Error::ConfigLock(err.into_error()))?;
+                .or_raise(|| gix_error::message("Could not acquire the local configuration lock"))?;
         let mut config = match gix_config::File::from_path_no_includes(config_path.clone(), gix_config::Source::Local) {
             Ok(config) => Some(config),
-            // TODO(gix-error): this is what should just be `err.not_found()` in future, anywhere.
-            Err(gix_config::file::init::from_paths::Error::Io { source, .. })
-                if source.kind() == std::io::ErrorKind::NotFound =>
-            {
-                None
+            Err(err) if err.is_not_found() => None,
+            Err(err) => {
+                return Err(err
+                    .raise(gix_error::message("Could not read the local configuration"))
+                    .into());
             }
-            Err(err) => return Err(delete::Error::ConfigRead(err)),
         };
         let removed_config = config
             .as_mut()
             .is_some_and(|config| remove_branch_config(config, &names, |_| true));
 
         let deleted: Vec<_> = self
-            .edit_references(edits)?
+            .edit_references(edits)
+            .or_raise(|| gix_error::message("Could not delete local branches"))?
             .into_iter()
             .filter_map(|edit| edit.change.previous_value().is_some().then_some(edit.name))
             .collect();
@@ -143,16 +137,19 @@ impl crate::Repository {
             let config = config.expect("configuration was present when sections were removed");
             config
                 .write_to(&mut config_lock)
-                .map_err(|source| delete::Error::Cleanup {
+                .or_raise(|| gix_error::message("Could not write the updated local configuration"))
+                .or_raise(|| delete::CleanupError {
+                    references: names.clone(),
+                    deleted: deleted.clone(),
+                })?;
+            config_lock
+                .commit()
+                .map_err(|err| err.error)
+                .or_raise(|| gix_error::message("Could not commit the updated local configuration"))
+                .or_raise(|| delete::CleanupError {
                     references: names.clone(),
                     deleted: deleted.clone(),
-                    source: delete::CleanupError::Write(source),
                 })?;
-            config_lock.commit().map_err(|err| delete::Error::Cleanup {
-                references: names.clone(),
-                deleted: deleted.clone(),
-                source: delete::CleanupError::Commit(err.error),
-            })?;
             remove_branch_config(
                 gix_features::threading::OwnShared::make_mut(&mut self.config.resolved),
                 &names,
diff --git a/gix/src/repository/checkout.rs b/gix/src/repository/checkout.rs
index c77ff99da85..f5562317fe7 100644
--- a/gix/src/repository/checkout.rs
+++ b/gix/src/repository/checkout.rs
@@ -1,4 +1,4 @@
-use crate::{Repository, config};
+use crate::{Repository, Result};
 
 impl Repository {
     /// Return options that can be used to drive a low-level checkout operation.
@@ -8,7 +8,7 @@ impl Repository {
     pub fn checkout_options(
         &self,
         attributes_source: gix_worktree::stack::state::attributes::Source,
-    ) -> Result<gix_worktree_state::checkout::Options, config::checkout_options::Error> {
+    ) -> Result<gix_worktree_state::checkout::Options> {
         self.config.checkout_options(self, attributes_source)
     }
 }
diff --git a/gix/src/repository/config/branch.rs b/gix/src/repository/config/branch.rs
index 4c564cb0704..811aa26b3a0 100644
--- a/gix/src/repository/config/branch.rs
+++ b/gix/src/repository/config/branch.rs
@@ -1,17 +1,16 @@
 use std::collections::BTreeSet;
 
+use gix_error::{ErrorExt, ResultExt};
 use gix_ref::{FullName, FullNameRef};
 
 use crate::{
+    Error, Result,
     bstr::{BStr, ByteSlice},
     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,
-    },
 };
 
 /// Query configuration related to branches.
@@ -41,11 +40,7 @@ impl crate::Repository {
     ///
     /// See also [`Reference::remote_ref_name()`](crate::Reference::remote_ref_name()).
     #[doc(alias = "branch_upstream_name", alias = "git2")]
-    pub fn branch_remote_ref_name(
-        &self,
-        name: &FullNameRef,
-        direction: remote::Direction,
-    ) -> Option<Result<FullName, branch_remote_ref_name::Error>> {
+    pub fn branch_remote_ref_name(&self, name: &FullNameRef, direction: remote::Direction) -> Option<Result<FullName>> {
         match direction {
             remote::Direction::Fetch => {
                 let short_name = name.shorten();
@@ -58,13 +53,17 @@ impl crate::Repository {
                         } else {
                             gix_ref::Category::LocalBranch.to_full_name(name.as_bstr())
                         }
-                        .map_err(Into::into)
+                        .map_err(|err| {
+                            Error::from(err.and_raise(gix_error::validation(
+                                "The configured name of the remote ref to merge wasn't valid",
+                            )))
+                        })
                     })
             }
             remote::Direction::Push => {
                 let remote = match self.branch_remote(name.shorten(), direction)? {
                     Ok(r) => r,
-                    Err(err) => return Some(Err(err.into())),
+                    Err(err) => return Some(Err(err)),
                 };
                 if remote.push_specs.is_empty() {
                     let push_default =
@@ -78,7 +77,7 @@ impl crate::Repository {
                                     .with_lenient_default(self.config.lenient_config)
                             }) {
                             Ok(v) => v,
-                            Err(err) => return Some(Err(err.into())),
+                            Err(err) => return Some(Err(err)),
                         };
                     match push_default {
                         push::Default::Nothing => None,
@@ -92,7 +91,7 @@ impl crate::Repository {
                     }
                 } else {
                     matching_remote(name, remote.push_specs.iter(), self.object_hash())
-                        .map(|res| res.map_err(Into::into))
+                        .map(|res| -> Result<_> { Ok(res.or_erased()?) })
                 }
             }
         }
@@ -120,21 +119,32 @@ impl crate::Repository {
         &self,
         name: &FullNameRef,
         direction: remote::Direction,
-    ) -> Option<Result<FullName, branch_remote_tracking_ref_name::Error>> {
+    ) -> Option<Result<FullName>> {
         let remote_ref = match self.branch_remote_ref_name(name, direction)? {
             Ok(r) => r,
-            Err(err) => return Some(Err(err.into())),
+            Err(err) => {
+                return Some(Err(Error::from(err.and_raise(gix_error::message(
+                    "Could not get the remote reference to translate into the local tracking branch",
+                )))));
+            }
         };
         let remote = match self.branch_remote(name.shorten(), direction)? {
             Ok(r) => r,
-            Err(err) => return Some(Err(err.into())),
+            Err(err) => {
+                return Some(Err(Error::from(err.and_raise(gix_error::message(
+                    "Couldn't find remote to obtain fetch-specs for mapping to the tracking reference",
+                )))));
+            }
         };
 
         if remote.fetch_specs.is_empty() {
             return None;
         }
-        matching_remote(remote_ref.as_ref(), remote.fetch_specs.iter(), self.object_hash())
-            .map(|res| res.map_err(Into::into))
+        matching_remote(remote_ref.as_ref(), remote.fetch_specs.iter(), self.object_hash()).map(|res| {
+            res.map_err(|err| {
+                Error::from(err.and_raise(gix_error::message("The name of the tracking reference was invalid")))
+            })
+        })
     }
 
     /// Given a local `tracking_branch` name, find the remote that maps to it along with the name of the branch on
@@ -146,12 +156,12 @@ impl crate::Repository {
     pub fn upstream_branch_and_remote_for_tracking_branch(
         &self,
         tracking_branch: &FullNameRef,
-    ) -> Result<Option<(FullName, crate::Remote<'_>)>, upstream_branch_and_remote_name_for_tracking_branch::Error> {
-        use upstream_branch_and_remote_name_for_tracking_branch::Error;
+    ) -> Result<Option<(FullName, crate::Remote<'_>)>> {
         if tracking_branch.category() != Some(gix_ref::Category::RemoteBranch) {
-            return Err(Error::BranchCategory {
-                full_name: tracking_branch.to_owned(),
-            });
+            return Err(Error::from_error(gix_error::validation(format!(
+                "The input branch '{}' needs to be a remote tracking branch",
+                tracking_branch.as_bstr()
+            ))));
         }
 
         let null = self.object_hash().null();
@@ -184,14 +194,17 @@ impl crate::Repository {
             return Ok(Some((upstream_branch, remote)));
         }
         if !ambiguous_remotes.is_empty() || candidates.len() > 1 {
-            return Err(Error::AmbiguousRemotes {
-                remotes: ambiguous_remotes
-                    .into_iter()
-                    .map(|r| r.name)
-                    .chain(candidates.into_iter().map(|(r, _)| r.name))
-                    .flatten()
-                    .collect(),
-            });
+            let remotes = ambiguous_remotes
+                .into_iter()
+                .map(|r| r.name)
+                .chain(candidates.into_iter().map(|(r, _)| r.name))
+                .flatten()
+                .map(|name| name.as_bstr().to_string())
+                .collect::<Vec<_>>()
+                .join(", ");
+            return Err(Error::from_error(gix_error::validation(format!(
+                "Found ambiguous remotes without 1:1 mapping or more than one match: {remotes}"
+            ))));
         }
         Ok(None)
     }
@@ -237,27 +250,22 @@ impl crate::Repository {
         &self,
         short_branch_name: impl Into<&'a BStr>,
         direction: remote::Direction,
-    ) -> Option<Result<crate::Remote<'_>, remote::find::existing::Error>> {
+    ) -> Option<Result<crate::Remote<'_>>> {
         let name = self.branch_remote_name(short_branch_name, direction)?;
-        self.try_find_remote(name.as_bstr())
-            .map(|res| res.map_err(Into::into))
-            .or_else(|| match name {
-                remote::Name::Url(url) => gix_url::parse(&url)
-                    .map_err(gix_error::Exn::into_error)
-                    .map_err(Into::into)
-                    .and_then(|url| {
-                        self.remote_at(url)
-                            .map_err(|err| remote::find::existing::Error::Find(remote::find::Error::Init(err)))
-                    })
-                    .into(),
-                remote::Name::Symbol(_) => None,
-            })
+        self.try_find_remote(name.as_bstr()).or_else(|| match name {
+            remote::Name::Url(url) => gix_url::parse(&url)
+                .map_err(gix_error::Exn::into_error)
+                .and_then(|url| self.remote_at(url))
+                .into(),
+            remote::Name::Symbol(_) => None,
+        })
     }
 }
 
-fn source_ref_to_full_name(source: gix_refspec::match_group::SourceRef<'_>) -> Result<FullName, gix_ref::name::Error> {
+fn source_ref_to_full_name(source: gix_refspec::match_group::SourceRef<'_>) -> Result<FullName> {
     match source {
-        gix_refspec::match_group::SourceRef::FullName(name) => gix_ref::FullName::try_from(name.into_owned()),
+        gix_refspec::match_group::SourceRef::FullName(name) => gix_ref::FullName::try_from(name.into_owned())
+            .map_err(|err| Error::from(err.and_raise(gix_error::validation("The upstream branch name is invalid")))),
         gix_refspec::match_group::SourceRef::ObjectId(_) => {
             unreachable!("Such a reverse mapping isn't ever produced")
         }
@@ -268,7 +276,7 @@ fn matching_remote<'a>(
     lhs: &FullNameRef,
     specs: impl IntoIterator<Item = &'a gix_refspec::RefSpec>,
     object_hash: gix_hash::Kind,
-) -> Option<Result<FullName, gix_validate::reference::name::Error>> {
+) -> Option<std::result::Result<FullName, gix_validate::reference::name::Error>> {
     let search = gix_refspec::MatchGroup {
         specs: specs
             .into_iter()
diff --git a/gix/src/repository/config/mod.rs b/gix/src/repository/config/mod.rs
index 2f5a3d35765..f4d1dd8cd21 100644
--- a/gix/src/repository/config/mod.rs
+++ b/gix/src/repository/config/mod.rs
@@ -1,4 +1,4 @@
-use crate::{bstr::ByteSlice, config};
+use crate::{Result, bstr::ByteSlice, config};
 use std::{collections::BTreeSet, ffi::OsString};
 
 /// General Configuration
@@ -9,7 +9,7 @@ impl crate::Repository {
     }
 
     /// Return the effective compression level used when writing pack entries.
-    pub fn pack_compression(&self) -> Result<gix_zlib::Compression, config::Error> {
+    pub fn pack_compression(&self) -> Result<gix_zlib::Compression> {
         config::cache::access::pack_compression(
             &self.config.resolved,
             self.config.lenient_config,
@@ -36,8 +36,9 @@ impl crate::Repository {
     /// The file and its parent directories do not have to exist. No [configuration transaction](config::FileTransaction)
     /// is opened, no lock is acquired, and no directories are created. Pass the path to
     /// [`config_file_mut()`](Self::config_file_mut) to edit it.
-    pub fn config_path(&self, source: config::Source) -> Result<std::path::PathBuf, config::file_mut::Error> {
-        use config::{Source, file_mut::Error};
+    pub fn config_path(&self, source: config::Source) -> Result<std::path::PathBuf> {
+        use config::Source;
+        use gix_error::{ErrorExt, message};
 
         let path = match source {
             Source::Local => self.common_dir().join("config"),
@@ -51,9 +52,17 @@ impl crate::Repository {
                     options.permissions.config,
                     &mut config::Cache::make_source_env(options.permissions.env),
                 )
-                .ok_or(Error::SourceUnavailable(source))?
+                .ok_or_else(|| {
+                    message!("Configuration source {source:?} has no available path with these options").raise()
+                })?
+            }
+            _ => {
+                return Err(
+                    message!("Configuration source {source:?} requires a repository or has no physical file")
+                        .raise()
+                        .into(),
+                );
             }
-            _ => return Err(Error::UnsupportedSource(source)),
         };
         Ok(self.current_dir().join(path))
     }
@@ -63,10 +72,7 @@ impl crate::Repository {
     /// Relative paths are resolved against the current directory captured when this repository was opened. Dropping the
     /// returned transaction releases the lock and discards its changes. Committing it only updates the file; call
     /// [`reload()`](Self::reload()) explicitly to rebuild this repository from the changed configuration.
-    pub fn config_file_mut(
-        &self,
-        path: impl Into<std::path::PathBuf>,
-    ) -> Result<config::FileTransaction, config::file_mut::Error> {
+    pub fn config_file_mut(&self, path: impl Into<std::path::PathBuf>) -> Result<config::FileTransaction> {
         let path = path.into();
         let path = if path.is_absolute() {
             path
@@ -127,7 +133,7 @@ impl crate::Repository {
     /// The returned command has repository context and inherited standard streams. Add the paths to edit as arguments
     /// before spawning it.
     #[cfg(feature = "command")]
-    pub fn editor_command(&self) -> Result<Option<gix_command::Prepare>, config::command_context::Error> {
+    pub fn editor_command(&self) -> Result<Option<gix_command::Prepare>> {
         use std::{path::Path, process::Stdio};
 
         let Some(editor) = self.editor() else {
@@ -154,9 +160,7 @@ impl crate::Repository {
     /// The returned plumbing options may be adjusted before use, for example to disable GPG pinentry by adding
     /// `--pinentry-mode=error` to `program_arguments`.
     #[cfg(feature = "command")]
-    pub fn commit_signing_options(
-        &self,
-    ) -> Result<gix_object::signature::sign::Options, crate::commit::sign::options::Error> {
+    pub fn commit_signing_options(&self) -> Result<gix_object::signature::sign::Options> {
         crate::commit::sign::signing_options(self)
     }
 
@@ -164,9 +168,7 @@ impl crate::Repository {
     ///
     /// If signing is disabled, signer-specific configuration isn't resolved or validated.
     #[cfg(feature = "command")]
-    pub fn commit_signing_options_if_enabled(
-        &self,
-    ) -> Result<Option<gix_object::signature::sign::Options>, crate::commit::sign::options::Error> {
+    pub fn commit_signing_options_if_enabled(&self) -> Result<Option<gix_object::signature::sign::Options>> {
         crate::commit::sign::signing_options_if_enabled(self)
     }
 
@@ -192,7 +194,7 @@ impl crate::Repository {
     /// Return filesystem options as retrieved from the repository configuration.
     ///
     /// Note that these values have not been [probed](gix_fs::Capabilities::probe()).
-    pub fn filesystem_options(&self) -> Result<gix_fs::Capabilities, config::boolean::Error> {
+    pub fn filesystem_options(&self) -> Result<gix_fs::Capabilities> {
         self.config.fs_capabilities()
     }
 
@@ -200,7 +202,7 @@ impl crate::Repository {
     ///
     /// Note that these values have not been [probed](gix_fs::Capabilities::probe()).
     #[cfg(feature = "index")]
-    pub fn stat_options(&self) -> Result<gix_index::entry::stat::Options, config::stat_options::Error> {
+    pub fn stat_options(&self) -> Result<gix_index::entry::stat::Options> {
         self.config.stat_options()
     }
 
@@ -211,7 +213,7 @@ impl crate::Repository {
 
     /// Return the big-file threshold above which Git will not perform a diff anymore or try to delta-diff packs,
     /// as configured by `core.bigFileThreshold`, or the default value.
-    pub fn big_file_threshold(&self) -> Result<u64, config::unsigned_integer::Error> {
+    pub fn big_file_threshold(&self) -> Result<u64> {
         self.config.big_file_threshold()
     }
 
@@ -220,16 +222,13 @@ impl crate::Repository {
     /// Depending on the configuration, precious-file parsing in `.gitignore-files` is supported.
     /// This means that `$` prefixed files will be interpreted as precious, which is a backwards-incompatible change.
     #[cfg(feature = "excludes")]
-    pub fn ignore_pattern_parser(&self) -> Result<gix_ignore::search::Ignore, config::boolean::Error> {
+    pub fn ignore_pattern_parser(&self) -> Result<gix_ignore::search::Ignore> {
         self.config.ignore_pattern_parser()
     }
 
     /// Obtain options for use when connecting via `ssh`.
     #[cfg(feature = "blocking-network-client")]
-    pub fn ssh_connect_options(
-        &self,
-    ) -> Result<gix_protocol::transport::client::blocking_io::ssh::connect::Options, config::ssh_connect_options::Error>
-    {
+    pub fn ssh_connect_options(&self) -> Result<gix_protocol::transport::client::blocking_io::ssh::connect::Options> {
         use crate::config::{
             cache::util::ApplyLeniency,
             tree::{Core, Ssh, gitoxide},
@@ -260,7 +259,7 @@ impl crate::Repository {
     /// Return the context to be passed to any spawned program that is supposed to interact with the repository, like
     /// hooks or filters.
     #[cfg(feature = "command")]
-    pub fn command_context(&self) -> Result<gix_command::Context, config::command_context::Error> {
+    pub fn command_context(&self) -> Result<gix_command::Context> {
         use crate::config::{cache::util::ApplyLeniency, tree::gitoxide};
 
         let pathspec_boolean = |key: &'static config::tree::keys::Boolean| {
@@ -301,7 +300,7 @@ impl crate::Repository {
     ///
     /// In case of merges, a diff is performed under the hood in order to learn which hunks need merging.
     #[cfg(feature = "blob-diff")]
-    pub fn diff_algorithm(&self) -> Result<gix_diff::blob::Algorithm, config::diff::algorithm::Error> {
+    pub fn diff_algorithm(&self) -> std::result::Result<gix_diff::blob::Algorithm, config::diff::algorithm::Error> {
         self.config.diff_algorithm()
     }
 }
diff --git a/gix/src/repository/config/transport.rs b/gix/src/repository/config/transport.rs
index 16345c968b7..22f0155e27c 100644
--- a/gix/src/repository/config/transport.rs
+++ b/gix/src/repository/config/transport.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::result_large_err)]
 use std::any::Any;
 
-use crate::bstr::BStr;
+use crate::{Result, bstr::BStr};
+use gix_error::ResultExt;
 
 impl crate::Repository {
     /// Produce configuration suitable for `url`, as differentiated by its protocol/scheme, to be passed to a transport instance via
@@ -25,380 +26,406 @@ impl crate::Repository {
         &self,
         url: impl Into<&'a BStr>,
         remote_name: Option<&BStr>,
-    ) -> Result<Option<Box<dyn Any>>, crate::config::transport::Error> {
-        let url = gix_url::parse(url.into()).map_err(gix_error::Exn::into_error)?;
+    ) -> Result<Option<Box<dyn Any>>> {
+        let url = gix_url::parse(url.into()).or_raise(|| gix_error::message("Invalid URL passed for configuration"))?;
         use gix_url::Scheme::*;
 
         match &url.scheme {
             Http | Https => {
-                #[cfg(not(any(
-                    feature = "blocking-http-transport-reqwest",
-                    feature = "blocking-http-transport-curl"
-                )))]
-                {
-                    Ok(None)
-                }
-                #[cfg(any(
-                    feature = "blocking-http-transport-reqwest",
-                    feature = "blocking-http-transport-curl"
-                ))]
-                {
-                    use std::sync::{Arc, Mutex};
+                let options: Result<Option<Box<dyn Any>>> = {
+                    #[cfg(not(any(
+                        feature = "blocking-http-transport-reqwest",
+                        feature = "blocking-http-transport-curl"
+                    )))]
+                    {
+                        Ok(None)
+                    }
+                    #[cfg(any(
+                        feature = "blocking-http-transport-reqwest",
+                        feature = "blocking-http-transport-curl"
+                    ))]
+                    {
+                        use std::sync::{Arc, Mutex};
 
-                    use gix_transport::client::blocking_io::http::{
-                        self,
-                        options::{ProxyAuthMethod, SslVersion, SslVersionRangeInclusive},
-                    };
+                        use gix_transport::client::blocking_io::http::{
+                            self,
+                            options::{ProxyAuthMethod, SslVersion, SslVersionRangeInclusive},
+                        };
 
-                    use crate::{
-                        bstr::BString,
-                        config,
-                        config::{
-                            cache::util::ApplyLeniency,
-                            tree::{Key, Remote, gitoxide},
-                        },
-                    };
-                    fn try_to_string(
-                        v: BString,
-                        lenient: bool,
-                        key_str: impl Into<BString>,
-                        key: &'static config::tree::keys::String,
-                    ) -> Result<Option<String>, config::transport::Error> {
-                        key.try_into_string(v)
-                            .map_err(|err| config::transport::Error::IllformedUtf8 {
-                                source: err,
-                                key: key_str.into(),
-                            })
-                            .map(Some)
-                            .with_leniency(lenient)
-                    }
+                        use crate::{
+                            Error,
+                            bstr::BString,
+                            config,
+                            config::{
+                                cache::util::ApplyLeniency,
+                                tree::{Key, Remote, gitoxide},
+                            },
+                        };
+                        use gix_error::ErrorExt;
+                        fn try_to_string(
+                            v: BString,
+                            lenient: bool,
+                            key_str: impl Into<BString>,
+                            key: &'static config::tree::keys::String,
+                        ) -> Result<Option<String>> {
+                            let key_str = key_str.into();
+                            key.try_into_string(v)
+                                .map_err(|err| {
+                                    Error::from(err.and_raise(gix_error::message!(
+                                        "Could not decode value at key {:?} as UTF-8 string",
+                                        key_str
+                                    )))
+                                })
+                                .map(Some)
+                                .with_leniency(lenient)
+                        }
 
-                    fn proxy_auth_method(
-                        value_and_key: Option<(BString, BString, &'static config::tree::http::ProxyAuthMethod)>,
-                    ) -> Result<ProxyAuthMethod, config::transport::Error> {
-                        let value = value_and_key
-                            .map(|(method, key, key_type)| {
-                                key_type.try_into_proxy_auth_method(method).map_err(|err| {
-                                    config::transport::http::Error::InvalidProxyAuthMethod { source: err, key }
+                        fn proxy_auth_method(
+                            value_and_key: Option<(BString, BString, &'static config::tree::http::ProxyAuthMethod)>,
+                        ) -> Result<ProxyAuthMethod> {
+                            let value = value_and_key
+                                .map(|(method, key, key_type)| {
+                                    let _ = &key; // CodeQL doesn't inspect formatting macro arguments.
+                                    key_type.try_into_proxy_auth_method(method).map_err(|err| {
+                                        err.and_raise(gix_error::message!(
+                                            "The proxy authentication at key `{key}` is invalid"
+                                        ))
+                                    })
                                 })
-                            })
-                            .transpose()?
-                            .unwrap_or_default();
-                        Ok(value)
-                    }
+                                .transpose()?
+                                .unwrap_or_default();
+                            Ok(value)
+                        }
 
-                    fn ssl_version(
-                        config: &gix_config::File,
-                        key_str: &'static str,
-                        key: &'static config::tree::http::SslVersion,
-                        mut filter: fn(&gix_config::file::Metadata) -> bool,
-                        lenient: bool,
-                    ) -> Result<Option<SslVersion>, config::transport::Error> {
-                        debug_assert_eq!(
-                            key_str,
-                            key.logical_name(),
-                            "BUG: hardcoded and generated key names must match"
-                        );
-                        config
-                            .string_filter(key_str, &mut filter)
-                            .filter(|v| !v.is_empty())
-                            .map(|v| {
-                                key.try_into_ssl_version(v)
-                                    .map_err(crate::config::transport::http::Error::from)
-                            })
-                            .transpose()
-                            .with_leniency(lenient)
-                            .map_err(Into::into)
-                    }
+                        fn ssl_version(
+                            config: &gix_config::File,
+                            key_str: &'static str,
+                            key: &'static config::tree::http::SslVersion,
+                            mut filter: fn(&gix_config::file::Metadata) -> bool,
+                            lenient: bool,
+                        ) -> Result<Option<SslVersion>> {
+                            debug_assert_eq!(
+                                key_str,
+                                key.logical_name(),
+                                "BUG: hardcoded and generated key names must match"
+                            );
+                            config
+                                .string_filter(key_str, &mut filter)
+                                .filter(|v| !v.is_empty())
+                                .map(|v| key.try_into_ssl_version(v))
+                                .transpose()
+                                .with_leniency(lenient)
+                        }
 
-                    fn proxy(
-                        value: Option<(BString, BString, &'static config::tree::keys::String)>,
-                        lenient: bool,
-                    ) -> Result<Option<String>, config::transport::Error> {
-                        Ok(value
-                            .and_then(|(v, k, key)| try_to_string(v, lenient, k.clone(), key).transpose())
-                            .transpose()?
-                            .map(|mut proxy| {
-                                if !proxy.trim().is_empty() && !proxy.contains("://") {
-                                    proxy.insert_str(0, "http://");
-                                    proxy
-                                } else {
-                                    proxy
-                                }
-                            }))
-                    }
+                        fn proxy(
+                            value: Option<(BString, BString, &'static config::tree::keys::String)>,
+                            lenient: bool,
+                        ) -> Result<Option<String>> {
+                            Ok(value
+                                .and_then(|(v, k, key)| try_to_string(v, lenient, k.clone(), key).transpose())
+                                .transpose()?
+                                .map(|mut proxy| {
+                                    if !proxy.trim().is_empty() && !proxy.contains("://") {
+                                        proxy.insert_str(0, "http://");
+                                        proxy
+                                    } else {
+                                        proxy
+                                    }
+                                }))
+                        }
 
-                    let mut opts = http::Options::default();
-                    let config = &self.config.resolved;
-                    let mut trusted_only = self.filter_config_section();
-                    let lenient = self.config.lenient_config;
-                    opts.extra_headers = {
-                        let key = "http.extraHeader";
-                        debug_assert_eq!(key, &config::tree::Http::EXTRA_HEADER.logical_name());
-                        config
-                            .strings_filter(key, &mut trusted_only)
-                            .map(|values| config::tree::Http::EXTRA_HEADER.try_into_extra_header(values))
-                            .transpose()
-                            .map_err(|err| config::transport::Error::IllformedUtf8 {
-                                source: err,
-                                key: key.into(),
-                            })?
-                            .unwrap_or_default()
-                    };
+                        let mut opts = http::Options::default();
+                        let config = &self.config.resolved;
+                        let mut trusted_only = self.filter_config_section();
+                        let lenient = self.config.lenient_config;
+                        opts.extra_headers = {
+                            let key = "http.extraHeader";
+                            debug_assert_eq!(key, &config::tree::Http::EXTRA_HEADER.logical_name());
+                            config
+                                .strings_filter(key, &mut trusted_only)
+                                .map(|values| config::tree::Http::EXTRA_HEADER.try_into_extra_header(values))
+                                .transpose()
+                                .map_err(|err| {
+                                    err.and_raise(gix_error::message!(
+                                        "Could not decode value at key {key:?} as UTF-8 string"
+                                    ))
+                                })?
+                                .unwrap_or_default()
+                        };
 
-                    opts.follow_redirects = {
-                        let key = "http.followRedirects";
+                        opts.follow_redirects = {
+                            let key = "http.followRedirects";
 
-                        config::tree::Http::FOLLOW_REDIRECTS
-                            .try_into_follow_redirects(
-                                config.string_filter(key, &mut trusted_only).unwrap_or_default(),
-                                || config.boolean_filter(key, &mut trusted_only).with_leniency(lenient),
-                            )
-                            .map_err(config::transport::http::Error::InvalidFollowRedirects)?
-                    };
+                            config::tree::Http::FOLLOW_REDIRECTS
+                                .try_into_follow_redirects(
+                                    config.string_filter(key, &mut trusted_only).unwrap_or_default(),
+                                    || {
+                                        config
+                                            .boolean_filter(key, &mut trusted_only)
+                                            .with_leniency(lenient)
+                                            .or_erased()
+                                    },
+                                )
+                                .map_err(|err| {
+                                    err.and_raise(gix_error::message!(
+                                        "The follow redirects value must be 'initial', or boolean true or false"
+                                    ))
+                                })?
+                        };
 
-                    opts.low_speed_time_seconds = config::tree::Http::LOW_SPEED_TIME
-                        .try_into_u64(config.integer_filter("http.lowSpeedTime", &mut trusted_only))
-                        .with_leniency(lenient)
-                        .map_err(config::transport::http::Error::from)?
-                        .unwrap_or_default();
-                    opts.low_speed_limit_bytes_per_second = config::tree::Http::LOW_SPEED_LIMIT
-                        .try_into_u32(config.integer_filter("http.lowSpeedLimit", &mut trusted_only))
-                        .with_leniency(lenient)
-                        .map_err(config::transport::http::Error::from)?
-                        .unwrap_or_default();
-                    opts.proxy = proxy(
-                        remote_name
-                            .and_then(|name| {
-                                config
-                                    .string_filter(
-                                        &format!("remote.{}.{}", name, Remote::PROXY.name),
-                                        &mut trusted_only,
+                        opts.low_speed_time_seconds = config::tree::Http::LOW_SPEED_TIME
+                            .try_into_u64(config.integer_filter("http.lowSpeedTime", &mut trusted_only))
+                            .with_leniency(lenient)?
+                            .unwrap_or_default();
+                        opts.low_speed_limit_bytes_per_second = config::tree::Http::LOW_SPEED_LIMIT
+                            .try_into_u32(config.integer_filter("http.lowSpeedLimit", &mut trusted_only))
+                            .with_leniency(lenient)?
+                            .unwrap_or_default();
+                        opts.proxy = proxy(
+                            remote_name
+                                .and_then(|name| {
+                                    config
+                                        .string_filter(
+                                            &format!("remote.{}.{}", name, Remote::PROXY.name),
+                                            &mut trusted_only,
+                                        )
+                                        .map(|v| (v, format!("remote.{name}.proxy").into(), &Remote::PROXY))
+                                })
+                                .or_else(|| {
+                                    let key = "http.proxy";
+                                    debug_assert_eq!(key, config::tree::Http::PROXY.logical_name());
+                                    let http_proxy = config
+                                        .string_filter(key, &mut trusted_only)
+                                        .map(|v| (v, key.into(), &config::tree::Http::PROXY))
+                                        .or_else(|| {
+                                            let key = "gitoxide.http.proxy";
+                                            debug_assert_eq!(key, gitoxide::Http::PROXY.logical_name());
+                                            config
+                                                .string_filter(key, &mut trusted_only)
+                                                .map(|v| (v, key.into(), &gitoxide::Http::PROXY))
+                                        });
+                                    if url.scheme == Https {
+                                        http_proxy.or_else(|| {
+                                            let key = "gitoxide.https.proxy";
+                                            debug_assert_eq!(key, gitoxide::Https::PROXY.logical_name());
+                                            config
+                                                .string_filter(key, &mut trusted_only)
+                                                .map(|v| (v, key.into(), &gitoxide::Https::PROXY))
+                                        })
+                                    } else {
+                                        http_proxy
+                                    }
+                                })
+                                .or_else(|| {
+                                    let key = "gitoxide.http.allProxy";
+                                    debug_assert_eq!(key, gitoxide::Http::ALL_PROXY.logical_name());
+                                    config
+                                        .string_filter(key, &mut trusted_only)
+                                        .map(|v| (v, key.into(), &gitoxide::Http::ALL_PROXY))
+                                }),
+                            lenient,
+                        )?;
+                        {
+                            let key = "gitoxide.http.noProxy";
+                            debug_assert_eq!(key, gitoxide::Http::NO_PROXY.logical_name());
+                            opts.no_proxy = config
+                                .string_filter(key, &mut trusted_only)
+                                .and_then(|v| try_to_string(v, lenient, key, &gitoxide::Http::NO_PROXY).transpose())
+                                .transpose()?;
+                        }
+                        opts.proxy_auth_method = proxy_auth_method({
+                            let key = "gitoxide.http.proxyAuthMethod";
+                            debug_assert_eq!(key, gitoxide::Http::PROXY_AUTH_METHOD.logical_name());
+                            config
+                                .string_filter(key, &mut trusted_only)
+                                .map(|v| (v, key.into(), &gitoxide::Http::PROXY_AUTH_METHOD))
+                                .or_else(|| {
+                                    remote_name
+                                        .and_then(|name| {
+                                            config
+                                                .string_filter(
+                                                    &format!("remote.{name}.proxyAuthMethod"),
+                                                    &mut trusted_only,
+                                                )
+                                                .map(|v| {
+                                                    (
+                                                        v,
+                                                        format!("remote.{name}.proxyAuthMethod").into(),
+                                                        &Remote::PROXY_AUTH_METHOD,
+                                                    )
+                                                })
+                                        })
+                                        .or_else(|| {
+                                            let key = "http.proxyAuthMethod";
+                                            debug_assert_eq!(key, config::tree::Http::PROXY_AUTH_METHOD.logical_name());
+                                            config
+                                                .string_filter(key, &mut trusted_only)
+                                                .map(|v| (v, key.into(), &config::tree::Http::PROXY_AUTH_METHOD))
+                                        })
+                                })
+                        })?;
+                        opts.proxy_authenticate = opts
+                            .proxy
+                            .as_deref()
+                            .filter(|url| !url.is_empty())
+                            .map(gix_url::parse)
+                            .transpose()
+                            .or_raise(|| gix_error::message("Invalid URL passed for configuration"))?
+                            .filter(|url| url.user().is_some())
+                            .map(|url| -> Result<_> {
+                                let (mut cascade, action_with_normalized_url, prompt_opts) =
+                                self.config_snapshot().credential_helpers(url).or_raise(|| {
+                                    gix_error::message(
+                                        "Could not configure the credential helpers for the authenticated proxy url",
                                     )
-                                    .map(|v| (v, format!("remote.{name}.proxy").into(), &Remote::PROXY))
-                            })
-                            .or_else(|| {
-                                let key = "http.proxy";
-                                debug_assert_eq!(key, config::tree::Http::PROXY.logical_name());
-                                let http_proxy = config
-                                    .string_filter(key, &mut trusted_only)
-                                    .map(|v| (v, key.into(), &config::tree::Http::PROXY))
-                                    .or_else(|| {
-                                        let key = "gitoxide.http.proxy";
-                                        debug_assert_eq!(key, gitoxide::Http::PROXY.logical_name());
-                                        config
-                                            .string_filter(key, &mut trusted_only)
-                                            .map(|v| (v, key.into(), &gitoxide::Http::PROXY))
-                                    });
-                                if url.scheme == Https {
-                                    http_proxy.or_else(|| {
-                                        let key = "gitoxide.https.proxy";
-                                        debug_assert_eq!(key, gitoxide::Https::PROXY.logical_name());
-                                        config
-                                            .string_filter(key, &mut trusted_only)
-                                            .map(|v| (v, key.into(), &gitoxide::Https::PROXY))
-                                    })
-                                } else {
-                                    http_proxy
-                                }
+                                })?;
+                                Ok((
+                                    action_with_normalized_url,
+                                    Arc::new(Mutex::new(move |action| cascade.invoke(action, prompt_opts.clone())))
+                                        as Arc<Mutex<http::options::AuthenticateFn>>,
+                                ))
                             })
-                            .or_else(|| {
-                                let key = "gitoxide.http.allProxy";
-                                debug_assert_eq!(key, gitoxide::Http::ALL_PROXY.logical_name());
-                                config
-                                    .string_filter(key, &mut trusted_only)
-                                    .map(|v| (v, key.into(), &gitoxide::Http::ALL_PROXY))
-                            }),
-                        lenient,
-                    )?;
-                    {
-                        let key = "gitoxide.http.noProxy";
-                        debug_assert_eq!(key, gitoxide::Http::NO_PROXY.logical_name());
-                        opts.no_proxy = config
-                            .string_filter(key, &mut trusted_only)
-                            .and_then(|v| try_to_string(v, lenient, key, &gitoxide::Http::NO_PROXY).transpose())
                             .transpose()?;
-                    }
-                    opts.proxy_auth_method = proxy_auth_method({
-                        let key = "gitoxide.http.proxyAuthMethod";
-                        debug_assert_eq!(key, gitoxide::Http::PROXY_AUTH_METHOD.logical_name());
-                        config
-                            .string_filter(key, &mut trusted_only)
-                            .map(|v| (v, key.into(), &gitoxide::Http::PROXY_AUTH_METHOD))
-                            .or_else(|| {
-                                remote_name
-                                    .and_then(|name| {
-                                        config
-                                            .string_filter(&format!("remote.{name}.proxyAuthMethod"), &mut trusted_only)
-                                            .map(|v| {
-                                                (
-                                                    v,
-                                                    format!("remote.{name}.proxyAuthMethod").into(),
-                                                    &Remote::PROXY_AUTH_METHOD,
-                                                )
-                                            })
-                                    })
-                                    .or_else(|| {
-                                        let key = "http.proxyAuthMethod";
-                                        debug_assert_eq!(key, config::tree::Http::PROXY_AUTH_METHOD.logical_name());
-                                        config
-                                            .string_filter(key, &mut trusted_only)
-                                            .map(|v| (v, key.into(), &config::tree::Http::PROXY_AUTH_METHOD))
-                                    })
-                            })
-                    })?;
-                    opts.proxy_authenticate = opts
-                        .proxy
-                        .as_deref()
-                        .filter(|url| !url.is_empty())
-                        .map(gix_url::parse)
-                        .transpose()
-                        .map_err(gix_error::Exn::into_error)?
-                        .filter(|url| url.user().is_some())
-                        .map(|url| -> Result<_, config::transport::http::Error> {
-                            let (mut cascade, action_with_normalized_url, prompt_opts) =
-                                self.config_snapshot().credential_helpers(url)?;
-                            Ok((
-                                action_with_normalized_url,
-                                Arc::new(Mutex::new(move |action| cascade.invoke(action, prompt_opts.clone())))
-                                    as Arc<Mutex<http::options::AuthenticateFn>>,
-                            ))
-                        })
-                        .transpose()?;
-                    opts.connect_timeout = {
-                        let key = "gitoxide.http.connectTimeout";
-                        debug_assert_eq!(key, gitoxide::Http::CONNECT_TIMEOUT.logical_name());
-                        gitoxide::Http::CONNECT_TIMEOUT
-                            .try_into_duration(config.integer_filter(key, &mut trusted_only))
-                            .map_err(crate::config::transport::http::Error::from)
-                            .with_leniency(lenient)?
-                    };
-                    {
-                        let key = "http.userAgent";
-                        opts.user_agent = config
-                            .string_filter(key, &mut trusted_only)
-                            .and_then(|v| try_to_string(v, lenient, key, &config::tree::Http::USER_AGENT).transpose())
-                            .transpose()?
-                            .or_else(|| Some(crate::env::agent().into()));
-                    }
+                        opts.connect_timeout = {
+                            let key = "gitoxide.http.connectTimeout";
+                            debug_assert_eq!(key, gitoxide::Http::CONNECT_TIMEOUT.logical_name());
+                            gitoxide::Http::CONNECT_TIMEOUT
+                                .try_into_duration(config.integer_filter(key, &mut trusted_only))
+                                .with_leniency(lenient)?
+                        };
+                        {
+                            let key = "http.userAgent";
+                            opts.user_agent = config
+                                .string_filter(key, &mut trusted_only)
+                                .and_then(|v| {
+                                    try_to_string(v, lenient, key, &config::tree::Http::USER_AGENT).transpose()
+                                })
+                                .transpose()?
+                                .or_else(|| Some(crate::env::agent().into()));
+                        }
 
-                    {
-                        let key = "http.version";
-                        opts.http_version = config
-                            .string_filter(key, &mut trusted_only)
-                            .map(|v| {
-                                config::tree::Http::VERSION
-                                    .try_into_http_version(v)
-                                    .map_err(config::transport::http::Error::InvalidHttpVersion)
-                            })
-                            .transpose()?;
-                    }
+                        {
+                            let key = "http.version";
+                            opts.http_version = config
+                                .string_filter(key, &mut trusted_only)
+                                .map(|v| {
+                                    config::tree::Http::VERSION.try_into_http_version(v).map_err(|err| {
+                                        err.and_raise(gix_error::message!(
+                                            "The HTTP version must be 'HTTP/2' or 'HTTP/1.1'"
+                                        ))
+                                    })
+                                })
+                                .transpose()?;
+                        }
 
-                    {
-                        opts.verbose = config
-                            .boolean_filter(gitoxide::Http::VERBOSE, &mut trusted_only)
-                            .ok()
-                            .flatten()
-                            .unwrap_or_default();
-                    }
+                        {
+                            opts.verbose = config
+                                .boolean_filter(gitoxide::Http::VERBOSE, &mut trusted_only)
+                                .ok()
+                                .flatten()
+                                .unwrap_or_default();
+                        }
 
-                    let may_use_cainfo = {
-                        let key = "http.schannelUseSSLCAInfo";
-                        config::tree::Http::SCHANNEL_USE_SSL_CA_INFO
-                            .enrich_error(config.boolean_filter(key, &mut trusted_only))
-                            .with_leniency(lenient)
-                            .map_err(config::transport::http::Error::from)?
-                            .unwrap_or(true)
-                    };
+                        let may_use_cainfo = {
+                            let key = "http.schannelUseSSLCAInfo";
+                            config::tree::Http::SCHANNEL_USE_SSL_CA_INFO
+                                .enrich_error(config.boolean_filter(key, &mut trusted_only))
+                                .with_leniency(lenient)?
+                                .unwrap_or(true)
+                        };
 
-                    if may_use_cainfo {
-                        let key = "http.sslCAInfo";
-                        debug_assert_eq!(key, config::tree::Http::SSL_CA_INFO.logical_name());
-                        opts.ssl_ca_info = config
-                            .path_filter(key, &mut trusted_only)
-                            .map(|p| {
-                                use crate::config::cache::interpolate_context;
-                                p.interpolate(interpolate_context(
-                                    self.install_dir().ok().as_deref(),
-                                    self.config.home_dir().as_deref(),
-                                ))
-                            })
-                            .transpose()
-                            .with_leniency(lenient)
-                            .map_err(|err| config::transport::Error::InterpolatePath { source: err, key })?;
-                    }
+                        if may_use_cainfo {
+                            let key = "http.sslCAInfo";
+                            debug_assert_eq!(key, config::tree::Http::SSL_CA_INFO.logical_name());
+                            opts.ssl_ca_info = config
+                                .path_filter(key, &mut trusted_only)
+                                .map(|p| {
+                                    use crate::config::cache::interpolate_context;
+                                    p.interpolate(interpolate_context(
+                                        self.install_dir().ok().as_deref(),
+                                        self.config.home_dir().as_deref(),
+                                    ))
+                                })
+                                .transpose()
+                                .with_leniency(lenient)
+                                .map_err(|err| {
+                                    err.raise(gix_error::message!("Could not interpolate path at key {key:?}"))
+                                })?;
+                        }
 
-                    {
-                        opts.ssl_version = ssl_version(
-                            config,
-                            "http.sslVersion",
-                            &config::tree::Http::SSL_VERSION,
-                            trusted_only,
-                            lenient,
-                        )?
-                        .map(|v| SslVersionRangeInclusive { min: v, max: v });
-                        let min_max = ssl_version(
-                            config,
-                            "gitoxide.http.sslVersionMin",
-                            &gitoxide::Http::SSL_VERSION_MIN,
-                            trusted_only,
-                            lenient,
-                        )
-                        .and_then(|min| {
-                            ssl_version(
+                        {
+                            opts.ssl_version = ssl_version(
+                                config,
+                                "http.sslVersion",
+                                &config::tree::Http::SSL_VERSION,
+                                trusted_only,
+                                lenient,
+                            )?
+                            .map(|v| SslVersionRangeInclusive { min: v, max: v });
+                            let min_max = ssl_version(
                                 config,
-                                "gitoxide.http.sslVersionMax",
-                                &gitoxide::Http::SSL_VERSION_MAX,
+                                "gitoxide.http.sslVersionMin",
+                                &gitoxide::Http::SSL_VERSION_MIN,
                                 trusted_only,
                                 lenient,
                             )
-                            .map(|max| min.zip(max))
-                        })?;
-                        if let Some((min, max)) = min_max {
-                            let v = opts.ssl_version.get_or_insert(SslVersionRangeInclusive {
-                                min: SslVersion::TlsV1_3,
-                                max: SslVersion::TlsV1_3,
-                            });
-                            v.min = min;
-                            v.max = max;
+                            .and_then(|min| {
+                                ssl_version(
+                                    config,
+                                    "gitoxide.http.sslVersionMax",
+                                    &gitoxide::Http::SSL_VERSION_MAX,
+                                    trusted_only,
+                                    lenient,
+                                )
+                                .map(|max| min.zip(max))
+                            })?;
+                            if let Some((min, max)) = min_max {
+                                let v = opts.ssl_version.get_or_insert(SslVersionRangeInclusive {
+                                    min: SslVersion::TlsV1_3,
+                                    max: SslVersion::TlsV1_3,
+                                });
+                                v.min = min;
+                                v.max = max;
+                            }
                         }
-                    }
 
-                    {
-                        let key = "gitoxide.http.sslNoVerify";
-                        let ssl_no_verify = config::tree::gitoxide::Http::SSL_NO_VERIFY
-                            .enrich_error(config.boolean_filter(key, &mut trusted_only))
-                            .with_leniency(lenient)
-                            .map_err(config::transport::http::Error::from)?
-                            .unwrap_or_default();
+                        {
+                            let key = "gitoxide.http.sslNoVerify";
+                            let ssl_no_verify = config::tree::gitoxide::Http::SSL_NO_VERIFY
+                                .enrich_error(config.boolean_filter(key, &mut trusted_only))
+                                .with_leniency(lenient)?
+                                .unwrap_or_default();
 
-                        if ssl_no_verify {
-                            opts.ssl_verify = false;
-                        } else {
-                            let key = "http.sslVerify";
-                            opts.ssl_verify = config::tree::Http::SSL_VERIFY
+                            if ssl_no_verify {
+                                opts.ssl_verify = false;
+                            } else {
+                                let key = "http.sslVerify";
+                                opts.ssl_verify = config::tree::Http::SSL_VERIFY
+                                    .enrich_error(config.boolean_filter(key, &mut trusted_only))
+                                    .with_leniency(lenient)?
+                                    .unwrap_or(true);
+                            }
+                        }
+
+                        #[cfg(feature = "blocking-http-transport-curl")]
+                        {
+                            let key = "http.schannelCheckRevoke";
+                            let schannel_check_revoke = config::tree::Http::SCHANNEL_CHECK_REVOKE
                                 .enrich_error(config.boolean_filter(key, &mut trusted_only))
-                                .with_leniency(lenient)
-                                .map_err(config::transport::http::Error::from)?
-                                .unwrap_or(true);
+                                .with_leniency(lenient)?;
+                            let backend = gix_protocol::transport::client::blocking_io::http::curl::Options {
+                                schannel_check_revoke,
+                            };
+                            opts.backend =
+                                Some(Arc::new(Mutex::new(backend)) as Arc<Mutex<dyn Any + Send + Sync + 'static>>);
                         }
-                    }
 
-                    #[cfg(feature = "blocking-http-transport-curl")]
-                    {
-                        let key = "http.schannelCheckRevoke";
-                        let schannel_check_revoke = config::tree::Http::SCHANNEL_CHECK_REVOKE
-                            .enrich_error(config.boolean_filter(key, &mut trusted_only))
-                            .with_leniency(lenient)
-                            .map_err(config::transport::http::Error::from)?;
-                        let backend =
-                            gix_protocol::transport::client::blocking_io::http::curl::Options { schannel_check_revoke };
-                        opts.backend =
-                            Some(Arc::new(Mutex::new(backend)) as Arc<Mutex<dyn Any + Send + Sync + 'static>>);
+                        Ok(Some(Box::new(opts) as Box<dyn Any>))
                     }
-
-                    Ok(Some(Box::new(opts)))
-                }
+                };
+                options
+                    .or_raise(|| gix_error::message("Could obtain configuration for an HTTP url"))
+                    .map_err(Into::into)
             }
             File | Git | Ssh | Ext | Helper(_) | HelperUrl(_) => Ok(None),
         }
diff --git a/gix/src/repository/diff.rs b/gix/src/repository/diff.rs
index 52c601cb198..d7c8f8c80a8 100644
--- a/gix/src/repository/diff.rs
+++ b/gix/src/repository/diff.rs
@@ -1,9 +1,7 @@
+use gix_error::ResultExt;
 use gix_object::TreeRefIter;
 
-use crate::{
-    Repository, Tree,
-    repository::{diff_resource_cache, diff_tree_to_tree},
-};
+use crate::{ExnResult, Repository, Result, Tree};
 
 /// Diff-utilities
 impl Repository {
@@ -21,9 +19,9 @@ impl Repository {
         &self,
         mode: gix_diff::blob::pipeline::Mode,
         worktree_roots: gix_diff::blob::pipeline::WorktreeRoots,
-    ) -> Result<gix_diff::blob::Platform, diff_resource_cache::Error> {
+    ) -> Result<gix_diff::blob::Platform> {
         let index = self.index_or_load_from_head_or_empty()?;
-        Ok(crate::diff::resource_cache(
+        crate::diff::resource_cache(
             self,
             mode,
             self.attributes_only(
@@ -33,10 +31,11 @@ impl Repository {
                 } else {
                     gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                 },
-            )?
+            )
+            .or_raise(|| gix_error::message("Could not obtain resource cache for diffing"))?
             .inner,
             worktree_roots,
-        )?)
+        )
     }
 
     /// Produce the changes that would need to be applied to `old_tree` to create `new_tree`.
@@ -52,7 +51,7 @@ impl Repository {
         old_tree: impl Into<Option<&'a Tree<'old_repo>>>,
         new_tree: impl Into<Option<&'a Tree<'new_repo>>>,
         options: impl Into<Option<crate::diff::Options>>,
-    ) -> Result<Vec<crate::object::tree::diff::ChangeDetached>, diff_tree_to_tree::Error> {
+    ) -> Result<Vec<crate::object::tree::diff::ChangeDetached>> {
         let mut cache = self.diff_resource_cache(gix_diff::blob::pipeline::Mode::ToGit, Default::default())?;
         let opts = options
             .into()
@@ -69,19 +68,20 @@ impl Repository {
             &mut cache,
             &mut Default::default(),
             &self.objects,
-            |change| -> Result<_, std::convert::Infallible> {
+            |change| -> ExnResult<_> {
                 out.push(change.into_owned());
                 Ok(std::ops::ControlFlow::Continue(()))
             },
             opts,
-        )?;
+        )
+        .or_erased()?;
         Ok(out)
     }
 
     /// Return a resource cache suitable for diffing blobs from trees directly, where no worktree checkout exists.
     ///
     /// For more control, see [`diff_resource_cache()`](Self::diff_resource_cache).
-    pub fn diff_resource_cache_for_tree_diff(&self) -> Result<gix_diff::blob::Platform, diff_resource_cache::Error> {
+    pub fn diff_resource_cache_for_tree_diff(&self) -> Result<gix_diff::blob::Platform> {
         self.diff_resource_cache(
             gix_diff::blob::pipeline::Mode::ToGit,
             gix_diff::blob::pipeline::WorktreeRoots::default(),
diff --git a/gix/src/repository/dirwalk.rs b/gix/src/repository/dirwalk.rs
index eb8e4b6e5e7..d36de800c51 100644
--- a/gix/src/repository/dirwalk.rs
+++ b/gix/src/repository/dirwalk.rs
@@ -1,18 +1,19 @@
 use std::sync::atomic::AtomicBool;
 
 use crate::{
-    Repository,
+    Error, Repository, Result,
     bstr::{BStr, BString},
-    config, dirwalk, is_dir_to_mode,
+    dirwalk, is_dir_to_mode,
     util::OwnedOrStaticAtomicBool,
     worktree::IndexPersistedOrInMemory,
 };
+use gix_error::ResultExt;
 
 impl Repository {
     /// Return default options suitable for performing a directory walk on this repository.
     ///
     /// Used in conjunction with [`dirwalk()`](Self::dirwalk())
-    pub fn dirwalk_options(&self) -> Result<dirwalk::Options, config::boolean::Error> {
+    pub fn dirwalk_options(&self) -> Result<dirwalk::Options> {
         Ok(dirwalk::Options::from_fs_caps(self.filesystem_options()?))
     }
 
@@ -38,9 +39,13 @@ impl Repository {
         should_interrupt: &AtomicBool,
         options: dirwalk::Options,
         delegate: &mut dyn gix_dir::walk::Delegate,
-    ) -> Result<dirwalk::Outcome<'_>, dirwalk::Error> {
+    ) -> Result<dirwalk::Outcome<'_>> {
         let _span = gix_trace::coarse!("gix::dirwalk");
-        let workdir = self.workdir().ok_or(dirwalk::Error::MissingWorkDir)?;
+        let workdir = self.workdir().ok_or_else(|| {
+            Error::from_error(gix_error::message(
+                "A working tree is required to perform a directory walk",
+            ))
+        })?;
         let mut excludes = self.excludes(
             index,
             None,
@@ -61,7 +66,9 @@ impl Repository {
         let mut opts = gix_dir::walk::Options::from(options);
         let worktree_relative_worktree_dirs_storage;
         if let Some(workdir) = self.workdir().filter(|_| opts.for_deletion.is_some()) {
-            let linked_worktrees = self.worktrees()?;
+            let linked_worktrees = self.worktrees().or_raise(|| {
+                gix_error::message("Could not list worktrees to assure they are no candidates for deletion")
+            })?;
             if !linked_worktrees.is_empty() {
                 let real_workdir = gix_path::realpath_opts(
                     workdir,
@@ -125,7 +132,7 @@ impl Repository {
         patterns: impl IntoIterator<Item = impl Into<BString>>,
         should_interrupt: OwnedOrStaticAtomicBool,
         options: dirwalk::Options,
-    ) -> Result<dirwalk::Iter, dirwalk::iter::Error> {
+    ) -> Result<dirwalk::Iter> {
         dirwalk::Iter::new(
             self,
             index.into(),
diff --git a/gix/src/repository/filter.rs b/gix/src/repository/filter.rs
index ffd7330ec8d..7fae0d5876d 100644
--- a/gix/src/repository/filter.rs
+++ b/gix/src/repository/filter.rs
@@ -1,25 +1,6 @@
-use crate::{Id, Repository, filter, worktree::IndexPersistedOrInMemory};
+use gix_error::ResultExt;
 
-///
-pub mod pipeline {
-    /// The error returned by [Repository::filter_pipeline()](super::Repository::filter_pipeline()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not obtain head commit of bare repository")]
-        HeadCommit(#[from] crate::reference::head_commit::Error),
-        #[error(transparent)]
-        DecodeCommit(#[from] gix_object::decode::Error),
-        #[error("Could not create index from tree at HEAD^{{tree}}")]
-        TreeTraverse(#[from] crate::repository::index_from_tree::Error),
-        #[error(transparent)]
-        BareAttributes(#[from] crate::config::attribute_stack::Error),
-        #[error(transparent)]
-        WorktreeIndex(#[from] crate::worktree::open_index::Error),
-        #[error(transparent)]
-        Init(#[from] crate::filter::pipeline::options::Error),
-    }
-}
+use crate::{Repository, Result, filter, worktree::IndexPersistedOrInMemory};
 
 impl Repository {
     /// Configure a pipeline for converting byte buffers to the worktree representation, and byte streams to the git-internal
@@ -39,24 +20,32 @@ impl Repository {
     pub fn filter_pipeline(
         &self,
         tree_if_bare: Option<gix_hash::ObjectId>,
-    ) -> Result<(filter::Pipeline<'_>, IndexPersistedOrInMemory), pipeline::Error> {
+    ) -> Result<(filter::Pipeline<'_>, IndexPersistedOrInMemory)> {
         let (cache, index) = if self.is_bare() {
-            let index = self.index_from_tree(&tree_if_bare.map_or_else(
-                || {
-                    self.head_commit()
-                        .map_err(pipeline::Error::from)
-                        .and_then(|c| c.tree_id().map(Id::detach).map_err(Into::into))
+            let tree = tree_if_bare.map_or_else(
+                || -> Result<_> {
+                    let commit = self
+                        .head_commit()
+                        .or_raise(|| gix_error::message("Could not obtain head commit of bare repository"))?;
+                    Ok(commit.tree_id().or_erased()?.detach())
                 },
                 Ok,
-            )?)?;
-            let cache = self.attributes_only(&index, gix_worktree::stack::state::attributes::Source::IdMapping)?;
+            )?;
+            let index = self
+                .index_from_tree(&tree)
+                .or_raise(|| gix_error::message("Could not create index from tree at HEAD^{tree}"))?;
+            let cache = self
+                .attributes_only(&index, gix_worktree::stack::state::attributes::Source::IdMapping)
+                .or_erased()?;
             (cache, IndexPersistedOrInMemory::InMemory(index))
         } else {
             let index = self.index_or_empty()?;
-            let cache = self.attributes_only(
-                &index,
-                gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-            )?;
+            let cache = self
+                .attributes_only(
+                    &index,
+                    gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+                )
+                .or_erased()?;
             (cache, IndexPersistedOrInMemory::Persisted(index))
         };
         Ok((filter::Pipeline::new(self, cache.detach())?, index))
diff --git a/gix/src/repository/graph.rs b/gix/src/repository/graph.rs
index 1d2e74e4142..1e7f4c8d585 100644
--- a/gix/src/repository/graph.rs
+++ b/gix/src/repository/graph.rs
@@ -1,5 +1,4 @@
-use crate::Error;
-
+use crate::Result;
 impl crate::Repository {
     /// Create a graph data-structure capable of accelerating graph traversals and storing state of type `T` with each commit
     /// it encountered.
@@ -26,22 +25,22 @@ impl crate::Repository {
     ///
     /// Note that [`revision_graph()`][crate::Repository::revision_graph()] should be preferred for general purpose walks that don't
     /// rely on the actual commit cache to be present, while leveraging the commit-graph if possible.
-    pub fn commit_graph(&self) -> Result<gix_commitgraph::Graph, Error> {
+    pub fn commit_graph(&self) -> Result<gix_commitgraph::Graph> {
         gix_commitgraph::at(self.objects.store_ref().path().join("info")).map_err(Into::into)
     }
 
     /// Return a newly opened commit-graph if it is available *and* enabled in the Git configuration.
-    pub fn commit_graph_if_enabled(
-        &self,
-    ) -> Result<Option<gix_commitgraph::Graph>, super::commit_graph_if_enabled::Error> {
-        Ok(self
-            .config
+    pub fn commit_graph_if_enabled(&self) -> Result<Option<gix_commitgraph::Graph>> {
+        self.config
             .may_use_commit_graph()?
             .then(|| gix_commitgraph::at(self.objects.store_ref().path().join("info")))
             .transpose()
-            .or_else(|err| match err.downcast_any_ref::<std::io::Error>() {
-                Some(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
-                _ => Err(err.into_error()),
-            })?)
+            .or_else(|err| {
+                if err.is_not_found() {
+                    Ok(None)
+                } else {
+                    Err(err.into_error())
+                }
+            })
     }
 }
diff --git a/gix/src/repository/identity.rs b/gix/src/repository/identity.rs
index f5223f54743..07d33b4ee63 100644
--- a/gix/src/repository/identity.rs
+++ b/gix/src/repository/identity.rs
@@ -1,6 +1,8 @@
+use gix_error::ResultExt;
+
 use crate::{
+    Result,
     bstr::{BString, ByteSlice},
-    config,
     config::tree::{Author, Committer, Key, User, gitoxide, keys},
 };
 
@@ -28,7 +30,7 @@ impl crate::Repository {
     /// # Note
     ///
     /// The values are cached when the repository is instantiated.
-    pub fn committer(&self) -> Option<Result<gix_actor::SignatureRef<'_>, config::time::Error>> {
+    pub fn committer(&self) -> Option<Result<gix_actor::SignatureRef<'_>>> {
         let p = self.config.personas();
 
         Ok(gix_actor::SignatureRef {
@@ -61,24 +63,22 @@ impl crate::Repository {
         &mut self,
         name: impl gix_utils::AsBStr,
         email: impl gix_utils::AsBStr,
-    ) -> Result<gix_actor::SignatureRef<'_>, config::commit_signature::Error> {
+    ) -> Result<gix_actor::SignatureRef<'_>> {
         if self.committer().is_none() {
             let mut config = gix_config::File::new(gix_config::file::Metadata::api());
             config.set_raw_value(gitoxide::Committer::NAME_FALLBACK, name)?;
             config.set_raw_value(gitoxide::Committer::EMAIL_FALLBACK, email)?;
             let mut repo_config = self.config_snapshot_mut();
-            repo_config.append(config)?;
+            repo_config.append(config).or_erased()?;
         }
-        Ok(self.committer().expect("committer was just set")?)
+        Ok(self.committer().expect("committer was just set").or_erased()?)
     }
 
     /// Return the configured committer or install a generic fallback in memory on this instance.
     ///
     /// This is equivalent to calling [`committer_or_set_fallback()`](Self::committer_or_set_fallback()) with
     /// `no name configured <noEmailAvailable@example.com>`.
-    pub fn committer_or_set_generic_fallback(
-        &mut self,
-    ) -> Result<gix_actor::SignatureRef<'_>, config::commit_signature::Error> {
+    pub fn committer_or_set_generic_fallback(&mut self) -> Result<gix_actor::SignatureRef<'_>> {
         self.committer_or_set_fallback("no name configured", "noEmailAvailable@example.com")
     }
 
@@ -96,7 +96,7 @@ impl crate::Repository {
     /// # Note
     ///
     /// The values are cached when the repository is instantiated.
-    pub fn author(&self) -> Option<Result<gix_actor::SignatureRef<'_>, config::time::Error>> {
+    pub fn author(&self) -> Option<Result<gix_actor::SignatureRef<'_>>> {
         let p = self.config.personas();
 
         Ok(gix_actor::SignatureRef {
diff --git a/gix/src/repository/impls.rs b/gix/src/repository/impls.rs
index 39aa392882c..365b3f0dcfd 100644
--- a/gix/src/repository/impls.rs
+++ b/gix/src/repository/impls.rs
@@ -1,5 +1,8 @@
 use std::ops::DerefMut;
 
+use crate::ExnResult;
+
+use gix_error::{ErrorExt, ResultExt};
 use gix_hash::ObjectId;
 use gix_object::Exists;
 
@@ -107,14 +110,14 @@ impl From<crate::Repository> for crate::ThreadSafeRepository {
 }
 
 impl gix_object::Write for crate::Repository {
-    fn write(&self, object: &dyn gix_object::WriteTo) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    fn write(&self, object: &dyn gix_object::WriteTo) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = self.empty_reusable_buffer();
-        object.write_to(buf.deref_mut())?;
+        object.write_to(buf.deref_mut()).or_erased()?;
         self.write_buf(object.kind(), &buf)
     }
 
-    fn write_buf(&self, object: gix_object::Kind, from: &[u8]) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
-        let oid = gix_object::compute_hash(self.object_hash(), object, from)?;
+    fn write_buf(&self, object: gix_object::Kind, from: &[u8]) -> ExnResult<gix_hash::ObjectId> {
+        let oid = gix_object::compute_hash(self.object_hash(), object, from).or_erased()?;
         if self.objects.exists(&oid) {
             return Ok(oid);
         }
@@ -126,11 +129,13 @@ impl gix_object::Write for crate::Repository {
         kind: gix_object::Kind,
         size: u64,
         from: &mut dyn std::io::Read,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = self.empty_reusable_buffer();
-        let bytes = std::io::copy(from, buf.deref_mut())?;
+        let bytes = std::io::copy(from, buf.deref_mut()).or_erased()?;
         if size != bytes {
-            return Err(format!("Found {bytes} bytes in stream, but had {size} bytes declared").into());
+            return Err(
+                gix_error::message!("Found {bytes} bytes in stream, but had {size} bytes declared").raise_erased(),
+            );
         }
         self.write_buf(kind, &buf)
     }
@@ -140,7 +145,7 @@ impl gix_object::Write for crate::Repository {
         object: gix_object::Kind,
         from: &[u8],
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         if self.objects.exists(&id) {
             return Ok(id);
         }
@@ -153,18 +158,20 @@ impl gix_object::Write for crate::Repository {
         size: u64,
         from: &mut dyn std::io::Read,
         id: gix_hash::ObjectId,
-    ) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
+    ) -> ExnResult<gix_hash::ObjectId> {
         let mut buf = self.empty_reusable_buffer();
-        let bytes = std::io::copy(from, buf.deref_mut())?;
+        let bytes = std::io::copy(from, buf.deref_mut()).or_erased()?;
         if size != bytes {
-            return Err(format!("Found {bytes} bytes in stream, but had {size} bytes declared").into());
+            return Err(
+                gix_error::message!("Found {bytes} bytes in stream, but had {size} bytes declared").raise_erased(),
+            );
         }
         self.write_buf_with_known_id(kind, &buf, id)
     }
 }
 
 impl gix_object::FindHeader for crate::Repository {
-    fn try_header(&self, id: &gix_hash::oid) -> Result<Option<gix_object::Header>, gix_object::find::Error> {
+    fn try_header(&self, id: &gix_hash::oid) -> ExnResult<Option<gix_object::Header>> {
         if id == ObjectId::empty_tree(self.object_hash()) {
             return Ok(Some(gix_object::Header {
                 kind: gix_object::Kind::Tree,
@@ -176,11 +183,7 @@ impl gix_object::FindHeader for crate::Repository {
 }
 
 impl gix_object::Find for crate::Repository {
-    fn try_find<'a>(
-        &self,
-        id: &gix_hash::oid,
-        buffer: &'a mut Vec<u8>,
-    ) -> Result<Option<gix_object::Data<'a>>, gix_object::find::Error> {
+    fn try_find<'a>(&self, id: &gix_hash::oid, buffer: &'a mut Vec<u8>) -> ExnResult<Option<gix_object::Data<'a>>> {
         if id == ObjectId::empty_tree(self.object_hash()) {
             buffer.clear();
             return Ok(Some(gix_object::Data {
diff --git a/gix/src/repository/index.rs b/gix/src/repository/index.rs
index f2aca8a22d5..d856285a04d 100644
--- a/gix/src/repository/index.rs
+++ b/gix/src/repository/index.rs
@@ -1,4 +1,7 @@
+use gix_error::ResultExt;
+
 use crate::{
+    Error, Result,
     config::{cache::util::ApplyLeniencyDefault, tree::Index},
     worktree,
     worktree::IndexPersistedOrInMemory,
@@ -22,7 +25,7 @@ impl crate::Repository {
     /// assert_eq!(index.entries().len(), 1);
     /// # Ok(()) }
     /// ```
-    pub fn open_index(&self) -> Result<gix_index::File, worktree::open_index::Error> {
+    pub fn open_index(&self) -> Result<gix_index::File> {
         let thread_limit = self
             .config
             .resolved
@@ -71,18 +74,13 @@ impl crate::Repository {
     /// assert_eq!(index.entries().len(), 1);
     /// # Ok(()) }
     /// ```
-    pub fn index(&self) -> Result<worktree::Index, worktree::open_index::Error> {
+    pub fn index(&self) -> Result<worktree::Index> {
         self.try_index().and_then(|opt| match opt {
             Some(index) => Ok(index),
-            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 '{index_path}' for opening.",
-                        index_path = self.index_path().display()
-                    ),
-                )),
-            )),
+            None => Err(Error::from_error(gix_error::not_found(format!(
+                "Could not find index file at '{index_path}' for opening.",
+                index_path = self.index_path().display()
+            )))),
         })
     }
 
@@ -100,7 +98,7 @@ impl crate::Repository {
     /// assert!(index.entries().is_empty());
     /// # Ok(()) }
     /// ```
-    pub fn index_or_empty(&self) -> Result<worktree::Index, worktree::open_index::Error> {
+    pub fn index_or_empty(&self) -> Result<worktree::Index> {
         Ok(self.try_index()?.unwrap_or_else(|| {
             worktree::Index::new(gix_fs::FileSnapshot::new(gix_index::File::from_state(
                 gix_index::State::new(self.object_hash()),
@@ -113,17 +111,21 @@ impl crate::Repository {
     /// on disk has changed, or `None` if no such file exists.
     ///
     /// The index file is shared across all clones of this repository.
-    pub fn try_index(&self) -> Result<Option<worktree::Index>, worktree::open_index::Error> {
+    pub fn try_index(&self) -> Result<Option<worktree::Index>> {
         self.index.recent_snapshot(
             || self.index_path().metadata().and_then(|m| m.modified()).ok(),
             || {
-                self.open_index().map(Some).or_else(|err| match err {
-                    worktree::open_index::Error::IndexFile(gix_index::file::init::Error::Io(err))
-                        if err.kind() == std::io::ErrorKind::NotFound =>
+                self.open_index().map(Some).or_else(|err| {
+                    if err
+                        .downcast_any_ref::<gix_index::file::init::OpenError>()
+                        .is_some_and(|err| {
+                            err.path == self.index_path() && err.source.kind() == std::io::ErrorKind::NotFound
+                        })
                     {
                         Ok(None)
+                    } else {
+                        Err(err)
                     }
-                    err => Err(err),
                 })
             },
         )
@@ -152,13 +154,11 @@ impl crate::Repository {
     /// assert_eq!(index.entries().len(), 1);
     /// # Ok(()) }
     /// ```
-    pub fn index_or_load_from_head(
-        &self,
-    ) -> Result<IndexPersistedOrInMemory, crate::repository::index_or_load_from_head::Error> {
+    pub fn index_or_load_from_head(&self) -> Result<IndexPersistedOrInMemory> {
         Ok(match self.try_index()? {
             Some(index) => IndexPersistedOrInMemory::Persisted(index),
             None => {
-                let tree = self.head_commit()?.tree_id()?;
+                let tree = self.head_commit()?.tree_id().or_erased()?;
                 IndexPersistedOrInMemory::InMemory(self.index_from_tree(&tree)?)
             }
         })
@@ -182,14 +182,12 @@ impl crate::Repository {
     /// assert!(index.entries().is_empty());
     /// # Ok(()) }
     /// ```
-    pub fn index_or_load_from_head_or_empty(
-        &self,
-    ) -> Result<IndexPersistedOrInMemory, crate::repository::index_or_load_from_head_or_empty::Error> {
+    pub fn index_or_load_from_head_or_empty(&self) -> Result<IndexPersistedOrInMemory> {
         Ok(match self.try_index()? {
             Some(index) => IndexPersistedOrInMemory::Persisted(index),
             None => match self.head()?.id() {
                 Some(id) => {
-                    let head_tree_id = id.object()?.peel_to_commit()?.tree_id()?;
+                    let head_tree_id = id.object()?.peel_to_commit()?.tree_id().or_erased()?;
                     IndexPersistedOrInMemory::InMemory(self.index_from_tree(&head_tree_id)?)
                 }
                 None => IndexPersistedOrInMemory::InMemory(gix_index::File::from_state(
@@ -203,14 +201,10 @@ impl crate::Repository {
     /// Create new index-file, which would live at the correct location, in memory from the given `tree`.
     ///
     /// Note that this is an expensive operation as it requires recursively traversing the entire tree to unpack it into the index.
-    pub fn index_from_tree(&self, tree: &gix_hash::oid) -> Result<gix_index::File, super::index_from_tree::Error> {
+    pub fn index_from_tree(&self, tree: &gix_hash::oid) -> Result<gix_index::File> {
         Ok(gix_index::File::from_state(
-            gix_index::State::from_tree(tree, self, self.config.protect_options()?).map_err(|err| {
-                super::index_from_tree::Error::IndexFromTree {
-                    id: tree.into(),
-                    source: err,
-                }
-            })?,
+            gix_index::State::from_tree(tree, self, self.config.protect_options()?)
+                .or_raise(|| gix_error::message!("Could not create index from tree at {tree}"))?,
             self.index_path(),
         ))
     }
diff --git a/gix/src/repository/init.rs b/gix/src/repository/init.rs
index 26b1e064137..d5e70c90fb2 100644
--- a/gix/src/repository/init.rs
+++ b/gix/src/repository/init.rs
@@ -1,5 +1,7 @@
 use std::cell::RefCell;
 
+use crate::Result;
+
 impl crate::Repository {
     #[expect(clippy::too_many_arguments)]
     pub(crate) fn from_refs_and_objects(
@@ -49,7 +51,7 @@ impl crate::Repository {
     /// When the [`git_dir`](Self::git_dir()) is relative and the current working dir changed,
     /// then a reload will be performed on the joined path of both to make it succeed, which makes
     /// the reloaded repository git-dir absolute.
-    pub fn reload(&mut self) -> Result<&mut Self, crate::open::Error> {
+    pub fn reload(&mut self) -> Result<&mut Self> {
         let mut git_dir = self.git_dir().to_owned();
         let options = self.options.clone().open_path_as_is(true);
         if git_dir.is_relative()
diff --git a/gix/src/repository/location.rs b/gix/src/repository/location.rs
index dec8e6b72c0..6a075826027 100644
--- a/gix/src/repository/location.rs
+++ b/gix/src/repository/location.rs
@@ -1,10 +1,11 @@
+use gix_error::ResultExt;
 use gix_path::realpath::MAX_SYMLINKS;
 use std::{
     borrow::Cow,
     path::{Path, PathBuf},
 };
 
-use crate::bstr::BStr;
+use crate::{Error, ExnResult, Result, bstr::BStr};
 
 impl crate::Repository {
     /// Return the path to the repository itself, containing objects, references, configuration, and more.
@@ -79,7 +80,10 @@ impl crate::Repository {
     ///   will still claim that it is *not* a [main worktree](crate::Worktree::is_main()) as that depends
     ///   on the `git_dir`, not the worktree dir.
     #[doc(alias = "git2")]
-    pub fn set_workdir(&mut self, workdir: impl Into<Option<PathBuf>>) -> Result<Option<PathBuf>, std::io::Error> {
+    pub fn set_workdir(
+        &mut self,
+        workdir: impl Into<Option<PathBuf>>,
+    ) -> std::result::Result<Option<PathBuf>, std::io::Error> {
         let workdir = workdir.into();
         Ok(match workdir {
             None => self.work_tree.take(),
@@ -126,12 +130,7 @@ impl crate::Repository {
     /// Absolute paths must be within the worktree, or within the Git directory for bare repositories.
     /// Paths which traverse outside of the repository are rejected. Note that passing absolute paths is expensive
     /// as their realpath has to be determined.
-    pub fn normalize_path<'a>(
-        &self,
-        path: &'a (impl gix_utils::AsBStr + ?Sized),
-    ) -> Result<Cow<'a, BStr>, crate::repository::normalize_path::Error> {
-        use crate::repository::normalize_path::Error;
-
+    pub fn normalize_path<'a>(&self, path: &'a (impl gix_utils::AsBStr + ?Sized)) -> Result<Cow<'a, BStr>> {
         let path = gix_path::from_bstr(Cow::Borrowed(path.as_bstr()));
         let path = if gix_path::is_absolute(path.as_ref()) {
             let root = gix_path::realpath_opts(
@@ -145,7 +144,13 @@ impl crate::Repository {
             } else {
                 gix_path::realpath_opts(&absolute, self.current_dir(), MAX_SYMLINKS)?
                     .strip_prefix(&root)
-                    .map_err(|_| Error::AbsolutePathOutsideOfRepository { path: absolute, root })?
+                    .or_raise(|| {
+                        gix_error::validation(format!(
+                            "The absolute path '{}' is not inside the repository at '{}'",
+                            absolute.display(),
+                            root.display()
+                        ))
+                    })?
                     .to_owned()
             };
             Cow::Owned(relative)
@@ -156,11 +161,20 @@ impl crate::Repository {
         };
 
         let path = match path {
-            Cow::Borrowed(path) => gix_path::normalize_and_clean(Cow::Borrowed(path), Path::new(""))
-                .ok_or_else(|| Error::OutsideOfRepository { path: path.to_owned() })?,
+            Cow::Borrowed(path) => {
+                gix_path::normalize_and_clean(Cow::Borrowed(path), Path::new("")).ok_or_else(|| {
+                    Error::from_error(gix_error::validation(format!(
+                        "The path '{}' leaves the repository",
+                        path.display()
+                    )))
+                })?
+            }
             Cow::Owned(path) => {
                 if gix_path::normalize_and_clean(Cow::Borrowed(path.as_path()), Path::new("")).is_none() {
-                    return Err(Error::OutsideOfRepository { path });
+                    return Err(Error::from_error(gix_error::validation(format!(
+                        "The path '{}' leaves the repository",
+                        path.display()
+                    ))));
                 }
                 gix_path::normalize_and_clean(Cow::Owned(path), Path::new(""))
                     .expect("path was just validated as normalizable")
@@ -180,7 +194,7 @@ impl crate::Repository {
     ///
     /// Note that the CWD is obtained once upon instantiation of the repository.
     // TODO: tests, details - there is a lot about environment variables to change things around.
-    pub fn prefix(&self) -> Result<Option<&Path>, gix_path::realpath::Error> {
+    pub fn prefix(&self) -> ExnResult<Option<&Path>> {
         let (root, current_dir) = match self.workdir().zip(self.options.current_dir.as_deref()) {
             Some((work_dir, cwd)) => (work_dir, cwd),
             None => return Ok(None),
diff --git a/gix/src/repository/mailmap.rs b/gix/src/repository/mailmap.rs
index 6ee80d2d6c9..a44a5042301 100644
--- a/gix/src/repository/mailmap.rs
+++ b/gix/src/repository/mailmap.rs
@@ -1,4 +1,5 @@
-use crate::{Id, bstr::ByteSlice, config::tree::Mailmap};
+use crate::{Error, Id, Result, bstr::ByteSlice, config::tree::Mailmap};
+use gix_error::ErrorExt;
 
 impl crate::Repository {
     /// Similar to [`open_mailmap_into()`][crate::Repository::open_mailmap_into()], but ignores all errors and returns at worst
@@ -21,12 +22,17 @@ impl crate::Repository {
     ///
     /// Only the first error will be reported, and as many source mailmaps will be merged into `target` as possible.
     /// Parsing errors will be ignored.
-    pub fn open_mailmap_into(&self, target: &mut gix_mailmap::Snapshot) -> Result<(), crate::mailmap::load::Error> {
-        let mut err = None::<crate::mailmap::load::Error>;
+    pub fn open_mailmap_into(&self, target: &mut gix_mailmap::Snapshot) -> Result<()> {
+        let mut err = None::<Error>;
         let mut buf = Vec::new();
         let mut blob_id = self.config.resolved.string(Mailmap::BLOB).and_then(|spec| {
             self.rev_parse_single(spec.as_bstr())
-                .map_err(|e| err.get_or_insert(e.into()))
+                .map_err(|e| {
+                    err.get_or_insert(
+                        e.and_raise(gix_error::message("The configured mailmap.blob could not be parsed"))
+                            .into(),
+                    )
+                })
                 .map(Id::detach)
                 .ok()
         });
@@ -46,36 +52,73 @@ impl crate::Repository {
                     .open(root.join(".mailmap"))
                     .map_err(|e| {
                         if e.kind() != std::io::ErrorKind::NotFound {
-                            err.get_or_insert(e.into());
+                            err.get_or_insert(
+                                e.and_raise(gix_error::message(
+                                    "The mailmap file declared in `mailmap.file` could not be read",
+                                ))
+                                .into(),
+                            );
                         }
                     })
                 {
                     buf.clear();
                     std::io::copy(&mut file, &mut buf)
-                        .map_err(|e| err.get_or_insert(e.into()))
+                        .map_err(|e| {
+                            err.get_or_insert(
+                                e.and_raise(gix_error::message(
+                                    "The mailmap file declared in `mailmap.file` could not be read",
+                                ))
+                                .into(),
+                            )
+                        })
                         .ok();
                     target.merge(gix_mailmap::parse_ignore_errors(&buf));
                 }
             }
         }
 
-        if let Some(blob) = blob_id.and_then(|id| self.find_object(id).map_err(|e| err.get_or_insert(e.into())).ok()) {
+        if let Some(blob) = blob_id.and_then(|id| {
+            self.find_object(id)
+                .map_err(|e| {
+                    err.get_or_insert(
+                        e.and_raise(gix_error::message("Could not find object configured in `mailmap.blob`"))
+                            .into(),
+                    )
+                })
+                .ok()
+        }) {
             target.merge(gix_mailmap::parse_ignore_errors(&blob.data));
         }
 
         let configured_path = self
             .config_snapshot()
             .trusted_path(Mailmap::FILE)
-            .map_err(|e| err.get_or_insert(e.into()))
+            .map_err(|e| err.get_or_insert(Error::from_error(e)))
             .ok()
             .flatten();
 
-        if let Some(mut file) =
-            configured_path.and_then(|path| std::fs::File::open(path).map_err(|e| err.get_or_insert(e.into())).ok())
-        {
+        if let Some(mut file) = configured_path.and_then(|path| {
+            std::fs::File::open(path)
+                .map_err(|e| {
+                    err.get_or_insert(
+                        e.and_raise(gix_error::message(
+                            "The mailmap file declared in `mailmap.file` could not be read",
+                        ))
+                        .into(),
+                    )
+                })
+                .ok()
+        }) {
             buf.clear();
             std::io::copy(&mut file, &mut buf)
-                .map_err(|e| err.get_or_insert(e.into()))
+                .map_err(|e| {
+                    err.get_or_insert(
+                        e.and_raise(gix_error::message(
+                            "The mailmap file declared in `mailmap.file` could not be read",
+                        ))
+                        .into(),
+                    )
+                })
                 .ok();
             target.merge(gix_mailmap::parse_ignore_errors(&buf));
         }
diff --git a/gix/src/repository/merge.rs b/gix/src/repository/merge.rs
index 663af4b92e4..5cdf447076a 100644
--- a/gix/src/repository/merge.rs
+++ b/gix/src/repository/merge.rs
@@ -1,14 +1,12 @@
+use gix_error::ResultExt;
+
 use gix_merge::blob::builtin_driver::text;
 use gix_object::Write;
 
 use crate::{
-    Repository,
+    Error, Repository, Result,
     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,
-    },
 };
 
 /// Merge-utilities
@@ -22,12 +20,13 @@ impl Repository {
     pub fn merge_resource_cache(
         &self,
         worktree_roots: gix_merge::blob::pipeline::WorktreeRoots,
-    ) -> Result<gix_merge::blob::Platform, merge_resource_cache::Error> {
+    ) -> Result<gix_merge::blob::Platform> {
         let index = self.index_or_load_from_head_or_empty()?;
         let mode = {
             let renormalize = tree::Merge::RENORMALIZE
                 .enrich_error(self.config.resolved.boolean(tree::Merge::RENORMALIZE))
-                .with_lenient_default(self.config.lenient_config)?
+                .with_lenient_default(self.config.lenient_config)
+                .or_erased()?
                 .unwrap_or_default();
             if renormalize {
                 gix_merge::blob::pipeline::Mode::Renormalize
@@ -43,7 +42,8 @@ impl Repository {
                 } else {
                     gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                 },
-            )?
+            )
+            .or_erased()?
             .inner;
         let filter = gix_filter::Pipeline::new(self.command_context()?, crate::filter::Pipeline::options(self)?);
         let filter = gix_merge::blob::Pipeline::new(worktree_roots, filter, self.config.merge_pipeline_options()?);
@@ -56,12 +56,12 @@ impl Repository {
 
     /// Return options for use with [`gix_merge::blob::PlatformRef::merge()`], accessible through
     /// [merge_resource_cache()](Self::merge_resource_cache).
-    pub fn blob_merge_options(&self) -> Result<gix_merge::blob::platform::merge::Options, blob_merge_options::Error> {
+    pub fn blob_merge_options(&self) -> Result<gix_merge::blob::platform::merge::Options> {
         Ok(gix_merge::blob::platform::merge::Options {
             is_virtual_ancestor: false,
             resolve_binary_with: None,
             text: gix_merge::blob::builtin_driver::text::Options {
-                diff_algorithm: self.diff_algorithm()?,
+                diff_algorithm: self.diff_algorithm().or_erased()?,
                 conflict: text::Conflict::Keep {
                     style: self
                         .config
@@ -72,7 +72,8 @@ impl Repository {
                                 .try_into_conflict_style(value)
                                 .with_lenient_default(self.config.lenient_config)
                         })
-                        .transpose()?
+                        .transpose()
+                        .or_erased()?
                         .unwrap_or_default(),
                     marker_size: text::Conflict::DEFAULT_MARKER_SIZE.try_into().unwrap(),
                 },
@@ -81,7 +82,7 @@ impl Repository {
     }
 
     /// Read all relevant configuration options to instantiate options for use in [`merge_trees()`](Self::merge_trees).
-    pub fn tree_merge_options(&self) -> Result<crate::merge::tree::Options, tree_merge_options::Error> {
+    pub fn tree_merge_options(&self) -> Result<crate::merge::tree::Options> {
         let (mut rewrites, mut is_configured) = crate::diff::utils::new_rewrites_inner(
             &self.config.resolved,
             self.config.lenient_config,
@@ -130,7 +131,7 @@ impl Repository {
         their_tree: impl AsRef<gix_hash::oid>,
         labels: gix_merge::blob::builtin_driver::text::Labels<'_>,
         options: crate::merge::tree::Options,
-    ) -> Result<crate::merge::tree::Outcome<'_>, merge_trees::Error> {
+    ) -> Result<crate::merge::tree::Outcome<'_>> {
         let mut diff_cache = self.diff_resource_cache_for_tree_diff()?;
         let mut blob_merge = self.merge_resource_cache(Default::default())?;
         let gix_merge::tree::Outcome {
@@ -150,7 +151,7 @@ impl Repository {
             options.into(),
         )?;
 
-        let validate = self.config.protect_options()?;
+        let validate = self.config.protect_options().or_erased()?;
         Ok(crate::merge::tree::Outcome {
             tree: crate::object::tree::Editor {
                 inner: tree,
@@ -184,7 +185,7 @@ impl Repository {
         their_commit: impl Into<gix_hash::ObjectId>,
         labels: gix_merge::blob::builtin_driver::text::Labels<'_>,
         options: crate::merge::commit::Options,
-    ) -> Result<crate::merge::commit::Outcome<'_>, merge_commits::Error> {
+    ) -> Result<crate::merge::commit::Outcome<'_>> {
         let mut diff_cache = self.diff_resource_cache_for_tree_diff()?;
         let mut blob_merge = self.merge_resource_cache(Default::default())?;
         let commit_graph = self.commit_graph_if_enabled()?;
@@ -211,7 +212,7 @@ impl Repository {
             options.into(),
         )?;
 
-        let validate = self.config.protect_options()?;
+        let validate = self.config.protect_options().or_erased()?;
         let tree_merge = crate::merge::tree::Outcome {
             tree: crate::object::tree::Editor {
                 inner: tree,
@@ -242,10 +243,10 @@ impl Repository {
         &self,
         merge_bases: impl IntoIterator<Item = impl Into<gix_hash::ObjectId>>,
         options: crate::merge::tree::Options,
-    ) -> Result<crate::merge::virtual_merge_base::Outcome<'_>, virtual_merge_base::Error> {
+    ) -> Result<crate::merge::virtual_merge_base::Outcome<'_>> {
         let commit_graph = self.commit_graph_if_enabled()?;
         let mut graph = self.revision_graph(commit_graph.as_ref());
-        Ok(self.virtual_merge_base_with_graph(merge_bases, &mut graph, options)?)
+        self.virtual_merge_base_with_graph(merge_bases, &mut graph, options)
     }
 
     /// Like [`Self::virtual_merge_base()`], but also allows to reuse a `graph` for faster merge-base calculation,
@@ -255,13 +256,13 @@ impl Repository {
         merge_bases: impl IntoIterator<Item = impl Into<gix_hash::ObjectId>>,
         graph: &mut gix_revwalk::Graph<'_, '_, gix_revwalk::graph::Commit<gix_revision::merge_base::Flags>>,
         options: crate::merge::tree::Options,
-    ) -> Result<crate::merge::virtual_merge_base::Outcome<'_>, virtual_merge_base_with_graph::Error> {
+    ) -> Result<crate::merge::virtual_merge_base::Outcome<'_>> {
         let mut merge_bases: Vec<_> = merge_bases.into_iter().map(Into::into).collect();
         let first = merge_bases
             .pop()
-            .ok_or(virtual_merge_base_with_graph::Error::MissingCommit)?;
+            .ok_or_else(|| Error::from_error(gix_error::message("No commit was provided as merge-base")))?;
         let Some(second) = merge_bases.pop() else {
-            let tree_id = self.find_commit(first)?.tree_id()?;
+            let tree_id = self.find_commit(first)?.tree_id().or_erased()?;
             let commit_id = first.attach(self);
             return Ok(crate::merge::virtual_merge_base::Outcome {
                 virtual_merge_bases: Vec::new(),
diff --git a/gix/src/repository/mod.rs b/gix/src/repository/mod.rs
index 19f52b27aa7..2f7de6323a9 100644
--- a/gix/src/repository/mod.rs
+++ b/gix/src/repository/mod.rs
@@ -64,34 +64,6 @@ mod submodule;
 mod thread_safe;
 pub(crate) mod worktree;
 
-///
-mod new_commit {
-    /// The error returned by [`new_commit(…)`](crate::Repository::new_commit()).
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error(transparent)]
-        ParseTime(#[from] crate::config::time::Error),
-        #[error("Committer identity is not configured")]
-        CommitterMissing,
-        #[error("Author identity is not configured")]
-        AuthorMissing,
-        #[error(transparent)]
-        NewCommitAs(#[from] crate::repository::new_commit_as::Error),
-    }
-}
-
-///
-mod new_commit_as {
-    /// The error returned by [`new_commit_as(…)`](crate::Repository::new_commit_as()).
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error(transparent)]
-        WriteObject(#[from] crate::object::write::Error),
-        #[error(transparent)]
-        FindCommit(#[from] crate::object::find::existing::Error),
-    }
-}
-
 ///
 #[cfg(feature = "blame")]
 pub mod blame_file {
@@ -107,458 +79,4 @@ pub mod blame_file {
         /// Determine if rename tracking should be performed, and how.
         pub rewrites: Option<gix_diff::Rewrites>,
     }
-
-    /// The error returned by [Repository::blame_file()](crate::Repository::blame_file()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        CommitGraphIfEnabled(#[from] super::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        DiffAlgorithm(#[from] crate::config::diff::algorithm::Error),
-        #[error(transparent)]
-        DiffResourceCache(#[from] super::diff_resource_cache::Error),
-        #[error(transparent)]
-        Blame(#[from] gix_blame::Error),
-    }
-}
-
-///
-#[cfg(feature = "blob-diff")]
-pub mod diff_tree_to_tree {
-    /// The error returned by [Repository::diff_tree_to_tree()](crate::Repository::diff_tree_to_tree()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        DiffOptions(#[from] crate::diff::options::init::Error),
-        #[error(transparent)]
-        CreateResourceCache(#[from] super::diff_resource_cache::Error),
-        #[error(transparent)]
-        TreeDiff(#[from] gix_diff::tree_with_rewrites::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod blob_merge_options {
-    /// The error returned by [Repository::blob_merge_options()](crate::Repository::blob_merge_options()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        DiffAlgorithm(#[from] crate::config::diff::algorithm::Error),
-        #[error(transparent)]
-        ConflictStyle(#[from] crate::config::key::GenericErrorWithValue),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod merge_resource_cache {
-    /// The error returned by [Repository::merge_resource_cache()](crate::Repository::merge_resource_cache()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        RenormalizeConfig(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        PipelineOptions(#[from] crate::config::merge::pipeline_options::Error),
-        #[error(transparent)]
-        Index(#[from] crate::repository::index_or_load_from_head_or_empty::Error),
-        #[error(transparent)]
-        AttributeStack(#[from] crate::config::attribute_stack::Error),
-        #[error(transparent)]
-        CommandContext(#[from] crate::config::command_context::Error),
-        #[error(transparent)]
-        FilterPipeline(#[from] crate::filter::pipeline::options::Error),
-        #[error(transparent)]
-        DriversConfig(#[from] crate::config::merge::drivers::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod merge_trees {
-    /// The error returned by [Repository::merge_trees()](crate::Repository::merge_trees()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        MergeResourceCache(#[from] super::merge_resource_cache::Error),
-        #[error(transparent)]
-        DiffResourceCache(#[from] super::diff_resource_cache::Error),
-        #[error(transparent)]
-        TreeMerge(#[from] gix_merge::tree::Error),
-        #[error(transparent)]
-        ValidationOptions(#[from] crate::config::boolean::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod merge_commits {
-    /// The error returned by [Repository::merge_commits()](crate::Repository::merge_commits()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCommitGraph(#[from] super::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        MergeResourceCache(#[from] super::merge_resource_cache::Error),
-        #[error(transparent)]
-        DiffResourceCache(#[from] super::diff_resource_cache::Error),
-        #[error(transparent)]
-        CommitMerge(#[from] gix_merge::commit::Error),
-        #[error(transparent)]
-        ValidationOptions(#[from] crate::config::boolean::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod virtual_merge_base {
-    /// The error returned by [Repository::virtual_merge_base()](crate::Repository::virtual_merge_base()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCommitGraph(#[from] super::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        VirtualMergeBase(#[from] super::virtual_merge_base_with_graph::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod virtual_merge_base_with_graph {
-    /// The error returned by [Repository::virtual_merge_base_with_graph()](crate::Repository::virtual_merge_base_with_graph()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("No commit was provided as merge-base")]
-        MissingCommit,
-        #[error(transparent)]
-        MergeResourceCache(#[from] super::merge_resource_cache::Error),
-        #[error(transparent)]
-        DiffResourceCache(#[from] super::diff_resource_cache::Error),
-        #[error(transparent)]
-        CommitMerge(#[from] gix_merge::commit::Error),
-        #[error(transparent)]
-        FindCommit(#[from] crate::object::find::existing::with_conversion::Error),
-        #[error(transparent)]
-        DecodeCommit(#[from] gix_object::decode::Error),
-    }
-}
-
-///
-#[cfg(feature = "revision")]
-pub mod merge_base_octopus_with_graph {
-    /// The error returned by [Repository::merge_base_octopus_with_graph()](crate::Repository::merge_base_octopus_with_graph()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("No commit was provided")]
-        MissingCommit,
-        #[error("No merge base was found between the given commits")]
-        NoMergeBase,
-        #[error(transparent)]
-        MergeBase(#[from] gix_revision::merge_base::Error),
-    }
-}
-
-///
-#[cfg(feature = "revision")]
-pub mod merge_base_octopus {
-    /// The error returned by [Repository::merge_base_octopus()](crate::Repository::merge_base_octopus()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        MergeBaseOctopus(#[from] super::merge_base_octopus_with_graph::Error),
-    }
-}
-
-///
-#[cfg(feature = "revision")]
-pub mod merge_bases_many {
-    /// The error returned by [Repository::merge_bases_many()](crate::Repository::merge_bases_many()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        MergeBase(#[from] gix_revision::merge_base::Error),
-    }
-}
-
-///
-#[cfg(feature = "merge")]
-pub mod tree_merge_options {
-    /// The error returned by [Repository::tree_merge_options()](crate::Repository::tree_merge_options()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        BlobMergeOptions(#[from] super::blob_merge_options::Error),
-        #[error(transparent)]
-        RewritesConfig(#[from] crate::diff::new_rewrites::Error),
-        #[error(transparent)]
-        CommandContext(#[from] crate::config::command_context::Error),
-    }
-}
-
-///
-#[cfg(feature = "blob-diff")]
-pub mod diff_resource_cache {
-    /// The error returned by [Repository::diff_resource_cache()](crate::Repository::diff_resource_cache()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not obtain resource cache for diffing")]
-        ResourceCache(#[from] crate::diff::resource_cache::Error),
-        #[error(transparent)]
-        Index(#[from] crate::repository::index_or_load_from_head_or_empty::Error),
-        #[error(transparent)]
-        AttributeStack(#[from] crate::config::attribute_stack::Error),
-    }
-}
-
-///
-pub mod edit_tree {
-    /// The error returned by [Repository::edit_tree()](crate::Repository::edit_tree).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FindTree(#[from] crate::object::find::existing::with_conversion::Error),
-        #[error(transparent)]
-        InitEditor(#[from] crate::object::tree::editor::init::Error),
-    }
-}
-
-///
-#[cfg(feature = "revision")]
-pub mod merge_base {
-    /// The error returned by [Repository::merge_base()](crate::Repository::merge_base()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
-        #[error(transparent)]
-        FindMergeBase(#[from] gix_revision::merge_base::Error),
-        #[error("Could not find a merge-base between commits {first} and {second}")]
-        NotFound {
-            first: gix_hash::ObjectId,
-            second: gix_hash::ObjectId,
-        },
-    }
-}
-
-///
-#[cfg(feature = "revision")]
-pub mod merge_base_with_graph {
-    /// The error returned by [Repository::merge_base_with_cache()](crate::Repository::merge_base_with_graph()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FindMergeBase(#[from] gix_revision::merge_base::Error),
-        #[error("Could not find a merge-base between commits {first} and {second}")]
-        NotFound {
-            first: gix_hash::ObjectId,
-            second: gix_hash::ObjectId,
-        },
-    }
-}
-
-///
-pub mod commit_graph_if_enabled {
-    /// The error returned by [Repository::commit_graph_if_enabled()](crate::Repository::commit_graph_if_enabled()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ConfigBoolean(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        OpenCommitGraph(#[from] crate::Error),
-    }
-}
-
-///
-#[cfg(feature = "index")]
-pub mod index_from_tree {
-    /// The error returned by [Repository::index_from_tree()](crate::Repository::index_from_tree).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Could not create index from tree at {id}")]
-        IndexFromTree {
-            id: gix_hash::ObjectId,
-            source: gix_index::init::from_tree::Error,
-        },
-        #[error("Couldn't obtain configuration for core.protect*")]
-        BooleanConfig(#[from] crate::config::boolean::Error),
-    }
-}
-
-///
-pub mod branch_remote_ref_name {
-    /// The error returned by [Repository::branch_remote_ref_name()](crate::Repository::branch_remote_ref_name()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The configured name of the remote ref to merge wasn't valid")]
-        ValidateFetchRemoteRefName(#[from] gix_validate::reference::name::Error),
-        #[error(transparent)]
-        PushDefault(#[from] crate::config::key::GenericErrorWithValue),
-        #[error(transparent)]
-        FindPushRemote(#[from] crate::remote::find::existing::Error),
-    }
-}
-
-///
-pub mod branch_remote_tracking_ref_name {
-    /// The error returned by [Repository::branch_remote_tracking_ref_name()](crate::Repository::branch_remote_tracking_ref_name()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The name of the tracking reference was invalid")]
-        ValidateTrackingRef(#[from] gix_validate::reference::name::Error),
-        #[error("Could not get the remote reference to translate into the local tracking branch")]
-        RemoteRef(#[from] super::branch_remote_ref_name::Error),
-        #[error("Couldn't find remote to obtain fetch-specs for mapping to the tracking reference")]
-        FindRemote(#[from] crate::remote::find::existing::Error),
-    }
-}
-
-///
-pub mod upstream_branch_and_remote_name_for_tracking_branch {
-    /// The error returned by [Repository::upstream_branch_and_remote_name_for_tracking_branch()](crate::Repository::upstream_branch_and_remote_for_tracking_branch()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("The input branch '{}' needs to be a remote tracking branch", full_name.as_bstr())]
-        BranchCategory { full_name: gix_ref::FullName },
-        #[error(transparent)]
-        FindRemote(#[from] crate::remote::find::existing::Error),
-        #[error("Found ambiguous remotes without 1:1 mapping or more than one match: {}", remotes.iter()
-                                                                            .map(|r| r.as_bstr().to_string())
-                                                                            .collect::<Vec<_>>().join(", "))]
-        AmbiguousRemotes { remotes: Vec<crate::remote::Name<'static>> },
-        #[error(transparent)]
-        ValidateUpstreamBranch(#[from] gix_ref::name::Error),
-    }
-}
-
-///
-pub mod normalize_path {
-    /// The error returned by [Repository::normalize_path()](crate::Repository::normalize_path()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Realpath(#[from] gix_path::realpath::Error),
-        #[error("The path '{}' leaves the repository", path.display())]
-        OutsideOfRepository { path: std::path::PathBuf },
-        #[error(
-            "The absolute path '{}' is not inside the repository at '{}'",
-            path.display(),
-            root.display()
-        )]
-        AbsolutePathOutsideOfRepository {
-            path: std::path::PathBuf,
-            root: std::path::PathBuf,
-        },
-    }
-}
-
-///
-#[cfg(feature = "attributes")]
-pub mod pathspec_defaults_ignore_case {
-    /// The error returned by [Repository::pathspec_defaults_ignore_case()](crate::Repository::pathspec_defaults_inherit_ignore_case()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error("Filesystem configuration could not be obtained to learn about case sensitivity")]
-        FilesystemConfig(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        Defaults(#[from] gix_pathspec::defaults::from_environment::Error),
-    }
-}
-
-///
-#[cfg(feature = "index")]
-pub mod index_or_load_from_head {
-    /// The error returned by [`Repository::index_or_load_from_head()`](crate::Repository::index_or_load_from_head()).
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        HeadCommit(#[from] crate::reference::head_commit::Error),
-        #[error(transparent)]
-        TreeId(#[from] gix_object::decode::Error),
-        #[error(transparent)]
-        TraverseTree(#[from] crate::repository::index_from_tree::Error),
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-    }
-}
-
-///
-#[cfg(feature = "index")]
-pub mod index_or_load_from_head_or_empty {
-    /// The error returned by [`Repository::index_or_load_from_head_or_empty()`](crate::Repository::index_or_load_from_head_or_empty()).
-    #[derive(thiserror::Error, Debug)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ReadHead(#[from] crate::reference::find::existing::Error),
-        #[error(transparent)]
-        FindCommit(#[from] crate::object::find::existing::Error),
-        #[error(transparent)]
-        PeelToTree(#[from] crate::object::peel::to_kind::Error),
-        #[error(transparent)]
-        TreeId(#[from] gix_object::decode::Error),
-        #[error(transparent)]
-        TraverseTree(#[from] crate::repository::index_from_tree::Error),
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-    }
-}
-
-///
-#[cfg(feature = "worktree-stream")]
-pub mod worktree_stream {
-    /// The error returned by [`Repository::worktree_stream()`](crate::Repository::worktree_stream()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        FindTree(#[from] crate::object::find::existing::Error),
-        #[error(transparent)]
-        OpenTree(#[from] crate::repository::index_from_tree::Error),
-        #[error(transparent)]
-        AttributesCache(#[from] crate::config::attribute_stack::Error),
-        #[error(transparent)]
-        FilterPipeline(#[from] crate::filter::pipeline::options::Error),
-        #[error(transparent)]
-        CommandContext(#[from] crate::config::command_context::Error),
-        #[error("Needed {id} to be a tree to turn into a workspace stream, got {actual}")]
-        NotATree {
-            id: gix_hash::ObjectId,
-            actual: gix_object::Kind,
-        },
-    }
-}
-
-///
-#[cfg(feature = "worktree-archive")]
-pub mod worktree_archive {
-    /// The error returned by [`Repository::worktree_archive()`](crate::Repository::worktree_archive()).
-    pub type Error = gix_error::Error;
 }
diff --git a/gix/src/repository/note.rs b/gix/src/repository/note.rs
index 23e4d7c875f..144478ccf25 100644
--- a/gix/src/repository/note.rs
+++ b/gix/src/repository/note.rs
@@ -1,11 +1,11 @@
-use crate::note;
+use crate::{Result, note};
 
 impl crate::Repository {
     /// Return a platform for repeated Git notes queries and mutations.
     ///
     /// Selected notes references do not have to exist. Missing references are treated
     /// as containing no notes rather than causing queries to fail.
-    pub fn notes(&self) -> Result<note::Platform<'_>, crate::Error> {
+    pub fn notes(&self) -> Result<note::Platform<'_>> {
         note::Platform::new(self)
     }
 }
diff --git a/gix/src/repository/object.rs b/gix/src/repository/object.rs
index ebc2ef9aea7..e7a025a4d72 100644
--- a/gix/src/repository/object.rs
+++ b/gix/src/repository/object.rs
@@ -1,4 +1,6 @@
 #![allow(clippy::result_large_err)]
+use gix_error::ResultExt;
+
 use std::ops::DerefMut;
 
 use gix_hash::ObjectId;
@@ -7,8 +9,7 @@ use gix_odb::{Header, HeaderExt};
 use gix_ref::{FullName, transaction::PreviousValue};
 use smallvec::SmallVec;
 
-use crate::repository::{new_commit, new_commit_as};
-use crate::{Blob, Commit, Id, Object, Reference, Tag, Tree, commit, ext::ObjectIdExt, object, tag};
+use crate::{Blob, Commit, Error, Id, Object, Reference, Result, Tag, Tree, ext::ObjectIdExt, object};
 
 /// Tree editing
 impl crate::Repository {
@@ -16,12 +17,9 @@ impl crate::Repository {
     ///
     /// This can be the [empty tree id](ObjectId::empty_tree) to build a tree from scratch.
     #[doc(alias = "treebuilder", alias = "git2")]
-    pub fn edit_tree(
-        &self,
-        id: impl Into<ObjectId>,
-    ) -> Result<object::tree::Editor<'_>, crate::repository::edit_tree::Error> {
+    pub fn edit_tree(&self, id: impl Into<ObjectId>) -> Result<object::tree::Editor<'_>> {
         let tree = self.find_tree(id)?;
-        Ok(tree.edit()?)
+        tree.edit()
     }
 }
 
@@ -49,7 +47,7 @@ impl crate::Repository {
     /// assert_eq!(object.into_commit().message_raw()?, "c2\n");
     /// # Ok(()) }
     /// ```
-    pub fn find_object(&self, id: impl Into<ObjectId>) -> Result<Object<'_>, object::find::existing::Error> {
+    pub fn find_object(&self, id: impl Into<ObjectId>) -> Result<Object<'_>> {
         let id = id.into();
         if id == ObjectId::empty_tree(self.object_hash()) {
             return Ok(Object {
@@ -60,7 +58,11 @@ impl crate::Repository {
             });
         }
         let mut buf = self.free_buf();
-        let kind = self.objects.find(&id, &mut buf)?.kind;
+        let kind = self
+            .objects
+            .find(&id, &mut buf)
+            .map_err(crate::object::existing_error)?
+            .kind;
         Ok(Object::from_data(id, kind, buf, self))
     }
 
@@ -77,11 +79,8 @@ impl crate::Repository {
     /// assert_eq!(commit.message_raw()?, "c2\n");
     /// # Ok(()) }
     /// ```
-    pub fn find_commit(
-        &self,
-        id: impl Into<ObjectId>,
-    ) -> Result<Commit<'_>, object::find::existing::with_conversion::Error> {
-        Ok(self.find_object(id)?.try_into_commit()?)
+    pub fn find_commit(&self, id: impl Into<ObjectId>) -> Result<Commit<'_>> {
+        Ok(self.find_object(id)?.try_into_commit().or_erased()?)
     }
 
     /// Find a tree with `id` or fail if there was no object or the object wasn't a tree.
@@ -97,24 +96,18 @@ impl crate::Repository {
     /// assert_eq!(tree.find_entry("this").expect("present").filename(), "this");
     /// # Ok(()) }
     /// ```
-    pub fn find_tree(
-        &self,
-        id: impl Into<ObjectId>,
-    ) -> Result<Tree<'_>, object::find::existing::with_conversion::Error> {
-        Ok(self.find_object(id)?.try_into_tree()?)
+    pub fn find_tree(&self, id: impl Into<ObjectId>) -> Result<Tree<'_>> {
+        Ok(self.find_object(id)?.try_into_tree().or_erased()?)
     }
 
     /// Find an annotated tag with `id` or fail if there was no object or the object wasn't a tag.
-    pub fn find_tag(&self, id: impl Into<ObjectId>) -> Result<Tag<'_>, object::find::existing::with_conversion::Error> {
-        Ok(self.find_object(id)?.try_into_tag()?)
+    pub fn find_tag(&self, id: impl Into<ObjectId>) -> Result<Tag<'_>> {
+        Ok(self.find_object(id)?.try_into_tag().or_erased()?)
     }
 
     /// Find a blob with `id` or fail if there was no object or the object wasn't a blob.
-    pub fn find_blob(
-        &self,
-        id: impl Into<ObjectId>,
-    ) -> Result<Blob<'_>, object::find::existing::with_conversion::Error> {
-        Ok(self.find_object(id)?.try_into_blob()?)
+    pub fn find_blob(&self, id: impl Into<ObjectId>) -> Result<Blob<'_>> {
+        Ok(self.find_object(id)?.try_into_blob().or_erased()?)
     }
 
     /// Obtain information about an object without fully decoding it, or fail if the object doesn't exist.
@@ -135,7 +128,7 @@ impl crate::Repository {
     /// assert_eq!(header.kind(), gix::objs::Kind::Commit);
     /// # Ok(()) }
     /// ```
-    pub fn find_header(&self, id: impl Into<ObjectId>) -> Result<gix_odb::find::Header, object::find::existing::Error> {
+    pub fn find_header(&self, id: impl Into<ObjectId>) -> Result<gix_odb::find::Header> {
         let id = id.into();
         if id == ObjectId::empty_tree(self.object_hash()) {
             return Ok(gix_odb::find::Header::Loose {
@@ -143,7 +136,7 @@ impl crate::Repository {
                 size: 0,
             });
         }
-        self.objects.header(id)
+        self.objects.header(id).map_err(crate::object::existing_error)
     }
 
     /// Return `true` if `id` exists in the object database.
@@ -189,10 +182,7 @@ impl crate::Repository {
     /// assert_eq!(header.kind(), gix::objs::Kind::Commit);
     /// # Ok(()) }
     /// ```
-    pub fn try_find_header(
-        &self,
-        id: impl Into<ObjectId>,
-    ) -> Result<Option<gix_odb::find::Header>, object::find::Error> {
+    pub fn try_find_header(&self, id: impl Into<ObjectId>) -> Result<Option<gix_odb::find::Header>> {
         let id = id.into();
         if id == ObjectId::empty_tree(self.object_hash()) {
             return Ok(Some(gix_odb::find::Header::Loose {
@@ -200,7 +190,7 @@ impl crate::Repository {
                 size: 0,
             }));
         }
-        self.objects.try_header(&id).map_err(Into::into)
+        Ok(self.objects.try_header(&id).or_erased()?)
     }
 
     /// Try to find the object with `id` or return `None` if it wasn't found.
@@ -216,7 +206,7 @@ impl crate::Repository {
     /// assert_eq!(object.kind, gix::objs::Kind::Commit);
     /// # Ok(()) }
     /// ```
-    pub fn try_find_object(&self, id: impl Into<ObjectId>) -> Result<Option<Object<'_>>, object::find::Error> {
+    pub fn try_find_object(&self, id: impl Into<ObjectId>) -> Result<Option<Object<'_>>> {
         let id = id.into();
         if id == ObjectId::empty_tree(self.object_hash()) {
             return Ok(Some(Object {
@@ -228,7 +218,7 @@ impl crate::Repository {
         }
 
         let mut buf = self.free_buf();
-        match self.objects.try_find(&id, &mut buf)? {
+        match self.objects.try_find(&id, &mut buf).or_erased()? {
             Some(obj) => {
                 let kind = obj.kind;
                 Ok(Some(Object::from_data(id, kind, buf, self)))
@@ -244,26 +234,24 @@ impl crate::Repository {
     ///
     /// Note that we hash the object in memory to avoid storing objects that are already present. That way,
     /// we avoid writing duplicate objects using slow disks that will eventually have to be garbage collected.
-    pub fn write_object(&self, object: impl gix_object::WriteTo) -> Result<Id<'_>, object::write::Error> {
+    pub fn write_object(&self, object: impl gix_object::WriteTo) -> Result<Id<'_>> {
         let mut buf = self.empty_reusable_buffer();
-        object
-            .write_to(buf.deref_mut())
-            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)?;
+        object.write_to(buf.deref_mut()).or_erased()?;
 
         self.write_object_inner(&buf, object.kind())
     }
 
-    fn write_object_inner(&self, buf: &[u8], kind: gix_object::Kind) -> Result<Id<'_>, object::write::Error> {
-        let oid = gix_object::compute_hash(self.object_hash(), kind, buf)
-            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
+    fn write_object_inner(&self, buf: &[u8], kind: gix_object::Kind) -> Result<Id<'_>> {
+        let oid = gix_object::compute_hash(self.object_hash(), kind, buf).or_erased()?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
         }
 
-        self.objects
+        Ok(self
+            .objects
             .write_buf_with_known_id(kind, buf, oid)
             .map(|oid| oid.attach(self))
-            .map_err(Into::into)
+            .or_erased()?)
     }
 
     /// Write a blob from the given `bytes`.
@@ -283,17 +271,17 @@ impl crate::Repository {
     /// assert_eq!(repo.find_blob(blob_id)?.data, b"hello world");
     /// # Ok(()) }
     /// ```
-    pub fn write_blob(&self, bytes: impl AsRef<[u8]>) -> Result<Id<'_>, object::write::Error> {
+    pub fn write_blob(&self, bytes: impl AsRef<[u8]>) -> Result<Id<'_>> {
         let bytes = bytes.as_ref();
-        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, bytes)
-            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
+        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, bytes).or_erased()?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
         }
-        self.objects
+        Ok(self
+            .objects
             .write_buf_with_known_id(gix_object::Kind::Blob, bytes, oid)
-            .map_err(Into::into)
             .map(|oid| oid.attach(self))
+            .or_erased()?)
     }
 
     /// Write a blob from the given `Read` implementation.
@@ -302,25 +290,24 @@ impl crate::Repository {
     /// we avoid writing duplicate objects using slow disks that will eventually have to be garbage collected.
     ///
     /// If that is prohibitive, use the object database directly.
-    pub fn write_blob_stream(&self, mut bytes: impl std::io::Read) -> Result<Id<'_>, object::write::Error> {
+    pub fn write_blob_stream(&self, mut bytes: impl std::io::Read) -> Result<Id<'_>> {
         let mut buf = self.empty_reusable_buffer();
-        std::io::copy(&mut bytes, buf.deref_mut())
-            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
+        std::io::copy(&mut bytes, buf.deref_mut()).or_erased()?;
 
         self.write_blob_stream_inner(&buf)
     }
 
-    fn write_blob_stream_inner(&self, buf: &[u8]) -> Result<Id<'_>, object::write::Error> {
-        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, buf)
-            .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync>)?;
+    fn write_blob_stream_inner(&self, buf: &[u8]) -> Result<Id<'_>> {
+        let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, buf).or_erased()?;
         if self.objects.exists(&oid) {
             return Ok(oid.attach(self));
         }
 
-        self.objects
+        Ok(self
+            .objects
             .write_buf_with_known_id(gix_object::Kind::Blob, buf, oid)
-            .map_err(Into::into)
             .map(|oid| oid.attach(self))
+            .or_erased()?)
     }
 }
 
@@ -339,17 +326,17 @@ impl crate::Repository {
         tagger: Option<gix_actor::SignatureRef<'_>>,
         message: impl AsRef<str>,
         constraint: PreviousValue,
-    ) -> Result<Reference<'_>, tag::Error> {
+    ) -> Result<Reference<'_>> {
         let tag = gix_object::Tag {
             target: target.as_ref().into(),
             target_kind,
             name: name.as_ref().into(),
-            tagger: tagger.map(|t| t.to_owned()).transpose()?,
+            tagger: tagger.map(|t| t.to_owned()).transpose().or_erased()?,
             message: message.as_ref().into(),
             signature: None,
         };
         let tag_id = self.write_object(&tag)?;
-        self.tag_reference(name, tag_id, constraint).map_err(Into::into)
+        self.tag_reference(name, tag_id, constraint)
     }
 
     /// Similar to [`commit(…)`](crate::Repository::commit()), but allows to create the commit with `committer` and `author` specified.
@@ -363,15 +350,15 @@ impl crate::Repository {
         message: impl AsRef<str>,
         tree: impl Into<ObjectId>,
         parents: impl IntoIterator<Item = impl Into<ObjectId>>,
-    ) -> Result<Id<'_>, commit::Error>
+    ) -> Result<Id<'_>>
     where
         Name: TryInto<FullName, Error = E>,
-        commit::Error: From<E>,
+        E: std::error::Error + Send + Sync + 'static,
     {
         self.commit_as_inner(
             committer.into(),
             author.into(),
-            reference.try_into()?,
+            reference.try_into().or_erased()?,
             message.as_ref(),
             tree.into(),
             parents.into_iter().map(Into::into).collect(),
@@ -386,7 +373,7 @@ impl crate::Repository {
         message: &str,
         tree: ObjectId,
         parents: SmallVec<[ObjectId; 1]>,
-    ) -> Result<Id<'_>, commit::Error> {
+    ) -> Result<Id<'_>> {
         use gix_ref::{Target, transaction::RefEdit};
 
         // TODO: possibly use CommitRef to save a few allocations (but will have to allocate for object ids anyway.
@@ -451,13 +438,19 @@ impl crate::Repository {
         message: impl AsRef<str>,
         tree: impl Into<ObjectId>,
         parents: impl IntoIterator<Item = impl Into<ObjectId>>,
-    ) -> Result<Id<'_>, commit::Error>
+    ) -> Result<Id<'_>>
     where
         Name: TryInto<FullName, Error = E>,
-        commit::Error: From<E>,
+        E: std::error::Error + Send + Sync + 'static,
     {
-        let author = self.author().ok_or(commit::Error::AuthorMissing)??;
-        let committer = self.committer().ok_or(commit::Error::CommitterMissing)??;
+        let author = self
+            .author()
+            .ok_or_else(|| Error::from_error(gix_error::message("Author identity is not configured")))?
+            .or_erased()?;
+        let committer = self
+            .committer()
+            .ok_or_else(|| Error::from_error(gix_error::message("Committer identity is not configured")))?
+            .or_erased()?;
         self.commit_as(committer, author, reference, message, tree, parents)
     }
 
@@ -472,10 +465,14 @@ impl crate::Repository {
         message: impl AsRef<str>,
         tree: impl Into<ObjectId>,
         parents: impl IntoIterator<Item = impl Into<ObjectId>>,
-    ) -> Result<Commit<'_>, new_commit::Error> {
-        let author = self.author().ok_or(new_commit::Error::AuthorMissing)??;
-        let committer = self.committer().ok_or(new_commit::Error::CommitterMissing)??;
-        Ok(self.new_commit_as(committer, author, message, tree, parents)?)
+    ) -> Result<Commit<'_>> {
+        let author = self
+            .author()
+            .ok_or_else(|| Error::from_error(gix_error::validation("Author identity is not configured")))??;
+        let committer = self
+            .committer()
+            .ok_or_else(|| Error::from_error(gix_error::validation("Committer identity is not configured")))??;
+        self.new_commit_as(committer, author, message, tree, parents)
     }
 
     /// Create a nwe commit object with `message` referring to `tree` with `parents`, using the specified
@@ -490,7 +487,7 @@ impl crate::Repository {
         message: impl AsRef<str>,
         tree: impl Into<ObjectId>,
         parents: impl IntoIterator<Item = impl Into<ObjectId>>,
-    ) -> Result<Commit<'_>, new_commit_as::Error> {
+    ) -> Result<Commit<'_>> {
         let commit = gix_object::Commit {
             message: message.as_ref().into(),
             tree: tree.into(),
diff --git a/gix/src/repository/pathspec.rs b/gix/src/repository/pathspec.rs
index 60801b4cf25..2e087c6b6ab 100644
--- a/gix/src/repository/pathspec.rs
+++ b/gix/src/repository/pathspec.rs
@@ -1,6 +1,7 @@
+use gix_error::{ErrorExt, ResultExt};
 use gix_pathspec::MagicSignature;
 
-use crate::{AttributeStack, Pathspec, Repository, bstr::BStr, config::cache::util::ApplyLeniencyDefault};
+use crate::{AttributeStack, Pathspec, Repository, Result, bstr::BStr, config::cache::util::ApplyLeniencyDefault};
 
 impl Repository {
     /// Create a new pathspec abstraction that allows to conduct searches using `patterns`.
@@ -21,11 +22,11 @@ impl Repository {
         inherit_ignore_case: bool,
         index: &gix_index::State,
         attributes_source: gix_worktree::stack::state::attributes::Source,
-    ) -> Result<Pathspec<'_>, crate::pathspec::init::Error> {
+    ) -> Result<Pathspec<'_>> {
         Pathspec::new(self, empty_patterns_match_prefix, patterns, inherit_ignore_case, || {
             self.attributes_only(index, attributes_source)
                 .map(AttributeStack::detach)
-                .map_err(Into::into)
+                .or_erased()
         })
     }
 
@@ -33,22 +34,24 @@ impl Repository {
     ///
     /// These are stemming from environment variables which have been converted to [config settings](crate::config::tree::gitoxide::Pathspec),
     /// which now serve as authority for configuration.
-    pub fn pathspec_defaults(&self) -> Result<gix_pathspec::Defaults, gix_pathspec::defaults::from_environment::Error> {
-        self.config.pathspec_defaults()
+    pub fn pathspec_defaults(&self) -> Result<gix_pathspec::Defaults> {
+        self.config.pathspec_defaults().map_err(gix_error::Exn::into_error)
     }
 
     /// Similar to [Self::pathspec_defaults()], but will automatically configure the returned defaults to match case-insensitively if the underlying
     /// filesystem is also configured to be case-insensitive according to `core.ignoreCase`, and `inherit_ignore_case` is `true`.
-    pub fn pathspec_defaults_inherit_ignore_case(
-        &self,
-        inherit_ignore_case: bool,
-    ) -> Result<gix_pathspec::Defaults, crate::repository::pathspec_defaults_ignore_case::Error> {
+    pub fn pathspec_defaults_inherit_ignore_case(&self, inherit_ignore_case: bool) -> Result<gix_pathspec::Defaults> {
         let mut defaults = self.config.pathspec_defaults()?;
         if inherit_ignore_case
             && self
                 .config
                 .fs_capabilities()
-                .with_lenient_default(self.config.lenient_config)?
+                .with_lenient_default(self.config.lenient_config)
+                .map_err(|err| {
+                    err.and_raise(gix_error::message(
+                        "Filesystem configuration could not be obtained to learn about case sensitivity",
+                    ))
+                })?
                 .ignore_case
         {
             defaults.signature |= MagicSignature::ICASE;
diff --git a/gix/src/repository/reference.rs b/gix/src/repository/reference.rs
index bc0cc7a254a..74b7fd30f0d 100644
--- a/gix/src/repository/reference.rs
+++ b/gix/src/repository/reference.rs
@@ -4,7 +4,8 @@ use gix_ref::{
     transaction::{PreviousValue, RefEdit},
 };
 
-use crate::{Reference, bstr::BString, ext::ReferenceExt, reference};
+use crate::{Reference, Result, bstr::BString, ext::ReferenceExt, reference};
+use gix_error::{ErrorExt, ResultExt};
 
 /// Obtain and alter references comfortably
 impl crate::Repository {
@@ -17,14 +18,14 @@ impl crate::Repository {
         name: impl AsRef<str>,
         target: impl Into<ObjectId>,
         constraint: PreviousValue,
-    ) -> Result<Reference<'_>, reference::edit::Error> {
+    ) -> Result<Reference<'_>> {
         let id = target.into();
-        let mut edits = self.edit_reference(RefEdit::update(
-            format!("refs/tags/{}", name.as_ref()).try_into()?,
-            id,
-            constraint,
-            "",
-        ))?;
+        let name = format!("refs/tags/{}", name.as_ref()).try_into().map_err(
+            |err: gix_validate::reference::name::Error| {
+                err.and_raise(gix_error::validation("The tag reference name is invalid"))
+            },
+        )?;
+        let mut edits = self.edit_reference(RefEdit::update(name, id, constraint, ""))?;
         assert_eq!(edits.len(), 1, "reference splits should ever happen");
         let edit = edits.pop().expect("exactly one item");
         Ok(Reference {
@@ -55,7 +56,7 @@ impl crate::Repository {
     pub fn set_namespace<'a, Name, E>(
         &mut self,
         namespace: Name,
-    ) -> Result<Option<gix_ref::Namespace>, gix_validate::reference::name::Error>
+    ) -> std::result::Result<Option<gix_ref::Namespace>, gix_validate::reference::name::Error>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
         gix_validate::reference::name::Error: From<E>,
@@ -79,13 +80,15 @@ impl crate::Repository {
         target: impl Into<ObjectId>,
         constraint: PreviousValue,
         log_message: impl Into<BString>,
-    ) -> Result<Reference<'_>, reference::edit::Error>
+    ) -> Result<Reference<'_>>
     where
         Name: TryInto<FullName, Error = E>,
         gix_validate::reference::name::Error: From<E>,
     {
         self.reference_inner(
-            name.try_into().map_err(gix_validate::reference::name::Error::from)?,
+            name.try_into()
+                .map_err(gix_validate::reference::name::Error::from)
+                .map_err(|err| err.and_raise(gix_error::validation("The reference name is invalid")))?,
             target.into(),
             constraint,
             log_message.into(),
@@ -98,7 +101,7 @@ impl crate::Repository {
         id: ObjectId,
         constraint: PreviousValue,
         log_message: BString,
-    ) -> Result<Reference<'_>, reference::edit::Error> {
+    ) -> Result<Reference<'_>> {
         let mut edits = self.edit_reference(RefEdit::update(name, id, constraint, log_message))?;
         assert_eq!(
             edits.len(),
@@ -118,7 +121,7 @@ impl crate::Repository {
     ///
     /// One or more `RefEdit`s  are returned - symbolic reference splits can cause more edits to be performed. All edits have the previous
     /// reference values set to the ones encountered at rest after acquiring the respective reference's lock.
-    pub fn edit_reference(&self, edit: RefEdit) -> Result<Vec<RefEdit>, reference::edit::Error> {
+    pub fn edit_reference(&self, edit: RefEdit) -> Result<Vec<RefEdit>> {
         self.edit_references(Some(edit))
     }
 
@@ -129,10 +132,7 @@ impl crate::Repository {
     ///
     /// Returns all reference edits, which might be more than where provided due the splitting of symbolic references, and
     /// whose previous (_old_) values are the ones seen on in storage after the reference was locked.
-    pub fn edit_references(
-        &self,
-        edits: impl IntoIterator<Item = RefEdit>,
-    ) -> Result<Vec<RefEdit>, reference::edit::Error> {
+    pub fn edit_references(&self, edits: impl IntoIterator<Item = RefEdit>) -> Result<Vec<RefEdit>> {
         self.edit_references_as(edits, self.committer().transpose()?)
     }
 
@@ -143,13 +143,20 @@ impl crate::Repository {
         &self,
         edits: impl IntoIterator<Item = RefEdit>,
         committer: Option<gix_actor::SignatureRef<'_>>,
-    ) -> Result<Vec<RefEdit>, reference::edit::Error> {
-        let (file_lock_fail, packed_refs_lock_fail) = self.config.lock_timeout()?;
-        self.refs
+    ) -> Result<Vec<RefEdit>> {
+        let (file_lock_fail, packed_refs_lock_fail) = self.config.lock_timeout().map_err(|err| {
+            err.and_raise(gix_error::message(
+                "Could not interpret core.filesRefLockTimeout or core.packedRefsTimeout, it must be the number in \
+                 milliseconds to wait for locks or negative to wait forever",
+            ))
+        })?;
+        Ok(self
+            .refs
             .transaction()
-            .prepare(edits, file_lock_fail, packed_refs_lock_fail)?
+            .prepare(edits, file_lock_fail, packed_refs_lock_fail)
+            .or_erased()?
             .commit(committer)
-            .map_err(Into::into)
+            .or_erased()?)
     }
 
     /// Return the repository head, an abstraction to help dealing with the `HEAD` reference.
@@ -169,12 +176,12 @@ impl crate::Repository {
     /// assert!(!head.is_unborn());
     /// # Ok(()) }
     /// ```
-    pub fn head(&self) -> Result<crate::Head<'_>, reference::find::existing::Error> {
+    pub fn head(&self) -> Result<crate::Head<'_>> {
         let head = self.find_reference("HEAD")?;
         Ok(match head.inner.target {
             Target::Symbolic(branch) => match self.find_reference(&branch) {
                 Ok(r) => crate::head::Kind::Symbolic(r.detach()),
-                Err(reference::find::existing::Error::NotFound { .. }) => crate::head::Kind::Unborn(branch),
+                Err(err) if err.is_not_found() => crate::head::Kind::Unborn(branch),
                 Err(err) => return Err(err),
             },
             Target::Object(target) => crate::head::Kind::Detached {
@@ -193,20 +200,20 @@ impl crate::Repository {
     ///
     /// Also note that the returned id is likely to point to a commit, but could also
     /// point to a tree or blob. It won't, however, point to a tag as these are always peeled.
-    pub fn head_id(&self) -> Result<crate::Id<'_>, reference::head_id::Error> {
-        Ok(self.head()?.into_peeled_id()?)
+    pub fn head_id(&self) -> Result<crate::Id<'_>> {
+        self.head()?.into_peeled_id()
     }
 
     /// Return the name to the symbolic reference `HEAD` points to, or `None` if the head is detached.
     ///
     /// The difference to [`head_ref()`](Self::head_ref()) is that the latter requires the reference to exist,
     /// whereas here we merely return a the name of the possibly unborn reference.
-    pub fn head_name(&self) -> Result<Option<FullName>, reference::find::existing::Error> {
+    pub fn head_name(&self) -> Result<Option<FullName>> {
         Ok(self.head()?.referent_name().map(std::borrow::ToOwned::to_owned))
     }
 
     /// Return the reference that `HEAD` points to, or `None` if the head is detached or unborn.
-    pub fn head_ref(&self) -> Result<Option<Reference<'_>>, reference::find::existing::Error> {
+    pub fn head_ref(&self) -> Result<Option<Reference<'_>>> {
         Ok(self.head()?.try_into_referent())
     }
 
@@ -235,8 +242,8 @@ impl crate::Repository {
     /// }
     /// # Ok(()) }
     /// ```
-    pub fn head_commit(&self) -> Result<crate::Commit<'_>, reference::head_commit::Error> {
-        Ok(self.head()?.peel_to_commit()?)
+    pub fn head_commit(&self) -> Result<crate::Commit<'_>> {
+        self.head()?.peel_to_commit()
     }
 
     /// Return the tree id the `HEAD` reference currently points to after peeling it fully,
@@ -245,24 +252,18 @@ impl crate::Repository {
     /// Note that this may fail for various reasons, most notably because the repository
     /// is freshly initialized and doesn't have any commits yet. It could also fail if the
     /// head does not point to a commit.
-    pub fn head_tree_id(&self) -> Result<crate::Id<'_>, reference::head_tree_id::Error> {
-        Ok(self.head_commit()?.tree_id()?)
+    pub fn head_tree_id(&self) -> Result<crate::Id<'_>> {
+        Ok(self.head_commit()?.tree_id().or_erased()?)
     }
 
     /// Like [`Self::head_tree_id()`], but will return an empty tree hash if the repository HEAD is unborn.
-    pub fn head_tree_id_or_empty(&self) -> Result<crate::Id<'_>, reference::head_tree_id::Error> {
-        self.head_tree_id().or_else(|err| {
-            if let reference::head_tree_id::Error::HeadCommit(reference::head_commit::Error::PeelToCommit(
-                crate::head::peel::to_commit::Error::PeelToObject(crate::head::peel::to_object::Error::Unborn {
-                    ..
-                }),
-            )) = err
-            {
-                Ok(self.empty_tree().id())
-            } else {
-                Err(err)
-            }
-        })
+    pub fn head_tree_id_or_empty(&self) -> Result<crate::Id<'_>> {
+        let mut head = self.head()?;
+        if head.is_unborn() {
+            Ok(self.empty_tree().id())
+        } else {
+            Ok(head.peel_to_commit()?.tree_id().or_erased()?)
+        }
     }
 
     /// Return the tree object the `HEAD^{tree}` reference currently points to after peeling it fully,
@@ -283,8 +284,8 @@ impl crate::Repository {
     /// assert_eq!(tree.find_entry("this").expect("present").filename(), "this");
     /// # Ok(()) }
     /// ```
-    pub fn head_tree(&self) -> Result<crate::Tree<'_>, reference::head_tree::Error> {
-        Ok(self.head_commit()?.tree()?)
+    pub fn head_tree(&self) -> Result<crate::Tree<'_>> {
+        self.head_commit()?.tree()
     }
 
     /// Find the reference with the given partial or full `name`, like `main`, `HEAD`, `heads/branch` or `origin/other`,
@@ -305,21 +306,12 @@ impl crate::Repository {
     /// assert_eq!(reference.peel_to_commit()?.message()?.title, "c2");
     /// # Ok(()) }
     /// ```
-    pub fn find_reference<'a, Name, E>(&self, name: Name) -> Result<Reference<'_>, reference::find::existing::Error>
+    pub fn find_reference<'a, Name, E>(&self, name: Name) -> Result<Reference<'_>>
     where
-        Name: TryInto<&'a PartialNameRef, Error = E> + Clone,
-        gix_ref::file::find::Error: From<E>,
+        Name: TryInto<&'a PartialNameRef, Error = E>,
+        std::result::Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        // TODO: is there a way to just pass `partial_name` to `try_find_reference()`? Compiler freaks out then
-        //       as it still wants to see `E` there, not `Infallible`.
-        let partial_name = name
-            .clone()
-            .try_into()
-            .map_err(|err| reference::find::Error::Find(gix_ref::file::find::Error::from(err)))?;
-        self.try_find_reference(name)?
-            .ok_or_else(|| reference::find::existing::Error::NotFound {
-                name: partial_name.to_owned(),
-            })
+        Ok(Reference::from_ref(self.refs.find(name)?, self))
     }
 
     /// Return a platform for iterating references.
@@ -341,7 +333,7 @@ impl crate::Repository {
     /// assert_eq!(branches, vec!["refs/heads/main".to_owned()]);
     /// # Ok(()) }
     /// ```
-    pub fn references(&self) -> Result<reference::iter::Platform<'_>, reference::iter::Error> {
+    pub fn references(&self) -> Result<reference::iter::Platform<'_>> {
         Ok(reference::iter::Platform {
             platform: self.refs.iter()?,
             repo: self,
@@ -352,17 +344,11 @@ impl crate::Repository {
     ///
     /// Otherwise return `None` if the reference wasn't found.
     /// If the reference is expected to exist, use [`find_reference()`](crate::Repository::find_reference()).
-    pub fn try_find_reference<'a, Name, E>(&self, name: Name) -> Result<Option<Reference<'_>>, reference::find::Error>
+    pub fn try_find_reference<'a, Name, E>(&self, name: Name) -> Result<Option<Reference<'_>>>
     where
         Name: TryInto<&'a PartialNameRef, Error = E>,
-        gix_ref::file::find::Error: From<E>,
+        std::result::Result<&'a PartialNameRef, E>: ResultExt<Success = &'a PartialNameRef>,
     {
-        match self.refs.try_find(name) {
-            Ok(r) => match r {
-                Some(r) => Ok(Some(Reference::from_ref(r, self))),
-                None => Ok(None),
-            },
-            Err(err) => Err(err.into()),
-        }
+        Ok(self.refs.try_find(name)?.map(|r| Reference::from_ref(r, self)))
     }
 }
diff --git a/gix/src/repository/remote.rs b/gix/src/repository/remote.rs
index ff76e264b27..2f6ea750718 100644
--- a/gix/src/repository/remote.rs
+++ b/gix/src/repository/remote.rs
@@ -1,5 +1,6 @@
 #![allow(clippy::result_large_err)]
-use crate::{Remote, bstr::BStr, config, remote, remote::find};
+use crate::{Error, Remote, Result, bstr::BStr, config, remote};
+use gix_error::{ErrorExt, ResultExt};
 
 impl crate::Repository {
     /// Create a new remote available at the given `url`.
@@ -28,7 +29,7 @@ impl crate::Repository {
     /// );
     /// # Ok(()) }
     /// ```
-    pub fn remote_at<Url, E>(&self, url: Url) -> Result<Remote<'_>, remote::init::Error>
+    pub fn remote_at<Url, E>(&self, url: Url) -> Result<Remote<'_>>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
@@ -40,7 +41,7 @@ impl crate::Repository {
     /// but don't rewrite the url according to rewrite rules.
     /// This eliminates a failure mode in case the rewritten URL is faulty, allowing to selectively [apply rewrite
     /// rules][Remote::rewrite_urls()] later and do so non-destructively.
-    pub fn remote_at_without_url_rewrite<Url, E>(&self, url: Url) -> Result<Remote<'_>, remote::init::Error>
+    pub fn remote_at_without_url_rewrite<Url, E>(&self, url: Url) -> Result<Remote<'_>>
     where
         Url: TryInto<gix_url::Url, Error = E>,
         E: std::error::Error + Send + Sync + 'static,
@@ -65,13 +66,13 @@ impl crate::Repository {
     /// assert_eq!(remote.refspecs(gix::remote::Direction::Fetch).len(), 1);
     /// # Ok(()) }
     /// ```
-    pub fn find_remote(&self, name_or_url: impl gix_utils::AsBStr) -> Result<Remote<'_>, find::existing::Error> {
+    pub fn find_remote(&self, name_or_url: impl gix_utils::AsBStr) -> Result<Remote<'_>> {
         let name_or_url = name_or_url.as_bstr();
-        Ok(self
-            .try_find_remote(name_or_url)
-            .ok_or_else(|| find::existing::Error::NotFound {
-                name: name_or_url.into(),
-            })??)
+        self.try_find_remote(name_or_url).ok_or_else(|| {
+            Error::from_error(gix_error::not_found(format!(
+                "The remote named {name_or_url:?} did not exist"
+            )))
+        })?
     }
 
     /// Find the default remote as configured, or `None` if no such configuration could be found.
@@ -91,10 +92,7 @@ impl crate::Repository {
     /// assert_eq!(remote.name().expect("named").as_bstr(), "origin");
     /// # Ok(()) }
     /// ```
-    pub fn find_default_remote(
-        &self,
-        direction: remote::Direction,
-    ) -> Option<Result<Remote<'_>, find::existing::Error>> {
+    pub fn find_default_remote(&self, direction: remote::Direction) -> Option<Result<Remote<'_>>> {
         self.remote_default_name(direction).map(|name| self.find_remote(name))
     }
 
@@ -102,6 +100,8 @@ impl crate::Repository {
     /// for the purpose of fetching or pushing data.
     ///
     /// There are various error kinds related to partial information or incorrectly formatted URLs or ref-specs.
+    /// Invalid configured URLs or refspecs include `name_or_url` bytes as `input`
+    /// [metadata](gix_error::Error::metadata()).
     /// Also note that the created `Remote` may have neither fetch nor push ref-specs set at all.
     /// Unlike Git, a configured remote with a symbolic name and no effective fetch URL remains without a fetch URL. If the
     /// requested remote name is itself a URL, it is used as the fetch URL instead. This applies equally to remotes whose URL
@@ -116,7 +116,7 @@ impl crate::Repository {
     /// as negations/excludes are applied after includes.
     ///
     /// We will only include information if we deem it [trustworthy][crate::open::Options::filter_config_section()].
-    pub fn try_find_remote<'a>(&self, name_or_url: impl Into<&'a BStr>) -> Option<Result<Remote<'_>, find::Error>> {
+    pub fn try_find_remote<'a>(&self, name_or_url: impl Into<&'a BStr>) -> Option<Result<Remote<'_>>> {
         self.try_find_remote_inner(name_or_url.into(), true)
     }
 
@@ -147,11 +147,13 @@ impl crate::Repository {
     /// assert_eq!(remote.name().expect("configured").as_bstr(), "origin");
     /// # Ok(()) }
     /// ```
-    pub fn find_fetch_remote(&self, name_or_url: Option<&BStr>) -> Result<Remote<'_>, find::for_fetch::Error> {
+    pub fn find_fetch_remote(&self, name_or_url: Option<&BStr>) -> Result<Remote<'_>> {
         Ok(match name_or_url {
-            Some(name) => match self.try_find_remote(name).and_then(Result::ok) {
+            Some(name) => match self.try_find_remote(name).and_then(std::result::Result::ok) {
                 Some(remote) => remote,
-                None => self.remote_at(gix_url::parse(name).map_err(gix_error::Exn::into_error)?)?,
+                None => self.remote_at(
+                    gix_url::parse(name).or_raise(|| gix_error::message("remote name could not be parsed as URL"))?,
+                )?,
             },
             None => self
                 .head()?
@@ -159,7 +161,11 @@ impl crate::Repository {
                 .transpose()?
                 .map(Ok)
                 .or_else(|| self.find_default_remote(remote::Direction::Fetch))
-                .ok_or(find::for_fetch::Error::ExactlyOneRemoteNotAvailable)??,
+                .ok_or_else(|| {
+                    Error::from_error(gix_error::not_found(
+                        "No configured remote could be found, or too many were available",
+                    ))
+                })??,
         })
     }
 
@@ -169,7 +175,7 @@ impl crate::Repository {
     pub fn try_find_remote_without_url_rewrite<'a>(
         &self,
         name_or_url: impl Into<&'a BStr>,
-    ) -> Option<Result<Remote<'_>, find::Error>> {
+    ) -> Option<Result<Remote<'_>>> {
         self.try_find_remote_inner(name_or_url.into(), false)
     }
 
@@ -177,24 +183,29 @@ impl crate::Repository {
         &self,
         name_or_url: impl Into<&'a BStr>,
         rewrite_urls: bool,
-    ) -> Option<Result<Remote<'_>, find::Error>> {
+    ) -> Option<Result<Remote<'_>>> {
         fn config_spec<T: config::tree::keys::Validate>(
             specs: Vec<crate::bstr::BString>,
             name_or_url: &BStr,
             key: &'static config::tree::keys::Any<T>,
             op: gix_refspec::parse::Operation,
-        ) -> Result<Vec<gix_refspec::RefSpec>, find::Error> {
+        ) -> Result<Vec<gix_refspec::RefSpec>> {
             let kind = key.name;
             specs
                 .into_iter()
                 .map(|spec| {
-                    key.try_into_refspec(spec, op).map_err(|err| find::Error::RefSpec {
-                        remote_name: name_or_url.into(),
-                        kind,
-                        source: err,
+                    key.try_into_refspec(spec, op).map_err(|err| {
+                        Error::from(
+                            err.and_raise(
+                                gix_error::validation(format!(
+                                    "{kind} ref-spec under `remote.{name_or_url}` was invalid"
+                                ))
+                                .with("input", name_or_url.to_owned()),
+                            ),
+                        )
                     })
                 })
-                .collect::<Result<Vec<_>, _>>()
+                .collect::<std::result::Result<Vec<_>, _>>()
                 .map(|mut specs| {
                     specs.sort();
                     specs.dedup();
@@ -232,10 +243,15 @@ impl crate::Repository {
                     effective_urls
                         .into_iter()
                         .map(|url| {
-                            key.try_into_url(url).map_err(|err| find::Error::Url {
-                                kind,
-                                remote_name: name_or_url.into(),
-                                source: err,
+                            key.try_into_url(url).map_err(|err| {
+                                Error::from(
+                                    err.and_raise(
+                                        gix_error::validation(format!(
+                                            "The {kind} url under `remote.{name_or_url}` was invalid"
+                                        ))
+                                        .with("input", name_or_url.to_owned()),
+                                    ),
+                                )
                             })
                         })
                         .collect()
@@ -268,9 +284,11 @@ impl crate::Repository {
         let fetch_tags = config
             .string_filter(&format!("remote.{}.{}", name_or_url, "tagOpt"), &mut filter)
             .map(|value| {
-                config::tree::Remote::TAG_OPT
-                    .try_into_tag_opt(value)
-                    .map_err(Into::into)
+                config::tree::Remote::TAG_OPT.try_into_tag_opt(value).map_err(|err| {
+                    Error::from(err.and_raise(gix_error::message(
+                        "The value for 'remote.<name>.tagOpt` is invalid and must either be '--tags' or '--no-tags'",
+                    )))
+                })
             });
         let fetch_tags = match fetch_tags {
             Some(Ok(v)) => v,
@@ -310,29 +328,29 @@ impl crate::Repository {
                         Ok(url) if name_is_url || url.scheme != gix_url::Scheme::File => urls.push(url),
                         Ok(_) => {}
                         Err(source) if name_is_url => {
-                            return Some(Err(find::Error::Url {
-                                kind: "fetch",
-                                remote_name: name_or_url.into(),
-                                source,
-                            }));
+                            return Some(Err(Error::from(
+                                source.and_raise(
+                                    gix_error::validation(format!(
+                                        "The fetch url under `remote.{name_or_url}` was invalid"
+                                    ))
+                                    .with("input", name_or_url.to_owned()),
+                                ),
+                            )));
                         }
                         Err(_) => {}
                     }
                 }
 
-                Some(
-                    Remote::from_preparsed_config(
-                        Some(name_or_url.to_owned()),
-                        urls,
-                        push_urls,
-                        fetch_specs,
-                        push_specs,
-                        rewrite_urls,
-                        fetch_tags,
-                        self,
-                    )
-                    .map_err(Into::into),
-                )
+                Some(Remote::from_preparsed_config(
+                    Some(name_or_url.to_owned()),
+                    urls,
+                    push_urls,
+                    fetch_specs,
+                    push_specs,
+                    rewrite_urls,
+                    fetch_tags,
+                    self,
+                ))
             }
         }
     }
diff --git a/gix/src/repository/revision.rs b/gix/src/repository/revision.rs
index 905a40d3189..2120cf5db0b 100644
--- a/gix/src/repository/revision.rs
+++ b/gix/src/repository/revision.rs
@@ -1,6 +1,9 @@
+#[cfg(feature = "revision")]
+use gix_error::ResultExt;
+
 use crate::revision;
 #[cfg(feature = "revision")]
-use crate::{Id, bstr::BStr};
+use crate::{Error, Id, Result, bstr::BStr};
 
 /// Methods for resolving revisions by spec or working with the commit graph.
 impl crate::Repository {
@@ -12,7 +15,7 @@ impl crate::Repository {
     ///   `HEAD` ref available for lookups.
     #[doc(alias = "revparse", alias = "git2")]
     #[cfg(feature = "revision")]
-    pub fn rev_parse<'a>(&self, spec: impl Into<&'a BStr>) -> Result<revision::Spec<'_>, gix_error::Error> {
+    pub fn rev_parse<'a>(&self, spec: impl Into<&'a BStr>) -> Result<revision::Spec<'_>> {
         revision::Spec::from_bstr(
             spec,
             self,
@@ -39,14 +42,14 @@ impl crate::Repository {
     /// ```
     #[doc(alias = "revparse_single", alias = "git2")]
     #[cfg(feature = "revision")]
-    pub fn rev_parse_single<'repo, 'a>(
-        &'repo self,
-        spec: impl Into<&'a BStr>,
-    ) -> Result<Id<'repo>, revision::spec::parse::single::Error> {
+    pub fn rev_parse_single<'repo, 'a>(&'repo self, spec: impl Into<&'a BStr>) -> Result<Id<'repo>> {
         let spec = spec.into();
-        self.rev_parse(spec)?
-            .single()
-            .ok_or(revision::spec::parse::single::Error::RangedRev { spec: spec.into() })
+        self.rev_parse(spec)?.single().ok_or_else(|| {
+            let spec: crate::bstr::BString = spec.into();
+            Error::from_error(gix_error::message!(
+                "revspec {spec:?} did not resolve to a single object"
+            ))
+        })
     }
 
     /// Obtain the best merge-base between commit `one` and `two`, or fail if there is none.
@@ -55,20 +58,19 @@ impl crate::Repository {
     /// For repeated calls, prefer [`merge_base_with_cache()`](crate::Repository::merge_base_with_graph()).
     /// Also be sure to [set an object cache](crate::Repository::object_cache_size_if_unset) to accelerate repeated commit lookups.
     #[cfg(feature = "revision")]
-    pub fn merge_base(
-        &self,
-        one: impl Into<gix_hash::ObjectId>,
-        two: impl Into<gix_hash::ObjectId>,
-    ) -> Result<Id<'_>, super::merge_base::Error> {
+    pub fn merge_base(&self, one: impl Into<gix_hash::ObjectId>, two: impl Into<gix_hash::ObjectId>) -> Result<Id<'_>> {
         use crate::prelude::ObjectIdExt;
         let one = one.into();
         let two = two.into();
         let cache = self.commit_graph_if_enabled()?;
         let mut graph = self.revision_graph(cache.as_ref());
-        let bases = gix_revision::merge_base(one, &[two], &mut graph)?.ok_or(super::merge_base::Error::NotFound {
-            first: one,
-            second: two,
-        })?;
+        let bases = gix_revision::merge_base(one, &[two], &mut graph)
+            .or_erased()?
+            .ok_or_else(|| {
+                Error::from_error(gix_error::message!(
+                    "Could not find a merge-base between commits {one} and {two}"
+                ))
+            })?;
         Ok(bases.first().attach(self))
     }
 
@@ -83,14 +85,16 @@ impl crate::Repository {
         one: impl Into<gix_hash::ObjectId>,
         two: impl Into<gix_hash::ObjectId>,
         graph: &mut gix_revwalk::Graph<'_, '_, gix_revwalk::graph::Commit<gix_revision::merge_base::Flags>>,
-    ) -> Result<Id<'_>, super::merge_base_with_graph::Error> {
+    ) -> Result<Id<'_>> {
         use crate::prelude::ObjectIdExt;
         let one = one.into();
         let two = two.into();
-        let bases =
-            gix_revision::merge_base(one, &[two], graph)?.ok_or(super::merge_base_with_graph::Error::NotFound {
-                first: one,
-                second: two,
+        let bases = gix_revision::merge_base(one, &[two], graph)
+            .or_erased()?
+            .ok_or_else(|| {
+                Error::from_error(gix_error::message!(
+                    "Could not find a merge-base between commits {one} and {two}"
+                ))
             })?;
         Ok(bases.first().attach(self))
     }
@@ -107,7 +111,7 @@ impl crate::Repository {
         one: impl Into<gix_hash::ObjectId>,
         others: &[gix_hash::ObjectId],
         graph: &mut gix_revwalk::Graph<'_, '_, gix_revwalk::graph::Commit<gix_revision::merge_base::Flags>>,
-    ) -> Result<Vec<Id<'_>>, gix_revision::merge_base::Error> {
+    ) -> Result<Vec<Id<'_>>> {
         use crate::prelude::ObjectIdExt;
         let one = one.into();
         Ok(match gix_revision::merge_base(one, others, graph)? {
@@ -128,10 +132,10 @@ impl crate::Repository {
         &self,
         one: impl Into<gix_hash::ObjectId>,
         others: &[gix_hash::ObjectId],
-    ) -> Result<Vec<Id<'_>>, crate::repository::merge_bases_many::Error> {
+    ) -> Result<Vec<Id<'_>>> {
         let cache = self.commit_graph_if_enabled()?;
         let mut graph = self.revision_graph(cache.as_ref());
-        Ok(self.merge_bases_many_with_graph(one, others, &mut graph)?)
+        Ok(self.merge_bases_many_with_graph(one, others, &mut graph).or_erased()?)
     }
 
     /// Return the best merge-base among all `commits`, or fail if `commits` yields no commit or no merge-base was found.
@@ -142,15 +146,16 @@ impl crate::Repository {
         &self,
         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, repository::merge_base_octopus_with_graph};
+    ) -> Result<Id<'_>> {
+        use crate::prelude::ObjectIdExt;
         let commits: Vec<_> = commits.into_iter().map(Into::into).collect();
         let first = commits
             .first()
             .copied()
-            .ok_or(merge_base_octopus_with_graph::Error::MissingCommit)?;
-        gix_revision::merge_base::octopus(first, &commits[1..], graph)?
-            .ok_or(merge_base_octopus_with_graph::Error::NoMergeBase)
+            .ok_or_else(|| Error::from_error(gix_error::message("No commit was provided")))?;
+        gix_revision::merge_base::octopus(first, &commits[1..], graph)
+            .or_erased()?
+            .ok_or_else(|| Error::from_error(gix_error::message("No merge base was found between the given commits")))
             .map(|id| id.attach(self))
     }
 
@@ -161,10 +166,10 @@ impl crate::Repository {
     pub fn merge_base_octopus(
         &self,
         commits: impl IntoIterator<Item = impl Into<gix_hash::ObjectId>>,
-    ) -> Result<Id<'_>, crate::repository::merge_base_octopus::Error> {
+    ) -> Result<Id<'_>> {
         let cache = self.commit_graph_if_enabled()?;
         let mut graph = self.revision_graph(cache.as_ref());
-        Ok(self.merge_base_octopus_with_graph(commits, &mut graph)?)
+        self.merge_base_octopus_with_graph(commits, &mut graph)
     }
 
     /// Create the baseline for a revision walk by initializing it with the `tips` to start iterating on.
diff --git a/gix/src/repository/shallow.rs b/gix/src/repository/shallow.rs
index 9d548fc4a4a..76fe7c1a32e 100644
--- a/gix/src/repository/shallow.rs
+++ b/gix/src/repository/shallow.rs
@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use crate::{
-    Repository,
+    Repository, Result,
     config::tree::{Key, gitoxide},
 };
 
@@ -19,11 +19,13 @@ impl Repository {
     /// isn't a shallow clone.
     ///
     /// The shared list is shared across all clones of this repository.
-    pub fn shallow_commits(&self) -> Result<Option<crate::shallow::Commits>, crate::shallow::read::Error> {
-        self.shallow_commits.recent_snapshot(
-            || self.shallow_file().metadata().ok().and_then(|m| m.modified().ok()),
-            || gix_shallow::read(&self.shallow_file()),
-        )
+    pub fn shallow_commits(&self) -> Result<Option<crate::shallow::Commits>> {
+        self.shallow_commits
+            .recent_snapshot(
+                || self.shallow_file().metadata().ok().and_then(|m| m.modified().ok()),
+                || gix_shallow::read(&self.shallow_file()),
+            )
+            .map_err(gix_error::Exn::into_error)
     }
 
     /// Return the path to the `shallow` file which contains hashes, one per line, that describe commits that don't have their
diff --git a/gix/src/repository/submodule.rs b/gix/src/repository/submodule.rs
index a70cc4df1a2..e25b956c4f9 100644
--- a/gix/src/repository/submodule.rs
+++ b/gix/src/repository/submodule.rs
@@ -1,6 +1,7 @@
 use std::rc::Rc;
 
-use crate::{Repository, submodule};
+use crate::{Error, Repository, Result, submodule};
+use gix_error::ResultExt;
 
 impl Repository {
     /// Open the `.gitmodules` file as present in the worktree, or return `None` if no such file is available.
@@ -10,7 +11,7 @@ impl Repository {
     ///
     /// Note that his method will not look in other places, like the index or the `HEAD` tree.
     // TODO(submodule): make it use an updated snapshot instead once we have `config()`.
-    pub fn open_modules_file(&self) -> Result<Option<gix_submodule::File>, submodule::open_modules_file::Error> {
+    pub fn open_modules_file(&self) -> Result<Option<gix_submodule::File>> {
         let path = match self.modules_path() {
             Some(path) => path,
             None => return Ok(None),
@@ -21,12 +22,12 @@ impl Repository {
         let metadata = match std::fs::symlink_metadata(&path) {
             Ok(metadata) => metadata,
             Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-            Err(err) => return Err(err.into()),
+            Err(err) => return Err(Error::from_error(err)),
         };
         if metadata.file_type().is_symlink() {
             return Ok(None);
         }
-        let buf = std::fs::read(&path)?;
+        let buf = std::fs::read(&path).or_raise(|| gix_error::message("Could not read '.gitmodules' file"))?;
         Ok(Some(gix_submodule::File::from_bytes(
             &buf,
             path,
@@ -45,14 +46,18 @@ impl Repository {
     /// Note that git configuration is also contributing to the result based on the current snapshot.
     ///
     // TODO(submodule): make it use an updated snapshot instead once we have `config()`.
-    pub fn modules(&self) -> Result<Option<submodule::ModulesSnapshot>, submodule::modules::Error> {
-        match self.modules.recent_snapshot(
-            || {
-                self.modules_path()
-                    .and_then(|path| path.metadata().and_then(|m| m.modified()).ok())
-            },
-            || self.open_modules_file(),
-        )? {
+    pub fn modules(&self) -> Result<Option<submodule::ModulesSnapshot>> {
+        match self
+            .modules
+            .recent_snapshot(
+                || {
+                    self.modules_path()
+                        .and_then(|path| path.metadata().and_then(|m| m.modified()).ok())
+                },
+                || self.open_modules_file(),
+            )
+            .or_erased()?
+        {
             Some(m) => Ok(Some(m)),
             None => {
                 let id = match self.try_index()?.and_then(|index| {
@@ -62,9 +67,10 @@ impl Repository {
                 }) {
                     Some(id) => id,
                     None => match self
-                        .head()?
+                        .head()
+                        .or_erased()?
                         .try_peel_to_id()?
-                        .map(|id| -> Result<Option<_>, submodule::modules::Error> {
+                        .map(|id| -> Result<Option<_>> {
                             Ok(id
                                 .object()?
                                 .peel_to_commit()?
@@ -80,9 +86,17 @@ impl Repository {
                     },
                 };
                 Ok(Some(gix_features::threading::OwnShared::new(
-                    gix_submodule::File::from_bytes(&self.find_object(id)?.data, None, &self.config.resolved)
-                        .map_err(submodule::open_modules_file::Error::from)?
-                        .into(),
+                    gix_submodule::File::from_bytes(
+                        &self
+                            .find_object(id)
+                            .or_raise(|| {
+                                gix_error::message("Could not find the .gitmodules file by id in the object database")
+                            })?
+                            .data,
+                        None,
+                        &self.config.resolved,
+                    )?
+                    .into(),
                 )))
             }
         }
@@ -90,7 +104,7 @@ impl Repository {
 
     /// Return the list of available submodules, or `None` if there is no submodule configuration.
     #[doc(alias = "git2")]
-    pub fn submodules(&self) -> Result<Option<impl Iterator<Item = crate::Submodule<'_>>>, submodule::modules::Error> {
+    pub fn submodules(&self) -> Result<Option<impl Iterator<Item = crate::Submodule<'_>>>> {
         let modules = match self.modules()? {
             None => return Ok(None),
             Some(m) => m,
diff --git a/gix/src/repository/worktree.rs b/gix/src/repository/worktree.rs
index c136f94c5dd..9ca0a612de2 100644
--- a/gix/src/repository/worktree.rs
+++ b/gix/src/repository/worktree.rs
@@ -1,20 +1,10 @@
 use std::{collections::BTreeMap, path::PathBuf};
 
-use crate::bstr::BStr;
-use crate::{Worktree, worktree};
-#[cfg(feature = "worktree-archive")]
+#[cfg(feature = "worktree-stream")]
+use crate::Error;
+use crate::{ExnMessageResult, Result, Worktree, bstr::BStr, worktree};
 use gix_error::ResultExt;
 
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum CheckedOutBranchesError {
-    #[error("Failed to read or iterate worktree directories")]
-    WorktreeListing(#[from] std::io::Error),
-    #[error("Could not open a worktree repository")]
-    OpenWorktreeRepo(#[from] crate::open::Error),
-    #[error("Failed to follow a symbolic reference")]
-    FollowSymref(#[from] gix_ref::file::find::existing::Error),
-}
-
 /// Interact with individual worktrees and their information.
 impl crate::Repository {
     /// Return all references checked out in this repository's main and linked worktrees.
@@ -23,13 +13,16 @@ impl crate::Repository {
     /// `HEAD` is recorded for every worktree with a readable head, and all symbolic references in
     /// the chain from `HEAD` to its referent are included. Detached heads therefore contribute only
     /// a `HEAD` entry. Bare repositories and worktrees whose head cannot be read are ignored.
-    pub(crate) fn checked_out_branches(
-        &self,
-    ) -> Result<BTreeMap<gix_ref::FullName, Vec<PathBuf>>, CheckedOutBranchesError> {
+    pub(crate) fn checked_out_branches(&self) -> ExnMessageResult<BTreeMap<gix_ref::FullName, Vec<PathBuf>>> {
         let mut map = BTreeMap::new();
         insert_head(self.head().ok(), &mut map)?;
-        for proxy in self.worktrees()? {
-            let repo = proxy.into_repo_with_possibly_inaccessible_worktree()?;
+        for proxy in self
+            .worktrees()
+            .or_raise(|| gix_error::message("Failed to read or iterate worktree directories"))?
+        {
+            let repo = proxy
+                .into_repo_with_possibly_inaccessible_worktree()
+                .or_raise(|| gix_error::message("Could not open a worktree repository"))?;
             insert_head(repo.head().ok(), &mut map)?;
         }
         Ok(map)
@@ -73,11 +66,7 @@ impl crate::Repository {
     ///
     /// Note that it might be the one that is currently open if this repository doesn't point to a linked worktree.
     /// Also note that the main repo might be bare.
-    #[expect(
-        clippy::result_large_err,
-        reason = "will be removed once `gix-error` is used consistently"
-    )]
-    pub fn main_repo(&self) -> Result<crate::Repository, crate::open::Error> {
+    pub fn main_repo(&self) -> Result<crate::Repository> {
         let options = match (self.kind(), self.options.clone()) {
             (crate::repository::Kind::LinkedWorkTree, opts) => opts.without_repository_environment_overrides(),
             (_, opts) => opts,
@@ -111,15 +100,15 @@ impl crate::Repository {
     pub fn worktree_stream(
         &self,
         id: impl Into<gix_hash::ObjectId>,
-    ) -> Result<(gix_worktree_stream::Stream, gix_index::File), crate::repository::worktree_stream::Error> {
+    ) -> Result<(gix_worktree_stream::Stream, gix_index::File)> {
         use gix_odb::HeaderExt;
         let id = id.into();
         let header = self.objects.header(id)?;
         if !header.kind().is_tree() {
-            return Err(crate::repository::worktree_stream::Error::NotATree {
-                id,
-                actual: header.kind(),
-            });
+            return Err(Error::from_error(gix_error::validation(format!(
+                "Needed {id} to be a tree to turn into a workspace stream, got {}",
+                header.kind()
+            ))));
         }
 
         // TODO(perf): potential performance improvements could be to use the index at `HEAD` if possible (`index_from_head_tree…()`)
@@ -127,7 +116,8 @@ impl crate::Repository {
         //             an object cache between the copies of the ODB handles isn't trivial and needs a lock.
         let index = self.index_from_tree(&id)?;
         let mut cache = self
-            .attributes_only(&index, gix_worktree::stack::state::attributes::Source::IdMapping)?
+            .attributes_only(&index, gix_worktree::stack::state::attributes::Source::IdMapping)
+            .or_erased()?
             .detach();
         let pipeline = gix_filter::Pipeline::new(self.command_context()?, crate::filter::Pipeline::options(self)?);
         let objects = self.objects.clone().into_arc().expect("TBD error handling");
@@ -164,7 +154,7 @@ impl crate::Repository {
         blobs: impl gix_features::progress::Count,
         should_interrupt: &std::sync::atomic::AtomicBool,
         options: gix_archive::Options,
-    ) -> Result<(), crate::repository::worktree_archive::Error> {
+    ) -> Result<()> {
         let mut out = gix_features::interrupt::Write {
             inner: out,
             should_interrupt,
@@ -197,10 +187,7 @@ impl crate::Repository {
 ///
 /// Do nothing if `head` is absent or its repository has no worktree, and fail if a symbolic
 /// reference in the chain cannot be followed.
-fn insert_head(
-    head: Option<crate::Head<'_>>,
-    out: &mut BTreeMap<gix_ref::FullName, Vec<PathBuf>>,
-) -> Result<(), CheckedOutBranchesError> {
+fn insert_head(head: Option<crate::Head<'_>>, out: &mut BTreeMap<gix_ref::FullName, Vec<PathBuf>>) -> ExnMessageResult {
     let Some((head, workdir)) = head.and_then(|head| head.repo.workdir().map(|workdir| (head, workdir))) else {
         return Ok(());
     };
@@ -212,7 +199,10 @@ fn insert_head(
         out.entry(reference.name().to_owned())
             .or_default()
             .push(workdir.to_owned());
-        cursor = reference.follow().transpose()?;
+        cursor = reference
+            .follow()
+            .transpose()
+            .or_raise(|| gix_error::message("Failed to follow a symbolic reference"))?;
     }
     Ok(())
 }
diff --git a/gix/src/revision/spec/parse/delegate/mod.rs b/gix/src/revision/spec/parse/delegate/mod.rs
index d2d14530e0c..df37762ba7e 100644
--- a/gix/src/revision/spec/parse/delegate/mod.rs
+++ b/gix/src/revision/spec/parse/delegate/mod.rs
@@ -1,9 +1,11 @@
 use super::{Delegate, ObjectKindHint, error};
+use crate::ExnMessageResult;
 use crate::{
     Repository,
     ext::{ObjectIdExt, ReferenceExt},
 };
-use gix_error::{ErrorExt, Exn, ResultExt, message};
+use gix_error::Result;
+use gix_error::{ErrorExt, Exn, ExnResult, ResultExt, message};
 use gix_hash::ObjectId;
 use gix_revision::spec::{parse, parse::delegate};
 use smallvec::SmallVec;
@@ -53,12 +55,12 @@ impl<'repo> Delegate<'repo> {
         }
     }
 
-    pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>, gix_error::Error> {
+    pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>> {
         fn zero_or_one_objects_or_ambiguity_err(
             mut candidates: [Option<Vec<ObjectId>>; 2],
             prefix: [Option<gix_hash::Prefix>; 2],
             repo: &Repository,
-        ) -> Result<[Option<ObjectId>; 2], gix_error::Error> {
+        ) -> Result<[Option<ObjectId>; 2]> {
             let mut out = [None, None];
             for ((candidates, prefix), out) in candidates.iter_mut().zip(prefix).zip(out.iter_mut()) {
                 let candidates = candidates.take();
@@ -86,11 +88,9 @@ impl<'repo> Delegate<'repo> {
         fn kind_to_spec(
             kind: Option<gix_revision::spec::Kind>,
             [first, second]: [Option<ObjectId>; 2],
-        ) -> Result<gix_revision::Spec, gix_error::Error> {
-            pub fn malformed() -> gix_error::Error {
-                message!("The rev-spec is malformed and misses a ref name")
-                    .raise()
-                    .into_error()
+        ) -> ExnMessageResult<gix_revision::Spec> {
+            pub fn malformed() -> Exn<gix_error::Message> {
+                message!("The rev-spec is malformed and misses a ref name").raise()
             }
             use gix_revision::spec::Kind::*;
             Ok(match kind.unwrap_or_default() {
@@ -110,18 +110,21 @@ impl<'repo> Delegate<'repo> {
         }
 
         let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.repo)?;
+        // Finalizing symbolic refs can fail after parsing succeeds. Preserve those causes on failure,
+        // but keep ignoring errors from rejected candidates when a complete spec was produced.
+        let inner = kind_to_spec(self.kind, range).map_err(|err| err.chain_all(self.delayed_errors).into_error())?;
         Ok(crate::revision::Spec {
             path: self.paths[0].take().or(self.paths[1].take()),
             first_ref: self.refs[0].take(),
             second_ref: self.refs[1].take(),
-            inner: kind_to_spec(self.kind, range)?,
+            inner,
             repo: self.repo,
         })
     }
 }
 
 impl parse::Delegate for Delegate<'_> {
-    fn done(&mut self) -> Result<(), Exn> {
+    fn done(&mut self) -> ExnResult {
         self.follow_refs_to_objects_if_needed_delay_errors();
         self.disambiguate_objects_by_fallback_hint_delay_errors(
             self.kind_implies_committish()
@@ -134,7 +137,7 @@ impl parse::Delegate for Delegate<'_> {
 }
 
 impl delegate::Kind for Delegate<'_> {
-    fn kind(&mut self, kind: gix_revision::spec::Kind) -> Result<(), Exn> {
+    fn kind(&mut self, kind: gix_revision::spec::Kind) -> ExnResult {
         use gix_revision::spec::Kind::*;
         self.kind = Some(kind);
 
@@ -158,7 +161,7 @@ impl Delegate<'_> {
     }
 
     fn disambiguate_objects_by_fallback_hint_delay_errors(&mut self, hint: Option<ObjectKindHint>) {
-        fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<(), Exn> {
+        fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> ExnResult {
             let obj = repo.find_object(obj).or_erased()?;
             if obj.kind == kind {
                 Ok(())
@@ -253,7 +256,7 @@ impl Delegate<'_> {
     }
 }
 
-fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<ObjectId, Exn> {
+fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> ExnResult<ObjectId> {
     let mut obj = repo.find_object(obj).or_erased()?;
     obj = obj.peel_to_kind(kind).or_erased()?;
     debug_assert_eq!(obj.kind, kind, "bug in Object::peel_to_kind() which didn't deliver");
diff --git a/gix/src/revision/spec/parse/delegate/navigate.rs b/gix/src/revision/spec/parse/delegate/navigate.rs
index ce5288cdb7d..904b93155f9 100644
--- a/gix/src/revision/spec/parse/delegate/navigate.rs
+++ b/gix/src/revision/spec/parse/delegate/navigate.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use gix_error::{ErrorExt, Exn, OptionExt, ResultExt, bail, message};
+use gix_error::{ErrorExt, Exn, ExnResult, OptionExt, ResultExt, bail, message};
 use gix_hash::ObjectId;
 use gix_index::entry::Stage;
 use gix_revision::spec::parse::{
@@ -17,7 +17,7 @@ use crate::{
 };
 
 impl delegate::Navigate for Delegate<'_> {
-    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn> {
+    fn traverse(&mut self, kind: Traversal) -> ExnResult {
         self.unset_disambiguate_call();
         self.follow_refs_to_objects_if_needed_delay_errors();
 
@@ -94,7 +94,7 @@ impl delegate::Navigate for Delegate<'_> {
         handle_errors_and_replacements(&mut self.delayed_errors, objs, errors, &mut replacements)
     }
 
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn> {
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> ExnResult {
         self.unset_disambiguate_call();
         self.follow_refs_to_objects_if_needed_delay_errors();
 
@@ -170,7 +170,7 @@ impl delegate::Navigate for Delegate<'_> {
         handle_errors_and_replacements(&mut self.delayed_errors, objs, errors, &mut replacements)
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> ExnResult {
         self.unset_disambiguate_call();
         self.follow_refs_to_objects_if_needed_delay_errors();
 
@@ -321,7 +321,7 @@ impl delegate::Navigate for Delegate<'_> {
         }
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> ExnResult {
         let stage = match stage {
             0 => Stage::Unconflicted,
             1 => Stage::Base,
@@ -380,7 +380,7 @@ impl delegate::Navigate for Delegate<'_> {
 
 /// Resolve `path` against the current working directory if it starts with `./` or `../`, and return it
 /// unchanged otherwise, matching the path syntax described in `gitrevisions(7)`.
-fn to_repo_relative_path<'a>(repo: &Repository, path: &'a BStr) -> Result<Cow<'a, BStr>, Exn> {
+fn to_repo_relative_path<'a>(repo: &Repository, path: &'a BStr) -> ExnResult<Cow<'a, BStr>> {
     if !(path.starts_with_str("./") || path.starts_with_str("../")) {
         return Ok(path.into());
     }
@@ -395,7 +395,7 @@ fn handle_errors_and_replacements(
     objs: &mut Vec<ObjectId>,
     errors: Vec<(ObjectId, Exn)>,
     replacements: &mut Replacements,
-) -> Result<(), Exn> {
+) -> ExnResult {
     if errors.len() == objs.len() {
         delayed_errors.extend(errors.into_iter().map(|(_, err)| err));
         Err(delayed_errors
diff --git a/gix/src/revision/spec/parse/delegate/revision.rs b/gix/src/revision/spec/parse/delegate/revision.rs
index d603d9a9652..c4d47752a47 100644
--- a/gix/src/revision/spec/parse/delegate/revision.rs
+++ b/gix/src/revision/spec/parse/delegate/revision.rs
@@ -1,4 +1,5 @@
-use gix_error::{ErrorExt, Exn, ResultExt, bail, message};
+use gix_error::Result;
+use gix_error::{ErrorExt, ExnResult, ResultExt, message};
 use gix_hash::ObjectId;
 use gix_revision::spec::parse::{
     delegate,
@@ -15,28 +16,22 @@ use crate::{
 };
 
 impl delegate::Revision for Delegate<'_> {
-    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
+    fn find_ref(&mut self, name: &BStr) -> ExnResult {
         self.unset_disambiguate_call();
         if self.has_delayed_err() && self.refs[self.idx].is_some() {
             return Err(message("Refusing call as there are delayed errors and a ref is available").raise_erased());
         }
-        match self.repo.refs.find(name) {
-            Ok(r) => {
-                assert!(self.refs[self.idx].is_none(), "BUG: cannot set the same ref twice");
-                self.refs[self.idx] = Some(r);
-                Ok(())
-            }
-            Err(err) => {
-                bail!(err.raise_erased())
-            }
-        }
+        let r = self.repo.refs.find(name)?;
+        assert!(self.refs[self.idx].is_none(), "BUG: cannot set the same ref twice");
+        self.refs[self.idx] = Some(r);
+        Ok(())
     }
 
     fn disambiguate_prefix(
         &mut self,
         prefix: gix_hash::Prefix,
         _must_be_commit: Option<delegate::PrefixHint<'_>>,
-    ) -> Result<(), Exn> {
+    ) -> ExnResult {
         self.last_call_was_disambiguate_prefix[self.idx] = true;
         let mut candidates = Some(HashSet::default());
         self.prefix[self.idx] = Some(prefix);
@@ -47,8 +42,7 @@ impl delegate::Revision for Delegate<'_> {
             Ok(Some(Err(())))
         } else {
             self.repo.objects.lookup_prefix(prefix, candidates.as_mut())
-        }
-        .or_erased()?;
+        }?;
 
         match ok {
             None => Err(message!("An object prefixed {prefix} could not be found").raise_erased()),
@@ -102,7 +96,7 @@ impl delegate::Revision for Delegate<'_> {
         }
     }
 
-    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn> {
+    fn reflog(&mut self, query: ReflogLookup) -> ExnResult {
         self.unset_disambiguate_call();
         let r = match &mut self.refs[self.idx] {
             Some(r) => r.clone().attach(self.repo),
@@ -122,7 +116,7 @@ impl delegate::Revision for Delegate<'_> {
                 ReflogLookup::Date(date) => {
                     let mut last = None;
                     let id_to_insert = match it
-                        .filter_map(Result::ok)
+                        .filter_map(std::result::Result::ok)
                         .inspect(|d| {
                             last = Some(if d.previous_oid.is_null() {
                                 d.new_oid
@@ -144,7 +138,7 @@ impl delegate::Revision for Delegate<'_> {
                     }
                     Ok(())
                 }
-                ReflogLookup::Entry(no) => match it.nth(no).and_then(Result::ok) {
+                ReflogLookup::Entry(no) => match it.nth(no).and_then(std::result::Result::ok) {
                     Some(line) => {
                         let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
                         if !objs.contains(&line.new_oid) {
@@ -172,13 +166,13 @@ impl delegate::Revision for Delegate<'_> {
         }
     }
 
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> ExnResult {
         self.unset_disambiguate_call();
         fn prior_checkouts_iter<'a>(
             platform: &'a mut gix_ref::file::log::iter::Platform<'static, '_>,
-        ) -> Result<impl Iterator<Item = (BString, ObjectId)> + 'a, gix_error::Error> {
+        ) -> Result<impl Iterator<Item = (BString, ObjectId)> + 'a> {
             match platform.rev().ok().flatten() {
-                Some(log) => Ok(log.filter_map(Result::ok).filter_map(|line| {
+                Some(log) => Ok(log.filter_map(std::result::Result::ok).filter_map(|line| {
                     line.message
                         .strip_prefix(b"checkout: moving from ")
                         .and_then(|from_to| from_to.find(" to ").map(|pos| &from_to[..pos]))
@@ -207,18 +201,16 @@ impl delegate::Revision for Delegate<'_> {
                         self.refs[self.idx] = Some(r.detach());
                         id
                     }
-                    Err(crate::reference::find::existing::Error::NotFound { .. }) => {
-                        match ObjectId::from_hex(ref_name.as_ref()) {
-                            Ok(id) if id.kind() == self.repo.object_hash() => id,
-                            _ => {
-                                return Err(message!(
-                                    "Previous checkout '{name}' does not resolve to an existing revision",
-                                    name = ref_name.as_bstr()
-                                )
-                                .raise_erased());
-                            }
+                    Err(err) if err.is_not_found() => match ObjectId::from_hex(ref_name.as_ref()) {
+                        Ok(id) if id.kind() == self.repo.object_hash() => id,
+                        _ => {
+                            return Err(message!(
+                                "Previous checkout '{name}' does not resolve to an existing revision",
+                                name = ref_name.as_bstr()
+                            )
+                            .raise_erased());
                         }
-                    }
+                    },
                     Err(err) => return Err(err.raise_erased()),
                 };
                 let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
@@ -235,7 +227,7 @@ impl delegate::Revision for Delegate<'_> {
         }
     }
 
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn> {
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> ExnResult {
         self.unset_disambiguate_call();
         let reference = match &mut self.refs[self.idx] {
             val @ None => match self.repo.head().map(crate::Head::try_into_referent) {
diff --git a/gix/src/revision/spec/parse/error.rs b/gix/src/revision/spec/parse/error.rs
index 9ce5642edfd..1e54827d06e 100644
--- a/gix/src/revision/spec/parse/error.rs
+++ b/gix/src/revision/spec/parse/error.rs
@@ -9,7 +9,7 @@ pub enum CandidateInfo {
     /// An error occurred when looking up the object in the database.
     FindError {
         /// The reported error.
-        source: crate::object::find::existing::Error,
+        source: crate::Error,
     },
     /// The candidate is an object of the given `kind`.
     Object {
diff --git a/gix/src/revision/spec/parse/mod.rs b/gix/src/revision/spec/parse/mod.rs
index 386ebf6e7ab..52f63389b97 100644
--- a/gix/src/revision/spec/parse/mod.rs
+++ b/gix/src/revision/spec/parse/mod.rs
@@ -1,5 +1,6 @@
 use crate::{Repository, bstr::BStr, revision::Spec};
 use gix_error::Exn;
+use gix_error::Result;
 use gix_hash::ObjectId;
 
 mod types;
@@ -7,21 +8,6 @@ pub use types::{ObjectKindHint, Options, RefsHint};
 
 use crate::bstr::BString;
 
-///
-pub mod single {
-    use crate::bstr::BString;
-
-    /// The error returned by [`crate::Repository::rev_parse_single()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Parse(#[from] gix_error::Error),
-        #[error("revspec {spec:?} did not resolve to a single object")]
-        RangedRev { spec: BString },
-    }
-}
-
 ///
 pub mod error;
 
@@ -29,11 +15,7 @@ impl<'repo> Spec<'repo> {
     /// Parse `spec` and use information from `repo` to resolve it, using `opts` to learn how to deal with ambiguity.
     ///
     /// Note that it's easier and to use [`repo.rev_parse()`][Repository::rev_parse()] instead.
-    pub fn from_bstr<'a>(
-        spec: impl Into<&'a BStr>,
-        repo: &'repo Repository,
-        opts: Options,
-    ) -> Result<Self, gix_error::Error> {
+    pub fn from_bstr<'a>(spec: impl Into<&'a BStr>, repo: &'repo Repository, opts: Options) -> Result<Self> {
         let mut delegate = Delegate::new(repo, opts);
         match gix_revision::spec::parse(spec.into(), &mut delegate) {
             Err(mut err) => {
diff --git a/gix/src/revision/walk.rs b/gix/src/revision/walk.rs
index 3b0b01f6a0b..ef1f9a77e1a 100644
--- a/gix/src/revision/walk.rs
+++ b/gix/src/revision/walk.rs
@@ -1,20 +1,10 @@
+use gix_error::ResultExt;
+
 use gix_hash::ObjectId;
 use gix_object::FindExt;
 use gix_traverse::commit::simple::CommitTimeOrder;
 
-use crate::{Repository, ext::ObjectIdExt, revision};
-
-/// The error returned by [`Platform::all()`] and [`Platform::selected()`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    SimpleTraversal(#[from] gix_traverse::commit::simple::Error),
-    #[error(transparent)]
-    ShallowCommits(#[from] crate::shallow::read::Error),
-    #[error(transparent)]
-    ConfigBoolean(#[from] crate::config::boolean::Error),
-}
+use crate::{Repository, Result, ext::ObjectIdExt, revision};
 
 /// Specify how to sort commits during a [revision::Walk] traversal.
 ///
@@ -105,7 +95,7 @@ impl<'repo> Info<'repo> {
     ///
     /// Note that this is an expensive operation which shouldn't be performed unless one needs more than parent ids
     /// and commit time.
-    pub fn object(&self) -> Result<crate::Commit<'repo>, crate::object::find::existing::Error> {
+    pub fn object(&self) -> Result<crate::Commit<'repo>> {
         Ok(self.id().object()?.into_commit())
     }
 
@@ -270,10 +260,7 @@ impl<'repo> Platform<'repo> {
     /// if the traversal should exclude it and its ancestry entirely.
     ///
     /// If `filter` is None, no pruning of the graph will be performed which is the default.
-    pub fn selected(
-        self,
-        mut filter: impl FnMut(&gix_hash::oid) -> bool + 'repo,
-    ) -> Result<revision::Walk<'repo>, Error> {
+    pub fn selected(self, mut filter: impl FnMut(&gix_hash::oid) -> bool + 'repo) -> Result<revision::Walk<'repo>> {
         let Platform {
             repo,
             tips,
@@ -324,12 +311,13 @@ impl<'repo> Platform<'repo> {
                 .parents(parents)
                 .commit_graph(
                     commit_graph.or(use_commit_graph
-                        .map_or_else(|| self.repo.config.may_use_commit_graph(), Ok)?
+                        .map_or_else(|| self.repo.config.may_use_commit_graph(), Ok)
+                        .or_erased()?
                         .then(|| self.repo.commit_graph().ok())
                         .flatten()),
                 )
                 .hide(hidden)?
-                .map(|res| res.map_err(iter::Error::from)),
+                .map(|res| res.map_err(gix_error::Exn::into_error)),
             ),
         })
     }
@@ -339,32 +327,23 @@ impl<'repo> Platform<'repo> {
     ///
     /// It's highly recommended to set an [`object cache`](Repository::object_cache_size()) on the parent repo
     /// to greatly speed up performance if the returned id is supposed to be looked up right after.
-    pub fn all(self) -> Result<revision::Walk<'repo>, Error> {
+    pub fn all(self) -> Result<revision::Walk<'repo>> {
         self.selected(|_| true)
     }
 }
 
-///
-pub mod iter {
-    /// The error returned by the [Walk](crate::revision::Walk) iterator.
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        SimpleTraversal(#[from] gix_traverse::commit::simple::Error),
-    }
-}
-
 pub(crate) mod iter_impl {
+    use crate::Result;
+
     /// The iterator returned by [`crate::revision::walk::Platform::all()`].
     pub struct Walk<'repo> {
         /// The owning repository.
         pub repo: &'repo crate::Repository,
-        pub(crate) inner: Box<dyn Iterator<Item = Result<gix_traverse::commit::Info, super::iter::Error>> + 'repo>,
+        pub(crate) inner: Box<dyn Iterator<Item = Result<gix_traverse::commit::Info>> + 'repo>,
     }
 
     impl<'repo> Iterator for Walk<'repo> {
-        type Item = Result<super::Info<'repo>, super::iter::Error>;
+        type Item = Result<super::Info<'repo>>;
 
         fn next(&mut self) -> Option<Self::Item> {
             self.inner
diff --git a/gix/src/shallow.rs b/gix/src/shallow.rs
index bd85cda8e17..34413d54bec 100644
--- a/gix/src/shallow.rs
+++ b/gix/src/shallow.rs
@@ -3,13 +3,3 @@ pub(crate) type CommitsStorage =
 /// A lazily loaded and auto-updated list of commits which are at the shallow boundary (behind which there are no commits available),
 /// sorted to allow bisecting.
 pub type Commits = gix_fs::SharedFileSnapshot<nonempty::NonEmpty<gix_hash::ObjectId>>;
-
-///
-pub mod read {
-    pub use gix_shallow::read::Error;
-}
-
-///
-pub mod write {
-    pub use gix_shallow::write::Error;
-}
diff --git a/gix/src/status/index_worktree.rs b/gix/src/status/index_worktree.rs
index 2b72ddd2bd6..fc0f4599cee 100644
--- a/gix/src/status/index_worktree.rs
+++ b/gix/src/status/index_worktree.rs
@@ -1,35 +1,15 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_error::ResultExt;
+
 use crate::{
-    Repository,
+    Error, Repository, Result,
     bstr::{BStr, BString},
     config,
     config::cache::util::ApplyLeniencyDefault,
 };
 use gix_status::index_as_worktree::traits::{CompareBlobs, SubmoduleStatus};
 
-/// The error returned by [Repository::index_worktree_status()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error("A working tree is required to perform a directory walk")]
-    MissingWorkDir,
-    #[error(transparent)]
-    AttributesAndExcludes(#[from] crate::repository::attributes::Error),
-    #[error(transparent)]
-    Pathspec(#[from] crate::pathspec::init::Error),
-    #[error(transparent)]
-    Prefix(#[from] gix_path::realpath::Error),
-    #[error(transparent)]
-    FilesystemOptions(#[from] config::boolean::Error),
-    #[error(transparent)]
-    IndexAsWorktreeWithRenames(#[from] gix_status::index_as_worktree_with_renames::Error),
-    #[error(transparent)]
-    StatOptions(#[from] config::stat_options::Error),
-    #[error(transparent)]
-    ResourceCache(#[from] crate::diff::resource_cache::Error),
-}
-
 /// Options for use with [Repository::index_worktree_status()].
 #[derive(Default, Debug, Clone, Copy, PartialEq)]
 pub struct Options {
@@ -87,7 +67,7 @@ impl Repository {
     ///
     /// This is a lower-level method, prefer the [`status`](Repository::status()) method for greater ease of use.
     #[expect(clippy::too_many_arguments)]
-    pub fn index_worktree_status<'index, T, U, E>(
+    pub fn index_worktree_status<'index, T, U>(
         &self,
         index: &'index gix_index::State,
         patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
@@ -97,33 +77,38 @@ impl Repository {
             SubmoduleStatus = U,
         >,
         compare: impl CompareBlobs<Output = T> + Send + Clone,
-        submodule: impl SubmoduleStatus<Output = U, Error = E> + Send + Clone,
+        submodule: impl SubmoduleStatus<Output = U> + Send + Clone,
         progress: &mut dyn gix_features::progress::Progress,
         should_interrupt: &AtomicBool,
         options: Options,
-    ) -> Result<gix_status::index_as_worktree_with_renames::Outcome, Error>
+    ) -> Result<gix_status::index_as_worktree_with_renames::Outcome>
     where
         T: Send + Clone,
         U: Send + Clone,
-        E: std::error::Error + Send + Sync + 'static,
     {
         let _span = gix_trace::coarse!("gix::index_worktree_status");
-        let workdir = self.workdir().ok_or(Error::MissingWorkDir)?;
-        let attrs_and_excludes = self.attributes(
-            index,
-            crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-            crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
-            None,
-        )?;
-        let pathspec =
-            self.index_worktree_status_pathspec::<Error>(patterns, index, options.dirwalk_options.as_ref())?;
+        let workdir = self.workdir().ok_or_else(|| {
+            Error::from_error(gix_error::message(
+                "A working tree is required to perform a directory walk",
+            ))
+        })?;
+        let attrs_and_excludes = self
+            .attributes(
+                index,
+                crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+                crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
+                None,
+            )
+            .or_erased()?;
+        let pathspec = self.index_worktree_status_pathspec(patterns, index, options.dirwalk_options.as_ref())?;
 
         let cwd = self.current_dir();
         let git_dir_realpath = crate::path::realpath_opts(self.git_dir(), cwd, crate::path::realpath::MAX_SYMLINKS)?;
-        let fs_caps = self.filesystem_options()?;
+        let fs_caps = self.filesystem_options().or_erased()?;
         let fscache = config::tree::Core::FS_CACHE
             .enrich_error(self.config.resolved.boolean(config::tree::Core::FS_CACHE))
-            .with_lenient_default(self.config.lenient_config)?
+            .with_lenient_default(self.config.lenient_config)
+            .or_erased()?
             // if unset, default to enabled on Windows. Good for missing Git installations that would turn it on by installation config
             .unwrap_or(cfg!(windows));
         let accelerate_lookup = fs_caps.ignore_case.then(|| index.prepare_icase_backing());
@@ -172,29 +157,28 @@ impl Repository {
         Ok(out)
     }
 
-    pub(super) fn index_worktree_status_pathspec<E>(
+    pub(super) fn index_worktree_status_pathspec(
         &self,
         patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
         index: &gix_index::State,
         options: Option<&crate::dirwalk::Options>,
-    ) -> Result<crate::Pathspec<'_>, E>
-    where
-        E: From<crate::repository::attributes::Error> + From<crate::pathspec::init::Error>,
-    {
+    ) -> Result<crate::Pathspec<'_>> {
         let empty_patterns_match_prefix = options.is_some_and(|opts| opts.empty_patterns_match_prefix);
-        let attrs_and_excludes = self.attributes(
-            index,
-            crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-            crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
-            None,
-        )?;
-        Ok(crate::Pathspec::new(
+        let attrs_and_excludes = self
+            .attributes(
+                index,
+                crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+                crate::worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
+                None,
+            )
+            .or_erased()?;
+        crate::Pathspec::new(
             self,
             empty_patterns_match_prefix,
             patterns,
             true, /* inherit ignore case */
             move || Ok(attrs_and_excludes.inner),
-        )?)
+        )
     }
 }
 
@@ -212,7 +196,9 @@ pub struct BuiltinSubmoduleStatus {
 
 ///
 mod submodule_status {
-    use crate::config::cache::util::ApplyLeniency;
+    use gix_error::ResultExt;
+
+    use crate::{ExnResult, Result, config::cache::util::ApplyLeniency};
     use crate::{
         bstr,
         bstr::BStr,
@@ -222,10 +208,7 @@ mod submodule_status {
 
     impl BuiltinSubmoduleStatus {
         /// Create a new instance from a `repo` and a `mode` to control how the submodule status will be obtained.
-        pub fn new(
-            repo: crate::ThreadSafeRepository,
-            mode: Submodule,
-        ) -> Result<Self, crate::submodule::modules::Error> {
+        pub fn new(repo: crate::ThreadSafeRepository, mode: Submodule) -> Result<Self> {
             let local_repo = repo.to_thread_local();
             let submodule_paths = match local_repo.submodules() {
                 Ok(Some(sm)) => {
@@ -247,22 +230,10 @@ mod submodule_status {
         }
     }
 
-    /// The error returned submodule status checks.
-    #[derive(Debug, thiserror::Error)]
-    pub enum Error {
-        #[error(transparent)]
-        SubmoduleStatus(#[from] crate::submodule::status::Error),
-        #[error(transparent)]
-        IgnoreConfig(#[from] crate::submodule::config::Error),
-        #[error(transparent)]
-        DiffSubmoduleIgnoreConfig(#[from] config::key::GenericErrorWithValue),
-    }
-
     impl gix_status::index_as_worktree::traits::SubmoduleStatus for BuiltinSubmoduleStatus {
         type Output = crate::submodule::Status;
-        type Error = Error;
 
-        fn status(&mut self, _entry: &gix_index::Entry, rela_path: &BStr) -> Result<Option<Self::Output>, Self::Error> {
+        fn status(&mut self, _entry: &gix_index::Entry, rela_path: &BStr) -> ExnResult<Option<Self::Output>> {
             use bstr::ByteSlice;
             if self
                 .submodule_paths
@@ -291,18 +262,19 @@ mod submodule_status {
                         .string(config::tree::Diff::IGNORE_SUBMODULES)
                         .map(|value| config::tree::Diff::IGNORE_SUBMODULES.try_into_ignore(value))
                         .transpose()
-                        .with_leniency(repo.config.lenient_config)?;
+                        .with_leniency(repo.config.lenient_config)
+                        .or_erased()?;
                     if let Some(ignore) = global_ignore {
                         (ignore, check_dirty)
                     } else {
                         // If no global ignore is set, use the submodule's ignore setting.
-                        let ignore = sm.ignore()?.unwrap_or_default();
+                        let ignore = sm.ignore().or_erased()?.unwrap_or_default();
                         (ignore, check_dirty)
                     }
                 }
                 Submodule::Given { ignore, check_dirty } => (ignore, check_dirty),
             };
-            let status = sm.status(ignore, check_dirty)?;
+            let status = sm.status(ignore, check_dirty).or_erased()?;
             Ok(status.is_dirty().and_then(|dirty| dirty.then_some(status)))
         }
     }
@@ -439,6 +411,7 @@ pub mod iter {
 
     use super::{Item, RewriteSource};
     use crate::{
+        Result,
         bstr::{BStr, BString},
         status::{Platform, index_worktree},
     };
@@ -586,7 +559,7 @@ pub mod iter {
         pub fn into_index_worktree_iter(
             mut self,
             patterns: impl IntoIterator<Item = BString>,
-        ) -> Result<index_worktree::Iter, crate::status::into_iter::Error> {
+        ) -> Result<index_worktree::Iter> {
             // deactivate the tree-iteration
             self.head_tree = None;
             Ok(index_worktree::Iter {
@@ -596,7 +569,7 @@ pub mod iter {
     }
 
     impl Iterator for super::Iter {
-        type Item = Result<Item, index_worktree::Error>;
+        type Item = Result<Item>;
 
         fn next(&mut self) -> Option<Self::Item> {
             self.inner.next().map(|res| {
@@ -604,12 +577,6 @@ pub mod iter {
                     crate::status::Item::IndexWorktree(item) => item,
                     crate::status::Item::TreeIndex(_) => unreachable!("BUG: we deactivated this kind of traversal"),
                 })
-                .map_err(|err| match err {
-                    crate::status::iter::Error::IndexWorktree(err) => err,
-                    crate::status::iter::Error::TreeIndex(_) => {
-                        unreachable!("BUG: we deactivated this kind of traversal")
-                    }
-                })
             })
         }
     }
diff --git a/gix/src/status/iter/mod.rs b/gix/src/status/iter/mod.rs
index 15e51e401c5..11d55c03480 100644
--- a/gix/src/status/iter/mod.rs
+++ b/gix/src/status/iter/mod.rs
@@ -1,11 +1,15 @@
 use std::sync::atomic::Ordering;
 
+#[cfg(feature = "parallel")]
+use gix_error::ErrorExt;
+use gix_error::ResultExt;
 use gix_status::index_as_worktree::{Change, EntryStatus};
 
 use crate::{
+    Result,
     bstr::BString,
     config::cache::util::ApplyLeniencyDefault,
-    status::{Platform, index_worktree, index_worktree::BuiltinSubmoduleStatus, tree_index},
+    status::{Platform, index_worktree, index_worktree::BuiltinSubmoduleStatus},
     worktree::IndexPersistedOrInMemory,
 };
 
@@ -37,18 +41,20 @@ where
     /// This isn't feasible to do here as it would mean that returned items would have to be delayed,
     /// degrading performance for everyone who isn't order-dependent.
     #[doc(alias = "diff_index_to_workdir", alias = "git2")]
-    pub fn into_iter(
-        self,
-        patterns: impl IntoIterator<Item = BString>,
-    ) -> Result<Iter, crate::status::into_iter::Error> {
+    pub fn into_iter(self, patterns: impl IntoIterator<Item = BString>) -> Result<Iter> {
         let index = match self.index {
             None => IndexPersistedOrInMemory::Persisted(self.repo.index_or_empty()?),
             Some(index) => index,
         };
 
-        let obtain_tree_id = || -> Result<Option<gix_hash::ObjectId>, crate::status::into_iter::Error> {
+        let obtain_tree_id = || -> Result<Option<gix_hash::ObjectId>> {
             Ok(match self.head_tree {
-                Some(None) => Some(self.repo.head_tree_id_or_empty()?.into()),
+                Some(None) => Some(
+                    self.repo
+                        .head_tree_id_or_empty()
+                        .or_raise(|| gix_error::message("Could not obtain the tree id pointed to by `HEAD`"))?
+                        .into(),
+                ),
                 Some(Some(tree_id)) => Some(tree_id),
                 None => None,
             })
@@ -56,10 +62,11 @@ where
 
         let skip_hash = crate::config::tree::Index::SKIP_HASH
             .enrich_error(self.repo.config.resolved.boolean(crate::config::tree::Index::SKIP_HASH))
-            .with_lenient_default(self.repo.config.lenient_config)?
+            .with_lenient_default(self.repo.config.lenient_config)
+            .or_erased()?
             .unwrap_or_default();
         let should_interrupt = self.should_interrupt.clone().unwrap_or_default();
-        let submodule = BuiltinSubmoduleStatus::new(self.repo.clone().into_sync(), self.submodules)?;
+        let submodule = BuiltinSubmoduleStatus::new(self.repo.clone().into_sync(), self.submodules).or_erased()?;
         #[cfg(feature = "parallel")]
         {
             let (tx, rx) = std::sync::mpsc::channel();
@@ -73,14 +80,12 @@ where
                         let tx = tx.clone();
                         let tree_index_renames = self.tree_index_renames;
                         let index = index.clone();
-                        let crate::Pathspec { repo: _, stack, search } = self
-                            .repo
-                            .index_worktree_status_pathspec::<crate::status::into_iter::Error>(
-                                &patterns,
-                                &index,
-                                self.index_worktree_options.dirwalk_options.as_ref(),
-                            )?;
-                        move || -> Result<_, _> {
+                        let crate::Pathspec { repo: _, stack, search } = self.repo.index_worktree_status_pathspec(
+                            &patterns,
+                            &index,
+                            self.index_worktree_options.dirwalk_options.as_ref(),
+                        )?;
+                        move || -> std::result::Result<_, _> {
                             let repo = repo.to_thread_local();
                             let mut pathspec = crate::Pathspec {
                                 repo: &repo,
@@ -100,12 +105,12 @@ where
                                     } else {
                                         std::ops::ControlFlow::Continue(())
                                     };
-                                    Ok::<_, std::convert::Infallible>(action)
+                                    Ok::<_, gix_error::Exn>(action)
                                 },
                             )
                         }
                     })
-                    .map_err(crate::status::into_iter::Error::SpawnThread)?
+                    .map_err(|err| err.and_raise(gix_error::message("Failed to spawn producer thread")))?
                     .into()
             } else {
                 None
@@ -118,7 +123,7 @@ where
                     let options = self.index_worktree_options;
                     let should_interrupt = should_interrupt.clone();
                     let mut progress = self.progress;
-                    move || -> Result<_, index_worktree::Error> {
+                    move || -> Result<_> {
                         let repo = repo.to_thread_local();
                         let out = repo.index_worktree_status(
                             &index,
@@ -139,7 +144,7 @@ where
                         })
                     }
                 })
-                .map_err(crate::status::into_iter::Error::SpawnThread)?;
+                .map_err(|err| err.and_raise(gix_error::message("Failed to spawn producer thread")))?;
 
             Ok(Iter {
                 rx_and_join: Some((rx, join_index_worktree, join_tree_index)),
@@ -158,7 +163,7 @@ where
             let patterns: Vec<BString> = patterns.into_iter().collect();
             let (mut items, tree_index) = match obtain_tree_id()? {
                 Some(tree_id) => {
-                    let mut pathspec = repo.index_worktree_status_pathspec::<crate::status::into_iter::Error>(
+                    let mut pathspec = repo.index_worktree_status_pathspec(
                         &patterns,
                         &index,
                         self.index_worktree_options.dirwalk_options.as_ref(),
@@ -176,7 +181,7 @@ where
                             } else {
                                 std::ops::ControlFlow::Continue(())
                             };
-                            Ok::<_, std::convert::Infallible>(action)
+                            Ok::<_, gix_error::Exn>(action)
                         },
                     )?;
                     (items, Some(tree_index))
@@ -219,18 +224,8 @@ where
     }
 }
 
-/// The error returned for each item returned by [`Iter`].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    IndexWorktree(#[from] index_worktree::Error),
-    #[error(transparent)]
-    TreeIndex(#[from] tree_index::Error),
-}
-
 impl Iterator for Iter {
-    type Item = Result<Item, Error>;
+    type Item = Result<Item>;
 
     fn next(&mut self) -> Option<Self::Item> {
         #[cfg(feature = "parallel")]
@@ -256,7 +251,7 @@ impl Iterator for Iter {
                     let tree_index = if let Some(handle) = tree_handle {
                         match handle.join().expect("no panic") {
                             Ok(out) => Some(out),
-                            Err(err) => break Some(Err(err.into())),
+                            Err(err) => break Some(Err(err)),
                         }
                     } else {
                         None
@@ -268,7 +263,7 @@ impl Iterator for Iter {
                             self.out = Some(out);
                             None
                         }
-                        Err(err) => Some(Err(err.into())),
+                        Err(err) => Some(Err(err)),
                     };
                 }
             }
diff --git a/gix/src/status/iter/types.rs b/gix/src/status/iter/types.rs
index 13585127839..2b548aa0cc8 100644
--- a/gix/src/status/iter/types.rs
+++ b/gix/src/status/iter/types.rs
@@ -1,4 +1,5 @@
 use crate::{
+    Result,
     bstr::BStr,
     status::{index_worktree, tree_index},
     worktree::IndexPersistedOrInMemory,
@@ -35,8 +36,8 @@ pub struct Iter {
     #[expect(clippy::type_complexity)]
     pub(super) rx_and_join: Option<(
         std::sync::mpsc::Receiver<Item>,
-        std::thread::JoinHandle<Result<Outcome, index_worktree::Error>>,
-        Option<std::thread::JoinHandle<Result<tree_index::Outcome, tree_index::Error>>>,
+        std::thread::JoinHandle<Result<Outcome>>,
+        Option<std::thread::JoinHandle<Result<tree_index::Outcome>>>,
     )>,
     #[cfg(feature = "parallel")]
     pub(super) should_interrupt: crate::status::OwnedOrStaticAtomicBool,
@@ -84,7 +85,7 @@ impl Outcome {
 
     /// Write the changes if there are any back to the index file.
     /// This can only be done once as the changes are consumed in the process, if there were any.
-    pub fn write_changes(&mut self) -> Option<Result<(), gix_index::file::write::Error>> {
+    pub fn write_changes(&mut self) -> Option<Result> {
         let _span = gix_features::trace::coarse!("gix::status::index_worktree::Outcome::write_changes()");
         let changes = self.changes.take()?;
         let mut index = match &self.worktree_index {
@@ -105,10 +106,14 @@ impl Outcome {
             }
         }
 
-        Some(index.write(crate::index::write::Options {
-            extensions: Default::default(),
-            skip_hash: self.skip_hash,
-        }))
+        Some(
+            index
+                .write(crate::index::write::Options {
+                    extensions: Default::default(),
+                    skip_hash: self.skip_hash,
+                })
+                .map_err(gix_error::Exn::into_error),
+        )
     }
 }
 
diff --git a/gix/src/status/mod.rs b/gix/src/status/mod.rs
index 010f3b0150d..753b024b4b7 100644
--- a/gix/src/status/mod.rs
+++ b/gix/src/status/mod.rs
@@ -1,6 +1,6 @@
 pub use gix_status as plumbing;
 
-use crate::{Repository, config, config::cache::util::ApplyLeniencyDefault, util::OwnedOrStaticAtomicBool};
+use crate::{Repository, Result, config, config::cache::util::ApplyLeniencyDefault, util::OwnedOrStaticAtomicBool};
 
 /// A structure to hold options configuring the status request, which can then be turned into an iterator.
 pub struct Platform<'repo, Progress>
@@ -63,16 +63,6 @@ impl Default for Submodule {
     }
 }
 
-/// The error returned by [status()](Repository::status).
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    DirwalkOptions(#[from] config::boolean::Error),
-    #[error(transparent)]
-    ConfigureUntrackedFiles(#[from] config::key::GenericErrorWithValue),
-}
-
 /// Status
 impl Repository {
     /// Obtain a platform for configuring iterators for traversing git repository status information.
@@ -96,7 +86,7 @@ impl Repository {
     /// Whereas Git runs the index-modified check before the directory walk to set entries
     /// as up-to-date to (potentially) safe some disk-access, we run both in parallel which
     /// ultimately is much faster.
-    pub fn status<P>(&self, progress: P) -> Result<Platform<'_, P>, Error>
+    pub fn status<P>(&self, progress: P) -> Result<Platform<'_, P>>
     where
         P: gix_features::progress::Progress + 'static,
     {
@@ -133,25 +123,7 @@ impl Repository {
 
 ///
 pub mod is_dirty {
-    use std::convert::Infallible;
-
-    use crate::Repository;
-
-    /// The error returned by [Repository::is_dirty()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        StatusPlatform(#[from] crate::status::Error),
-        #[error(transparent)]
-        CreateStatusIterator(#[from] crate::status::into_iter::Error),
-        #[error(transparent)]
-        TreeIndexStatus(#[from] crate::status::tree_index::Error),
-        #[error(transparent)]
-        HeadTreeId(#[from] crate::reference::head_tree_id::Error),
-        #[error(transparent)]
-        OpenWorktreeIndex(#[from] crate::worktree::open_index::Error),
-    }
+    use crate::{Repository, Result};
 
     impl Repository {
         /// Returns `true` if the repository is dirty.
@@ -165,7 +137,7 @@ pub mod is_dirty {
         // TODO(performance): this could be its very own implementation with parallelism and the special:
         //                    stop once there is a change flag, but without using the iterator for
         //                    optimal resource usage.
-        pub fn is_dirty(&self) -> Result<bool, Error> {
+        pub fn is_dirty(&self) -> Result<bool> {
             {
                 let head_tree_id = self.head_tree_id_or_empty()?;
                 let mut index_is_dirty = false;
@@ -188,7 +160,7 @@ pub mod is_dirty {
                     crate::status::tree_index::TrackRenames::Disabled,
                     |_, _, _| {
                         index_is_dirty = true;
-                        Ok::<_, Infallible>(std::ops::ControlFlow::Break(()))
+                        Ok::<_, gix_error::Exn>(std::ops::ControlFlow::Break(()))
                     },
                 )?;
                 if index_is_dirty {
@@ -203,7 +175,7 @@ pub mod is_dirty {
                     opts.dirwalk_options = None;
                 })
                 .into_index_worktree_iter(Vec::new())?
-                .take_while(Result::is_ok)
+                .take_while(std::result::Result::is_ok)
                 .next()
                 .is_some();
             Ok(is_dirty)
@@ -211,37 +183,6 @@ pub mod is_dirty {
     }
 }
 
-///
-pub mod into_iter {
-    /// The error returned by [status::Platform::into_iter()](crate::status::Platform::into_iter()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Index(#[from] crate::worktree::open_index::Error),
-        #[error("Failed to spawn producer thread")]
-        #[cfg(feature = "parallel")]
-        SpawnThread(#[source] std::io::Error),
-        #[error(transparent)]
-        #[cfg(not(feature = "parallel"))]
-        IndexWorktreeStatus(#[from] crate::status::index_worktree::Error),
-        #[error(transparent)]
-        ConfigSkipHash(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        PrepareSubmodules(#[from] crate::submodule::modules::Error),
-        #[error("Could not create an index for the head tree to compare with the worktree index")]
-        HeadTreeIndex(#[from] crate::repository::index_from_tree::Error),
-        #[error("Could not obtain the tree id pointed to by `HEAD`")]
-        HeadTreeId(#[from] crate::reference::head_tree_id::Error),
-        #[error(transparent)]
-        AttributesAndExcludes(#[from] crate::repository::attributes::Error),
-        #[error(transparent)]
-        Pathspec(#[from] crate::pathspec::init::Error),
-        #[error(transparent)]
-        HeadTreeDiff(#[from] crate::status::tree_index::Error),
-    }
-}
-
 mod platform;
 
 ///
diff --git a/gix/src/status/tree_index.rs b/gix/src/status/tree_index.rs
index cb89faf78a0..2133d1c7835 100644
--- a/gix/src/status/tree_index.rs
+++ b/gix/src/status/tree_index.rs
@@ -1,18 +1,5 @@
-use crate::{Repository, config::tree};
-
-/// The error returned by [Repository::tree_index_status()].
-#[derive(Debug, thiserror::Error)]
-#[expect(missing_docs)]
-pub enum Error {
-    #[error(transparent)]
-    IndexFromMTree(#[from] crate::repository::index_from_tree::Error),
-    #[error(transparent)]
-    RewritesConfiguration(#[from] crate::diff::new_rewrites::Error),
-    #[error("Could not create diff-cache for similarity checks")]
-    DiffResourceCache(#[from] crate::repository::diff_resource_cache::Error),
-    #[error(transparent)]
-    TreeIndexDiff(#[from] gix_diff::index::Error),
-}
+use crate::{ExnResult, Repository, Result, config::tree};
+use gix_error::ResultExt;
 
 /// Specify how to perform rewrite tracking [Repository::tree_index_status()].
 #[derive(Default, Debug, Copy, Clone)]
@@ -52,7 +39,7 @@ impl Repository {
     ///
     /// * This is a low-level method - prefer the [`Repository::status()`] platform instead for access to various iterators
     ///   over the same information.
-    pub fn tree_index_status<'repo, E>(
+    pub fn tree_index_status<'repo>(
         &'repo self,
         tree_id: &gix_hash::oid,
         worktree_index: &gix_index::State,
@@ -62,11 +49,8 @@ impl Repository {
             gix_diff::index::ChangeRef<'_, '_>,
             &gix_index::State,
             &gix_index::State,
-        ) -> Result<gix_diff::index::Action, E>,
-    ) -> Result<Outcome, Error>
-    where
-        E: Into<Box<dyn std::error::Error + Send + Sync>>,
-    {
+        ) -> ExnResult<gix_diff::index::Action>,
+    ) -> Result<Outcome> {
         let _span = gix_trace::coarse!("gix::tree_index_status");
         let tree_index: gix_index::State = self.index_from_tree(tree_id)?.into();
         let rewrites = match renames {
@@ -76,10 +60,12 @@ impl Repository {
                     self.config.lenient_config,
                     &tree::Status::RENAMES,
                     &tree::Status::RENAME_LIMIT,
-                )?;
+                )
+                .or_erased()?;
                 if !is_configured {
                     (rewrites, is_configured) =
-                        crate::diff::utils::new_rewrites(&self.config.resolved, self.config.lenient_config)?;
+                        crate::diff::utils::new_rewrites(&self.config.resolved, self.config.lenient_config)
+                            .or_erased()?;
                 }
                 if !is_configured {
                     rewrites = Some(Default::default());
@@ -91,7 +77,10 @@ impl Repository {
         };
         let mut resource_cache = None;
         if rewrites.is_some() {
-            resource_cache = Some(self.diff_resource_cache_for_tree_diff()?);
+            resource_cache = Some(
+                self.diff_resource_cache_for_tree_diff()
+                    .or_raise(|| gix_error::message("Could not create diff-cache for similarity checks"))?,
+            );
         }
         let mut pathspec_storage = None;
         if pathspec.is_none() {
diff --git a/gix/src/submodule/errors.rs b/gix/src/submodule/errors.rs
deleted file mode 100644
index 7ffb0eb0a3d..00000000000
--- a/gix/src/submodule/errors.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-///
-pub mod open_modules_file {
-    /// The error returned by [Repository::open_modules_file()](crate::Repository::open_modules_file()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Configuration(#[from] gix_submodule::init::Error),
-        #[error("Could not read '.gitmodules' file")]
-        Io(#[from] std::io::Error),
-    }
-}
-
-///
-pub mod modules {
-    /// The error returned by [Repository::modules()](crate::Repository::modules()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenModulesFile(#[from] crate::submodule::open_modules_file::Error),
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-        #[error("Could not find the .gitmodules file by id in the object database")]
-        FindExistingBlob(#[from] crate::object::find::existing::Error),
-        #[error(transparent)]
-        FindHeadRef(#[from] crate::reference::find::existing::Error),
-        #[error(transparent)]
-        PeelHeadRef(#[from] crate::head::peel::Error),
-        #[error(transparent)]
-        PeelObjectToCommit(#[from] crate::object::peel::to_kind::Error),
-        #[error(transparent)]
-        TreeFromCommit(#[from] crate::object::commit::Error),
-    }
-}
-
-///
-pub mod is_active {
-    /// The error returned by [Submodule::is_active()](crate::Submodule::is_active()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        InitIsActivePlatform(#[from] gix_submodule::is_active_platform::Error),
-        #[error(transparent)]
-        QueryIsActive(#[from] gix_config::value::Error),
-        #[error(transparent)]
-        InitAttributes(#[from] crate::config::attribute_stack::Error),
-        #[error(transparent)]
-        InitPathspecDefaults(#[from] gix_pathspec::defaults::from_environment::Error),
-        #[error(transparent)]
-        ObtainIndex(#[from] crate::repository::index_or_load_from_head::Error),
-    }
-}
-
-///
-pub mod fetch_recurse {
-    /// The error returned by [Submodule::fetch_recurse()](crate::Submodule::fetch_recurse()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ModuleBoolean(#[from] gix_submodule::config::Error),
-        #[error(transparent)]
-        ConfigurationFallback(#[from] crate::config::key::GenericErrorWithValue),
-    }
-}
-
-///
-pub mod open {
-    /// The error returned by [Submodule::open()](crate::Submodule::open()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenRepository(#[from] crate::open::Error),
-        #[error(transparent)]
-        GitDir(#[from] crate::submodule::git_dir_try_old_form::Error),
-        #[error(transparent)]
-        PathConfiguration(#[from] gix_submodule::config::path::Error),
-        #[error(transparent)]
-        WorktreeDirInaccessible(#[from] std::io::Error),
-    }
-}
-
-///
-pub mod git_dir_try_old_form {
-    /// The error returned by [Submodule::git_dir_try_old_form()](crate::Submodule::git_dir_try_old_form()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        PathConfiguration(#[from] gix_submodule::config::path::Error),
-        #[error("The gitdir file at '{}' contains an invalid gitdir target: {:?}", .gitdir_file.display(), .target)]
-        InvalidGitDirFileTarget {
-            gitdir_file: std::path::PathBuf,
-            target: Option<std::path::PathBuf>,
-            #[source]
-            source: Option<gix_discover::path::from_gitdir_file::Error>,
-        },
-        #[error(transparent)]
-        GitDir(#[from] gix_validate::submodule::name::Error),
-    }
-}
-
-///
-pub mod state {
-    /// The error returned by [Submodule::state()](crate::Submodule::state()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        GitDirTryOldForm(#[from] crate::submodule::git_dir_try_old_form::Error),
-        #[error(transparent)]
-        GitDir(#[from] gix_validate::submodule::name::Error),
-        #[error(transparent)]
-        PathConfiguration(#[from] gix_submodule::config::path::Error),
-    }
-}
-
-///
-pub mod index_id {
-    /// The error returned by [Submodule::index_id()](crate::Submodule::index_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        PathConfiguration(#[from] gix_submodule::config::path::Error),
-        #[error(transparent)]
-        Index(#[from] crate::repository::index_or_load_from_head::Error),
-    }
-}
-
-///
-pub mod head_id {
-    /// The error returned by [Submodule::head_id()](crate::Submodule::head_id()).
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        HeadCommit(#[from] crate::reference::head_commit::Error),
-        #[error("Could not get tree of head commit")]
-        CommitTree(#[from] crate::object::commit::Error),
-        #[error("Could not peel tree to submodule path")]
-        PeelTree(#[from] crate::object::find::existing::Error),
-        #[error(transparent)]
-        PathConfiguration(#[from] gix_submodule::config::path::Error),
-    }
-}
diff --git a/gix/src/submodule/mod.rs b/gix/src/submodule/mod.rs
index 724b5de83b8..cc94c3e35ce 100644
--- a/gix/src/submodule/mod.rs
+++ b/gix/src/submodule/mod.rs
@@ -1,15 +1,17 @@
 #![allow(clippy::result_large_err)]
 //! Submodule plumbing and abstractions
 //!
+use gix_error::ExnMessageResult;
 use std::{
     cell::{Ref, RefCell, RefMut},
     path::{Path, PathBuf},
 };
 
+use gix_error::{ErrorExt, ResultExt};
 pub use gix_submodule::*;
 
 use crate::{
-    Repository, Submodule,
+    Error, Repository, Result, Submodule,
     bstr::{BStr, BString},
     is_dir_to_mode,
     worktree::IndexPersistedOrInMemory,
@@ -22,9 +24,6 @@ pub type ModulesSnapshot = gix_fs::SharedFileSnapshot<File>;
 /// The name of the file containing (sub) module information.
 pub(crate) const MODULES_FILE: &str = ".gitmodules";
 
-mod errors;
-pub use errors::*;
-
 /// A platform maintaining state needed to interact with submodules, created by [`Repository::submodules()].
 pub(crate) struct SharedState<'repo> {
     pub repo: &'repo Repository,
@@ -43,7 +42,7 @@ impl<'repo> SharedState<'repo> {
         }
     }
 
-    fn index(&self) -> Result<Ref<'_, IndexPersistedOrInMemory>, crate::repository::index_or_load_from_head::Error> {
+    fn index(&self) -> Result<Ref<'_, IndexPersistedOrInMemory>> {
         {
             let mut state = self.index.borrow_mut();
             if state.is_none() {
@@ -55,14 +54,13 @@ impl<'repo> SharedState<'repo> {
         }))
     }
 
-    fn active_state_mut(
-        &self,
-    ) -> Result<(RefMut<'_, IsActivePlatform>, RefMut<'_, gix_worktree::Stack>), is_active::Error> {
+    fn active_state_mut(&self) -> Result<(RefMut<'_, IsActivePlatform>, RefMut<'_, gix_worktree::Stack>)> {
         let mut state = self.is_active.borrow_mut();
         if state.is_none() {
             let platform = self
                 .modules
-                .is_active_platform(&self.repo.config.resolved, self.repo.config.pathspec_defaults()?)?;
+                .is_active_platform(&self.repo.config.resolved, self.repo.config.pathspec_defaults()?)
+                .or_erased()?;
             let index = self.index()?;
             let attributes = self
                 .repo
@@ -99,40 +97,40 @@ impl Submodule<'_> {
     }
 
     /// Return the submodule's name after validating it for safe use in paths like `.git/modules/<name>`.
-    pub fn validated_name(&self) -> Result<&BStr, gix_validate::submodule::name::Error> {
+    pub fn validated_name(&self) -> std::result::Result<&BStr, gix_validate::submodule::name::Error> {
         gix_validate::submodule::name(self.name())
     }
     /// Return the path at which the submodule can be found, relative to the repository.
     ///
     /// For details, see [gix_submodule::File::path()].
-    pub fn path(&self) -> Result<BString, config::path::Error> {
+    pub fn path(&self) -> ExnMessageResult<BString> {
         self.state.modules.path(self.name())
     }
 
     /// Return the url from which to clone or update the submodule.
     ///
     /// This method takes into consideration submodule configuration overrides.
-    pub fn url(&self) -> Result<gix_url::Url, config::url::Error> {
-        self.state.modules.url(self.name())
+    pub fn url(&self) -> Result<gix_url::Url> {
+        self.state.modules.url(self.name()).map_err(Into::into)
     }
 
     /// Return the `update` field from this submodule's configuration, if present, or `None`.
     ///
     /// This method takes into consideration submodule configuration overrides.
-    pub fn update(&self) -> Result<Option<config::Update>, config::update::Error> {
+    pub fn update(&self) -> ExnMessageResult<Option<config::Update>> {
         self.state.modules.update(self.name())
     }
 
     /// Return the `branch` field from this submodule's configuration, if present, or `None`.
     ///
     /// This method takes into consideration submodule configuration overrides.
-    pub fn branch(&self) -> Result<Option<config::Branch>, config::branch::Error> {
-        self.state.modules.branch(self.name())
+    pub fn branch(&self) -> Result<Option<config::Branch>> {
+        self.state.modules.branch(self.name()).map_err(Into::into)
     }
 
     /// Return the `fetchRecurseSubmodules` field from this submodule's configuration, or retrieve the value from `fetch.recurseSubmodules` if unset.
-    pub fn fetch_recurse(&self) -> Result<Option<config::FetchRecurse>, fetch_recurse::Error> {
-        Ok(match self.state.modules.fetch_recurse(self.name())? {
+    pub fn fetch_recurse(&self) -> Result<Option<config::FetchRecurse>> {
+        Ok(match self.state.modules.fetch_recurse(self.name()).or_erased()? {
             Some(val) => Some(val),
             None => crate::config::tree::Fetch::RECURSE_SUBMODULES
                 .try_into_recurse_submodules(self.state.repo.config.resolved.boolean("fetch.recurseSubmodules"))?,
@@ -142,21 +140,21 @@ impl Submodule<'_> {
     /// Return the `ignore` field from this submodule's configuration, if present, or `None`.
     ///
     /// This method takes into consideration submodule configuration overrides.
-    pub fn ignore(&self) -> Result<Option<config::Ignore>, config::Error> {
+    pub fn ignore(&self) -> ExnMessageResult<Option<config::Ignore>> {
         self.state.modules.ignore(self.name())
     }
 
     /// Return the `shallow` field from this submodule's configuration, if present, or `None`.
     ///
     /// If `true`, the submodule will be checked out with `depth = 1`. If unset, `false` is assumed.
-    pub fn shallow(&self) -> Result<Option<bool>, gix_config::value::Error> {
-        self.state.modules.shallow(self.name())
+    pub fn shallow(&self) -> Result<Option<bool>> {
+        self.state.modules.shallow(self.name()).map_err(Into::into)
     }
 
     /// Returns true if this submodule is considered active and can thus participate in an operation.
     ///
     /// Please see the [plumbing crate documentation](gix_submodule::IsActivePlatform::is_active()) for details.
-    pub fn is_active(&self) -> Result<bool, is_active::Error> {
+    pub fn is_active(&self) -> Result<bool> {
         let (mut platform, mut attributes) = self.state.active_state_mut()?;
         let is_active = platform.is_active(
             &self.state.repo.config.resolved,
@@ -177,8 +175,8 @@ impl Submodule<'_> {
     /// If `None`, but `Some()` when calling [`Self::head_id()`], then the submodule was just deleted but the change
     /// wasn't yet committed. Note that `None` is also returned if the entry at the submodule path isn't a submodule.
     /// If `Some()`, but `None` when calling [`Self::head_id()`], then the submodule was just added without having committed the change.
-    pub fn index_id(&self) -> Result<Option<gix_hash::ObjectId>, index_id::Error> {
-        let path = self.path()?;
+    pub fn index_id(&self) -> Result<Option<gix_hash::ObjectId>> {
+        let path = self.path().or_erased()?;
         Ok(self
             .state
             .index()?
@@ -191,21 +189,23 @@ impl Submodule<'_> {
     /// If `Some()`, but `None` when calling [`Self::index_id()`], then the submodule was just deleted but the change
     /// wasn't yet committed. Note that `None` is also returned if the entry at the submodule path isn't a submodule.
     /// If `None`, but `Some()` when calling [`Self::index_id()`], then the submodule was just added without having committed the change.
-    pub fn head_id(&self) -> Result<Option<gix_hash::ObjectId>, head_id::Error> {
-        let path = self.path()?;
+    pub fn head_id(&self) -> Result<Option<gix_hash::ObjectId>> {
+        let path = self.path().or_erased()?;
         Ok(self
             .state
             .repo
             .head_commit()?
-            .tree()?
-            .peel_to_entry_by_path(gix_path::from_bstring(path))?
+            .tree()
+            .or_raise(|| gix_error::message("Could not get tree of head commit"))?
+            .peel_to_entry_by_path(gix_path::from_bstring(path))
+            .or_raise(|| gix_error::message("Could not peel tree to submodule path"))?
             .and_then(|entry| (entry.mode().is_commit()).then_some(entry.inner.oid)))
     }
 
     /// Return the path at which the repository of the submodule should be located.
     ///
     /// The retunred directory might not exist yet.
-    pub fn git_dir(&self) -> Result<PathBuf, gix_validate::submodule::name::Error> {
+    pub fn git_dir(&self) -> std::result::Result<PathBuf, gix_validate::submodule::name::Error> {
         Ok(git_dir_from_name(self.state.repo.common_dir(), self.validated_name()?))
     }
 
@@ -213,7 +213,7 @@ impl Submodule<'_> {
     ///
     /// Note that it may be a path relative to the repository if, for some reason, the parent directory
     /// doesn't have a working dir set.
-    pub fn work_dir(&self) -> Result<PathBuf, config::path::Error> {
+    pub fn work_dir(&self) -> ExnMessageResult<PathBuf> {
         let worktree_git = gix_path::from_bstr(self.path()?);
         Ok(match self.state.repo.workdir() {
             None => worktree_git.into_owned(),
@@ -230,7 +230,7 @@ impl Submodule<'_> {
     /// is required to be a directory though, as a malformed gitdir file means a broken submodule checkout.
     ///
     /// Also note that the fallback path returned for uninitialized submodules may not actually exist.
-    pub fn git_dir_try_old_form(&self) -> Result<PathBuf, git_dir_try_old_form::Error> {
+    pub fn git_dir_try_old_form(&self) -> Result<PathBuf> {
         self.git_dir_try_old_form_inner(true)
     }
 
@@ -239,29 +239,27 @@ impl Submodule<'_> {
     ///
     /// Validation may be skipped when callers only need coarse state, like `status_opts()` with
     /// `Ignore::All`, which returns before opening or inspecting the submodule repository.
-    fn git_dir_try_old_form_inner(
-        &self,
-        validate_gitdir_file_target: bool,
-    ) -> Result<PathBuf, git_dir_try_old_form::Error> {
-        let git_dir = self.git_dir()?;
-        let worktree_gitdir = self.worktree_gitdir()?;
+    fn git_dir_try_old_form_inner(&self, validate_gitdir_file_target: bool) -> Result<PathBuf> {
+        let git_dir = self
+            .git_dir()
+            .map_err(|err| err.and_raise(gix_error::validation("The submodule name is invalid")))?;
+        let worktree_gitdir = self.worktree_gitdir().or_erased()?;
         let git_dir = if worktree_gitdir.is_dir() {
             worktree_gitdir
         } else if worktree_gitdir.is_file() {
             if validate_gitdir_file_target {
-                let git_dir = gix_discover::path::from_gitdir_file(&worktree_gitdir).map_err(|source| {
-                    git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                        gitdir_file: worktree_gitdir.clone(),
-                        target: None,
-                        source: Some(source),
-                    }
+                let git_dir = gix_discover::path::from_gitdir_file(&worktree_gitdir).map_err(|err| {
+                    err.raise(gix_error::validation(format!(
+                        "The gitdir file at '{}' contains an invalid gitdir target",
+                        worktree_gitdir.display()
+                    )))
                 })?;
                 if !git_dir.is_dir() {
-                    return Err(git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                        gitdir_file: worktree_gitdir,
-                        target: Some(git_dir),
-                        source: None,
-                    });
+                    return Err(Error::from_error(gix_error::validation(format!(
+                        "The gitdir file at '{}' contains an invalid gitdir target: '{}'",
+                        worktree_gitdir.display(),
+                        git_dir.display()
+                    ))));
                 }
                 git_dir
             } else {
@@ -273,9 +271,9 @@ impl Submodule<'_> {
         Ok(git_dir)
     }
 
-    fn state_inner(&self, validate_gitdir_file_target: bool) -> Result<State, state::Error> {
+    fn state_inner(&self, validate_gitdir_file_target: bool) -> Result<State> {
         let maybe_old_path = self.git_dir_try_old_form_inner(validate_gitdir_file_target)?;
-        let worktree_git = self.worktree_gitdir()?;
+        let worktree_git = self.worktree_gitdir().or_erased()?;
         let superproject_configuration = self
             .state
             .repo
@@ -295,7 +293,7 @@ impl Submodule<'_> {
 
     /// Query various parts of the submodule and assemble it into state information.
     #[doc(alias = "status", alias = "git2")]
-    pub fn state(&self) -> Result<State, state::Error> {
+    pub fn state(&self) -> Result<State> {
         self.state_inner(true)
     }
 
@@ -310,7 +308,7 @@ impl Submodule<'_> {
     /// Also see the [state()](Self::state()) method for learning about the submodule.
     /// The repository can also be used to learn about the submodule `HEAD`, i.e. where its working tree is at,
     /// which may differ compared to the superproject's index or `HEAD` commit.
-    pub fn open(&self) -> Result<Option<Repository>, open::Error> {
+    pub fn open(&self) -> Result<Option<Repository>> {
         let mut options = self
             .state
             .repo
@@ -321,23 +319,31 @@ impl Submodule<'_> {
         match crate::open_opts(self.git_dir_try_old_form()?, options) {
             Ok(mut repo) => {
                 if repo.workdir().is_none() {
-                    let wd = self.work_dir()?;
+                    let wd = self.work_dir().or_erased()?;
                     // We should always have a workdir, as bare submodules don't exist.
                     // However, it's possible for no workdir to be accessible if there is a symlink in the way.
                     // Just setting it by hand fixes this issue effectively, even though the question remains
                     // if this should work automatically.
                     // For now, let's *not* use the `self.worktree_git()` directory which has its own edge-cases,
                     // while the current solution yields the cleanest paths (i.e. it keeps relative ones).
-                    repo.set_workdir(Some(wd))?;
+                    repo.set_workdir(Some(wd)).or_erased()?;
                 }
                 Ok(Some(repo))
             }
-            Err(crate::open::Error::NotARepository { .. }) => Ok(None),
-            Err(err) => Err(err.into()),
+            // Nested not-found causes may instead describe invalid repository configuration.
+            Err(err)
+                if err
+                    .error()
+                    .downcast_ref::<gix_error::Message>()
+                    .is_some_and(|error| error.class == Some(gix_error::Class::NotFound)) =>
+            {
+                Ok(None)
+            }
+            Err(err) => Err(err),
         }
     }
 
-    fn worktree_gitdir(&self) -> Result<PathBuf, config::path::Error> {
+    fn worktree_gitdir(&self) -> ExnMessageResult<PathBuf> {
         Ok(self.work_dir()?.join(gix_discover::DOT_GIT_DIR))
     }
 }
@@ -389,30 +395,8 @@ mod tests {
 pub mod status {
     use gix_submodule::config;
 
-    use super::{Status, head_id, index_id, open, state};
-    use crate::Submodule;
-
-    /// The error returned by [Submodule::status()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        State(#[from] state::Error),
-        #[error(transparent)]
-        HeadId(#[from] head_id::Error),
-        #[error(transparent)]
-        IndexId(#[from] index_id::Error),
-        #[error(transparent)]
-        OpenRepository(#[from] open::Error),
-        #[error(transparent)]
-        IgnoreConfiguration(#[from] config::Error),
-        #[error(transparent)]
-        StatusPlatform(#[from] crate::status::Error),
-        #[error(transparent)]
-        StatusIter(#[from] crate::status::into_iter::Error),
-        #[error(transparent)]
-        NextStatusItem(#[from] crate::status::iter::Error),
-    }
+    use super::Status;
+    use crate::{Result, Submodule};
 
     impl Submodule<'_> {
         /// Return the status of the submodule.
@@ -427,7 +411,7 @@ pub mod status {
             &self,
             ignore: config::Ignore,
             check_dirty: bool,
-        ) -> Result<crate::submodule::status::types::Status, Error> {
+        ) -> Result<crate::submodule::status::types::Status> {
             self.status_opts(ignore, check_dirty, &mut |s| s)
         }
         /// Return the status of the submodule, just like [`status`](Self::status), but allows to adjust options
@@ -451,7 +435,7 @@ pub mod status {
                 crate::status::Platform<'a, gix_features::progress::Discard>,
             )
                 -> crate::status::Platform<'a, gix_features::progress::Discard>,
-        ) -> Result<Status, Error> {
+        ) -> Result<Status> {
             let mut state = self.state_inner(ignore != config::Ignore::All)?;
             if ignore == config::Ignore::All {
                 return Ok(Status {
diff --git a/gix/src/tag.rs b/gix/src/tag.rs
index 65902867d74..53bf3e336d9 100644
--- a/gix/src/tag.rs
+++ b/gix/src/tag.rs
@@ -1,19 +1,2 @@
 //!
 #![allow(clippy::empty_docs)]
-mod error {
-
-    /// The error returned by [`tag(…)`][crate::Repository::tag()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ReferenceNameValidation(#[from] gix_ref::name::Error),
-        #[error(transparent)]
-        WriteObject(#[from] crate::object::write::Error),
-        #[error(transparent)]
-        ReferenceEdit(#[from] crate::reference::edit::Error),
-        #[error(transparent)]
-        DateParseError(#[from] gix_date::Error),
-    }
-}
-pub use error::Error;
diff --git a/gix/src/worktree/mod.rs b/gix/src/worktree/mod.rs
index 0d1e66b3136..3858c72ca91 100644
--- a/gix/src/worktree/mod.rs
+++ b/gix/src/worktree/mod.rs
@@ -118,28 +118,16 @@ pub mod proxy;
 ///
 #[cfg(feature = "index")]
 pub mod open_index {
-    /// The error returned by [`Worktree::open_index()`][crate::Worktree::open_index()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        ConfigIndexThreads(#[from] crate::config::key::GenericErrorWithValue),
-        #[error(transparent)]
-        ConfigSkipHash(#[from] crate::config::boolean::Error),
-        #[error(transparent)]
-        IndexFile(#[from] gix_index::file::init::Error),
-        #[error(transparent)]
-        IndexCorrupt(#[from] gix_index::file::verify::Error),
-    }
+    use crate::Result;
 
     impl crate::Worktree<'_> {
         /// A shortcut to [`crate::Repository::open_index()`].
-        pub fn open_index(&self) -> Result<gix_index::File, Error> {
+        pub fn open_index(&self) -> Result<gix_index::File> {
             self.parent.open_index()
         }
 
         /// A shortcut to [`crate::Repository::index()`].
-        pub fn index(&self) -> Result<crate::worktree::Index, Error> {
+        pub fn index(&self) -> Result<crate::worktree::Index> {
             self.parent.index()
         }
     }
@@ -148,17 +136,7 @@ pub mod open_index {
 ///
 #[cfg(feature = "excludes")]
 pub mod excludes {
-    use crate::AttributeStack;
-
-    /// The error returned by [`Worktree::excludes()`][crate::Worktree::excludes()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-        #[error(transparent)]
-        CreateCache(#[from] crate::config::exclude_stack::Error),
-    }
+    use crate::{AttributeStack, Result};
 
     impl crate::Worktree<'_> {
         /// Configure a file-system cache checking if files below the repository are excluded.
@@ -170,13 +148,13 @@ pub mod excludes {
         ///
         /// When only excludes are desired, this is the most efficient way to obtain them. Otherwise use
         /// [`Worktree::attributes()`][crate::Worktree::attributes()] for accessing both attributes and excludes.
-        pub fn excludes(&self, overrides: Option<gix_ignore::Search>) -> Result<AttributeStack<'_>, Error> {
+        pub fn excludes(&self, overrides: Option<gix_ignore::Search>) -> Result<AttributeStack<'_>> {
             let index = self.index()?;
-            Ok(self.parent.excludes(
+            self.parent.excludes(
                 &index,
                 overrides,
                 gix_worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
-            )?)
+            )
         }
     }
 }
@@ -184,17 +162,7 @@ pub mod excludes {
 ///
 #[cfg(feature = "attributes")]
 pub mod attributes {
-    use crate::{AttributeStack, Worktree};
-
-    /// The error returned by [`Worktree::attributes()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-        #[error(transparent)]
-        CreateCache(#[from] crate::repository::attributes::Error),
-    }
+    use crate::{AttributeStack, Result, Worktree};
 
     impl<'repo> Worktree<'repo> {
         /// Configure a file-system cache checking if files below the repository are excluded or for querying their attributes.
@@ -203,25 +171,23 @@ pub mod attributes {
         ///
         /// * `$XDG_CONFIG_HOME/…/ignore|attributes` if `core.excludesFile|attributesFile` is *not* set, otherwise use the configured file.
         /// * `$GIT_DIR/info/exclude|attributes` if present.
-        pub fn attributes(&self, overrides: Option<gix_ignore::Search>) -> Result<AttributeStack<'repo>, Error> {
+        pub fn attributes(&self, overrides: Option<gix_ignore::Search>) -> Result<AttributeStack<'repo>> {
             let index = self.index()?;
-            Ok(self.parent.attributes(
+            self.parent.attributes(
                 &index,
                 gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
                 gix_worktree::stack::state::ignore::Source::WorktreeThenIdMappingIfNotSkipped,
                 overrides,
-            )?)
+            )
         }
 
         /// Like [attributes()][Self::attributes()], but without access to exclude/ignore information.
-        pub fn attributes_only(&self) -> Result<AttributeStack<'repo>, Error> {
+        pub fn attributes_only(&self) -> Result<AttributeStack<'repo>> {
             let index = self.index()?;
-            self.parent
-                .attributes_only(
-                    &index,
-                    gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-                )
-                .map_err(|err| Error::CreateCache(err.into()))
+            self.parent.attributes_only(
+                &index,
+                gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
+            )
         }
     }
 }
@@ -230,21 +196,11 @@ pub mod attributes {
 #[cfg(feature = "attributes")]
 pub mod pathspec {
     use crate::{
-        Worktree,
+        Result, Worktree,
         bstr::BStr,
         config::{cache::util::ApplyLeniencyDefaultValue, tree::gitoxide},
     };
 
-    /// The error returned by [`Worktree::pathspec()`].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Init(#[from] crate::pathspec::init::Error),
-        #[error(transparent)]
-        OpenIndex(#[from] crate::worktree::open_index::Error),
-    }
-
     impl<'repo> Worktree<'repo> {
         /// Configure pathspecs `patterns` to be matched against, with pathspec attributes read from the worktree and then from the index
         /// if needed.
@@ -254,10 +210,7 @@ pub mod pathspec {
         /// ### Deviation
         ///
         /// Pathspec attributes match case-insensitively by default if the underlying filesystem is configured that way.
-        pub fn pathspec(
-            &self,
-            patterns: impl IntoIterator<Item = impl AsRef<BStr>>,
-        ) -> Result<crate::Pathspec<'repo>, Error> {
+        pub fn pathspec(&self, patterns: impl IntoIterator<Item = impl AsRef<BStr>>) -> Result<crate::Pathspec<'repo>> {
             let index = self.index()?;
             let inherit_ignore_case = gitoxide::Pathspec::INHERIT_IGNORE_CASE
                 .enrich_error(
@@ -269,16 +222,15 @@ pub mod pathspec {
                 .with_lenient_default_value(
                     self.parent.config.lenient_config,
                     Some(gitoxide::Pathspec::INHERIT_IGNORE_CASE_DEFAULT),
-                )
-                .map_err(|err| Error::Init(crate::pathspec::init::Error::Defaults(err.into())))?
+                )?
                 .unwrap_or(gitoxide::Pathspec::INHERIT_IGNORE_CASE_DEFAULT);
-            Ok(self.parent.pathspec(
+            self.parent.pathspec(
                 true, /* empty patterns match prefix */
                 patterns,
                 inherit_ignore_case,
                 &index,
                 gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
-            )?)
+            )
         }
     }
 }
diff --git a/gix/src/worktree/proxy.rs b/gix/src/worktree/proxy.rs
index bb9198afb1e..02911e38856 100644
--- a/gix/src/worktree/proxy.rs
+++ b/gix/src/worktree/proxy.rs
@@ -1,29 +1,14 @@
 #![allow(clippy::result_large_err)]
+use gix_error::ResultExt;
+
 use std::path::{Path, PathBuf};
 
 use crate::{
-    Repository, ThreadSafeRepository,
+    Error, Repository, Result, ThreadSafeRepository,
     bstr::{BStr, BString, ByteSlice},
     worktree::Proxy,
 };
 
-#[expect(missing_docs)]
-pub mod into_repo {
-    use std::path::PathBuf;
-
-    /// The error returned by [`Proxy::into_repo()`][super::Proxy::into_repo()].
-    #[derive(Debug, thiserror::Error)]
-    #[expect(missing_docs)]
-    pub enum Error {
-        #[error(transparent)]
-        Open(#[from] crate::open::Error),
-        #[error("Worktree at '{}' is inaccessible", .base.display())]
-        MissingWorktree { base: PathBuf },
-        #[error(transparent)]
-        MissingGitDirFile(#[from] std::io::Error),
-    }
-}
-
 impl<'repo> Proxy<'repo> {
     pub(crate) fn new(parent: &'repo Repository, git_dir: impl Into<PathBuf>) -> Self {
         Proxy {
@@ -102,7 +87,7 @@ impl Proxy<'_> {
     /// was removed or moved in the mean time or is unavailable for other reasons.
     /// The caller will encounter io errors if it's used like the work tree is guaranteed to be present, but can still access
     /// a lot of information if work tree access is avoided.
-    pub fn into_repo_with_possibly_inaccessible_worktree(self) -> Result<Repository, crate::open::Error> {
+    pub fn into_repo_with_possibly_inaccessible_worktree(self) -> Result<Repository> {
         let base = self.base().ok();
         let options = self.parent.options.clone().without_repository_environment_overrides();
         let common_dir = self.parent.common_dir().to_owned();
@@ -114,10 +99,13 @@ impl Proxy<'_> {
     /// if the worktree doesn't exist.
     ///
     /// Note that it won't fail if the worktree doesn't exist.
-    pub fn into_repo(self) -> Result<Repository, into_repo::Error> {
-        let base = self.base()?;
+    pub fn into_repo(self) -> Result<Repository> {
+        let base = self.base().or_erased()?;
         if !base.is_dir() {
-            return Err(into_repo::Error::MissingWorktree { base });
+            return Err(Error::from_error(gix_error::message!(
+                "Worktree at '{}' is inaccessible",
+                base.display()
+            )));
         }
         let options = self.parent.options.clone().without_repository_environment_overrides();
         let common_dir = self.parent.common_dir().to_owned();
diff --git a/gix/tests/doctest.rs b/gix/tests/doctest.rs
index 308aaada474..98f4be77b83 100644
--- a/gix/tests/doctest.rs
+++ b/gix/tests/doctest.rs
@@ -2,11 +2,11 @@ pub fn basic_repo_dir() -> Result<std::path::PathBuf, Box<dyn std::error::Error
     gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")
 }
 
-pub fn open_repo(path: impl Into<std::path::PathBuf>) -> Result<gix::Repository, gix::open::Error> {
+pub fn open_repo(path: impl Into<std::path::PathBuf>) -> Result<gix::Repository, gix_error::Error> {
     gix::open_opts(path, gix::open::Options::isolated())
 }
 
-pub fn discover_repo(path: impl AsRef<std::path::Path>) -> Result<gix::Repository, gix::discover::Error> {
+pub fn discover_repo(path: impl AsRef<std::path::Path>) -> Result<gix::Repository, gix_error::Error> {
     let opts = gix::open::Options::isolated();
     gix::ThreadSafeRepository::discover_opts(
         path,
diff --git a/gix/tests/gix-init.rs b/gix/tests/gix-init.rs
index c5d7bf41b07..4c35bd5a451 100644
--- a/gix/tests/gix-init.rs
+++ b/gix/tests/gix-init.rs
@@ -11,14 +11,12 @@ pub fn named_subrepo_opts(
     fixture: &str,
     name: &str,
     opts: gix::open::Options,
-) -> std::result::Result<Repository, gix::open::Error> {
+) -> std::result::Result<Repository, gix_error::Error> {
     let repo_path = gix_testtools::scripted_fixture_read_only(fixture).unwrap().join(name);
     Ok(ThreadSafeRepository::open_opts(repo_path, opts)?.to_thread_local())
 }
 
-fn discover_with_environment_overrides_isolated(
-    directory: impl AsRef<Path>,
-) -> Result<Repository, gix::discover::Error> {
+fn discover_with_environment_overrides_isolated(directory: impl AsRef<Path>) -> Result<Repository, gix_error::Error> {
     let mut options = gix::open::Options::isolated();
     options.permissions.env.git_prefix = Permission::Allow;
     ThreadSafeRepository::discover_with_environment_overrides_opts(
@@ -127,7 +125,7 @@ mod config {
 }
 
 mod config_mut {
-    use gix::config::{Source, file_mut::Error};
+    use gix::config::Source;
     use gix_sec::Permission;
     use gix_testtools::{Env, Result};
     use serial_test::serial;
@@ -264,6 +262,7 @@ mod config_mut {
     #[test]
     #[serial]
     fn source_paths_match_standalone_reads() -> Result {
+        let mut diagnostics = Vec::new();
         let _environment = gix_testtools::isolate_git_environment()?;
         let temp = gix_testtools::tempfile::tempdir()?;
         let home = temp.path();
@@ -326,19 +325,23 @@ mod config_mut {
         );
         drop(file);
         options.permissions.env.home = Permission::Deny;
-        assert!(
-            matches!(
-                gix::config_mut(Source::Git, &options),
-                Err(Error::SourceUnavailable(Source::Git))
-            ),
-            "a source with no permitted path is unavailable"
+        diagnostics.push(
+            gix::config_mut(Source::Git, &options)
+                .err()
+                .expect("a source with no permitted path is unavailable"),
         );
+        insta::assert_debug_snapshot!(diagnostics, "GIT_CONFIG_NOSYSTEM suppresses explicit installation and system paths", @"
+        [
+            Configuration source Git has no available path with these options,
+        ]
+        ");
         Ok(())
     }
 
     #[test]
     #[serial]
     fn honors_environment_and_explicit_path_overrides() -> Result {
+        let mut diagnostics = Vec::new();
         let _environment = gix_testtools::isolate_git_environment()?;
         let temp = gix_testtools::tempfile::tempdir()?;
         let global = temp.path().join("global.config");
@@ -383,9 +386,10 @@ mod config_mut {
             );
             drop(file);
             let _no_system = Env::new().set("GIT_CONFIG_NOSYSTEM", "true");
-            assert!(
-                matches!(gix::config_mut(source, &options), Err(Error::SourceUnavailable(actual)) if actual == source),
-                "GIT_CONFIG_NOSYSTEM suppresses explicit installation and system paths"
+            diagnostics.push(
+                gix::config_mut(source, &options)
+                    .err()
+                    .expect("GIT_CONFIG_NOSYSTEM suppresses explicit installation and system paths"),
             );
             options.permissions.env.git_prefix = Permission::Deny;
             assert!(
@@ -398,24 +402,41 @@ mod config_mut {
         options.permissions.config.git = true;
         options.permissions.env.git_prefix = Permission::Allow;
         let _file = gix::config_mut(Source::User, &options)?;
-        assert!(
-            matches!(gix::config_mut(Source::Git, &options), Err(Error::AcquireLock(_))),
-            "sources overridden to the same file share its lock"
-        );
+        let err = gix::config_mut(Source::Git, &options)
+            .err()
+            .expect("sources overridden to the same file share its lock");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&temp.path().to_string_lossy(), "<tmp>")]), "sources overridden to the same file share its lock", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ The lock for resource '<tmp>/global.config' could not be obtained immediately after 1 attempt(s). The lockfile at '<tmp>/global.config.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<tmp>/global.config.lock"
+        "#);
+        assert!(err.can_retry(), "sources overridden to the same file share its lock");
+        insta::assert_debug_snapshot!(diagnostics, "GIT_CONFIG_NOSYSTEM suppresses explicit installation and system paths", @"
+        [
+            Configuration source GitInstallation has no available path with these options,
+            Configuration source System has no available path with these options,
+        ]
+        ");
         Ok(())
     }
 
     #[test]
     #[serial]
     fn rejects_unsupported_and_disabled_sources() -> Result {
+        let mut diagnostics = Vec::new();
         let temp = gix_testtools::tempfile::tempdir()?;
         let options = gix::open::Options::isolated()
             .git_installation_config_path(temp.path().join("installation.config"))
             .system_config_path(temp.path().join("system.config"));
         for source in [Source::GitInstallation, Source::System, Source::Git, Source::User] {
-            assert!(
-                matches!(gix::config_mut(source, &options), Err(Error::SourceUnavailable(actual)) if actual == source),
-                "disabled sources cannot be opened for writing"
+            diagnostics.push(
+                gix::config_mut(source, &options)
+                    .err()
+                    .expect("disabled sources cannot be opened for writing"),
             );
         }
         for source in [
@@ -426,9 +447,10 @@ mod config_mut {
             Source::Api,
             Source::EnvOverride,
         ] {
-            assert!(
-                matches!(gix::config_mut(source, &options), Err(Error::UnsupportedSource(actual)) if actual == source),
-                "repository and in-memory sources have no standalone transaction"
+            diagnostics.push(
+                gix::config_mut(source, &options)
+                    .err()
+                    .expect("repository and in-memory sources have no standalone transaction"),
             );
         }
         assert_eq!(
@@ -436,6 +458,20 @@ mod config_mut {
             0,
             "rejected sources do not create files or locks"
         );
+        insta::assert_debug_snapshot!(diagnostics, "GIT_CONFIG_NOSYSTEM suppresses explicit installation and system paths", @"
+        [
+            Configuration source GitInstallation has no available path with these options,
+            Configuration source System has no available path with these options,
+            Configuration source Git has no available path with these options,
+            Configuration source User has no available path with these options,
+            Configuration source Local requires a repository or has no physical file,
+            Configuration source Worktree requires a repository or has no physical file,
+            Configuration source Env requires a repository or has no physical file,
+            Configuration source Cli requires a repository or has no physical file,
+            Configuration source Api requires a repository or has no physical file,
+            Configuration source EnvOverride requires a repository or has no physical file,
+        ]
+        ");
         Ok(())
     }
 
@@ -445,15 +481,19 @@ mod config_mut {
         let temp = gix_testtools::tempfile::tempdir()?;
         let path = temp.path().join("missing/global.config");
         let options = options_for(Source::System).system_config_path(&path);
-        assert!(
-            matches!(
-                gix::config_mut(Source::System, &options),
-                Err(Error::AcquireLock(err)) if err
-                    .downcast_any_ref::<std::io::Error>()
-                    .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
-            ),
-            "the parent directory must already exist"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("the parent directory must already exist");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&temp.path().to_string_lossy(), "<tmp>")]), "the parent directory must already exist", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ Another IO error occurred while obtaining the lock
+        |
+        └─ I/O error (NotFound)
+        |
+        └─ NotFound at path "<tmp>/missing/global.config.lock"
+        "#);
+        assert!(err.is_not_found(), "the parent directory must already exist");
         assert!(
             !path.parent().expect("config parent").exists(),
             "opening does not create directories"
@@ -478,10 +518,18 @@ mod config_mut {
         let options = options_for(Source::System).system_config_path(&path);
         let malformed = "[unterminated";
         std::fs::write(&path, malformed)?;
-        assert!(
-            matches!(gix::config_mut(Source::System, &options), Err(Error::Config(_))),
-            "malformed configuration cannot be overwritten through a transaction"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("malformed configuration cannot be overwritten through a transaction");
+        insta::assert_debug_snapshot!(err, "malformed configuration cannot be overwritten through a transaction", @"
+        Could not load global configuration
+        |
+        └─ Could not initialize configuration from a path
+        |
+        └─ Could not parse configuration
+        |
+        └─ Got an unexpected token on line 1 while trying to parse a section header: '[untermina' ... (3 characters omitted)
+        ");
         assert_eq!(
             std::fs::read_to_string(&path)?,
             malformed,
@@ -511,30 +559,44 @@ mod config_mut {
             .strict_config(true)
             .cli_overrides(["core.configLockTimeout=invalid"])
             .config_overrides(["core.configLockTimeout=0"]);
-        assert!(
-            matches!(
-                gix::config_mut(Source::System, &options),
-                Err(Error::AcquireLock(err))
-                    if err.downcast_any_ref::<gix::error::RetryableError>().is_some()
-                        && err.to_string().contains("immediately")
-            ),
-            "API overrides take precedence over CLI and disk values"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("API overrides take precedence over CLI and disk values");
+        assert!(err.can_retry(), "lock contention is retryable");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(temp.path()).to_string_lossy(), "<tmp>")]), "API overrides take precedence over CLI and disk values", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ The lock for resource '<tmp>/global.config' could not be obtained immediately after 1 attempt(s). The lockfile at '<tmp>/global.config.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<tmp>/global.config.lock"
+        "#);
         let options = options.filter_config_section(|meta| meta.source != Source::Api);
-        assert!(
-            matches!(gix::config_mut(Source::System, &options), Err(Error::LockTimeout(_))),
-            "section filtering exposes the invalid CLI timeout in strict mode"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("section filtering exposes the invalid CLI timeout in strict mode");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(temp.path()).to_string_lossy(), "<tmp>")]), "section filtering exposes the invalid CLI timeout in strict mode", @r#"
+        Invalid lock timeout, "key"="core.configLockTimeout"
+        |
+        └─ Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G, "input"="invalid"
+        "#);
         let options = options.strict_config(false);
-        assert!(
-            matches!(
-                gix::config_mut(Source::System, &options),
-                Err(Error::AcquireLock(err))
-                    if err.downcast_any_ref::<gix::error::RetryableError>().is_some()
-                        && err.to_string().contains("after 1.00s")
-            ),
-            "lenient invalid timeouts use the one-second default"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("lenient invalid timeouts use the one-second default");
+        assert!(err.can_retry(), "lock contention is retryable");
+        insta::with_settings!({ filters => vec![(r"after \d+ attempt\(s\)", "after <attempts> attempt(s)")] }, {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(temp.path()).to_string_lossy(), "<tmp>")]), "lenient invalid timeouts use the one-second default", @r#"
+            Could not acquire the lock for the configuration file
+            |
+            └─ The lock for resource '<tmp>/global.config' could not be obtained after 1.00s after <attempts> attempt(s). The lockfile at '<tmp>/global.config.lock' might need manual deletion.
+            |
+            └─ I/O error (AlreadyExists)
+            |
+            └─ AlreadyExists at path "<tmp>/global.config.lock"
+            "#);
+        });
 
         std::fs::write(
             &global_config_path,
@@ -554,20 +616,28 @@ mod config_mut {
             .system_config_path(&global_config_path)
             .strict_config(true);
         options.permissions.config.includes = true;
-        assert!(
-            matches!(
-                gix::config_mut(Source::System, &options),
-                Err(Error::AcquireLock(err))
-                    if err.downcast_any_ref::<gix::error::RetryableError>().is_some()
-                        && err.to_string().contains("immediately")
-            ),
-            "expanded global includes can supply the lock timeout"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("expanded global includes can supply the lock timeout");
+        assert!(err.can_retry(), "lock contention is retryable");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(temp.path()).to_string_lossy(), "<tmp>")]), "expanded global includes can supply the lock timeout", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ The lock for resource '<tmp>/global.config' could not be obtained immediately after 1 attempt(s). The lockfile at '<tmp>/global.config.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<tmp>/global.config.lock"
+        "#);
         options.permissions.config.includes = false;
-        assert!(
-            matches!(gix::config_mut(Source::System, &options), Err(Error::LockTimeout(_))),
-            "disabling includes exposes the invalid physical timeout"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("disabling includes exposes the invalid physical timeout");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(temp.path()).to_string_lossy(), "<tmp>")]), "disabling includes exposes the invalid physical timeout", @r#"
+        Invalid lock timeout, "key"="core.configLockTimeout"
+        |
+        └─ Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G, "input"="invalid"
+        "#);
         Ok(())
     }
 
@@ -634,13 +704,14 @@ mod config_mut {
             "editing preserves existing permissions"
         );
         let options = options.config_overrides(["core.sharedRepository=invalid"]);
-        assert!(
-            matches!(
-                gix::config_mut(Source::System, &options),
-                Err(Error::InvalidSharedRepository(_))
-            ),
-            "invalid sharing policies in overrides are rejected even for existing files"
-        );
+        let err = gix::config_mut(Source::System, &options)
+            .err()
+            .expect("invalid sharing policies in overrides are rejected even for existing files");
+        insta::assert_debug_snapshot!(err, "invalid sharing policies in overrides are rejected even for existing files", @r#"
+        Invalid configuration value, "input"="invalid", "key"="core.sharedRepository"
+        |
+        └─ Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid"
+        "#);
         Ok(())
     }
 
@@ -1259,6 +1330,52 @@ fn git_index_file_override_is_not_inherited_by_opened_submodules() -> gix_testto
     Ok(())
 }
 
+#[test]
+#[serial]
+#[cfg(feature = "attributes")]
+fn submodule_open_propagates_missing_environment_configuration() -> gix_testtools::Result {
+    let mut error_snapshots = Vec::new();
+    let fixture = gix_testtools::scripted_fixture_read_only("make_submodules.sh")?;
+    let _empty_config = gix_testtools::Env::new().set("GIT_CONFIG_COUNT", "0");
+    let mut options = gix::open::Options::isolated();
+    options.permissions.config.env = true;
+    let repo = gix::open_opts(fixture.join("with-submodules"), options)?;
+    let submodule = repo
+        .submodules()?
+        .expect("modules present")
+        .next()
+        .expect("one submodule");
+    assert!(submodule.open()?.is_some(), "the submodule is initialized");
+
+    for missing in ["GIT_CONFIG_KEY_0", "GIT_CONFIG_VALUE_0"] {
+        let _env = gix_testtools::Env::new()
+            .set("GIT_CONFIG_COUNT", "1")
+            .set("GIT_CONFIG_KEY_0", "core.key")
+            .set("GIT_CONFIG_VALUE_0", "value")
+            .unset(missing);
+        let err = submodule
+            .open()
+            .expect_err("invalid environment configuration does not make the repository absent");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        #[cfg(feature = "status")]
+        assert!(
+            submodule.status(gix::submodule::config::Ignore::None, false).is_err(),
+            "status must propagate the configuration failure as well"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "submodule open propagates missing environment configuration", @"
+    [
+        Repository configuration could not be loaded
+        |
+        └─ GIT_CONFIG_KEY_0 was not set,
+        Repository configuration could not be loaded
+        |
+        └─ GIT_CONFIG_VALUE_0 was not set,
+    ]
+    ");
+    Ok(())
+}
+
 #[test]
 #[serial]
 fn git_index_file_relative_paths_use_the_cwd_when_opening() -> gix_testtools::Result {
diff --git a/gix/tests/gix/clone.rs b/gix/tests/gix/clone.rs
index 755c1e54e68..cb6defbfdef 100644
--- a/gix/tests/gix/clone.rs
+++ b/gix/tests/gix/clone.rs
@@ -1,7 +1,9 @@
+use crate::Result;
 use crate::{remote, util::restricted};
 
 #[cfg(all(feature = "worktree-mutation", feature = "blocking-network-client"))]
 mod blocking_io {
+    use crate::Result;
     use std::{borrow::Cow, path::Path, sync::atomic::AtomicBool};
 
     use crate::{
@@ -11,6 +13,7 @@ mod blocking_io {
     use gix::{
         bstr::BString,
         config::tree::{Clone, Core, Init, Key},
+        error::ResultExt,
         refs::transaction::PreviousValue,
         remote::{
             Direction,
@@ -26,7 +29,7 @@ mod blocking_io {
 
     #[test]
     #[serial_test::serial]
-    fn inherited_core_symlinks_false_is_respected() -> crate::Result {
+    fn inherited_core_symlinks_false_is_respected() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         use gix_sec::Permission;
 
@@ -109,7 +112,7 @@ mod blocking_io {
         Ok(())
     }
 
-    fn shallow_ids(repo: &gix::Repository, expected: &'static str) -> crate::Result<Vec<gix::ObjectId>> {
+    fn shallow_ids(repo: &gix::Repository, expected: &'static str) -> Result<Vec<gix::ObjectId>> {
         let commits = repo.shallow_commits()?.expect(expected);
         // `gix_shallow::read` returns these sorted by id; the expected side is sorted via `sorted(...)`.
         Ok(std::iter::once(commits.head)
@@ -124,7 +127,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_shallow_no_checkout_then_unshallow() -> crate::Result {
+    fn fetch_shallow_no_checkout_then_unshallow() -> Result {
         // Local Git transport children read ambient config independently of repository options.
         // Process isolation keeps the shallow fetch and unshallow I/O off the shared serial lock.
         if gix_testtools::run_in_isolated_process()? {
@@ -146,7 +149,8 @@ mod blocking_io {
                             "+refs/tags/b-tag:refs/tags/b-tag".to_owned().into(),
                         ],
                         Direction::Fetch,
-                    )?;
+                    )
+                    .or_erased()?;
                     Ok(r)
                 }
             })
@@ -192,7 +196,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn shallow_clone_uses_single_branch_refspec() -> crate::Result {
+    fn shallow_clone_uses_single_branch_refspec() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -224,7 +228,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn shallow_clone_with_ambiguous_branch_and_tag_name_prefers_branch() -> crate::Result {
+    fn shallow_clone_with_ambiguous_branch_and_tag_name_prefers_branch() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -281,7 +285,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn from_shallow_prohibited_with_option() -> crate::Result {
+    fn from_shallow_prohibited_with_option() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -295,20 +299,19 @@ mod blocking_io {
         )?
         .fetch_only(gix::progress::Discard, &AtomicBool::default())
         .unwrap_err();
+        insta::assert_debug_snapshot!(err, "the configured rejection is a validation failure", @"Receiving objects from shallow remotes is prohibited due to the value of `clone.rejectShallow`");
+        assert!(err.is_validation(), "the configured rejection is a validation failure");
         assert!(
-            matches!(
-                err,
-                gix::clone::fetch::Error::Fetch(gix::remote::fetch::Error::Fetch(
-                    gix_protocol::fetch::Error::RejectShallowRemote
-                ))
-            ),
-            "we can avoid fetching from remotes with this setting"
+            err.classify()
+                .filter(|classification| classification.class() == gix_error::Class::Validation)
+                .any(|classification| classification.error().is::<gix_error::Message>()),
+            "the rejected shallow clone retains its typed validation cause"
         );
         Ok(())
     }
 
     #[test]
-    fn from_shallow_allowed_by_default() -> crate::Result {
+    fn from_shallow_allowed_by_default() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -340,7 +343,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn from_non_shallow_then_deepen_then_deepen_since_to_unshallow() -> crate::Result {
+    fn from_non_shallow_then_deepen_then_deepen_since_to_unshallow() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -348,7 +351,8 @@ mod blocking_io {
         let (repo, _change) = gix::prepare_clone_bare(remote::repo("base").path(), tmp.path())?
             .with_shallow(Shallow::DepthAtRemote(2.try_into()?))
             .configure_remote(|mut r| {
-                r.replace_refspecs(Some("refs/heads/main:refs/remotes/origin/main"), Direction::Fetch)?;
+                r.replace_refspecs(Some("refs/heads/main:refs/remotes/origin/main"), Direction::Fetch)
+                    .or_erased()?;
                 Ok(r)
             })
             .fetch_only(gix::progress::Discard, &AtomicBool::default())?;
@@ -406,7 +410,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn from_non_shallow_by_deepen_exclude_then_deepen_to_unshallow() -> crate::Result {
+    fn from_non_shallow_by_deepen_exclude_then_deepen_to_unshallow() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -450,7 +454,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_only_with_configuration() -> crate::Result {
+    fn fetch_only_with_configuration() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -475,7 +479,8 @@ mod blocking_io {
             move |r| {
                 called_configure_remote.store(true, std::sync::atomic::Ordering::Relaxed);
                 let r = r
-                    .with_refspecs(Some("+refs/tags/b-tag:refs/tags/b-tag"), gix::remote::Direction::Fetch)?
+                    .with_refspecs(Some("+refs/tags/b-tag:refs/tags/b-tag"), gix::remote::Direction::Fetch)
+                    .or_erased()?
                     .with_fetch_tags(desired_fetch_tags);
                 Ok(r)
             }
@@ -689,7 +694,7 @@ mod blocking_io {
         let lines = log
             .unwrap()
             .expect("log present")
-            .collect::<Result<Vec<_>, _>>()
+            .collect::<std::result::Result<Vec<_>, _>>()
             .unwrap();
         assert_eq!(lines.len(), 1, "just created");
         let line = &lines[0];
@@ -703,7 +708,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout() -> crate::Result {
+    fn fetch_and_checkout() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -727,7 +732,7 @@ mod blocking_io {
 
     #[test]
     #[cfg(unix)]
-    fn fetch_and_checkout_does_not_follow_delayed_symlink_prefixes() -> crate::Result {
+    fn fetch_and_checkout_does_not_follow_delayed_symlink_prefixes() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -765,7 +770,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_into_non_empty_directory() -> crate::Result {
+    fn fetch_and_checkout_into_non_empty_directory() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -796,7 +801,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_into_non_empty_directory_does_not_overwrite_pre_existing_tracked_file() -> crate::Result {
+    fn fetch_and_checkout_into_non_empty_directory_does_not_overwrite_pre_existing_tracked_file() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -840,7 +845,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_into_non_empty_directory_with_existing_dot_git_is_rejected() -> crate::Result {
+    fn fetch_and_checkout_into_non_empty_directory_with_existing_dot_git_is_rejected() -> Result {
         let fixture = gix_testtools::scripted_fixture_writable("make_clone_destinations.sh")?;
         let destination = fixture.path().join("non-empty-with-dot-git");
         let existing_path = destination.join("existing.txt");
@@ -859,22 +864,27 @@ mod blocking_io {
         )
         .map(drop)
         .expect_err("an existing .git directory must not be reused for clone");
-
-        assert!(
-            matches!(
-                err,
-                gix::clone::Error::Init(gix::init::Error::Init(gix::create::Error::DirectoryExists { ref path }))
-                    if *path == dot_git
-            ),
-            "unexpected error: {err}"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(fixture.path()).to_string_lossy(), "<fixture>")]), "fetch and checkout into non empty directory with existing dot git is rejected", @r#"
+        Message {
+            message: "Refusing to initialize an existing directory",
+            class: Validation,
+            values: {"input": Bytes("<fixture>/non-empty-with-dot-git/.git")},
+        }
+        "#);
+
+        assert!(matches!(
+            err.classify().filter(|classification| classification.class() == gix_error::Class::Validation)
+                .find_map(|classification| classification.error().downcast_ref::<gix_error::Message>()),
+            Some(gix_error::Message { values, .. })
+                if values.get("input") == Some(&gix_error::MetadataValue::Bytes(dot_git.to_string_lossy().as_bytes().into()))
+        ));
         assert_eq!(std::fs::read(&existing_path)?, EXISTING_CONTENT);
         assert_eq!(std::fs::read(&head_path)?, EXISTING_HEAD_CONTENT);
         Ok(())
     }
 
     #[test]
-    fn drop_after_failed_fetch_into_non_empty_directory_preserves_destination() -> crate::Result {
+    fn drop_after_failed_fetch_into_non_empty_directory_preserves_destination() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -912,7 +922,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_specific_ref() -> crate::Result {
+    fn fetch_and_checkout_specific_ref() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -960,7 +970,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_specific_revision() -> crate::Result {
+    fn fetch_and_checkout_specific_revision() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1012,7 +1022,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_specific_revision_bare_and_shallow() -> crate::Result {
+    fn fetch_specific_revision_bare_and_shallow() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1059,7 +1069,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn invalid_specific_revisions_are_rejected() -> crate::Result {
+    fn invalid_specific_revisions_are_rejected() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1088,10 +1098,13 @@ mod blocking_io {
         let err = missing
             .fetch_only(gix::progress::Discard, &AtomicBool::default())
             .expect_err("missing full references fail");
-        assert!(
-            matches!(err, gix::clone::fetch::Error::RevisionMissing { .. }),
-            "the missing revision is reported directly: {err}"
-        );
+        insta::assert_debug_snapshot!(err, "the missing revision is reported directly", @r#"
+        Message {
+            message: "The remote didn't have the requested revision \"refs/heads/does-not-exist\"",
+            class: NotFound,
+        }
+        "#);
+        assert!(err.is_not_found(), "the missing revision is reported directly: {err}");
 
         let tree_id = remote_repo
             .find_reference("refs/heads/a")?
@@ -1108,15 +1121,17 @@ mod blocking_io {
         let err = tree
             .fetch_only(gix::progress::Discard, &AtomicBool::default())
             .expect_err("tree revisions cannot become HEAD");
-        assert!(
-            matches!(err, gix::clone::fetch::Error::PeelRevision(_)),
-            "non-commit revisions are rejected: {err}"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&tree_id.to_string()[..7], "<tree-id>")]), "non-commit revisions cannot become HEAD", @"
+        The requested revision did not peel to a commit
+        |
+        └─ Last encountered object <tree-id> was tree while trying to peel to commit
+        ");
+        assert!(err.is_validation(), "non-commit revisions are rejected: {err}");
         Ok(())
     }
 
     #[test]
-    fn fetch_and_checkout_specific_non_existing() -> crate::Result {
+    fn fetch_and_checkout_specific_non_existing() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1135,16 +1150,17 @@ mod blocking_io {
         let err = prepare
             .fetch_then_checkout(gix::progress::Discard, &AtomicBool::default())
             .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "The remote didn't have any ref that matched 'does-not-exist'",
-            "we don't test this, but it's important that it determines this before receiving a pack"
-        );
+        insta::assert_debug_snapshot!(err, "we don't test this, but it's important that it determines this before receiving a pack", @r#"
+        Message {
+            message: "The remote didn't have any ref that matched 'does-not-exist'",
+            class: NotFound,
+        }
+        "#);
         Ok(())
     }
 
     #[test]
-    fn fetch_succeeds_despite_remote_head_ref() -> crate::Result {
+    fn fetch_retries_without_the_implicit_head_refspec_on_conflict() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1160,12 +1176,19 @@ mod blocking_io {
 
         let (mut checkout, _out) = prepare.fetch_then_checkout(gix::progress::Discard, &AtomicBool::default())?;
         let (repo, _) = checkout.main_worktree(gix::progress::Discard, &AtomicBool::default())?;
-        assert!(repo.head().is_ok(), "we could handle the HEAD normaller");
+        assert!(
+            repo.head().is_ok(),
+            "the clone completed after recovering from the conflict"
+        );
+        assert!(
+            repo.try_find_reference("refs/remotes/origin/HEAD")?.is_some(),
+            "retrying without the implicit refspec still fetches the remote branch named HEAD"
+        );
         Ok(())
     }
 
     #[test]
-    fn fetch_and_checkout_specific_annotated_tag() -> crate::Result {
+    fn fetch_and_checkout_specific_annotated_tag() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1233,7 +1256,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_and_checkout_empty_remote_repo() -> crate::Result {
+    fn fetch_and_checkout_empty_remote_repo() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1285,7 +1308,7 @@ mod blocking_io {
     }
 
     #[test]
-    fn fetch_only_without_configuration() -> crate::Result {
+    fn fetch_only_without_configuration() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -1313,7 +1336,7 @@ mod blocking_io {
 
     #[test]
     #[cfg(feature = "sha256")]
-    fn fetch_only_adopts_remote_sha256_object_format() -> crate::Result {
+    fn fetch_only_adopts_remote_sha256_object_format() -> Result {
         let remote = gix_testtools::scripted_fixture_read_only("make_sha256_remote.sh")?.join("remote");
         assert_eq!(
             gix::open_opts(&remote, gix::open::Options::isolated())?.object_hash(),
@@ -1361,7 +1384,7 @@ mod blocking_io {
 }
 
 #[test]
-fn clone_and_early_persist_without_receive() -> crate::Result {
+fn clone_and_early_persist_without_receive() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let repo = gix::clone::PrepareFetch::new(
         remote::repo("base").path(),
@@ -1377,7 +1400,8 @@ fn clone_and_early_persist_without_receive() -> crate::Result {
 }
 
 #[test]
-fn clone_and_destination_must_be_empty() -> crate::Result {
+fn clone_and_destination_must_be_empty() -> Result {
+    let mut error_snapshots = Vec::new();
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     std::fs::write(tmp.path().join("file"), b"hello")?;
     match gix::clone::PrepareFetch::new(
@@ -1388,16 +1412,37 @@ fn clone_and_destination_must_be_empty() -> crate::Result {
         restricted(),
     ) {
         Ok(_) => unreachable!("this should fail as the directory isn't empty"),
-        Err(err) => assert!(
-            err.to_string()
-                .starts_with("Refusing to initialize the non-empty directory as ")
-        ),
+        Err(err) => {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(tmp.path()).to_string_lossy(), "<destination>")],
+            ));
+            assert!(err.is_validation());
+            let validation = err
+                .classify()
+                .filter(|classification| classification.class() == gix_error::Class::Validation)
+                .find_map(|classification| classification.error().downcast_ref::<gix::error::Message>())
+                .expect("the non-empty destination remains a classified validation failure");
+            assert!(
+                validation.values.contains_key("input"),
+                "the rejected destination is retained"
+            );
+        }
     }
+    insta::assert_debug_snapshot!(error_snapshots, "clone and destination must be empty", @r#"
+    [
+        Message {
+            message: "Refusing to initialize the non-empty directory as",
+            class: Validation,
+            values: {"input": Bytes("<destination>")},
+        },
+    ]
+    "#);
     Ok(())
 }
 
 #[test]
-fn clone_with_worktree_and_destination_must_be_empty() -> crate::Result {
+fn clone_with_worktree_and_destination_must_be_empty() -> Result {
     let fixture = gix_testtools::scripted_fixture_writable("make_clone_destinations.sh")?;
     let destination = fixture.path().join("non-empty");
     let err = gix::clone::PrepareFetch::new(
@@ -1409,15 +1454,28 @@ fn clone_with_worktree_and_destination_must_be_empty() -> crate::Result {
     )
     .map(drop)
     .expect_err("this should fail as the directory isn't empty");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(fixture.path()).to_string_lossy(), "<fixture>")]), "clone with worktree and destination must be empty", @r#"
+    Message {
+        message: "Refusing to initialize the non-empty directory as",
+        class: Validation,
+        values: {"input": Bytes("<fixture>/non-empty")},
+    }
+    "#);
+    assert!(err.is_validation());
+    let validation = err
+        .classify()
+        .filter(|classification| classification.class() == gix_error::Class::Validation)
+        .find_map(|classification| classification.error().downcast_ref::<gix::error::Message>())
+        .expect("the non-empty destination remains a classified validation failure");
     assert!(
-        err.to_string()
-            .starts_with("Refusing to initialize the non-empty directory as ")
+        validation.values.contains_key("input"),
+        "the rejected destination is retained"
     );
     Ok(())
 }
 
 #[test]
-fn clone_bare_into_empty_directory_and_early_drop() -> crate::Result {
+fn clone_bare_into_empty_directory_and_early_drop() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     // this breaks isolation, but shouldn't be affecting the test. If so, use isolation options for opening the repo.
     let prep = gix::clone::PrepareFetch::new(
@@ -1436,7 +1494,7 @@ fn clone_bare_into_empty_directory_and_early_drop() -> crate::Result {
 }
 
 #[test]
-fn clone_into_empty_directory_and_early_drop() -> crate::Result {
+fn clone_into_empty_directory_and_early_drop() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
     let prep = gix::clone::PrepareFetch::new(
         remote::repo("base").path(),
diff --git a/gix/tests/gix/commit.rs b/gix/tests/gix/commit.rs
index 3fb06f48724..476f6374031 100644
--- a/gix/tests/gix/commit.rs
+++ b/gix/tests/gix/commit.rs
@@ -1,17 +1,19 @@
 #[cfg(feature = "revision")]
 mod describe {
+    use crate::Result;
     use gix::commit::describe::SelectRef::{AllRefs, AllTags, AnnotatedTags};
 
     use crate::named_repo;
 
     #[cfg(feature = "status")]
     mod with_dirty_suffix {
+        use crate::Result;
         use gix::commit::describe::SelectRef;
 
         use crate::util::named_subrepo_opts;
 
         #[test]
-        fn dirty_suffix_applies_automatically_if_dirty() -> crate::Result {
+        fn dirty_suffix_applies_automatically_if_dirty() -> Result {
             let repo = named_subrepo_opts(
                 "make_submodules.sh",
                 "submodule-head-changed",
@@ -31,7 +33,7 @@ mod describe {
         }
 
         #[test]
-        fn dirty_suffix_does_not_apply_if_not_dirty() -> crate::Result {
+        fn dirty_suffix_does_not_apply_if_not_dirty() -> Result {
             let repo = named_subrepo_opts("make_submodules.sh", "module1", gix::open::Options::isolated())?;
 
             let actual = repo
@@ -48,7 +50,7 @@ mod describe {
     }
 
     #[test]
-    fn tags_are_sorted_by_date_and_lexicographically() -> crate::Result {
+    fn tags_are_sorted_by_date_and_lexicographically() -> Result {
         let repo = named_repo("make_commit_describe_multiple_tags.sh")?;
         let mut describe = repo.head_commit()?.describe();
         for filter in &[AnnotatedTags, AllTags, AllRefs] {
@@ -59,7 +61,7 @@ mod describe {
     }
 
     #[test]
-    fn tags_are_sorted_by_priority() -> crate::Result {
+    fn tags_are_sorted_by_priority() -> Result {
         let repo = named_repo("make_commit_describe_multiple_tags.sh")?;
         let commit = repo.find_reference("refs/tags/v0")?.id().object()?.into_commit();
         let mut describe = commit.describe();
@@ -71,7 +73,7 @@ mod describe {
     }
 
     #[test]
-    fn lightweight_tags_are_sorted_lexicographically() -> crate::Result {
+    fn lightweight_tags_are_sorted_lexicographically() -> Result {
         let repo = named_repo("make_commit_describe_multiple_tags.sh")?;
         let commit = repo.find_reference("refs/tags/l0")?.id().object()?.into_commit();
         let mut describe = commit.describe();
@@ -90,6 +92,7 @@ mod describe {
 
 #[cfg(feature = "command")]
 mod signature {
+    use crate::Result;
     use gix::config::tree::{Gpg, Key, User, gpg};
     use gix_testtools::signature;
     use serial_test::serial;
@@ -99,7 +102,7 @@ mod signature {
     // `fatal: invalid date format: 42 +0030` while creating the reference signature.
     #[serial]
     #[cfg_attr(windows, ignore = "TODO: requires direct investigation on Windows")]
-    fn verifies_a_commit_signed_by_git_with_ssh() -> crate::Result {
+    fn verifies_a_commit_signed_by_git_with_ssh() -> Result {
         if !signature::program_available("ssh-keygen") {
             return Ok(());
         }
@@ -144,7 +147,7 @@ mod signature {
     }
 
     #[test]
-    fn sign_write_and_verify_an_ssh_commit() -> crate::Result {
+    fn sign_write_and_verify_an_ssh_commit() -> Result {
         let (_key_home, key) = signature::ssh_private_key()?;
         let options = gix::open::Options::isolated().config_overrides([
             User::NAME.validated_assignment_fmt(&"Gitoxide Signing Fixture")?,
@@ -189,7 +192,7 @@ mod signature {
     }
 
     #[test]
-    fn resolves_format_defaults_and_program_paths() -> crate::Result {
+    fn resolves_format_defaults_and_program_paths() -> Result {
         let home = gix::path::env::home_dir().expect("the test environment has a home directory");
         let mut permissions = gix::open::Permissions::isolated();
         permissions.env.home = gix::sec::Permission::Allow;
@@ -212,7 +215,7 @@ mod signature {
     }
 
     #[test]
-    fn expands_verification_program_paths() -> crate::Result {
+    fn expands_verification_program_paths() -> Result {
         let home = gix::path::env::home_dir().expect("the test environment has a home directory");
         let mut permissions = gix::open::Permissions::isolated();
         permissions.env.home = gix::sec::Permission::Allow;
@@ -232,20 +235,18 @@ mod signature {
             .find_commit(id)?
             .verify_signature()
             .expect_err("the configured verifier does not exist");
-        let gix::commit::verify::Error::Verify(gix_object::signature::verify::Error::Spawn { program, .. }) = err
-        else {
-            panic!("expected a verifier spawn failure, got {err:?}");
-        };
-        assert_eq!(
-            program,
-            home.join("bin/missing-gpg"),
-            "the configured verifier path is expanded relative to home"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(home).to_string_lossy(), "<home>")]), "the configured verifier path is expanded relative to home", @r#"
+        Could not verify the commit signature
+        |
+        └─ Could not execute signature verifier "<home>/bin/missing-gpg"
+        |
+        └─ NotFound
+        "#);
         Ok(())
     }
 
     #[test]
-    fn resolves_signing_options_only_when_enabled() -> crate::Result {
+    fn resolves_signing_options_only_when_enabled() -> Result {
         let disabled = gix::open_opts(
             gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")?,
             gix::open::Options::isolated().config_overrides(["gpg.format=invalid"]),
@@ -272,7 +273,7 @@ mod signature {
 
     #[cfg(unix)]
     #[test]
-    fn resolves_the_default_ssh_key_command() -> crate::Result {
+    fn resolves_the_default_ssh_key_command() -> Result {
         let options = gix::open::Options::isolated().config_overrides([
             "user.name=Gitoxide Signing Fixture",
             "user.email=signing@example.com",
diff --git a/gix/tests/gix/config/file_mut.rs b/gix/tests/gix/config/file_mut.rs
index 29f4c376088..52dbf133a0e 100644
--- a/gix/tests/gix/config/file_mut.rs
+++ b/gix/tests/gix/config/file_mut.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use crate::repository::config::config_snapshot::options_with_includes;
 use crate::{named_repo, repo_rw_opts};
 use std::io::Write;
 
 #[test]
-fn locks_and_edits_one_physical_file_until_explicit_reload() -> crate::Result {
+fn locks_and_edits_one_physical_file_until_explicit_reload() -> Result {
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options_with_includes())?;
     let git_config_path = repo.git_dir().join("config");
     let target_path = repo.workdir().expect("worktree repository").join("a.config");
@@ -34,11 +35,25 @@ leading = value
 
     repo.config_snapshot_mut().set_raw_value("memory.value", "transient")?;
     let mut file = repo.config_file_mut(&target_path)?;
-    match repo.config_file_mut(&target_path) {
-        Err(gix::config::file_mut::Error::AcquireLock(_)) => {}
-        Err(err) => panic!("lock contention must be reported precisely: {err:?}"),
+    let err = match repo.config_file_mut(&target_path) {
+        Err(err) => err,
         Ok(_) => panic!("a second transaction must not acquire the same lock"),
-    }
+    };
+    insta::with_settings!({ filters => vec![(r"after \d+ attempt\(s\)", "after <attempts> attempt(s)")] }, {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(_tmp.path()).to_string_lossy(), "<repo>")]), "lock contention must be reported as retryable: {err:?}", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ The lock for resource '<repo>/a.config' could not be obtained after 1.00s after <attempts> attempt(s). The lockfile at '<repo>/a.config.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<repo>/a.config.lock"
+        "#);
+    });
+    assert!(
+        err.can_retry(),
+        "lock contention must be reported as retryable: {err:?}"
+    );
     file.set_raw_value("a.local-override", "written")?;
     file.commit()?;
 
@@ -88,7 +103,7 @@ leading = value
 }
 
 #[test]
-fn honors_core_config_lock_timeout() -> crate::Result {
+fn honors_core_config_lock_timeout() -> Result {
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", gix::open::Options::isolated())?;
     let config_path = repo.git_dir().join("config");
     let mut lock_path = config_path.as_os_str().to_owned();
@@ -113,22 +128,24 @@ fn honors_core_config_lock_timeout() -> crate::Result {
         Err(err) => err,
     };
     std::fs::remove_file(lock_path)?;
-    let gix::config::file_mut::Error::AcquireLock(err) = err else {
-        panic!("a held lock must cause a lock-acquisition error")
-    };
-    assert!(
-        err.downcast_any_ref::<gix::error::RetryableError>().is_some(),
-        "lock contention is retryable"
-    );
     assert!(
-        err.to_string().contains("immediately"),
-        "the configured zero timeout must be retained in the error"
+        err.can_retry(),
+        "lock contention must be reported as retryable: {err:?}"
     );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(_tmp.path()).to_string_lossy(), "<repo>")]), "the configured zero timeout must be retained in the error", @r#"
+    Could not acquire the lock for the configuration file
+    |
+    └─ The lock for resource '<repo>/.git/config' could not be obtained immediately after 1 attempt(s). The lockfile at '<repo>/.git/config.lock' might need manual deletion.
+    |
+    └─ I/O error (AlreadyExists)
+    |
+    └─ AlreadyExists at path "<repo>/.git/config.lock"
+    "#);
     Ok(())
 }
 
 #[test]
-fn preserves_permissions() -> crate::Result {
+fn preserves_permissions() -> Result {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
@@ -169,7 +186,7 @@ fn preserves_permissions() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn follows_symlinked_configuration_files() -> crate::Result {
+fn follows_symlinked_configuration_files() -> Result {
     use std::os::unix::fs::symlink;
 
     let repo = named_repo("make_basic_repo.sh")?;
@@ -185,11 +202,22 @@ fn follows_symlinked_configuration_files() -> crate::Result {
     symlink("target.config", &link)?;
 
     let mut file = repo.config_file_mut(&link)?;
-    match repo.config_file_mut(&target) {
-        Err(gix::config::file_mut::Error::AcquireLock(_)) => {}
-        Err(err) => panic!("the target must report lock contention: {err:?}"),
+    let err = match repo.config_file_mut(&target) {
+        Err(err) => err,
         Ok(_) => panic!("the symlink and its target must use the same lock"),
-    }
+    };
+    insta::with_settings!({ filters => vec![(r"after \d+ attempt\(s\)", "after <attempts> attempt(s)")] }, {
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(dir.path()).to_string_lossy(), "<tmp>")]), "the target must report lock contention: {err:?}", @r#"
+        Could not acquire the lock for the configuration file
+        |
+        └─ The lock for resource '<tmp>/target.config' could not be obtained after 1.00s after <attempts> attempt(s). The lockfile at '<tmp>/target.config.lock' might need manual deletion.
+        |
+        └─ I/O error (AlreadyExists)
+        |
+        └─ AlreadyExists at path "<tmp>/target.config.lock"
+        "#);
+    });
+    assert!(err.can_retry(), "the target must report lock contention: {err:?}");
     file.set_raw_value("core.abbrev", "8")?;
     file.commit()?;
 
@@ -207,7 +235,7 @@ fn follows_symlinked_configuration_files() -> crate::Result {
 }
 
 #[test]
-fn supports_empty_and_missing_files() -> crate::Result {
+fn supports_empty_and_missing_files() -> Result {
     let repo = named_repo("make_basic_repo.sh")?;
     let dir = gix_testtools::tempfile::tempdir()?;
     let empty = dir.path().join("empty.config");
@@ -233,7 +261,7 @@ fn supports_empty_and_missing_files() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn applies_shared_repository_permissions_to_new_files() -> crate::Result {
+fn applies_shared_repository_permissions_to_new_files() -> Result {
     use std::os::unix::fs::PermissionsExt;
 
     let mut repo = named_repo("make_basic_repo.sh")?;
@@ -254,7 +282,7 @@ fn applies_shared_repository_permissions_to_new_files() -> crate::Result {
 }
 
 #[test]
-fn semantic_validation_happens_on_reload() -> crate::Result {
+fn semantic_validation_happens_on_reload() -> Result {
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options_with_includes().strict_config(true))?;
     let original_format_version = repo.config_snapshot().integer("core.repositoryFormatVersion");
     let config_path = repo.git_dir().join("config");
@@ -268,13 +296,13 @@ fn semantic_validation_happens_on_reload() -> crate::Result {
         Ok(_) => panic!("the persisted repository format must be rejected while reopening"),
         Err(err) => err,
     };
-    assert!(
-        matches!(
-            err,
-            gix::open::Error::Config(gix::config::Error::UnsupportedRepositoryFormatVersion { version: 2 })
-        ),
-        "reload reports the semantic error: {err:?}"
-    );
+    assert!(err.is_validation(), "reload reports the semantic error: {err:?}");
+    insta::assert_debug_snapshot!(err.probable_cause(), "semantic validation happens on reload", @r#"
+    Message {
+        message: "Unsupported repository format version 2; only versions 0 and 1 are supported",
+        class: Validation,
+    }
+    "#);
     assert_eq!(
         repo.config_snapshot().integer("core.repositoryFormatVersion"),
         original_format_version,
@@ -284,7 +312,7 @@ fn semantic_validation_happens_on_reload() -> crate::Result {
 }
 
 #[test]
-fn include_changes_take_effect_only_after_reload() -> crate::Result {
+fn include_changes_take_effect_only_after_reload() -> Result {
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options_with_includes())?;
     let replacement_path = repo.workdir().expect("worktree repository").join("replacement.config");
     std::fs::write(
@@ -314,7 +342,7 @@ value = visible
 
 #[test]
 #[cfg(unix)]
-fn paths_with_parent_components_retain_symlink_semantics() -> crate::Result {
+fn paths_with_parent_components_retain_symlink_semantics() -> Result {
     use std::os::unix::fs::symlink;
 
     let repo = named_repo("make_basic_repo.sh")?;
diff --git a/gix/tests/gix/config/key.rs b/gix/tests/gix/config/key.rs
new file mode 100644
index 00000000000..e80c88342a9
--- /dev/null
+++ b/gix/tests/gix/config/key.rs
@@ -0,0 +1,143 @@
+use gix::{
+    bstr::ByteSlice,
+    config::tree::{Core, Http, keys},
+};
+use gix_error::MetadataValue;
+
+pub(super) fn assert_config_error(
+    error: &gix::Error,
+    key: &str,
+    input: Option<MetadataValue>,
+    environment: Option<&str>,
+) {
+    assert!(
+        error.is_validation(),
+        "invalid configuration is classified as validation"
+    );
+    let metadata = error.metadata().next().expect("a configuration error has metadata");
+    assert_eq!(
+        metadata.get("key"),
+        Some(&MetadataValue::from(key)),
+        "the context identifies the key"
+    );
+    assert_eq!(
+        metadata.get("input"),
+        input.as_ref(),
+        "the context retains the available input"
+    );
+    assert_eq!(
+        metadata.get("environment_override"),
+        environment.map(MetadataValue::from).as_ref(),
+        "the context identifies the possible environment override"
+    );
+}
+
+#[test]
+fn integer_metadata_and_cause_survive_wrapping() {
+    let err: gix::Error = Core::DELTA_BASE_CACHE_LIMIT
+        .try_into_usize(Ok(Some(-1)))
+        .expect_err("negative values cannot be cache sizes");
+    assert!(err.is_validation(), "invalid configuration is classified as validation");
+    assert!(
+        err.downcast_any_ref::<std::num::TryFromIntError>().is_some(),
+        "the integer conversion error remains available"
+    );
+    let metadata = err
+        .metadata()
+        .find(|metadata| metadata.contains_key("key"))
+        .expect("the configuration context exposes its key as metadata");
+    assert_eq!(metadata["key"], MetadataValue::from("core.deltaBaseCacheLimit"));
+    assert_eq!(
+        metadata["input"],
+        MetadataValue::I64(-1),
+        "parsed numbers retain their type"
+    );
+    assert_eq!(
+        metadata["environment_override"],
+        MetadataValue::from("GIX_PACK_CACHE_MEMORY")
+    );
+}
+
+#[test]
+fn string_metadata_preserves_invalid_bytes_and_cause() {
+    let input = b"\xF0\x80\x80".as_bstr();
+    let err: gix::Error = Http::USER_AGENT
+        .try_into_string(input)
+        .expect_err("overlong UTF-8 is rejected");
+    assert!(err.is_validation(), "invalid configuration is classified as validation");
+    assert!(
+        err.downcast_any_ref::<gix::bstr::Utf8Error>().is_some(),
+        "the UTF-8 conversion error remains available"
+    );
+    let metadata = err
+        .metadata()
+        .find(|metadata| metadata.contains_key("key"))
+        .expect("the configuration context exposes its key as metadata");
+    assert_eq!(metadata["key"], MetadataValue::from("http.userAgent"));
+    assert_eq!(
+        metadata["input"],
+        MetadataValue::from(input),
+        "input bytes are not decoded lossily"
+    );
+    assert!(
+        !metadata.contains_key("environment_override"),
+        "keys without an environment override omit it"
+    );
+}
+
+#[test]
+fn boolean_parser_metadata_remains_in_its_own_context() {
+    let input = b"bogus".as_bstr();
+    let error = Core::BARE
+        .enrich_error(gix::config::Boolean::try_from(input).map(|boolean| Some(boolean.0)))
+        .expect_err("the value is not a boolean");
+    assert_config_error(&error, "core.bare", None, None);
+    let source = error
+        .metadata()
+        .nth(1)
+        .expect("the parser retains its own input context");
+    assert_eq!(source.get("input"), Some(&MetadataValue::from(input)));
+    assert!(!source.contains_key("key"), "contexts are not merged across causes");
+}
+
+#[test]
+fn date_conversion_retains_key_metadata() {
+    let error = keys::Time::new_time("date", &gix::config::tree::Author)
+        .with_environment_override("GIT_AUTHOR_DATE")
+        .try_into_time("not a date", None)
+        .expect_err("the date is invalid")
+        .into_error();
+    assert_config_error(
+        &error,
+        "author.date",
+        Some(b"not a date".as_bstr().into()),
+        Some("GIT_AUTHOR_DATE"),
+    );
+    assert!(
+        error.metadata().count() > 1,
+        "the date parser's context remains available"
+    );
+}
+
+#[cfg(any(
+    feature = "blocking-http-transport-reqwest",
+    feature = "blocking-http-transport-curl"
+))]
+#[test]
+fn http_callback_can_return_a_concrete_cause() {
+    use gix_error::ErrorExt;
+
+    let error = Http::FOLLOW_REDIRECTS
+        .try_into_follow_redirects("bad", || {
+            Err(std::io::Error::from(std::io::ErrorKind::TimedOut).raise_erased())
+        })
+        .expect_err("callback failures are propagated");
+    assert_config_error(&error, "http.followRedirects", Some(b"bad".as_bstr().into()), None);
+    assert_eq!(
+        error
+            .downcast_any_ref::<std::io::Error>()
+            .expect("the callback's concrete cause is retained")
+            .kind(),
+        std::io::ErrorKind::TimedOut
+    );
+}
diff --git a/gix/tests/gix/config/mod.rs b/gix/tests/gix/config/mod.rs
index 88184dc8448..341deda7c0b 100644
--- a/gix/tests/gix/config/mod.rs
+++ b/gix/tests/gix/config/mod.rs
@@ -1,2 +1,3 @@
 mod file_mut;
+mod key;
 mod tree;
diff --git a/gix/tests/gix/config/tree.rs b/gix/tests/gix/config/tree.rs
index 83ce08fe319..b59fd905a22 100644
--- a/gix/tests/gix/config/tree.rs
+++ b/gix/tests/gix/config/tree.rs
@@ -1,19 +1,26 @@
+fn config_value_error(message: &'static str, input: &'static str) -> gix_error::Exn<gix_error::Message> {
+    use gix_error::ErrorExt;
+    gix_error::validation(message).with("input", input.as_bytes()).raise()
+}
+
 mod keys {
+    use crate::Result;
     use gix::config::tree::{Key, Section};
     use gix_object::bstr::{BStr, ByteSlice};
 
     #[test]
-    fn string() -> crate::Result {
+    fn string() -> Result {
         assert_eq!(gix::config::tree::Http::USER_AGENT.try_into_string("agent")?, "agent");
         assert!(gix::config::tree::Http::USER_AGENT.validate("agent".into()).is_ok());
 
         let invalid = b"\xF0\x80\x80".as_bstr();
-        assert_eq!(
-            gix::config::tree::Http::USER_AGENT
+        crate::config::key::assert_config_error(
+            &gix::config::tree::Http::USER_AGENT
                 .try_into_string(invalid)
-                .unwrap_err()
-                .to_string(),
-            "The utf-8 string at \"http.userAgent=���\" could not be decoded"
+                .expect_err("invalid configuration"),
+            "http.userAgent",
+            Some(b"\xF0\x80\x80".as_slice().into()),
+            None,
         );
         assert!(gix::config::tree::Http::USER_AGENT.validate(invalid).is_err());
 
@@ -93,6 +100,8 @@ mod keys {
 
     #[test]
     fn unsigned_integer() {
+        let mut diagnostics = Vec::new();
+        let mut error_snapshots = Vec::new();
         for valid in [0, 1, 100_124] {
             assert!(
                 gix::config::tree::Core::DELTA_BASE_CACHE_LIMIT
@@ -102,23 +111,58 @@ mod keys {
         }
 
         for invalid in [-1, -100] {
-            assert_eq!(
-                gix::config::tree::Core::DELTA_BASE_CACHE_LIMIT
-                    .validate(invalid.to_string().as_str().into())
-                    .unwrap_err()
-                    .to_string(),
-                "cannot use sign for unsigned integer"
+            let err = gix::config::tree::Core::DELTA_BASE_CACHE_LIMIT
+                .validate(invalid.to_string().as_str().into())
+                .expect_err("negative values are not unsigned");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            diagnostics.push(gix_testtools::redact_debug_snapshot(&err, &[]));
+            assert!(
+                err.downcast_any_ref::<std::num::TryFromIntError>().is_some(),
+                "the signed-to-unsigned conversion failure remains available"
             );
+            assert!(err.is_validation());
         }
 
         let out_of_bounds = ((i64::MAX as u64) + 1).to_string();
-        assert_eq!(
-            gix::config::tree::Core::DELTA_BASE_CACHE_LIMIT
-                .validate(out_of_bounds.as_bytes().into())
-                .unwrap_err()
-                .to_string(),
-            "Could not decode '9223372036854775808': Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G"
-        );
+        let err = gix::config::tree::Core::DELTA_BASE_CACHE_LIMIT
+            .validate(out_of_bounds.as_bytes().into())
+            .expect_err("the value is larger than the config integer range");
+        insta::assert_debug_snapshot!(err.probable_cause(), "unsigned integer", @r#"
+        Message {
+            message: "Integers needs to be positive or negative numbers which may have a suffix like 1k, 42, or 50G",
+            class: Validation,
+            values: {"input": Bytes("9223372036854775808")},
+        }
+        "#);
+        assert!(err.is_validation());
+        insta::assert_debug_snapshot!(error_snapshots, "unsigned integer", @r#"
+        [
+            Invalid configuration value, "environment_override"="GIX_PACK_CACHE_MEMORY", "input"="-1", "key"="core.deltaBaseCacheLimit"
+            |
+            └─ unsigned integer is out of range, "input"="-1"
+            |
+            └─ out of range integral type conversion attempted,
+            Invalid configuration value, "environment_override"="GIX_PACK_CACHE_MEMORY", "input"="-100", "key"="core.deltaBaseCacheLimit"
+            |
+            └─ unsigned integer is out of range, "input"="-100"
+            |
+            └─ out of range integral type conversion attempted,
+        ]
+        "#);
+        insta::assert_debug_snapshot!(diagnostics, "unsigned integer", @r#"
+        [
+            Invalid configuration value, "environment_override"="GIX_PACK_CACHE_MEMORY", "input"="-1", "key"="core.deltaBaseCacheLimit"
+            |
+            └─ unsigned integer is out of range, "input"="-1"
+            |
+            └─ out of range integral type conversion attempted,
+            Invalid configuration value, "environment_override"="GIX_PACK_CACHE_MEMORY", "input"="-100", "key"="core.deltaBaseCacheLimit"
+            |
+            └─ unsigned integer is out of range, "input"="-100"
+            |
+            └─ out of range integral type conversion attempted,
+        ]
+        "#);
     }
 }
 
@@ -195,10 +239,11 @@ mod branch {
 }
 
 mod ssh {
-
+    #[cfg(feature = "blocking-network-client")]
+    use crate::Result;
     #[test]
     #[cfg(feature = "blocking-network-client")]
-    fn variant() -> crate::Result {
+    fn variant() -> Result {
         use gix::config::tree::Ssh;
         use gix_protocol::transport::client::blocking_io::ssh::ProgramKind;
 
@@ -213,10 +258,11 @@ mod ssh {
             assert_eq!(Ssh::VARIANT.try_into_variant(actual)?, expected);
         }
 
-        assert_eq!(
-            Ssh::VARIANT.try_into_variant("SSH").unwrap_err().to_string(),
-            "The key \"ssh.variant=SSH\" (possibly from GIT_SSH_VARIANT) was invalid",
-            "case-sensitive comparisons"
+        crate::config::key::assert_config_error(
+            &Ssh::VARIANT.try_into_variant("SSH").expect_err("invalid configuration"),
+            "ssh.variant",
+            Some("SSH".as_bytes().into()),
+            Some("GIT_SSH_VARIANT"),
         );
         Ok(())
     }
@@ -224,10 +270,11 @@ mod ssh {
 
 #[cfg(feature = "status")]
 mod status {
+    use crate::Result;
     use gix::{config::tree::Status, status::UntrackedFiles};
 
     #[test]
-    fn default() -> crate::Result {
+    fn default() -> Result {
         for (actual, expected) in [
             ("no", UntrackedFiles::None),
             ("normal", UntrackedFiles::Collapsed),
@@ -239,23 +286,24 @@ mod status {
             );
         }
 
-        assert_eq!(
-            Status::SHOW_UNTRACKED_FILES
+        crate::config::key::assert_config_error(
+            &Status::SHOW_UNTRACKED_FILES
                 .try_into_show_untracked_files("NO")
-                .unwrap_err()
-                .to_string(),
-            "The key \"status.showUntrackedFiles=NO\" was invalid",
-            "case-sensitive comparisons"
+                .expect_err("invalid configuration"),
+            "status.showUntrackedFiles",
+            Some("NO".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 }
 
 mod push {
+    use crate::Result;
     use gix::{config::tree::Push, push};
 
     #[test]
-    fn default() -> crate::Result {
+    fn default() -> Result {
         for (actual, expected) in [
             ("nothing", push::Default::Nothing),
             ("current", push::Default::Current),
@@ -267,10 +315,13 @@ mod push {
             assert_eq!(Push::DEFAULT.try_into_default(actual)?, expected);
         }
 
-        assert_eq!(
-            Push::DEFAULT.try_into_default("Nothing").unwrap_err().to_string(),
-            "The key \"push.default=Nothing\" was invalid",
-            "case-sensitive comparisons"
+        crate::config::key::assert_config_error(
+            &Push::DEFAULT
+                .try_into_default("Nothing")
+                .expect_err("invalid configuration"),
+            "push.default",
+            Some("Nothing".as_bytes().into()),
+            None,
         );
         Ok(())
     }
@@ -278,9 +329,10 @@ mod push {
 
 mod fetch {
 
+    use crate::Result;
     #[test]
     #[cfg(feature = "credentials")]
-    fn algorithm() -> crate::Result {
+    fn algorithm() -> Result {
         use gix::{
             config::tree::{Fetch, Key},
             remote::fetch::negotiate::Algorithm,
@@ -298,19 +350,20 @@ mod fetch {
             );
             assert!(Fetch::NEGOTIATION_ALGORITHM.validate(actual.into()).is_ok());
         }
-        assert_eq!(
-            Fetch::NEGOTIATION_ALGORITHM
+        crate::config::key::assert_config_error(
+            &Fetch::NEGOTIATION_ALGORITHM
                 .try_into_negotiation_algorithm("foo")
-                .unwrap_err()
-                .to_string(),
-            "The key \"fetch.negotiationAlgorithm=foo\" was invalid"
+                .expect_err("invalid configuration"),
+            "fetch.negotiationAlgorithm",
+            Some("foo".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
     #[cfg(feature = "attributes")]
-    fn recurse_submodule() -> crate::Result {
+    fn recurse_submodule() -> Result {
         use gix::{
             bstr::ByteSlice,
             config::tree::{Fetch, Key},
@@ -329,12 +382,13 @@ mod fetch {
             );
             assert!(Fetch::RECURSE_SUBMODULES.validate(actual.into()).is_ok());
         }
-        assert_eq!(
-            Fetch::RECURSE_SUBMODULES
+        crate::config::key::assert_config_error(
+            &Fetch::RECURSE_SUBMODULES
                 .try_into_recurse_submodules(gix_config::Boolean::try_from(b"foo".as_bstr()).map(|b| Some(b.0)))
-                .unwrap_err()
-                .to_string(),
-            "The key \"fetch.recurseSubmodules=foo\" was invalid"
+                .expect_err("invalid configuration"),
+            "fetch.recurseSubmodules",
+            Some("foo".as_bytes().into()),
+            None,
         );
         Ok(())
     }
@@ -342,6 +396,7 @@ mod fetch {
 
 #[cfg(feature = "blob-diff")]
 mod diff {
+    use crate::Result;
     use gix::{
         config::tree::{Diff, Key},
         diff::rename::Tracking,
@@ -349,7 +404,7 @@ mod diff {
     use gix_diff::blob::Algorithm;
 
     #[test]
-    fn renames() -> crate::Result {
+    fn renames() -> Result {
         assert_eq!(Diff::RENAMES.try_into_renames(Ok(Some(true)))?, Some(Tracking::Renames));
         assert!(Diff::RENAMES.validate("1".into()).is_ok());
         assert_eq!(
@@ -358,28 +413,51 @@ mod diff {
         );
         assert!(Diff::RENAMES.validate("0".into()).is_ok());
         assert_eq!(
-            Diff::RENAMES.try_into_renames(Err(gix_config::value::Error::new("err", "copy")))?,
+            Diff::RENAMES.try_into_renames(Err(crate::config::tree::config_value_error("err", "copy")))?,
             Some(Tracking::RenamesAndCopies)
         );
         assert!(Diff::RENAMES.validate("copy".into()).is_ok());
         assert_eq!(
-            Diff::RENAMES.try_into_renames(Err(gix_config::value::Error::new("err", "copies")))?,
+            Diff::RENAMES.try_into_renames(Err(crate::config::tree::config_value_error("err", "copies")))?,
             Some(Tracking::RenamesAndCopies)
         );
         assert!(Diff::RENAMES.validate("copies".into()).is_ok());
 
-        assert_eq!(
-            Diff::RENAMES
-                .try_into_renames(Err(gix_config::value::Error::new("err", "foo")))
-                .unwrap_err()
-                .to_string(),
-            "The value of key \"diff.renames=foo\" was invalid"
+        crate::config::key::assert_config_error(
+            &Diff::RENAMES
+                .try_into_renames(Err(crate::config::tree::config_value_error("err", "foo")))
+                .expect_err("invalid configuration"),
+            "diff.renames",
+            Some("foo".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
-    fn driver_binary() -> crate::Result {
+    fn renames_preserves_other_errors() {
+        use gix_error::{ErrorExt, message};
+
+        for context in [message("caller error"), message("caller error").with("input", "copy")] {
+            let expected = context.to_string();
+            let source = std::io::Error::from(std::io::ErrorKind::PermissionDenied);
+            let err = Diff::RENAMES
+                .try_into_renames(Err(source.and_raise(context)))
+                .expect_err("caller errors without byte input are propagated");
+            assert_eq!(
+                err.error().to_string(),
+                expected,
+                "the caller's context and metadata are preserved"
+            );
+            assert!(
+                err.downcast_any_ref::<std::io::Error>().is_some(),
+                "the caller's original cause is preserved"
+            );
+        }
+    }
+
+    #[test]
+    fn driver_binary() -> Result {
         assert_eq!(
             Diff::DRIVER_BINARY.try_into_binary(Some("auto"))?,
             None,
@@ -398,19 +476,20 @@ mod diff {
             }
         }
 
-        assert_eq!(
-            Diff::DRIVER_BINARY
+        crate::config::key::assert_config_error(
+            &Diff::DRIVER_BINARY
                 .try_into_binary(Some("something"))
-                .unwrap_err()
-                .to_string(),
-            "The key \"diff.<driver>.binary=something\" was invalid",
+                .expect_err("invalid configuration"),
+            "diff.<driver>.binary",
+            Some("something".as_bytes().into()),
+            None,
         );
         assert!(Diff::DRIVER_BINARY.validate("foo".into()).is_err());
         Ok(())
     }
 
     #[test]
-    fn algorithm() -> crate::Result {
+    fn algorithm() -> Result {
         for (actual, expected) in [
             ("myers", Algorithm::Myers),
             ("Myers", Algorithm::Myers),
@@ -422,25 +501,28 @@ mod diff {
             assert_eq!(Diff::ALGORITHM.try_into_algorithm(actual)?, expected);
             assert!(Diff::ALGORITHM.validate(actual.into()).is_ok());
         }
-        assert_eq!(
-            Diff::ALGORITHM.try_into_algorithm("patience").unwrap_err().to_string(),
-            "The 'patience' algorithm is not yet implemented"
-        );
-        assert_eq!(
-            Diff::ALGORITHM.try_into_algorithm("foo").unwrap_err().to_string(),
-            "Unknown diff algorithm named 'foo'"
-        );
+        insta::assert_debug_snapshot!(Diff::ALGORITHM.try_into_algorithm("patience").expect_err("algorithm"), "algorithm", @r#"
+        Unimplemented {
+            name: "patience",
+        }
+        "#);
+        insta::assert_debug_snapshot!(Diff::ALGORITHM.try_into_algorithm("foo").expect_err("algorithm"), "algorithm", @r#"
+        Unknown {
+            name: "foo",
+        }
+        "#);
         Ok(())
     }
 }
 
 #[cfg(feature = "merge")]
 mod merge {
+    use crate::Result;
     use gix::config::tree::{Key, Merge};
     use gix_merge::blob::builtin_driver::text::ConflictStyle;
 
     #[test]
-    fn conflict_style() -> crate::Result {
+    fn conflict_style() -> Result {
         for (actual, expected) in [
             ("merge", ConflictStyle::Merge),
             ("diff3", ConflictStyle::Diff3),
@@ -449,24 +531,28 @@ mod merge {
             assert_eq!(Merge::CONFLICT_STYLE.try_into_conflict_style(actual)?, expected);
             assert!(Merge::CONFLICT_STYLE.validate(actual.into()).is_ok());
         }
-        assert_eq!(
-            Merge::CONFLICT_STYLE
+        crate::config::key::assert_config_error(
+            &Merge::CONFLICT_STYLE
                 .try_into_conflict_style("foo")
-                .unwrap_err()
-                .to_string(),
-            "The key \"merge.conflictStyle=foo\" was invalid"
+                .expect_err("invalid configuration"),
+            "merge.conflictStyle",
+            Some("foo".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 }
 
 mod core {
+    use crate::Result;
     use std::time::Duration;
 
+    use gix_error::ExnMessageResult;
+
     use gix::config::tree::{Core, Key};
     use gix_lock::acquire::Fail;
 
-    fn signed(value: i64) -> Result<Option<i64>, gix_config::value::Error> {
+    fn signed(value: i64) -> ExnMessageResult<Option<i64>> {
         Ok(Some(value))
     }
 
@@ -487,7 +573,7 @@ mod core {
     }
 
     #[test]
-    fn shared_repository() -> crate::Result {
+    fn shared_repository() -> Result {
         for (value, expected) in [
             (None, 0o660),
             (Some("umask"), 0),
@@ -513,12 +599,13 @@ mod core {
         }
 
         for value in ["0400", "invalid"] {
-            assert_eq!(
-                Core::SHARED_REPOSITORY
+            crate::config::key::assert_config_error(
+                &Core::SHARED_REPOSITORY
                     .try_into_shared_repository(Some(value))
-                    .unwrap_err()
-                    .to_string(),
-                format!("The key \"core.sharedRepository={value}\" was invalid")
+                    .expect_err("invalid configuration"),
+                "core.sharedRepository",
+                Some(value.as_bytes().into()),
+                None,
             );
             assert!(Core::SHARED_REPOSITORY.validate(value.into()).is_err());
         }
@@ -526,7 +613,7 @@ mod core {
     }
 
     #[test]
-    fn timeouts() -> crate::Result {
+    fn timeouts() -> Result {
         assert_eq!(
             Core::FILES_REF_LOCK_TIMEOUT.try_into_lock_timeout(Ok(Some(0)))?,
             Some(Fail::Immediately)
@@ -543,19 +630,20 @@ mod core {
             Some(Fail::AfterDurationWithBackoff(Duration::from_millis(2500)))
         );
         assert!(Core::FILES_REF_LOCK_TIMEOUT.validate("2500".into()).is_ok());
-        assert_eq!(
-            Core::FILES_REF_LOCK_TIMEOUT
-                .try_into_lock_timeout(Err(gix_config::value::Error::new("err", "bogus")))
-                .unwrap_err()
-                .to_string(),
-            "The timeout at key \"core.filesRefLockTimeout\" was invalid"
+        crate::config::key::assert_config_error(
+            &Core::FILES_REF_LOCK_TIMEOUT
+                .try_into_lock_timeout(Err(crate::config::tree::config_value_error("err", "bogus")))
+                .expect_err("invalid configuration"),
+            "core.filesRefLockTimeout",
+            None,
+            None,
         );
         Ok(())
     }
 
     #[test]
     #[cfg(feature = "revision")]
-    fn disambiguate() -> crate::Result {
+    fn disambiguate() -> Result {
         use gix::revision::spec::parse::ObjectKindHint;
         for (value, expected) in [
             ("none", None),
@@ -568,18 +656,19 @@ mod core {
             assert_eq!(Core::DISAMBIGUATE.try_into_object_kind_hint(value).unwrap(), expected);
             assert!(Core::DISAMBIGUATE.validate(value.into()).is_ok());
         }
-        assert_eq!(
-            Core::DISAMBIGUATE
+        crate::config::key::assert_config_error(
+            &Core::DISAMBIGUATE
                 .try_into_object_kind_hint("CommiT")
-                .unwrap_err()
-                .to_string(),
-            "The key \"core.disambiguate=CommiT\" was invalid"
+                .expect_err("invalid configuration"),
+            "core.disambiguate",
+            Some("CommiT".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
-    fn log_all_ref_updates() -> crate::Result {
+    fn log_all_ref_updates() -> Result {
         assert_eq!(
             Core::LOG_ALL_REF_UPDATES.try_into_ref_updates(Ok(Some(true)))?,
             Some(gix_ref::store::WriteReflog::Normal)
@@ -596,19 +685,52 @@ mod core {
             Some(gix_ref::store::WriteReflog::Always)
         );
         assert!(Core::LOG_ALL_REF_UPDATES.validate("always".into()).is_ok());
-        assert_eq!(
-            Core::LOG_ALL_REF_UPDATES
+        crate::config::key::assert_config_error(
+            &Core::LOG_ALL_REF_UPDATES
                 .try_into_ref_updates(boolean("invalid"))
-                .unwrap_err()
-                .to_string(),
-            "The key \"core.logAllRefUpdates=invalid\" was invalid"
+                .expect_err("invalid configuration"),
+            "core.logAllRefUpdates",
+            Some("invalid".as_bytes().into()),
+            None,
         );
-        assert!(Core::LOG_ALL_REF_UPDATES.validate("invalid".into()).is_err());
+        let err = Core::LOG_ALL_REF_UPDATES
+            .validate("invalid".into())
+            .expect_err("the value is neither a boolean nor 'always'");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "log all ref updates", @r#"
+        Invalid configuration value, "input"="invalid", "key"="core.logAllRefUpdates"
+        |
+        └─ Invalid configuration value, "input"="invalid", "key"="core.logAllRefUpdates"
+        |
+        └─ Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid"
+        "#);
+        assert!(err.is_validation());
         Ok(())
     }
 
     #[test]
-    fn abbrev() -> crate::Result {
+    fn log_all_ref_updates_preserves_other_errors() {
+        use gix_error::{ErrorExt, message};
+
+        for context in [message("caller error"), message("caller error").with("input", "always")] {
+            let expected = context.to_string();
+            let source = std::io::Error::from(std::io::ErrorKind::PermissionDenied);
+            let err = Core::LOG_ALL_REF_UPDATES
+                .try_into_ref_updates(Err(source.and_raise(context)))
+                .expect_err("caller errors without byte input are propagated");
+            assert_eq!(
+                err.error().to_string(),
+                expected,
+                "the caller's context and metadata are preserved"
+            );
+            assert!(
+                err.downcast_any_ref::<std::io::Error>().is_some(),
+                "the caller's original cause is preserved"
+            );
+        }
+    }
+
+    #[test]
+    fn abbrev() -> Result {
         let object_hash = gix_hash::Kind::Sha1;
         assert_eq!(Core::ABBREV.try_into_abbreviation("4", object_hash)?, Some(4));
         assert_eq!(Core::ABBREV.try_into_abbreviation("auto", object_hash)?, None);
@@ -623,13 +745,14 @@ mod core {
             "turns abbreviations off entirely"
         );
 
-        assert_eq!(
-            Core::ABBREV
+        insta::assert_debug_snapshot!(Core::ABBREV
                 .try_into_abbreviation("   ", object_hash)
-                .unwrap_err()
-                .to_string(),
-            "Invalid value for 'core.abbrev' = '   '. It must be between 4 and 40"
-        );
+                .expect_err("abbrev"), "abbrev", @r#"
+        Message {
+            message: "Invalid value for 'core.abbrev' = '   '. It must be between 4 and 40",
+            class: Validation,
+        }
+        "#);
         for invalid in ["foo", "3", "41"] {
             assert!(Core::ABBREV.try_into_abbreviation(invalid, object_hash).is_err());
         }
@@ -637,29 +760,34 @@ mod core {
     }
 
     #[test]
-    fn delta_base_cache_limit() -> crate::Result {
+    fn delta_base_cache_limit() -> Result {
         assert_eq!(Core::DELTA_BASE_CACHE_LIMIT.try_into_usize(signed(1))?, Some(1));
         assert_eq!(Core::DELTA_BASE_CACHE_LIMIT.try_into_usize(signed(0))?, Some(0));
         assert!(Core::DELTA_BASE_CACHE_LIMIT.validate("0".into()).is_ok());
         assert!(Core::DELTA_BASE_CACHE_LIMIT.validate("1".into()).is_ok());
-        assert_eq!(
-            Core::DELTA_BASE_CACHE_LIMIT
+        crate::config::key::assert_config_error(
+            &Core::DELTA_BASE_CACHE_LIMIT
                 .try_into_usize(signed(-1))
-                .unwrap_err()
-                .to_string(),
-            "The value of key \"core.deltaBaseCacheLimit\" (possibly from GIX_PACK_CACHE_MEMORY) could not be parsed as unsigned integer"
+                .expect_err("invalid configuration"),
+            "core.deltaBaseCacheLimit",
+            Some((-1_i64).into()),
+            Some("GIX_PACK_CACHE_MEMORY"),
         );
         assert!(Core::DELTA_BASE_CACHE_LIMIT.validate("-1".into()).is_err());
         Ok(())
     }
 
     #[test]
-    fn check_stat() -> crate::Result {
+    fn check_stat() -> Result {
         assert!(Core::CHECK_STAT.try_into_checkstat("default")?);
         assert!(!Core::CHECK_STAT.try_into_checkstat("minimal")?);
-        assert_eq!(
-            Core::CHECK_STAT.try_into_checkstat("normal").unwrap_err().to_string(),
-            "The key \"core.checkStat=normal\" was invalid"
+        crate::config::key::assert_config_error(
+            &Core::CHECK_STAT
+                .try_into_checkstat("normal")
+                .expect_err("invalid configuration"),
+            "core.checkStat",
+            Some("normal".as_bytes().into()),
+            None,
         );
 
         assert!(Core::CHECK_STAT.validate("default".into()).is_ok());
@@ -670,7 +798,7 @@ mod core {
 
     #[test]
     #[cfg(feature = "attributes")]
-    fn safecrlf() -> crate::Result {
+    fn safecrlf() -> Result {
         for (value, expected) in [
             ("false", gix_filter::pipeline::CrlfRoundTripCheck::Skip),
             ("true", gix_filter::pipeline::CrlfRoundTripCheck::Fail),
@@ -679,16 +807,20 @@ mod core {
             assert_eq!(Core::SAFE_CRLF.try_into_safecrlf(value).unwrap(), expected);
             assert!(Core::SAFE_CRLF.validate(value.into()).is_ok());
         }
-        assert_eq!(
-            Core::SAFE_CRLF.try_into_safecrlf("WARN").unwrap_err().to_string(),
-            "The key \"core.safecrlf=WARN\" was invalid"
+        crate::config::key::assert_config_error(
+            &Core::SAFE_CRLF
+                .try_into_safecrlf("WARN")
+                .expect_err("invalid configuration"),
+            "core.safecrlf",
+            Some("WARN".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
     #[cfg(feature = "attributes")]
-    fn autocrlf() -> crate::Result {
+    fn autocrlf() -> Result {
         for (value, expected) in [
             ("false", gix_filter::eol::AutoCrlf::Disabled),
             ("true", gix_filter::eol::AutoCrlf::Enabled),
@@ -697,16 +829,20 @@ mod core {
             assert_eq!(Core::AUTO_CRLF.try_into_autocrlf(value).unwrap(), expected);
             assert!(Core::AUTO_CRLF.validate(value.into()).is_ok());
         }
-        assert_eq!(
-            Core::AUTO_CRLF.try_into_autocrlf("Input").unwrap_err().to_string(),
-            "The key \"core.autocrlf=Input\" was invalid"
+        crate::config::key::assert_config_error(
+            &Core::AUTO_CRLF
+                .try_into_autocrlf("Input")
+                .expect_err("invalid configuration"),
+            "core.autocrlf",
+            Some("Input".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
     #[cfg(feature = "attributes")]
-    fn eol() -> crate::Result {
+    fn eol() -> Result {
         for (value, expected) in [
             ("lf", gix_filter::eol::Mode::Lf),
             ("crlf", gix_filter::eol::Mode::CrLf),
@@ -715,16 +851,18 @@ mod core {
             assert_eq!(Core::EOL.try_into_eol(value).unwrap(), expected);
             assert!(Core::EOL.validate(value.into()).is_ok());
         }
-        assert_eq!(
-            Core::EOL.try_into_eol("LF").unwrap_err().to_string(),
-            "The key \"core.eol=LF\" was invalid"
+        crate::config::key::assert_config_error(
+            &Core::EOL.try_into_eol("LF").expect_err("invalid configuration"),
+            "core.eol",
+            Some("LF".as_bytes().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
     #[cfg(feature = "attributes")]
-    fn check_round_trip_encoding() -> crate::Result {
+    fn check_round_trip_encoding() -> Result {
         for (value, expected) in [
             (
                 Some("UTF-8 utf-16BE"),
@@ -748,13 +886,14 @@ mod core {
                 assert!(Core::CHECK_ROUND_TRIP_ENCODING.validate(value.into()).is_ok());
             }
         }
-        assert_eq!(
-            Core::CHECK_ROUND_TRIP_ENCODING
+        insta::assert_debug_snapshot!(Core::CHECK_ROUND_TRIP_ENCODING
                 .try_into_encodings(Some("SOMETHING ELSE"))
-                .unwrap_err()
-                .to_string(),
-            "The encoding named 'SOMETHING' seen in key 'core.checkRoundTripEncoding=SOMETHING ELSE' is unsupported"
-        );
+                .expect_err("check round trip encoding"), "check round trip encoding", @r#"
+        Message {
+            message: "The encoding named 'SOMETHING' seen in key 'core.checkRoundTripEncoding=SOMETHING ELSE' is unsupported",
+            class: Validation,
+        }
+        "#);
         Ok(())
     }
 }
@@ -772,21 +911,23 @@ mod index {
             );
             assert!(Index::THREADS.validate(value.into()).is_ok());
         }
-        assert_eq!(
-            Index::THREADS
+        crate::config::key::assert_config_error(
+            &Index::THREADS
                 .try_into_index_threads("nothing")
-                .unwrap_err()
-                .to_string(),
-            "The key \"index.threads=nothing\" was invalid"
+                .expect_err("invalid configuration"),
+            "index.threads",
+            Some("nothing".as_bytes().into()),
+            None,
         );
     }
 }
 
 mod extensions {
+    use crate::Result;
     use gix::config::tree::{Extensions, Key};
 
     #[test]
-    fn object_format() -> crate::Result {
+    fn object_format() -> Result {
         #[cfg(feature = "sha1")]
         {
             assert_eq!(
@@ -813,12 +954,13 @@ mod extensions {
             );
             assert!(Extensions::OBJECT_FORMAT.validate("sha256".into()).is_ok());
         }
-        assert_eq!(
-            Extensions::OBJECT_FORMAT
+        crate::config::key::assert_config_error(
+            &Extensions::OBJECT_FORMAT
                 .try_into_object_format("invalid")
-                .unwrap_err()
-                .to_string(),
-            "The key \"extensions.objectFormat=invalid\" was invalid"
+                .expect_err("invalid configuration"),
+            "extensions.objectFormat",
+            Some("invalid".as_bytes().into()),
+            None,
         );
         assert!(Extensions::OBJECT_FORMAT.validate("invalid".into()).is_err());
         Ok(())
@@ -826,14 +968,16 @@ mod extensions {
 }
 
 mod checkout {
+    use crate::Result;
     use gix::config::tree::{Checkout, Key};
+    use gix_error::ExnMessageResult;
 
-    fn int(value: i64) -> Result<Option<i64>, gix_config::value::Error> {
+    fn int(value: i64) -> ExnMessageResult<Option<i64>> {
         Ok(Some(value))
     }
 
     #[test]
-    fn workers() -> crate::Result {
+    fn workers() -> Result {
         assert!(Checkout::WORKERS.validate("0".into()).is_ok());
         assert_eq!(Checkout::WORKERS.try_from_workers(int(0))?, Some(0));
         assert!(Checkout::WORKERS.validate("-1".into()).is_ok());
@@ -846,10 +990,11 @@ mod checkout {
 }
 
 mod pack {
+    use crate::Result;
     use gix::config::tree::{Key, Pack};
 
     #[test]
-    fn index_version() -> crate::Result {
+    fn index_version() -> Result {
         assert_eq!(
             Pack::INDEX_VERSION.try_into_index_version(Ok(Some(1)))?,
             Some(gix_pack::index::Version::V1)
@@ -865,12 +1010,13 @@ mod pack {
             None,
             "an unset key remains distinguishable from an explicitly configured version"
         );
-        assert_eq!(
-            Pack::INDEX_VERSION
+        crate::config::key::assert_config_error(
+            &Pack::INDEX_VERSION
                 .try_into_index_version(Ok(Some(3)))
-                .unwrap_err()
-                .to_string(),
-            "The value of key \"pack.indexVersion\" was invalid"
+                .expect_err("invalid configuration"),
+            "pack.indexVersion",
+            Some(3_i64.into()),
+            None,
         );
         assert!(Pack::INDEX_VERSION.validate("3".into()).is_err());
         assert!(Pack::INDEX_VERSION.validate("-1".into()).is_err());
@@ -879,11 +1025,14 @@ mod pack {
 }
 
 mod protocol {
+    #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
+    use crate::Result;
     use gix::config::tree::{Key, Protocol};
 
     #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
     #[test]
-    fn allow() -> crate::Result {
+    fn allow() -> Result {
+        let mut error_snapshots = Vec::new();
         use gix::{config::tree::protocol, remote::url::scheme_permission::Allow};
 
         for (key, protocol_name_parameter) in [
@@ -898,17 +1047,23 @@ mod protocol {
                 assert_eq!(key.try_into_allow(input, protocol_name_parameter)?, expected);
                 assert!(key.validate(input.into()).is_ok());
             }
-            assert_eq!(
-                key.try_into_allow("User", protocol_name_parameter)
-                    .unwrap_err()
-                    .to_string(),
-                format!(
-                    "The value \"User\" must be allow|deny|user in configuration key {}",
-                    protocol_name_parameter
-                        .map_or_else(|| "protocol.allow".into(), |key| format!("protocol.{key}.allow"))
-                )
-            );
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(key.try_into_allow("User", protocol_name_parameter).unwrap_err()),
+                &[],
+            ));
         }
+        insta::assert_debug_snapshot!(error_snapshots, "allow", @r#"
+        [
+            Message {
+                message: "The value \"User\" must be allow|deny|user in configuration key protocol.allow",
+                class: Validation,
+            },
+            Message {
+                message: "The value \"User\" must be allow|deny|user in configuration key protocol.http.allow",
+                class: Validation,
+            },
+        ]
+        "#);
         Ok(())
     }
 
@@ -918,10 +1073,15 @@ mod protocol {
             assert!(Protocol::VERSION.validate(valid.to_string().as_str().into()).is_ok());
         }
 
-        assert_eq!(
-            Protocol::VERSION.validate("5".into()).unwrap_err().to_string(),
-            "protocol version 5 is unknown"
-        );
+        let err = Protocol::VERSION
+            .validate("5".into())
+            .expect_err("protocol version 5 is unsupported");
+        insta::assert_debug_snapshot!(err.probable_cause(), "version", @r#"
+        Message {
+            message: "protocol version 5 is unknown",
+        }
+        "#);
+        assert!(err.is_validation());
 
         #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
         {
@@ -939,12 +1099,13 @@ mod protocol {
                 );
             }
 
-            assert_eq!(
-                Protocol::VERSION
+            crate::config::key::assert_config_error(
+                &Protocol::VERSION
                     .try_into_protocol_version(Ok(Some(5)))
-                    .unwrap_err()
-                    .to_string(),
-                "The key \"protocol.version=5\" was invalid"
+                    .expect_err("invalid configuration"),
+                "protocol.version",
+                Some(5_i64.into()),
+                None,
             );
         }
     }
@@ -1004,6 +1165,7 @@ mod gpg {
 }
 
 mod notes {
+    use crate::Result;
     use gix::config::tree::{Key, Notes};
     use gix_object::bstr::BString;
 
@@ -1018,7 +1180,7 @@ mod notes {
     }
 
     #[test]
-    fn display_ref_parsing() -> crate::Result {
+    fn display_ref_parsing() -> Result {
         assert_eq!(
             Notes::DISPLAY_REF.try_into_display_refs(":refs/notes/review::refs/notes/*:")?,
             vec![BString::from("refs/notes/review"), BString::from("refs/notes/*")],
@@ -1053,12 +1215,13 @@ mod notes {
 
 mod gitoxide {
     mod http {
+        use crate::Result;
         use std::time::Duration;
 
         use gix::config::tree::{Key, gitoxide};
 
         #[test]
-        fn connect_timeout() -> crate::Result {
+        fn connect_timeout() -> Result {
             assert_eq!(
                 gitoxide::Http::CONNECT_TIMEOUT.validated_assignment_fmt(&Duration::from_secs(1).as_millis())?,
                 "gitoxide.http.connectTimeout=1000"
@@ -1138,10 +1301,11 @@ mod gitoxide {
         }
     }
     mod objects {
+        use crate::Result;
         use gix::config::tree::{Key, gitoxide};
 
         #[test]
-        fn alloc_limit() -> crate::Result {
+        fn alloc_limit() -> Result {
             assert_eq!(
                 gitoxide::Objects::ALLOC_LIMIT.validated_assignment("16m".into())?,
                 "gitoxide.objects.allocLimit=16m"
@@ -1150,7 +1314,7 @@ mod gitoxide {
         }
 
         #[test]
-        fn alloc_limit_if_reduced_trust() -> crate::Result {
+        fn alloc_limit_if_reduced_trust() -> Result {
             assert_eq!(
                 gitoxide::Objects::ALLOC_LIMIT_IF_REDUCED_TRUST.validated_assignment("16m".into())?,
                 "gitoxide.objects.allocLimitIfReducedTrust=16m"
@@ -1165,11 +1329,12 @@ mod gitoxide {
     feature = "blocking-http-transport-curl"
 ))]
 mod http {
+    use crate::Result;
     use gix::config::tree::{Http, Key};
     use gix_object::bstr::ByteSlice;
 
     #[test]
-    fn follow_redirects() -> crate::Result {
+    fn follow_redirects() -> Result {
         use gix_transport::client::blocking_io::http::options::FollowRedirects;
         assert_eq!(
             Http::FOLLOW_REDIRECTS.try_into_follow_redirects("initial", || unreachable!("no call"))?,
@@ -1188,19 +1353,22 @@ mod http {
             assert!(Http::FOLLOW_REDIRECTS.validate(actual.into()).is_ok());
         }
 
-        assert_eq!(
-            Http::FOLLOW_REDIRECTS
-                .try_into_follow_redirects("something", || Err(gix_config::value::Error::new("invalid", "value")))
-                .unwrap_err()
-                .to_string(),
-            "The key \"http.followRedirects=something\" was invalid",
+        crate::config::key::assert_config_error(
+            &Http::FOLLOW_REDIRECTS
+                .try_into_follow_redirects("something", || {
+                    Err(crate::config::tree::config_value_error("invalid", "value").erased())
+                })
+                .expect_err("invalid configuration"),
+            "http.followRedirects",
+            Some("something".as_bytes().into()),
+            None,
         );
         assert!(Http::FOLLOW_REDIRECTS.validate("foo".into()).is_err());
         Ok(())
     }
 
     #[test]
-    fn extra_header() -> crate::Result {
+    fn extra_header() -> Result {
         assert_eq!(Http::EXTRA_HEADER.try_into_extra_header(vec!["a", "b"])?, ["a", "b"]);
         assert_eq!(
             Http::EXTRA_HEADER.try_into_extra_header(vec!["a", "b", "", "c", "d"])?,
@@ -1211,18 +1379,19 @@ mod http {
 
         let invalid = b"\xF0\x80\x80";
         assert!(Http::EXTRA_HEADER.validate(invalid.as_bstr()).is_err());
-        assert_eq!(
-            Http::EXTRA_HEADER
+        crate::config::key::assert_config_error(
+            &Http::EXTRA_HEADER
                 .try_into_extra_header(vec![invalid.as_bstr()])
-                .unwrap_err()
-                .to_string(),
-            "The utf-8 string at \"http.extraHeader=���\" could not be decoded"
+                .expect_err("invalid configuration"),
+            "http.extraHeader",
+            Some(b"\xF0\x80\x80".as_slice().into()),
+            None,
         );
         Ok(())
     }
 
     #[test]
-    fn http_version() -> crate::Result {
+    fn http_version() -> Result {
         use gix_transport::client::blocking_io::http::options::HttpVersion;
 
         for (actual, expected) in [("HTTP/1.1", HttpVersion::V1_1), ("HTTP/2", HttpVersion::V2)] {
@@ -1230,16 +1399,20 @@ mod http {
             assert!(Http::VERSION.validate(actual.into()).is_ok());
         }
 
-        assert_eq!(
-            Http::VERSION.try_into_http_version("invalid").unwrap_err().to_string(),
-            "The key \"http.version=invalid\" was invalid"
+        crate::config::key::assert_config_error(
+            &Http::VERSION
+                .try_into_http_version("invalid")
+                .expect_err("invalid configuration"),
+            "http.version",
+            Some("invalid".as_bytes().into()),
+            None,
         );
         assert!(Http::VERSION.validate("invalid".into()).is_err());
         Ok(())
     }
 
     #[test]
-    fn ssl_version() -> crate::Result {
+    fn ssl_version() -> Result {
         use gix_transport::client::blocking_io::http::options::SslVersion::*;
 
         for (actual, expected) in [
@@ -1257,19 +1430,20 @@ mod http {
             assert!(Http::SSL_VERSION.validate(actual.into()).is_ok());
         }
 
-        assert_eq!(
-            Http::SSL_VERSION
+        crate::config::key::assert_config_error(
+            &Http::SSL_VERSION
                 .try_into_ssl_version("invalid")
-                .unwrap_err()
-                .to_string(),
-            "The ssl version at \"http.sslVersion=invalid\" (possibly from GIT_SSL_VERSION) was invalid"
+                .expect_err("invalid configuration"),
+            "http.sslVersion",
+            Some("invalid".as_bytes().into()),
+            Some("GIT_SSL_VERSION"),
         );
         assert!(Http::SSL_VERSION.validate("invalid".into()).is_err());
         Ok(())
     }
 
     #[test]
-    fn proxy_auth_method() -> crate::Result {
+    fn proxy_auth_method() -> Result {
         use gix_transport::client::blocking_io::http::options::ProxyAuthMethod::*;
         for (actual, expected) in [
             ("anyauth", AnyAuth),
@@ -1282,12 +1456,13 @@ mod http {
             assert!(Http::PROXY_AUTH_METHOD.validate(actual.into()).is_ok());
         }
 
-        assert_eq!(
-            Http::PROXY_AUTH_METHOD
+        crate::config::key::assert_config_error(
+            &Http::PROXY_AUTH_METHOD
                 .try_into_proxy_auth_method("invalid")
-                .unwrap_err()
-                .to_string(),
-            "The key \"http.proxyAuthMethod=invalid\" was invalid"
+                .expect_err("invalid configuration"),
+            "http.proxyAuthMethod",
+            Some("invalid".as_bytes().into()),
+            None,
         );
         assert!(Http::PROXY_AUTH_METHOD.validate("invalid".into()).is_err());
         Ok(())
@@ -1295,13 +1470,14 @@ mod http {
 }
 
 mod remote {
+    use crate::Result;
     use gix::{
         config::tree::{Key, Remote},
         remote,
     };
 
     #[test]
-    fn tag_opt() -> crate::Result {
+    fn tag_opt() -> Result {
         assert_eq!(Remote::TAG_OPT.try_into_tag_opt("--tags")?, remote::fetch::Tags::All);
         assert!(Remote::TAG_OPT.validate("--tags".into()).is_ok());
         assert_eq!(
@@ -1310,9 +1486,13 @@ mod remote {
         );
         assert!(Remote::TAG_OPT.validate("--no-tags".into()).is_ok());
 
-        assert_eq!(
-            Remote::TAG_OPT.try_into_tag_opt("--unknown").unwrap_err().to_string(),
-            "The key \"remote.<name>.tagOpt=--unknown\" was invalid"
+        crate::config::key::assert_config_error(
+            &Remote::TAG_OPT
+                .try_into_tag_opt("--unknown")
+                .expect_err("invalid configuration"),
+            "remote.<name>.tagOpt",
+            Some("--unknown".as_bytes().into()),
+            None,
         );
         Ok(())
     }
@@ -1322,9 +1502,11 @@ mod remote {
         assert!(Remote::URL.try_into_url("http://example.org").is_ok());
         assert!(Remote::URL.validate("http://example.org".into()).is_ok());
 
-        assert_eq!(
-            Remote::URL.try_into_url("https://").unwrap_err().to_string(),
-            "The url at \"remote.<name>.url=https://\" could not be parsed"
+        crate::config::key::assert_config_error(
+            &Remote::URL.try_into_url("https://").expect_err("invalid configuration"),
+            "remote.<name>.url",
+            Some("https://".as_bytes().into()),
+            None,
         );
         assert!(Remote::URL.validate("http://".into()).is_err());
     }
@@ -1347,19 +1529,21 @@ mod remote {
         );
         assert!(Remote::PUSH.validate(push_spec.into()).is_ok());
 
-        assert_eq!(
-            Remote::FETCH
+        crate::config::key::assert_config_error(
+            &Remote::FETCH
                 .try_into_refspec("*/*/*:refs/heads/*", gix_refspec::parse::Operation::Fetch)
-                .unwrap_err()
-                .to_string(),
-            "The refspec at \"remote.<name>.fetch=*/*/*:refs/heads/*\" could not be parsed"
+                .expect_err("invalid configuration"),
+            "remote.<name>.fetch",
+            Some("*/*/*:refs/heads/*".as_bytes().into()),
+            None,
         );
-        assert_eq!(
-            Remote::PUSH
+        crate::config::key::assert_config_error(
+            &Remote::PUSH
                 .try_into_refspec("*/*/*:refs/heads/*", gix_refspec::parse::Operation::Push)
-                .unwrap_err()
-                .to_string(),
-            "The refspec at \"remote.<name>.push=*/*/*:refs/heads/*\" could not be parsed"
+                .expect_err("invalid configuration"),
+            "remote.<name>.push",
+            Some("*/*/*:refs/heads/*".as_bytes().into()),
+            None,
         );
     }
 }
diff --git a/gix/tests/gix/diff.rs b/gix/tests/gix/diff.rs
index 2b9fa79401b..b2d23537525 100644
--- a/gix/tests/gix/diff.rs
+++ b/gix/tests/gix/diff.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use gix_diff::blob::{Algorithm, Driver};
 
 use crate::util::named_repo;
 
 #[test]
-fn resource_cache() -> crate::Result {
+fn resource_cache() -> Result {
     let repo = named_repo("make_diff_repo.sh")?;
     let index = repo.index()?;
     let cache = gix::diff::resource_cache(
diff --git a/gix/tests/gix/head.rs b/gix/tests/gix/head.rs
index edde1d717af..a41789ecc5d 100644
--- a/gix/tests/gix/head.rs
+++ b/gix/tests/gix/head.rs
@@ -1,8 +1,9 @@
 mod peel {
+    use crate::Result;
     use crate::util::{hex_to_id, named_subrepo_opts};
 
     #[test]
-    fn all_cases() -> crate::Result {
+    fn all_cases() -> Result {
         let expected_commit = hex_to_id("fafd9d08a839d99db60b222cd58e2e0bfaf1f7b2");
         for name in ["detached", "symbolic", "tag-detached", "tag-symbolic"] {
             let repo = named_subrepo_opts("make_head_repos.sh", name, gix::open::Options::isolated())?;
@@ -19,13 +20,29 @@ mod peel {
         }
         Ok(())
     }
+
+    #[test]
+    fn a_missing_detached_head_object_is_not_an_empty_tree() -> Result {
+        let (repo, _keep) = crate::basic_rw_repo()?;
+        let mut missing_id = repo.object_hash().null();
+        missing_id.as_mut_slice()[0] = 1;
+        repo.reference("HEAD", missing_id, gix::refs::transaction::PreviousValue::Any, "")?;
+
+        let err = repo
+            .head_tree_id_or_empty()
+            .expect_err("a born HEAD with a missing object must remain an error");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "a missing detached head object is not an empty tree", @"An object with id Oid(1) could not be found");
+        assert!(err.is_not_found());
+        Ok(())
+    }
 }
 
 mod into_remote {
+    use crate::Result;
     use crate::remote;
 
     #[test]
-    fn unborn_is_none() -> crate::Result {
+    fn unborn_is_none() -> Result {
         let repo = remote::repo("url-rewriting");
         assert_eq!(
             repo.head()?.into_remote(gix::remote::Direction::Fetch).transpose()?,
@@ -40,7 +57,7 @@ mod into_remote {
     }
 
     #[test]
-    fn detached_is_none() -> crate::Result {
+    fn detached_is_none() -> Result {
         let repo = remote::repo("detached-head");
         assert_eq!(
             repo.head()?.into_remote(gix::remote::Direction::Fetch).transpose()?,
diff --git a/gix/tests/gix/id.rs b/gix/tests/gix/id.rs
index 85b31d471b6..8de322b3fbb 100644
--- a/gix/tests/gix/id.rs
+++ b/gix/tests/gix/id.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::cmp::Ordering;
 
 use crate::util::hex_to_id;
@@ -8,7 +9,7 @@ use gix::{
 use gix_object::bstr::BString;
 
 #[test]
-fn prefix() -> crate::Result {
+fn prefix() -> Result {
     let repo = crate::repo("make_repo_with_fork_and_dates.sh")?.to_thread_local();
     let work_dir = repo.workdir().expect("non-bare");
     let id = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170").attach(&repo);
@@ -35,24 +36,42 @@ fn prefix() -> crate::Result {
         "By default gitoxide acts like `libgit2` here and we prefer to be lenient when possible"
     );
 
+    let err = gix::open_opts(
+        work_dir,
+        gix::open::Options::isolated()
+            .strict_config(true)
+            .config_overrides(Some(BString::from("core.abbrev=invalid"))),
+    )
+    .expect_err("invalid core.abbrev must fail");
     assert!(
-        matches!(
-            gix::open_opts(
-                work_dir,
-                gix::open::Options::isolated()
-                    .strict_config(true)
-                    .config_overrides(Some(BString::from("core.abbrev=invalid")))
-            )
-            .unwrap_err(),
-            gix::open::Error::Config(gix::config::Error::CoreAbbrev(_))
-        ),
+        err.is_validation(),
         "an empty core.abbrev fails the open operation in strict config mode, emulating git behaviour"
     );
+    let diagnostic = err
+        .classify()
+        .filter(|classification| classification.class() == gix_error::Class::Validation)
+        .find_map(|classification| classification.error().downcast_ref::<gix_error::Message>())
+        .expect("invalid abbreviations retain their validation diagnostic");
+    if repo.object_hash() == gix_hash::Kind::Sha1 {
+        insta::assert_debug_snapshot!(diagnostic, "invalid abbreviation lengths retain the configuration validation diagnostic", @r#"
+        Message {
+            message: "Invalid value for 'core.abbrev' = 'invalid'. It must be between 4 and 40",
+            class: Validation,
+        }
+        "#);
+    } else {
+        insta::assert_debug_snapshot!(diagnostic, "invalid abbreviation lengths retain the configuration validation diagnostic", @r#"
+        Message {
+            message: "Invalid value for 'core.abbrev' = 'invalid'. It must be between 4 and 64",
+            class: Validation,
+        }
+        "#);
+    }
     Ok(())
 }
 
 #[test]
-fn display_and_debug() -> crate::Result {
+fn display_and_debug() -> Result {
     let expected = match gix_testtools::object_hash() {
         gix_hash::Kind::Sha1 => {
             "3189cd3cb0af8586c39a838aa3e54fd72a872a41 Sha1(3189cd3cb0af8586c39a838aa3e54fd72a872a41)"
@@ -70,7 +89,7 @@ fn display_and_debug() -> crate::Result {
 }
 
 #[test]
-fn compares_with_text() -> crate::Result {
+fn compares_with_text() -> Result {
     let repo = crate::basic_repo()?;
     let id = repo.head_id()?;
     let text = id.to_string();
@@ -85,10 +104,11 @@ fn compares_with_text() -> crate::Result {
 }
 
 mod ancestors {
+    use crate::Result;
     use crate::util::hex_to_id;
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let repo = crate::repo("make_repo_with_fork_and_dates.sh")?.to_thread_local();
         let has_commit_graph = repo.commit_graph_if_enabled()?.is_some();
         for use_commit_graph in [false, true] {
@@ -98,7 +118,7 @@ mod ancestors {
                 .use_commit_graph(use_commit_graph)
                 .all()?
                 .map(|c| c.map(gix::revision::walk::Info::detach))
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<std::result::Result<Vec<_>, _>>()?;
             assert_eq!(commits_graph_order.len(), 4, "need a specific amount of commits");
             if use_commit_graph && has_commit_graph {
                 assert!(
@@ -118,7 +138,7 @@ mod ancestors {
                 .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
                 .all()?
                 .map(|c| c.map(gix::revision::walk::Info::detach))
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<std::result::Result<Vec<_>, _>>()?;
             assert_eq!(
                 commits_by_commit_date.len(),
                 4,
@@ -154,7 +174,7 @@ mod ancestors {
     }
 
     #[test]
-    fn pre_epoch() -> crate::Result {
+    fn pre_epoch() -> Result {
         let repo = crate::repo("make_pre_epoch_repo.sh")?.to_thread_local();
         for use_commit_graph in [false, true] {
             let head = repo.head()?.into_peeled_id()?;
@@ -163,7 +183,7 @@ mod ancestors {
                 .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default())) // assure we have time set
                 .use_commit_graph(use_commit_graph)
                 .all()?
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<std::result::Result<Vec<_>, _>>()?;
             assert_eq!(commits.len(), 1, "only one commit");
 
             let commit = &commits[0];
@@ -174,7 +194,7 @@ mod ancestors {
     }
 
     #[test]
-    fn prune_with_auto_cutoff() -> crate::Result {
+    fn prune_with_auto_cutoff() -> Result {
         let repo = crate::repo("make_repo_with_fork_and_dates.sh")?.to_thread_local();
         let head = repo.head()?.into_peeled_id()?;
 
@@ -185,7 +205,7 @@ mod ancestors {
                 .use_commit_graph(use_commit_graph)
                 .all()?
                 .map(|c| c.map(|c| c.id))
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<std::result::Result<Vec<_>, _>>()?;
             assert_eq!(
                 commits_graph_order,
                 &[hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170")],
@@ -196,7 +216,7 @@ mod ancestors {
     }
 
     #[test]
-    fn filtered() -> crate::Result {
+    fn filtered() -> Result {
         let repo = crate::repo("make_repo_with_fork_and_dates.sh")?.to_thread_local();
         let head = repo.head()?.into_peeled_id()?;
 
@@ -219,7 +239,7 @@ mod ancestors {
                             && id != hex_to_id("bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac")
                     })?
                     .map(|c| c.map(|c| c.id))
-                    .collect::<Result<Vec<_>, _>>()?;
+                    .collect::<std::result::Result<Vec<_>, _>>()?;
                 assert_eq!(
                     commits_graph_order,
                     &[hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170")],
diff --git a/gix/tests/gix/init.rs b/gix/tests/gix/init.rs
index 8c2db1d12b5..9b9b3399ff3 100644
--- a/gix/tests/gix/init.rs
+++ b/gix/tests/gix/init.rs
@@ -1,9 +1,10 @@
 mod bare {
+    use crate::Result;
     use gix_testtools::tempfile;
 
     #[test]
     #[serial_test::serial]
-    fn init_into_non_existing_directory_creates_it() -> crate::Result {
+    fn init_into_non_existing_directory_creates_it() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         let tmp = tempfile::tempdir()?;
         let git_dir = tmp.path().join("bare.git");
@@ -24,7 +25,7 @@ mod bare {
 
     #[test]
     #[serial_test::serial]
-    fn init_into_empty_directory_uses_it_directly() -> crate::Result {
+    fn init_into_empty_directory_uses_it_directly() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         let tmp = tempfile::tempdir()?;
         let repo = gix::init_bare(tmp.path())?;
@@ -43,25 +44,28 @@ mod bare {
     }
 
     #[test]
-    fn init_into_non_empty_directory_is_not_allowed() -> crate::Result {
+    fn init_into_non_empty_directory_is_not_allowed() -> Result {
         let tmp = tempfile::tempdir()?;
         std::fs::write(tmp.path().join("existing.txt"), b"I was here before you")?;
 
-        assert!(
-            gix::init_bare(tmp.path())
-                .unwrap_err()
-                .to_string()
-                .starts_with("Refusing to initialize the non-empty directory as")
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(gix::init_bare(tmp.path())
+                .expect_err("init into non empty directory is not allowed")), &[(&(tmp.path()).to_string_lossy(), "<destination>")]), "init into non empty directory is not allowed", @r#"
+        Message {
+            message: "Refusing to initialize the non-empty directory as",
+            class: Validation,
+            values: {"input": Bytes("<destination>")},
+        }
+        "#);
         Ok(())
     }
 }
 
 mod non_bare {
+    use crate::Result;
     use gix_testtools::tempfile;
 
     #[test]
-    fn init_bare_with_custom_branch_name() -> crate::Result {
+    fn init_bare_with_custom_branch_name() -> Result {
         let tmp = tempfile::tempdir()?;
         let repo: gix::Repository = gix::ThreadSafeRepository::init_opts(
             tmp.path(),
@@ -79,7 +83,7 @@ mod non_bare {
     }
 
     #[test]
-    fn init_bare_with_fully_qualified_custom_branch_name_is_not_prefixed_again() -> crate::Result {
+    fn init_bare_with_fully_qualified_custom_branch_name_is_not_prefixed_again() -> Result {
         let tmp = tempfile::tempdir()?;
         let repo: gix::Repository = gix::ThreadSafeRepository::init_opts(
             tmp.path(),
@@ -102,7 +106,7 @@ mod non_bare {
     }
 
     #[test]
-    fn init_bare_rejects_reserved_branch_name() -> crate::Result {
+    fn init_bare_rejects_reserved_branch_name() -> Result {
         let tmp = tempfile::tempdir()?;
         let err = gix::ThreadSafeRepository::init_opts(
             tmp.path(),
@@ -111,18 +115,25 @@ mod non_bare {
             gix::open::Options::isolated().config_overrides(["user.name=a", "user.email=b", "init.defaultBranch=HEAD"]),
         )
         .unwrap_err();
+        insta::assert_debug_snapshot!(err, "init bare rejects reserved branch name", @r#"
+        Invalid default branch name, "input"="HEAD"
+        |
+        └─ Reference name is reserved and cannot be used: "refs/heads/HEAD"
+        "#);
+        assert!(matches!(
+            err.classify().filter(|classification| classification.class() == gix_error::Class::Validation)
+                .find_map(|classification| classification.error().downcast_ref::<gix_error::Message>()),
+            Some(gix_error::Message { values, .. }) if values.get("input") == Some(&gix_error::MetadataValue::Bytes("HEAD".into()))
+        ));
         assert!(matches!(
-            err,
-            gix::init::Error::InvalidBranchName {
-                name,
-                source: gix_validate::reference::name::Error::Reserved { name: reserved }
-            } if name == "HEAD" && reserved == "refs/heads/HEAD"
+            err.downcast_any_ref(),
+            Some(gix_validate::reference::name::Error::Reserved { name }) if name == "refs/heads/HEAD"
         ));
         Ok(())
     }
 
     #[test]
-    fn init_bare_rejects_reserved_fully_qualified_branch_name() -> crate::Result {
+    fn init_bare_rejects_reserved_fully_qualified_branch_name() -> Result {
         let tmp = tempfile::tempdir()?;
         let err = gix::ThreadSafeRepository::init_opts(
             tmp.path(),
@@ -135,19 +146,26 @@ mod non_bare {
             ]),
         )
         .unwrap_err();
+        insta::assert_debug_snapshot!(err, "init bare rejects reserved fully qualified branch name", @r#"
+        Invalid default branch name, "input"="refs/heads/HEAD"
+        |
+        └─ Reference name is reserved and cannot be used: "refs/heads/HEAD"
+        "#);
         assert!(matches!(
-            err,
-            gix::init::Error::InvalidBranchName {
-                name,
-                source: gix_validate::reference::name::Error::Reserved { name: reserved }
-            } if name == "refs/heads/HEAD" && reserved == "refs/heads/HEAD"
+            err.classify().filter(|classification| classification.class() == gix_error::Class::Validation)
+                .find_map(|classification| classification.error().downcast_ref::<gix_error::Message>()),
+            Some(gix_error::Message { values, .. }) if values.get("input") == Some(&gix_error::MetadataValue::Bytes("refs/heads/HEAD".into()))
+        ));
+        assert!(matches!(
+            err.downcast_any_ref(),
+            Some(gix_validate::reference::name::Error::Reserved { name }) if name == "refs/heads/HEAD"
         ));
         Ok(())
     }
 
     #[test]
     #[serial_test::serial]
-    fn init_into_empty_directory_creates_a_dot_git_dir() -> crate::Result {
+    fn init_into_empty_directory_creates_a_dot_git_dir() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         let tmp = tempfile::tempdir()?;
         let repo = gix::init(tmp.path())?;
@@ -167,7 +185,7 @@ mod non_bare {
     }
 
     #[test]
-    fn init_into_non_empty_directory_is_allowed_if_option_is_none_or_false() -> crate::Result {
+    fn init_into_non_empty_directory_is_allowed_if_option_is_none_or_false() -> Result {
         for destination_must_be_empty in [None, Some(false)] {
             let tmp = tempfile::tempdir()?;
             std::fs::write(tmp.path().join("existing.txt"), b"I was here before you")?;
@@ -192,7 +210,7 @@ mod non_bare {
     }
 
     #[test]
-    fn init_into_non_empty_directory_is_not_allowed_if_option_is_true() -> crate::Result {
+    fn init_into_non_empty_directory_is_not_allowed_if_option_is_true() -> Result {
         let tmp = tempfile::tempdir()?;
         std::fs::write(tmp.path().join("existing.txt"), b"I was here before you")?;
 
@@ -206,10 +224,13 @@ mod non_bare {
             gix::open::Options::isolated(),
         )
         .unwrap_err();
-        assert!(
-            err.to_string()
-                .starts_with("Refusing to initialize the non-empty directory as")
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(tmp.path()).to_string_lossy(), "<destination>")]), "init into non empty directory is not allowed if option is true", @r#"
+        Message {
+            message: "Refusing to initialize the non-empty directory as",
+            class: Validation,
+            values: {"input": Bytes("<destination>")},
+        }
+        "#);
         Ok(())
     }
 }
diff --git a/gix/tests/gix/object/commit.rs b/gix/tests/gix/object/commit.rs
index f96ec29c4ee..6d91cbb3f7f 100644
--- a/gix/tests/gix/object/commit.rs
+++ b/gix/tests/gix/object/commit.rs
@@ -1,9 +1,10 @@
+use crate::Result;
 use std::cmp::Ordering;
 
 use crate::{basic_repo, util::hex_to_id};
 
 #[test]
-fn short_id() -> crate::Result {
+fn short_id() -> Result {
     let repo = basic_repo()?;
     let commit = repo.head_commit()?;
     assert_eq!(commit.short_id()?.cmp_oid(&commit.id), Ordering::Equal);
@@ -11,7 +12,7 @@ fn short_id() -> crate::Result {
 }
 
 #[test]
-fn tree() -> crate::Result {
+fn tree() -> Result {
     let repo = basic_repo()?;
     let tree_id = repo.head_tree_id()?;
     assert_eq!(tree_id, hex_to_id("21d3ba9a26b790a4858d67754ae05d04dfce4d0c"));
@@ -30,7 +31,7 @@ fn tree() -> crate::Result {
 }
 
 #[test]
-fn decode() -> crate::Result {
+fn decode() -> Result {
     let repo = basic_repo()?;
     let commit = repo.head_commit()?;
     assert_eq!(commit.decode()?.message, commit.message_raw()?);
diff --git a/gix/tests/gix/object/tree/diff.rs b/gix/tests/gix/object/tree/diff.rs
index 5d7b4f6249a..fdaa1fee23e 100644
--- a/gix/tests/gix/object/tree/diff.rs
+++ b/gix/tests/gix/object/tree/diff.rs
@@ -1,12 +1,15 @@
+use crate::Result;
 use std::convert::Infallible;
 
+use gix_error::ExnResult;
+
 use gix::object::{blob::diff::lines, tree::diff::Change};
 use gix_object::{bstr::ByteSlice, tree::EntryKind};
 
 use crate::named_repo;
 
 #[test]
-fn changes_against_tree_modified() -> crate::Result {
+fn changes_against_tree_modified() -> Result {
     let repo = named_repo("make_diff_repo.sh")?;
     let from = tree_named(&repo, "@^{/c3-modification}~1");
     let to = tree_named(&repo, ":/c3-modification");
@@ -19,65 +22,64 @@ fn changes_against_tree_modified() -> crate::Result {
     ];
     let mut i = 0;
 
-    from.changes()?
-        .for_each_to_obtain_tree(&to, |change| -> Result<_, Infallible> {
-            let (expected_previous_entry_mode, expected_previous_data, expected_entry_mode, expected_data) =
-                expected_modifications[i];
-
-            assert!(
-                !change.location().is_empty(),
-                "without configuration the location field is set"
-            );
-            match change {
-                Change::Modification {
-                    previous_entry_mode,
-                    previous_id,
-                    entry_mode,
-                    id,
-                    ..
-                } => {
-                    assert_eq!(previous_entry_mode.kind(), expected_previous_entry_mode);
-                    assert_eq!(entry_mode.kind(), expected_entry_mode);
+    from.changes()?.for_each_to_obtain_tree(&to, |change| -> ExnResult<_> {
+        let (expected_previous_entry_mode, expected_previous_data, expected_entry_mode, expected_data) =
+            expected_modifications[i];
 
-                    if matches!(entry_mode.kind(), EntryKind::Tree) {
-                        i += 1;
-                        return Ok(std::ops::ControlFlow::Continue(()));
-                    }
+        assert!(
+            !change.location().is_empty(),
+            "without configuration the location field is set"
+        );
+        match change {
+            Change::Modification {
+                previous_entry_mode,
+                previous_id,
+                entry_mode,
+                id,
+                ..
+            } => {
+                assert_eq!(previous_entry_mode.kind(), expected_previous_entry_mode);
+                assert_eq!(entry_mode.kind(), expected_entry_mode);
 
-                    assert_eq!(previous_id.object().unwrap().data.as_bstr(), expected_previous_data);
-                    assert_eq!(id.object().unwrap().data.as_bstr(), expected_data);
-                }
-                Change::Rewrite { .. } | Change::Deletion { .. } | Change::Addition { .. } => {
-                    unreachable!("only modification is expected")
+                if matches!(entry_mode.kind(), EntryKind::Tree) {
+                    i += 1;
+                    return Ok(std::ops::ControlFlow::Continue(()));
                 }
+
+                assert_eq!(previous_id.object().unwrap().data.as_bstr(), expected_previous_data);
+                assert_eq!(id.object().unwrap().data.as_bstr(), expected_data);
             }
+            Change::Rewrite { .. } | Change::Deletion { .. } | Change::Addition { .. } => {
+                unreachable!("only modification is expected")
+            }
+        }
 
-            let mut diff = change.diff(&mut cache).expect("objects available");
-            let count = diff.line_counts().expect("no diff error").expect("no binary blobs");
-            assert_eq!(count.insertions, 1);
-            assert_eq!(count.removals, 0);
-            diff.lines(|hunk| {
-                match hunk {
-                    lines::Change::Deletion { .. } => unreachable!("there was no deletion"),
-                    lines::Change::Addition { lines } => {
-                        assert_eq!(lines.len(), 1);
-                        assert_eq!(
-                            lines[0],
-                            expected_data.as_bytes()[expected_previous_data.len()..]
-                                .as_bstr()
-                                .trim(),
-                            "diffed lines don't have newlines anymore"
-                        );
-                    }
-                    lines::Change::Modification { .. } => unreachable!("there was no modification"),
+        let mut diff = change.diff(&mut cache).expect("objects available");
+        let count = diff.line_counts().expect("no diff error").expect("no binary blobs");
+        assert_eq!(count.insertions, 1);
+        assert_eq!(count.removals, 0);
+        diff.lines(|hunk| {
+            match hunk {
+                lines::Change::Deletion { .. } => unreachable!("there was no deletion"),
+                lines::Change::Addition { lines } => {
+                    assert_eq!(lines.len(), 1);
+                    assert_eq!(
+                        lines[0],
+                        expected_data.as_bytes()[expected_previous_data.len()..]
+                            .as_bstr()
+                            .trim(),
+                        "diffed lines don't have newlines anymore"
+                    );
                 }
-                Ok::<_, Infallible>(())
-            })
-            .expect("infallible");
+                lines::Change::Modification { .. } => unreachable!("there was no modification"),
+            }
+            Ok::<_, Infallible>(())
+        })
+        .expect("infallible");
 
-            i += 1;
-            Ok(std::ops::ControlFlow::Continue(()))
-        })?;
+        i += 1;
+        Ok(std::ops::ControlFlow::Continue(()))
+    })?;
     assert_eq!(i, 3);
 
     let actual = repo.diff_tree_to_tree(&from, &to, None)?;
@@ -149,7 +151,10 @@ fn changes_against_tree_modified() -> crate::Result {
 }
 
 mod track_rewrites {
-    use std::{collections::HashMap, convert::Infallible};
+    use crate::Result;
+    use std::collections::HashMap;
+
+    use gix_error::ExnResult;
 
     use gix::{
         diff::{
@@ -163,7 +168,7 @@ mod track_rewrites {
     use crate::{object::tree::diff::tree_named, util::named_subrepo_opts};
 
     #[test]
-    fn jj_realistic_needs_to_be_more_clever() -> crate::Result {
+    fn jj_realistic_needs_to_be_more_clever() -> Result {
         // The test case only works (and is only needed) for SHA-1.
         // Ideally this can be ported to SHA-256 once rename tracking is par with Git.
         if gix_testtools::object_hash() == gix::hash::Kind::Sha256 {
@@ -205,7 +210,7 @@ mod track_rewrites {
             .options(|opts| {
                 opts.track_rewrites(rewrites.into());
             })
-            .for_each_to_obtain_tree(&to, |change| -> Result<_, Infallible> {
+            .for_each_to_obtain_tree(&to, |change| -> ExnResult<_> {
                 if let Change::Rewrite {
                     source_location,
                     diff: Some(diff),
@@ -443,7 +448,7 @@ mod track_rewrites {
     }
 
     #[test]
-    fn jj_realistic_directory_rename() -> crate::Result {
+    fn jj_realistic_directory_rename() -> Result {
         // The test case only works (and is only needed) for SHA-1.
         // Ideally this can be ported to SHA-256 once rename tracking is par with Git.
         if gix_testtools::object_hash() == gix::hash::Kind::Sha256 {
diff --git a/gix/tests/gix/object/tree/mod.rs b/gix/tests/gix/object/tree/mod.rs
index b3280ce9105..28be6034a6d 100644
--- a/gix/tests/gix/object/tree/mod.rs
+++ b/gix/tests/gix/object/tree/mod.rs
@@ -1,14 +1,15 @@
+use crate::Result;
 use crate::util::{named_repo, named_subrepo_opts};
 
 #[cfg(all(feature = "blob-diff", feature = "revision"))]
 mod diff;
 
-fn worktree_repo() -> Result<gix::Repository, gix::open::Error> {
+fn worktree_repo() -> std::result::Result<gix::Repository, gix_error::Error> {
     named_subrepo_opts("make_worktree_repo.sh", "repo", gix::open::Options::isolated())
 }
 
 #[test]
-fn find_entry() -> crate::Result {
+fn find_entry() -> Result {
     let repo = named_repo("make_basic_repo.sh")?;
     let tree = repo.head_commit()?.tree()?;
     assert_eq!(tree.find_entry("this").expect("present").filename(), "this");
@@ -18,7 +19,7 @@ fn find_entry() -> crate::Result {
 }
 
 #[test]
-fn lookup_entry_by_path() -> crate::Result {
+fn lookup_entry_by_path() -> Result {
     let repo = worktree_repo()?;
     let tree = repo.head_commit()?.tree()?;
     assert_eq!(tree.lookup_entry_by_path("dir/c")?.expect("present").filename(), "c");
@@ -26,7 +27,7 @@ fn lookup_entry_by_path() -> crate::Result {
 }
 
 #[test]
-fn decode_uses_the_tree_id_hash_kind() -> crate::Result {
+fn decode_uses_the_tree_id_hash_kind() -> Result {
     use gix::bstr::ByteSlice;
 
     let repo = named_repo("make_basic_repo.sh")?;
@@ -56,8 +57,10 @@ fn decode_uses_the_tree_id_hash_kind() -> crate::Result {
 }
 
 mod peel_to_entry {
+    use crate::Result;
+
     #[test]
-    fn top_level_file_keeps_the_current_tree() -> crate::Result {
+    fn top_level_file_keeps_the_current_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let root_id = tree.id();
@@ -70,7 +73,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn nested_file_moves_to_the_last_seen_tree() -> crate::Result {
+    fn nested_file_moves_to_the_last_seen_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let dir_id = tree.lookup_entry(["dir"])?.expect("tree entry").object_id();
@@ -83,7 +86,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn tree_leaf_moves_to_the_returned_tree() -> crate::Result {
+    fn tree_leaf_moves_to_the_returned_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let dir_id = tree.lookup_entry(["dir"])?.expect("tree entry").object_id();
@@ -101,7 +104,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn missing_top_level_entry_keeps_the_current_tree() -> crate::Result {
+    fn missing_top_level_entry_keeps_the_current_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let root_id = tree.id();
@@ -114,7 +117,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn missing_nested_entry_moves_to_the_last_seen_tree() -> crate::Result {
+    fn missing_nested_entry_moves_to_the_last_seen_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let dir_id = tree.lookup_entry(["dir"])?.expect("tree entry").object_id();
@@ -127,7 +130,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn path_continuing_past_a_top_level_file_keeps_the_current_tree() -> crate::Result {
+    fn path_continuing_past_a_top_level_file_keeps_the_current_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let root_id = tree.id();
@@ -145,7 +148,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn path_continuing_past_a_nested_file_keeps_the_last_seen_tree() -> crate::Result {
+    fn path_continuing_past_a_nested_file_keeps_the_last_seen_tree() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let dir_id = tree.lookup_entry(["dir"])?.expect("tree entry").object_id();
@@ -163,7 +166,7 @@ mod peel_to_entry {
     }
 
     #[test]
-    fn by_path_has_the_same_tree_leaf_behavior() -> crate::Result {
+    fn by_path_has_the_same_tree_leaf_behavior() -> Result {
         let repo = super::worktree_repo()?;
         let mut tree = repo.head_commit()?.tree()?;
         let dir_id = tree.lookup_entry(["dir"])?.expect("tree entry").object_id();
diff --git a/gix/tests/gix/reference/mod.rs b/gix/tests/gix/reference/mod.rs
index d73657f1e3b..22c0ca2c8d5 100644
--- a/gix/tests/gix/reference/mod.rs
+++ b/gix/tests/gix/reference/mod.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use gix::remote::Direction;
 
 #[test]
-fn compares_with_name_representations() -> crate::Result {
+fn compares_with_name_representations() -> Result {
     use gix::{
         bstr::{BString, ByteSlice},
         refs::{FullName, FullNameRef, Target},
@@ -60,7 +61,7 @@ mod log {
 }
 
 #[test]
-fn remote_name() -> crate::Result {
+fn remote_name() -> Result {
     let repo = crate::named_subrepo_opts(
         "make_remote_config_repos.sh",
         "multiple-remotes",
@@ -84,16 +85,61 @@ fn remote_name() -> crate::Result {
 }
 
 mod find {
+    use crate::Result;
     use gix_ref::{FullName, FullNameRef, Target, TargetRef};
 
     use crate::util::hex_to_id;
 
-    fn repo() -> crate::Result<gix::Repository> {
+    fn repo() -> Result<gix::Repository> {
         crate::repo("make_references_repo.sh").map(Into::into)
     }
 
     #[test]
-    fn and_peel() -> crate::Result {
+    fn missing_reference_is_classified() -> Result {
+        let err = repo()?
+            .find_reference("does-not-exist")
+            .expect_err("the reference is missing");
+        insta::assert_debug_snapshot!(err, "missing reference is classified", @r#"The ref partially named "does-not-exist" could not be found"#);
+        assert!(err.is_not_found());
+        Ok(())
+    }
+
+    #[test]
+    fn invalid_reference_names_are_classified() -> Result {
+        let mut error_snapshots = Vec::new();
+        let repo = repo()?;
+        for err in [
+            repo.find_reference("refs//heads/main")
+                .expect_err("repeated slashes are invalid"),
+            repo.try_find_reference("refs//heads/main")
+                .expect_err("optional lookup still validates the name"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.is_validation(), "porcelain errors retain name validation failures");
+            assert!(!err.is_not_found(), "an invalid name is not a missing reference");
+            assert!(!err.can_retry(), "retrying cannot fix an invalid name");
+            assert!(
+                err.downcast_any_ref::<gix::validate::reference::name::Error>()
+                    .is_some(),
+                "the original name error remains available"
+            );
+        }
+        insta::assert_debug_snapshot!(error_snapshots, "invalid reference names are classified", @"
+        [
+            The ref name or path is not a valid ref name
+            |
+            └─ Reference name cannot contain repeated slashes,
+            The ref name or path is not a valid ref name
+            |
+            └─ Reference name cannot contain repeated slashes,
+        ]
+        ");
+        Ok(())
+    }
+
+    #[test]
+    fn and_peel() -> Result {
+        let mut error_snapshots = Vec::new();
         let repo = repo()?;
         let mut packed_tag_ref = repo.try_find_reference("dt1")?.expect("tag to exist");
         let expected: &FullNameRef = "refs/tags/dt1".try_into()?;
@@ -155,21 +201,21 @@ mod find {
 
         let err = tag_ref.peel_to_kind(gix::object::Kind::Blob).unwrap_err();
         let empty_tree_id = hex_to_id("4b825dc642cb6eb9a060e54bf8d69288fbee4904");
-        let expected_err = format!(
-            "Last encountered object {} was tree while trying to peel to blob",
-            &empty_tree_id.to_string()[..7]
-        );
-        assert_eq!(
-            err.to_string(),
-            expected_err,
-            "it's an error if the desired type isn't actually present"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&empty_tree_id.to_string()[..7], "<tree-id>")]), "peeling reports the final object and the requested type", @r#"
+        Message {
+            message: "Last encountered object <tree-id> was tree while trying to peel to blob",
+            class: Validation,
+        }
+        "#);
         match tag_ref.peel_to_blob() {
             Ok(_) => {
                 unreachable!("target is a commit")
             }
             Err(err) => {
-                assert_eq!(err.to_string(), expected_err);
+                error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                    &err,
+                    &[(&empty_tree_id.to_string()[..7], "<tree-id>")],
+                ));
             }
         }
 
@@ -215,11 +261,19 @@ mod find {
             "as it was read from a packed-ref, it contains peeling information nonetheless"
         );
 
+        insta::assert_debug_snapshot!(error_snapshots, "and peel", @r#"
+        [
+            Message {
+                message: "Last encountered object <tree-id> was tree while trying to peel to blob",
+                class: Validation,
+            },
+        ]
+        "#);
         Ok(())
     }
 
     #[test]
-    fn and_follow() -> crate::Result {
+    fn and_follow() -> Result {
         let repo = repo()?;
         let mut symbolic_ref = repo.find_reference("multi-link-target1")?;
         let first_hop = Target::Symbolic(FullName::try_from("refs/tags/multi-link-target2").expect("valid"));
@@ -251,12 +305,17 @@ fn set_target_id() {
     assert_eq!(head_ref.id(), target_id, "the id was set and is observable right away");
 
     head_ref.delete().unwrap();
+    let err = head_ref
+        .set_target_id(prev_id, "fails")
+        .expect_err("the reference was deleted");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "updating a deleted reference requires reconciling its absence", @r#"
+    Could not prepare reference edit, "reference"="refs/heads/main", "referent"="refs/heads/main"
+    |
+    └─ The reference must exist with content Oid(1)
+    "#);
     assert!(
-        head_ref
-            .set_target_id(prev_id, "fails")
-            .unwrap_err()
-            .to_string()
-            .starts_with("Reference \"refs/heads/main\" was supposed to exist")
+        err.is_not_found(),
+        "updating a deleted reference requires reconciling its absence"
     );
 }
 
diff --git a/gix/tests/gix/reference/remote.rs b/gix/tests/gix/reference/remote.rs
index 0e787c99a27..387b60850e4 100644
--- a/gix/tests/gix/reference/remote.rs
+++ b/gix/tests/gix/reference/remote.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use crate::remote;
 
 #[test]
-fn push_defaults_to_fetch() -> crate::Result {
+fn push_defaults_to_fetch() -> Result {
     let repo = remote::repo("many-fetchspecs");
     let head = repo.head()?;
     let branch = head.clone().try_into_referent().expect("history");
@@ -31,7 +32,7 @@ fn push_defaults_to_fetch() -> crate::Result {
 }
 
 #[test]
-fn separate_push_and_fetch() -> crate::Result {
+fn separate_push_and_fetch() -> Result {
     for name in ["push-default", "branch-push-remote"] {
         let repo = remote::repo(name);
         let head = repo.head()?;
@@ -56,7 +57,7 @@ fn separate_push_and_fetch() -> crate::Result {
 }
 
 #[test]
-fn not_configured() -> crate::Result {
+fn not_configured() -> Result {
     let repo = remote::repo("base");
     let head = repo.head()?;
     let branch = head.clone().try_into_referent().expect("history");
@@ -65,19 +66,20 @@ fn not_configured() -> crate::Result {
     assert_eq!(branch.remote_name(gix::remote::Direction::Fetch), None);
     assert_eq!(branch.remote(gix::remote::Direction::Fetch).transpose()?, None);
     assert_eq!(head.into_remote(gix::remote::Direction::Fetch).transpose()?, None);
-    assert!(
-        matches!(
-            repo.find_fetch_remote(None),
-            Err(gix::remote::find::for_fetch::Error::ExactlyOneRemoteNotAvailable)
-        ),
-        "there is no remote to be found"
-    );
+    let err = repo.find_fetch_remote(None).unwrap_err();
+    assert!(err.is_not_found(), "there is no remote to be found");
+    insta::assert_debug_snapshot!(err.probable_cause(), "not configured", @r#"
+    Message {
+        message: "No configured remote could be found, or too many were available",
+        class: NotFound,
+    }
+    "#);
 
     Ok(())
 }
 
 #[test]
-fn dot_remote_behind_symbol() -> crate::Result {
+fn dot_remote_behind_symbol() -> Result {
     let repo = remote::repo("branch-dot-remote");
     let head = repo.head()?;
     let branch = head.clone().try_into_referent().expect("history");
@@ -102,7 +104,7 @@ fn dot_remote_behind_symbol() -> crate::Result {
 }
 
 #[test]
-fn url_as_remote_name() -> crate::Result {
+fn url_as_remote_name() -> Result {
     let repo = remote::repo("remote-as-url");
     let branch = repo.head_ref()?.expect("history");
 
diff --git a/gix/tests/gix/remote/connect.rs b/gix/tests/gix/remote/connect.rs
index d5de8bb00a7..a137f24439f 100644
--- a/gix/tests/gix/remote/connect.rs
+++ b/gix/tests/gix/remote/connect.rs
@@ -3,10 +3,12 @@
     feature = "blocking-http-transport-reqwest"
 ))]
 mod http_authentication {
+    use crate::Result;
+    use gix_error::ErrorExt;
     use std::io::{BufRead, Write};
 
     #[test]
-    fn cached_credentials_are_selected_without_prompting() -> crate::Result {
+    fn cached_credentials_are_selected_without_prompting() -> Result {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
@@ -16,9 +18,8 @@ mod http_authentication {
             .set("NO_PROXY", "*")
             .set("no_proxy", "*");
         let directory = gix_testtools::tempfile::tempdir()?;
-        gix_testtools::git(directory.path(), "init --bare")?;
         let _cwd = gix_testtools::set_current_dir(directory.path())?;
-        let mut repo = gix::open_opts(directory.path(), gix::open::Options::isolated())?;
+        let mut repo = crate::init_repo_isolated(directory.path(), gix::create::Kind::Bare)?.to_thread_local();
 
         // Like GCM, this helper needs the server's account hint to choose a cached credential.
         // The credentials are fictitious, and both the helper and gix must keep prompting disabled.
@@ -65,7 +66,7 @@ mod http_authentication {
             .with_credentials(|action| {
                 obtained = Some(authenticate(action));
                 // Stop after credential lookup, before the transport sends these dummy credentials.
-                Err(gix_credentials::protocol::Error::Quit)
+                Err(gix_error::message("The handler asked to stop trying to obtain credentials").raise_erased())
             })
             .ref_map(gix::progress::Discard, Default::default());
         server.join().expect("the HTTP fixture thread does not panic")?;
@@ -74,7 +75,8 @@ mod http_authentication {
             "the callback stops the handshake after credential lookup"
         );
         let outcome = obtained
-            .expect("the 401 response invokes the credential callback")?
+            .expect("the 401 response invokes the credential callback")
+            .map_err(gix_error::Exn::into_error)?
             .expect("the cached credential is complete");
         assert_eq!(
             outcome.identity.username, "cached-user",
@@ -91,6 +93,7 @@ mod http_authentication {
 #[cfg(feature = "blocking-network-client")]
 mod blocking_io {
     mod protocol_allow {
+        use crate::Result;
         use gix::remote::Direction::Fetch;
         use serial_test::serial;
 
@@ -99,22 +102,49 @@ mod blocking_io {
         #[test]
         #[serial]
         fn deny() {
+            let mut error_snapshots = Vec::new();
             for name in ["protocol_denied", "protocol_file_denied"] {
                 let repo = remote::repo(name);
                 let remote = repo.find_remote("origin").unwrap();
-                assert!(matches!(
-                    remote.connect(Fetch).err(),
-                    Some(gix::remote::connect::Error::ProtocolDenied {
-                        url: _,
-                        scheme: gix::url::Scheme::File
-                    })
+                let err = remote.connect(Fetch).err().expect("protocol is denied");
+                error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                    &(err),
+                    &[(
+                        &(gix_testtools::scripted_fixture_read_only("make_remote_repos.sh")
+                            .expect("remote fixture")
+                            .canonicalize()
+                            .expect("fixture exists"))
+                        .to_string_lossy(),
+                        "<fixture>",
+                    )],
                 ));
+                assert!(err.is_validation());
+                let validation = err
+                    .classify()
+                    .filter(|classification| classification.class() == gix_error::Class::Validation)
+                    .find_map(|classification| classification.error().downcast_ref::<gix::error::Message>())
+                    .expect("protocol denial retains its validation details");
+                assert!(validation.values.contains_key("input"), "the denied URL is retained");
             }
+            insta::assert_debug_snapshot!(error_snapshots, "deny", @r#"
+            [
+                Message {
+                    message: "Protocol File is denied per configuration",
+                    class: Validation,
+                    values: {"input": Bytes("<fixture>/base")},
+                },
+                Message {
+                    message: "Protocol File is denied per configuration",
+                    class: Validation,
+                    values: {"input": Bytes("<fixture>/base")},
+                },
+            ]
+            "#);
         }
 
         #[test]
         #[serial]
-        fn user() -> crate::Result {
+        fn user() -> Result {
             let _environment = gix_testtools::isolate_git_environment()?;
             for (env_value, should_allow) in [
                 (None, Some(true)),
@@ -141,10 +171,7 @@ mod blocking_io {
                 if let Some(should_allow) = should_allow {
                     assert_eq!(result.is_ok(), should_allow, "Value = {env_value:?}");
                 } else {
-                    assert!(
-                        matches!(result, Err(gix::remote::connect::Error::SchemePermission(_))),
-                        "invalid booleans must be reported"
-                    );
+                    assert!(result.is_err(), "invalid booleans must be reported");
                 }
             }
             Ok(())
diff --git a/gix/tests/gix/remote/fetch.rs b/gix/tests/gix/remote/fetch.rs
index 2e7bad54038..dd8d47061ed 100644
--- a/gix/tests/gix/remote/fetch.rs
+++ b/gix/tests/gix/remote/fetch.rs
@@ -12,6 +12,7 @@ mod shallow {
 
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client-async-std"))]
 mod blocking_and_async_io {
+    use crate::Result;
     use std::sync::atomic::AtomicBool;
 
     use gix::{
@@ -81,10 +82,9 @@ mod blocking_and_async_io {
         dir.join(name)
     }
 
-    #[expect(clippy::result_large_err)]
     pub(crate) fn try_repo_rw(
         name: &str,
-    ) -> Result<(gix::Repository, gix_testtools::tempfile::TempDir), gix::open::Error> {
+    ) -> std::result::Result<(gix::Repository, gix_testtools::tempfile::TempDir), gix_error::Error> {
         try_repo_rw_args(name, Vec::<String>::new(), Mode::FastClone)
     }
 
@@ -93,12 +93,11 @@ mod blocking_and_async_io {
         CloneWithShallowSupport,
     }
 
-    #[expect(clippy::result_large_err)]
     pub(crate) fn try_repo_rw_args<S: Into<String>>(
         name: &str,
         args: impl IntoIterator<Item = S>,
         mode: Mode,
-    ) -> Result<(gix::Repository, gix_testtools::tempfile::TempDir), gix::open::Error> {
+    ) -> std::result::Result<(gix::Repository, gix_testtools::tempfile::TempDir), gix_error::Error> {
         let dir = gix_testtools::scripted_fixture_writable_with_args_single_archive(
             "make_fetch_repos.sh",
             [{
@@ -121,7 +120,7 @@ mod blocking_and_async_io {
         try_repo_rw(name).unwrap()
     }
 
-    fn commit_empty(repo: &gix::Repository, message: &str) -> crate::Result<gix::ObjectId> {
+    fn commit_empty(repo: &gix::Repository, message: &str) -> Result<gix::ObjectId> {
         Ok(repo
             .commit(
                 "HEAD",
@@ -132,7 +131,7 @@ mod blocking_and_async_io {
             .detach())
     }
 
-    fn init_repo(path: &std::path::Path) -> crate::Result<gix::Repository> {
+    fn init_repo(path: &std::path::Path) -> Result<gix::Repository> {
         Ok(gix::ThreadSafeRepository::init_opts(
             path,
             gix::create::Kind::WithWorktree,
@@ -142,7 +141,7 @@ mod blocking_and_async_io {
         .to_thread_local())
     }
 
-    fn shallow_ids(repo: &gix::Repository, expected: &'static str) -> crate::Result<Vec<gix::ObjectId>> {
+    fn shallow_ids(repo: &gix::Repository, expected: &'static str) -> Result<Vec<gix::ObjectId>> {
         let commits = repo.shallow_commits()?.expect(expected);
         Ok(std::iter::once(commits.head)
             .chain(commits.tail.iter().copied())
@@ -157,7 +156,7 @@ mod blocking_and_async_io {
         if gix_testtools::run_in_isolated_process()? {
             return Ok(());
         }
-        use gix::{config::tree::User, interrupt::IS_INTERRUPTED};
+        use gix::{config::tree::User, error::MetadataValue, interrupt::IS_INTERRUPTED};
         use gix_odb::store::init::Slots;
         use gix_testtools::tempfile;
         fn create_empty_commit(repo: &gix::Repository) -> anyhow::Result<()> {
@@ -246,9 +245,14 @@ mod blocking_and_async_io {
                 {
                     Ok(out) => check_fetch_output(&local_repo, out, expected_object_count)?,
                     Err(err) => {
-                        assert!(
-                            err.to_string()
-                                .starts_with("The slotmap turned out to be too small with ")
+                        let context = err.metadata().next().expect("index capacity details");
+                        assert_eq!(
+                            (&context["current"], &context["needed"]),
+                            (
+                                &MetadataValue::from(max_packs),
+                                &MetadataValue::from(round_to_create_pack + 1 - usize::from(max_packs))
+                            ),
+                            "each fetch adds one pack beyond the configured capacity"
                         );
                         // But opening a new repo will always be able to read all objects
                         // as it dynamically sizes the otherwise static slotmap.
@@ -266,8 +270,7 @@ mod blocking_and_async_io {
 
     #[test]
     #[cfg(feature = "blocking-network-client")]
-    #[expect(clippy::result_large_err)]
-    fn collate_fetch_error() -> Result<(), gix::env::collate::fetch::Error<std::io::Error>> {
+    fn collate_fetch_error() -> std::result::Result<(), gix_error::Error> {
         let (repo, _tmp) = try_repo_rw("two-origins")?;
         let remote = repo
             .head()?
@@ -284,7 +287,7 @@ mod blocking_and_async_io {
             repo.path()
                 .join("HEAD")
                 .metadata()
-                .map_err(gix::env::collate::fetch::Error::Other)?
+                .map_err(gix::Error::from_error)?
                 .is_file(),
             "just to show off the 'Other' error type"
         );
@@ -293,7 +296,9 @@ mod blocking_and_async_io {
 
     #[test]
     #[cfg(feature = "blocking-network-client")]
-    fn fetch_with_alternates_adds_tips_from_alternates() -> crate::Result<()> {
+    fn fetch_with_alternates_adds_tips_from_alternates() -> Result<()> {
+        use gix::error::ResultExt;
+
         // Isolated repository options don't sanitize the ambient Git config inherited by local `upload-pack`.
         // Use a child to keep this clone parallel with other tests without changing the parent environment.
         if gix_testtools::run_in_isolated_process()? {
@@ -314,10 +319,13 @@ mod blocking_and_async_io {
                     r.repo().objects.store_ref().path().join("info").join("alternates"),
                     format!(
                         "{}\n",
-                        gix::path::realpath(remote_repo.objects.store_ref().path())?.display()
+                        gix::path::realpath(remote_repo.objects.store_ref().path())
+                            .or_erased()?
+                            .display()
                     )
                     .as_bytes(),
-                )?;
+                )
+                .or_erased()?;
                 Ok(r)
             }
         })
@@ -347,7 +355,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn local_transport_fetches_head_against_remote_refs() -> crate::Result {
+    async fn local_transport_fetches_head_against_remote_refs() -> Result {
         // Blocking local transport spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -405,7 +413,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_ignores_dangling_symbolic_refs_during_negotiation() -> crate::Result {
+    async fn fetch_ignores_dangling_symbolic_refs_during_negotiation() -> Result {
         // Blocking local transport spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -453,7 +461,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_with_multi_round_negotiation() -> crate::Result {
+    async fn fetch_with_multi_round_negotiation() -> Result {
         // Blocking local clone/fetch spawns `upload-pack`, which inherits ambient Git configuration.
         // Use a child to keep negotiation I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -539,7 +547,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_shallow_deepen_zero_does_not_fail() -> crate::Result {
+    async fn fetch_shallow_deepen_zero_does_not_fail() -> Result {
         // Even without deepening, blocking local transport spawns `upload-pack` with ambient Git config.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -583,7 +591,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_shallow_deepen_not_possible() -> crate::Result {
+    async fn fetch_shallow_deepen_not_possible() -> Result {
         // Blocking local transport spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep shallow-fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -644,7 +652,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_empty_pack() -> crate::Result {
+    async fn fetch_empty_pack() -> Result {
         // Even without receiving a pack, blocking local transport spawns `upload-pack` with ambient Git config.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -730,7 +738,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_pack_without_local_destination() -> crate::Result {
+    async fn fetch_pack_without_local_destination() -> Result {
         // Blocking local transport spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -805,7 +813,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetching_a_missing_explicit_ref_fails_even_if_ls_refs_returns_nothing() -> crate::Result {
+    async fn fetching_a_missing_explicit_ref_fails_even_if_ls_refs_returns_nothing() -> Result {
         // Blocking local ref discovery spawns `upload-pack` with ambient Git config, even for a missing ref.
         // Isolate it in a child to keep Git I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
@@ -834,17 +842,19 @@ mod blocking_and_async_io {
             .await
             .unwrap_err();
 
-        assert_eq!(
-            err.to_string(),
-            "None of the refspec(s) refs/heads/does-not-exist matched any of the 0 refs on the remote"
-        );
+        insta::assert_debug_snapshot!(err, "fetching a missing explicit ref fails even if ls refs returns nothing", @r#"
+        Message {
+            message: "None of the refspec(s) refs/heads/does-not-exist matched any of the 0 refs on the remote",
+            class: Validation,
+        }
+        "#);
         Ok(())
     }
 
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn fetch_pack() -> crate::Result {
+    async fn fetch_pack() -> Result {
         // Blocking local transport spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep fetch I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
diff --git a/gix/tests/gix/remote/ref_map.rs b/gix/tests/gix/remote/ref_map.rs
index bedc8ae56ff..edc239fe847 100644
--- a/gix/tests/gix/remote/ref_map.rs
+++ b/gix/tests/gix/remote/ref_map.rs
@@ -1,5 +1,6 @@
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client-async-std"))]
 mod blocking_and_async_io {
+    use crate::Result;
     use gix::{config::tree::Protocol, remote::Direction::Fetch};
     use gix_features::progress;
     use gix_protocol::bisync;
@@ -12,7 +13,7 @@ mod blocking_and_async_io {
     #[bisync::bisync]
     #[cfg_attr(feature = "blocking-network-client", test)]
     #[cfg_attr(feature = "async-network-client-async-std", async_std::test)]
-    async fn all() -> crate::Result {
+    async fn all() -> Result {
         // Blocking local ref discovery spawns `upload-pack`, which inherits ambient Git configuration.
         // Isolate it in a child to keep ref-map I/O parallel without changing the parent environment.
         #[cfg(feature = "blocking-network-client")]
diff --git a/gix/tests/gix/remote/save.rs b/gix/tests/gix/remote/save.rs
index 04c00257b9c..fde8551f85b 100644
--- a/gix/tests/gix/remote/save.rs
+++ b/gix/tests/gix/remote/save.rs
@@ -1,9 +1,10 @@
 mod save_to {
 
+    use crate::Result;
     use crate::{remote, remote::save::uniformize};
 
     #[test]
-    fn named_remotes_save_as_is() -> crate::Result {
+    fn named_remotes_save_as_is() -> Result {
         let repo = remote::repo("clone");
         let remote = repo.find_remote("origin")?;
 
@@ -42,24 +43,28 @@ mod save_to {
 }
 
 mod save_as_to {
+    use crate::Result;
     use crate::{
         basic_repo, remote,
         remote::save::{remote_config, uniformize},
     };
 
     #[test]
-    fn anonymous_remotes_cannot_be_saved_lacking_a_name() -> crate::Result {
+    fn anonymous_remotes_cannot_be_saved_lacking_a_name() -> Result {
         let repo = basic_repo()?;
         let remote = repo.remote_at("https://example.com/path")?;
-        assert!(matches!(
-            remote.save_to(&mut gix::config::File::default()).unwrap_err(),
-            gix::remote::save::Error::NameMissing { .. }
-        ));
+        insta::assert_debug_snapshot!(remote
+                .save_to(&mut gix::config::File::default())
+                .expect_err("anonymous remotes cannot be saved lacking a name"), "anonymous remotes cannot be saved lacking a name", @r#"
+        Message {
+            message: "The remote pointing to https://example.com/path is anonymous and can't be saved.",
+        }
+        "#);
         Ok(())
     }
 
     #[test]
-    fn new_anonymous_remote_with_name() -> crate::Result {
+    fn new_anonymous_remote_with_name() -> Result {
         let repo = basic_repo()?;
         let mut remote = repo
             .remote_at("https://example.com/path")?
@@ -118,7 +123,7 @@ mod save_as_to {
     }
 
     #[test]
-    fn new_remote_in_presence_of_global_section_writes_to_local_file() -> crate::Result {
+    fn new_remote_in_presence_of_global_section_writes_to_local_file() -> Result {
         use gix::bstr::ByteSlice;
         // A repo with no remotes, opened so that `remote.origin` exists only as a non-local (`Api`)
         // override, mirroring global configuration like `remote.origin.prune = true` (issue #1951).
@@ -152,7 +157,7 @@ mod save_as_to {
     /// saving another `origin` must clear those inherited values locally, or reopening would merge them
     /// back into the saved URL lists.
     #[test]
-    fn inherited_urls_are_saved_with_reset_markers() -> crate::Result {
+    fn inherited_urls_are_saved_with_reset_markers() -> Result {
         use gix::bstr::{BStr, BString};
 
         let repo = gix::open_opts(
@@ -212,7 +217,7 @@ mod save_as_to {
     /// reset-bearing local section after it so reopening clears the included URL before restoring
     /// the remote's effective URL list.
     #[test]
-    fn reset_markers_follow_later_foreign_url_sections() -> crate::Result {
+    fn reset_markers_follow_later_foreign_url_sections() -> Result {
         use gix::bstr::{BStr, BString, ByteSlice};
 
         let inherited_url = "https://included.example/path";
diff --git a/gix/tests/gix/repository/blame.rs b/gix/tests/gix/repository/blame.rs
index aa5106f0d32..c70d1d0817d 100644
--- a/gix/tests/gix/repository/blame.rs
+++ b/gix/tests/gix/repository/blame.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use gix::bstr::BString;
 use std::num::NonZero;
 
 #[test]
-fn simple() -> crate::Result {
+fn simple() -> Result {
     let repo = crate::named_repo("make_blame_repo.sh")?;
 
     let suspect = repo.head_id()?;
@@ -14,7 +15,7 @@ fn simple() -> crate::Result {
 }
 
 #[test]
-fn with_options() -> crate::Result {
+fn with_options() -> Result {
     let repo = crate::named_repo("make_blame_repo.sh")?;
 
     let options = gix::repository::blame_file::Options {
diff --git a/gix/tests/gix/repository/branch.rs b/gix/tests/gix/repository/branch.rs
index e884e5dd7a4..db85da99810 100644
--- a/gix/tests/gix/repository/branch.rs
+++ b/gix/tests/gix/repository/branch.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::io::Write;
 
 use gix::refs::{
@@ -10,7 +11,7 @@ fn refname(value: &str) -> FullName {
 }
 
 #[test]
-fn deletes_a_batch_and_all_of_its_local_config_without_inspecting_commits() -> crate::Result {
+fn deletes_a_batch_and_all_of_its_local_config_without_inspecting_commits() -> Result {
     let (mut repo, _tmp) = crate::repo_rw("make_references_repo.sh")?;
     let direct = refname("refs/heads/delete-direct");
     let symbolic = refname("refs/heads/delete-symbolic");
@@ -105,28 +106,41 @@ fn deletes_a_batch_and_all_of_its_local_config_without_inspecting_commits() -> c
 }
 
 #[test]
-fn validation_failure_leaves_the_entire_batch_unchanged() -> crate::Result {
+fn validation_failure_leaves_the_entire_batch_unchanged() -> Result {
     let (mut repo, _tmp) = crate::repo_rw("make_references_repo.sh")?;
+    let work_dir = repo
+        .workdir()
+        .expect("the reference fixture is a non-bare repository")
+        .to_owned();
     let deletable = refname("refs/heads/d1");
     let checked_out = refname("refs/heads/main");
 
     let err = repo
         .delete_local_branches([deletable.clone(), checked_out.clone()])
         .expect_err("the checked-out branch prevents the whole batch");
-    assert!(matches!(err, gix::repository::branch::delete::Error::CheckedOut { name, .. } if name == checked_out));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(work_dir).to_string_lossy(), "<worktree>")]), "validation failure leaves the entire batch unchanged", @r#"The local branch FullName("refs/heads/main") is checked out in ["<worktree>"]"#);
+    let cause = err
+        .downcast_any_ref::<gix::repository::branch::delete::CheckedOutError>()
+        .expect("checked-out branches remain identifiable without parsing the diagnostic");
+    assert_eq!(cause.name, checked_out, "the protected branch is retained");
+    assert_eq!(
+        cause.worktree_dirs.as_slice(),
+        std::slice::from_ref(&work_dir),
+        "the main worktree path is retained"
+    );
     assert!(repo.try_find_reference(deletable.as_ref())?.is_some());
 
     let tag = refname("refs/tags/t1");
     let err = repo
         .delete_local_branches([tag.clone()])
         .expect_err("non-local references are rejected");
-    assert!(matches!(err, gix::repository::branch::delete::Error::NotLocal { name } if name == tag));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(work_dir).to_string_lossy(), "<worktree>")]), "validation failure leaves the entire batch unchanged", @r#"FullName("refs/tags/t1") is not a local branch"#);
     assert!(repo.try_find_reference(tag.as_ref())?.is_some());
     Ok(())
 }
 
 #[test]
-fn missing_branches_are_successful_and_their_config_is_removed() -> crate::Result {
+fn missing_branches_are_successful_and_their_config_is_removed() -> Result {
     let (mut repo, _tmp) = crate::repo_rw("make_references_repo.sh")?;
     let existing = refname("refs/heads/d1");
     let missing = refname("refs/heads/does-not-exist");
@@ -200,7 +214,7 @@ fn missing_branches_are_successful_and_their_config_is_removed() -> crate::Resul
 }
 
 #[test]
-fn linked_worktree_branches_are_protected_and_common_config_is_updated() -> crate::Result {
+fn linked_worktree_branches_are_protected_and_common_config_is_updated() -> Result {
     // `git worktree add --relative-paths`, used by the fixture, was added in Git 2.48.
     let Some(fixture) = gix_testtools::scripted_fixture_writable_with_args_with_git_version(
         "make_worktree_relative_linking.sh",
@@ -233,10 +247,23 @@ fn linked_worktree_branches_are_protected_and_common_config_is_updated() -> crat
     std::fs::write(linked_repo.git_dir().join("HEAD"), b"ref: refs/heads/linked\n")?;
 
     let mut main = gix::open_opts(&main_path, crate::restricted())?;
+    let linked_work_dir = main
+        .worktree_proxy_by_id("linked")
+        .expect("the linked worktree is registered")
+        .base()?;
     let err = main
         .delete_local_branches([checked_out.clone()])
         .expect_err("a linked worktree checkout is protected");
-    assert!(matches!(err, gix::repository::branch::delete::Error::CheckedOut { name, .. } if name == checked_out));
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(fixture.path()).to_string_lossy(), "<fixture>")]), "linked worktree branches are protected and common config is updated", @r#"The local branch FullName("refs/heads/linked") is checked out in ["<fixture>/main/.git/worktrees/linked/../../../../linked"]"#);
+    let cause = err
+        .downcast_any_ref::<gix::repository::branch::delete::CheckedOutError>()
+        .expect("linked worktree checkouts retain the same typed rejection");
+    assert_eq!(cause.name, checked_out, "the protected branch is retained");
+    assert_eq!(
+        cause.worktree_dirs,
+        [linked_work_dir],
+        "the linked worktree path is retained"
+    );
 
     let mut config = std::fs::OpenOptions::new()
         .append(true)
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 7ec3faa2b64..4427ef992c9 100644
--- a/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
+++ b/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
@@ -1,6 +1,8 @@
+use crate::Result;
 use crate::remote;
 
 mod baseline {
+    use crate::Result;
     use std::collections::HashMap;
 
     use gix_object::bstr::BString;
@@ -17,11 +19,11 @@ mod baseline {
     static BASELINE: LazyLock<HashMap<String, Helpers>> = LazyLock::new(|| {
         let base = remote::repo_path("credential-helpers");
 
-        (|| -> crate::Result<_> {
+        (|| -> Result<_> {
             use std::io::BufRead;
             let mut map = HashMap::new();
             let baseline = std::fs::read(base.join("baseline.git"))?;
-            let mut lines = baseline.lines().map(Result::unwrap).peekable();
+            let mut lines = baseline.lines().map(std::result::Result::unwrap).peekable();
             while let Some(url) = lines.next() {
                 let mut helpers = Vec::new();
                 while let Some(helper) = lines
@@ -125,7 +127,7 @@ fn any_url_calls_global() {
 }
 
 #[test]
-fn protect_protocol_defaults_to_true_and_can_be_overridden_per_url() -> crate::Result {
+fn protect_protocol_defaults_to_true_and_can_be_overridden_per_url() -> Result {
     let mut repo = remote::repo("credential-helpers");
     let url = "https://example.com";
     let (cascade, action, _) = repo.config_snapshot().credential_helpers(url.try_into()?)?;
@@ -200,7 +202,7 @@ fn subdomain_globs_match_on_their_level() {
 
 #[test]
 #[serial_test::serial]
-fn http_urls_match_the_host_without_path_as_well() -> crate::Result {
+fn http_urls_match_the_host_without_path_as_well() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("GIT_ASKPASS", "foo");
     baseline::agrees_with("http://example.com:8080/other/path");
     baseline::agrees_with_but_drops_default_port_in_prompt("http://example.com:80/");
@@ -211,7 +213,7 @@ fn http_urls_match_the_host_without_path_as_well() -> crate::Result {
 
 #[test]
 #[serial_test::serial]
-fn user_rules_only_match_urls_with_user() -> crate::Result {
+fn user_rules_only_match_urls_with_user() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?.set("SSH_ASKPASS", "foo");
     baseline::agrees_with("https://user@example.com/with-user");
     baseline::agrees_with("https://example.com/with-user");
@@ -239,10 +241,50 @@ fn invalid_urls_are_rejected_early() {
 }
 
 #[test]
-fn empty_core_askpass_is_ignored() -> crate::Result {
-    let repo = remote::repo("empty-core-askpass");
-    let _ = repo
-        .config_snapshot()
-        .credential_helpers("does-not-matter".try_into()?)?;
+fn empty_core_askpass_is_ignored() -> Result {
+    for strict in [false, true] {
+        let repo = gix::open_opts(
+            remote::repo_path("empty-core-askpass"),
+            gix::open::Options::isolated().strict_config(strict),
+        )?;
+        let (_, _, prompt) = repo
+            .config_snapshot()
+            .credential_helpers("does-not-matter".try_into()?)?;
+        assert!(prompt.askpass.is_none(), "an empty askpass path is always ignored");
+    }
+    Ok(())
+}
+
+#[test]
+fn core_askpass_interpolation_errors_are_not_ignored() -> Result {
+    let mut error_snapshots = Vec::new();
+    for strict in [false, true] {
+        let repo = gix::open_opts(
+            remote::repo_path("empty-core-askpass"),
+            gix::open::Options::isolated()
+                .strict_config(strict)
+                .config_overrides(["core.askpass=~/askpass"]),
+        )?;
+        let err = repo
+            .config_snapshot()
+            .credential_helpers("does-not-matter".try_into()?)
+            .err()
+            .expect("the isolated repository cannot resolve the home directory");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(
+            err.is_not_found(),
+            "the missing interpolation input remains available in the error chain"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "core askpass interpolation errors are not ignored", @"
+    [
+        core.askpass could not be read
+        |
+        └─ home dir is missing,
+        core.askpass could not be read
+        |
+        └─ home dir is missing,
+    ]
+    ");
     Ok(())
 }
diff --git a/gix/tests/gix/repository/config/config_snapshot/mod.rs b/gix/tests/gix/repository/config/config_snapshot/mod.rs
index ce1f7a24b7c..79e74764117 100644
--- a/gix/tests/gix/repository/config/config_snapshot/mod.rs
+++ b/gix/tests/gix/repository/config/config_snapshot/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix::config::tree::{Branch, Core, Key, Pack, gitoxide};
 
 use crate::{named_repo, repo_rw, repo_rw_opts};
@@ -6,7 +7,7 @@ use crate::{named_repo, repo_rw, repo_rw_opts};
 mod credential_helpers;
 
 #[test]
-fn commit_auto_rollback() -> crate::Result {
+fn commit_auto_rollback() -> Result {
     let mut repo = named_repo("make_basic_repo.sh")?;
     let default_abbrev = repo.head_id()?.to_string()[..7].to_owned();
     let short_abbrev = repo.head_id()?.to_string()[..4].to_owned();
@@ -36,10 +37,11 @@ fn commit_auto_rollback() -> crate::Result {
 }
 
 mod trusted_path {
+    use crate::Result;
     use crate::util::named_repo;
 
     #[test]
-    fn optional_is_respected() -> crate::Result {
+    fn optional_is_respected() -> Result {
         let mut repo = named_repo("make_basic_repo.sh")?;
         repo.config_snapshot_mut().set_raw_value("my.path", "does-not-exist")?;
 
@@ -59,7 +61,7 @@ mod trusted_path {
 }
 
 #[test]
-fn snapshot_mut_commit_and_forget() -> crate::Result {
+fn snapshot_mut_commit_and_forget() -> Result {
     let mut repo = named_repo("make_basic_repo.sh")?;
     let repo = {
         let mut repo = repo.config_snapshot_mut();
@@ -77,7 +79,7 @@ fn snapshot_mut_commit_and_forget() -> crate::Result {
 }
 
 #[test]
-fn committing_loose_compression_requires_reopening_the_object_store() -> crate::Result {
+fn committing_loose_compression_requires_reopening_the_object_store() -> Result {
     use gix::objs::Write;
 
     fn loose_object_size(repo: &gix::Repository, id: gix::ObjectId) -> std::io::Result<u64> {
@@ -116,7 +118,7 @@ fn committing_loose_compression_requires_reopening_the_object_store() -> crate::
 }
 
 #[test]
-fn compression_levels() -> crate::Result {
+fn compression_levels() -> Result {
     use gix::zlib::Compression;
 
     let mut repo = named_repo("make_basic_repo.sh")?;
@@ -194,7 +196,7 @@ fn set_value_in_subsection() {
 }
 
 #[test]
-fn apply_cli_overrides() -> crate::Result {
+fn apply_cli_overrides() -> Result {
     let mut repo = named_repo("make_config_repo.sh").unwrap();
     repo.config_snapshot_mut().append_config(
         [
@@ -234,7 +236,7 @@ fn apply_cli_overrides() -> crate::Result {
 }
 
 #[test]
-fn reload_reloads_on_disk_changes() -> crate::Result {
+fn reload_reloads_on_disk_changes() -> Result {
     let (mut repo, _tmp) = repo_rw("make_config_repo.sh")?;
     assert_eq!(repo.config_snapshot().integer("core.abbrev"), None);
     let original_index = repo.index_path();
@@ -261,7 +263,7 @@ fn reload_reloads_on_disk_changes() -> crate::Result {
 }
 
 #[test]
-fn reload_discards_in_memory_only_changes() -> crate::Result {
+fn reload_discards_in_memory_only_changes() -> Result {
     let mut repo = named_repo("make_config_repo.sh")?;
 
     repo.config_snapshot_mut().set_raw_value(Core::ABBREV, "4")?;
@@ -273,7 +275,7 @@ fn reload_discards_in_memory_only_changes() -> crate::Result {
 }
 
 #[test]
-fn reload_rebuilds_includes_even_when_the_file_was_empty_or_missing() -> crate::Result {
+fn reload_rebuilds_includes_even_when_the_file_was_empty_or_missing() -> Result {
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options_with_includes())?;
     let included_path = repo.workdir().expect("worktree repository").join("a.config");
 
@@ -304,7 +306,7 @@ fn reload_rebuilds_includes_even_when_the_file_was_empty_or_missing() -> crate::
 
 #[test]
 #[cfg(feature = "index")]
-fn reload_preserves_the_reduced_trust_allocation_limit() -> crate::Result {
+fn reload_preserves_the_reduced_trust_allocation_limit() -> Result {
     let fixture = gix_testtools::scripted_fixture_writable("make_config_repo.sh")?;
     let mut repo = gix::open_opts(
         fixture.path(),
@@ -324,7 +326,7 @@ fn reload_preserves_the_reduced_trust_allocation_limit() -> crate::Result {
 
 #[test]
 #[serial_test::serial]
-fn reload_reapplies_per_file_safe_directory_trust() -> crate::Result {
+fn reload_reapplies_per_file_safe_directory_trust() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let fixture = gix_testtools::scripted_fixture_writable("make_config_repo.sh")?;
     let included_path = fixture.path().join("a.config");
@@ -365,7 +367,7 @@ fn reload_reapplies_per_file_safe_directory_trust() -> crate::Result {
 }
 
 #[test]
-fn reload_resolves_onbranch_includes_from_unnamespaced_head() -> crate::Result {
+fn reload_resolves_onbranch_includes_from_unnamespaced_head() -> Result {
     use std::io::Write;
 
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options_with_includes())?;
@@ -410,7 +412,7 @@ fn reload_resolves_onbranch_includes_from_unnamespaced_head() -> crate::Result {
 
 #[test]
 #[cfg(all(feature = "sha1", feature = "sha256"))]
-fn reload_rebuilds_object_stores_for_a_new_object_format() -> crate::Result {
+fn reload_rebuilds_object_stores_for_a_new_object_format() -> Result {
     let (mut repo, _tmp) = repo_rw("make_config_repo.sh")?;
     let new_object_hash = match repo.object_hash() {
         gix::hash::Kind::Sha1 => gix::hash::Kind::Sha256,
@@ -430,7 +432,7 @@ fn reload_rebuilds_object_stores_for_a_new_object_format() -> crate::Result {
 }
 
 #[test]
-fn reload_keeps_opening_overrides_and_discards_runtime_edits() -> crate::Result {
+fn reload_keeps_opening_overrides_and_discards_runtime_edits() -> Result {
     let options = options_with_includes().config_overrides(["refresh.open=from-options"]);
     let (mut repo, _tmp) = repo_rw_opts("make_config_repo.sh", options)?;
     repo.config_snapshot_mut()
diff --git a/gix/tests/gix/repository/config/identity.rs b/gix/tests/gix/repository/config/identity.rs
index 394edeffa05..99189e38694 100644
--- a/gix/tests/gix/repository/config/identity.rs
+++ b/gix/tests/gix/repository/config/identity.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use std::path::Path;
 
 use gix_sec::Permission;
@@ -7,7 +8,7 @@ use serial_test::serial;
 use crate::{named_repo, util::named_subrepo_opts};
 
 #[test]
-fn custom_committer_fallback_is_only_installed_if_needed() -> crate::Result {
+fn custom_committer_fallback_is_only_installed_if_needed() -> Result {
     let tmp = tempfile::tempdir()?;
     let repo = crate::init_repo_isolated(tmp.path(), gix::create::Kind::Bare)?;
     let git_dir = repo.git_dir().to_owned();
@@ -45,7 +46,7 @@ fn custom_committer_fallback_is_only_installed_if_needed() -> crate::Result {
 }
 
 #[test]
-fn configured_identity_fallbacks_follow_user_identity() -> crate::Result {
+fn configured_identity_fallbacks_follow_user_identity() -> Result {
     let tmp = tempfile::tempdir()?;
     let repo = crate::init_repo_isolated(tmp.path(), gix::create::Kind::Bare)?;
     let repo = gix::open_opts(
@@ -86,7 +87,7 @@ fn configured_identity_fallbacks_follow_user_identity() -> crate::Result {
 
 #[test]
 #[serial]
-fn author_included_by_hasconfig() -> crate::Result {
+fn author_included_by_hasconfig() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let repo = named_subrepo_opts("make_config_repos.sh", "with-hasconfig", gix::open::Options::isolated())?;
     let _environment = _environment
@@ -107,7 +108,7 @@ fn author_included_by_hasconfig() -> crate::Result {
 
 #[test]
 #[serial]
-fn author_and_committer_and_fallback() -> crate::Result {
+fn author_and_committer_and_fallback() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     for trust in [gix_sec::Trust::Full, gix_sec::Trust::Reduced] {
         let repo = named_repo("make_config_repo.sh")?;
@@ -154,7 +155,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
 
         assert_eq!(config.boolean("core.bare"), Some(false));
         assert_eq!(config.boolean("a.bad-bool"), None);
-        assert_eq!(config.try_boolean("core.bare"), Ok(Some(false)));
+        assert_eq!(config.try_boolean("core.bare")?, Some(false));
         assert!(config.try_boolean("a.bad-bool").is_err());
 
         assert_eq!(config.integer("a.int"), Some(42));
@@ -171,7 +172,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
         assert_eq!(config.string("a.env-override").expect("present"), "from-c.config");
 
         assert_eq!(config.boolean("core.missing"), None);
-        assert_eq!(config.try_boolean("core.missing"), Ok(None));
+        assert_eq!(config.try_boolean("core.missing")?, None);
 
         let relative_path_key = "a.relative-path";
         if trust == gix_sec::Trust::Full {
@@ -203,7 +204,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
 
 #[test]
 #[serial]
-fn author_from_different_config_sections() -> crate::Result {
+fn author_from_different_config_sections() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let repo = named_repo("make_signatures_repo.sh")?;
     let work_dir = repo.workdir().unwrap().canonicalize()?;
diff --git a/gix/tests/gix/repository/config/mod.rs b/gix/tests/gix/repository/config/mod.rs
index f9009592abf..61f86b88bbe 100644
--- a/gix/tests/gix/repository/config/mod.rs
+++ b/gix/tests/gix/repository/config/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 pub(crate) mod config_snapshot;
 #[cfg(feature = "command")]
 mod editor;
@@ -5,7 +6,7 @@ mod identity;
 mod remote;
 
 #[test]
-fn config_path_for_repository_sources_matches_git() -> crate::Result {
+fn config_path_for_repository_sources_matches_git() -> Result {
     use gix::config::Source;
 
     let fixture = gix_testtools::scripted_fixture_read_only("make_worktree_repo.sh")?;
@@ -34,7 +35,7 @@ fn config_path_for_repository_sources_matches_git() -> crate::Result {
 }
 
 #[test]
-fn big_file_threshold() -> crate::Result {
+fn big_file_threshold() -> Result {
     let repo = repo("with-hasconfig");
     assert_eq!(
         repo.big_file_threshold()?,
@@ -47,14 +48,64 @@ fn big_file_threshold() -> crate::Result {
     Ok(())
 }
 
+#[cfg(feature = "index")]
+#[test]
+fn invalid_stat_boolean_is_validation_error() -> Result {
+    let mut diagnostics = Vec::new();
+    for key in [
+        "core.trustCTime",
+        "gitoxide.core.useNsec",
+        "gitoxide.core.useStdev",
+        "core.checkStat",
+    ] {
+        let mut repo = repo("with-hasconfig");
+        repo.config_snapshot_mut().set_raw_value(key, "invalid")?;
+        let err = repo.stat_options().expect_err("invalid value must fail");
+        assert!(err.is_validation(), "invalid {key} is classified as a validation error");
+        diagnostics.push((key, err));
+    }
+    insta::assert_debug_snapshot!(diagnostics, "invalid stat options identify their configuration key and rejected value", @r#"
+    [
+        (
+            "core.trustCTime",
+            Invalid boolean, "key"="core.trustCTime"
+            |
+            └─ Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid",
+        ),
+        (
+            "gitoxide.core.useNsec",
+            Invalid boolean, "key"="gitoxide.core.useNsec"
+            |
+            └─ Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid",
+        ),
+        (
+            "gitoxide.core.useStdev",
+            Invalid boolean, "key"="gitoxide.core.useStdev"
+            |
+            └─ Booleans need to be 'no', 'off', 'false', '' or 'yes', 'on', 'true' or any number, "input"="invalid",
+        ),
+        (
+            "core.checkStat",
+            Message {
+                message: "Invalid configuration value",
+                class: Validation,
+                values: {"input": Bytes("invalid"), "key": String("core.checkStat")},
+            },
+        ),
+    ]
+    "#);
+    Ok(())
+}
+
 #[cfg(feature = "blocking-network-client")]
 mod ssh_options {
+    use crate::Result;
     use std::ffi::OsStr;
 
     use crate::repository::config::repo;
 
     #[test]
-    fn with_command_and_variant() -> crate::Result {
+    fn with_command_and_variant() -> Result {
         let repo = repo("ssh-all-options");
         let opts = repo.ssh_connect_options()?;
         assert_eq!(opts.command.as_deref(), Some(OsStr::new("ssh -VVV")));
@@ -67,7 +118,7 @@ mod ssh_options {
     }
 
     #[test]
-    fn with_command_fallback_which_disallows_shell() -> crate::Result {
+    fn with_command_fallback_which_disallows_shell() -> Result {
         let repo = repo("ssh-command-fallback");
         let opts = repo.ssh_connect_options()?;
         assert_eq!(opts.command.as_deref(), Some(OsStr::new("ssh --fallback")));
diff --git a/gix/tests/gix/repository/config/remote.rs b/gix/tests/gix/repository/config/remote.rs
index ae9ea7c1f9b..abcb9764059 100644
--- a/gix/tests/gix/repository/config/remote.rs
+++ b/gix/tests/gix/repository/config/remote.rs
@@ -52,17 +52,19 @@ fn remote_default_name() {
 }
 
 mod branch_remote {
+    use crate::Result;
     use gix::{config::tree::Push, remote};
 
     use crate::util::named_subrepo_opts;
 
     mod name {
+        use crate::Result;
         use gix::remote;
 
         use crate::repository::config::remote::branch_remote::repo;
 
         #[test]
-        fn push() -> crate::Result {
+        fn push() -> Result {
             {
                 let repo = repo("push-remote")?;
 
@@ -90,7 +92,7 @@ mod branch_remote {
     }
 
     #[test]
-    fn fetch() -> crate::Result {
+    fn fetch() -> Result {
         let repo = repo("fetch")?;
 
         assert_eq!(
@@ -159,7 +161,7 @@ mod branch_remote {
     }
 
     #[test]
-    fn upstream_branch_and_remote_name_for_tracking_branch() -> crate::Result {
+    fn upstream_branch_and_remote_name_for_tracking_branch() -> Result {
         let mut repo = repo("multiple-remotes")?;
         for expected_remote_name in ["other", "with/two"] {
             let (upstream, remote) = repo
@@ -175,11 +177,12 @@ mod branch_remote {
         let err = repo
             .upstream_branch_and_remote_for_tracking_branch("refs/remotes/with/two/slashes/main".try_into()?)
             .expect_err("both remotes reverse-map the tracking branch");
-        assert_eq!(
-            err.to_string(),
-            "Found ambiguous remotes without 1:1 mapping or more than one match: with/two, with/two/slashes",
-            "the name is ambiguous because both remotes have fetch refspecs mapping to it"
-        );
+        insta::assert_debug_snapshot!(err, "the name is ambiguous because both remotes have fetch refspecs mapping to it", @r#"
+        Message {
+            message: "Found ambiguous remotes without 1:1 mapping or more than one match: with/two, with/two/slashes",
+            class: Validation,
+        }
+        "#);
 
         let (upstream, remote) = repo
             .upstream_branch_and_remote_for_tracking_branch("refs/remotes/with/two/special".try_into()?)?
@@ -219,16 +222,17 @@ mod branch_remote {
         let err = repo
             .upstream_branch_and_remote_for_tracking_branch("refs/remotes/prefix/main".try_into()?)
             .expect_err("multiple remotes are ambiguous");
-        assert_eq!(
-            err.to_string(),
-            "Found ambiguous remotes without 1:1 mapping or more than one match: also-fallback, fallback",
-            "all remotes mapping the same tracking branch are reported"
-        );
+        insta::assert_debug_snapshot!(err, "all remotes mapping the same tracking branch are reported", @r#"
+        Message {
+            message: "Found ambiguous remotes without 1:1 mapping or more than one match: also-fallback, fallback",
+            class: Validation,
+        }
+        "#);
         Ok(())
     }
 
     #[test]
-    fn push_default() -> crate::Result {
+    fn push_default() -> Result {
         let repo = repo("fetch")?;
 
         assert_eq!(
@@ -258,7 +262,7 @@ mod branch_remote {
     }
 
     #[test]
-    fn push_mapped() -> crate::Result {
+    fn push_mapped() -> Result {
         let repo = repo("push-mapped")?;
 
         assert_eq!(
@@ -315,7 +319,7 @@ mod branch_remote {
     }
 
     #[test]
-    fn push_missing() -> crate::Result {
+    fn push_missing() -> Result {
         let repo = repo("push-missing")?;
 
         assert!(
@@ -342,7 +346,7 @@ mod branch_remote {
     }
 
     #[test]
-    fn push_default_current() -> crate::Result {
+    fn push_default_current() -> Result {
         let mut repo = repo("push-default-current")?;
 
         for same_name_default in ["current", "matching"] {
@@ -395,7 +399,7 @@ mod branch_remote {
         Ok(())
     }
 
-    fn repo(name: &str) -> Result<gix::Repository, gix::open::Error> {
+    fn repo(name: &str) -> std::result::Result<gix::Repository, gix_error::Error> {
         named_subrepo_opts("make_remote_config_repos.sh", name, gix::open::Options::isolated())
     }
 }
diff --git a/gix/tests/gix/repository/excludes.rs b/gix/tests/gix/repository/excludes.rs
index ed9593d9bde..4c165c7fb00 100644
--- a/gix/tests/gix/repository/excludes.rs
+++ b/gix/tests/gix/repository/excludes.rs
@@ -1,9 +1,11 @@
+use crate::Result;
 use gix_worktree::stack::state::ignore::Source;
 
 use crate::util::named_subrepo_opts;
 
 #[test]
-fn empty_core_excludes() -> crate::Result {
+fn empty_core_excludes() -> Result {
+    let mut error_snapshots = Vec::new();
     let repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "empty-core-excludes",
@@ -15,21 +17,25 @@ fn empty_core_excludes() -> crate::Result {
             unreachable!("Should fail due to empty excludes path")
         }
         Err(err) => {
-            assert_eq!(
-                err.to_string(),
-                "The value for `core.excludesFile` could not be read from configuration"
-            );
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
         }
     }
 
     let repo = gix::open_opts(repo.git_dir(), repo.open_options().clone().strict_config(false))?;
     repo.excludes(&index, None, Source::WorktreeThenIdMappingIfNotSkipped)
         .expect("empty paths are now just skipped");
+    insta::assert_debug_snapshot!(error_snapshots, "empty core excludes", @"
+    [
+        The value for `core.excludesFile` could not be read from configuration
+        |
+        └─ path is missing,
+    ]
+    ");
     Ok(())
 }
 
 #[test]
-fn missing_core_excludes_is_ignored() -> crate::Result {
+fn missing_core_excludes_is_ignored() -> Result {
     let mut repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "empty-core-excludes",
@@ -45,7 +51,7 @@ fn missing_core_excludes_is_ignored() -> crate::Result {
 }
 
 #[test]
-fn worktree_info_exclude_from_common_dir() -> crate::Result {
+fn worktree_info_exclude_from_common_dir() -> Result {
     let repo = named_subrepo_opts(
         "make_worktree_repo_with_info_exclude.sh",
         "worktree",
diff --git a/gix/tests/gix/repository/filter.rs b/gix/tests/gix/repository/filter.rs
index d8a5f697b5d..8d70ab9f863 100644
--- a/gix/tests/gix/repository/filter.rs
+++ b/gix/tests/gix/repository/filter.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use std::path::Path;
 
 #[test]
-fn pipeline_in_nonbare_repo_without_index() -> crate::Result {
+fn pipeline_in_nonbare_repo_without_index() -> Result {
     let repo = named_subrepo_opts("make_basic_repo.sh", "all-untracked", Default::default())?;
     let _ = repo.filter_pipeline(None).expect("does not fail due to missing index");
     Ok(())
@@ -14,7 +15,7 @@ use super::blob_id;
 use crate::util::{named_repo, named_subrepo_opts};
 
 #[test]
-fn pipeline_in_repo_without_special_options() -> crate::Result {
+fn pipeline_in_repo_without_special_options() -> Result {
     let repo = named_repo("make_basic_repo.sh")?;
     let (mut pipe, index) = repo.filter_pipeline(None)?;
 
@@ -33,7 +34,7 @@ fn pipeline_in_repo_without_special_options() -> crate::Result {
 }
 
 #[test]
-fn repo_local_filter_driver_configuration_overrides_global_configuration() -> crate::Result {
+fn repo_local_filter_driver_configuration_overrides_global_configuration() -> Result {
     let mut repo = named_repo("make_basic_repo.sh")?;
     repo.config_snapshot_mut()
         .append_config(
@@ -59,7 +60,7 @@ fn repo_local_filter_driver_configuration_overrides_global_configuration() -> cr
 
 #[test]
 #[cfg(unix)]
-fn pipeline_worktree_file_to_object() -> crate::Result {
+fn pipeline_worktree_file_to_object() -> Result {
     let repo = named_repo("repo_with_untracked_files.sh")?;
     let work_dir = repo.workdir().expect("non-bare");
     let (mut pipe, index) = repo.filter_pipeline(None)?;
@@ -120,7 +121,7 @@ fn pipeline_worktree_file_to_object() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn worktree_file_to_object_opens_submodules_after_path_options_were_consumed() -> crate::Result {
+fn worktree_file_to_object_opens_submodules_after_path_options_were_consumed() -> Result {
     let repo = named_repo("repo_with_untracked_files.sh")?;
     let submodule = gix::open_opts(
         repo.workdir().expect("non-bare").join("submodule"),
@@ -129,7 +130,7 @@ fn worktree_file_to_object_opens_submodules_after_path_options_were_consumed() -
     let checked_out_head = submodule.head_id()?;
     let mut repo = gix::open_opts(repo.git_dir(), gix::open::Options::isolated().open_path_as_is(true))?;
 
-    fn submodule_entry(repo: &gix::Repository) -> crate::Result<Option<(gix::ObjectId, gix::object::tree::EntryKind)>> {
+    fn submodule_entry(repo: &gix::Repository) -> Result<Option<(gix::ObjectId, gix::object::tree::EntryKind)>> {
         let (mut pipe, index) = repo.filter_pipeline(None)?;
         Ok(pipe
             .worktree_file_to_object("submodule".into(), &index)?
@@ -162,7 +163,7 @@ fn worktree_file_to_object_opens_submodules_after_path_options_were_consumed() -
 }
 
 #[test]
-fn pipeline_with_autocrlf() -> crate::Result {
+fn pipeline_with_autocrlf() -> Result {
     let repo = named_repo("make_config_repo.sh")?;
     let (mut pipe, index) = repo.filter_pipeline(None)?;
 
diff --git a/gix/tests/gix/repository/merge.rs b/gix/tests/gix/repository/merge.rs
index 9aa117c0126..8b7fd63b414 100644
--- a/gix/tests/gix/repository/merge.rs
+++ b/gix/tests/gix/repository/merge.rs
@@ -1,7 +1,8 @@
+use crate::Result;
 use crate::util::named_repo;
 
 #[test]
-fn tree_merge_options() -> crate::Result {
+fn tree_merge_options() -> Result {
     let repo = named_repo("make_basic_repo.sh")?;
     let opts: gix::merge::plumbing::tree::Options = repo.tree_merge_options()?.into();
     assert_eq!(
diff --git a/gix/tests/gix/repository/mod.rs b/gix/tests/gix/repository/mod.rs
index ef8cc3242f7..d661526511c 100644
--- a/gix/tests/gix/repository/mod.rs
+++ b/gix/tests/gix/repository/mod.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "parallel")]
+use crate::Result;
 use gix::Repository;
 
 fn blob_id(repo: &Repository, data: &[u8]) -> gix_hash::ObjectId {
@@ -32,8 +34,10 @@ mod worktree;
 
 #[cfg(feature = "revision")]
 mod revision {
+    use crate::Result;
+
     #[test]
-    fn missing_objects_info_does_not_prevent_merge_base() -> crate::Result {
+    fn missing_objects_info_does_not_prevent_merge_base() -> Result {
         let (repo, _tmp) = crate::util::basic_rw_repo()?;
         let info_dir = repo.objects.store_ref().path().join("info");
         std::fs::create_dir_all(&info_dir)?;
@@ -63,7 +67,7 @@ mod revision {
     }
 
     #[test]
-    fn date() -> crate::Result {
+    fn date() -> Result {
         let repo = crate::named_repo("make_rev_parse_repo.sh")?;
         let actual = repo
             .rev_parse_single("old@{20 years ago}")
@@ -83,9 +87,52 @@ mod revision {
 
 #[cfg(feature = "index")]
 mod index {
+    use crate::Result;
+
     #[test]
-    fn basics() -> crate::Result {
+    fn missing_shared_index_is_an_error() -> Result {
+        let (repo, _tmp) = crate::basic_rw_repo()?;
+        let workdir = repo.workdir().expect("the fixture has a worktree");
+        gix_testtools::git(workdir, "update-index --split-index")?;
+        assert_eq!(
+            repo.open_index()?.entries().len(),
+            1,
+            "the split index is initially valid"
+        );
+        let shared_index = gix_testtools::git(workdir, "rev-parse --shared-index-path")?;
+        std::fs::remove_file(workdir.join(shared_index.trim()))?;
+
+        assert!(
+            !gix_testtools::run_git(workdir, &["ls-files"])?.success(),
+            "Git rejects a split index whose shared file is missing"
+        );
+        assert!(repo.try_index().is_err(), "the primary index still exists");
+        assert!(repo.index_or_empty().is_err(), "a broken index must not become empty");
+        assert!(
+            repo.index_or_load_from_head().is_err(),
+            "a broken index must not be replaced with HEAD"
+        );
+        assert!(
+            repo.index_or_load_from_head_or_empty().is_err(),
+            "neither fallback applies to a broken index"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn basics() -> Result {
         let repo = crate::named_subrepo_opts("make_basic_repo.sh", "unborn", gix::open::Options::isolated())?;
+        let err = repo.index().expect_err("the fixture has no index");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&repo.git_dir().to_string_lossy(), "<git-dir>")]), "a missing index has standard not-found classification", @r#"
+        Message {
+            message: "Could not find index file at '<git-dir>/index' for opening.",
+            class: NotFound,
+        }
+        "#);
+        assert!(
+            err.is_not_found(),
+            "a missing index has standard not-found classification"
+        );
         assert!(
             repo.index_or_load_from_head().is_err(),
             "can't read index if `HEAD^{{tree}}` can't be resolved"
@@ -110,12 +157,13 @@ mod index {
 
 #[cfg(feature = "dirwalk")]
 mod dirwalk {
+    use crate::Result;
     use std::sync::atomic::AtomicBool;
 
     use gix_dir::{entry::Kind::*, walk::EmissionMode};
 
     #[test]
-    fn basics() -> crate::Result {
+    fn basics() -> Result {
         let repo = crate::named_repo("make_basic_repo.sh")?;
         let untracked_only = repo.dirwalk_options()?.emit_untracked(EmissionMode::CollapseDirectory);
         let mut collect = gix::dir::walk::delegate::Collect::default();
@@ -152,7 +200,7 @@ mod dirwalk {
         let mut iter = repo.dirwalk_iter(index, None::<&str>, Default::default(), untracked_only)?;
         let mut actual: Vec<_> = iter
             .by_ref()
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .map(|item| {
                 (
                     item.entry.rela_path.to_string(),
@@ -187,7 +235,7 @@ fn size_in_memory() {
 
 #[test]
 #[cfg(feature = "parallel")]
-fn thread_safe_repository_is_sync() -> crate::Result {
+fn thread_safe_repository_is_sync() -> Result {
     fn f<T: Send + Sync + Clone>(_t: T) {}
     f(crate::util::basic_repo()?.into_sync());
     Ok(())
@@ -195,7 +243,7 @@ fn thread_safe_repository_is_sync() -> crate::Result {
 
 #[test]
 #[cfg(feature = "parallel")]
-fn repository_is_send() -> crate::Result {
+fn repository_is_send() -> Result {
     fn f<T: Send + Clone>(_t: T) {}
     f(crate::util::basic_repo()?);
     Ok(())
diff --git a/gix/tests/gix/repository/note.rs b/gix/tests/gix/repository/note.rs
index 5d85b2969aa..1d9af0081e7 100644
--- a/gix/tests/gix/repository/note.rs
+++ b/gix/tests/gix/repository/note.rs
@@ -1,5 +1,6 @@
+use crate::Result;
 #[test]
-fn query_and_mutate_a_configured_notes_ref() -> crate::Result {
+fn query_and_mutate_a_configured_notes_ref() -> Result {
     let (mut repo, _tmp) = crate::util::basic_rw_repo()?;
     let mut config = repo.config_snapshot_mut();
     config.set_value(&gix::config::tree::Core::NOTES_REF, "refs/notes/review")?;
@@ -63,7 +64,7 @@ fn query_and_mutate_a_configured_notes_ref() -> crate::Result {
 }
 
 #[test]
-fn mutations_follow_symbolic_references_to_their_direct_target() -> crate::Result {
+fn mutations_follow_symbolic_references_to_their_direct_target() -> Result {
     use gix::refs::{
         FullName, Target, TargetRef,
         transaction::{PreviousValue, RefEdit},
@@ -73,7 +74,7 @@ fn mutations_follow_symbolic_references_to_their_direct_target() -> crate::Resul
         name.try_into().expect("test reference names are valid")
     }
 
-    fn create_symbolic_ref(repo: &gix::Repository, name: &str, target: &str) -> crate::Result {
+    fn create_symbolic_ref(repo: &gix::Repository, name: &str, target: &str) -> Result {
         repo.edit_reference(RefEdit::update(
             full_name(name),
             Target::Symbolic(full_name(target)),
@@ -83,7 +84,7 @@ fn mutations_follow_symbolic_references_to_their_direct_target() -> crate::Resul
         Ok(())
     }
 
-    fn assert_symbolic_target(repo: &gix::Repository, name: &str, target: &str) -> crate::Result {
+    fn assert_symbolic_target(repo: &gix::Repository, name: &str, target: &str) -> Result {
         assert_eq!(
             repo.find_reference(name)?.target(),
             TargetRef::Symbolic(target.try_into()?),
@@ -174,7 +175,7 @@ fn mutations_follow_symbolic_references_to_their_direct_target() -> crate::Resul
 }
 
 #[test]
-fn mutations_reject_non_commit_notes_ref_targets() -> crate::Result {
+fn mutations_reject_non_commit_notes_ref_targets() -> Result {
     use gix::refs::transaction::PreviousValue;
 
     let (repo, _tmp) = crate::util::basic_rw_repo()?;
@@ -230,7 +231,7 @@ fn mutations_reject_non_commit_notes_ref_targets() -> crate::Result {
 }
 
 #[test]
-fn custom_commit_message_is_used_for_mutations() -> crate::Result {
+fn custom_commit_message_is_used_for_mutations() -> Result {
     let (repo, _tmp) = crate::util::basic_rw_repo()?;
     let annotated_blob_id = repo.write_blob(b"annotated")?;
     let mut notes = repo.notes()?.with_commit_message("custom notes update");
@@ -256,7 +257,7 @@ fn custom_commit_message_is_used_for_mutations() -> crate::Result {
 }
 
 #[test]
-fn query_and_mutate_multiple_notes_refs() -> crate::Result {
+fn query_and_mutate_multiple_notes_refs() -> Result {
     let (repo, _tmp) = crate::util::basic_rw_repo()?;
     let target = repo.write_blob(b"annotated")?;
     let notes_refs = ["refs/notes/review", "refs/notes/security"];
@@ -325,7 +326,7 @@ fn query_and_mutate_multiple_notes_refs() -> crate::Result {
 }
 
 #[test]
-fn add_to_an_exact_fully_qualified_reference() -> crate::Result {
+fn add_to_an_exact_fully_qualified_reference() -> Result {
     let (repo, _tmp) = crate::util::basic_rw_repo()?;
     let target = repo.write_blob(b"annotated")?.detach();
     let reference: gix::refs::FullName = "refs/worktree/tix/notes".try_into()?;
diff --git a/gix/tests/gix/repository/object.rs b/gix/tests/gix/repository/object.rs
index 0f4e600984e..2640bde4930 100644
--- a/gix/tests/gix/repository/object.rs
+++ b/gix/tests/gix/repository/object.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_date::parse::TimeBuf;
 use gix_odb::Header;
 use gix_pack::Find;
@@ -6,10 +7,11 @@ use gix_testtools::tempfile;
 use crate::util::named_subrepo_opts;
 
 mod object_database_impl {
+    use crate::Result;
     use gix_object::{Exists, Find, FindHeader};
 
     #[test]
-    fn empty_tree_is_always_present() -> crate::Result {
+    fn empty_tree_is_always_present() -> Result {
         let repo = crate::named_subrepo_opts("make_basic_repo.sh", "unborn", gix::open::Options::isolated())?;
         let empty_tree = gix::ObjectId::empty_tree(repo.object_hash());
         assert!(repo.exists(&empty_tree));
@@ -32,6 +34,7 @@ mod object_database_impl {
 }
 
 mod edit_tree {
+    use crate::Result;
     use gix::bstr::{BStr, BString};
     use gix_object::tree::EntryKind;
 
@@ -40,7 +43,7 @@ mod edit_tree {
     #[test]
     // Some part of the test validation the implementation for this exists, but it's needless nonetheless.
     #[expect(clippy::needless_borrows_for_generic_args)]
-    fn from_head_tree() -> crate::Result {
+    fn from_head_tree() -> Result {
         let (repo, _tmp) = crate::repo_rw("make_packed_and_loose.sh")?;
         let head_tree_id = repo.head_tree_id()?;
         assert_eq!(
@@ -150,7 +153,7 @@ mod edit_tree {
     }
 
     #[test]
-    fn submodules_are_not_checked_for_existence() -> crate::Result {
+    fn submodules_are_not_checked_for_existence() -> Result {
         let repo = crate::named_subrepo_opts("make_submodules.sh", "with-submodules", gix::open::Options::isolated())?
             .with_object_memory();
         let mut editor = repo.head_tree()?.edit()?;
@@ -164,7 +167,7 @@ mod edit_tree {
     }
 
     #[test]
-    fn remove_leaf_rejects_tree_entries() -> crate::Result {
+    fn remove_leaf_rejects_tree_entries() -> Result {
         let (repo, _tmp) = crate::repo_rw("make_packed_and_loose.sh")?;
         let head_tree_id = repo.head_tree_id()?;
         let this_id = hex_to_id("317e9677c3bcffd006f9fc84bbb0a54ef1676197");
@@ -175,11 +178,7 @@ mod edit_tree {
             Ok(_) => unreachable!("removing a tree as leaf must fail"),
             Err(err) => err,
         };
-        assert_eq!(
-            err.to_string(),
-            "Cannot remove 'A' as leaf entry because it is a tree",
-            "leaf-only removal must reject non-leaf entries"
-        );
+        insta::assert_debug_snapshot!(err, "leaf-only removal must reject non-leaf entries", @"Cannot remove 'A' as leaf entry because it is a tree");
 
         let actual = editor.remove_leaf("A/one")?.write()?;
         assert_eq!(
@@ -191,7 +190,7 @@ mod edit_tree {
     }
 
     #[test]
-    fn missing_objects_and_illformed_path_components_trigger_error() -> crate::Result {
+    fn missing_objects_and_illformed_path_components_trigger_error() -> Result {
         let (repo, _tmp) = crate::repo_rw("make_packed_and_loose.sh")?;
         let tree = repo.head_tree_id()?.object()?.into_tree();
         let mut editor = tree.edit()?;
@@ -213,11 +212,11 @@ mod edit_tree {
             )?
             .write()
             .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            format!("The object {missing_id} (100644) at 'non-existing' could not be found"),
-            "each entry to be written is checked for existence"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "each entry to be written is checked for existence", @r#"
+        Message {
+            message: "The object Oid(1) (100644) at 'non-existing' could not be found",
+        }
+        "#);
 
         let this_id = hex_to_id("317e9677c3bcffd006f9fc84bbb0a54ef1676197");
         let err = editor
@@ -225,11 +224,11 @@ mod edit_tree {
             .upsert(".git", EntryKind::Blob, this_id)?
             .write()
             .expect_err(".git is universally forbidden in trees");
-        assert_eq!(
-            err.to_string(),
-            format!("The object {this_id} (100644) has an invalid filename: '.git'"),
-            "each component is validated"
-        );
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "each component is validated", @"
+        The object Oid(1) (100644) has an invalid filename: '.git'
+        |
+        └─ The .git name may never be used
+        ");
 
         Ok(())
     }
@@ -246,7 +245,7 @@ mod edit_tree {
             repo: &Repository,
             name: Option<&BStr>,
         ) -> anyhow::Result<termtree::Tree<String>> {
-            let tree = repo.find_tree(tree_id)?.decode()?.to_owned();
+            let tree = repo.find_tree(tree_id)?.decode().map_err(gix::Error::from)?.to_owned();
             let mut termtree = termtree::Tree::new(if let Some(name) = name {
                 if tree.entries.is_empty() {
                     format!("{name} (empty)")
@@ -285,10 +284,11 @@ mod edit_tree {
     }
 }
 mod write_object {
+    use crate::Result;
     use crate::repository::object::empty_bare_in_memory_repo;
 
     #[test]
-    fn empty_tree() -> crate::Result {
+    fn empty_tree() -> Result {
         let repo = empty_bare_in_memory_repo()?;
         let oid = repo.write_object(gix::objs::TreeRef::empty())?;
         assert_eq!(
@@ -300,7 +300,7 @@ mod write_object {
     }
 
     #[test]
-    fn commit_with_invalid_author() -> crate::Result {
+    fn commit_with_invalid_author() -> Result {
         let repo = empty_bare_in_memory_repo()?;
         let actor = gix::actor::Signature {
             name: "1 < 0".into(),
@@ -316,16 +316,16 @@ mod write_object {
             message: Default::default(),
             extra_headers: vec![],
         };
-        assert_eq!(
-            repo.write_object(commit).unwrap_err().to_string(),
-            r#"Signature name or email must not contain '<', '>' or \n: "1 < 0""#,
-            "the actor is invalid so triggers an error when persisting it"
-        );
+        insta::assert_debug_snapshot!(repo.write_object(commit).expect_err("the actor is invalid so triggers an error when persisting it"), "the actor is invalid so triggers an error when persisting it", @r#"
+        I/O error (Other)
+        |
+        └─ Signature name or email must not contain '<', '>' or \n, "input"="1 < 0"
+        "#);
         Ok(())
     }
 
     #[test]
-    fn blob_write_to_implementation() -> crate::Result {
+    fn blob_write_to_implementation() -> Result {
         let repo = empty_bare_in_memory_repo()?;
         let blob = repo.empty_blob();
 
@@ -341,6 +341,7 @@ mod write_object {
 }
 
 mod write_blob {
+    use crate::Result;
     use std::io::{Seek, SeekFrom};
 
     use crate::repository::{
@@ -349,7 +350,7 @@ mod write_blob {
     };
 
     #[test]
-    fn from_slice() -> crate::Result {
+    fn from_slice() -> Result {
         let (_tmp, repo) = empty_bare_repo()?;
         let expected = blob_id(&repo, b"hello world");
         assert!(!repo.has_object(expected));
@@ -373,7 +374,7 @@ mod write_blob {
     }
 
     #[test]
-    fn from_stream() -> crate::Result {
+    fn from_stream() -> Result {
         let repo = empty_bare_in_memory_repo()?;
         let mut cursor = std::io::Cursor::new(b"hello world");
         let mut seek_cursor = cursor.clone();
@@ -397,7 +398,7 @@ mod write_blob {
 }
 
 #[test]
-fn writes_avoid_io_using_duplicate_check() -> crate::Result {
+fn writes_avoid_io_using_duplicate_check() -> Result {
     let (mut repo, _tmp) = crate::repo_rw("make_packed_and_loose.sh")?;
     let store = gix::odb::loose::Store::at(repo.git_dir().join("objects"), repo.object_hash());
     let loose_count = store.iter().count();
@@ -471,13 +472,14 @@ fn writes_avoid_io_using_duplicate_check() -> crate::Result {
 }
 
 mod find {
+    use crate::Result;
     use gix_pack::Find;
 
     use crate::basic_repo;
     use crate::repository::object::empty_bare_in_memory_repo;
 
     #[test]
-    fn find_and_try_find_with_and_without_object_cache() -> crate::Result {
+    fn find_and_try_find_with_and_without_object_cache() -> Result {
         let mut repo = basic_repo()?;
 
         assert_eq!(
@@ -516,7 +518,7 @@ mod find {
     }
 
     #[test]
-    fn empty_tree_can_always_be_found() -> crate::Result {
+    fn empty_tree_can_always_be_found() -> Result {
         let repo = basic_repo()?;
         let empty_tree = gix::hash::ObjectId::empty_tree(repo.object_hash());
         assert_eq!(repo.find_object(empty_tree)?.into_tree().iter().count(), 0);
@@ -555,7 +557,7 @@ mod find {
     }
 
     #[test]
-    fn empty_blob_can_be_found_if_it_exists() -> crate::Result {
+    fn empty_blob_can_be_found_if_it_exists() -> Result {
         let repo = basic_repo()?;
         let empty_blob = gix::hash::ObjectId::empty_blob(repo.object_hash());
 
@@ -593,7 +595,7 @@ mod find {
     }
 
     #[test]
-    fn empty_blob() -> crate::Result {
+    fn empty_blob() -> Result {
         let repo = empty_bare_in_memory_repo()?;
         let empty_blob = repo.empty_blob();
 
@@ -609,7 +611,7 @@ mod find {
 }
 
 #[test]
-fn empty_objects_are_always_present_but_not_in_plumbing() -> crate::Result {
+fn empty_objects_are_always_present_but_not_in_plumbing() -> Result {
     let repo = empty_bare_in_memory_repo()?;
     let empty_blob_id = repo.object_hash().empty_blob();
 
@@ -619,14 +621,17 @@ fn empty_objects_are_always_present_but_not_in_plumbing() -> crate::Result {
     );
     assert!(!repo.objects.contains(&empty_blob_id));
 
-    assert!(
-        repo.find_header(empty_blob_id).is_err(),
-        "Empty blob doesn't exist automatically just like in Git"
-    );
+    let err = repo
+        .find_header(empty_blob_id)
+        .expect_err("empty blob doesn't exist automatically just like in Git");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "empty objects are always present but not in plumbing", @"An object with id Oid(1) could not be found");
+    assert!(err.is_not_found());
     assert_eq!(repo.objects.try_header(&empty_blob_id)?, None);
 
     assert_eq!(repo.try_find_header(empty_blob_id)?, None);
-    assert!(repo.find_object(empty_blob_id).is_err());
+    let err = repo.find_object(empty_blob_id).expect_err("empty blob doesn't exist");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "empty objects are always present but not in plumbing", @"An object with id Oid(1) could not be found");
+    assert!(err.is_not_found());
 
     assert!(repo.try_find_object(empty_blob_id)?.is_none());
     let mut buf = Vec::new();
@@ -636,8 +641,10 @@ fn empty_objects_are_always_present_but_not_in_plumbing() -> crate::Result {
 }
 
 mod tag {
+    use crate::Result;
+
     #[test]
-    fn simple() -> crate::Result {
+    fn simple() -> Result {
         let (repo, _keep) = crate::repo_rw("make_basic_repo.sh")?;
         let current_head_id = repo.head_id()?;
         let message = "a multi\nline message";
@@ -666,11 +673,12 @@ mod tag {
 }
 
 mod commit_as {
+    use crate::Result;
     use gix_date::parse::TimeBuf;
     use gix_testtools::tempfile;
 
     #[test]
-    fn specify_committer_and_author() -> crate::Result {
+    fn specify_committer_and_author() -> Result {
         let tmp = tempfile::tempdir()?;
         let repo = crate::init_repo_isolated(&tmp, gix::create::Kind::WithWorktree)?.to_thread_local();
         let empty_tree = repo.empty_tree();
@@ -703,6 +711,7 @@ mod commit_as {
 }
 
 mod commit {
+    use crate::Result;
     use gix_testtools::tempfile;
 
     use crate::{freeze_time, restricted_and_git, util::hex_to_id};
@@ -723,7 +732,7 @@ mod commit {
     }
 
     #[test]
-    fn parent_in_initial_commit_causes_failure() -> crate::Result {
+    fn parent_in_initial_commit_causes_failure() -> Result {
         let tmp = tempfile::tempdir()?;
         let repo = gix::ThreadSafeRepository::init_opts(
             &tmp,
@@ -735,18 +744,24 @@ mod commit {
         let empty_tree_id = repo.write_object(gix::objs::Tree::empty())?.detach();
         let err = repo
             .commit("HEAD", "initial", empty_tree_id, [empty_tree_id])
-            .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            "Reference \"refs/heads/main\" was supposed to exist with value 4b825dc642cb6eb9a060e54bf8d69288fbee4904, but didn't.",
-            "cannot provide parent id in initial commit"
+            .expect_err("an initial commit cannot have a parent");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[]), "the expected previous reference value is absent", @r#"
+        Could not prepare reference edit, "reference"="HEAD", "referent"="refs/heads/main"
+        |
+        └─ The reference must exist with content Oid(1)
+        "#);
+        assert!(err.is_not_found(), "the expected previous reference value is absent");
+        assert_eq!(
+            err.metadata().next().expect("the failed edit has context")["reference"],
+            gix::error::MetadataValue::from(b"HEAD".as_slice()),
+            "the error identifies the requested reference"
         );
         Ok(())
     }
 
     #[test]
     #[serial_test::serial]
-    fn single_line_initial_commit_empty_tree_ref_nonexisting() -> crate::Result {
+    fn single_line_initial_commit_empty_tree_ref_nonexisting() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         let _env = freeze_time();
         let tmp = tempfile::tempdir()?;
@@ -785,7 +800,7 @@ mod commit {
 
     #[test]
     #[serial_test::serial]
-    fn multi_line_commit_message_uses_first_line_in_ref_log_ref_nonexisting() -> crate::Result {
+    fn multi_line_commit_message_uses_first_line_in_ref_log_ref_nonexisting() -> Result {
         let _environment = gix_testtools::isolate_git_environment()?;
         let _env = freeze_time();
         let (repo, _keep) = crate::repo_rw_opts("make_basic_repo.sh", restricted_and_git())?;
@@ -814,7 +829,7 @@ mod commit {
             .log_iter()
             .rev()?
             .expect("log present")
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .map(|l| l.message)
             .collect();
         assert_eq!(
@@ -858,7 +873,7 @@ mod commit {
 }
 
 #[test]
-fn new_commit_as() -> crate::Result {
+fn new_commit_as() -> Result {
     let repo = empty_bare_in_memory_repo()?;
     let empty_tree = repo.empty_tree();
     let committer = gix::actor::Signature {
@@ -905,7 +920,7 @@ fn new_commit_as() -> crate::Result {
 }
 
 #[test]
-fn new_commit() -> crate::Result {
+fn new_commit() -> Result {
     let mut repo = empty_bare_in_memory_repo()?;
     let mut config = repo.config_snapshot_mut();
     config.set_value(&gix::config::tree::User::NAME, "user")?;
@@ -924,11 +939,11 @@ fn new_commit() -> crate::Result {
     Ok(())
 }
 
-fn empty_bare_in_memory_repo() -> crate::Result<gix::Repository> {
+fn empty_bare_in_memory_repo() -> Result<gix::Repository> {
     Ok(named_subrepo_opts("make_basic_repo.sh", "bare.git", gix::open::Options::isolated())?.with_object_memory())
 }
 
-fn empty_bare_repo() -> crate::Result<(tempfile::TempDir, gix::Repository)> {
+fn empty_bare_repo() -> Result<(tempfile::TempDir, gix::Repository)> {
     let tmp = tempfile::tempdir()?;
     let object_hash = gix_testtools::object_hash();
     let repo = gix::ThreadSafeRepository::init_opts(
diff --git a/gix/tests/gix/repository/open.rs b/gix/tests/gix/repository/open.rs
index e8ec65b1c6d..8c18b5cbcb8 100644
--- a/gix/tests/gix/repository/open.rs
+++ b/gix/tests/gix/repository/open.rs
@@ -1,4 +1,5 @@
-use std::{borrow::Cow, error::Error};
+use crate::Result;
+use std::borrow::Cow;
 
 use gix::bstr::BString;
 use gix::config::tree::Key;
@@ -13,7 +14,7 @@ fn open_permissions_is_isolated() {
 
 #[test]
 #[serial_test::serial]
-fn discover_with_git_dir_environment_override_uses_it_and_sets_trust() -> crate::Result {
+fn discover_with_git_dir_environment_override_uses_it_and_sets_trust() -> Result {
     let _environment = gix_testtools::isolate_git_environment()?;
     let fallback = gix_testtools::tempfile::TempDir::new()?;
     crate::init_repo_isolated(fallback.path(), gix::create::Kind::WithWorktree)?;
@@ -41,7 +42,7 @@ fn discover_with_git_dir_environment_override_uses_it_and_sets_trust() -> crate:
 }
 
 #[test]
-fn core_worktree_paths_are_literal() -> crate::Result {
+fn core_worktree_paths_are_literal() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only("make_literal_worktree_paths.sh")?;
     let baseline = std::fs::read_to_string(fixture.join("worktrees.baseline"))?;
     for line in baseline.lines() {
@@ -66,7 +67,7 @@ fn core_worktree_paths_are_literal() -> crate::Result {
 }
 
 #[test]
-fn core_worktree_cli_override_does_not_override_bare() -> crate::Result {
+fn core_worktree_cli_override_does_not_override_bare() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only("make_config_repos.sh")?;
     let worktree = gix_testtools::tempfile::TempDir::new()?;
     let repo = gix::open_opts(
@@ -84,7 +85,7 @@ fn core_worktree_cli_override_does_not_override_bare() -> crate::Result {
 }
 
 #[test]
-fn on_root_with_decomposed_unicode() -> crate::Result {
+fn on_root_with_decomposed_unicode() -> Result {
     let tmp = gix_testtools::tempfile::TempDir::new()?;
 
     let decomposed = "a\u{308}";
@@ -133,7 +134,7 @@ fn on_root_with_decomposed_unicode() -> crate::Result {
 }
 
 #[test]
-fn non_bare_reftable() -> crate::Result {
+fn non_bare_reftable() -> Result {
     let Some(root) = gix_testtools::scripted_fixture_read_only_with_git_version("make_reftable_repo.sh", |version| {
         version >= (2, 44, 0)
     })?
@@ -142,11 +143,11 @@ fn non_bare_reftable() -> crate::Result {
     };
     let repo = gix::open_opts(root.join("reftable-clone"), gix::open::Options::isolated())?;
     let err = repo.head_id().expect_err("reftable references are not supported");
-    assert_eq!(
-        err.source().expect("reference decoding error").to_string(),
-        "This reference uses an unsupported storage backend, such as reftable",
-        "accessing HEAD explains that the reference storage backend is unsupported"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "accessing HEAD explains that the reference storage backend is unsupported", @r#"
+    Message {
+        message: "This reference uses an unsupported storage backend, such as reftable",
+    }
+    "#);
     assert!(!repo.is_bare());
     assert_eq!(repo.kind(), gix::repository::Kind::Common);
     assert_ne!(
@@ -158,7 +159,7 @@ fn non_bare_reftable() -> crate::Result {
 }
 
 #[test]
-fn bare_repo_with_index() -> crate::Result {
+fn bare_repo_with_index() -> Result {
     let repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "bare-repo-with-index.git",
@@ -174,7 +175,7 @@ fn bare_repo_with_index() -> crate::Result {
 }
 
 #[test]
-fn git_index_file_overrides_the_index_in_the_git_dir() -> crate::Result {
+fn git_index_file_overrides_the_index_in_the_git_dir() -> Result {
     let repository = gix_testtools::scripted_fixture_writable("make_basic_repo.sh")?;
     let index_file = repository.path().join(".git/temporary-index");
     let repo = gix::open_opts(repository.path(), gix::open::Options::isolated())?;
@@ -213,7 +214,8 @@ fn git_index_file_overrides_the_index_in_the_git_dir() -> crate::Result {
     #[cfg(feature = "index")]
     {
         gix::index::File::from_state(gix::index::State::new(repo.object_hash()), index_file)
-            .write(Default::default())?;
+            .write(Default::default())
+            .map_err(gix::Exn::into_error)?;
         assert!(
             repo.index()?.entries().is_empty(),
             "the configured index is read, and it's initially empty"
@@ -224,7 +226,7 @@ fn git_index_file_overrides_the_index_in_the_git_dir() -> crate::Result {
 
 #[test]
 #[cfg(feature = "index")]
-fn git_index_file_missing_yields_no_index() -> crate::Result {
+fn git_index_file_missing_yields_no_index() -> Result {
     let repository = gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")?;
     let index_file = repository.join(".git/missing");
     let repo = gix::open_opts(
@@ -245,7 +247,7 @@ fn git_index_file_missing_yields_no_index() -> crate::Result {
 }
 
 #[test]
-fn git_index_file_empty_is_invalid_even_with_lenient_config() -> crate::Result {
+fn git_index_file_empty_is_invalid_even_with_lenient_config() -> Result {
     assert!(
         gix::config::tree::gitoxide::Core::INDEX_FILE
             .validated_assignment("".into())
@@ -259,17 +261,17 @@ fn git_index_file_empty_is_invalid_even_with_lenient_config() -> crate::Result {
     )
     .expect_err("an empty index path must be rejected");
 
-    assert_eq!(
-        err.source().expect("configuration error").to_string(),
-        "The key \"gitoxide.core.indexFile=\" (possibly from GIT_INDEX_FILE) was invalid",
-        "an empty index path is never ignored, even though configuration is lenient by default"
-    );
+    insta::assert_debug_snapshot!(err, "an empty index path is never ignored, even though configuration is lenient by default", @r#"
+    Invalid configuration value, "environment_override"="GIT_INDEX_FILE", "input"="", "key"="gitoxide.core.indexFile"
+    |
+    └─ index file path must not be empty
+    "#);
     Ok(())
 }
 
 #[test]
 #[cfg(feature = "index")]
-fn git_index_file_receives_writes_while_the_git_dir_index_is_locked() -> crate::Result {
+fn git_index_file_receives_writes_while_the_git_dir_index_is_locked() -> Result {
     let repository = gix_testtools::scripted_fixture_writable("make_basic_repo.sh")?;
     let index_file = repository.path().join(".git/temporary-index");
     let repo = gix::open_opts(
@@ -283,7 +285,7 @@ fn git_index_file_receives_writes_while_the_git_dir_index_is_locked() -> crate::
     assert!(!index_file.exists());
     std::fs::write(repo.git_dir().join("index.lock"), [])?;
     let mut index = (**repo.index_or_empty()?).clone();
-    index.write(Default::default())?;
+    index.write(Default::default()).map_err(gix::Exn::into_error)?;
 
     assert!(index_file.is_file(), "the write lands on the configured index");
     assert_eq!(
@@ -295,7 +297,7 @@ fn git_index_file_receives_writes_while_the_git_dir_index_is_locked() -> crate::
 }
 
 #[test]
-fn non_bare_repo_with_git_extension() -> crate::Result {
+fn non_bare_repo_with_git_extension() -> Result {
     let repo = named_subrepo_opts("make_basic_repo.sh", "repo.git", gix::open::Options::isolated())?;
     assert_eq!(repo.kind(), gix::repository::Kind::Common);
     assert!(!repo.is_bare());
@@ -313,7 +315,7 @@ fn non_bare_repo_with_git_extension() -> crate::Result {
 }
 
 #[test]
-fn non_bare_turned_bare() -> crate::Result {
+fn non_bare_turned_bare() -> Result {
     let repo = named_subrepo_opts(
         "make_worktree_repo.sh",
         "non-bare-turned-bare",
@@ -329,7 +331,7 @@ fn non_bare_turned_bare() -> crate::Result {
 }
 
 #[test]
-fn worktree_of_bare_repo() -> crate::Result {
+fn worktree_of_bare_repo() -> Result {
     let repo = named_subrepo_opts(
         "make_worktree_repo.sh",
         "worktree-of-bare-repo",
@@ -356,7 +358,7 @@ fn worktree_of_bare_repo() -> crate::Result {
 }
 
 #[test]
-fn worktree_of_natively_bare_repo() -> crate::Result {
+fn worktree_of_natively_bare_repo() -> Result {
     let repo = named_subrepo_opts(
         "make_worktree_repo.sh",
         "worktree-of-natively-bare-repo",
@@ -383,7 +385,7 @@ fn worktree_of_natively_bare_repo() -> crate::Result {
 }
 
 #[test]
-fn natively_bare_repo_itself_is_common() -> crate::Result {
+fn natively_bare_repo_itself_is_common() -> Result {
     let repo = named_subrepo_opts(
         "make_worktree_repo.sh",
         "natively-bare-repo",
@@ -401,7 +403,7 @@ fn natively_bare_repo_itself_is_common() -> crate::Result {
 }
 
 #[test]
-fn non_bare_non_git_repo_without_worktree() -> crate::Result {
+fn non_bare_non_git_repo_without_worktree() -> Result {
     let repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "non-bare-without-worktree",
@@ -426,7 +428,7 @@ fn non_bare_non_git_repo_without_worktree() -> crate::Result {
 }
 
 #[test]
-fn none_bare_repo_without_index() -> crate::Result {
+fn none_bare_repo_without_index() -> Result {
     let mut repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "non-bare-repo-without-index",
@@ -476,7 +478,7 @@ fn none_bare_repo_without_index() -> crate::Result {
 }
 
 #[test]
-fn non_bare_split_worktree() -> crate::Result {
+fn non_bare_split_worktree() -> Result {
     for (name, worktree_exists) in [
         ("repo-with-worktree-in-config-unborn-no-worktreedir", false),
         ("repo-with-worktree-in-config-unborn", true),
@@ -498,23 +500,26 @@ fn non_bare_split_worktree() -> crate::Result {
 }
 
 #[test]
-fn non_bare_split_worktree_invalid_worktree_path_boolean() -> crate::Result {
+fn non_bare_split_worktree_invalid_worktree_path_boolean() -> Result {
     let err = named_subrepo_opts(
         "make_worktree_repo.sh",
         "repo-with-worktree-in-config-unborn-worktreedir-missing-value",
         gix::open::Options::isolated().strict_config(true),
     )
-    .unwrap_err();
-    assert_eq!(
-        err.source().expect("present").to_string(),
-        "The key \"core.worktree\" (possibly from GIT_WORK_TREE) was invalid",
-        "in strict mode, we fail just like git does"
-    );
+    .expect_err("a bare worktree-path key is invalid in strict mode");
+    assert!(err.is_validation(), "in strict mode, we fail just like git does");
+    insta::assert_debug_snapshot!(err, "non bare split worktree invalid worktree path boolean", @r#"
+    Message {
+        message: "Invalid configuration value",
+        class: Validation,
+        values: {"environment_override": String("GIT_WORK_TREE"), "key": String("core.worktree")},
+    }
+    "#);
     Ok(())
 }
 
 #[test]
-fn non_bare_split_worktree_invalid_worktree_path_empty() -> crate::Result {
+fn non_bare_split_worktree_invalid_worktree_path_empty() -> Result {
     // "repo-with-worktree-in-config-unborn-worktreedir-missing-value",
     let err = named_subrepo_opts(
         "make_worktree_repo.sh",
@@ -522,18 +527,32 @@ fn non_bare_split_worktree_invalid_worktree_path_empty() -> crate::Result {
         gix::open::Options::isolated(),
     )
     .unwrap_err();
+    insta::assert_debug_snapshot!(err, "DEVIATION: could not read path at core.worktree as empty is always invalid, git tries to use an empty path, even though it's better to reject it", @r#"
+    The path at the 'core.worktree' configuration could not be interpolated, "input"=""
+    |
+    └─ path is missing
+    "#);
     assert!(
-        matches!(
-            err,
-            gix::open::Error::Config(gix::config::Error::PathInterpolation { .. })
-        ),
+        err.is_validation(),
         "DEVIATION: could not read path at core.worktree as empty is always invalid, git tries to use an empty path, even though it's better to reject it"
     );
+    let validation = err
+        .classify()
+        .filter(|classification| classification.class() == gix_error::Class::Validation)
+        .find_map(|classification| classification.error().downcast_ref::<gix::error::Message>())
+        .expect("the invalid core.worktree path remains classified");
+    insta::assert_debug_snapshot!(validation, "non bare split worktree invalid worktree path empty", @r#"
+    Message {
+        message: "The path at the 'core.worktree' configuration could not be interpolated",
+        class: Validation,
+        values: {"input": Bytes("")},
+    }
+    "#);
     Ok(())
 }
 
 #[test]
-fn bare_with_worktree_is_still_bare() -> crate::Result {
+fn bare_with_worktree_is_still_bare() -> Result {
     let repo = named_subrepo_opts("make_config_repos.sh", "bare-link", gix::open::Options::isolated())?;
     assert!(
         repo.is_bare(),
@@ -551,10 +570,11 @@ fn bare_with_worktree_is_still_bare() -> crate::Result {
 
 mod missing_config_file {
 
+    use crate::Result;
     use crate::util::named_subrepo_opts;
 
     #[test]
-    fn bare() -> crate::Result {
+    fn bare() -> Result {
         let repo = named_subrepo_opts("make_config_repos.sh", "bare-no-config", gix::open::Options::isolated())?;
         assert!(
             repo.is_bare(),
@@ -572,7 +592,7 @@ mod missing_config_file {
     }
 
     #[test]
-    fn non_bare() -> crate::Result {
+    fn non_bare() -> Result {
         let repo = named_subrepo_opts(
             "make_config_repos.sh",
             "worktree-no-config",
@@ -595,24 +615,42 @@ mod missing_config_file {
 }
 
 mod not_a_repository {
+    use crate::Result;
 
     #[test]
-    fn shows_proper_error() -> crate::Result {
+    fn shows_proper_error() -> Result {
+        let mut error_snapshots = Vec::new();
         for name in ["empty-dir", "with-files"] {
             let name = format!("not-a-repo-{name}");
             let repo_path = gix_testtools::scripted_fixture_read_only("make_config_repos.sh")?.join(name);
             let err = gix::open_opts(&repo_path, gix::open::Options::isolated()).unwrap_err();
-            assert!(matches!(err, gix::open::Error::NotARepository { path, .. } if path == repo_path));
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&(repo_path).to_string_lossy(), "<repository>")],
+            ));
+            assert!(err.is_not_found());
         }
+        insta::assert_debug_snapshot!(error_snapshots, "shows proper error", @r#"
+        [
+            "<repository>" does not appear to be a git repository
+            |
+            └─ Missing HEAD at '.git/HEAD',
+            "<repository>" does not appear to be a git repository
+            |
+            └─ Missing HEAD at '.git/HEAD',
+        ]
+        "#);
         Ok(())
     }
 }
 
 mod object_format_extension {
+    use crate::Result;
     use crate::util::named_subrepo_opts;
 
     #[test]
-    fn rejects_object_format_on_v0_repo() -> crate::Result {
+    fn rejects_object_format_on_v0_repo() -> Result {
+        let mut error_snapshots = Vec::new();
         // objectFormat is a "v1-only" extension: git refuses to operate on a version-0 repo that
         // sets it, even for sha1 (unlike grandfathered extensions like preciousObjects, which v0
         // still honours). This rejection was introduced in git 2.29.0 (2020). We match it.
@@ -622,19 +660,27 @@ mod object_format_extension {
         ] {
             let err = named_subrepo_opts("make_config_repos.sh", name, gix::open::Options::isolated())
                 .expect_err("a v0 repository setting extensions.objectFormat must be rejected");
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
             assert!(
-                matches!(
-                    err,
-                    gix::open::Error::Config(gix::config::Error::ObjectFormatRequiresV1)
-                ),
+                err.is_validation(),
                 "objectFormat on a v0 repository must be rejected, got {err:?} for {name}"
             );
         }
+        insta::assert_debug_snapshot!(error_snapshots, "rejects object format on v0 repo", @"
+        [
+            Repository configuration could not be loaded
+            |
+            └─ extensions.objectFormat is a v1-only extension, but the repository format version is 0; set core.repositoryFormatVersion=1 to use it, or remove extensions.objectFormat to fall back to the default Sha1 format (if supported by this build),
+            Repository configuration could not be loaded
+            |
+            └─ extensions.objectFormat is a v1-only extension, but the repository format version is 0; set core.repositoryFormatVersion=1 to use it, or remove extensions.objectFormat to fall back to the default Sha1 format (if supported by this build),
+        ]
+        ");
         Ok(())
     }
 
     #[test]
-    fn rejects_future_repository_format_versions() -> crate::Result {
+    fn rejects_future_repository_format_versions() -> Result {
         let err = named_subrepo_opts(
             "make_config_repos.sh",
             "repository-format-v2-with-objectformat-sha1",
@@ -642,18 +688,22 @@ mod object_format_extension {
         )
         .expect_err("future repository format versions must be rejected");
         assert!(
-            matches!(
-                err,
-                gix::open::Error::Config(gix::config::Error::UnsupportedRepositoryFormatVersion { version: 2 })
-            ),
+            err.is_validation(),
             "future repository format versions must be rejected before interpreting extensions, got {err:?}"
         );
+        insta::assert_debug_snapshot!(err.probable_cause(), "rejects future repository format versions", @r#"
+        Message {
+            message: "Unsupported repository format version 2; only versions 0 and 1 are supported",
+            class: Validation,
+        }
+        "#);
         Ok(())
     }
 }
 
 mod open_path_as_is {
 
+    use crate::Result;
     use crate::util::{named_subrepo_opts, repo_opts};
 
     fn open_path_as_is() -> gix::open::Options {
@@ -661,26 +711,39 @@ mod open_path_as_is {
     }
 
     #[test]
-    fn bare_repos_open_normally() -> crate::Result {
+    fn bare_repos_open_normally() -> Result {
         assert!(named_subrepo_opts("make_basic_repo.sh", "bare.git", open_path_as_is())?.is_bare());
         Ok(())
     }
 
     #[test]
-    fn worktrees_cannot_be_opened() -> crate::Result {
+    fn worktrees_cannot_be_opened() -> Result {
         let err = repo_opts("make_basic_repo.sh", open_path_as_is()).unwrap_err();
-        assert!(matches!(err, gix::open::Error::NotARepository { .. }));
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&(gix_testtools::scripted_fixture_read_only("make_basic_repo.sh")?).to_string_lossy(), "<worktree>")]), "worktrees cannot be opened", @r#"
+        "<worktree>" does not appear to be a git repository
+        |
+        └─ Missing HEAD at '.git/HEAD'
+        "#);
+        assert!(err.is_not_found());
+        assert_eq!(
+            err.error()
+                .downcast_ref::<gix::error::Message>()
+                .and_then(|error| error.class),
+            Some(gix_error::Class::NotFound),
+            "the outer not-a-repository classification survives erasure"
+        );
         Ok(())
     }
 
     #[test]
-    fn git_dir_within_worktrees_open_normally() -> crate::Result {
+    fn git_dir_within_worktrees_open_normally() -> Result {
         assert!(!named_subrepo_opts("make_basic_repo.sh", ".git", open_path_as_is())?.is_bare());
         Ok(())
     }
 }
 
 mod submodules {
+    use crate::Result;
     use std::path::Path;
 
     #[test]
@@ -710,7 +773,7 @@ mod submodules {
         }
     }
 
-    fn discover_repo(name: impl AsRef<Path>) -> crate::Result<gix::Repository> {
+    fn discover_repo(name: impl AsRef<Path>) -> Result<gix::Repository> {
         let dir = gix_testtools::scripted_fixture_read_only("make_submodules.sh")?;
         let repo_dir = dir.join(name);
         Ok(gix::ThreadSafeRepository::discover_opts(
@@ -727,10 +790,11 @@ mod submodules {
 
 mod object_caches {
 
+    use crate::Result;
     use crate::util::named_subrepo_opts;
 
     #[test]
-    fn default_git_and_custom_caches() -> crate::Result {
+    fn default_git_and_custom_caches() -> Result {
         let opts = gix::open::Options::isolated();
         let repo = named_subrepo_opts("make_config_repos.sh", "object-caches", opts)?;
         assert_eq!(
@@ -745,7 +809,7 @@ mod object_caches {
     }
 
     #[test]
-    fn disabled() -> crate::Result {
+    fn disabled() -> Result {
         let opts = gix::open::Options::isolated();
         let repo = named_subrepo_opts("make_config_repos.sh", "disabled-object-caches", opts)?;
         assert!(!repo.objects.has_object_cache());
@@ -755,6 +819,7 @@ mod object_caches {
 }
 
 mod pack_alloc_limit_bytes {
+    use crate::Result;
     use gix_odb::HeaderExt;
     use gix_odb::find::Header;
     use gix_sec::Trust;
@@ -762,7 +827,7 @@ mod pack_alloc_limit_bytes {
     use crate::util::repo_opts;
 
     #[test]
-    fn limits_packed_object_allocations() -> crate::Result {
+    fn limits_packed_object_allocations() -> Result {
         let repo = repo_opts("make_packed_and_loose.sh", crate::util::restricted())?.to_thread_local();
         let packed_only_id = repo
             .objects
@@ -790,7 +855,7 @@ mod pack_alloc_limit_bytes {
     }
 
     #[test]
-    fn limits_loose_object_allocations() -> crate::Result {
+    fn limits_loose_object_allocations() -> Result {
         let repo = repo_opts("make_packed_and_loose.sh", crate::util::restricted())?.to_thread_local();
         let loose_only_blob_id = repo
             .objects
@@ -834,12 +899,12 @@ mod pack_alloc_limit_bytes {
     }
 
     #[test]
-    fn reduced_trust_sets_a_default_limit_unless_disabled() -> crate::Result {
+    fn reduced_trust_sets_a_default_limit_unless_disabled() -> Result {
         let base = repo_opts("make_packed_and_loose.sh", crate::util::restricted())?.to_thread_local();
         let packed_only_id = base
             .objects
             .iter()?
-            .map(Result::unwrap)
+            .map(std::result::Result::unwrap)
             .next()
             .expect("fixture contains packed-only objects");
         assert!(
diff --git a/gix/tests/gix/repository/pathspec.rs b/gix/tests/gix/repository/pathspec.rs
index 50e951a3078..0b2ff1c4cdf 100644
--- a/gix/tests/gix/repository/pathspec.rs
+++ b/gix/tests/gix/repository/pathspec.rs
@@ -1,10 +1,11 @@
+use crate::Result;
 use gix::{bstr::ByteSlice, config::tree::gitoxide};
 use gix_worktree::stack::state::attributes::Source;
 
 use crate::util::named_repo;
 
 #[test]
-fn defaults_are_taken_from_repo_config() -> crate::Result {
+fn defaults_are_taken_from_repo_config() -> Result {
     let mut repo = named_repo("make_basic_repo.sh")?;
     repo.config_snapshot_mut()
         .set_value(&gitoxide::Pathspec::ICASE, "true")?;
diff --git a/gix/tests/gix/repository/reference.rs b/gix/tests/gix/repository/reference.rs
index 521385b8509..ea59aa9c6df 100644
--- a/gix/tests/gix/repository/reference.rs
+++ b/gix/tests/gix/repository/reference.rs
@@ -1,13 +1,16 @@
+use crate::Result;
+
 mod set_namespace {
+    use crate::Result;
     use gix::refs::transaction::PreviousValue;
     use gix_testtools::tempfile;
 
-    fn easy_repo_rw() -> crate::Result<(gix::Repository, tempfile::TempDir)> {
+    fn easy_repo_rw() -> Result<(gix::Repository, tempfile::TempDir)> {
         crate::repo_rw("make_references_repo.sh")
     }
 
     #[test]
-    fn affects_edits_and_iteration() -> crate::Result {
+    fn affects_edits_and_iteration() -> Result {
         let (mut repo, _keep) = easy_repo_rw()?;
         assert_eq!(
             repo.references()?.all()?.count(),
@@ -18,7 +21,7 @@ mod set_namespace {
         assert!(repo.set_namespace("foo")?.is_none(), "there is no previous namespace");
 
         assert_eq!(
-            repo.references()?.all()?.filter_map(Result::ok).count(),
+            repo.references()?.all()?.filter_map(std::result::Result::ok).count(),
             0,
             "no references are in the namespace yet"
         );
@@ -33,7 +36,10 @@ mod set_namespace {
         )?;
 
         assert_eq!(
-            repo.references()?.all()?.filter_map(Result::ok).collect::<Vec<_>>(),
+            repo.references()?
+                .all()?
+                .filter_map(std::result::Result::ok)
+                .collect::<Vec<_>>(),
             vec!["refs/heads/new-branch", "refs/tags/new-tag"],
             "namespaced references appear like normal ones"
         );
@@ -41,7 +47,7 @@ mod set_namespace {
         assert_eq!(
             repo.references()?
                 .prefixed("refs/tags/")?
-                .filter_map(Result::ok)
+                .filter_map(std::result::Result::ok)
                 .collect::<Vec<_>>(),
             vec!["refs/tags/new-tag"],
             "namespaced references appear like normal ones"
@@ -72,7 +78,7 @@ mod set_namespace {
 }
 
 #[test]
-fn try_find_reference_with_existing_ref_as_path_prefix_returns_none() -> crate::Result {
+fn try_find_reference_with_existing_ref_as_path_prefix_returns_none() -> Result {
     let (repo, _tmp) = crate::repo_rw("make_references_repo.sh")?;
     std::fs::create_dir_all(repo.git_dir().join("refs/heads"))?;
     std::fs::write(
@@ -88,17 +94,21 @@ fn try_find_reference_with_existing_ref_as_path_prefix_returns_none() -> crate::
 }
 
 mod iter_references {
+    use crate::Result;
     use crate::util::hex_to_id;
 
-    fn repo() -> crate::Result<gix::Repository> {
+    fn repo() -> Result<gix::Repository> {
         crate::repo("make_references_repo.sh").map(|r| r.to_thread_local())
     }
 
     #[test]
-    fn all() -> crate::Result {
+    fn all() -> Result {
         let repo = repo()?;
         assert_eq!(
-            repo.references()?.all()?.filter_map(Result::ok).collect::<Vec<_>>(),
+            repo.references()?
+                .all()?
+                .filter_map(std::result::Result::ok)
+                .collect::<Vec<_>>(),
             vec![
                 "refs/d1",
                 "refs/heads/d1",
@@ -122,12 +132,12 @@ mod iter_references {
     }
 
     #[test]
-    fn prefixed() -> crate::Result {
+    fn prefixed() -> Result {
         let repo = repo()?;
         assert_eq!(
             repo.references()?
                 .prefixed("refs/heads/")?
-                .filter_map(Result::ok)
+                .filter_map(std::result::Result::ok)
                 .map(|r| (
                     r.name().as_bstr().to_string(),
                     r.target().try_id().map(ToOwned::to_owned)
@@ -153,13 +163,13 @@ mod iter_references {
     }
 
     #[test]
-    fn prefixed_and_peeled() -> crate::Result {
+    fn prefixed_and_peeled() -> Result {
         let repo = repo()?;
         assert_eq!(
             repo.references()?
                 .prefixed(b"refs/heads/")?
                 .peeled()?
-                .filter_map(Result::ok)
+                .filter_map(std::result::Result::ok)
                 .map(|r| (
                     r.name().as_bstr().to_string(),
                     r.target().try_id().map(ToOwned::to_owned)
@@ -190,12 +200,12 @@ mod iter_references {
     /// Regression test for https://github.com/GitoxideLabs/gitoxide/issues/2103
     /// This only ensures we can return a reference, not that the code below is correct
     #[test]
-    fn tags() -> crate::Result {
+    fn tags() -> Result {
         let repo = repo()?;
         let actual = repo
             .references()?
             .tags()?
-            .filter_map(Result::ok)
+            .filter_map(std::result::Result::ok)
             .max_by_key(|tag| tag.name().shorten().to_owned())
             .ok_or(std::io::Error::other("latest tag not found"))?;
         assert_eq!(actual, "refs/tags/t1");
@@ -205,12 +215,13 @@ mod iter_references {
 
 mod head {
 
+    use crate::Result;
     use gix_ref::transaction::PreviousValue;
 
     use crate::util::hex_to_id;
 
     #[test]
-    fn symbolic() -> crate::Result {
+    fn symbolic() -> Result {
         let repo = crate::basic_repo()?;
         let head = repo.head()?;
         match &head.kind {
@@ -228,7 +239,7 @@ mod head {
     }
 
     #[test]
-    fn detached() -> crate::Result {
+    fn detached() -> Result {
         let (repo, _keep) = crate::basic_rw_repo()?;
         repo.reference(
             "HEAD",
diff --git a/gix/tests/gix/repository/remote.rs b/gix/tests/gix/repository/remote.rs
index aeab08451cd..f7cb9b899ea 100644
--- a/gix/tests/gix/repository/remote.rs
+++ b/gix/tests/gix/repository/remote.rs
@@ -1,10 +1,11 @@
 mod remote_at {
+    use crate::Result;
     use gix::remote::Direction;
 
     use crate::remote;
 
     #[test]
-    fn url_and_push_url() -> crate::Result {
+    fn url_and_push_url() -> Result {
         let repo = remote::repo("base");
         let fetch_url = "https://github.com/byron/gitoxide";
         let remote = repo.remote_at(fetch_url)?;
@@ -44,7 +45,7 @@ mod remote_at {
     }
 
     #[test]
-    fn url_rewrites_are_respected() -> crate::Result {
+    fn url_rewrites_are_respected() -> Result {
         let repo = remote::repo("url-rewriting");
         let remote = repo.remote_at("https://github.com/foobar/gitoxide")?;
 
@@ -94,7 +95,7 @@ mod remote_at {
     }
 
     #[test]
-    fn url_rewrites_can_be_skipped() -> crate::Result {
+    fn url_rewrites_can_be_skipped() -> Result {
         let repo = remote::repo("url-rewriting");
         let remote = repo.remote_at_without_url_rewrite("https://github.com/foobar/gitoxide")?;
 
@@ -149,7 +150,7 @@ mod remote_at {
     }
 
     #[test]
-    fn with_url_ignores_bad_push_fallback_rewrites() -> crate::Result {
+    fn with_url_ignores_bad_push_fallback_rewrites() -> Result {
         let repo = remote::repo("bad-push-fallback-url-rewriting");
         let remote = repo.remote_at("alias:one")?.with_url("alias:two")?;
 
@@ -168,6 +169,7 @@ mod remote_at {
 }
 
 mod find_remote {
+    use crate::Result;
     use std::io::BufRead;
 
     use gix::{Repository, remote::Direction};
@@ -176,7 +178,7 @@ mod find_remote {
     use crate::remote;
 
     #[test]
-    fn tags_option() -> crate::Result {
+    fn tags_option() -> Result {
         let repo = remote::repo("clone-no-tags");
         for (remote_name, expected) in [
             ("origin", gix::remote::fetch::Tags::None),
@@ -190,7 +192,7 @@ mod find_remote {
     }
 
     #[test]
-    fn typical() -> crate::Result {
+    fn typical() -> Result {
         let repo = remote::repo("clone");
         let mut count = 0;
         let base_dir = base_dir(&repo);
@@ -224,15 +226,19 @@ mod find_remote {
             );
         }
         assert!(count > 0, "should have seen more than one commit");
-        assert!(matches!(
-            repo.find_remote("unknown").unwrap_err(),
-            gix::remote::find::existing::Error::NotFound { .. }
-        ));
+        let err = repo.find_remote("unknown").unwrap_err();
+        assert!(err.is_not_found());
+        insta::assert_debug_snapshot!(err, "remote lookup identifies the missing remote name", @r#"
+        Message {
+            message: "The remote named \"unknown\" did not exist",
+            class: NotFound,
+        }
+        "#);
         Ok(())
     }
 
     #[test]
-    fn missing_fetch_urls_only_fall_back_to_url_shaped_remote_names() -> crate::Result {
+    fn missing_fetch_urls_only_fall_back_to_url_shaped_remote_names() -> Result {
         let repo = remote::repo("missing-urls");
         for name in ["no-url", "reset-url"] {
             let remote = repo.find_remote(name)?;
@@ -296,11 +302,11 @@ mod find_remote {
     }
 
     #[test]
-    fn instead_of_url_rewriting() -> crate::Result {
+    fn instead_of_url_rewriting() -> Result {
         let repo = remote::repo("url-rewriting");
 
         let baseline = std::fs::read(repo.git_dir().join("baseline.git"))?;
-        let mut baseline = baseline.lines().map_while(Result::ok);
+        let mut baseline = baseline.lines().map_while(std::result::Result::ok);
         let expected_fetch_url: BString = baseline.next().expect("fetch").into();
         let expected_push_url: BString = baseline.next().expect("push").into();
 
@@ -341,11 +347,11 @@ mod find_remote {
     }
 
     #[test]
-    fn bad_url_rewriting_can_be_handled_much_like_git() -> crate::Result {
+    fn bad_url_rewriting_can_be_handled_much_like_git() -> Result {
         let repo = remote::repo("bad-url-rewriting");
 
         let baseline = std::fs::read(repo.git_dir().join("baseline.git"))?;
-        let mut baseline = baseline.lines().map_while(Result::ok);
+        let mut baseline = baseline.lines().map_while(std::result::Result::ok);
         let expected_fetch_url: BString = baseline.next().expect("fetch").into();
         let expected_push_url: BString = baseline.next().expect("push").into();
         assert_eq!(
@@ -395,11 +401,11 @@ mod find_remote {
     }
 
     #[test]
-    fn multiple_urls_are_preserved_in_order_and_single_url_matches_git_first_url() -> crate::Result {
+    fn multiple_urls_are_preserved_in_order_and_single_url_matches_git_first_url() -> Result {
         let repo = remote::repo("multiple-urls");
 
         let baseline = std::fs::read(repo.git_dir().join("baseline.git"))?;
-        let mut baseline = baseline.lines().map_while(Result::ok);
+        let mut baseline = baseline.lines().map_while(std::result::Result::ok);
         let expected_fetch_url: BString = baseline.next().expect("single fetch").into();
         let expected_fetch_urls: Vec<BString> = baseline
             .by_ref()
@@ -453,15 +459,17 @@ mod find_remote {
     }
 
     #[test]
-    fn multiple_url_rewriting_preserves_successful_rewrites_when_another_url_fails() -> crate::Result {
+    fn multiple_url_rewriting_preserves_successful_rewrites_when_another_url_fails() -> Result {
         let repo = remote::repo("multiple-bad-url-rewriting");
 
         let mut remote = repo.try_find_remote_without_url_rewrite("origin").expect("exists")?;
-        assert_eq!(
-            remote.rewrite_urls().unwrap_err().to_string(),
-            "The rewritten fetch url \":://gitoxide\" failed to parse",
-            "one malformed rewrite is reported"
-        );
+        insta::assert_debug_snapshot!(remote.rewrite_urls().expect_err("one malformed rewrite is reported"), "one malformed rewrite is reported", @r#"
+        The rewritten fetch url ":://gitoxide" failed to parse
+        |
+        └─ URL can not be parsed as valid URL, "input"=":://gitoxide"
+        |
+        └─ relative URL without a base
+        "#);
         assert_eq!(
             urls(&remote, Direction::Fetch),
             ["https://github.com/byron/gitoxide", "bad:gitoxide"],
@@ -472,11 +480,11 @@ mod find_remote {
     }
 
     #[test]
-    fn empty_url_values_reset_earlier_url_lists() -> crate::Result {
+    fn empty_url_values_reset_earlier_url_lists() -> Result {
         let repo = remote::repo("multiple-urls-with-empty-reset");
 
         let baseline = std::fs::read(repo.git_dir().join("baseline.git"))?;
-        let mut baseline = baseline.lines().map_while(Result::ok);
+        let mut baseline = baseline.lines().map_while(std::result::Result::ok);
         let expected_fetch_url: BString = baseline.next().expect("single fetch").into();
         let expected_fetch_urls: Vec<BString> = baseline
             .by_ref()
@@ -512,7 +520,7 @@ mod find_remote {
     }
 
     #[test]
-    fn bad_push_fallback_rewriting_does_not_break_fetch_remote() -> crate::Result {
+    fn bad_push_fallback_rewriting_does_not_break_fetch_remote() -> Result {
         let repo = remote::repo("bad-push-fallback-url-rewriting");
 
         let remote = repo.find_remote("origin")?;
@@ -528,11 +536,13 @@ mod find_remote {
         );
 
         let mut remote = repo.try_find_remote_without_url_rewrite("origin").expect("exists")?;
-        assert_eq!(
-            remote.rewrite_urls().unwrap_err().to_string(),
-            "The rewritten push url \":://repo\" failed to parse",
-            "explicit rewriting still reports the malformed push fallback rewrite"
-        );
+        insta::assert_debug_snapshot!(remote.rewrite_urls().expect_err("explicit rewriting still reports the malformed push fallback rewrite"), "explicit rewriting still reports the malformed push fallback rewrite", @r#"
+        The rewritten push url ":://repo" failed to parse
+        |
+        └─ URL can not be parsed as valid URL, "input"=":://repo"
+        |
+        └─ relative URL without a base
+        "#);
         assert_eq!(
             remote.url(Direction::Fetch).expect("present").to_bstring(),
             "alias:repo",
@@ -543,23 +553,26 @@ mod find_remote {
     }
 
     #[test]
-    fn bad_explicit_push_url_rewriting_is_reported_as_push_url() -> crate::Result {
+    fn bad_explicit_push_url_rewriting_is_reported_as_push_url() -> Result {
         let repo = remote::repo("bad-explicit-push-url-rewriting");
 
-        let expected_err_msg = "The rewritten push url \":://repo\" failed to parse";
-        assert_eq!(
-            repo.find_remote("origin").unwrap_err().to_string(),
-            expected_err_msg,
-            "explicit pushUrl values use normal insteadOf rewriting, 
-            so a malformed result must fail and be labeled as a push URL error"
-        );
+        insta::assert_debug_snapshot!(repo.find_remote("origin")
+                .expect_err("rewriting the explicit push URL produces a malformed URL"), "explicit pushUrl values use insteadOf rewriting and report failures as push URL errors", @r#"
+        The rewritten push url ":://repo" failed to parse
+        |
+        └─ URL can not be parsed as valid URL, "input"=":://repo"
+        |
+        └─ relative URL without a base
+        "#);
 
         let mut remote = repo.try_find_remote_without_url_rewrite("origin").expect("exists")?;
-        assert_eq!(
-            remote.rewrite_urls().unwrap_err().to_string(),
-            expected_err_msg,
-            "refreshing rewrites also rejects the malformed result of applying insteadOf to an explicit pushUrl"
-        );
+        insta::assert_debug_snapshot!(remote.rewrite_urls().expect_err("refreshing rewrites also rejects the malformed result of applying insteadOf to an explicit pushUrl"), "refreshing rewrites also rejects the malformed result of applying insteadOf to an explicit pushUrl", @r#"
+        The rewritten push url ":://repo" failed to parse
+        |
+        └─ URL can not be parsed as valid URL, "input"=":://repo"
+        |
+        └─ relative URL without a base
+        "#);
 
         Ok(())
     }
@@ -594,10 +607,11 @@ mod find_remote {
 }
 
 mod find_fetch_remote {
+    use crate::Result;
     use crate::remote;
 
     #[test]
-    fn symbol_name() -> crate::Result {
+    fn symbol_name() -> Result {
         let repo = remote::repo("clone-no-tags");
         assert_eq!(
             repo.find_fetch_remote(Some("origin".into()))?
@@ -610,7 +624,7 @@ mod find_fetch_remote {
     }
 
     #[test]
-    fn urls() -> crate::Result {
+    fn urls() -> Result {
         let repo = remote::repo("clone-no-tags");
         for url in [
             "some-path",
@@ -635,10 +649,11 @@ mod find_fetch_remote {
 
 mod find_default_remote {
 
+    use crate::Result;
     use crate::remote;
 
     #[test]
-    fn works_on_detached_heads() -> crate::Result {
+    fn works_on_detached_heads() -> Result {
         let repo = remote::repo("detached-head");
         assert_eq!(
             repo.find_default_remote(gix::remote::Direction::Fetch)
diff --git a/gix/tests/gix/repository/shallow.rs b/gix/tests/gix/repository/shallow.rs
index d7b8bb7812a..43897104b39 100644
--- a/gix/tests/gix/repository/shallow.rs
+++ b/gix/tests/gix/repository/shallow.rs
@@ -1,8 +1,9 @@
+use crate::Result;
 use serial_test::parallel;
 
 use crate::util::{hex_to_id, named_subrepo_opts};
 
-fn shallow_ids(repo: &gix::Repository) -> crate::Result<Vec<gix::ObjectId>> {
+fn shallow_ids(repo: &gix::Repository) -> Result<Vec<gix::ObjectId>> {
     let commits = repo.shallow_commits()?.expect("present");
     Ok(std::iter::once(commits.head)
         .chain(commits.tail.iter().copied())
@@ -11,7 +12,7 @@ fn shallow_ids(repo: &gix::Repository) -> crate::Result<Vec<gix::ObjectId>> {
 
 #[test]
 #[parallel]
-fn no() -> crate::Result {
+fn no() -> Result {
     for name in ["base", "empty"] {
         let repo = named_subrepo_opts("make_shallow_repo.sh", name, crate::restricted())?;
         assert!(!repo.is_shallow());
@@ -21,7 +22,7 @@ fn no() -> crate::Result {
             .ancestors()
             .all()?
             .map(|c| c.map(|c| c.id))
-            .collect::<Result<_, _>>()?;
+            .collect::<std::result::Result<_, _>>()?;
         let expected = if name == "base" {
             vec![
                 hex_to_id("30887839de28edf7ab66c860e5c58b4d445f6b12"),
@@ -38,7 +39,7 @@ fn no() -> crate::Result {
 
 #[test]
 #[parallel]
-fn yes() -> crate::Result {
+fn yes() -> Result {
     for name in ["shallow.git", "shallow"] {
         let repo = named_subrepo_opts("make_shallow_repo.sh", name, crate::restricted())?;
         assert!(repo.is_shallow());
@@ -51,6 +52,7 @@ fn yes() -> crate::Result {
 }
 
 mod traverse {
+    use crate::Result;
     use gix_traverse::commit::simple::CommitTimeOrder;
     use serial_test::parallel;
 
@@ -58,7 +60,7 @@ mod traverse {
 
     #[test]
     #[parallel]
-    fn boundary_is_detected_triggering_no_error() -> crate::Result {
+    fn boundary_is_detected_triggering_no_error() -> Result {
         for sorting in [
             gix::revision::walk::Sorting::BreadthFirst,
             gix::revision::walk::Sorting::ByCommitTime(CommitTimeOrder::NewestFirst),
@@ -77,7 +79,7 @@ mod traverse {
                         .sorting(sorting)
                         .all()?
                         .map(|c| c.map(|c| c.id))
-                        .collect::<Result<_, _>>()?;
+                        .collect::<std::result::Result<_, _>>()?;
                     assert_eq!(commits, [hex_to_id("30887839de28edf7ab66c860e5c58b4d445f6b12")]);
                 }
             }
@@ -87,7 +89,7 @@ mod traverse {
 
     #[test]
     #[parallel]
-    fn complex_graphs_can_be_iterated_despite_multiple_shallow_boundaries() -> crate::Result {
+    fn complex_graphs_can_be_iterated_despite_multiple_shallow_boundaries() -> Result {
         let base = gix_path::realpath(gix_testtools::scripted_fixture_read_only("make_remote_repos.sh")?.join("base"))?;
         let shallow_base = gix_testtools::scripted_fixture_read_only_with_args_single_archive(
             "make_complex_shallow_repo.sh",
@@ -120,7 +122,7 @@ mod traverse {
                     .sorting(gix::revision::walk::Sorting::ByCommitTime(CommitTimeOrder::NewestFirst))
                     .all()?
                     .map(|c| c.map(|c| c.id))
-                    .collect::<Result<_, _>>()?;
+                    .collect::<std::result::Result<_, _>>()?;
                 assert_eq!(
                     commits,
                     [
diff --git a/gix/tests/gix/repository/submodule.rs b/gix/tests/gix/repository/submodule.rs
index df00b4cff61..e04ebaeaefb 100644
--- a/gix/tests/gix/repository/submodule.rs
+++ b/gix/tests/gix/repository/submodule.rs
@@ -1,8 +1,9 @@
 mod modules_file {
+    use crate::Result;
     use crate::submodule::repo;
 
     #[test]
-    fn none_if_not_present() -> crate::Result {
+    fn none_if_not_present() -> Result {
         let repo = repo("module1")?;
         assert!(repo.open_modules_file()?.is_none(), "it's OK to not have such a file");
         assert!(
@@ -13,7 +14,7 @@ mod modules_file {
     }
 
     #[test]
-    fn is_read_from_worktree() -> crate::Result {
+    fn is_read_from_worktree() -> Result {
         let repo = repo("with-submodules")?;
         let modules = repo.modules()?.expect("present");
         assert_eq!(
@@ -25,7 +26,7 @@ mod modules_file {
     }
 
     #[test]
-    fn is_read_from_index_if_not_in_worktree() -> crate::Result {
+    fn is_read_from_index_if_not_in_worktree() -> Result {
         let repo = repo("with-submodules-in-index")?;
         assert!(
             repo.open_modules_file()?.is_none(),
@@ -41,7 +42,7 @@ mod modules_file {
     }
 
     #[test]
-    fn is_read_from_tree_if_not_in_index() -> crate::Result {
+    fn is_read_from_tree_if_not_in_index() -> Result {
         let repo = repo("with-submodules-in-tree")?;
         assert!(
             repo.open_modules_file()?.is_none(),
@@ -58,12 +59,13 @@ mod modules_file {
 }
 
 mod submodules {
+    use crate::Result;
     use gix::bstr::BString;
 
     use crate::{submodule::repo, util::hex_to_id};
 
     #[test]
-    fn all_modules_are_active_by_default() -> crate::Result {
+    fn all_modules_are_active_by_default() -> Result {
         let repo = repo("with-submodules")?;
         let id = hex_to_id("e046f3e51d955840619fc7d01fbd9a469663de22");
         assert_eq!(
@@ -98,13 +100,14 @@ mod submodules {
 
 #[cfg(unix)]
 mod advisory {
+    use crate::Result;
     use gix_testtools::tempfile;
 
     /// Reproducer for GHSA-pg4w-g64p-qwhj: `Repository::open_modules_file()` and
     /// `Repository::submodules()` currently follow a symlinked worktree `.gitmodules`, allowing
     /// attacker-controlled bytes outside the repository to define submodule configuration.
     #[test]
-    fn symlinked_gitmodules_are_rejected() -> crate::Result {
+    fn symlinked_gitmodules_are_rejected() -> Result {
         use std::os::unix::fs as unix_fs;
 
         let temp = tempfile::tempdir()?;
diff --git a/gix/tests/gix/repository/worktree.rs b/gix/tests/gix/repository/worktree.rs
index b99c5519418..09dd0ca8130 100644
--- a/gix/tests/gix/repository/worktree.rs
+++ b/gix/tests/gix/repository/worktree.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix_ref::bstr;
 
 /// The buffer length for SHA1 archives.
@@ -16,7 +17,7 @@ fn expected_buffer_length(repo: &gix::Repository) -> usize {
 
 #[test]
 #[cfg(feature = "worktree-stream")]
-fn stream() -> crate::Result {
+fn stream() -> Result {
     let repo = crate::named_repo("make_packed_and_loose.sh")?;
     let mut stream = repo.worktree_stream(repo.head_commit()?.tree_id()?)?.0.into_read();
     assert_eq!(
@@ -29,7 +30,7 @@ fn stream() -> crate::Result {
 
 #[test]
 #[cfg(feature = "worktree-archive")]
-fn archive() -> crate::Result {
+fn archive() -> Result {
     let repo = crate::named_repo("make_packed_and_loose.sh")?;
     let (stream, _index) = repo.worktree_stream(repo.head_commit()?.tree_id()?)?;
     let mut buf = Vec::<u8>::new();
@@ -46,11 +47,12 @@ fn archive() -> crate::Result {
 }
 
 mod with_core_worktree_config {
+    use crate::Result;
     use std::io::BufRead;
 
     #[test]
     #[cfg(feature = "index")]
-    fn relative() -> crate::Result {
+    fn relative() -> Result {
         for (name, is_relative) in [("absolute-worktree", false), ("relative-worktree", true)] {
             let repo = repo(name);
 
@@ -126,7 +128,7 @@ mod with_core_worktree_config {
 
     #[test]
     #[cfg(feature = "index")]
-    fn bare_relative() -> crate::Result {
+    fn bare_relative() -> Result {
         let repo = repo("bare-relative-worktree");
 
         assert_eq!(
@@ -145,7 +147,7 @@ mod with_core_worktree_config {
 
     #[test]
     #[cfg(unix)] // symlinks are used here, let's not try our luck on Windows.
-    fn relative_through_symlinked_ancestor_keeps_callers_path_namespace() -> crate::Result {
+    fn relative_through_symlinked_ancestor_keeps_callers_path_namespace() -> Result {
         let link = gix_testtools::scripted_fixture_read_only("make_core_worktree_repo.sh")?.join("symlinked-ancestor");
 
         let repo = gix::open_opts(link.join("relative-worktree"), crate::restricted())?;
@@ -160,7 +162,7 @@ mod with_core_worktree_config {
 
     #[test]
     #[cfg(unix)] // symlinks are used here, let's not try our luck on Windows.
-    fn relative_from_symlinked_git_dir() -> crate::Result {
+    fn relative_from_symlinked_git_dir() -> Result {
         let fixture = gix_testtools::scripted_fixture_read_only("make_core_worktree_repo.sh")?;
         let root = fixture.join("linked-git-dir-detached-worktree");
         let repo = gix::open_opts(root.join("home"), crate::restricted())?;
@@ -183,7 +185,7 @@ mod with_core_worktree_config {
         std::fs::read(git_dir.join("status.baseline"))
             .unwrap()
             .lines()
-            .map_while(Result::ok)
+            .map_while(std::result::Result::ok)
             .filter(|line| line.contains(" D "))
             .count()
     }
@@ -298,7 +300,7 @@ fn from_nonbare_parent_repo() {
 }
 
 #[test]
-fn linked_worktree_proxy_base_with_relative_linking_files() -> crate::Result {
+fn linked_worktree_proxy_base_with_relative_linking_files() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only_needs_archive("make_worktree_relative_linking.sh")?;
     let main = fixture.join("main");
     let linked = fixture.join("linked");
@@ -325,7 +327,7 @@ fn linked_worktree_proxy_base_with_relative_linking_files() -> crate::Result {
 
 #[test]
 #[cfg(unix)]
-fn linked_worktree_proxy_base_with_symlinked_main_repo() -> crate::Result {
+fn linked_worktree_proxy_base_with_symlinked_main_repo() -> Result {
     let fixture = gix_testtools::scripted_fixture_read_only_needs_archive("make_worktree_relative_linking.sh")?;
     let linked = fixture.join("actual/linked");
     let main_symlink = fixture.join("main-symlink");
@@ -467,13 +469,14 @@ fn run_assertions(main_repo: gix::Repository, should_be_bare: bool) {
             );
             repo
         } else {
-            assert!(
-                matches!(
-                    actual.clone().into_repo(),
-                    Err(gix::worktree::proxy::into_repo::Error::MissingWorktree { .. })
-                ),
-                "missing bases are detected"
-            );
+            let err = actual.clone().into_repo().expect_err("the worktree base is missing");
+            insta::allow_duplicates! {
+                insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&base.to_string_lossy(), "<worktree>")]), "opening a worktree reports its inaccessible base", @r#"
+                Message {
+                    message: "Worktree at '<worktree>' is inaccessible",
+                }
+                "#);
+            }
             actual.clone().into_repo_with_possibly_inaccessible_worktree().unwrap()
         };
         let worktree = repo.worktree().expect("linked worktrees have at least a base path");
diff --git a/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs b/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
index c52306a1591..af60977f254 100644
--- a/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
@@ -1,8 +1,9 @@
 use super::repo;
+use crate::Result;
 use crate::{
     revision::spec::from_bytes::{
-        parse_spec, parse_spec_better_than_baseline, parse_spec_no_baseline, parse_spec_no_baseline_opts,
-        parse_spec_opts, rev_parse,
+        normalize_repo_path, parse_spec, parse_spec_better_than_baseline, parse_spec_no_baseline,
+        parse_spec_no_baseline_opts, parse_spec_opts, rev_parse,
     },
     util::hex_to_id_sha1_only,
 };
@@ -16,26 +17,38 @@ use gix::{
 
 #[test]
 fn prefix() {
+    let mut error_snapshots = Vec::new();
     {
         let repo = repo("blob.prefix").unwrap();
-        assert_eq!(
-            parse_spec("dead", &repo).unwrap_err().probable_cause().to_string(),
-            "Short id dead is ambiguous. Candidates are:\n\tdead7b2 blob\n\tdead9d3 blob"
-        );
-        assert_eq!(
-            parse_spec("beef", &repo).unwrap_err().probable_cause().to_string(),
-            "Short id beef is ambiguous. Candidates are:\n\tbeef2b0 blob\n\tbeefc9b blob"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(parse_spec("dead", &repo).unwrap_err().probable_cause()),
+            &[],
+        ));
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(parse_spec("beef", &repo).unwrap_err().probable_cause()),
+            &[],
+        ));
     }
 
     {
         let repo = repo("blob.bad").unwrap();
-        assert_eq!(
-            parse_spec("bad0", &repo).unwrap_err().probable_cause().to_string(),
-            "Short id bad0 is ambiguous. Candidates are:\n\tbad0853 lookup error: An error occurred while obtaining an object from the loose object store\n\tbad0bd4 lookup error: An error occurred while obtaining an object from the loose object store",
-            "git provides a much worse hint messages and fails to provide information for both bad objects"
-        );
-    }
+        let err = parse_spec("bad0", &repo).expect_err("both prefix candidates are malformed");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&format_args!("{}", normalize_repo_path(&format!("{err:#?}"), &repo)), &[]), "ambiguous prefixes retain the lookup failure for each malformed candidate", @"
+        Short id bad0 is ambiguous. Candidates are:
+        \tbad0853 lookup error: Could not read loose object, \"path\"=\"$GIT_DIR/objects/ba/d0853730d9d114ac789f0ce89039d224bf66c9\"
+        \tbad0bd4 lookup error: Could not read loose object, \"path\"=\"$GIT_DIR/objects/ba/d0bd4672dee1b4d3b8088534ed5a0362bc8d59\"
+        ");
+    };
+    insta::assert_debug_snapshot!(error_snapshots, "ambiguous object prefixes list the matching candidates", @r#"
+    [
+        Message {
+            message: "Short id dead is ambiguous. Candidates are:\n\tdead7b2 blob\n\tdead9d3 blob",
+        },
+        Message {
+            message: "Short id beef is ambiguous. Candidates are:\n\tbeef2b0 blob\n\tbeefc9b blob",
+        },
+    ]
+    "#);
 }
 
 #[test]
@@ -43,30 +56,30 @@ fn fully_failed_disambiguation_still_yields_an_ambiguity_error() {
     let repo = repo("ambiguous_blob_tree_commit").unwrap();
     let err = parse_spec("0000000000^{tag}", &repo).unwrap_err();
 
-    insta::assert_debug_snapshot!(err, @r#"
-    delegate.peel_until(ObjectKind(Tag)) failed: "{tag}"
+    insta::assert_debug_snapshot!(err, @"
+    delegate.peel_until(ObjectKind(Tag)) failed, \"input\"=\"{tag}\"
     |
     └─ Short id 0000000000 is ambiguous. Candidates are:
-    	0000000000e commit 2005-04-07 "a2onsxbvj"
-    	0000000000c tree
-    	0000000000b blob
+    \t0000000000e commit 2005-04-07 \"a2onsxbvj\"
+    \t0000000000c tree
+    \t0000000000b blob
     |
     └─ Last encountered object 0000000000c was tree while trying to peel to tag
-    "#);
+    ");
 
     insta::assert_snapshot!(format!("{err:#}"), @r#"
-    ValidationError { message: "delegate.peel_until(ObjectKind(Tag)) failed", input: Some("{tag}") }
+    Message { message: "delegate.peel_until(ObjectKind(Tag)) failed", class: Validation, values: {"input": Bytes("{tag}")} }
     |
-    └─ Message("Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob")
+    └─ Message { message: "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob" }
         |
-        └─ NotFound { oid: Prefix { bytes: Sha1(0000000000c00000000000000000000000000000), hex_len: 11 }, actual: Tree, expected: Tag }
+        └─ Message { message: "Last encountered object 0000000000c was tree while trying to peel to tag", class: Validation }
     "#);
     use std::error::Error;
-    assert_eq!(
-        err.source().expect("ambiguity error").to_string(),
-        "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
-        "without special treatment, one would see a bunch of failed transformations with the impression that the first of them is the root cause, which isn't correct."
-    );
+    insta::assert_debug_snapshot!(err.source().expect("ambiguity error"), "without special treatment, one would see a bunch of failed transformations with the impression that the first of them is the root cause, which isn't correct.", @r#"
+    Message {
+        message: "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
+    }
+    "#);
 }
 
 #[test]
@@ -90,16 +103,49 @@ fn ranges_are_auto_disambiguated_by_committish() {
 }
 
 #[test]
-fn blob_and_tree_can_be_disambiguated_by_type() {
-    let repo = repo("ambiguous_blob_tree_commit").unwrap();
+fn resolved_ambiguity_does_not_hide_a_missing_symbolic_referent() -> Result {
+    let fixture = gix_testtools::scripted_fixture_writable("make_rev_spec_parse_repos.sh")?;
+    let repo = gix::open_opts(fixture.path().join("ambiguous_blob_tree_commit"), crate::restricted())?;
+    std::fs::write(repo.git_dir().join("refs/heads/alias"), b"ref: refs/heads/missing\n")?;
+
+    let err = repo
+        .rev_parse("000000000..alias")
+        .expect_err("the left endpoint resolves to a commit, but the right referent is missing");
+    assert!(
+        err.is_not_found(),
+        "resolved ambiguity must not mask the missing referent: {err}"
+    );
     assert_eq!(
-        parse_spec("0000000000", &repo)
-            .unwrap_err()
-            .probable_cause()
-            .to_string(),
-        "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
-        "in theory one could disambiguate with 0000000000^{{tree}} (which works in git) or 0000000000^{{blob}} which doesn't work for some reason."
+        err.downcast_any_ref::<gix::refs::file::find::NotFound>()
+            .expect("the lookup error survives rejected-candidate errors")
+            .name,
+        std::path::Path::new("refs/heads/missing"),
+        "the final spec conversion retains the actual lookup failure"
     );
+    insta::assert_debug_snapshot!(err, @r#"
+    The rev-spec is malformed and misses a ref name
+    |
+    └─ Last encountered object 0000000000b was blob while trying to peel to commit
+    |
+    └─ Last encountered object 0000000000c was tree while trying to peel to commit
+    |
+    └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found
+    "#);
+    Ok(())
+}
+
+#[test]
+fn blob_and_tree_can_be_disambiguated_by_type() {
+    let repo = repo("ambiguous_blob_tree_commit").unwrap();
+    insta::assert_debug_snapshot!(parse_spec("0000000000", &repo)
+            .expect_err("in theory one could disambiguate with 0000000000^{{tree}} (which works in git) or 0000000000^{{blob}} which doesn't work for some reason.")
+            .probable_cause(), "in theory one could disambiguate with 0000000000^{{tree}} (which works in git) or 0000000000^{{blob}} which doesn't work for some reason.", @r#"
+    Message {
+        message: "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
+    }
+    "#);
 
     assert_eq!(
         parse_spec("0000000000cdc^{tree}", &repo).unwrap(),
@@ -165,14 +211,13 @@ fn tags_can_be_disambiguated_with_commit_specific_transformations() {
 #[test]
 fn duplicates_are_deduplicated_across_all_odb_types() {
     let repo = repo("duplicate_ambiguous_objects").unwrap();
-    assert_eq!(
-        parse_spec_no_baseline("0000000000", &repo)
-            .unwrap_err()
-            .probable_cause()
-            .to_string(),
-        "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t000000000002 tree\n\t00000000005 tree\n\t00000000009 tree\n\t0000000000c tree\n\t0000000000fd tree\n\t00000000001 blob\n\t00000000003 blob\n\t0000000000a blob\n\t0000000000b blob\n\t0000000000f2 blob",
-        "One day we want to see 16 objects here, and not 32 just because they exist in the loose and the packed odb"
-    );
+    insta::assert_debug_snapshot!(parse_spec_no_baseline("0000000000", &repo)
+            .expect_err("One day we want to see 16 objects here, and not 32 just because they exist in the loose and the packed odb")
+            .probable_cause(), "One day we want to see 16 objects here, and not 32 just because they exist in the loose and the packed odb", @r#"
+    Message {
+        message: "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t000000000002 tree\n\t00000000005 tree\n\t00000000009 tree\n\t0000000000c tree\n\t0000000000fd tree\n\t00000000001 blob\n\t00000000003 blob\n\t0000000000a blob\n\t0000000000b blob\n\t0000000000f2 blob",
+    }
+    "#);
 }
 
 fn opts_ref_hint(hint: RefsHint) -> Options {
@@ -204,13 +249,13 @@ fn ambiguous_40hex_refs_are_ignored_and_we_prefer_the_object_of_the_same_name()
         "we can prefer refs in any case, too"
     );
 
-    assert_eq!(
-        parse_spec_no_baseline_opts(spec, &repo, opts_ref_hint(RefsHint::Fail))
-            .unwrap_err()
-            .probable_cause()
-            .to_string(),
-        "The short hash 0000000000e4f9fbd19cf1e932319e5ad0d1d00b matched both the reference refs/heads/0000000000e4f9fbd19cf1e932319e5ad0d1d00b and at least one object"
-    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(parse_spec_no_baseline_opts(spec, &repo, opts_ref_hint(RefsHint::Fail))
+            .expect_err("ambiguous 40hex refs are ignored and we prefer the object of the same name")
+            .probable_cause()), &[]), "ambiguous 40hex refs are ignored and we prefer the object of the same name", @r#"
+    Message {
+        message: "The short hash Oid(1) matched both the reference refs/heads/Oid(1) and at least one object",
+    }
+    "#);
 }
 
 #[test]
@@ -235,14 +280,13 @@ fn ambiguous_short_refs_are_dereferenced() {
         "we can always prefer objects, too"
     );
 
-    assert_eq!(
-        parse_spec_no_baseline_opts(spec, &repo, opts_ref_hint(RefsHint::Fail))
-            .unwrap_err()
-            .probable_cause()
-            .to_string(),
-        "The short hash 0000000000e matched both the reference refs/heads/0000000000e and at least one object",
-        "users who don't want this ambiguity, could fail like this."
-    );
+    insta::assert_debug_snapshot!(parse_spec_no_baseline_opts(spec, &repo, opts_ref_hint(RefsHint::Fail))
+            .expect_err("users who don't want this ambiguity, could fail like this.")
+            .probable_cause(), "users who don't want this ambiguity, could fail like this.", @r#"
+    Message {
+        message: "The short hash 0000000000e matched both the reference refs/heads/0000000000e and at least one object",
+    }
+    "#);
 }
 
 #[test]
@@ -254,31 +298,35 @@ fn repository_local_disambiguation_hints_disambiguate() {
         "we read the 'core.disambiguate' value and apply it to auto-disambiguate"
     );
     let err = rev_parse("0000000000", &r).unwrap_err();
-    insta::assert_debug_snapshot!(err, @r#"
+    insta::assert_debug_snapshot!(err, @"
     Short id 0000000000 is ambiguous. Candidates are:
-    	0000000000f8 tag "v1.0.0"
-    	000000000004 commit 2005-04-07 "czy8f73t"
-    	00000000006 commit 2005-04-07 "ad2uee"
-    	00000000008 commit 2005-04-07 "ioiley5o"
-    	0000000000e commit 2005-04-07 "a2onsxbvj"
-    "#);
-    assert_eq!(
-        err.to_string(),
-        "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\""
-    );
+    \t0000000000f8 tag \"v1.0.0\"
+    \t000000000004 commit 2005-04-07 \"czy8f73t\"
+    \t00000000006 commit 2005-04-07 \"ad2uee\"
+    \t00000000008 commit 2005-04-07 \"ioiley5o\"
+    \t0000000000e commit 2005-04-07 \"a2onsxbvj\"
+    ");
+    insta::assert_debug_snapshot!(err, "repository local disambiguation hints disambiguate", @"
+    Short id 0000000000 is ambiguous. Candidates are:
+    \t0000000000f8 tag \"v1.0.0\"
+    \t000000000004 commit 2005-04-07 \"czy8f73t\"
+    \t00000000006 commit 2005-04-07 \"ad2uee\"
+    \t00000000008 commit 2005-04-07 \"ioiley5o\"
+    \t0000000000e commit 2005-04-07 \"a2onsxbvj\"
+    ");
 
     let r = repo("ambiguous_objects_disambiguation_config_treeish").unwrap();
     let err = rev_parse("0000000000f", &r).unwrap_err();
-    insta::assert_debug_snapshot!(err, @r#"
+    insta::assert_debug_snapshot!(err, @"
     Short id 0000000000f is ambiguous. Candidates are:
-    	0000000000f8 tag "v1.0.0"
-    	0000000000fd tree
-    "#);
-    assert_eq!(
-        err.to_string(),
-        "Short id 0000000000f is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t0000000000fd tree",
-        "disambiguation might not always work either."
-    );
+    \t0000000000f8 tag \"v1.0.0\"
+    \t0000000000fd tree
+    ");
+    insta::assert_debug_snapshot!(err, "disambiguation might not always work either.", @"
+    Short id 0000000000f is ambiguous. Candidates are:
+    \t0000000000f8 tag \"v1.0.0\"
+    \t0000000000fd tree
+    ");
 
     {
         let id = hex_to_id_sha1_only("00000000000434887f772f53e14e39497f7747d3");
@@ -298,14 +346,19 @@ fn repository_local_disambiguation_hints_disambiguate() {
     );
 
     let r = repo("ambiguous_objects_disambiguation_config_commit").unwrap();
-    assert_eq!(
-        rev_parse("0000000000f", &r).unwrap_err().to_string(),
-        "Short id 0000000000f is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t0000000000fd tree\n\t0000000000f2 blob",
-    );
-    assert_eq!(
-        rev_parse("0000000000", &r).unwrap_err().to_string(),
-        "Short id 0000000000 is ambiguous. Candidates are:\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"",
-    );
+    insta::assert_debug_snapshot!(rev_parse("0000000000f", &r).expect_err("repository local disambiguation hints disambiguate"), "repository local disambiguation hints disambiguate", @"
+    Short id 0000000000f is ambiguous. Candidates are:
+    \t0000000000f8 tag \"v1.0.0\"
+    \t0000000000fd tree
+    \t0000000000f2 blob
+    ");
+    insta::assert_debug_snapshot!(rev_parse("0000000000", &r).expect_err("repository local disambiguation hints disambiguate"), "repository local disambiguation hints disambiguate", @"
+    Short id 0000000000 is ambiguous. Candidates are:
+    \t000000000004 commit 2005-04-07 \"czy8f73t\"
+    \t00000000006 commit 2005-04-07 \"ad2uee\"
+    \t00000000008 commit 2005-04-07 \"ioiley5o\"
+    \t0000000000e commit 2005-04-07 \"a2onsxbvj\"
+    ");
 
     let r = repo("ambiguous_objects_disambiguation_config_blob").unwrap();
     assert_eq!(
@@ -318,14 +371,14 @@ fn repository_local_disambiguation_hints_disambiguate() {
 fn repository_local_disambiguation_hints_are_overridden_by_specific_ones() {
     let repo = repo("ambiguous_objects_disambiguation_config_committish").unwrap();
     let err = rev_parse("0000000000f^{tree}", &repo).unwrap_err();
-    insta::assert_debug_snapshot!(err, @r"
+    insta::assert_debug_snapshot!(err, @"
+    Short id 0000000000f is ambiguous. Candidates are:
+    \t0000000000c tree
+    \t0000000000fd tree
+    ");
+    insta::assert_debug_snapshot!(err, "spec overrides overrule the configuration value, which makes this particular object ambiguous between tree and tag", @"
     Short id 0000000000f is ambiguous. Candidates are:
     	0000000000c tree
     	0000000000fd tree
     ");
-    assert_eq!(
-        err.to_string(),
-        "Short id 0000000000f is ambiguous. Candidates are:\n\t0000000000c tree\n\t0000000000fd tree",
-        "spec overrides overrule the configuration value, which makes this particular object ambiguous between tree and tag"
-    );
 }
diff --git a/gix/tests/gix/revision/spec/from_bytes/mod.rs b/gix/tests/gix/revision/spec/from_bytes/mod.rs
index a337e1b378e..8b12f4c4868 100644
--- a/gix/tests/gix/revision/spec/from_bytes/mod.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/mod.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix::{prelude::ObjectIdExt, revision::Spec};
 pub use util::*;
 
@@ -13,13 +14,14 @@ mod traverse;
 mod peel;
 
 mod sibling_branch {
+    use crate::Result;
     use crate::{
         revision::spec::from_bytes::{parse_spec, repo},
         util::hex_to_id_sha1_only,
     };
 
     #[test]
-    fn push_and_upstream() -> crate::Result {
+    fn push_and_upstream() -> Result {
         let repo = repo("complex_graph").unwrap();
         for op in ["upstream", "push"] {
             for branch in ["", "main"] {
@@ -64,21 +66,23 @@ mod index {
         |
         └─ Path "file" did not exist in index at stage 1. It does exist at stage 0. It exists on disk
         "#);
-        assert_eq!(
-            err.probable_cause().to_string(),
-            "Path \"file\" did not exist in index at stage 1. It does exist at stage 0. It exists on disk",
-        );
+        insta::assert_debug_snapshot!(err.probable_cause(), "at stage", @r#"
+        Message {
+            message: "Path \"file\" did not exist in index at stage 1. It does exist at stage 0. It exists on disk",
+        }
+        "#);
 
-        assert_eq!(
-            parse_spec(":5:file", &repo).unwrap_err().probable_cause().to_string(),
-            "Path \"5:file\" did not exist in index at stage 0. It does not exist on disk",
-            "invalid stage ids are interpreted as part of the filename"
-        );
+        insta::assert_debug_snapshot!(parse_spec(":5:file", &repo).expect_err("invalid stage ids are interpreted as part of the filename").probable_cause(), "invalid stage ids are interpreted as part of the filename", @r#"
+        Message {
+            message: "Path \"5:file\" did not exist in index at stage 0. It does not exist on disk",
+        }
+        "#);
 
-        assert_eq!(
-            parse_spec(":foo", &repo).unwrap_err().probable_cause().to_string(),
-            "Path \"foo\" did not exist in index at stage 0. It does not exist on disk",
-        );
+        insta::assert_debug_snapshot!(parse_spec(":foo", &repo).expect_err("at stage").probable_cause(), "at stage", @r#"
+        Message {
+            message: "Path \"foo\" did not exist in index at stage 0. It does not exist on disk",
+        }
+        "#);
     }
 }
 
@@ -107,29 +111,165 @@ fn names_are_made_available_via_references() {
 }
 
 #[test]
-fn missing_revision_keeps_reference_lookup_error_available_for_path_fallback() -> crate::Result {
+fn missing_revision_keeps_reference_lookup_error_available_for_path_fallback() -> Result {
     let repo = repo("complex_graph")?;
     let err = repo
         .rev_parse("README.md")
         .expect_err("missing revspec must fail before callers can inspect the error chain");
+    insta::assert_debug_snapshot!(err, "rev-parse preserves the reference lookup classification", @r#"
+    couldn't parse revision, "input"="README.md"
+    |
+    └─ The ref partially named "README.md" could not be found
+    "#);
 
+    assert!(
+        err.is_not_found(),
+        "rev-parse preserves the reference lookup classification"
+    );
     let not_found = err
-        .downcast_any_ref::<gix::refs::file::find::existing::Error>()
+        .downcast_any_ref::<gix::refs::file::find::NotFound>()
         .expect("reference lookup failure remains available for downcasting after rev-parse");
 
-    match not_found {
-        gix::refs::file::find::existing::Error::NotFound { name } => {
-            assert_eq!(
-                name,
-                std::path::Path::new("README.md"),
-                "the ref lookup error carries the unresolved revspec for path fallback"
-            );
-        }
-        gix::refs::file::find::existing::Error::Find(_) => {
-            panic!("expected a missing ref error, got a lower-level ref lookup failure")
-        }
+    assert_eq!(
+        not_found.name,
+        std::path::Path::new("README.md"),
+        "the missing reference carries the unresolved revspec for path fallback"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn missing_symbolic_referents_keep_their_name() -> Result {
+    let mut error_snapshots = Vec::new();
+    let (repo, _keep) = crate::basic_rw_repo()?;
+    std::fs::write(repo.git_dir().join("refs/heads/alias"), b"ref: refs/heads/missing\n")?;
+
+    for revspec in ["alias", "alias..HEAD", "HEAD..alias", "alias...HEAD", "HEAD...alias"] {
+        let err = repo.rev_parse(revspec).expect_err("the symbolic referent is missing");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(
+            err.is_not_found(),
+            "missing symbolic referents are classified as not found: {err:?}"
+        );
+        assert_eq!(
+            err.downcast_any_ref::<gix::refs::file::find::NotFound>()
+                .expect("the missing referent remains available for path fallback")
+                .name,
+            std::path::Path::new("refs/heads/missing"),
+            "the missing reference name is not necessarily the input revspec"
+        );
     }
+    insta::assert_debug_snapshot!(error_snapshots, "missing symbolic referents keep their name", @r#"
+    [
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found,
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found,
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found,
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found,
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ The ref partially named "refs/heads/missing" could not be found,
+    ]
+    "#);
+    Ok(())
+}
+
+#[test]
+fn both_missing_symbolic_referents_are_retained() -> Result {
+    let (repo, _keep) = crate::basic_rw_repo()?;
+    std::fs::write(
+        repo.git_dir().join("refs/heads/first"),
+        b"ref: refs/heads/missing-first\n",
+    )?;
+    std::fs::write(
+        repo.git_dir().join("refs/heads/second"),
+        b"ref: refs/heads/missing-second\n",
+    )?;
+
+    for revspec in ["first..second", "first...second"] {
+        let err = repo
+            .rev_parse(revspec)
+            .expect_err("both symbolic referents are missing");
+        let missing_names: Vec<_> = err
+            .iter_errors()
+            .filter_map(|cause| cause.downcast_ref::<gix::refs::file::find::NotFound>())
+            .map(|cause| cause.name.as_path())
+            .collect();
+        assert_eq!(
+            missing_names,
+            [
+                std::path::Path::new("refs/heads/missing-first"),
+                std::path::Path::new("refs/heads/missing-second"),
+            ],
+            "final spec conversion preserves both lookup failures"
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn missing_objects_are_classified_without_a_missing_reference() -> Result {
+    let mut error_snapshots = Vec::new();
+    let (repo, _keep) = crate::basic_rw_repo()?;
+    let mut missing_commit_id = repo.object_hash().null();
+    missing_commit_id.as_mut_slice()[0] = 1;
+    repo.reference(
+        "refs/heads/missing-object",
+        missing_commit_id,
+        gix::refs::transaction::PreviousValue::Any,
+        "",
+    )?;
 
+    std::fs::write(
+        repo.git_dir().join("refs/heads/alias"),
+        b"ref: refs/heads/missing-object\n",
+    )?;
+
+    for revspec in ["missing-object^{object}", "missing-object:README.md", "alias"] {
+        let err = repo.rev_parse(revspec).expect_err("the referenced object is missing");
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+        assert!(
+            err.is_not_found(),
+            "object lookup failures retain their classification: {err}"
+        );
+        assert!(
+            err.downcast_any_ref::<gix::refs::file::find::NotFound>().is_none(),
+            "a missing object must not trigger missing-reference path fallback: {err}"
+        );
+    }
+    insta::assert_debug_snapshot!(error_snapshots, "missing objects are classified without a missing reference", @r#"
+    [
+        delegate.peel_until(ValidObject) failed, "input"="{object}"
+        |
+        └─ An object with id Oid(1) could not be found,
+        delegate.peel_until(Path("README.md")) failed
+        |
+        └─ An object with id Oid(1) could not be found,
+        The rev-spec is malformed and misses a ref name
+        |
+        └─ Could not peel 'refs/heads/alias' to obtain its target
+        |
+        └─ Could not peel reference to an object: object could not be found, "object_id"="Oid(1)", "reference"="refs/heads/missing-object",
+    ]
+    "#);
     Ok(())
 }
 
@@ -143,19 +283,26 @@ fn bad_objects_are_valid_until_they_are_actually_read_from_the_odb() {
             "we are able to return objects even though they are 'bad' when trying to decode them, like git",
         );
         let err = parse_spec("e328^{object}", &repo).unwrap_err();
+        let cause = err
+            .probable_cause()
+            .downcast_ref::<gix_error::Message>()
+            .expect("invalid object kinds are classified as validation failures");
         assert_eq!(
-            format!("{:?}", err.probable_cause()),
-            r#"InvalidObjectKind { kind: "bad" }"#,
+            (cause.class, cause.values.get("input")),
+            (
+                Some(gix_error::Class::Validation),
+                Some(&gix_error::MetadataValue::Bytes("bad".into()))
+            ),
             "Now we enforce the object to exist and be valid, as ultimately it wants to match with a certain type"
         );
-        insta::assert_debug_snapshot!(err, @r#"
-        delegate.peel_until(ValidObject) failed: "{object}"
+        insta::assert_snapshot!(normalize_repo_path(&format!("{err:#?}"), &repo), @r#"
+        delegate.peel_until(ValidObject) failed, "input"="{object}"
         |
-        └─ An error occurred while obtaining an object from the loose object store
+        └─ Could not read loose object, "path"="$GIT_DIR/objects/e3/2851d29feb48953c6f40b2e06d630a3c49608a"
         |
         └─ The object header contained an unknown object kind.
         |
-        └─ Unknown object kind: "bad"
+        └─ Unknown object kind, "input"="bad"
         "#);
     }
 
@@ -166,23 +313,10 @@ fn bad_objects_are_valid_until_they_are_actually_read_from_the_odb() {
             Spec::from_id(hex_to_id_sha1_only("cafea31147e840161a1860c50af999917ae1536b").attach(&repo))
         );
         let err = parse_spec("cafea^{object}", &repo).unwrap_err();
-        let actual = {
-            let mut actual = format!("{err:#?}").replace('\\', "/").replace("windows", "unix");
-            let marker = "make_rev_spec_parse_repos/";
-            if let Some(start) = actual.find(marker) {
-                let start = start + marker.len();
-                if let Some(end) = actual[start..].find("/blob.corrupt") {
-                    actual.replace_range(start..start + end, "$HASH/$SEED-unix");
-                }
-            }
-            actual
-        };
-        insta::assert_snapshot!(actual, @r#"
-        delegate.peel_until(ValidObject) failed: "{object}"
+        insta::assert_snapshot!(normalize_repo_path(&format!("{err:#?}"), &repo), @r#"
+        delegate.peel_until(ValidObject) failed, "input"="{object}"
         |
-        └─ An error occurred while obtaining an object from the loose object store
-        |
-        └─ decompression of loose object at 'tests/fixtures/generated-do-not-edit/make_rev_spec_parse_repos/$HASH/$SEED-unix/blob.corrupt/objects/ca/fea31147e840161a1860c50af999917ae1536b' failed
+        └─ Could not read loose object, "path"="$GIT_DIR/objects/ca/fea31147e840161a1860c50af999917ae1536b"
         |
         └─ Could not decode zip stream
         |
@@ -211,10 +345,11 @@ fn access_blob_through_tree() {
     |
     └─ Could not find path "missing" in tree 0000000000c of parent object 0000000000c
     "#);
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "Could not find path \"missing\" in tree 0000000000c of parent object 0000000000c"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "access blob through tree", @r#"
+    Message {
+        message: "Could not find path \"missing\" in tree 0000000000c of parent object 0000000000c",
+    }
+    "#);
 }
 
 #[test]
@@ -226,17 +361,23 @@ fn invalid_head() {
     |
     └─ Could not peel 'HEAD' to obtain its target
         |
-        └─ Could not follow a single level of a symbolic reference
-        |   |
-        |   └─ The ref partially named "refs/heads/main" could not be found
+        └─ The ref partially named "refs/heads/main" could not be found
         |
         └─ Couldn't get object at internal index 0
     "#);
 
     let err = parse_spec("HEAD", &repo).unwrap_err();
-    // The head couldn't be peeled, and there is nothing left to consume, but no
-    // object was resolved.
-    insta::assert_debug_snapshot!(err, @"The rev-spec is malformed and misses a ref name");
+    assert!(
+        err.is_not_found(),
+        "final conversion retains the deferred lookup failure"
+    );
+    insta::assert_debug_snapshot!(err, @r#"
+    The rev-spec is malformed and misses a ref name
+    |
+    └─ Could not peel 'HEAD' to obtain its target
+    |
+    └─ The ref partially named "refs/heads/main" could not be found
+    "#);
 }
 
 #[test]
diff --git a/gix/tests/gix/revision/spec/from_bytes/reflog.rs b/gix/tests/gix/revision/spec/from_bytes/reflog.rs
index 876a3cd1b7e..10fb70a8e6a 100644
--- a/gix/tests/gix/revision/spec/from_bytes/reflog.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/reflog.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix::{prelude::ObjectIdExt, revision::Spec};
 
 use crate::{
@@ -21,27 +22,27 @@ fn nth_prior_checkout() {
         assert_eq!(parsed.second_reference(), None);
     }
 
-    assert_eq!(
-        parse_spec("@{-6}", &repo).unwrap_err().probable_cause().to_string(),
-        "HEAD has 5 prior checkouts and checkout number 6 is out of range"
-    );
+    insta::assert_debug_snapshot!(parse_spec("@{-6}", &repo).expect_err("nth prior checkout").probable_cause(), "nth prior checkout", @r#"
+    Message {
+        message: "HEAD has 5 prior checkouts and checkout number 6 is out of range",
+    }
+    "#);
 }
 
 #[test]
-fn nth_prior_checkout_to_deleted_branch_fails_like_git() -> crate::Result {
+fn nth_prior_checkout_to_deleted_branch_fails_like_git() -> Result {
     let repo = repo("deleted_prior_checkout")?;
     let err = parse_spec("@{-1}", &repo).expect_err("deleted prior checkout branch must not resolve by object id");
-    assert!(
-        err.probable_cause()
-            .to_string()
-            .contains("Previous checkout 'prev-target' does not resolve"),
-        "error should explain that the reflog name no longer resolves"
-    );
+    insta::assert_debug_snapshot!(err.probable_cause(), "error should explain that the reflog name no longer resolves", @r#"
+    Message {
+        message: "Previous checkout 'prev-target' does not resolve to an existing revision",
+    }
+    "#);
     Ok(())
 }
 
 #[test]
-fn nth_prior_checkout_to_deleted_branch_named_like_object_matches_git() -> crate::Result {
+fn nth_prior_checkout_to_deleted_branch_named_like_object_matches_git() -> Result {
     let repo = repo("deleted_prior_checkout_named_like_object")?;
     assert_eq!(
         parse_spec("@{-1}", &repo)?,
@@ -55,10 +56,11 @@ fn nth_prior_checkout_to_deleted_branch_named_like_object_matches_git() -> crate
 fn by_index_unborn_head() {
     let repo = &repo("new").unwrap();
 
-    assert_eq!(
-        parse_spec("@{1}", repo).unwrap_err().probable_cause().to_string(),
-        "Unborn heads do not have a reflog yet"
-    );
+    insta::assert_debug_snapshot!(parse_spec("@{1}", repo).expect_err("by index unborn head").probable_cause(), "by index unborn head", @r#"
+    Message {
+        message: "Unborn heads do not have a reflog yet",
+    }
+    "#);
 }
 
 #[test]
@@ -92,13 +94,13 @@ fn by_index() {
         assert_eq!(spec.second_reference(), None);
     }
 
-    assert_eq!(
-        parse_spec("main@{12345}", repo)
-            .unwrap_err()
-            .probable_cause()
-            .to_string(),
-        "Reference 'refs/heads/main' has 4 ref-log entries and entry number 12345 is out of range"
-    );
+    insta::assert_debug_snapshot!(parse_spec("main@{12345}", repo)
+            .expect_err("by index")
+            .probable_cause(), "by index", @r#"
+    Message {
+        message: "Reference 'refs/heads/main' has 4 ref-log entries and entry number 12345 is out of range",
+    }
+    "#);
 }
 
 #[test]
diff --git a/gix/tests/gix/revision/spec/from_bytes/regex.rs b/gix/tests/gix/revision/spec/from_bytes/regex.rs
index e06f80345d0..74abbff7106 100644
--- a/gix/tests/gix/revision/spec/from_bytes/regex.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/regex.rs
@@ -26,11 +26,11 @@ mod with_known_revision {
         |
         └─ None of 1 commits from 0000000000e matched text ".*x"
         "#);
-        assert_eq!(
-            err.probable_cause().to_string(),
-            "None of 1 commits from 0000000000e matched text \".*x\"",
-            "regexes are not actually available for us, but git could do that"
-        );
+        insta::assert_debug_snapshot!(err.probable_cause(), "regexes are not actually available for us, but git could do that", @r#"
+        Message {
+            message: "None of 1 commits from 0000000000e matched text \".*x\"",
+        }
+        "#);
     }
 
     #[test]
@@ -61,19 +61,21 @@ mod with_known_revision {
         |
         └─ None of 1 commits from 0000000000e matched regex "^x"
         "#);
-        assert_eq!(
-            err.probable_cause().to_string(),
-            "None of 1 commits from 0000000000e matched regex \"^x\"",
-        );
+        insta::assert_debug_snapshot!(err.probable_cause(), "contained string matches in unanchored regex and disambiguates automatically", @r#"
+        Message {
+            message: "None of 1 commits from 0000000000e matched regex \"^x\"",
+        }
+        "#);
     }
 }
 
 mod empty_pattern {
     use super::*;
+    use crate::Result;
     use crate::revision::spec::from_bytes::{parse_spec, repo};
 
     #[test]
-    fn matches_everything_and_peels_to_a_commit() -> crate::Result {
+    fn matches_everything_and_peels_to_a_commit() -> Result {
         let repo = repo("complex_graph")?;
 
         assert_eq!(
@@ -88,11 +90,19 @@ mod empty_pattern {
         );
 
         let err = parse_spec("@^{/!-}", &repo).unwrap_err();
-        let cause = err.probable_cause().to_string();
-        assert!(
-            cause.starts_with("None of") && cause.contains("matched"),
-            "a negated empty pattern matches nothing and fails like Git: {cause}"
-        );
+        if cfg!(feature = "revparse-regex") {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "a negated empty pattern matches nothing and fails like Git", @r#"
+            Delegate couldn't find '' (negated: true)
+            |
+            └─ None of 10 commits from 55e825e matched regex ""
+            "#);
+        } else {
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[]), "a negated empty pattern matches nothing and fails like Git", @r#"
+            Delegate couldn't find '' (negated: true)
+            |
+            └─ None of 10 commits from 55e825e matched text ""
+            "#);
+        }
         Ok(())
     }
 }
@@ -132,11 +142,11 @@ mod find_youngest_matching_commit {
         |
         └─ None of 10 commits reached from all references matched text "messa.e"
         "#);
-        assert_eq!(
-            err.probable_cause().to_string(),
-            "None of 10 commits reached from all references matched text \"messa.e\"",
-            "regex definitely don't work as it's not compiled in"
-        );
+        insta::assert_debug_snapshot!(err.probable_cause(), "regex definitely don't work as it's not compiled in", @r#"
+        Message {
+            message: "None of 10 commits reached from all references matched text \"messa.e\"",
+        }
+        "#);
     }
 
     #[test]
@@ -157,10 +167,11 @@ mod find_youngest_matching_commit {
         |
         └─ None of 10 commits reached from all references matched regex "not there"
         "#);
-        assert_eq!(
-            err.probable_cause().to_string(),
-            "None of 10 commits reached from all references matched regex \"not there\""
-        );
+        insta::assert_debug_snapshot!(err.probable_cause(), "regex matches", @r#"
+        Message {
+            message: "None of 10 commits reached from all references matched regex \"not there\"",
+        }
+        "#);
 
         assert_eq!(
             parse_spec(":/!-message", &repo).unwrap(),
diff --git a/gix/tests/gix/revision/spec/from_bytes/traverse.rs b/gix/tests/gix/revision/spec/from_bytes/traverse.rs
index e8e097bc9ac..92a378cebbf 100644
--- a/gix/tests/gix/revision/spec/from_bytes/traverse.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/traverse.rs
@@ -1,3 +1,4 @@
+use crate::Result;
 use gix::{prelude::ObjectIdExt, revision::Spec};
 
 use crate::{
@@ -6,7 +7,7 @@ use crate::{
 };
 
 #[test]
-fn complex() -> crate::Result {
+fn complex() -> Result {
     let repo = &repo("complex_graph")?;
 
     assert_eq!(parse_spec("b", repo)?, parse_spec("a~1", repo)?);
@@ -22,32 +23,41 @@ fn complex() -> crate::Result {
 }
 
 #[test]
-fn freestanding_negation_yields_descriptive_error() -> crate::Result {
+fn freestanding_negation_yields_descriptive_error() -> Result {
+    let mut error_snapshots = Vec::new();
     let repo = repo("complex_graph")?;
     for revspec in ["^^", "^^HEAD"] {
-        assert_eq!(
-            parse_spec(revspec, &repo).unwrap_err().probable_cause().to_string(),
-            "Tried to navigate the commit-graph without providing an anchor first"
-        );
+        error_snapshots.push(gix_testtools::redact_debug_snapshot(
+            &(parse_spec(revspec, &repo).unwrap_err().probable_cause()),
+            &[],
+        ));
     }
-    assert_eq!(
-        parse_spec("^", &repo).unwrap_err().probable_cause().to_string(),
-        "The rev-spec is malformed and misses a ref name"
-    );
+    insta::assert_debug_snapshot!(parse_spec("^", &repo).expect_err("freestanding negation yields descriptive error").probable_cause(), "freestanding negation yields descriptive error", @r#"
+    Message {
+        message: "The rev-spec is malformed and misses a ref name",
+    }
+    "#);
     let err = parse_spec("^!", &repo).unwrap_err();
     insta::assert_debug_snapshot!(err, @r#"
-    couldn't parse revision: "!"
+    couldn't parse revision, "input"="!"
     |
     └─ The ref partially named "!" could not be found
     "#);
-    assert_eq!(
-        err.probable_cause().to_string(),
-        "The ref partially named \"!\" could not be found"
-    );
+    assert!(err.is_not_found(), "the missing anchor reference remains classified");
+    insta::assert_debug_snapshot!(error_snapshots, "freestanding negation yields descriptive error", @r#"
+    [
+        Message {
+            message: "Tried to navigate the commit-graph without providing an anchor first",
+        },
+        Message {
+            message: "Tried to navigate the commit-graph without providing an anchor first",
+        },
+    ]
+    "#);
     Ok(())
 }
 #[test]
-fn freestanding_double_or_triple_dot_defaults_to_head_refs() -> crate::Result {
+fn freestanding_double_or_triple_dot_defaults_to_head_refs() -> Result {
     let repo = repo("complex_graph")?;
     assert_eq!(
         parse_spec_no_baseline("..", &repo)?, // git can't communicate what it does here
@@ -65,14 +75,15 @@ fn parent() {
         Spec::from_id(hex_to_id_sha1_only("5b3f9e24965d0b28780b7ce5daf2b5b7f7e0459f").attach(&repo))
     );
     assert_eq!(parse_spec("a", &repo).unwrap(), parse_spec("a^0", &repo).unwrap());
-    assert_eq!(
-        parse_spec("a^42", &repo).unwrap_err().probable_cause().to_string(),
-        "Commit 55e825e has 2 parents and parent number 42 is out of range"
-    );
+    insta::assert_debug_snapshot!(parse_spec("a^42", &repo).expect_err("parent").probable_cause(), "parent", @r#"
+    Message {
+        message: "Commit 55e825e has 2 parents and parent number 42 is out of range",
+    }
+    "#);
 }
 
 #[test]
-fn tags_navigate_from_their_commit() -> crate::Result {
+fn tags_navigate_from_their_commit() -> Result {
     let repo = repo("complex_graph")?;
     for (spec, expected) in [
         ("b-tag^", "d"),
@@ -105,8 +116,9 @@ fn ancestors() {
         parse_spec("a~3", &repo).unwrap(),
         Spec::from_id(hex_to_id_sha1_only("9f9eac6bd1cd4b4cc6a494f044b28c985a22972b").attach(&repo))
     );
-    assert_eq!(
-        parse_spec("a~42", &repo).unwrap_err().probable_cause().to_string(),
-        "Commit 55e825e has 3 ancestors along the first parent and ancestor number 42 is out of range"
-    );
+    insta::assert_debug_snapshot!(parse_spec("a~42", &repo).expect_err("ancestors").probable_cause(), "ancestors", @r#"
+    Message {
+        message: "Commit 55e825e has 3 ancestors along the first parent and ancestor number 42 is out of range",
+    }
+    "#);
 }
diff --git a/gix/tests/gix/revision/spec/from_bytes/util.rs b/gix/tests/gix/revision/spec/from_bytes/util.rs
index 3b616ec0572..7e5ce01bc66 100644
--- a/gix/tests/gix/revision/spec/from_bytes/util.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/util.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::result_large_err)]
+use crate::Result;
 use std::{collections::HashMap, path::Path, str::FromStr};
 
 use gix_object::{bstr, bstr::BStr};
@@ -7,6 +8,14 @@ use gix_revision::spec::Kind;
 
 const FIXTURE_NAME: &str = "make_rev_spec_parse_repos.sh";
 
+/// Replace fixture paths in diagnostics independently of hash kind, seed, and platform.
+pub fn normalize_repo_path(message: &str, repo: &gix::Repository) -> String {
+    message
+        .replace("\\\\", "/")
+        .replace('\\', "/")
+        .replace(&repo.git_dir().to_string_lossy().replace('\\', "/"), "$GIT_DIR")
+}
+
 fn git_has_correct_pattern_revision_order(version: (u8, u8, u8)) -> bool {
     // Git 57fb139b5e accidentally reversed `:/<text>` traversal order in 2.47.x.
     // Git 0ff919e87a restored youngest-first traversal starting with 2.48.0.
@@ -116,7 +125,7 @@ fn baseline_at(repo_dir: &Path) -> HashMap<BString, Option<gix_revision::Spec>>
 pub fn parse_spec_no_baseline<'a>(
     spec: &str,
     repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
+) -> std::result::Result<gix::revision::Spec<'a>, gix_error::Error> {
     parse_spec_no_baseline_opts(spec, repo, Default::default())
 }
 
@@ -131,7 +140,7 @@ enum BaselineExpectation {
 pub fn parse_spec_better_than_baseline<'a>(
     spec: &str,
     repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
+) -> std::result::Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = gix::revision::Spec::from_bstr(spec, repo, Default::default());
     compare_with_baseline(&res, repo, spec, BaselineExpectation::GitFailsWeSucceed);
     res
@@ -141,7 +150,7 @@ pub fn parse_spec_no_baseline_opts<'a>(
     spec: &str,
     repo: &'a gix::Repository,
     opts: gix::revision::spec::parse::Options,
-) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
+) -> std::result::Result<gix::revision::Spec<'a>, gix_error::Error> {
     gix::revision::Spec::from_bstr(spec, repo, opts)
 }
 
@@ -149,20 +158,23 @@ pub fn parse_spec_opts<'a>(
     spec: &str,
     repo: &'a gix::Repository,
     opts: gix::revision::spec::parse::Options,
-) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
+) -> std::result::Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = gix::revision::Spec::from_bstr(spec, repo, opts);
     compare_with_baseline(&res, repo, spec, BaselineExpectation::Same);
     res
 }
 
-pub fn rev_parse<'a>(spec: &str, repo: &'a gix::Repository) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
+pub fn rev_parse<'a>(
+    spec: &str,
+    repo: &'a gix::Repository,
+) -> std::result::Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = repo.rev_parse(spec);
     compare_with_baseline(&res, repo, spec, BaselineExpectation::Same);
     res
 }
 
 fn compare_with_baseline(
-    res: &Result<gix::revision::Spec<'_>, gix_error::Error>,
+    res: &std::result::Result<gix::revision::Spec<'_>, gix_error::Error>,
     repo: &gix::Repository,
     spec: &str,
     expectation: BaselineExpectation,
@@ -186,16 +198,19 @@ fn compare_with_baseline(
     }
 }
 
-pub fn parse_spec(spec: impl AsRef<str>, repo: &gix::Repository) -> Result<gix::revision::Spec<'_>, gix_error::Error> {
+pub fn parse_spec(
+    spec: impl AsRef<str>,
+    repo: &gix::Repository,
+) -> std::result::Result<gix::revision::Spec<'_>, gix_error::Error> {
     parse_spec_opts(spec.as_ref(), repo, Default::default())
 }
 
-pub fn repo(name: &str) -> crate::Result<gix::Repository> {
+pub fn repo(name: &str) -> Result<gix::Repository> {
     let base = gix_testtools::scripted_fixture_read_only(FIXTURE_NAME)?;
     Ok(gix::open_opts(base.join(name), crate::restricted())?)
 }
 
-pub fn repo_with_correct_pattern_revision_order(name: &str) -> crate::Result<Option<gix::Repository>> {
+pub fn repo_with_correct_pattern_revision_order(name: &str) -> Result<Option<gix::Repository>> {
     gix_testtools::scripted_fixture_read_only_with_git_version(FIXTURE_NAME, git_has_correct_pattern_revision_order)?
         .map(|base| gix::open_opts(base.join(name), crate::restricted()).map_err(Into::into))
         .transpose()
diff --git a/gix/tests/gix/status.rs b/gix/tests/gix/status.rs
index e2da4de21d8..3c33d2c6110 100644
--- a/gix/tests/gix/status.rs
+++ b/gix/tests/gix/status.rs
@@ -1,4 +1,5 @@
-pub fn submodule_repo(name: &str) -> crate::Result<gix::Repository> {
+use crate::Result;
+pub fn submodule_repo(name: &str) -> Result<gix::Repository> {
     use crate::util::named_subrepo_opts;
     Ok(named_subrepo_opts(
         "make_submodules.sh",
@@ -7,7 +8,7 @@ pub fn submodule_repo(name: &str) -> crate::Result<gix::Repository> {
     )?)
 }
 
-pub fn repo(name: &str) -> crate::Result<gix::Repository> {
+pub fn repo(name: &str) -> Result<gix::Repository> {
     use crate::util::named_subrepo_opts;
     Ok(named_subrepo_opts(
         "make_status_repos.sh",
@@ -17,6 +18,7 @@ pub fn repo(name: &str) -> crate::Result<gix::Repository> {
 }
 
 mod into_iter {
+    use crate::Result;
     use gix::status::{Item, Submodule, tree_index::TrackRenames};
     use gix_diff::Rewrites;
     use gix_testtools::size_ok;
@@ -36,7 +38,7 @@ mod into_iter {
     }
 
     #[test]
-    fn submodule_tree_index_modification() -> crate::Result {
+    fn submodule_tree_index_modification() -> Result {
         let repo = submodule_repo("git-mv-and-untracked-and-submodule-head-changed-and-modified")?;
         let mut status = repo
             .status(gix::progress::Discard)?
@@ -49,7 +51,7 @@ mod into_iter {
                 ..Default::default()
             }))
             .into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         assert_eq!(items.len(), 3, "1 untracked, 1 move, 1 submodule modification");
         let snapshot = gix_testtools::normalize_debug_snapshot(&&items[1..]).0;
@@ -95,7 +97,7 @@ mod into_iter {
     }
 
     #[test]
-    fn submodule_fully_ignored_by_override() -> crate::Result {
+    fn submodule_fully_ignored_by_override() -> Result {
         let repo = submodule_repo("git-mv-and-untracked-and-submodule-head-changed-and-modified")?;
         let mut status = repo
             .status(gix::progress::Discard)?
@@ -112,7 +114,7 @@ mod into_iter {
                 check_dirty: false,
             }))
             .into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         assert_eq!(
             items.len(),
@@ -161,7 +163,7 @@ mod into_iter {
         Ok(())
     }
     #[test]
-    fn submodule_fully_ignored_by_configuration() -> crate::Result {
+    fn submodule_fully_ignored_by_configuration() -> Result {
         let repo = submodule_repo("git-mv-and-untracked-and-submodule-head-changed-and-modified-ignore-all")?;
         let mut status = repo
             .status(gix::progress::Discard)?
@@ -174,7 +176,7 @@ mod into_iter {
                 ..Default::default()
             }))
             .into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         assert_eq!(items.len(), 1, "1 untracked, 0 submodule modification (ignored)");
         insta::assert_debug_snapshot!(&items, @r#"
@@ -202,20 +204,20 @@ mod into_iter {
     }
 
     #[test]
-    fn tree_index_modification_worktree_modification_racy_git() -> crate::Result {
+    fn tree_index_modification_worktree_modification_racy_git() -> Result {
         let repo = repo("racy-git")?;
         let mut status = repo.status(gix::progress::Discard)?.into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         assert_eq!(items.len(), 2, "1 modified in index, the same in worktree");
         Ok(())
     }
 
     #[test]
-    fn untracked_unborn() -> crate::Result {
+    fn untracked_unborn() -> Result {
         let repo = repo("untracked-unborn")?;
         let mut status = repo.status(gix::progress::Discard)?.into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         insta::assert_debug_snapshot!(items, @r#"
         [
@@ -242,10 +244,10 @@ mod into_iter {
     }
 
     #[test]
-    fn added_unborn() -> crate::Result {
+    fn added_unborn() -> Result {
         let repo = repo("added-unborn")?;
         let mut status = repo.status(gix::progress::Discard)?.into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         let snapshot = gix_testtools::normalize_debug_snapshot(&items).0;
         insta::assert_snapshot!(snapshot, @r#"
@@ -276,10 +278,10 @@ mod into_iter {
     }
 
     #[test]
-    fn untracked_added() -> crate::Result {
+    fn untracked_added() -> Result {
         let repo = repo("untracked-added")?;
         let mut status = repo.status(gix::progress::Discard)?.into_iter(None)?;
-        let mut items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let mut items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         items.sort_by(|a, b| a.location().cmp(b.location()));
         let snapshot = gix_testtools::normalize_debug_snapshot(&items).0;
         insta::assert_snapshot!(snapshot, @r#"
@@ -301,10 +303,10 @@ mod into_iter {
 
     #[test]
     #[cfg(unix)]
-    fn submodule_assume_unchanged_replaced_with_symlink_is_ignored() -> crate::Result {
+    fn submodule_assume_unchanged_replaced_with_symlink_is_ignored() -> Result {
         let repo = repo("submodule-assume-unchanged-symlink")?;
         let mut status = repo.status(gix::progress::Discard)?.into_iter(None)?;
-        let items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+        let items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
         assert!(
             items.is_empty(),
             "assume-unchanged submodule should not show up in status"
@@ -313,11 +315,11 @@ mod into_iter {
     }
 
     #[test]
-    fn error_during_tree_traversal_causes_failure() -> crate::Result {
+    fn error_during_tree_traversal_causes_failure() -> Result {
+        let mut error_snapshots = Vec::new();
         let repo = repo("untracked-only")?;
         let invalid_tree_id = repo.object_hash().empty_blob();
         let platform = repo.status(gix::progress::Discard)?.head_tree(invalid_tree_id);
-        let expected_err = format!("Could not create index from tree at {invalid_tree_id}");
         if cfg!(feature = "parallel") {
             let mut items: Vec<_> = platform.into_iter(None)?.collect();
             assert_eq!(
@@ -325,23 +327,36 @@ mod into_iter {
                 3,
                 "2 untracked and one error, which is detected only in the end."
             );
-            assert_eq!(items.pop().expect("last item").unwrap_err().to_string(), expected_err);
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(items.pop().expect("last item").unwrap_err()),
+                &[],
+            ));
         } else {
             match platform.into_iter(None) {
                 Ok(_) => {
                     unreachable!("errors would be detected early here as everything is done ahead of time")
                 }
                 Err(err) => {
-                    assert_eq!(err.to_string(), expected_err);
+                    error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
                 }
             }
         }
+        insta::assert_debug_snapshot!(error_snapshots, "error during tree traversal causes failure", @"
+        [
+            Could not create index from tree at Oid(1)
+            |
+            └─ Tree traversal failed
+            |
+            └─ Expected object of kind tree but got blob at Oid(1),
+        ]
+        ");
         Ok(())
     }
 }
 
 mod index_worktree {
     mod iter {
+        use crate::Result;
         use gix::status::index_worktree::Item;
         use gix_testtools::size_ok;
         use pretty_assertions::assert_eq;
@@ -361,7 +376,7 @@ mod index_worktree {
         }
 
         #[test]
-        fn submodule_modification() -> crate::Result {
+        fn submodule_modification() -> Result {
             let repo = submodule_repo("modified-untracked-and-submodule-head-changed-and-modified")?;
             let mut status = repo
                 .status(gix::progress::Discard)?
@@ -370,13 +385,13 @@ mod index_worktree {
                         Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive);
                 })
                 .into_index_worktree_iter(None)?;
-            let items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+            let items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
             assert_eq!(items.len(), 3, "1 untracked, 1 modified file, 1 submodule modification");
             Ok(())
         }
 
         #[test]
-        fn untracked_files_collapse_by_default() -> crate::Result {
+        fn untracked_files_collapse_by_default() -> Result {
             let repo = repo("untracked-only")?;
             let status = repo
                 .status(gix::progress::Discard)?
@@ -385,7 +400,7 @@ mod index_worktree {
                         Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive);
                 })
                 .into_index_worktree_iter(None)?;
-            let items: Vec<_> = status.filter_map(Result::ok).collect();
+            let items: Vec<_> = status.filter_map(std::result::Result::ok).collect();
             assert_eq!(
                 items,
                 [
@@ -419,7 +434,7 @@ mod index_worktree {
         }
 
         #[test]
-        fn untracked_files_settings_none() -> crate::Result {
+        fn untracked_files_settings_none() -> Result {
             let mut repo = repo("untracked-only")?;
             repo.config_snapshot_mut()
                 .set_value(&gix::config::tree::Status::SHOW_UNTRACKED_FILES, "no")?;
@@ -431,7 +446,7 @@ mod index_worktree {
                         Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive);
                 })
                 .into_index_worktree_iter(None)?;
-            let items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+            let items: Vec<_> = status.by_ref().filter_map(std::result::Result::ok).collect();
             assert_eq!(items, [], "no untracked files are found…");
             assert_eq!(
                 status.outcome_mut().expect("iteration done").index_worktree.dirwalk,
@@ -442,7 +457,7 @@ mod index_worktree {
         }
 
         #[test]
-        fn early_drop_for_is_dirty_emulation() -> crate::Result {
+        fn early_drop_for_is_dirty_emulation() -> Result {
             let repo = submodule_repo("modified-untracked-and-submodule-head-changed-and-modified")?;
             let is_dirty = repo
                 .status(gix::progress::Discard)?
@@ -460,12 +475,12 @@ mod index_worktree {
 
         #[test]
         #[cfg(unix)] // symlinks are used here, let's not try our luck on Windows.
-        fn tracked_entries_under_a_symlinked_directory_are_reported_as_removed() -> crate::Result {
+        fn tracked_entries_under_a_symlinked_directory_are_reported_as_removed() -> Result {
             let repo = repo("symlink-replaces-tracked-dir")?;
             let mut items: Vec<_> = repo
                 .status(gix::progress::Discard)?
                 .into_index_worktree_iter(None)?
-                .collect::<Result<_, _>>()?;
+                .collect::<std::result::Result<_, _>>()?;
             items.sort_by(|a, b| a.rela_path().cmp(b.rela_path()));
             let idx = 2;
             assert_eq!(items[idx].rela_path(), "tracked/file");
@@ -519,24 +534,25 @@ mod index_worktree {
 }
 
 mod is_dirty {
+    use crate::Result;
     use crate::status::{repo, submodule_repo};
 
     #[test]
-    fn various_changes_positive() -> crate::Result {
+    fn various_changes_positive() -> Result {
         let repo = submodule_repo("modified-untracked-and-submodule-head-changed-and-modified")?;
         assert!(repo.is_dirty()?, "The repository has various changes");
         Ok(())
     }
 
     #[test]
-    fn submodule_changes_are_picked_up() -> crate::Result {
+    fn submodule_changes_are_picked_up() -> Result {
         let repo = submodule_repo("submodule-head-changed")?;
         assert!(repo.is_dirty()?, "head-changes are also discovered");
         Ok(())
     }
 
     #[test]
-    fn untracked_files_are_excluded() -> crate::Result {
+    fn untracked_files_are_excluded() -> Result {
         let repo = submodule_repo("module1")?;
         assert_eq!(
             repo.status(gix::progress::Discard)?
@@ -553,7 +569,7 @@ mod is_dirty {
     }
 
     #[test]
-    fn unborn_head_is_not_an_error() -> crate::Result {
+    fn unborn_head_is_not_an_error() -> Result {
         let repo = repo("untracked-unborn")?;
 
         assert!(
@@ -564,7 +580,7 @@ mod is_dirty {
     }
 
     #[test]
-    fn added_files_in_unborn_head_are_dirty() -> crate::Result {
+    fn added_files_in_unborn_head_are_dirty() -> Result {
         let repo = repo("added-unborn")?;
 
         assert!(
@@ -575,7 +591,7 @@ mod is_dirty {
     }
 
     #[test]
-    fn index_changed() -> crate::Result {
+    fn index_changed() -> Result {
         let repo = repo("git-mv")?;
         assert!(
             repo.is_dirty()?,
diff --git a/gix/tests/gix/submodule.rs b/gix/tests/gix/submodule.rs
index 7ee0d26fd8a..9cbd8552759 100644
--- a/gix/tests/gix/submodule.rs
+++ b/gix/tests/gix/submodule.rs
@@ -1,4 +1,5 @@
-pub fn repo(name: &str) -> crate::Result<gix::Repository> {
+use crate::Result;
+pub fn repo(name: &str) -> Result<gix::Repository> {
     use crate::util::named_subrepo_opts;
     Ok(named_subrepo_opts(
         "make_submodules.sh",
@@ -8,6 +9,9 @@ pub fn repo(name: &str) -> crate::Result<gix::Repository> {
 }
 
 mod open {
+    use crate::Result;
+    use std::io::Write;
+
     use gix_sec::Trust;
 
     use gix::submodule;
@@ -15,7 +19,51 @@ mod open {
     use crate::{submodule::repo, util::named_subrepo_opts};
 
     #[test]
-    fn various() -> crate::Result {
+    fn empty_worktree_config_is_not_an_uninitialized_submodule() -> Result {
+        let fixture = gix_testtools::scripted_fixture_writable("make_submodule_with_worktree.sh")?;
+        let repo = gix::open_opts(
+            fixture.path().join("submodule-with-extra-worktree-host"),
+            gix::open::Options::isolated(),
+        )?;
+        let worktree = repo.workdir().expect("fixture has a worktree");
+        gix_testtools::git(worktree, "submodule deinit -f m1")?;
+        let sm = repo
+            .submodules()?
+            .expect("fixture has submodules")
+            .next()
+            .expect("fixture has m1");
+        assert!(
+            sm.open()?.is_some(),
+            "deinitializing preserves the submodule repository"
+        );
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(repo.git_dir().join("modules/m1/config"))?
+            .write_all(b"\n[core]\n\tworktree = \n")?;
+
+        let err = sm
+            .open()
+            .expect_err("invalid core.worktree configuration must propagate");
+        insta::assert_debug_snapshot!(err, "the nested missing-path error must not hide the configuration failure", @r#"
+        The path at the 'core.worktree' configuration could not be interpolated, "input"=""
+        |
+        └─ path is missing
+        "#);
+        assert!(
+            err.error()
+                .downcast_ref::<gix_error::Message>()
+                .is_some_and(|error| error.class == Some(gix_error::Class::Validation)),
+            "the failure is classified as invalid configuration: {err:?}"
+        );
+        assert!(
+            err.is_not_found(),
+            "the nested missing-path error must not hide the configuration failure"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn various() -> Result {
         for (name, expected) in [
             (
                 "with-submodules",
@@ -128,7 +176,7 @@ mod open {
     }
 
     #[test]
-    fn absolute_looking_names_remain_below_the_modules_directory() -> crate::Result {
+    fn absolute_looking_names_remain_below_the_modules_directory() -> Result {
         let repo = repo("absolute-looking-submodule-names")?;
         let modules_dir = repo.common_dir().join("modules");
         let mut count = 0;
@@ -153,7 +201,7 @@ mod open {
     /// `git_dir_trust` from the parent repository because doing so skips recomputing
     /// trust for the submodule git-dir and can bypass ownership-based trust checks.
     #[test]
-    fn trust_is_recomputed_for_opened_submodules() -> crate::Result {
+    fn trust_is_recomputed_for_opened_submodules() -> Result {
         let repo = named_subrepo_opts(
             "make_submodules.sh",
             "with-submodules",
@@ -180,7 +228,7 @@ mod open {
     }
 
     #[test]
-    fn gitlink_target_takes_precedence_over_name_in_git_dir_resolution() -> crate::Result {
+    fn gitlink_target_takes_precedence_over_name_in_git_dir_resolution() -> Result {
         let repo = repo("submodule-with-divergent-gitlink")?;
         let sm = repo
             .submodules()?
@@ -244,7 +292,7 @@ mod open {
     }
 
     #[test]
-    fn status_uses_detached_worktree_from_symlinked_git_dir() -> crate::Result {
+    fn status_uses_detached_worktree_from_symlinked_git_dir() -> Result {
         let root =
             gix_testtools::scripted_fixture_read_only("make_submodules.sh")?.join("linked-git-dir-detached-worktree");
         let repo = gix::open_opts(root.join("home"), gix::open::Options::isolated())?;
@@ -281,7 +329,7 @@ mod open {
 
     #[test]
     #[cfg(unix)] // symlinks are used here, let's not try our luck on Windows.
-    fn keeps_callers_path_namespace_when_opened_through_symlinked_ancestor() -> crate::Result {
+    fn keeps_callers_path_namespace_when_opened_through_symlinked_ancestor() -> Result {
         let link = gix_testtools::scripted_fixture_read_only("make_submodules.sh")?.join("symlinked-ancestor");
 
         for parent_name in ["with-submodules", "with-submodule-uninitialized-checkout"] {
@@ -312,59 +360,41 @@ mod open {
     }
 
     #[test]
-    fn broken_gitlink_target_is_reported() -> crate::Result {
+    fn broken_gitlink_target_is_reported() -> Result {
+        let mut error_snapshots = Vec::new();
         let repo = repo("submodule-with-missing-gitlink-target")?;
+        let work_dir = repo.workdir().expect("fixture has a worktree");
         let sm = repo
             .submodules()?
             .expect("modules present")
             .next()
             .expect("one submodule");
 
-        assert!(matches!(
-            sm.git_dir_try_old_form(),
-            Err(submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                target: Some(target),
-                source: None,
-                ..
-            }) if target.ends_with("missing")
-        ));
-        assert!(matches!(
-            sm.state(),
-            Err(submodule::state::Error::GitDirTryOldForm(
-                submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                    target: Some(target),
-                    source: None,
-                    ..
-                }
-            )) if target.ends_with("missing")
-        ));
-        assert!(matches!(
-            sm.open(),
-            Err(submodule::open::Error::GitDir(
-                submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                    target: Some(target),
-                    source: None,
-                    ..
-                }
-            )) if target.ends_with("missing")
-        ));
+        for err in [
+            sm.git_dir_try_old_form().expect_err("the gitlink target is missing"),
+            sm.state().expect_err("state validates the gitlink target"),
+            sm.open().expect_err("opening validates the gitlink target"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(
+                &(err),
+                &[(&work_dir.to_string_lossy(), "<repository>")],
+            ));
+            assert!(err.is_validation());
+        }
 
         #[cfg(feature = "status")]
-        assert!(
-            matches!(
-                sm.status(gix::submodule::config::Ignore::None, false),
-                Err(submodule::status::Error::State(
-                    submodule::state::Error::GitDirTryOldForm(
-                        submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                            target: Some(target),
-                            source: None,
-                            ..
-                        }
-                    )
-                )) if target.ends_with("missing")
-            ),
-            "ignore=none fails as some submodules can't be opened"
-        );
+        {
+            let err = sm
+                .status(gix::submodule::config::Ignore::None, false)
+                .expect_err("ignore=none fails as some submodules can't be opened");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&work_dir.to_string_lossy(), "<repository>")]), "status reports the invalid submodule gitdir target", @r#"
+            Message {
+                message: "The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target: '<repository>/m1/../missing'",
+                class: Validation,
+            }
+            "#);
+            assert!(err.is_validation());
+        }
 
         #[cfg(feature = "status")]
         {
@@ -381,44 +411,54 @@ mod open {
             );
         }
 
+        insta::assert_debug_snapshot!(error_snapshots, "broken gitlink target is reported", @r#"
+        [
+            Message {
+                message: "The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target: '<repository>/m1/../missing'",
+                class: Validation,
+            },
+            Message {
+                message: "The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target: '<repository>/m1/../missing'",
+                class: Validation,
+            },
+            Message {
+                message: "The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target: '<repository>/m1/../missing'",
+                class: Validation,
+            },
+        ]
+        "#);
         Ok(())
     }
 
     #[test]
-    fn malformed_gitlink_target_is_ignored_by_ignore_all_status() -> crate::Result {
+    fn malformed_gitlink_target_is_ignored_by_ignore_all_status() -> Result {
         let repo = repo("submodule-with-malformed-gitlink")?;
+        let work_dir = repo.workdir().expect("fixture has a worktree");
         let sm = repo
             .submodules()?
             .expect("modules present")
             .next()
             .expect("one submodule");
 
-        assert!(matches!(
-            sm.git_dir_try_old_form(),
-            Err(submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                target: None,
-                source: Some(_),
-                ..
-            })
-        ));
+        let err = sm.git_dir_try_old_form().expect_err("the gitlink target is malformed");
+        insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err), &[(&work_dir.to_string_lossy(), "<repository>")]), "malformed gitlink target is ignored by ignore all status", @r#"
+        The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target
+        |
+        └─ Format should be 'gitdir: <path>', but got, "input"="bogus\n"
+        "#);
+        assert!(err.is_validation());
 
         #[cfg(feature = "status")]
         {
-            assert!(
-                matches!(
-                    sm.status(gix::submodule::config::Ignore::None, false),
-                    Err(submodule::status::Error::State(
-                        submodule::state::Error::GitDirTryOldForm(
-                            submodule::git_dir_try_old_form::Error::InvalidGitDirFileTarget {
-                                target: None,
-                                source: Some(_),
-                                ..
-                            }
-                        )
-                    ))
-                ),
-                "ignore=none fails as some submodules can't be opened"
-            );
+            let err = sm
+                .status(gix::submodule::config::Ignore::None, false)
+                .expect_err("ignore=none fails as some submodules can't be opened");
+            insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&err, &[(&work_dir.to_string_lossy(), "<repository>")]), "status reports the invalid submodule gitdir target", @r#"
+            The gitdir file at '<repository>/m1/.git' contains an invalid gitdir target
+            |
+            └─ Format should be 'gitdir: <path>', but got, "input"="bogus\n"
+            "#);
+            assert!(err.is_validation());
 
             let status = sm.status(gix::submodule::config::Ignore::All, false)?;
             assert_eq!(
@@ -438,10 +478,11 @@ mod open {
 
     #[cfg(feature = "status")]
     mod status {
+        use crate::Result;
         use crate::{submodule::repo, util::hex_to_id};
 
         #[test]
-        fn changed_head_compared_to_superproject_index() -> crate::Result {
+        fn changed_head_compared_to_superproject_index() -> Result {
             let repo = repo("submodule-head-changed")?;
             let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
             let mut status = sm.status(gix::submodule::config::Ignore::None, false)?;
@@ -497,7 +538,7 @@ mod open {
         }
 
         #[test]
-        fn modified_in_index_only() -> crate::Result {
+        fn modified_in_index_only() -> Result {
             let mut repo: gix::Repository = repo("submodule-index-changed")?;
             let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
 
@@ -551,7 +592,7 @@ mod open {
         }
 
         #[test]
-        fn modified_and_untracked() -> crate::Result {
+        fn modified_and_untracked() -> Result {
             let repo = repo("modified-and-untracked")?;
             let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
 
@@ -608,7 +649,7 @@ mod open {
         }
 
         #[test]
-        fn changed_head_empty_worktree() -> crate::Result {
+        fn changed_head_empty_worktree() -> Result {
             let repo = repo("submodule-head-changed-no-worktree")?;
             let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
 
@@ -641,7 +682,7 @@ mod open {
         }
 
         #[test]
-        fn is_dirty_skips_expensive_checks() -> crate::Result {
+        fn is_dirty_skips_expensive_checks() -> Result {
             let repo = repo("submodule-head-changed-and-modified")?;
             let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
 
@@ -665,7 +706,7 @@ mod open {
     }
 
     #[test]
-    fn not_a_submodule() -> crate::Result {
+    fn not_a_submodule() -> Result {
         let repo = repo("not-a-submodule")?;
         let sm = repo.submodules()?.into_iter().flatten().next().expect("one submodule");
         assert!(sm.open()?.is_some(), "repo available as it was cloned");
@@ -675,7 +716,7 @@ mod open {
     }
 
     #[test]
-    fn in_unborn() -> crate::Result {
+    fn in_unborn() -> Result {
         let repo = repo("unborn")?;
         assert_eq!(
             repo.submodules()?.into_iter().flatten().count(),
@@ -687,7 +728,7 @@ mod open {
 
     #[test]
     #[cfg(feature = "revision")]
-    fn submodule_worktrees() -> crate::Result {
+    fn submodule_worktrees() -> Result {
         let sm_repo = crate::util::named_subrepo_opts(
             "make_submodule_with_worktree.sh",
             "worktree-of-submodule",
@@ -709,7 +750,7 @@ mod open {
 
     #[test]
     #[cfg(feature = "revision")]
-    fn list_submodule_worktrees() -> crate::Result {
+    fn list_submodule_worktrees() -> Result {
         let sm_repo = crate::util::named_subrepo_opts(
             "make_submodule_with_worktree.sh",
             "submodule-with-extra-worktree-host/m1",
@@ -730,7 +771,7 @@ mod open {
     }
 
     #[test]
-    fn old_form() -> crate::Result {
+    fn old_form() -> Result {
         for name in ["old-form-invalid-worktree-path", "old-form"] {
             let repo = repo(name)?;
             let sm = repo
@@ -766,14 +807,15 @@ mod open {
 
 #[cfg(unix)]
 mod advisory {
-    use gix::bstr::BString;
+    use crate::Result;
 
     /// Reproducer for GHSA-p3hw-mv63-rf9w and GHSA-fr8x-3vfx-f45h: a crafted submodule name with
     /// traversal components is reused to derive `.git/modules/<name>`, so `Submodule::state()` and
     /// `Submodule::open()` can be redirected to another repository outside the intended modules
     /// directory.
     #[test]
-    fn traversal_names_do_not_escape_the_modules_directory() -> crate::Result {
+    fn traversal_names_do_not_escape_the_modules_directory() -> Result {
+        let mut error_snapshots = Vec::new();
         let fixture = gix_testtools::scripted_fixture_writable("make_submodule_traversal_advisory.sh")?;
         let repo_dir = fixture.path().join("victim-repo");
 
@@ -788,29 +830,21 @@ mod advisory {
             sm.git_dir(),
             Err(gix_validate::submodule::name::Error::ParentComponent)
         ));
-        assert!(matches!(
-            sm.git_dir_try_old_form(),
-            Err(gix::submodule::git_dir_try_old_form::Error::GitDir(
-                gix_validate::submodule::name::Error::ParentComponent
-            ))
-        ));
-
-        assert!(matches!(
-            sm.open(),
-            Err(gix::submodule::open::Error::GitDir(
-                gix::submodule::git_dir_try_old_form::Error::GitDir(
-                    gix_validate::submodule::name::Error::ParentComponent
-                )
-            ))
-        ));
-        assert!(matches!(
-            sm.state(),
-            Err(gix::submodule::state::Error::GitDirTryOldForm(
-                gix::submodule::git_dir_try_old_form::Error::GitDir(
-                    gix_validate::submodule::name::Error::ParentComponent
-                )
-            ))
-        ));
+        for err in [
+            sm.git_dir_try_old_form().expect_err("the traversal name is rejected"),
+            sm.open().expect_err("opening rejects the traversal name"),
+            sm.state().expect_err("state rejects the traversal name"),
+        ] {
+            error_snapshots.push(gix_testtools::redact_debug_snapshot(&(err), &[]));
+            assert!(err.is_validation());
+            assert!(
+                matches!(
+                    err.downcast_any_ref::<gix_validate::submodule::name::Error>(),
+                    Some(gix_validate::submodule::name::Error::ParentComponent)
+                ),
+                "the precise traversal-name failure remains in the erased API's chain"
+            );
+        }
 
         let redirected_repo = fixture.path().join("escaped-target.git");
         assert!(
@@ -818,6 +852,19 @@ mod advisory {
             "the attacker-controlled repository does indeex exist at {}",
             redirected_repo.display()
         );
+        insta::assert_debug_snapshot!(error_snapshots, "traversal names do not escape the modules directory", @"
+        [
+            The submodule name is invalid
+            |
+            └─ Submodules names must not contains '..',
+            The submodule name is invalid
+            |
+            └─ Submodules names must not contains '..',
+            The submodule name is invalid
+            |
+            └─ Submodules names must not contains '..',
+        ]
+        ");
         Ok(())
     }
 
@@ -825,7 +872,7 @@ mod advisory {
     /// after `git submodule init`: `gix` must reject them from `.gitmodules` instead of exposing
     /// them as executable updates.
     #[test]
-    fn update_commands_from_gitmodules_are_rejected_after_init() -> crate::Result {
+    fn update_commands_from_gitmodules_are_rejected_after_init() -> Result {
         let fixture = gix_testtools::scripted_fixture_writable("make_submodule_update_advisory.sh")?;
         let victim = fixture.path().join("victim");
 
@@ -835,16 +882,12 @@ mod advisory {
             .expect("submodules present")
             .next()
             .expect("one submodule");
-        match sm.update() {
-            Err(gix::submodule::config::update::Error::CommandForbiddenInModulesConfiguration {
-                submodule,
-                actual,
-            }) => {
-                assert_eq!(submodule, BString::from("sub"));
-                assert_eq!(actual, BString::from("touch pwned"));
-            }
-            other => panic!("expected forbidden command from `.gitmodules`, got {other:?}"),
-        }
+        let err = sm.update().expect_err("commands from `.gitmodules` are forbidden");
+        insta::assert_debug_snapshot!(err, "update commands from gitmodules are rejected after init", @r#"The 'update' field of submodule 'sub' tried to set a command to be shared, "input"="touch pwned""#);
+        assert_eq!(
+            err.values.get("input"),
+            Some(&gix_error::MetadataValue::Bytes("touch pwned".into()))
+        );
         Ok(())
     }
 }
diff --git a/gix/tests/gix/util.rs b/gix/tests/gix/util.rs
index 6d9de0f9db6..812063065a8 100644
--- a/gix/tests/gix/util.rs
+++ b/gix/tests/gix/util.rs
@@ -214,7 +214,7 @@ pub fn freeze_time() -> gix_testtools::Env<'static> {
 pub fn init_repo_isolated(
     path: impl AsRef<std::path::Path>,
     kind: gix::create::Kind,
-) -> std::result::Result<ThreadSafeRepository, gix::init::Error> {
+) -> std::result::Result<ThreadSafeRepository, gix::Error> {
     ThreadSafeRepository::init_opts(path, kind, Default::default(), open::Options::isolated())
 }
 
@@ -223,7 +223,7 @@ pub fn repo(name: &str) -> Result<ThreadSafeRepository> {
     Ok(ThreadSafeRepository::open_opts(repo_path, restricted())?)
 }
 
-pub fn repo_opts(name: &str, opts: open::Options) -> std::result::Result<ThreadSafeRepository, open::Error> {
+pub fn repo_opts(name: &str, opts: open::Options) -> std::result::Result<ThreadSafeRepository, gix_error::Error> {
     let repo_path = gix_testtools::scripted_fixture_read_only(name).unwrap();
     ThreadSafeRepository::open_opts(repo_path, opts)
 }
@@ -237,9 +237,9 @@ pub fn named_subrepo_opts(
     fixture: &str,
     name: &str,
     opts: open::Options,
-) -> std::result::Result<Repository, gix::open::Error> {
+) -> std::result::Result<Repository, gix_error::Error> {
     let repo_path = gix_testtools::scripted_fixture_read_only(fixture)
-        .map_err(|err| gix::open::Error::Io(std::io::Error::other(err)))?
+        .map_err(gix_error::Error::from_boxed)?
         .join(name);
     Ok(ThreadSafeRepository::open_opts(repo_path, opts)?.to_thread_local())
 }
diff --git a/gix/tests/repository.rs b/gix/tests/repository.rs
index de295431d6c..d9f882d029c 100644
--- a/gix/tests/repository.rs
+++ b/gix/tests/repository.rs
@@ -7,7 +7,8 @@ use serial_test::serial;
 #[test]
 #[serial]
 fn config_path_uses_repository_options_for_global_sources() -> gix_testtools::Result {
-    use gix::config::{Source, file_mut::Error};
+    let mut diagnostics = Vec::new();
+    use gix::config::Source;
 
     let fixture = gix::path::realpath(gix_testtools::scripted_fixture_read_only("make_config_repos.sh")?)?;
     let git_dir = fixture.join("bare-repo");
@@ -44,17 +45,55 @@ fn config_path_uses_repository_options_for_global_sources() -> gix_testtools::Re
 
     let repo = gix::open_opts(&git_dir, gix::open::Options::isolated())?;
     for source in [Source::GitInstallation, Source::System, Source::Git, Source::User] {
-        assert!(
-            matches!(repo.config_path(source), Err(Error::SourceUnavailable(actual)) if actual == source),
-            "{source:?} remains unavailable when disabled by the repository's permissions"
-        );
+        diagnostics.push((
+            source,
+            repo.config_path(source)
+                .expect_err("the configuration source is unavailable"),
+        ));
     }
     for source in [Source::Env, Source::Cli, Source::Api, Source::EnvOverride] {
-        assert!(
-            matches!(repo.config_path(source), Err(Error::UnsupportedSource(actual)) if actual == source),
-            "{source:?} has no physical configuration file even with a repository"
-        );
+        diagnostics.push((
+            source,
+            repo.config_path(source)
+                .expect_err("the configuration source is unavailable"),
+        ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "configuration paths distinguish disabled sources from sources without files", @"
+    [
+        (
+            GitInstallation,
+            Configuration source GitInstallation has no available path with these options,
+        ),
+        (
+            System,
+            Configuration source System has no available path with these options,
+        ),
+        (
+            Git,
+            Configuration source Git has no available path with these options,
+        ),
+        (
+            User,
+            Configuration source User has no available path with these options,
+        ),
+        (
+            Env,
+            Configuration source Env requires a repository or has no physical file,
+        ),
+        (
+            Cli,
+            Configuration source Cli requires a repository or has no physical file,
+        ),
+        (
+            Api,
+            Configuration source Api requires a repository or has no physical file,
+        ),
+        (
+            EnvOverride,
+            Configuration source EnvOverride requires a repository or has no physical file,
+        ),
+    ]
+    ");
     Ok(())
 }
 
@@ -230,13 +269,16 @@ fn paths_cannot_leave_the_repository() -> gix_testtools::Result {
         "some-with-file/very/deeply/nested/subdir/empty-file",
         "absolute paths inside the worktree become repository-relative"
     );
-    assert!(
-        matches!(
-            repo.normalize_path("../../outside"),
-            Err(gix::repository::normalize_path::Error::OutsideOfRepository { .. })
-        ),
-        "relative paths cannot traverse above the worktree"
-    );
+    let err = repo
+        .normalize_path("../../outside")
+        .expect_err("relative paths cannot traverse above the worktree");
+    assert!(err.is_validation(), "leaving the worktree is a validation error");
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(err.probable_cause(), &[(r"some\../../outside", "some/../../outside")]), "paths cannot leave the repository", @r#"
+    Message {
+        message: "The path 'some/../../outside' leaves the repository",
+        class: Validation,
+    }
+    "#);
 
     assert_eq!(
         repo.normalize_path("")?.as_bstr(),
@@ -254,19 +296,23 @@ fn absolute_paths_outside_the_repository_are_rejected() -> gix_testtools::Result
     let outside = root.parent().expect("fixture has a parent").to_owned();
     let outside_as_bstr = gix::path::into_bstr(outside.clone());
 
-    match repo
+    let err = repo
         .normalize_path(&outside_as_bstr)
-        .expect_err("an absolute path outside the repository must fail")
-    {
-        gix::repository::normalize_path::Error::AbsolutePathOutsideOfRepository {
-            path,
-            root: actual_root,
-        } => {
-            assert_eq!(path, outside, "the rejected path is retained");
-            assert_eq!(actual_root, root, "the repository root is retained");
-        }
-        err => panic!("expected an absolute-path-outside error, got {err:?}"),
+        .expect_err("an absolute path outside the repository must fail");
+    assert!(err.is_validation(), "an outside path is a validation error");
+    assert!(
+        err.downcast_any_ref::<std::path::StripPrefixError>().is_some(),
+        "the path comparison failure remains available"
+    );
+    insta::assert_debug_snapshot!(gix_testtools::redact_debug_snapshot(&(err.classify()
+            .filter(|classification| classification.class() == gix_error::Class::Validation)
+            .find_map(|classification| classification.error().downcast_ref::<gix_error::Message>())
+            .expect("the path validation diagnostic is preserved")), &[(&root.to_string_lossy(), "<repo>"), (&outside.to_string_lossy(), "<outside>")]), "absolute paths outside the repository are rejected", @r#"
+    Message {
+        message: "The absolute path '<outside>' is not inside the repository at '<repo>'",
+        class: Validation,
     }
+    "#);
     Ok(())
 }
 
@@ -443,9 +489,8 @@ fn open_options_preset_system_config_paths_avoid_running_git() -> gix_testtools:
 }
 
 #[cfg(feature = "revision")]
-fn probable_cause(res: Result<gix::Id<'_>, gix::revision::spec::parse::single::Error>) -> String {
-    match res.expect_err("the revspec must not resolve") {
-        gix::revision::spec::parse::single::Error::Parse(err) => err.probable_cause().to_string(),
-        err => panic!("expected a failure while parsing, got {err:?}"),
-    }
+fn probable_cause(res: Result<gix::Id<'_>, gix_error::Error>) -> String {
+    res.expect_err("the revspec must not resolve")
+        .probable_cause()
+        .to_string()
 }
diff --git a/src/porcelain/options.rs b/src/porcelain/options.rs
index 0dcb77c3fa3..1c65657034a 100644
--- a/src/porcelain/options.rs
+++ b/src/porcelain/options.rs
@@ -210,7 +210,7 @@ pub mod tools {
         fn assure_is_repo(dir: &OsStr) -> anyhow::Result<()> {
             let git_dir = PathBuf::from(dir).join(".git");
             let p = gix::path::realpath(&git_dir)
-                .map_err(gix::path::realpath::Error::into_error)
+                .map_err(gix::Exn::into_error)
                 .with_context(|| format!("Could not canonicalize git repository at '{}'", git_dir.display()))?;
             if p.extension().unwrap_or_default() == "git"
                 || p.file_name().unwrap_or_default() == ".git"
diff --git a/src/shared.rs b/src/shared.rs
index 67154b0c13f..0f0c8f1a95f 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -319,6 +319,7 @@ mod clap {
     }
 
     use clap::builder::{OsStringValueParser, StringValueParser, TypedValueParser};
+    use gix::ExnMessageResult;
 
     #[derive(Clone)]
     pub struct AsPathSpec;
@@ -332,7 +333,7 @@ mod clap {
 
         fn parse_ref(&self, cmd: &Command, arg: Option<&Arg>, value: &OsStr) -> Result<Self::Value, Error> {
             OsStringValueParser::new()
-                .try_map(|arg| -> Result<_, gix::pathspec::parse::Error> {
+                .try_map(|arg| -> ExnMessageResult<_> {
                     let arg = gix::path::into_bstr(std::path::PathBuf::from(arg));
                     gix::pathspec::parse(arg.as_ref(), *PATHSPEC_DEFAULTS)?;
                     Ok(arg.into_owned())
@@ -354,7 +355,7 @@ mod clap {
 
         fn parse_ref(&self, cmd: &Command, arg: Option<&Arg>, value: &OsStr) -> Result<Self::Value, Error> {
             OsStringValueParser::new()
-                .try_map(|arg| -> Result<_, gix::pathspec::parse::Error> {
+                .try_map(|arg| -> ExnMessageResult<_> {
                     let arg = gix::path::into_bstr(std::path::PathBuf::from(arg));
                     gix::pathspec::parse(arg.as_ref(), Default::default())?;
                     Ok(arg.into_owned())
diff --git a/tests/it/Cargo.toml b/tests/it/Cargo.toml
index b404c2e1714..92be80f8f00 100644
--- a/tests/it/Cargo.toml
+++ b/tests/it/Cargo.toml
@@ -17,6 +17,6 @@ path = "src/main.rs"
 [dependencies]
 anyhow = "1.0.102"
 clap = { version = "4.5.60", features = ["derive"] }
-gix = { version = "^0.87.1", path = "../../gix", default-features = false, features = ["attributes", "blame", "blob-diff", "parallel", "revision", "sha1"] }
+gix = { version = "^0.87.1", path = "../../gix", default-features = false, features = ["anyhow", "attributes", "blame", "blob-diff", "parallel", "revision", "sha1"] }
 gix-testtools = { path = "../tools", default-features = false, features = ["sha1"] }
 regex = { version = "1.12.3", default-features = false, features = ["std"] }
diff --git a/tests/it/src/commands/blame_copy_royal.rs b/tests/it/src/commands/blame_copy_royal.rs
index 8e3dae733fa..96f20a431d9 100644
--- a/tests/it/src/commands/blame_copy_royal.rs
+++ b/tests/it/src/commands/blame_copy_royal.rs
@@ -47,7 +47,7 @@ pub(super) mod function {
 
         // The following block, including the `TODO` comment, comes from
         // `gitoxide_core::repository::blame`.
-        let file = gix::path::os_str_into_bstr(file)?;
+        let file = gix::path::os_str_into_bstr(file).map_err(gix::Exn::into_error)?;
         let specs = repo.pathspec(
             false,
             [file],
@@ -71,7 +71,8 @@ pub(super) mod function {
             &mut resource_cache,
             file.as_bstr(),
             options,
-        )?;
+        )
+        .map_err(gix::Exn::into_error)?;
 
         let blame_infos = outcome
             .blame_path
@@ -91,7 +92,11 @@ pub(super) mod function {
         for blame_path_entry in &blame_infos {
             let dst = assets.join(format!("{}.commit", blame_path_entry.commit_id));
             if !dry_run {
-                let blob = repo.objects.find_blob(&blame_path_entry.blob_id, &mut buf)?.data;
+                let blob = repo
+                    .objects
+                    .find_blob(&blame_path_entry.blob_id, &mut buf)
+                    .map_err(gix::Exn::into_error)?
+                    .data;
 
                 if verbatim {
                     std::fs::write(dst, blob)?;
diff --git a/tests/it/src/commands/create_diff_cases.rs b/tests/it/src/commands/create_diff_cases.rs
index ad43ae5a2e3..2372b03a1b8 100644
--- a/tests/it/src/commands/create_diff_cases.rs
+++ b/tests/it/src/commands/create_diff_cases.rs
@@ -79,10 +79,18 @@ mkdir -p assets
             let dst_old_blob = assets.join(format!("{old_blob_id}.blob"));
             let dst_new_blob = assets.join(format!("{new_blob_id}.blob"));
             if !dry_run {
-                let old_blob = repo.objects.find_blob(&old_blob_id, &mut buf)?.data;
+                let old_blob = repo
+                    .objects
+                    .find_blob(&old_blob_id, &mut buf)
+                    .map_err(gix::Exn::into_error)?
+                    .data;
                 std::fs::write(dst_old_blob, old_blob)?;
 
-                let new_blob = repo.objects.find_blob(&new_blob_id, &mut buf)?.data;
+                let new_blob = repo
+                    .objects
+                    .find_blob(&new_blob_id, &mut buf)
+                    .map_err(gix::Exn::into_error)?
+                    .data;
                 std::fs::write(dst_new_blob, new_blob)?;
             }
 
diff --git a/tests/it/src/commands/git_to_sh.rs b/tests/it/src/commands/git_to_sh.rs
index 435f3d69095..1a014a0e7a5 100644
--- a/tests/it/src/commands/git_to_sh.rs
+++ b/tests/it/src/commands/git_to_sh.rs
@@ -107,7 +107,10 @@ pub(super) mod function {
                         unreachable!("Can't have trees in indices")
                     }
                     EntryKind::Blob | EntryKind::BlobExecutable => {
-                        let obj = repo.objects.find(&entry.id, &mut blob_buf)?;
+                        let obj = repo
+                            .objects
+                            .find(&entry.id, &mut blob_buf)
+                            .map_err(gix::Exn::into_error)?;
                         if verbatim {
                             (entry.id, Cow::Borrowed(&blob_buf))
                         } else {
@@ -126,7 +129,9 @@ pub(super) mod function {
                         }
                     }
                     EntryKind::Link => {
-                        repo.objects.find(&entry.id, &mut blob_buf)?;
+                        repo.objects
+                            .find(&entry.id, &mut blob_buf)
+                            .map_err(gix::Exn::into_error)?;
                         (entry.id, Cow::Borrowed(&blob_buf))
                     }
                     EntryKind::Commit => continue,
diff --git a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-host b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-host
index 52e6b005a91..761206d7dc1 100644
--- a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-host
+++ b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-host
@@ -1 +1,6 @@
-
Error: Host name '-oProxyCommand=open$IFS-aCalculator' could be mistaken for a command-line argument
\ No newline at end of file
+
Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Host name '-oProxyCommand=open$IFS-aCalculator' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-path b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-path
index 5ce09d4e1a9..eca984a0560 100644
--- a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-path
+++ b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-path
@@ -1 +1,5 @@
-
Error: The repository path '-oProxyCommand=open$IFS-aCalculator/bar' could be mistaken for a command-line argument
\ No newline at end of file
+
Error: Transport handshake failed
+
+Caused by:
+    0: The repository path '-oProxyCommand=open$IFS-aCalculator/bar' could be mistaken for a command-line argument
+    1: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/explicit-ssh b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/explicit-ssh
index 78d252596ad..a02e94061ed 100644
--- a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/explicit-ssh
+++ b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/explicit-ssh
@@ -1 +1,6 @@
-
Error: Username '-Fconfigfile' could be mistaken for a command-line argument
\ No newline at end of file
+
Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Username '-Fconfigfile' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/implicit-ssh b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/implicit-ssh
index 78d252596ad..a02e94061ed 100644
--- a/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/implicit-ssh
+++ b/tests/snapshots/plumbing/no-repo/pack/clone/fail-ambiguous-username/implicit-ssh
@@ -1 +1,6 @@
-
Error: Username '-Fconfigfile' could be mistaken for a command-line argument
\ No newline at end of file
+
Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Username '-Fconfigfile' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-host b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-host
index 473adbb4a27..d11a7f21a37 100644
--- a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-host
+++ b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-host
@@ -1 +1,6 @@
-Error: Host name '-oProxyCommand=open$IFS-aCalculator' could be mistaken for a command-line argument
\ No newline at end of file
+Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Host name '-oProxyCommand=open$IFS-aCalculator' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-path b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-path
index 2d3c844e17f..6a4f4fb705a 100644
--- a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-path
+++ b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-path
@@ -1 +1,5 @@
-Error: The repository path '-oProxyCommand=open$IFS-aCalculator/bar' could be mistaken for a command-line argument
\ No newline at end of file
+Error: Transport handshake failed
+
+Caused by:
+    0: The repository path '-oProxyCommand=open$IFS-aCalculator/bar' could be mistaken for a command-line argument
+    1: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/explicit-ssh b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/explicit-ssh
index 8a9fca8771d..179b115af29 100644
--- a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/explicit-ssh
+++ b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/explicit-ssh
@@ -1 +1,6 @@
-Error: Username '-Fconfigfile' could be mistaken for a command-line argument
\ No newline at end of file
+Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Username '-Fconfigfile' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/implicit-ssh b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/implicit-ssh
index 8a9fca8771d..179b115af29 100644
--- a/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/implicit-ssh
+++ b/tests/snapshots/plumbing/no-repo/pack/receive/fail-ambiguous-username/implicit-ssh
@@ -1 +1,6 @@
-Error: Username '-Fconfigfile' could be mistaken for a command-line argument
\ No newline at end of file
+Error: Transport handshake failed
+
+Caused by:
+    0: Failed to prepare SSH invocation
+    1: Username '-Fconfigfile' could be mistaken for a command-line argument
+    2: Validation
\ No newline at end of file
diff --git a/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure b/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
index fec486aaac0..1ffffc3c84d 100644
--- a/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
+++ b/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
@@ -1,4 +1,5 @@
-Error: couldn't parse revision: "foobar"
+Error: couldn't parse revision, "input"="foobar"
 
 Caused by:
-    The ref partially named "foobar" could not be found
\ No newline at end of file
+    0: The ref partially named "foobar" could not be found
+    1: NotFound
\ No newline at end of file
diff --git a/tests/snapshots/porcelain/init/fail b/tests/snapshots/porcelain/init/fail
index 3897b81e206..c8a90e9a194 100644
--- a/tests/snapshots/porcelain/init/fail
+++ b/tests/snapshots/porcelain/init/fail
@@ -1,4 +1,4 @@
 Error: Repository initialization failed
 
 Caused by:
-    Refusing to initialize the existing '.git' directory
\ No newline at end of file
+    Refusing to initialize an existing directory, "input"=".git"
\ No newline at end of file
diff --git a/tests/snapshots/porcelain/init/fail-with-multi-element-directory b/tests/snapshots/porcelain/init/fail-with-multi-element-directory
index fb1ec202ce8..9d324e99958 100644
--- a/tests/snapshots/porcelain/init/fail-with-multi-element-directory
+++ b/tests/snapshots/porcelain/init/fail-with-multi-element-directory
@@ -1,4 +1,4 @@
 Error: Repository initialization failed
 
 Caused by:
-    Refusing to initialize the existing 'foo/bar/.git' directory
\ No newline at end of file
+    Refusing to initialize an existing directory, "input"="foo/bar/.git"
\ No newline at end of file
diff --git a/tests/tools/src/lib.rs b/tests/tools/src/lib.rs
index cb45612b415..06bbc3b7378 100644
--- a/tests/tools/src/lib.rs
+++ b/tests/tools/src/lib.rs
@@ -52,9 +52,6 @@ pub mod repository;
 
 const ARCHIVE_DIR_NAME: &str = "generated-archives";
 
-/// The error returned by test functions.
-pub use gix_error::TestError as Error;
-
 /// A result type to allow using the try operator `?` in unit tests.
 ///
 /// Use it like so:
@@ -1995,6 +1992,105 @@ pub fn normalize_debug_snapshot(value: &dyn std::fmt::Debug) -> (String, Vec<gix
     normalize_hashes(&format!("{value:#?}"))
 }
 
+/// Prepare a pretty-debug diagnostic for an `insta::assert_debug_snapshot!` assertion.
+///
+/// Apply literal `replacements` (and their debug-escaped spellings) in the given order, then normalize
+/// object IDs with [`normalize_hashes()`]. Supply unstable path prefixes or port numbers explicitly,
+/// preserving meaningful path suffixes. Windows paths also match without their verbatim prefix or
+/// with forward slashes. Windows path suffixes use forward slashes; backslashes in
+/// other input remain unchanged. Use complete paths for unquoted paths containing whitespace.
+/// Platform-specific I/O messages and pretty-debug OS errors are replaced by their [`std::io::ErrorKind`].
+///
+/// The returned value owns its text and prints it without adding quotes or escaping newlines.
+pub fn redact_debug_snapshot(
+    value: &dyn std::fmt::Debug,
+    replacements: &[(&str, &str)],
+) -> impl std::fmt::Debug + use<> {
+    struct Diagnostic(String);
+
+    impl std::fmt::Debug for Diagnostic {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.write_str(&self.0)
+        }
+    }
+
+    let mut text = format!("{value:#?}");
+    for (from, to) in replacements {
+        let windows_path = from.contains('\\') || (cfg!(windows) && from.contains('/'));
+        let mut prefixes = vec![(*from).to_owned()];
+        if windows_path {
+            let plain = match from.strip_prefix(r"\\?\") {
+                Some(path) => path
+                    .strip_prefix(r"UNC\")
+                    .map_or_else(|| path.to_owned(), |path| format!(r"\\{path}")),
+                None => (*from).to_owned(),
+            };
+            prefixes.push(plain.replace('\\', "/"));
+            prefixes.push(plain);
+        }
+        prefixes.extend(prefixes.clone().iter().map(|prefix| {
+            let escaped = format!("{prefix:?}");
+            escaped[1..escaped.len() - 1].to_owned()
+        }));
+        prefixes.sort();
+        prefixes.dedup();
+        prefixes.sort_by_key(|prefix| std::cmp::Reverse(prefix.len()));
+        for prefix in &prefixes {
+            if !windows_path {
+                text = text.replace(prefix, to);
+                continue;
+            }
+            let paths: Vec<_> = text
+                .match_indices(prefix.as_str())
+                .map(|(start, _)| {
+                    let suffix_start = start + prefix.len();
+                    let quote = text[..start].chars().next_back().filter(|ch| matches!(ch, '\'' | '"'));
+                    // ponytail: whitespace delimits unquoted paths; supply a complete path if it contains spaces.
+                    let suffix_len = match quote {
+                        Some('"') if text[..start].ends_with(r#"\""#) => text[suffix_start..].find(r#"\""#),
+                        Some('\'') if text[..start].ends_with(r"\'") => text[suffix_start..].find(r"\'"),
+                        Some(quote) => text[suffix_start..].find(quote),
+                        None => text[suffix_start..].find(|ch: char| ch.is_whitespace() || matches!(ch, '\'' | '"')),
+                    }
+                    .unwrap_or(text.len() - suffix_start);
+                    let end = suffix_start + suffix_len;
+                    let suffix = text[suffix_start..end].replace(r"\\", "/").replace('\\', "/");
+                    (start, end, format!("{to}{suffix}"))
+                })
+                .collect();
+            for (start, end, replacement) in paths.into_iter().rev() {
+                text.replace_range(start..end, &replacement);
+            }
+        }
+    }
+    let os_errors: Vec<_> = text
+        .split("(os error ")
+        .skip(1)
+        .filter_map(|tail| tail.split_once(')')?.0.parse::<i32>().ok())
+        .map(std::io::Error::from_raw_os_error)
+        .collect();
+    for err in os_errors {
+        text = text.replace(&err.to_string(), &format!("{:?}", err.kind()));
+    }
+    let os_debug: Vec<_> = text
+        .match_indices("Os {\n")
+        .filter_map(|(start, _)| {
+            let line = text[start + "Os {\n".len()..].lines().next()?;
+            let code = line.trim().strip_prefix("code: ")?.strip_suffix(',')?.parse().ok()?;
+            let err = std::io::Error::from_raw_os_error(code);
+            let indent = " ".repeat((line.len() - line.trim_start().len()).saturating_sub(4));
+            Some((
+                format!("{err:#?}").replace('\n', &format!("\n{indent}")),
+                format!("{:?}", err.kind()),
+            ))
+        })
+        .collect();
+    for (from, to) in os_debug {
+        text = text.replace(&from, &to);
+    }
+    Diagnostic(normalize_hashes(&text).0)
+}
+
 /// Normalize 40- and 64-character hexadecimal object IDs in `input`.
 ///
 /// This is like [`normalize_debug_snapshot()`], but operates on already-formatted text.
diff --git a/tests/tools/src/repository/gix.rs b/tests/tools/src/repository/gix.rs
index f0094e1ff1e..7bf3cc23ddc 100644
--- a/tests/tools/src/repository/gix.rs
+++ b/tests/tools/src/repository/gix.rs
@@ -73,10 +73,10 @@ fn worktree_config(git_dir: &Path, config: &gix_config::File) -> Result<Option<g
         return Ok(None);
     }
     let path = git_dir.join("config.worktree");
-    path.is_file()
+    Ok(path
+        .is_file()
         .then(|| gix_config::File::from_path_no_includes(path, gix_config::Source::Worktree))
-        .transpose()
-        .map_err(Into::into)
+        .transpose()?)
 }
 
 fn worktree_from_config(
@@ -189,7 +189,7 @@ fn resolve_symbolic(store: &gix_ref::file::Store, mut name: gix_ref::FullName) -
                     is_broken: false,
                 });
             }
-            Err(gix_ref::file::find::Error::ReferenceCreation { .. }) => {
+            Err(err) if err.downcast_any_ref::<gix_ref::file::find::ReferenceDecode>().is_some() => {
                 return Ok(SymbolicResolution {
                     name,
                     id: None,
@@ -218,7 +218,9 @@ fn references(store: &gix_ref::file::Store) -> Result<(Vec<Reference>, Vec<Objec
     for reference in platform.all()? {
         let reference = match reference {
             Ok(reference) => reference,
-            Err(gix_ref::file::iter::loose_then_packed::Error::ReferenceCreation { .. }) => continue,
+            Err(err) if err.downcast_any_ref::<gix_ref::file::find::ReferenceDecode>().is_some() => {
+                continue;
+            }
             Err(err) => return Err(err.into()),
         };
         if !reference.name.as_ref().as_bstr().starts_with(b"refs/") {
diff --git a/tests/tools/tests/env.rs b/tests/tools/tests/env.rs
index 037502d8c4a..d5ba24b54e7 100644
--- a/tests/tools/tests/env.rs
+++ b/tests/tools/tests/env.rs
@@ -108,6 +108,7 @@ mod isolate_git_environment {
     use std::{
         collections::BTreeMap,
         ffi::{OsStr, OsString},
+        io::Write,
         path::PathBuf,
         process::Command,
     };
@@ -251,8 +252,12 @@ mod isolate_git_environment {
         let outside = tempfile::tempdir()?;
         gix_testtools::git(repo.path(), "init -q")?;
         gix_testtools::git(outside.path(), "init -q")?;
-        gix_testtools::git(repo.path(), "config foo.bar intended")?;
-        gix_testtools::git(outside.path(), "config foo.bar outside")?;
+        for (directory, value) in [(repo.path(), "intended"), (outside.path(), "outside")] {
+            let mut config = std::fs::OpenOptions::new()
+                .append(true)
+                .open(directory.join(".git/config"))?;
+            writeln!(config, "\n[foo]\n\tbar = {value}")?;
+        }
         let mut command = gix_testtools::git_command(repo.path());
         command.args(["config", "--local", "--get", "foo.bar"]);
 
@@ -348,11 +353,12 @@ mod isolate_git_environment {
             "an early successful return restores the entire environment"
         );
         let error = leave_scope(true).expect_err("the deliberate error leaves the guarded scope");
-        assert_eq!(
-            error.to_string(),
-            "deliberate scoped error",
-            "the error comes from inside the scope, not guard creation"
-        );
+        insta::assert_debug_snapshot!(error, "the error comes from inside the scope, not guard creation", @r#"
+        Custom {
+            kind: Other,
+            error: "deliberate scoped error",
+        }
+        "#);
         assert_eq!(snapshot(), before, "error propagation restores the entire environment");
         Ok(())
     }
diff --git a/tests/tools/tests/sbom.rs b/tests/tools/tests/sbom.rs
index 8d042b42be7..aa20f5a2e93 100644
--- a/tests/tools/tests/sbom.rs
+++ b/tests/tools/tests/sbom.rs
@@ -127,20 +127,57 @@ fn help_and_invalid_selection() -> Result {
         String::from_utf8_lossy(&help.stdout).contains("--package"),
         "help explains package selection"
     );
-    for (args, diagnostic) in [
-        (vec!["--package", "missing"], "unknown workspace package"),
-        (vec!["--package", "app", "--features", "missing"], "unknown feature"),
-        (vec!["--features", "http"], "--package"),
-        (vec!["--package"], "requires a value"),
+    let mut diagnostics = Vec::new();
+    for args in [
+        vec!["--package", "missing"],
+        vec!["--package", "app", "--features", "missing"],
+        vec!["--features", "http"],
+        vec!["--package"],
     ] {
         let output = jtt(root.path(), &args)?;
         assert!(!output.status.success(), "invalid selection must fail: {args:?}");
-        assert!(
-            String::from_utf8_lossy(&output.stderr).contains(diagnostic),
-            "diagnostic explains {args:?}: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
+        diagnostics.push((
+            args,
+            gix_testtools::redact_debug_snapshot(&format_args!("{}", String::from_utf8_lossy(&output.stderr)), &[]),
+        ));
     }
+    insta::assert_debug_snapshot!(diagnostics, "invalid SBOM selections identify the rejected package, feature, or argument", @r#"
+    [
+        (
+            [
+                "--package",
+                "missing",
+            ],
+            Error: "unknown workspace package Some(\"missing\")"
+            ,
+        ),
+        (
+            [
+                "--package",
+                "app",
+                "--features",
+                "missing",
+            ],
+            Error: "unknown feature \"missing\" for \"app\""
+            ,
+        ),
+        (
+            [
+                "--features",
+                "http",
+            ],
+            Error: "feature selection requires --package; workspace inventories always enable all features"
+            ,
+        ),
+        (
+            [
+                "--package",
+            ],
+            Error: "--package requires a value"
+            ,
+        ),
+    ]
+    "#);
     Ok(())
 }
 
diff --git a/tests/tools/tests/tools/main.rs b/tests/tools/tests/tools/main.rs
index d2a06528e21..b8e3fc5475b 100644
--- a/tests/tools/tests/tools/main.rs
+++ b/tests/tools/tests/tools/main.rs
@@ -1,5 +1,5 @@
 mod isolation {
-    use gix_testtools::{Creation, Result};
+    use gix_testtools::{Creation, Result, redact_debug_snapshot};
 
     #[test]
     fn script_configuration_adds_to_the_isolation() -> Result {
@@ -36,6 +36,92 @@ mod isolation {
         );
         Ok(())
     }
+
+    #[test]
+    fn redact_debug_snapshot_preserves_diagnostics_and_object_identity() {
+        for (input, replacements, expected) in [
+            (
+                "read /tmp/random/repo/objects/pack failed: NotFound\nsource: /tmp/random/repo/config",
+                &[("/tmp/random/repo", "<repo>")][..],
+                "read <repo>/objects/pack failed: NotFound\nsource: <repo>/config",
+            ),
+            (
+                r#"path: "C:\\Temp\\random\\repo\\config", input: "a\\b""#,
+                &[(r"C:\Temp\random\repo\config", "<repo>/config")][..],
+                r#"path: "<repo>/config", input: "a\\b""#,
+            ),
+            (
+                r#"path: "C:\\Temp\\random\\repo\\dir with spaces\\config", input: "a\\b""#,
+                &[(r"C:\Temp\random\repo", "<repo>")][..],
+                r#"path: "<repo>/dir with spaces/config", input: "a\\b""#,
+            ),
+            (
+                r"Alternates form a cycle -> C:\Temp\repo\a -> C:\Temp\repo\b",
+                &[(r"C:\Temp\repo", "<repo>")][..],
+                "Alternates form a cycle -> <repo>/a -> <repo>/b",
+            ),
+            (
+                r"error: C:/Temp/repo/base did not send all necessary objects",
+                &[(r"C:\Temp\repo", "<repo>")][..],
+                "error: <repo>/base did not send all necessary objects",
+            ),
+            (
+                r"Alternates form a cycle -> C:\Temp\repo\a -> C:\Temp\repo\b",
+                &[(r"\\?\C:\Temp\repo", "<repo>")][..],
+                "Alternates form a cycle -> <repo>/a -> <repo>/b",
+            ),
+            (
+                r#"path: "tests/fixtures\\repo\\sub\\config", input: "a\\b""#,
+                &[(r"tests/fixtures\repo", "<repo>")][..],
+                r#"path: "<repo>/sub/config", input: "a\\b""#,
+            ),
+            (
+                r#"message: "Could not read \"C:\\Temp\\repo\\config\"", input: "a\\b""#,
+                &[(r"C:\Temp\repo", "<repo>")][..],
+                r#"message: "Could not read \"<repo>/config\"", input: "a\\b""#,
+            ),
+            (
+                r#"Filter process "\'C:/Temp/filter.exe\' process fail-on-shutdown" failed"#,
+                &[(r"C:\Temp\filter.exe", "<filter-driver>")][..],
+                r#"Filter process "\'<filter-driver>\' process fail-on-shutdown" failed"#,
+            ),
+            (
+                "connect 127.0.0.1:49152: ConnectionRefused; expected port 443",
+                &[("127.0.0.1:49152", "127.0.0.1:<port>")][..],
+                "connect 127.0.0.1:<port>: ConnectionRefused; expected port 443",
+            ),
+        ] {
+            let snapshot = redact_debug_snapshot(&format_args!("{input}"), replacements);
+            assert_eq!(
+                format!("{snapshot:#?}"),
+                expected,
+                "explicit redactions preserve the surrounding diagnostic without extra quoting"
+            );
+        }
+        let os_error = std::io::Error::from_raw_os_error(2);
+        let snapshot = redact_debug_snapshot(&format_args!("read failed: {os_error}"), &[]);
+        assert_eq!(
+            format!("{snapshot:#?}"),
+            format!("read failed: {:?}", os_error.kind()),
+            "platform-dependent OS text is reduced to its portable error kind"
+        );
+        let snapshot = redact_debug_snapshot(&vec![os_error], &[]);
+        insta::assert_debug_snapshot!(snapshot, "nested pretty-debug OS errors omit platform-specific codes and messages", @"
+        [
+            NotFound,
+        ]
+        ");
+
+        #[cfg(all(feature = "sha1", feature = "sha256"))]
+        {
+            let input = "expected e69de29bb2d1d6434b8b29ae775ad8c2e48c5391, actual 473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813; expected e69de29bb2d1d6434b8b29ae775ad8c2e48c5391";
+            let snapshot = redact_debug_snapshot(&format_args!("{input}"), &[]);
+            assert_eq!(
+                format!("{snapshot:#?}"),
+                "expected Oid(1), actual Oid(2); expected Oid(1)"
+            );
+        }
+    }
 }
 mod repository;
 mod rust_fixture;
diff --git a/tests/tools/tests/tools/repository.rs b/tests/tools/tests/tools/repository.rs
index 5905295e478..a4bd4d534dd 100644
--- a/tests/tools/tests/tools/repository.rs
+++ b/tests/tools/tests/tools/repository.rs
@@ -57,7 +57,7 @@ mod snapshot {
         let again = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(state, again, "taking a snapshot has no observable side effects");
 
-        gix_testtools::git(fixture.path(), "checkout --theirs -- conflicted")?;
+        std::fs::write(fixture.path().join("conflicted"), b"conflict theirs\n")?;
         gix_testtools::git(fixture.path(), "add conflicted")?;
         assert!(
             gix_testtools::repository::snapshot(fixture.path())?
diff --git a/tests/tools/tests/tools/rust_fixture.rs b/tests/tools/tests/tools/rust_fixture.rs
index 4dd4712f3c8..b34dcf2c9e1 100644
--- a/tests/tools/tests/tools/rust_fixture.rs
+++ b/tests/tools/tests/tools/rust_fixture.rs
@@ -101,9 +101,6 @@ fn rust_fixture_closure_error_propagates() {
         Err::<(), _>("intentional error".into())
     });
 
-    let err_msg = res.unwrap_err().to_string();
-    assert!(
-        err_msg.contains("intentional error"),
-        "Error message should contain the original error, got: {err_msg}"
-    );
+    let err = res.expect_err("the fixture closure failed");
+    insta::assert_debug_snapshot!(err, "fixture setup preserves the closure's error", @r#""intentional error""#);
 }