From cc952d361a9f2f2a4ad48cecd01d2b55e896eee8 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 01:38:06 -0400
Subject: [PATCH 01/14] feat(binary): binary patch types and parser

* Added types representing both literal and delta Git binary patches
* Added a parser for the `GIT binary patch` format.

This doesn't include the patch application
(which will be added in later commits)

The implementation is based on

* Specification from <https://diffx.org/spec/binary-diffs.html>
* Behavior observation of Git CLI
---
 src/binary/mod.rs | 338 ++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs        |   1 +
 2 files changed, 339 insertions(+)
 create mode 100644 src/binary/mod.rs

diff --git a/src/binary/mod.rs b/src/binary/mod.rs
new file mode 100644
index 00000000..7f2db8fc
--- /dev/null
+++ b/src/binary/mod.rs
@@ -0,0 +1,338 @@
+//! Git binary diffs support.
+//!
+//! This module provides parsing and decoding for Git's binary diff format,
+//! as generated by `git diff --binary` or `git format-patch --binary`.
+//!
+//! Based on [DiffX Binary Diffs specification](https://diffx.org/spec/binary-diffs.html).
+
+use std::{fmt, ops::Range};
+
+/// The type of a binary patch block.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinaryBlockKind {
+    /// [Literal](https://diffx.org/spec/binary-diffs.html#git-literal-binary-diffs):
+    /// contains the full file content, zlib-compressed and Base85-encoded.
+    Literal,
+    /// [Delta](https://diffx.org/spec/binary-diffs.html#git-delta-binary-diffs):
+    /// contains delta instructions to transform one file into another.
+    Delta,
+}
+
+/// A single block in a binary patch.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BinaryBlock<'a> {
+    /// The type of this block (literal content or delta instructions).
+    pub kind: BinaryBlockKind,
+    /// The encoded data.
+    pub data: BinaryData<'a>,
+}
+
+/// A parsed binary patch.
+///
+/// A binary patch contains encoded binary data that can be decoded
+/// to recover the original and modified file contents.
+///
+/// Git may use different encodings for each direction:
+///
+/// - `literal`: full file content
+/// - `delta`: instructions to transform one file into another
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BinaryPatch<'a> {
+    /// A full binary patch with forward and reverse data.
+    ///
+    /// The forward block transforms original -> modified.
+    /// The reverse block transforms modified -> original.
+    ///
+    /// Each block can independently be either `literal` or `delta`.
+    Full {
+        /// Forward transformation (original -> modified).
+        forward: BinaryBlock<'a>,
+        /// Reverse transformation (modified -> original).
+        reverse: BinaryBlock<'a>,
+    },
+    /// A Git binary diff marker.
+    ///
+    /// This represents the `Binary files a/path and b/path differ` case,
+    /// where git detected a binary change but didn't include the actual data.
+    Marker,
+}
+
+/// Represents a single binary payload in a Git binary diff.
+///
+/// For example, the following patch block
+///
+/// * is parsed as `BinaryData { size: 10, data: "UcmV+l0QLU>0RjUA1qKHQ2>\`DEE&u=k" }`
+/// * The line starts with a length indicator (`U` = 21 decoded bytes)
+///
+///
+/// ```text
+/// literal 10
+/// UcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BinaryData<'a> {
+    /// Uncompressed size in bytes.
+    pub size: u64,
+    /// Raw Base85 lines with length indicators.
+    pub data: &'a str,
+}
+
+/// Error type for binary patch operations.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BinaryPatchParseError {
+    pub(crate) kind: BinaryPatchParseErrorKind,
+    span: Option<Range<usize>>,
+}
+
+impl BinaryPatchParseError {
+    /// Creates a new error with the given kind and span.
+    pub(crate) fn new(kind: BinaryPatchParseErrorKind, span: Range<usize>) -> Self {
+        Self {
+            kind,
+            span: Some(span),
+        }
+    }
+
+    /// Returns the byte range in the input where the error occurred.
+    pub fn span(&self) -> Option<Range<usize>> {
+        self.span.clone()
+    }
+}
+
+impl fmt::Display for BinaryPatchParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(span) = &self.span {
+            write!(
+                f,
+                "error parsing binary patch at byte {}: {}",
+                span.start, self.kind
+            )
+        } else {
+            write!(f, "error parsing binary patch: {}", self.kind)
+        }
+    }
+}
+
+impl std::error::Error for BinaryPatchParseError {}
+
+impl From<BinaryPatchParseErrorKind> for BinaryPatchParseError {
+    fn from(kind: BinaryPatchParseErrorKind) -> Self {
+        Self { kind, span: None }
+    }
+}
+
+/// The kind of error that occurred when parsing a binary patch.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub(crate) enum BinaryPatchParseErrorKind {
+    /// Missing or invalid "GIT binary patch" header.
+    InvalidHeader,
+
+    /// First binary block (forward) not found.
+    MissingForwardBlock,
+
+    /// Second binary block (reverse) not found.
+    MissingReverseBlock,
+
+    /// No binary data available (marker-only patch).
+    NoBinaryData,
+
+    /// Invalid line length indicator in Base85 data.
+    InvalidLineLengthIndicator,
+}
+
+impl fmt::Display for BinaryPatchParseErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidHeader => write!(f, "invalid binary patch header"),
+            Self::MissingForwardBlock => write!(f, "first binary block not found"),
+            Self::MissingReverseBlock => write!(f, "second binary block not found"),
+            Self::NoBinaryData => write!(f, "no binary data available"),
+            Self::InvalidLineLengthIndicator => write!(f, "invalid line length indicator"),
+        }
+    }
+}
+
+/// Simple streaming parser for binary patches.
+struct BinaryParser<'a> {
+    input: &'a str,
+    offset: usize,
+}
+
+impl<'a> BinaryParser<'a> {
+    fn new(input: &'a str) -> Self {
+        Self { input, offset: 0 }
+    }
+
+    /// Creates an error with the current offset as span.
+    fn error(&self, kind: BinaryPatchParseErrorKind) -> BinaryPatchParseError {
+        BinaryPatchParseError::new(kind, self.offset..self.offset)
+    }
+
+    fn next_line(&mut self) -> Option<&'a str> {
+        let rest = &self.input[self.offset..];
+        if rest.is_empty() {
+            return None;
+        }
+        let (line, skip) = match rest.find('\n') {
+            Some(pos) => (&rest[..pos], pos + 1),
+            None => (rest, rest.len()),
+        };
+        self.offset += skip;
+        Some(line.strip_suffix('\r').unwrap_or(line))
+    }
+}
+
+/// Parses binary patch content after git extended headers.
+///
+/// Expects input starting with "GIT binary patch" line.
+/// Returns the parsed patch and the number of bytes consumed.
+///
+/// Format:
+///
+/// ```text
+/// GIT binary patch
+/// <literal|delta> <modified_size>
+/// <base85_lines>
+///
+/// <literal|delta> <original_size>
+/// <base85_lines>
+/// ```
+pub(crate) fn parse_binary_patch(
+    input: &str,
+) -> Result<(BinaryPatch<'_>, usize), BinaryPatchParseError> {
+    let mut parser = BinaryParser::new(input);
+
+    // Expect "GIT binary patch" marker
+    if parser.next_line() != Some("GIT binary patch") {
+        return Err(parser.error(BinaryPatchParseErrorKind::InvalidHeader));
+    }
+
+    // Parse first block (forward: original -> modified)
+    let Some(forward) = parse_binary_block(&mut parser) else {
+        return Err(parser.error(BinaryPatchParseErrorKind::MissingForwardBlock));
+    };
+
+    // Parse second block (reverse: modified -> original)
+    let Some(reverse) = parse_binary_block(&mut parser) else {
+        return Err(parser.error(BinaryPatchParseErrorKind::MissingReverseBlock));
+    };
+
+    Ok((BinaryPatch::Full { forward, reverse }, parser.offset))
+}
+
+/// Parses a single binary block.
+///
+/// Returns a `BinaryBlock` with kind (literal/delta) and data.
+fn parse_binary_block<'a>(parser: &mut BinaryParser<'a>) -> Option<BinaryBlock<'a>> {
+    // Parse "literal 10" or "delta 18"
+    let format_line = parser.next_line()?;
+    let (patch_type, size_str) = format_line.split_once(' ')?;
+    let size: u64 = size_str.parse().ok()?;
+
+    let kind = match patch_type {
+        "literal" => BinaryBlockKind::Literal,
+        "delta" => BinaryBlockKind::Delta,
+        _ => return None,
+    };
+
+    // Consume Base85 lines until blank line, tracking the end of actual data.
+    let data_start = parser.offset;
+    let mut data_end = data_start;
+    while let Some(line) = parser.next_line() {
+        if line.is_empty() {
+            break;
+        }
+        data_end = parser.offset;
+    }
+
+    // Slice the data lines, stripping the final line ending.
+    let data = &parser.input[data_start..data_end];
+    let data = data
+        .strip_suffix("\r\n")
+        .or_else(|| data.strip_suffix('\n'))
+        .unwrap_or(data);
+
+    Some(BinaryBlock {
+        kind,
+        data: BinaryData { size, data },
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_literal_format_simple() {
+        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let (patch, consumed) = parse_binary_patch(input).unwrap();
+
+        assert_eq!(consumed, input.len());
+        match &patch {
+            BinaryPatch::Full { forward, reverse } => {
+                assert_eq!(forward.kind, BinaryBlockKind::Literal);
+                assert_eq!(forward.data.size, 10);
+                assert_eq!(reverse.kind, BinaryBlockKind::Literal);
+                assert_eq!(reverse.data.size, 0);
+            }
+            _ => panic!("expected Full variant"),
+        }
+    }
+
+    #[test]
+    fn parse_delta_format() {
+        let input = "GIT binary patch\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^BFm9#}av-trB0zxAOrvLx|\n\n";
+        let (patch, _) = parse_binary_patch(input).unwrap();
+
+        match &patch {
+            BinaryPatch::Full { forward, reverse } => {
+                assert_eq!(forward.kind, BinaryBlockKind::Delta);
+                assert_eq!(forward.data.size, 18);
+                assert_eq!(reverse.kind, BinaryBlockKind::Delta);
+                assert_eq!(reverse.data.size, 18);
+            }
+            _ => panic!("expected Full variant"),
+        }
+    }
+
+    #[test]
+    fn parse_invalid_header() {
+        // Without "GIT binary patch" marker, parse_binary_patch returns error
+        let input = "literal 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\n";
+        let err = parse_binary_patch(input).unwrap_err();
+        assert_eq!(err.kind, BinaryPatchParseErrorKind::InvalidHeader);
+    }
+
+    #[test]
+    fn parse_with_crlf_line_endings() {
+        let input = "GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
+        let (patch, consumed) = parse_binary_patch(input).unwrap();
+
+        assert_eq!(consumed, input.len());
+        match &patch {
+            BinaryPatch::Full { forward, reverse } => {
+                assert_eq!(forward.kind, BinaryBlockKind::Literal);
+                assert_eq!(forward.data.size, 10);
+                assert_eq!(reverse.kind, BinaryBlockKind::Literal);
+                assert_eq!(reverse.data.size, 0);
+            }
+            _ => panic!("expected Full variant"),
+        }
+    }
+
+    #[test]
+    fn parse_mixed_format() {
+        // Git can use different encoding for each direction
+        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\n";
+        let (patch, _) = parse_binary_patch(input).unwrap();
+
+        match &patch {
+            BinaryPatch::Full { forward, reverse } => {
+                assert_eq!(forward.kind, BinaryBlockKind::Literal);
+                assert_eq!(reverse.kind, BinaryBlockKind::Delta);
+            }
+            _ => panic!("expected Full variant"),
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 33ebbb64..5e11a40d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -223,6 +223,7 @@
 //! [`create_patch_bytes`]: fn.create_patch_bytes.html
 
 mod apply;
+pub mod binary;
 mod diff;
 mod merge;
 mod patch;

From 7c505f6a8421ff388b7e1e348d3dd29a88cb84a8 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 10:33:33 -0400
Subject: [PATCH 02/14] refactor(utils): add `Text::as_str_prefix` method

Returns the longest valid UTF-8 prefix of the input.
For `str` this is the entire input; for `[u8]` it truncates
at the first invalid byte.

This will be used at call sites where generic `T: Text` input
needs to be narrowed to `&str` for parsers that only handle
ASCII data (e.g. binary patch base85 content).
---
 src/utils.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/utils.rs b/src/utils.rs
index c4914566..e337e6cd 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -144,6 +144,11 @@ pub trait Text: Eq + Hash + ToOwned {
     fn find(&self, needle: &str) -> Option<usize>;
     fn split_at(&self, mid: usize) -> (&Self, &Self);
     fn as_str(&self) -> Option<&str>;
+    /// Returns the longest valid UTF-8 prefix.
+    ///
+    /// For `str` this is the entire input.
+    /// For `[u8]` this returns up to the first invalid UTF-8 byte.
+    fn as_str_prefix(&self) -> &str;
     fn as_bytes(&self) -> &[u8];
     #[allow(unused)]
     fn lines(&self) -> LineIter<'_, Self>;
@@ -205,6 +210,10 @@ impl Text for str {
         Some(self)
     }
 
+    fn as_str_prefix(&self) -> &str {
+        self
+    }
+
     fn as_bytes(&self) -> &[u8] {
         self.as_bytes()
     }
@@ -259,6 +268,13 @@ impl Text for [u8] {
         std::str::from_utf8(self).ok()
     }
 
+    fn as_str_prefix(&self) -> &str {
+        match std::str::from_utf8(self) {
+            Ok(s) => s,
+            Err(e) => std::str::from_utf8(&self[..e.valid_up_to()]).unwrap(),
+        }
+    }
+
     fn as_bytes(&self) -> &[u8] {
         self
     }

From 26973522fff35b7a158679ba826838f087f431ac Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 10:41:00 -0400
Subject: [PATCH 03/14] feat(patch_set): wire binary diff parsing

---
 src/patch_set/error.rs | 11 +++++++++
 src/patch_set/mod.rs   | 22 ++++++++++++-----
 src/patch_set/parse.rs | 55 ++++++++++++++++++++++++++++++++++++------
 src/patch_set/tests.rs |  7 +++---
 tests/compat/common.rs | 13 +++++++---
 tests/replay.rs        |  4 ++-
 6 files changed, 92 insertions(+), 20 deletions(-)

diff --git a/src/patch_set/error.rs b/src/patch_set/error.rs
index 3a8fc616..2c9116b6 100644
--- a/src/patch_set/error.rs
+++ b/src/patch_set/error.rs
@@ -3,6 +3,7 @@
 use std::fmt;
 use std::ops::Range;
 
+use crate::binary::BinaryPatchParseError;
 use crate::patch::ParsePatchError;
 
 /// An error returned when parsing patches fails.
@@ -76,6 +77,9 @@ pub(crate) enum PatchSetParseErrorKind {
 
     /// Invalid `diff --git` path.
     InvalidDiffGitPath,
+
+    /// Binary patch parsing failed.
+    BinaryParse(BinaryPatchParseError),
 }
 
 impl fmt::Display for PatchSetParseErrorKind {
@@ -89,6 +93,7 @@ impl fmt::Display for PatchSetParseErrorKind {
             Self::CreateMissingModifiedPath => write!(f, "create patch has no modified path"),
             Self::InvalidFileMode(mode) => write!(f, "invalid file mode: {mode}"),
             Self::InvalidDiffGitPath => write!(f, "invalid diff --git path"),
+            Self::BinaryParse(e) => write!(f, "{e}"),
         }
     }
 }
@@ -98,3 +103,9 @@ impl From<ParsePatchError> for PatchSetParseError {
         PatchSetParseErrorKind::Patch(e).into()
     }
 }
+
+impl From<BinaryPatchParseError> for PatchSetParseError {
+    fn from(e: BinaryPatchParseError) -> Self {
+        PatchSetParseErrorKind::BinaryParse(e).into()
+    }
+}
diff --git a/src/patch_set/mod.rs b/src/patch_set/mod.rs
index ed3f68e4..16ec2808 100644
--- a/src/patch_set/mod.rs
+++ b/src/patch_set/mod.rs
@@ -11,6 +11,7 @@ mod tests;
 use std::borrow::Cow;
 use std::fmt;
 
+use crate::binary::BinaryPatch;
 use crate::utils::Text;
 use crate::Patch;
 
@@ -90,7 +91,7 @@ impl ParseOptions {
     /// * `diff --git` headers
     /// * Extended headers (`new file mode`, `deleted file mode`, etc.)
     /// * Rename/copy detection (`rename from`/`rename to`, `copy from`/`copy to`)
-    /// * Binary file detection (emitted a marker by defualt)
+    /// * Binary file detection
     ///
     /// [git-diff-format]: https://git-scm.com/docs/diff-format
     pub fn gitdiff() -> Self {
@@ -133,7 +134,7 @@ pub enum PatchKind<'a, T: ToOwned + ?Sized> {
     /// Text patch with hunks.
     Text(Patch<'a, T>),
     /// Binary patch (literal or delta encoded, or marker-only).
-    Binary,
+    Binary(BinaryPatch<'a>),
 }
 
 impl<T: ?Sized, O> std::fmt::Debug for PatchKind<'_, T>
@@ -144,7 +145,7 @@ where
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             PatchKind::Text(patch) => f.debug_tuple("Text").field(patch).finish(),
-            PatchKind::Binary => f.write_str("Binary"),
+            PatchKind::Binary(patch) => f.debug_tuple("Binary").field(patch).finish(),
         }
     }
 }
@@ -154,13 +155,21 @@ impl<'a, T: ToOwned + ?Sized> PatchKind<'a, T> {
     pub fn as_text(&self) -> Option<&Patch<'a, T>> {
         match self {
             PatchKind::Text(patch) => Some(patch),
-            PatchKind::Binary => None,
+            PatchKind::Binary(_) => None,
+        }
+    }
+
+    /// Returns the binary patch, or `None` if this is a text patch.
+    pub fn as_binary(&self) -> Option<&BinaryPatch<'a>> {
+        match self {
+            PatchKind::Binary(patch) => Some(patch),
+            PatchKind::Text(_) => None,
         }
     }
 
     /// Returns `true` if this is a binary diff.
     pub fn is_binary(&self) -> bool {
-        matches!(self, PatchKind::Binary)
+        matches!(self, PatchKind::Binary(_))
     }
 }
 
@@ -209,12 +218,13 @@ impl<'a, T: ToOwned + ?Sized> FilePatch<'a, T> {
 
     fn new_binary(
         operation: FileOperation<'a, T>,
+        patch: BinaryPatch<'a>,
         old_mode: Option<FileMode>,
         new_mode: Option<FileMode>,
     ) -> Self {
         Self {
             operation,
-            kind: PatchKind::Binary,
+            kind: PatchKind::Binary(patch),
             old_mode,
             new_mode,
         }
diff --git a/src/patch_set/parse.rs b/src/patch_set/parse.rs
index 08339da8..e552e647 100644
--- a/src/patch_set/parse.rs
+++ b/src/patch_set/parse.rs
@@ -4,6 +4,7 @@ use super::{
     error::PatchSetParseErrorKind, FileMode, FileOperation, FilePatch, Format, ParseOptions,
     PatchSetParseError,
 };
+use crate::binary::{parse_binary_patch, BinaryPatch};
 use crate::patch::parse::parse_one;
 use crate::utils::{escaped_filename, Text};
 use crate::Patch;
@@ -227,8 +228,9 @@ fn next_gitdiff_patch<'a, T: Text + ?Sized>(
     let (header, header_consumed) = GitHeader::parse(remaining(ps));
     ps.offset += header_consumed;
 
-    // Handle binary markers ("Binary files ... differ") and binary patches ("GIT binary patch")
-    if header.is_binary_marker || header.is_binary_patch {
+    // Handle "Binary files ... differ" (no patch data)
+    if header.is_binary_marker {
+        // FIXME: error spans point at `diff --git` line, not the specific offending line
         let operation = match extract_file_op_binary(&header, abs_patch_start) {
             Ok(op) => op,
             Err(e) => return Some(Err(e)),
@@ -240,7 +242,45 @@ fn next_gitdiff_patch<'a, T: Text + ?Sized>(
                 return Some(Err(e));
             }
         };
-        return Some(Ok(FilePatch::new_binary(operation, old_mode, new_mode)));
+        return Some(Ok(FilePatch::new_binary(
+            operation,
+            BinaryPatch::Marker,
+            old_mode,
+            new_mode,
+        )));
+    }
+
+    // Handle "GIT binary patch" (has patch data)
+    if let Some(binary_patch_start) = header.binary_patch_offset {
+        // GitHeader::parse consumed the marker line but not the payload.
+        // Use the recorded offset to pass input from the marker onward.
+        let (_, binary_input) = ps.input.split_at(abs_patch_start + binary_patch_start);
+        // Binary patch data is always ASCII (base85-encoded).
+        let binary_input = binary_input.as_str_prefix();
+        let (binary_patch, consumed) = match parse_binary_patch(binary_input) {
+            Ok(result) => result,
+            Err(e) => return Some(Err(e.into())),
+        };
+        ps.offset = abs_patch_start + binary_patch_start + consumed;
+
+        // FIXME: error spans point at `diff --git` line, not the specific offending line
+        let operation = match extract_file_op_binary(&header, abs_patch_start) {
+            Ok(op) => op,
+            Err(e) => return Some(Err(e)),
+        };
+        let (old_mode, new_mode) = match parse_file_modes(&header) {
+            Ok(modes) => modes,
+            Err(mut e) => {
+                e.set_span(abs_patch_start..abs_patch_start);
+                return Some(Err(e));
+            }
+        };
+        return Some(Ok(FilePatch::new_binary(
+            operation,
+            binary_patch,
+            old_mode,
+            new_mode,
+        )));
     }
 
     // `git diff` output format is stricter.
@@ -328,7 +368,8 @@ struct GitHeader<'a, T: ?Sized> {
     /// Binary files /dev/null and b/image.png differ
     /// ```
     is_binary_marker: bool,
-    /// Whether this is a binary diff with actual patch content.
+    /// Byte offset of `"GIT binary patch"` line relative to header input,
+    /// or `None` if no binary patch content was found.
     ///
     /// Observed `git diff --binary` output:
     ///
@@ -343,7 +384,7 @@ struct GitHeader<'a, T: ?Sized> {
     /// literal 0
     /// KcmV+b0RR6000031
     /// ```
-    is_binary_patch: bool,
+    binary_patch_offset: Option<usize>,
 }
 
 impl<T: ?Sized> Default for GitHeader<'_, T> {
@@ -359,7 +400,7 @@ impl<T: ?Sized> Default for GitHeader<'_, T> {
             new_file_mode: None,
             deleted_file_mode: None,
             is_binary_marker: false,
-            is_binary_patch: false,
+            binary_patch_offset: None,
         }
     }
 }
@@ -410,7 +451,7 @@ impl<'a, T: Text + ?Sized> GitHeader<'a, T> {
             } else if trimmed.starts_with("Binary files ") {
                 header.is_binary_marker = true;
             } else if trimmed.starts_with("GIT binary patch") {
-                header.is_binary_patch = true;
+                header.binary_patch_offset = Some(consumed);
             } else {
                 // Unrecognized line: End of extended headers
                 // (typically `---`/`+++`/`@@` or trailing content).
diff --git a/src/patch_set/tests.rs b/src/patch_set/tests.rs
index ee7f75bb..d1ff8804 100644
--- a/src/patch_set/tests.rs
+++ b/src/patch_set/tests.rs
@@ -752,7 +752,8 @@ index 0000000..e69de29
     }
 
     #[test]
-    fn binary_emits_marker() {
+    fn binary_marker_kept_by_default() {
+        // Default is Keep: binary marker is returned as BinaryPatch::Marker.
         let input = "\
 diff --git a/img.png b/img.png
 Binary files a/img.png and b/img.png differ
@@ -765,9 +766,9 @@ diff --git a/foo b/foo
 ";
         let patches = parse_gitdiff(input);
         assert_eq!(patches.len(), 2);
-        assert!(patches[0].patch().is_binary());
+        assert!(patches[0].patch().as_binary().is_some());
         assert!(patches[0].operation().is_modify());
-        assert!(!patches[1].patch().is_binary());
+        assert!(patches[1].patch().as_text().is_some());
     }
 }
 
diff --git a/tests/compat/common.rs b/tests/compat/common.rs
index 1c8c8c2e..6e871b08 100644
--- a/tests/compat/common.rs
+++ b/tests/compat/common.rs
@@ -8,7 +8,10 @@ use std::{
     sync::Once,
 };
 
-use diffy::patch_set::{FileOperation, ParseOptions, PatchKind, PatchSet, PatchSetParseError};
+use diffy::{
+    binary::BinaryPatch,
+    patch_set::{FileOperation, ParseOptions, PatchKind, PatchSet, PatchSetParseError},
+};
 
 /// Which external tool to compare against.
 #[derive(Clone, Copy)]
@@ -411,8 +414,12 @@ pub fn apply_diffy(
                 }
                 fs::write(&result_path, &result).unwrap();
             }
-            PatchKind::Binary => {
-                // No patch data to apply — nothing to do.
+            PatchKind::Binary(BinaryPatch::Marker) => {
+                // Dont do anything if it is just a binary patch marker.
+            }
+            PatchKind::Binary(_) => {
+                // Binary patch application requires the `binary` feature.
+                // Will be wired up when that feature is added.
             }
         }
     }
diff --git a/tests/replay.rs b/tests/replay.rs
index c98eef12..e6fbab3e 100644
--- a/tests/replay.rs
+++ b/tests/replay.rs
@@ -544,7 +544,9 @@ fn process_commit(
                     );
                 }
             }
-            PatchKind::Binary => {
+            PatchKind::Binary(_) => {
+                // Binary patch application not yet wired up in replay tests.
+                // Will be done once the `binary` Cargo feature is added.
                 skipped += 1;
                 continue;
             }

From 1c6a9e26ec5658a8f88aeb766ae60cd1fb78fe59 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 10:43:30 -0400
Subject: [PATCH 04/14] refactor: clippy manual_div_ceil

The API was stabilized in 1.73.
The lint was added in 1.93.

This is required for a MSRV bump to 1.75
---
 src/diff/myers.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/diff/myers.rs b/src/diff/myers.rs
index 73eb4106..502d0772 100644
--- a/src/diff/myers.rs
+++ b/src/diff/myers.rs
@@ -69,7 +69,7 @@ impl ::std::fmt::Display for Snake {
 
 fn max_d(len1: usize, len2: usize) -> usize {
     // XXX look into reducing the need to have the additional '+ 1'
-    (len1 + len2 + 1) / 2 + 1
+    (len1 + len2).div_ceil(2) + 1
 }
 
 // The divide part of a divide-and-conquer strategy. A D-path has D+1 snakes some of which may

From ff60fe77d8a69b0061be46c5b6a82ff4858934bb Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 10:43:59 -0400
Subject: [PATCH 05/14] chore: dependency flate2 behind binary feature

This is a preparation for binary diff application support.

* Git binary patch is compressed by zlib hence flate2
* zlib-rs (which is the most performant zlib backend)
  requires MSRV 1.75.0+ hence the bump.
---
 .github/workflows/ci.yml |  2 +-
 Cargo.lock               | 39 +++++++++++++++++++++++++++++++++++++++
 Cargo.toml               |  4 +++-
 deny.toml                |  1 +
 4 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2f514b37..d0ca9b80 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: [stable, beta, nightly, 1.70.0]
+        rust: [stable, beta, nightly, 1.75.0]
 
     steps:
       - uses: actions/checkout@v6
diff --git a/Cargo.lock b/Cargo.lock
index ad290e3b..c726b1cd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
 [[package]]
 name = "anstream"
 version = "0.6.21"
@@ -109,6 +115,7 @@ name = "diffy"
 version = "0.4.2"
 dependencies = [
  "anstyle",
+ "flate2",
  "rayon",
  "snapbox",
 ]
@@ -152,6 +159,16 @@ dependencies = [
  "libredox",
 ]
 
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "miniz_oxide",
+ "zlib-rs",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.3.4"
@@ -200,6 +217,16 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
 [[package]]
 name = "normalize-line-endings"
 version = "0.3.0"
@@ -281,6 +308,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "similar"
 version = "2.7.0"
@@ -446,3 +479,9 @@ name = "wit-bindgen"
 version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
diff --git a/Cargo.toml b/Cargo.toml
index 25c6e518..68ce3ff3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,14 +9,16 @@ repository = "https://github.com/bmwill/diffy"
 readme = "README.md"
 keywords = ["diff", "patch", "merge"]
 categories = ["text-processing"]
-rust-version = "1.70.0"
+rust-version = "1.75.0"
 edition = "2021"
 
 [features]
+binary = ["dep:flate2"]
 color = ["dep:anstyle"]
 
 [dependencies]
 anstyle = { version = "1.0.13", optional = true }
+flate2 = { version = "1.1.9", optional = true, default-features = false, features = ["zlib-rs"] }
 
 [dev-dependencies]
 rayon = "1.10.0"
diff --git a/deny.toml b/deny.toml
index d495b7c5..740f35a3 100644
--- a/deny.toml
+++ b/deny.toml
@@ -91,6 +91,7 @@ ignore = [
 allow = [
     "MIT",
     "Apache-2.0",
+    "Zlib",
     #"Apache-2.0 WITH LLVM-exception",
 ]
 # The confidence threshold for detecting a license from license text.

From d2b9720dd01251f6675141e13577f364951ad3dc Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 17 Apr 2026 10:50:14 -0400
Subject: [PATCH 06/14] feat(binary): base85/delta decode and patch application

* Add base85 encoder/decoder and Git delta format decoder.
* Wire them into `BinaryPatch::apply() and `apply_reverse()`
  for decoding zlib-compressed, base85-encoded binary payload.

These are feature-gated behind the `binary` feature.
---
 src/binary/base85.rs | 229 +++++++++++++++++++++++++++
 src/binary/delta.rs  | 362 +++++++++++++++++++++++++++++++++++++++++++
 src/binary/mod.rs    | 210 +++++++++++++++++++++++++
 3 files changed, 801 insertions(+)
 create mode 100644 src/binary/base85.rs
 create mode 100644 src/binary/delta.rs

diff --git a/src/binary/base85.rs b/src/binary/base85.rs
new file mode 100644
index 00000000..182efe87
--- /dev/null
+++ b/src/binary/base85.rs
@@ -0,0 +1,229 @@
+//! Base85 encoding and decoding using the character set defined in [RFC 1924].
+//!
+//! ## References
+//!
+//! * [RFC 1924]
+//! * [Wikipedia: Ascii85 § RFC 1924 version](https://en.wikipedia.org/wiki/Ascii85#RFC_1924_version)
+//!
+//! [RFC 1924]: https://datatracker.ietf.org/doc/html/rfc1924
+
+use std::fmt;
+
+/// Base85 character set (RFC 1924).
+const ALPHABET: &[u8; 85] = b"0123456789\
+    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+    !#$%&()*+-;<=>?@^_`{|}~";
+
+/// Pre-computed lookup table for Base85 decoding.
+///
+/// Maps ASCII byte value → digit value or `0xFF` for invalid characters.
+/// This provides O(1) lookup.
+const TABLE: [u8; 256] = {
+    let mut table = [0xFFu8; 256];
+    let mut i = 0usize;
+    while i < 85 {
+        table[ALPHABET[i] as usize] = i as u8;
+        i += 1;
+    }
+    table
+};
+
+/// Error type for Base85 operations.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Base85Error {
+    /// Invalid character that is not in RFC 1924 alphabet.
+    InvalidCharacter(char),
+    /// Invalid input length for the operation.
+    InvalidLength,
+}
+
+impl fmt::Display for Base85Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Base85Error::InvalidCharacter(c) => write!(f, "invalid base85 character: {:?}", c),
+            Base85Error::InvalidLength => write!(f, "invalid input length"),
+        }
+    }
+}
+
+impl std::error::Error for Base85Error {}
+
+/// Decodes a Base85 string to the provided output.
+///
+/// ## Limitations
+///
+/// The input length must be a multiple of 5.
+///
+/// This function does not handle padding for partial chunks.
+/// When decoding data where the original byte count isn't a multiple of 4,
+/// callers must handle truncation at a higher level.
+/// For example, via a length indicator in Git binary patch.
+pub fn decode_into(input: &str, output: &mut impl Extend<u8>) -> Result<(), Base85Error> {
+    let bytes = input.as_bytes();
+
+    if bytes.len() % 5 != 0 {
+        return Err(Base85Error::InvalidLength);
+    }
+
+    // TODO: Use `as_chunks::<5>()` when MSRV >= 1.88
+    for chunk in bytes.chunks_exact(5) {
+        let mut value: u32 = 0;
+        for &byte in chunk {
+            let digit = TABLE[byte as usize];
+            if digit == 0xFF {
+                return Err(Base85Error::InvalidCharacter(byte as char));
+            }
+            value = value * 85 + digit as u32;
+        }
+
+        output.extend(value.to_be_bytes());
+    }
+
+    Ok(())
+}
+
+/// Encodes bytes in Base85 to the provided output.
+///
+/// ## Limitations
+///
+/// The input length must be a multiple of 4.
+///
+/// This function does not handle padding for partial chunks.
+/// Callers encoding data where the byte count isn't a multiple of 4
+/// must handle padding at a higher level.
+/// For example, via a length indicator in Git binary patch format.
+#[allow(dead_code)] // will be used for patch formatting
+pub fn encode_into(input: &[u8], output: &mut impl Extend<char>) -> Result<(), Base85Error> {
+    if input.len() % 4 != 0 {
+        return Err(Base85Error::InvalidLength);
+    }
+
+    // TODO: Use `as_chunks::<4>()` when MSRV >= 1.88
+    for chunk in input.chunks_exact(4) {
+        let mut value = u32::from_be_bytes(chunk.try_into().unwrap());
+
+        // Extract 5 base85 digits (least to most significant order)
+        let mut digits = [0u8; 5];
+        for digit in digits.iter_mut().rev() {
+            *digit = ALPHABET[(value % 85) as usize];
+            value /= 85;
+        }
+        output.extend(digits.iter().map(|&b| b as char));
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn decode(input: &str) -> Result<Vec<u8>, Base85Error> {
+        let mut result = Vec::with_capacity((input.len() / 5) * 4);
+        decode_into(input, &mut result)?;
+        Ok(result)
+    }
+
+    fn encode(input: &[u8]) -> Result<String, Base85Error> {
+        let mut result = String::with_capacity((input.len() / 4) * 5);
+        encode_into(input, &mut result)?;
+        Ok(result)
+    }
+
+    const TEST_VECTORS: &[(&[u8], &str)] = &[
+        (b"", ""),
+        (&[0x00, 0x00, 0x00, 0x00], "00000"),
+        (&[0xff, 0xff, 0xff, 0xff], "|NsC0"),
+        // Rust ecosystem phrases
+        (b"Rust", "Qgw55"),
+        (b"Fearless concurrency", "MrC1gY-MwEAY*TCV|8+JWo~16"),
+        (b"memory safe!", "ZDnn5a(N(gVP<6^"),
+        (b"blazing fast", "Vr*f0X>MmAW?^%5"),
+        (
+            b"zero-cost abstraction!??",
+            "dS!BNEn{zUbRc13b98cHV{~b6ZXrKE",
+        ),
+    ];
+
+    #[test]
+    fn table_covers_all_alphabet_chars() {
+        for (i, &c) in ALPHABET.iter().enumerate() {
+            assert_eq!(
+                TABLE[c as usize], i as u8,
+                "mismatch for char '{}' at index {}",
+                c as char, i
+            );
+        }
+    }
+
+    #[test]
+    fn table_rejects_invalid_chars() {
+        let invalid_chars = b" \t\n\r\"'\\[],:";
+        for &c in invalid_chars {
+            assert_eq!(
+                TABLE[c as usize], 0xFF,
+                "char '{}' should be invalid",
+                c as char
+            );
+        }
+    }
+
+    #[test]
+    fn decode_test_vectors() {
+        for (bytes, encoded) in TEST_VECTORS {
+            let result = decode(encoded).unwrap();
+            assert_eq!(&result, *bytes, "decode({:?}) failed", encoded);
+        }
+    }
+
+    #[test]
+    fn encode_test_vectors() {
+        for (bytes, encoded) in TEST_VECTORS {
+            let result = encode(bytes).unwrap();
+            assert_eq!(result, *encoded, "encode({:?}) failed", bytes);
+        }
+    }
+
+    #[test]
+    fn decode_invalid_length() {
+        assert!(matches!(decode("0000"), Err(Base85Error::InvalidLength)));
+        assert!(matches!(decode("000"), Err(Base85Error::InvalidLength)));
+        assert!(matches!(decode("00"), Err(Base85Error::InvalidLength)));
+        assert!(matches!(decode("0"), Err(Base85Error::InvalidLength)));
+    }
+
+    #[test]
+    fn decode_invalid_character() {
+        assert!(matches!(
+            decode("0000 "),
+            Err(Base85Error::InvalidCharacter(' '))
+        ));
+        assert!(matches!(
+            decode("0000\""),
+            Err(Base85Error::InvalidCharacter('"'))
+        ));
+    }
+
+    #[test]
+    fn encode_invalid_length() {
+        assert!(matches!(encode(&[0]), Err(Base85Error::InvalidLength)));
+        assert!(matches!(encode(&[0, 0]), Err(Base85Error::InvalidLength)));
+        assert!(matches!(
+            encode(&[0, 0, 0]),
+            Err(Base85Error::InvalidLength)
+        ));
+        assert!(matches!(
+            encode(&[0, 0, 0, 0, 0]),
+            Err(Base85Error::InvalidLength)
+        ));
+    }
+
+    #[test]
+    fn round_trip() {
+        for (bytes, _) in TEST_VECTORS {
+            let encoded = encode(bytes).unwrap();
+            let decoded = decode(&encoded).unwrap();
+            assert_eq!(&decoded, *bytes, "round-trip failed for {:?}", bytes);
+        }
+    }
+}
diff --git a/src/binary/delta.rs b/src/binary/delta.rs
new file mode 100644
index 00000000..fa1de268
--- /dev/null
+++ b/src/binary/delta.rs
@@ -0,0 +1,362 @@
+//! Git delta binary diff support.
+//!
+//! A delta payload contains:
+//!
+//! 1. Header: variable-length encoded sizes (original_size, modified_size)
+//! 2. Instructions: sequence of `ADD` and `COPY` operations
+//!
+//! Based on Diffx's [Git Delta Binary Diffs](https://diffx.org/spec/binary-diffs.html#git-delta-binary-diffs)
+
+use std::fmt;
+
+/// Applies delta instructions to an original file, producing the modified file.
+pub fn apply(original: &[u8], delta: &[u8]) -> Result<Vec<u8>, DeltaError> {
+    let mut cursor = DeltaCursor::new(delta);
+
+    let header_orig_size = cursor.read_size()?;
+    let header_mod_size = cursor.read_size()?;
+
+    // Validate original size
+    if original.len() as u64 != header_orig_size {
+        return Err(DeltaError::OriginalSizeMismatch {
+            expected: header_orig_size,
+            actual: original.len() as u64,
+        });
+    }
+
+    let mut result = Vec::with_capacity(header_mod_size as usize);
+
+    // Process instructions until we've consumed all delta data
+    while !cursor.is_empty() {
+        let control = cursor.read_byte()?;
+
+        if control & 0x80 != 0 {
+            // COPY instruction
+            let (src_offset, copy_len) = cursor.read_copy_params(control)?;
+            let src_end = src_offset
+                .checked_add(copy_len)
+                .ok_or(DeltaError::InvalidCopyRange)?;
+
+            if src_end > original.len() {
+                return Err(DeltaError::CopyOutOfBounds {
+                    offset: src_offset,
+                    length: copy_len,
+                    original_size: original.len(),
+                });
+            }
+
+            result.extend_from_slice(&original[src_offset..src_end]);
+        } else {
+            // ADD instruction
+            let add_len = control as usize;
+            let data = cursor.read_bytes(add_len)?;
+            result.extend_from_slice(data);
+        }
+    }
+
+    // Validate result size
+    if result.len() as u64 != header_mod_size {
+        return Err(DeltaError::ModifiedSizeMismatch {
+            expected: header_mod_size,
+            actual: result.len() as u64,
+        });
+    }
+
+    Ok(result)
+}
+
+/// Cursor for reading delta instructions.
+struct DeltaCursor<'a> {
+    data: &'a [u8],
+    offset: usize,
+}
+
+impl<'a> DeltaCursor<'a> {
+    fn new(data: &'a [u8]) -> Self {
+        Self { data, offset: 0 }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.offset >= self.data.len()
+    }
+
+    fn read_byte(&mut self) -> Result<u8, DeltaError> {
+        if self.offset >= self.data.len() {
+            return Err(DeltaError::UnexpectedEof);
+        }
+        let byte = self.data[self.offset];
+        self.offset += 1;
+        Ok(byte)
+    }
+
+    fn read_bytes(&mut self, len: usize) -> Result<&'a [u8], DeltaError> {
+        let end = self
+            .offset
+            .checked_add(len)
+            .ok_or(DeltaError::UnexpectedEof)?;
+        if end > self.data.len() {
+            return Err(DeltaError::UnexpectedEof);
+        }
+        let bytes = &self.data[self.offset..end];
+        self.offset = end;
+        Ok(bytes)
+    }
+
+    /// Reads a variable-length encoded size from the header.
+    ///
+    /// Format: each byte uses 7 bits for value, MSB indicates continuation.
+    /// Bytes are in little-endian order (LSB first).
+    fn read_size(&mut self) -> Result<u64, DeltaError> {
+        let mut file_len: u64 = 0;
+        let mut shift: u32 = 0;
+
+        loop {
+            let byte = self.read_byte()?;
+
+            // Add 7 bits of value at current shift position
+            let value = (byte & 0x7F) as u64;
+            file_len |= value.checked_shl(shift).ok_or(DeltaError::SizeOverflow)?;
+
+            // MSB clear means this is the last byte
+            if byte & 0x80 == 0 {
+                break;
+            }
+
+            shift += 7;
+        }
+
+        Ok(file_len)
+    }
+
+    /// Reads `COPY` instruction parameters from the control byte.
+    /// Returns `(src_offset, copy_len)`.
+    ///
+    /// Control byte format is `1oooosss`:
+    ///
+    /// * Bits 0-3: src_offset bytes
+    /// * Bits 4-6: copy_len bytes
+    fn read_copy_params(&mut self, control: u8) -> Result<(usize, usize), DeltaError> {
+        let mut src_offset: u32 = 0;
+        for (mask, shift) in [(0x01, 0), (0x02, 8), (0x04, 16), (0x08, 24)] {
+            if control & mask != 0 {
+                let byte = self.read_byte()? as u32;
+                src_offset |= byte.checked_shl(shift).ok_or(DeltaError::SizeOverflow)?;
+            }
+        }
+
+        let mut copy_len: u32 = 0;
+        for (mask, shift) in [(0x10, 0), (0x20, 8), (0x40, 16)] {
+            if control & mask != 0 {
+                let byte = self.read_byte()? as u32;
+                copy_len |= byte.checked_shl(shift).ok_or(DeltaError::SizeOverflow)?;
+            }
+        }
+
+        if copy_len == 0 {
+            // Size of 0 means 65536
+            copy_len = 0x10000;
+        }
+
+        Ok((src_offset as usize, copy_len as usize))
+    }
+}
+
+/// Error type for delta operations.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DeltaError {
+    /// Unexpected end of delta data.
+    UnexpectedEof,
+    /// Size value overflowed during decoding.
+    SizeOverflow,
+    /// Original file size doesn't match header.
+    OriginalSizeMismatch { expected: u64, actual: u64 },
+    /// Modified file size doesn't match header.
+    ModifiedSizeMismatch { expected: u64, actual: u64 },
+    /// COPY instruction references out-of-bounds data.
+    CopyOutOfBounds {
+        offset: usize,
+        length: usize,
+        original_size: usize,
+    },
+    /// COPY range calculation overflowed.
+    InvalidCopyRange,
+}
+
+impl fmt::Display for DeltaError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DeltaError::UnexpectedEof => write!(f, "unexpected end of delta data"),
+            DeltaError::SizeOverflow => write!(f, "size value overflow"),
+            DeltaError::OriginalSizeMismatch { expected, actual } => {
+                write!(
+                    f,
+                    "original size mismatch: expected {expected}, got {actual}"
+                )
+            }
+            DeltaError::ModifiedSizeMismatch { expected, actual } => {
+                write!(
+                    f,
+                    "modified size mismatch: expected {expected}, got {actual}"
+                )
+            }
+            DeltaError::CopyOutOfBounds {
+                offset,
+                length,
+                original_size,
+            } => {
+                write!(
+                    f,
+                    "copy out of bounds: offset={offset}, length={length}, original_size={original_size}"
+                )
+            }
+            DeltaError::InvalidCopyRange => write!(f, "copy range calculation overflow"),
+        }
+    }
+}
+
+impl std::error::Error for DeltaError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn read_size_single_byte() {
+        // 0x0A = 10, MSB clear = end
+        let data = [0x0A];
+        let mut cursor = DeltaCursor::new(&data);
+        assert_eq!(cursor.read_size().unwrap(), 10);
+    }
+
+    #[test]
+    fn read_size_multi_byte() {
+        // 0x80 | 0x01 = 1, continue; 0x02 = 2 << 7 = 256; total = 257
+        let data = [0x81, 0x02];
+        let mut cursor = DeltaCursor::new(&data);
+        assert_eq!(cursor.read_size().unwrap(), 1 + (2 << 7));
+    }
+
+    #[test]
+    fn apply_add_only() {
+        // Header: orig_size=0, mod_size=5
+        // ADD 5 bytes: "hello"
+        let delta = [
+            0x00, // orig_size = 0
+            0x05, // mod_size = 5
+            0x05, // ADD 5 bytes
+            b'h', b'e', b'l', b'l', b'o',
+        ];
+        let result = apply(&[], &delta).unwrap();
+        assert_eq!(result, b"hello");
+    }
+
+    #[test]
+    fn apply_copy_only() {
+        // Header: orig_size=5, mod_size=5
+        // COPY offset=0, len=5
+        let delta = [
+            0x05, // orig_size = 5
+            0x05, // mod_size = 5
+            0x90, // COPY: control=0x90 (0x80 | 0x10), offset=0, size byte present
+            0x05, // size = 5
+        ];
+        let original = b"hello";
+        let result = apply(original, &delta).unwrap();
+        assert_eq!(result, b"hello");
+    }
+
+    #[test]
+    fn apply_copy_with_offset() {
+        // Header: orig_size=10, mod_size=5
+        // COPY offset=5, len=5
+        let delta = [
+            0x0A, // orig_size = 10
+            0x05, // mod_size = 5
+            0x91, // COPY: 0x80 | 0x10 | 0x01 (offset1 + size1 present)
+            0x05, // offset = 5
+            0x05, // size = 5
+        ];
+        let original = b"helloworld";
+        let result = apply(original, &delta).unwrap();
+        assert_eq!(result, b"world");
+    }
+
+    #[test]
+    fn apply_mixed_instructions() {
+        // Create "HELLO world" from "hello world"
+        // Header: orig_size=11, mod_size=11
+        // ADD 5: "HELLO"
+        // COPY offset=5, len=6: " world"
+        let delta = [
+            0x0B, // orig_size = 11
+            0x0B, // mod_size = 11
+            0x05, // ADD 5 bytes
+            b'H', b'E', b'L', b'L', b'O', // "HELLO"
+            0x91, // COPY: offset1 + size1 present
+            0x05, // offset = 5
+            0x06, // size = 6
+        ];
+        let original = b"hello world";
+        let result = apply(original, &delta).unwrap();
+        assert_eq!(result, b"HELLO world");
+    }
+
+    #[test]
+    fn apply_copy_size_zero_means_65536() {
+        // When size bytes result in 0, it means 65536
+        // Header: orig_size=65536, mod_size=65536
+        // COPY offset=0, len=65536 (encoded as 0)
+        let original = vec![0xAB; 65536];
+        let delta = [
+            0x80, 0x80, 0x04, // orig_size = 65536 (varint)
+            0x80, 0x80, 0x04, // mod_size = 65536 (varint)
+            0x80, // COPY: no offset bytes, no size bytes = offset 0, size 65536
+        ];
+        let result = apply(&original, &delta).unwrap();
+        assert_eq!(result.len(), 65536);
+        assert_eq!(result, original);
+    }
+
+    #[test]
+    fn error_original_size_mismatch() {
+        let delta = [
+            0x0A, // orig_size = 10
+            0x05, // mod_size = 5
+        ];
+        let original = b"short"; // only 5 bytes
+        let err = apply(original, &delta).unwrap_err();
+        assert!(matches!(
+            err,
+            DeltaError::OriginalSizeMismatch {
+                expected: 10,
+                actual: 5
+            }
+        ));
+    }
+
+    #[test]
+    fn error_copy_out_of_bounds() {
+        let delta = [
+            0x05, // orig_size = 5
+            0x05, // mod_size = 5
+            0x91, // COPY
+            0x0A, // offset = 10 (out of bounds!)
+            0x05, // size = 5
+        ];
+        let original = b"hello";
+        let err = apply(original, &delta).unwrap_err();
+        assert!(matches!(err, DeltaError::CopyOutOfBounds { .. }));
+    }
+
+    #[test]
+    fn error_unexpected_eof_in_add() {
+        let delta = [
+            0x00, // orig_size = 0
+            0x05, // mod_size = 5
+            0x05, // ADD 5 bytes
+            b'h', b'i', // only 2 bytes provided
+        ];
+        let err = apply(&[], &delta).unwrap_err();
+        assert_eq!(err, DeltaError::UnexpectedEof);
+    }
+}
diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index 7f2db8fc..b5cf1e48 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -5,6 +5,11 @@
 //!
 //! Based on [DiffX Binary Diffs specification](https://diffx.org/spec/binary-diffs.html).
 
+#[cfg(feature = "binary")]
+mod base85;
+#[cfg(feature = "binary")]
+mod delta;
+
 use std::{fmt, ops::Range};
 
 /// The type of a binary patch block.
@@ -54,9 +59,69 @@ pub enum BinaryPatch<'a> {
     ///
     /// This represents the `Binary files a/path and b/path differ` case,
     /// where git detected a binary change but didn't include the actual data.
+    ///
+    /// Calling [`apply()`](Self::apply) on this variant returns an error.
     Marker,
 }
 
+impl<'a> BinaryPatch<'a> {
+    /// Applies a binary patch forward: original -> modified.
+    ///
+    /// - If the forward block is `Literal`: returns the decoded content directly.
+    /// - If the forward block is `Delta`: applies delta instructions to `original`.
+    ///
+    /// Unlike `git apply`, this doesn't validate the original content hash.
+    #[cfg(feature = "binary")]
+    pub fn apply(&self, original: &[u8]) -> Result<Vec<u8>, BinaryPatchParseError> {
+        match self {
+            BinaryPatch::Full { forward, .. } => Self::apply_block(forward, original),
+            BinaryPatch::Marker => Err(BinaryPatchParseErrorKind::NoBinaryData.into()),
+        }
+    }
+
+    /// Applies a binary patch in reverse: modified -> original.
+    ///
+    /// - If the reverse block is `Literal`: returns the decoded content directly.
+    /// - If the reverse block is `Delta`: applies delta instructions to `modified`.
+    ///
+    /// Unlike `git apply`, this doesn't validate the modified content hash.
+    #[cfg(feature = "binary")]
+    pub fn apply_reverse(&self, modified: &[u8]) -> Result<Vec<u8>, BinaryPatchParseError> {
+        match self {
+            BinaryPatch::Full { reverse, .. } => Self::apply_block(reverse, modified),
+            BinaryPatch::Marker => Err(BinaryPatchParseErrorKind::NoBinaryData.into()),
+        }
+    }
+
+    /// Applies a single block (either literal or delta).
+    #[cfg(feature = "binary")]
+    fn apply_block(block: &BinaryBlock<'_>, base: &[u8]) -> Result<Vec<u8>, BinaryPatchParseError> {
+        match block.kind {
+            BinaryBlockKind::Literal => Self::decode_data(&block.data),
+            BinaryBlockKind::Delta => {
+                let delta_instructions = Self::decode_data(&block.data)?;
+                delta::apply(base, &delta_instructions).map_err(BinaryPatchParseError::from)
+            }
+        }
+    }
+
+    /// See [Decoding Logic](https://diffx.org/spec/binary-diffs.html#decoding-logic)
+    #[cfg(feature = "binary")]
+    fn decode_data(binary_data: &BinaryData<'_>) -> Result<Vec<u8>, BinaryPatchParseError> {
+        use std::io::Read;
+
+        let compressed = decode_base85_lines(binary_data.data)?;
+
+        let mut decoder = flate2::read::ZlibDecoder::new(&compressed[..]);
+        let mut decompressed = Vec::new();
+        decoder
+            .read_to_end(&mut decompressed)
+            .map_err(|e| BinaryPatchParseErrorKind::DecompressionFailed(e.to_string()))?;
+
+        Ok(decompressed)
+    }
+}
+
 /// Represents a single binary payload in a Git binary diff.
 ///
 /// For example, the following patch block
@@ -115,6 +180,20 @@ impl fmt::Display for BinaryPatchParseError {
 
 impl std::error::Error for BinaryPatchParseError {}
 
+#[cfg(feature = "binary")]
+impl From<base85::Base85Error> for BinaryPatchParseError {
+    fn from(e: base85::Base85Error) -> Self {
+        BinaryPatchParseErrorKind::Base85(e).into()
+    }
+}
+
+#[cfg(feature = "binary")]
+impl From<delta::DeltaError> for BinaryPatchParseError {
+    fn from(e: delta::DeltaError) -> Self {
+        BinaryPatchParseErrorKind::Delta(e).into()
+    }
+}
+
 impl From<BinaryPatchParseErrorKind> for BinaryPatchParseError {
     fn from(kind: BinaryPatchParseErrorKind) -> Self {
         Self { kind, span: None }
@@ -126,6 +205,8 @@ impl From<BinaryPatchParseErrorKind> for BinaryPatchParseError {
 #[non_exhaustive]
 pub(crate) enum BinaryPatchParseErrorKind {
     /// Missing or invalid "GIT binary patch" header.
+    // TODO: Switch to #[expect(dead_code)] when MSRV >= 1.81
+    #[cfg_attr(not(feature = "binary"), allow(dead_code))]
     InvalidHeader,
 
     /// First binary block (forward) not found.
@@ -135,10 +216,26 @@ pub(crate) enum BinaryPatchParseErrorKind {
     MissingReverseBlock,
 
     /// No binary data available (marker-only patch).
+    // TODO: Switch to #[expect(dead_code)] when MSRV >= 1.81
+    #[cfg_attr(not(feature = "binary"), allow(dead_code))]
     NoBinaryData,
 
     /// Invalid line length indicator in Base85 data.
+    // TODO: Switch to #[expect(dead_code)] when MSRV >= 1.81
+    #[cfg_attr(not(feature = "binary"), allow(dead_code))]
     InvalidLineLengthIndicator,
+
+    /// Base85 decoding failed.
+    #[cfg(feature = "binary")]
+    Base85(base85::Base85Error),
+
+    /// Delta application failed.
+    #[cfg(feature = "binary")]
+    Delta(delta::DeltaError),
+
+    /// Zlib decompression failed.
+    #[cfg(feature = "binary")]
+    DecompressionFailed(String),
 }
 
 impl fmt::Display for BinaryPatchParseErrorKind {
@@ -149,6 +246,12 @@ impl fmt::Display for BinaryPatchParseErrorKind {
             Self::MissingReverseBlock => write!(f, "second binary block not found"),
             Self::NoBinaryData => write!(f, "no binary data available"),
             Self::InvalidLineLengthIndicator => write!(f, "invalid line length indicator"),
+            #[cfg(feature = "binary")]
+            Self::Base85(e) => write!(f, "{e}"),
+            #[cfg(feature = "binary")]
+            Self::Delta(e) => write!(f, "{e}"),
+            #[cfg(feature = "binary")]
+            Self::DecompressionFailed(msg) => write!(f, "decompression failed: {msg}"),
         }
     }
 }
@@ -259,6 +362,62 @@ fn parse_binary_block<'a>(parser: &mut BinaryParser<'a>) -> Option<BinaryBlock<'
     })
 }
 
+/// Decodes multi-line Base85 data with length indicators.
+///
+/// Each line has the format: `<len_c><data>`
+///
+/// From [5.1.1. Binary Payloads](https://diffx.org/spec/binary-diffs.html#binary-payloads):
+///
+/// > Each line represents up to 52 bytes of pre-encoded data.
+/// > There may be an unlimited number of lines.
+/// > They contain the following fields:
+/// >
+/// >  * `len_c` is a line length character.
+/// >     This encodes the length of the (pre-encoded) data written on this line.
+/// >  * `data` is Base85-encoded data for this line.
+#[cfg(feature = "binary")]
+fn decode_base85_lines(data: &str) -> Result<Vec<u8>, BinaryPatchParseError> {
+    // A rough estimate: In Base85, 5 chars -> 4 bytes
+    let mut result = Vec::with_capacity(data.len() * 4 / 5);
+
+    for line in data.lines() {
+        if line.is_empty() {
+            continue;
+        }
+
+        let line_bytes = line.as_bytes();
+
+        let length = decode_line_length(line_bytes[0])
+            .ok_or(BinaryPatchParseErrorKind::InvalidLineLengthIndicator)?;
+        let encoded = &line[1..];
+        let start = result.len();
+        base85::decode_into(encoded, &mut result)?;
+        result.truncate(start + length);
+    }
+
+    Ok(result)
+}
+
+/// Decodes a line length character to its numeric value.
+///
+/// From [Line Length Characters](https://diffx.org/spec/binary-diffs.html#line-length-characters):
+///
+/// > Each encoded line in a binary diff payload is prefixed by a line length character.
+/// > This encodes the length of the compressed (but not encoded) data for the line.
+/// >
+/// > Line length characters always represent a value between 1 and 52:
+/// >
+/// > * A value of A-Z represents a number between 1..26.
+/// > * A value of a-z represents a number between 27..52.
+#[cfg(feature = "binary")]
+fn decode_line_length(c: u8) -> Option<usize> {
+    match c {
+        b'A'..=b'Z' => Some((c - b'A' + 1) as usize),
+        b'a'..=b'z' => Some((c - b'a' + 27) as usize),
+        _ => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -336,3 +495,54 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+#[cfg(feature = "binary")]
+mod apply_tests {
+    use super::*;
+
+    #[test]
+    fn decode_line_length_uppercase() {
+        assert_eq!(decode_line_length(b'A'), Some(1));
+        assert_eq!(decode_line_length(b'B'), Some(2));
+        assert_eq!(decode_line_length(b'Z'), Some(26));
+    }
+
+    #[test]
+    fn decode_line_length_lowercase() {
+        assert_eq!(decode_line_length(b'a'), Some(27));
+        assert_eq!(decode_line_length(b'b'), Some(28));
+        assert_eq!(decode_line_length(b'z'), Some(52));
+    }
+
+    #[test]
+    fn decode_line_length_invalid() {
+        assert_eq!(decode_line_length(b'0'), None);
+        assert_eq!(decode_line_length(b'!'), None);
+        assert_eq!(decode_line_length(b' '), None);
+    }
+
+    #[test]
+    fn apply_literal_patch() {
+        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let (patch, _) = parse_binary_patch(input).unwrap();
+
+        let modified = patch.apply(&[]).unwrap();
+        assert_eq!(modified.len(), 10);
+        assert_eq!(modified, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+        let original = patch.apply_reverse(&[]).unwrap();
+        assert_eq!(original.len(), 0);
+    }
+
+    #[test]
+    fn apply_with_crlf_line_endings() {
+        let input = "GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
+        let (patch, _) = parse_binary_patch(input).unwrap();
+
+        let modified = patch.apply(&[]).unwrap();
+        assert_eq!(modified, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        let original = patch.apply_reverse(&[]).unwrap();
+        assert_eq!(original.len(), 0);
+    }
+}

From d43d756e0d2bf28c9b9095e1d0f19ec5aa801f7f Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:23:02 -0400
Subject: [PATCH 07/14] test(compat): binary patch tests

Now compat tests require `binary` Cargo feature.
---
 .github/workflows/ci.yml                      |   1 +
 Cargo.toml                                    |   4 +
 tests/compat/common.rs                        |  45 +++++----
 .../git/binary_and_text_mixed/in/foo.patch    |  16 ++++
 .../git/binary_and_text_mixed/in/image.png    |   2 +
 .../git/binary_and_text_mixed/in/text.txt     |   1 +
 .../git/binary_and_text_mixed/out/image.png   | Bin 0 -> 10 bytes
 .../git/binary_and_text_mixed/out/text.txt    |   1 +
 tests/compat/git/binary_delta/in/foo.patch    |   9 ++
 tests/compat/git/binary_delta/in/large.bin    | Bin 0 -> 5120 bytes
 tests/compat/git/binary_delta/out/large.bin   | Bin 0 -> 5120 bytes
 .../binary_delta_wrong_original/in/foo.patch  |   9 ++
 .../binary_delta_wrong_original/in/large.bin  |   1 +
 tests/compat/git/binary_literal/in/foo.patch  |  10 ++
 tests/compat/git/binary_literal/out/small.bin | Bin 0 -> 10 bytes
 .../binary_literal_wrong_original/in/file.bin |   1 +
 .../in/foo.patch                              |   8 ++
 .../out/file.bin                              | Bin 0 -> 10 bytes
 .../binary_mixed_delta_literal/in/favicon.png | Bin 0 -> 2919 bytes
 .../binary_mixed_delta_literal/in/foo.patch   |  86 ++++++++++++++++++
 .../out/favicon.png                           | Bin 0 -> 1125 bytes
 tests/compat/git/mod.rs                       |  67 +++++++++++++-
 tests/compat/main.rs                          |  10 +-
 23 files changed, 248 insertions(+), 23 deletions(-)
 create mode 100644 tests/compat/git/binary_and_text_mixed/in/foo.patch
 create mode 100644 tests/compat/git/binary_and_text_mixed/in/image.png
 create mode 100644 tests/compat/git/binary_and_text_mixed/in/text.txt
 create mode 100644 tests/compat/git/binary_and_text_mixed/out/image.png
 create mode 100644 tests/compat/git/binary_and_text_mixed/out/text.txt
 create mode 100644 tests/compat/git/binary_delta/in/foo.patch
 create mode 100644 tests/compat/git/binary_delta/in/large.bin
 create mode 100644 tests/compat/git/binary_delta/out/large.bin
 create mode 100644 tests/compat/git/binary_delta_wrong_original/in/foo.patch
 create mode 100644 tests/compat/git/binary_delta_wrong_original/in/large.bin
 create mode 100644 tests/compat/git/binary_literal/in/foo.patch
 create mode 100644 tests/compat/git/binary_literal/out/small.bin
 create mode 100644 tests/compat/git/binary_literal_wrong_original/in/file.bin
 create mode 100644 tests/compat/git/binary_literal_wrong_original/in/foo.patch
 create mode 100644 tests/compat/git/binary_literal_wrong_original/out/file.bin
 create mode 100644 tests/compat/git/binary_mixed_delta_literal/in/favicon.png
 create mode 100644 tests/compat/git/binary_mixed_delta_literal/in/foo.patch
 create mode 100644 tests/compat/git/binary_mixed_delta_literal/out/favicon.png

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d0ca9b80..481f8788 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -30,6 +30,7 @@ jobs:
       - run: rustup toolchain install ${{ matrix.rust }} --profile minimal
       - run: cargo +${{ matrix.rust }} check --all-targets --all-features
       - run: cargo +${{ matrix.rust }} test
+      - run: cargo +${{ matrix.rust }} test -F binary
 
   lint:
     runs-on: ubuntu-latest
diff --git a/Cargo.toml b/Cargo.toml
index 68ce3ff3..42637f69 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,3 +27,7 @@ snapbox = { version = "0.6.24", features = ["dir"] }
 [[example]]
 name = "patch_formatter"
 required-features = ["color"]
+
+[[test]]
+name = "compat"
+required-features = ["binary"]
diff --git a/tests/compat/common.rs b/tests/compat/common.rs
index 6e871b08..e8c3b12e 100644
--- a/tests/compat/common.rs
+++ b/tests/compat/common.rs
@@ -9,7 +9,7 @@ use std::{
 };
 
 use diffy::{
-    binary::BinaryPatch,
+    binary::{BinaryPatch, BinaryPatchParseError},
     patch_set::{FileOperation, ParseOptions, PatchKind, PatchSet, PatchSetParseError},
 };
 
@@ -298,7 +298,7 @@ fn print_patch_version() {
 pub enum TestError {
     Parse(PatchSetParseError),
     Apply(diffy::ApplyError),
-    Io(std::io::Error),
+    Binary(BinaryPatchParseError),
 }
 
 impl std::fmt::Display for TestError {
@@ -306,7 +306,7 @@ impl std::fmt::Display for TestError {
         match self {
             TestError::Parse(e) => write!(f, "parse error: {e}"),
             TestError::Apply(e) => write!(f, "apply error: {e}"),
-            TestError::Io(e) => write!(f, "io error: {e}"),
+            TestError::Binary(e) => write!(f, "binary patch error: {e}"),
         }
     }
 }
@@ -397,29 +397,40 @@ pub fn apply_diffy(
             }
         };
 
+        let read_original = || {
+            if let Some(name) = original_name {
+                let original_path = in_dir.join(bytes_to_path(name));
+                fs::read(&original_path).unwrap_or_default()
+            } else {
+                Vec::new()
+            }
+        };
+
+        let write_modified = |result: &[u8]| {
+            let result_path = output_dir.join(bytes_to_path(target_name));
+            if let Some(parent) = result_path.parent() {
+                fs::create_dir_all(parent).unwrap();
+            }
+            fs::write(&result_path, result).unwrap();
+        };
+
         match file_patch.patch() {
             PatchKind::Text(patch) => {
-                let original = if let Some(name) = original_name {
-                    let original_path = in_dir.join(bytes_to_path(name));
-                    fs::read(&original_path).map_err(TestError::Io)?
-                } else {
-                    Vec::new()
-                };
+                let original = read_original();
 
                 let result = diffy::apply_bytes(&original, patch).map_err(TestError::Apply)?;
 
-                let result_path = output_dir.join(bytes_to_path(target_name));
-                if let Some(parent) = result_path.parent() {
-                    fs::create_dir_all(parent).unwrap();
-                }
-                fs::write(&result_path, &result).unwrap();
+                write_modified(&result);
             }
             PatchKind::Binary(BinaryPatch::Marker) => {
                 // Dont do anything if it is just a binary patch marker.
             }
-            PatchKind::Binary(_) => {
-                // Binary patch application requires the `binary` feature.
-                // Will be wired up when that feature is added.
+            PatchKind::Binary(patch) => {
+                let original = read_original();
+
+                let result = patch.apply(&original).map_err(TestError::Binary)?;
+
+                write_modified(&result);
             }
         }
     }
diff --git a/tests/compat/git/binary_and_text_mixed/in/foo.patch b/tests/compat/git/binary_and_text_mixed/in/foo.patch
new file mode 100644
index 00000000..9ae73cb9
--- /dev/null
+++ b/tests/compat/git/binary_and_text_mixed/in/foo.patch
@@ -0,0 +1,16 @@
+diff --git a/image.png b/image.png
+index 0dd1608e45a9c4d35bfc1e6f266a796364aa8754..bccac03558b00545e7ea8ced4a3a1ee232cc185a 100644
+GIT binary patch
+literal 10
+UcmV+l0QLWgP)<h;3K|Lk0S%l1s{jB1
+
+literal 8
+ScmV+j0QdiiP)<h;3K|LuM**q;
+
+diff --git a/text.txt b/text.txt
+index 33194a0a6f3f99e366d606c24d9b1ab0e0086e69..b66ba06d315d46280bb09d54614cc52d1677809f 100644
+--- a/text.txt
++++ b/text.txt
+@@ -1 +1 @@
+-old content
++new content
diff --git a/tests/compat/git/binary_and_text_mixed/in/image.png b/tests/compat/git/binary_and_text_mixed/in/image.png
new file mode 100644
index 00000000..0dd1608e
--- /dev/null
+++ b/tests/compat/git/binary_and_text_mixed/in/image.png
@@ -0,0 +1,2 @@
+‰PNG
+
diff --git a/tests/compat/git/binary_and_text_mixed/in/text.txt b/tests/compat/git/binary_and_text_mixed/in/text.txt
new file mode 100644
index 00000000..33194a0a
--- /dev/null
+++ b/tests/compat/git/binary_and_text_mixed/in/text.txt
@@ -0,0 +1 @@
+old content
diff --git a/tests/compat/git/binary_and_text_mixed/out/image.png b/tests/compat/git/binary_and_text_mixed/out/image.png
new file mode 100644
index 0000000000000000000000000000000000000000..bccac03558b00545e7ea8ced4a3a1ee232cc185a
GIT binary patch
literal 10
RcmeAS@N?(olHy`u1ON@30jmH2

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_and_text_mixed/out/text.txt b/tests/compat/git/binary_and_text_mixed/out/text.txt
new file mode 100644
index 00000000..b66ba06d
--- /dev/null
+++ b/tests/compat/git/binary_and_text_mixed/out/text.txt
@@ -0,0 +1 @@
+new content
diff --git a/tests/compat/git/binary_delta/in/foo.patch b/tests/compat/git/binary_delta/in/foo.patch
new file mode 100644
index 00000000..9abf334b
--- /dev/null
+++ b/tests/compat/git/binary_delta/in/foo.patch
@@ -0,0 +1,9 @@
+diff --git a/large.bin b/large.bin
+index ffba9ca51637158e8f46f0a2a9014372778eeef4..a8a025a84f32c7552841b683361d03d3e171294d 100644
+GIT binary patch
+delta 15
+ZcmV+q0Pz2SD1a!CWCZ{J|NpUQm=imI2nhfH
+
+delta 15
+ZcmV+q0Pz2SD1a!CWCQ_9%OJ66m=h@q1w#M;
+
diff --git a/tests/compat/git/binary_delta/in/large.bin b/tests/compat/git/binary_delta/in/large.bin
new file mode 100644
index 0000000000000000000000000000000000000000..ffba9ca51637158e8f46f0a2a9014372778eeef4
GIT binary patch
literal 5120
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

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_delta/out/large.bin b/tests/compat/git/binary_delta/out/large.bin
new file mode 100644
index 0000000000000000000000000000000000000000..a8a025a84f32c7552841b683361d03d3e171294d
GIT binary patch
literal 5120
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

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_delta_wrong_original/in/foo.patch b/tests/compat/git/binary_delta_wrong_original/in/foo.patch
new file mode 100644
index 00000000..9abf334b
--- /dev/null
+++ b/tests/compat/git/binary_delta_wrong_original/in/foo.patch
@@ -0,0 +1,9 @@
+diff --git a/large.bin b/large.bin
+index ffba9ca51637158e8f46f0a2a9014372778eeef4..a8a025a84f32c7552841b683361d03d3e171294d 100644
+GIT binary patch
+delta 15
+ZcmV+q0Pz2SD1a!CWCZ{J|NpUQm=imI2nhfH
+
+delta 15
+ZcmV+q0Pz2SD1a!CWCQ_9%OJ66m=h@q1w#M;
+
diff --git a/tests/compat/git/binary_delta_wrong_original/in/large.bin b/tests/compat/git/binary_delta_wrong_original/in/large.bin
new file mode 100644
index 00000000..0d6307ba
--- /dev/null
+++ b/tests/compat/git/binary_delta_wrong_original/in/large.bin
@@ -0,0 +1 @@
+WRONG CONTENT
\ No newline at end of file
diff --git a/tests/compat/git/binary_literal/in/foo.patch b/tests/compat/git/binary_literal/in/foo.patch
new file mode 100644
index 00000000..61ea8bfc
--- /dev/null
+++ b/tests/compat/git/binary_literal/in/foo.patch
@@ -0,0 +1,10 @@
+diff --git a/small.bin b/small.bin
+new file mode 100644
+index 0000000000000000000000000000000000000000..df93f5f3f72487244976c34e85525cf445016566
+GIT binary patch
+literal 10
+UcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k
+
+literal 0
+KcmV+b0RR6000031
+
diff --git a/tests/compat/git/binary_literal/out/small.bin b/tests/compat/git/binary_literal/out/small.bin
new file mode 100644
index 0000000000000000000000000000000000000000..df93f5f3f72487244976c34e85525cf445016566
GIT binary patch
literal 10
RcmZQzWMXDvWn<^y1ONc904@Lk

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_literal_wrong_original/in/file.bin b/tests/compat/git/binary_literal_wrong_original/in/file.bin
new file mode 100644
index 00000000..605cc407
--- /dev/null
+++ b/tests/compat/git/binary_literal_wrong_original/in/file.bin
@@ -0,0 +1 @@
+WRONG CONTENT - not matching the hash in patch
\ No newline at end of file
diff --git a/tests/compat/git/binary_literal_wrong_original/in/foo.patch b/tests/compat/git/binary_literal_wrong_original/in/foo.patch
new file mode 100644
index 00000000..d3e39d97
--- /dev/null
+++ b/tests/compat/git/binary_literal_wrong_original/in/foo.patch
@@ -0,0 +1,8 @@
+diff --git a/file.bin b/file.bin
+index df93f5f3f72487244976c34e85525cf445016566..a8a025a84f32c7552841b683361d03d3e171294d 100644
+GIT binary patch
+literal 10
+UcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k
+
+literal 10
+UcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k
diff --git a/tests/compat/git/binary_literal_wrong_original/out/file.bin b/tests/compat/git/binary_literal_wrong_original/out/file.bin
new file mode 100644
index 0000000000000000000000000000000000000000..df93f5f3f72487244976c34e85525cf445016566
GIT binary patch
literal 10
RcmZQzWMXDvWn<^y1ONc904@Lk

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_mixed_delta_literal/in/favicon.png b/tests/compat/git/binary_mixed_delta_literal/in/favicon.png
new file mode 100644
index 0000000000000000000000000000000000000000..5109c1de8bea744180448b347fb44ddef23b90f4
GIT binary patch
literal 2919
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
IIpoLx0#^I3DgXcg

literal 0
HcmV?d00001

diff --git a/tests/compat/git/binary_mixed_delta_literal/in/foo.patch b/tests/compat/git/binary_mixed_delta_literal/in/foo.patch
new file mode 100644
index 00000000..7f52479d
--- /dev/null
+++ b/tests/compat/git/binary_mixed_delta_literal/in/foo.patch
@@ -0,0 +1,86 @@
+diff --git a/favicon.png b/favicon.png
+index 5109c1de8bea744180448b347fb44ddef23b90f4..69b8613ce1506e1c92b864f91cc46df06348c62b 100644
+GIT binary patch
+delta 1115
+zcmV-h1f=`t7Uc+#8Gi%-007x@vVQ;o00d`2O+f$vv5yP<VFdsH03c&XQcVB=dL{q>
+zfP?@5`Tzg`fam}Kbua(`>R<o>I+y?e7jT@qQ9J+u00Lr5M??VshmXv^00009a7bBm
+z000DZ000DZ0m8#+P5=M^2XskIMF-{q4Gj?pmKmEP0008eNq<B^R7l5_)lX;~brc8i
+zPqJ&%ZnWlLg|)3nu-5jHf(c5Y8}{JQ=AsewC=?}0X|aceco!A*(py0AAPA<O1g$}>
+zS*l<~QA$1JAY?<@4F!`%H{0#bjE9}fZuU?Ayt&Np_x{ZHeczk+=q00aIO{BOMm>NW
+zGb^R2YFbUrw129ilv&5_?R*#op%sCs<q50^6=I7P>1zv6w<_>da(*43C8z5GS?N}X
+z{^V`QxQx)j*!`A8b;E|$ExHA=4hUt88|nl<E=XYi=A>Q7tEk9hz=YqEbOPg@0Wz`s
+zmN!~(9dV=u?I~Mvh)g?mp_)jf?D@Nr{DQJb<hHOu=YKYd%MK!R&1MhRfBfQoTb@(2
+z2PIE#t40*u*ip1zPtjvIB@(%=V5AXXRwxp=a~~l-MLK38G}{P}vf`$5HvMVA)x`Lk
+z1q&8jYQgunlu0+7b5ltQ#uNp<*XN?kIG-5LX(qWI-<1uz>>GW45GWc;+ig_8yt0(H
+zchI)mFn`!(GAY|t|C#flvV9n{2WCVfKibO<1Qi=LY`EQ$z;UqGqDW*0&cq!s6My4;
+zPXgEE5_G3UA~k24J=gwQb;>^P#8wX*Y*kE)MBeQ{FfT7}!Y4_A1FwN^<FuyWL|oPR
+zjsVRnTuSb~M8;q7sVbLN^{eChP5459rxUkPpMPV{cYaR(zLS13=vffDVyn?erMvXr
+zTX?CfrX<xEC<XiPLElA7U2gX)kj7U6r)9Bbqr>c9)O_GgkHj~RdK~NC^L5i~IUXh_
+z95o@^6-U;DqjIVuk>ys^VPVp56?GT72DqTE5?dt$r77DZ?T}ZyX3UaF&vYMYG>7U(
+z=6{7=Hn2lG;1!X1AGZ(HW&;lyamBia;`62jOIGoOLtacMykp3iKdiS0Xh_|vJ_mY~
+zb4{&%v9!zfYAbcDwo>=i)=iqrbxKXm)PpS7rrhUx{~ymQhCvo@p6LJp03~!qSaf7z
+zbY(hYa%Ew3WdJfTGBPbNF)cAOR53F;F@HBYFgPnPFgh?WYdBZ^0000bbVXQnWMOn=
+zI&E)cX=Zr<GB7eSEif@HF*8&#GdeLhIxsjZFfckWFdAj=K>z>%8FWQhbW?9;ba!EL
+zWdL_~cP?peYja~^aAhuUa%Y?FJQ@H109SfcSaechcOY<bZ)Rz1Wgv8UaAhEAa8z_-
+z004NL<MIp$aaJfO%1_J8N##-i10xGAV+#`_6HAj60}~)bfHcEo10%CkAj{a)$i&RV
+h9K;99fJmT9E&%Em5p?oGHI)DW002ovPDHLkV1gh=-pv32
+
+literal 2919
+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
+R3Jw4O002ovPDHLkV1icrt||Zk
+
diff --git a/tests/compat/git/binary_mixed_delta_literal/out/favicon.png b/tests/compat/git/binary_mixed_delta_literal/out/favicon.png
new file mode 100644
index 0000000000000000000000000000000000000000..69b8613ce1506e1c92b864f91cc46df06348c62b
GIT binary patch
literal 1125
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE0wix1Z>k4UEa{HEjtmSN`?>!lvVtU&J%W50
z7^>757#dm_7=8hT8eT9klo~KFyh>nTu$sZZAYL$MSD+10f+@+{-G$+Qd;gjJKptm-
zM`SV3z!DH<JajnI4=Bi9;_2(k{)~~ASCC_x<ZNZ2rVE}fjv*e$r(X5XkSP^m|KPtV
z`*PlvX9=xa*LrNY_H9xVr`JO1Zx1d$TO{~JLqydxb7OmJg}CU~OVJJ=6gZa6V_ECC
zHgZ*hYoM3y6NMD#TfD53-OO*lJ=fDd_e|b5|Nnb-o_YWM-<j{V_h)~9p}M%p;<ZkZ
zn{9)PvG&pxSy8@cx2#$;CGz;Yw>1*13q>1OJmp-&A)3@J_A;A0V7u0bkfJ)-`Krrb
zGey1(YybBo_r#8#3kPrfo#tA4xb3R$F4j$a9H~9huUPE$JQDstTM~O>^@<b82U_k=
zE@65+m(ghB?`h^y1+s-pSl?<!7k2nqmoA*;vE<Fq-IM+_ZSr`sZG+=;v(D3eN+oC0
z_^;Rhc~l!cFL(>Ps(;>UH<3Fx0=LBZUre@8723HjVToWun1;~KVtGY7SF1E7liM5<
zHa%KaZ1y+v;MF5PX0dXM#bh1)zI}?P`JCclPp)GktoyD%Uv%1HzQp-VwViVJr}FN4
zBVAi3pdsabJ2zzio=sD>mtWX++u%m3k>>5t|1&=?+*B*EnLW)#$^O=9J{D1Fvz#4w
zCmkr<aD9<S3fs9OvIfHSk8Avyu0IhfS?;Q2nm)_+`oHMXQ+Dr<gz-z~g!**5+<WU_
zps$~QNZqrMd3|I4<1Nb`xWruj*~f5JE5_^HK9^(hA6IHk5Bs|M@h{&WP7TY2w+GHo
zK387n_ix|iI-?hn0=tq{U-VeI`^&xPij}LEsa%!NVEz5x@xH5fY~FY63CF^jmZxq^
zTYUIU{FRyqzWqnc`>SML-}_v8Imc2?O<l%R@wTY@wU)(2tCS`_4ZE6{cqw1BRD2iP
zjs@$4qE(rfYTj0UJ0W~`+L=k7=S$=>P1;|%KWmLM+u&^dKy+fI{C57UY0UhRg-3U_
zKl;3k)jRBCi*uZh#-8L8Gwj!FXV37syULEeYD%&1+S-j<PJheNE?u)N==;@czOzo3
zdikEc(yViR*`4QA|K-nXw>gUC&wB|>?y4oO5hW>!C8<`)MX5lF!N|bKNY}tn*U&h`
z(Adh*+{(a0+rYrez#!Wq{4a`z-29Zxv`X9>q*C7l^C^QQ$cEtjw370~qEv?R@^Zb*
zyzJuS#DY}4{G#;P?`))iio&ZxB1(c1%M}WW^3yVNQWZ)n3sMy_3rdn17%JvG{=~yk
z7^b0d%K!8k&!<5Q%*xz)$=t%q!rqfbn1vNw8cYtSFe`5kQ8<0$%84Uqj>sHgKi%N5
cz)O$emAGKZCnwXXKr0wLUHx3vIVCg!0EmFw6951J

literal 0
HcmV?d00001

diff --git a/tests/compat/git/mod.rs b/tests/compat/git/mod.rs
index b294cb11..66687a5a 100644
--- a/tests/compat/git/mod.rs
+++ b/tests/compat/git/mod.rs
@@ -184,7 +184,7 @@ fn fail_prefix_no_slash() {
     Case::git("fail_prefix_no_slash")
         .strip(1)
         .expect_success(false)
-        .expect_diffy_error(snapbox::str!["io error: No such file or directory (os error 2)"])
+        .expect_diffy_error(snapbox::str!["apply error: error applying hunk #1"])
         .expect_external_error(snapbox::str![[r#"
 error: git diff header lacks filename information when removing 1 leading pathname component (line 5)
 
@@ -214,6 +214,71 @@ error: patch fragment without header at line 11: @@ -7,3 +7,3 @@
         .run();
 }
 
+// Mixed binary and text patch.
+//
+// Both git apply and diffy should apply both the binary and text changes.
+#[test]
+fn binary_and_text_mixed() {
+    Case::git("binary_and_text_mixed").strip(1).run();
+}
+
+// Binary patch in literal format (new file creation).
+#[test]
+fn binary_literal() {
+    Case::git("binary_literal").strip(1).run();
+}
+
+// Binary patch in delta format (modify existing file).
+#[test]
+fn binary_delta() {
+    Case::git("binary_delta").strip(1).run();
+}
+
+// Binary literal patch applied to wrong original content.
+//
+// diffy succeeds (literal format doesn't need the original); git rejects.
+#[test]
+fn binary_literal_wrong_original() {
+    Case::git("binary_literal_wrong_original")
+        .strip(1)
+        .expect_compat(false)
+        .expect_external_error(snapbox::str![[r#"
+error: corrupt binary patch at line 9: 
+error: No valid patches in input (allow with "--allow-empty")
+
+"#]])
+        .run();
+}
+
+// Binary delta patch applied to wrong original content.
+// Both diffy and git fail, but for different reasons (see snapshots).
+#[test]
+fn binary_delta_wrong_original() {
+    Case::git("binary_delta_wrong_original")
+        .strip(1)
+        .expect_success(false)
+        .expect_diffy_error(snapbox::str!["binary patch error: error parsing binary patch: original size mismatch: expected 5120, got 13"])
+        .expect_external_error(snapbox::str![[r#"
+error: the patch applies to 'large.bin' (0d6307ba5442d0fdfe89dd3d78f82604fe0c0d80), which does not match the current contents.
+error: large.bin: patch does not apply
+
+"#]])
+        .run();
+}
+
+// Binary patch with mixed delta/literal format.
+//
+// Git can choose different encodings for forward and reverse transformations
+// based on which is more efficient. This patch has:
+// - forward (original -> modified): delta
+// - reverse (modified -> original): literal
+//
+// From rust-lang/rust@ad46af24 (favicon-32x32.png update).
+#[test]
+fn binary_mixed_delta_literal() {
+    Case::git("binary_mixed_delta_literal").strip(1).run();
+}
+
 // Multi-file patch with junk/preamble text between different files.
 //
 // git apply behavior: Ignores content between `diff --git` boundaries.
diff --git a/tests/compat/main.rs b/tests/compat/main.rs
index e35ed079..2c0afe7c 100644
--- a/tests/compat/main.rs
+++ b/tests/compat/main.rs
@@ -20,25 +20,25 @@
 //!
 //! ```sh
 //! # Run all compat tests
-//! cargo test --test compat
+//! cargo test --test compat -F binary
 //!
 //! # Run with reference tool comparison (CI mode)
-//! CI=1 cargo test --test compat
+//! CI=1 cargo test --test compat -F binary
 //!
 //! # For Nix users, run this to ensure you have GNU patch
-//! CI=1 nix shell nixpkgs#gnupatch -c cargo test --test compat
+//! CI=1 nix shell nixpkgs#gnupatch -c cargo test --test compat -F binary
 //! ```
 //!
 //! ## Regenerating snapshots
 //!
 //! ```sh
-//! SNAPSHOTS=overwrite cargo test --test compat
+//! SNAPSHOTS=overwrite cargo test --test compat -F binary
 //! ```
 //!
 //! ## Adding new test cases
 //!
 //! 1. Create `case_name/in/` with input file(s) and `foo.patch`
-//! 2. Run `SNAPSHOTS=overwrite cargo test --test compat` to generate `out/`
+//! 2. Run `SNAPSHOTS=overwrite cargo test --test compat -F binary` to generate `out/`
 //! 3. Add `#[test] fn case_name() { Case::{gnu_patch,git}(...).run(); }` in the module
 //!
 //! For failure tests, use `.expect_success(false)` and skip step 2.

From b13571401897b10dfc57172085ae6c4b156783d5 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:23:10 -0400
Subject: [PATCH 08/14] test(replay): wire binary patch into replay tests

Now replay tests require `binary` Cargo feature.
---
 .github/workflows/replay.yml |  2 +-
 Cargo.toml                   |  4 +++
 tests/replay.rs              | 63 ++++++++++++++++++++++++++++--------
 3 files changed, 55 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/replay.yml b/.github/workflows/replay.yml
index 08384d61..48368fce 100644
--- a/.github/workflows/replay.yml
+++ b/.github/workflows/replay.yml
@@ -67,7 +67,7 @@ jobs:
             exit 1
           fi
       - run: rustup toolchain install stable --profile minimal
-      - run: cargo test --release --test replay -- --ignored --nocapture
+      - run: cargo test --release --test replay -F binary -- --ignored --nocapture
         env:
           DIFFY_TEST_REPO: ${{ inputs.repo_url == '' && '.' || 'target/test-repo' }}
           DIFFY_TEST_COMMITS: ${{ inputs.commits }}
diff --git a/Cargo.toml b/Cargo.toml
index 42637f69..125a3c72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,3 +31,7 @@ required-features = ["color"]
 [[test]]
 name = "compat"
 required-features = ["binary"]
+
+[[test]]
+name = "replay"
+required-features = ["binary"]
diff --git a/tests/replay.rs b/tests/replay.rs
index e6fbab3e..48f64e68 100644
--- a/tests/replay.rs
+++ b/tests/replay.rs
@@ -6,7 +6,7 @@
 //! ## Usage
 //!
 //! ```console
-//! $ cargo test --test replay -- --ignored --nocapture
+//! $ cargo test --test replay -F binary -- --ignored --nocapture
 //! ```
 //!
 //! ## Environment Variables
@@ -59,7 +59,10 @@ use std::{
     sync::Mutex,
 };
 
-use diffy::patch_set::{FileOperation, ParseOptions, PatchKind, PatchSet};
+use diffy::{
+    binary::BinaryPatch,
+    patch_set::{FileOperation, ParseOptions, PatchKind, PatchSet},
+};
 use rayon::prelude::*;
 
 /// Persistent `git cat-file --batch` process for fast object lookups.
@@ -331,13 +334,10 @@ fn process_commit(
 
     // UniDiff format cannot express pure renames (no ---/+++ headers).
     // Use `--no-renames` to represent them as delete + create instead.
-    // GitDiff mode handles renames via extended headers natively.
+    // GitDiff mode uses `--binary` to get actual binary patch data.
     let diff_output = match mode {
         TestMode::UniDiff => git_bytes(repo, &["diff", "--no-renames", parent, child]),
-        // TODO: pass `--binary` once binary patch support lands,
-        // so binary files get actual delta/literal data instead of
-        // "Binary files differ" markers.
-        TestMode::GitDiff => git_bytes(repo, &["diff", parent, child]),
+        TestMode::GitDiff => git_bytes(repo, &["diff", "--binary", parent, child]),
     };
 
     if diff_output.is_empty() {
@@ -387,9 +387,7 @@ fn process_commit(
             text_files + type_changes
         }
         TestMode::GitDiff => {
-            // Can't use `--numstat` for GitDiff: it shows `-\t-\t` for both
-            // actual binary diffs AND pure binary renames (100% similarity).
-            // Use `--raw` for total count instead.
+            // With `--binary`, all files including binary ones have patch data.
             let raw = git(repo, &["diff", "--raw", parent, child]);
             let (mut total, mut type_changes) = (0, 0);
             for line in raw.lines().filter(|l| !l.is_empty()) {
@@ -544,12 +542,51 @@ fn process_commit(
                     );
                 }
             }
-            PatchKind::Binary(_) => {
-                // Binary patch application not yet wired up in replay tests.
-                // Will be done once the `binary` Cargo feature is added.
+            PatchKind::Binary(BinaryPatch::Marker) => {
+                // `Binary files differ` marker - no actual data to apply
                 skipped += 1;
                 continue;
             }
+            PatchKind::Binary(patch) => {
+                // Get content as bytes
+                let base_content = if let Some(path) = base_path {
+                    let Some(content) = cat.get(parent, path) else {
+                        skipped += 1;
+                        continue;
+                    };
+                    content
+                } else {
+                    Vec::new()
+                };
+
+                let expected_content = if let Some(path) = target_path {
+                    let Some(content) = cat.get(child, path) else {
+                        skipped += 1;
+                        continue;
+                    };
+                    content
+                } else {
+                    Vec::new()
+                };
+
+                let result = match patch.apply(&base_content) {
+                    Ok(r) => r,
+                    Err(e) => {
+                        panic!(
+                            "Failed to apply binary patch at {parent_short}..{child_short} for {desc}: {e}"
+                        );
+                    }
+                };
+
+                if result != expected_content {
+                    panic!(
+                        "Binary content mismatch at {parent_short}..{child_short} for {desc}\n\n\
+                        Expected {} bytes, got {} bytes",
+                        expected_content.len(),
+                        result.len()
+                    );
+                }
+            }
         }
 
         applied += 1;

From 3622334be256c691473bd178ad113d5377eaa506 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:13:36 -0400
Subject: [PATCH 09/14] test(binary): add zero control byte delta test

Assert current behavior where 0x00 control byte falls
through to ADD which is a no-op.
`git apply` rejects this as "unexpected delta opcode 0".
---
 src/binary/delta.rs                           | 21 +++++++++++++++
 .../git/binary_delta_zero_control/in/file.bin |  1 +
 .../binary_delta_zero_control/in/foo.patch    |  9 +++++++
 .../binary_delta_zero_control/out/file.bin    |  1 +
 tests/compat/git/mod.rs                       | 26 +++++++++++++++++++
 5 files changed, 58 insertions(+)
 create mode 100644 tests/compat/git/binary_delta_zero_control/in/file.bin
 create mode 100644 tests/compat/git/binary_delta_zero_control/in/foo.patch
 create mode 100644 tests/compat/git/binary_delta_zero_control/out/file.bin

diff --git a/src/binary/delta.rs b/src/binary/delta.rs
index fa1de268..b9ee1354 100644
--- a/src/binary/delta.rs
+++ b/src/binary/delta.rs
@@ -359,4 +359,25 @@ mod tests {
         let err = apply(&[], &delta).unwrap_err();
         assert_eq!(err, DeltaError::UnexpectedEof);
     }
+
+    #[test]
+    fn zero_control_byte_is_add_zero() {
+        // Same delta layout as compat fixture `binary_delta_zero_control`:
+        // hello -> hellX with zero control byte (0x00) between COPY and ADD.
+        //
+        // Currently 0x00 falls through to ADD with length 0 (a no-op),
+        // so the delta applies successfully. git apply rejects this.
+        let delta = [
+            0x05, // orig_size = 5
+            0x05, // mod_size = 5
+            0x91, // COPY: 0x80 | 0x10 | 0x01 (offset1 + size1 present)
+            0x00, // offset=0
+            0x04, // len=4 ("hell")
+            0x00, // zero control byte — currently treated as ADD(0)
+            0x01, b'X', // ADD 1 byte: 'X'
+        ];
+        let original = b"hello";
+        let result = apply(original, &delta).unwrap();
+        assert_eq!(result, b"hellX");
+    }
 }
diff --git a/tests/compat/git/binary_delta_zero_control/in/file.bin b/tests/compat/git/binary_delta_zero_control/in/file.bin
new file mode 100644
index 00000000..b6fc4c62
--- /dev/null
+++ b/tests/compat/git/binary_delta_zero_control/in/file.bin
@@ -0,0 +1 @@
+hello
\ No newline at end of file
diff --git a/tests/compat/git/binary_delta_zero_control/in/foo.patch b/tests/compat/git/binary_delta_zero_control/in/foo.patch
new file mode 100644
index 00000000..373cf385
--- /dev/null
+++ b/tests/compat/git/binary_delta_zero_control/in/foo.patch
@@ -0,0 +1,9 @@
+diff --git a/file.bin b/file.bin
+index b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0..959ff41a016f2a808d4f2b71f559d510416a020d 100644
+GIT binary patch
+delta 8
+Pc${Npoyfq#z!(7l1S0_X
+
+delta 7
+Oc${Npoyfq#m=6F0ngI|1
+
diff --git a/tests/compat/git/binary_delta_zero_control/out/file.bin b/tests/compat/git/binary_delta_zero_control/out/file.bin
new file mode 100644
index 00000000..959ff41a
--- /dev/null
+++ b/tests/compat/git/binary_delta_zero_control/out/file.bin
@@ -0,0 +1 @@
+hellX
\ No newline at end of file
diff --git a/tests/compat/git/mod.rs b/tests/compat/git/mod.rs
index 66687a5a..6ff2c9e9 100644
--- a/tests/compat/git/mod.rs
+++ b/tests/compat/git/mod.rs
@@ -279,6 +279,32 @@ fn binary_mixed_delta_literal() {
     Case::git("binary_mixed_delta_literal").strip(1).run();
 }
 
+// Binary delta with a zero control byte (0x00) in the instruction stream.
+//
+// Hand-crafted fixture: `hello` -> `hellX`. Forward delta instructions:
+//
+// - 0x05       orig_size = 5
+// - 0x05       mod_size = 5
+// - 0x91 0x00 0x04  COPY offset=0, len=4 ("hell")
+// - 0x00       zero control byte
+// - 0x01 0x58  ADD 1 byte: 'X'
+//
+// git apply rejects this (`error: unexpected delta opcode 0`).
+// diffy currently treats 0x00 as ADD(0) (a no-op) and succeeds.
+#[test]
+fn binary_delta_zero_control() {
+    Case::git("binary_delta_zero_control")
+        .strip(1)
+        .expect_compat(false)
+        .expect_external_error(snapbox::str![[r#"
+error: unexpected delta opcode 0
+error: binary patch does not apply to 'file.bin'
+error: file.bin: patch does not apply
+
+"#]])
+        .run();
+}
+
 // Multi-file patch with junk/preamble text between different files.
 //
 // git apply behavior: Ignores content between `diff --git` boundaries.

From 99042b7c48754661d577b5059f57038ee45ade98 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:14:45 -0400
Subject: [PATCH 10/14] fix(binary): reject zero control byte in delta

---
 src/binary/delta.rs                             | 17 ++++++++++-------
 .../git/binary_delta_zero_control/out/file.bin  |  1 -
 tests/compat/git/mod.rs                         |  8 ++++----
 3 files changed, 14 insertions(+), 12 deletions(-)
 delete mode 100644 tests/compat/git/binary_delta_zero_control/out/file.bin

diff --git a/src/binary/delta.rs b/src/binary/delta.rs
index b9ee1354..7580e92d 100644
--- a/src/binary/delta.rs
+++ b/src/binary/delta.rs
@@ -46,6 +46,9 @@ pub fn apply(original: &[u8], delta: &[u8]) -> Result<Vec<u8>, DeltaError> {
             }
 
             result.extend_from_slice(&original[src_offset..src_end]);
+        } else if control == 0 {
+            // `git apply` rejects this as "unexpected delta opcode 0".
+            return Err(DeltaError::UnexpectedOpcode);
         } else {
             // ADD instruction
             let add_len = control as usize;
@@ -180,6 +183,8 @@ pub enum DeltaError {
     },
     /// COPY range calculation overflowed.
     InvalidCopyRange,
+    /// Unexpected delta opcode (control byte 0x00).
+    UnexpectedOpcode,
 }
 
 impl fmt::Display for DeltaError {
@@ -210,6 +215,7 @@ impl fmt::Display for DeltaError {
                 )
             }
             DeltaError::InvalidCopyRange => write!(f, "copy range calculation overflow"),
+            DeltaError::UnexpectedOpcode => write!(f, "unexpected delta opcode 0"),
         }
     }
 }
@@ -361,23 +367,20 @@ mod tests {
     }
 
     #[test]
-    fn zero_control_byte_is_add_zero() {
+    fn error_unexpected_opcode() {
         // Same delta layout as compat fixture `binary_delta_zero_control`:
         // hello -> hellX with zero control byte (0x00) between COPY and ADD.
-        //
-        // Currently 0x00 falls through to ADD with length 0 (a no-op),
-        // so the delta applies successfully. git apply rejects this.
         let delta = [
             0x05, // orig_size = 5
             0x05, // mod_size = 5
             0x91, // COPY: 0x80 | 0x10 | 0x01 (offset1 + size1 present)
             0x00, // offset=0
             0x04, // len=4 ("hell")
-            0x00, // zero control byte — currently treated as ADD(0)
+            0x00, // zero control byte (unexpected opcode)
             0x01, b'X', // ADD 1 byte: 'X'
         ];
         let original = b"hello";
-        let result = apply(original, &delta).unwrap();
-        assert_eq!(result, b"hellX");
+        let err = apply(original, &delta).unwrap_err();
+        assert_eq!(err, DeltaError::UnexpectedOpcode);
     }
 }
diff --git a/tests/compat/git/binary_delta_zero_control/out/file.bin b/tests/compat/git/binary_delta_zero_control/out/file.bin
deleted file mode 100644
index 959ff41a..00000000
--- a/tests/compat/git/binary_delta_zero_control/out/file.bin
+++ /dev/null
@@ -1 +0,0 @@
-hellX
\ No newline at end of file
diff --git a/tests/compat/git/mod.rs b/tests/compat/git/mod.rs
index 6ff2c9e9..ff32e073 100644
--- a/tests/compat/git/mod.rs
+++ b/tests/compat/git/mod.rs
@@ -288,14 +288,14 @@ fn binary_mixed_delta_literal() {
 // - 0x91 0x00 0x04  COPY offset=0, len=4 ("hell")
 // - 0x00       zero control byte
 // - 0x01 0x58  ADD 1 byte: 'X'
-//
-// git apply rejects this (`error: unexpected delta opcode 0`).
-// diffy currently treats 0x00 as ADD(0) (a no-op) and succeeds.
 #[test]
 fn binary_delta_zero_control() {
     Case::git("binary_delta_zero_control")
         .strip(1)
-        .expect_compat(false)
+        .expect_success(false)
+        .expect_diffy_error(snapbox::str![[
+            "binary patch error: error parsing binary patch: unexpected delta opcode 0"
+        ]])
         .expect_external_error(snapbox::str![[r#"
 error: unexpected delta opcode 0
 error: binary patch does not apply to 'file.bin'

From ceb0dfb5db2944bffdea8175aa98c590c204d3dc Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:35:53 -0400
Subject: [PATCH 11/14] test(binary): add literal size mismatch test

Declared literal size doesn't match decompressed data.
`git apply` rejects this; diffy currently doesn't check.
---
 src/binary/mod.rs                               |  11 +++++++++++
 .../binary_literal_size_mismatch/in/foo.patch   |  10 ++++++++++
 .../binary_literal_size_mismatch/out/small.bin  | Bin 0 -> 10 bytes
 tests/compat/git/mod.rs                         |  16 ++++++++++++++++
 4 files changed, 37 insertions(+)
 create mode 100644 tests/compat/git/binary_literal_size_mismatch/in/foo.patch
 create mode 100644 tests/compat/git/binary_literal_size_mismatch/out/small.bin

diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index b5cf1e48..aa71f324 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -535,6 +535,17 @@ mod apply_tests {
         assert_eq!(original.len(), 0);
     }
 
+    #[test]
+    fn literal_size_mismatch() {
+        // Declared size 99 but actual decompressed data is 10 bytes.
+        // Currently accepted — no size validation after decompression.
+        let input = "GIT binary patch\nliteral 99\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let (patch, _) = parse_binary_patch(input).unwrap();
+
+        let modified = patch.apply(&[]).unwrap();
+        assert_eq!(modified.len(), 10);
+    }
+
     #[test]
     fn apply_with_crlf_line_endings() {
         let input = "GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
diff --git a/tests/compat/git/binary_literal_size_mismatch/in/foo.patch b/tests/compat/git/binary_literal_size_mismatch/in/foo.patch
new file mode 100644
index 00000000..4fbee5a3
--- /dev/null
+++ b/tests/compat/git/binary_literal_size_mismatch/in/foo.patch
@@ -0,0 +1,10 @@
+diff --git a/small.bin b/small.bin
+new file mode 100644
+index 0000000000000000000000000000000000000000..df93f5f3f72487244976c34e85525cf445016566
+GIT binary patch
+literal 99
+UcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k
+
+literal 0
+KcmV+b0RR6000031
+
diff --git a/tests/compat/git/binary_literal_size_mismatch/out/small.bin b/tests/compat/git/binary_literal_size_mismatch/out/small.bin
new file mode 100644
index 0000000000000000000000000000000000000000..df93f5f3f72487244976c34e85525cf445016566
GIT binary patch
literal 10
RcmZQzWMXDvWn<^y1ONc904@Lk

literal 0
HcmV?d00001

diff --git a/tests/compat/git/mod.rs b/tests/compat/git/mod.rs
index ff32e073..7498a3c2 100644
--- a/tests/compat/git/mod.rs
+++ b/tests/compat/git/mod.rs
@@ -250,6 +250,22 @@ error: No valid patches in input (allow with "--allow-empty")
         .run();
 }
 
+// Declared literal size (99) doesn't match actual decompressed data (10 bytes).
+//
+// git apply rejects this; diffy currently ignores the declared size.
+#[test]
+fn binary_literal_size_mismatch() {
+    Case::git("binary_literal_size_mismatch")
+        .strip(1)
+        .expect_compat(false)
+        .expect_external_error(snapbox::str![[r#"
+error: corrupt binary patch at line 7: 
+error: No valid patches in input (allow with "--allow-empty")
+
+"#]])
+        .run();
+}
+
 // Binary delta patch applied to wrong original content.
 // Both diffy and git fail, but for different reasons (see snapshots).
 #[test]

From d506a5ed6709ac71a685fbbaa83c10010c848366 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 13:37:19 -0400
Subject: [PATCH 12/14] fix(binary): check decompressed size against declared

After this, both git-apply and diffy reject.
---
 src/binary/mod.rs                             |  30 ++++++++++++++++--
 .../out/small.bin                             | Bin 10 -> 0 bytes
 tests/compat/git/mod.rs                       |   8 +++--
 3 files changed, 32 insertions(+), 6 deletions(-)
 delete mode 100644 tests/compat/git/binary_literal_size_mismatch/out/small.bin

diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index aa71f324..d82fe3bb 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -118,6 +118,14 @@ impl<'a> BinaryPatch<'a> {
             .read_to_end(&mut decompressed)
             .map_err(|e| BinaryPatchParseErrorKind::DecompressionFailed(e.to_string()))?;
 
+        if decompressed.len() as u64 != binary_data.size {
+            return Err(BinaryPatchParseErrorKind::DecompressedSizeMismatch {
+                expected: binary_data.size,
+                actual: decompressed.len() as u64,
+            }
+            .into());
+        }
+
         Ok(decompressed)
     }
 }
@@ -236,6 +244,10 @@ pub(crate) enum BinaryPatchParseErrorKind {
     /// Zlib decompression failed.
     #[cfg(feature = "binary")]
     DecompressionFailed(String),
+
+    /// Decompressed size doesn't match declared size.
+    #[cfg(feature = "binary")]
+    DecompressedSizeMismatch { expected: u64, actual: u64 },
 }
 
 impl fmt::Display for BinaryPatchParseErrorKind {
@@ -252,6 +264,13 @@ impl fmt::Display for BinaryPatchParseErrorKind {
             Self::Delta(e) => write!(f, "{e}"),
             #[cfg(feature = "binary")]
             Self::DecompressionFailed(msg) => write!(f, "decompression failed: {msg}"),
+            #[cfg(feature = "binary")]
+            Self::DecompressedSizeMismatch { expected, actual } => {
+                write!(
+                    f,
+                    "decompressed size mismatch: expected {expected}, got {actual}"
+                )
+            }
         }
     }
 }
@@ -538,12 +557,17 @@ mod apply_tests {
     #[test]
     fn literal_size_mismatch() {
         // Declared size 99 but actual decompressed data is 10 bytes.
-        // Currently accepted — no size validation after decompression.
         let input = "GIT binary patch\nliteral 99\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
-        let modified = patch.apply(&[]).unwrap();
-        assert_eq!(modified.len(), 10);
+        let err = patch.apply(&[]).unwrap_err();
+        assert!(matches!(
+            err.kind,
+            BinaryPatchParseErrorKind::DecompressedSizeMismatch {
+                expected: 99,
+                actual: 10
+            }
+        ));
     }
 
     #[test]
diff --git a/tests/compat/git/binary_literal_size_mismatch/out/small.bin b/tests/compat/git/binary_literal_size_mismatch/out/small.bin
deleted file mode 100644
index df93f5f3f72487244976c34e85525cf445016566..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10
RcmZQzWMXDvWn<^y1ONc904@Lk

diff --git a/tests/compat/git/mod.rs b/tests/compat/git/mod.rs
index 7498a3c2..51b7cd8b 100644
--- a/tests/compat/git/mod.rs
+++ b/tests/compat/git/mod.rs
@@ -251,13 +251,15 @@ error: No valid patches in input (allow with "--allow-empty")
 }
 
 // Declared literal size (99) doesn't match actual decompressed data (10 bytes).
-//
-// git apply rejects this; diffy currently ignores the declared size.
+// Both git apply and diffy reject this.
 #[test]
 fn binary_literal_size_mismatch() {
     Case::git("binary_literal_size_mismatch")
         .strip(1)
-        .expect_compat(false)
+        .expect_success(false)
+        .expect_diffy_error(snapbox::str![[
+            "binary patch error: error parsing binary patch: decompressed size mismatch: expected 99, got 10"
+        ]])
         .expect_external_error(snapbox::str![[r#"
 error: corrupt binary patch at line 7: 
 error: No valid patches in input (allow with "--allow-empty")

From c5f8447db84e893705471ae35002c3e0c3cf7551 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 18 Apr 2026 14:11:13 -0400
Subject: [PATCH 13/14] fix(binary): cap pre-allocation to prevent OOM

A malformed delta header claiming a huge modified size
could cause an instant OOM.

Cap the pre-allocation at 64 KiB,
and let the vec grow organically from actual instructions.
---
 src/binary/delta.rs | 2 +-
 src/binary/mod.rs   | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/binary/delta.rs b/src/binary/delta.rs
index 7580e92d..7ab42bf6 100644
--- a/src/binary/delta.rs
+++ b/src/binary/delta.rs
@@ -24,7 +24,7 @@ pub fn apply(original: &[u8], delta: &[u8]) -> Result<Vec<u8>, DeltaError> {
         });
     }
 
-    let mut result = Vec::with_capacity(header_mod_size as usize);
+    let mut result = Vec::with_capacity(header_mod_size.min(super::MAX_PREALLOC) as usize);
 
     // Process instructions until we've consumed all delta data
     while !cursor.is_empty() {
diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index d82fe3bb..6c85d35e 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -12,6 +12,13 @@ mod delta;
 
 use std::{fmt, ops::Range};
 
+/// Cap preallocation when the size comes from untrusted input.
+///
+/// This prevents instant OOM from a bogus header.
+/// The vec grows as needed if the actual output is larger.
+#[cfg(feature = "binary")]
+const MAX_PREALLOC: u64 = 64 * 1024; // 64 KiB
+
 /// The type of a binary patch block.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryBlockKind {
@@ -113,7 +120,7 @@ impl<'a> BinaryPatch<'a> {
         let compressed = decode_base85_lines(binary_data.data)?;
 
         let mut decoder = flate2::read::ZlibDecoder::new(&compressed[..]);
-        let mut decompressed = Vec::new();
+        let mut decompressed = Vec::with_capacity(binary_data.size.min(MAX_PREALLOC) as usize);
         decoder
             .read_to_end(&mut decompressed)
             .map_err(|e| BinaryPatchParseErrorKind::DecompressionFailed(e.to_string()))?;

From 54f4e9516f23b98cbdaebee62a16a510708b2df3 Mon Sep 17 00:00:00 2001
From: Brandon Williams <bwilliamseng@gmail.com>
Date: Sun, 19 Apr 2026 19:33:25 -0500
Subject: [PATCH 14/14] binary: convert parse_binary_patch to take &[u8]

---
 src/binary/base85.rs   | 10 +++-----
 src/binary/mod.rs      | 55 +++++++++++++++++++++---------------------
 src/patch_set/parse.rs |  4 +--
 src/utils.rs           | 16 ------------
 4 files changed, 33 insertions(+), 52 deletions(-)

diff --git a/src/binary/base85.rs b/src/binary/base85.rs
index 182efe87..62cb832b 100644
--- a/src/binary/base85.rs
+++ b/src/binary/base85.rs
@@ -58,15 +58,13 @@ impl std::error::Error for Base85Error {}
 /// When decoding data where the original byte count isn't a multiple of 4,
 /// callers must handle truncation at a higher level.
 /// For example, via a length indicator in Git binary patch.
-pub fn decode_into(input: &str, output: &mut impl Extend<u8>) -> Result<(), Base85Error> {
-    let bytes = input.as_bytes();
-
-    if bytes.len() % 5 != 0 {
+pub fn decode_into(input: &[u8], output: &mut impl Extend<u8>) -> Result<(), Base85Error> {
+    if input.len() % 5 != 0 {
         return Err(Base85Error::InvalidLength);
     }
 
     // TODO: Use `as_chunks::<5>()` when MSRV >= 1.88
-    for chunk in bytes.chunks_exact(5) {
+    for chunk in input.chunks_exact(5) {
         let mut value: u32 = 0;
         for &byte in chunk {
             let digit = TABLE[byte as usize];
@@ -120,7 +118,7 @@ mod tests {
 
     fn decode(input: &str) -> Result<Vec<u8>, Base85Error> {
         let mut result = Vec::with_capacity((input.len() / 5) * 4);
-        decode_into(input, &mut result)?;
+        decode_into(input.as_bytes(), &mut result)?;
         Ok(result)
     }
 
diff --git a/src/binary/mod.rs b/src/binary/mod.rs
index 6c85d35e..e41226d8 100644
--- a/src/binary/mod.rs
+++ b/src/binary/mod.rs
@@ -141,7 +141,7 @@ impl<'a> BinaryPatch<'a> {
 ///
 /// For example, the following patch block
 ///
-/// * is parsed as `BinaryData { size: 10, data: "UcmV+l0QLU>0RjUA1qKHQ2>\`DEE&u=k" }`
+/// * is parsed as `BinaryData { size: 10, data: b"UcmV+l0QLU>0RjUA1qKHQ2>\`DEE&u=k" }`
 /// * The line starts with a length indicator (`U` = 21 decoded bytes)
 ///
 ///
@@ -154,7 +154,7 @@ pub struct BinaryData<'a> {
     /// Uncompressed size in bytes.
     pub size: u64,
     /// Raw Base85 lines with length indicators.
-    pub data: &'a str,
+    pub data: &'a [u8],
 }
 
 /// Error type for binary patch operations.
@@ -284,12 +284,12 @@ impl fmt::Display for BinaryPatchParseErrorKind {
 
 /// Simple streaming parser for binary patches.
 struct BinaryParser<'a> {
-    input: &'a str,
+    input: &'a [u8],
     offset: usize,
 }
 
 impl<'a> BinaryParser<'a> {
-    fn new(input: &'a str) -> Self {
+    fn new(input: &'a [u8]) -> Self {
         Self { input, offset: 0 }
     }
 
@@ -298,17 +298,17 @@ impl<'a> BinaryParser<'a> {
         BinaryPatchParseError::new(kind, self.offset..self.offset)
     }
 
-    fn next_line(&mut self) -> Option<&'a str> {
+    fn next_line(&mut self) -> Option<&'a [u8]> {
         let rest = &self.input[self.offset..];
         if rest.is_empty() {
             return None;
         }
-        let (line, skip) = match rest.find('\n') {
+        let (line, skip) = match rest.iter().position(|&b| b == b'\n') {
             Some(pos) => (&rest[..pos], pos + 1),
             None => (rest, rest.len()),
         };
         self.offset += skip;
-        Some(line.strip_suffix('\r').unwrap_or(line))
+        Some(line.strip_suffix(b"\r").unwrap_or(line))
     }
 }
 
@@ -328,12 +328,12 @@ impl<'a> BinaryParser<'a> {
 /// <base85_lines>
 /// ```
 pub(crate) fn parse_binary_patch(
-    input: &str,
+    input: &[u8],
 ) -> Result<(BinaryPatch<'_>, usize), BinaryPatchParseError> {
     let mut parser = BinaryParser::new(input);
 
     // Expect "GIT binary patch" marker
-    if parser.next_line() != Some("GIT binary patch") {
+    if parser.next_line() != Some(b"GIT binary patch".as_slice()) {
         return Err(parser.error(BinaryPatchParseErrorKind::InvalidHeader));
     }
 
@@ -356,12 +356,14 @@ pub(crate) fn parse_binary_patch(
 fn parse_binary_block<'a>(parser: &mut BinaryParser<'a>) -> Option<BinaryBlock<'a>> {
     // Parse "literal 10" or "delta 18"
     let format_line = parser.next_line()?;
-    let (patch_type, size_str) = format_line.split_once(' ')?;
+    let space = format_line.iter().position(|&b| b == b' ')?;
+    let (patch_type, rest) = format_line.split_at(space);
+    let size_str = std::str::from_utf8(&rest[1..]).ok()?;
     let size: u64 = size_str.parse().ok()?;
 
     let kind = match patch_type {
-        "literal" => BinaryBlockKind::Literal,
-        "delta" => BinaryBlockKind::Delta,
+        b"literal" => BinaryBlockKind::Literal,
+        b"delta" => BinaryBlockKind::Delta,
         _ => return None,
     };
 
@@ -378,8 +380,8 @@ fn parse_binary_block<'a>(parser: &mut BinaryParser<'a>) -> Option<BinaryBlock<'
     // Slice the data lines, stripping the final line ending.
     let data = &parser.input[data_start..data_end];
     let data = data
-        .strip_suffix("\r\n")
-        .or_else(|| data.strip_suffix('\n'))
+        .strip_suffix(b"\r\n".as_slice())
+        .or_else(|| data.strip_suffix(b"\n".as_slice()))
         .unwrap_or(data);
 
     Some(BinaryBlock {
@@ -402,18 +404,17 @@ fn parse_binary_block<'a>(parser: &mut BinaryParser<'a>) -> Option<BinaryBlock<'
 /// >     This encodes the length of the (pre-encoded) data written on this line.
 /// >  * `data` is Base85-encoded data for this line.
 #[cfg(feature = "binary")]
-fn decode_base85_lines(data: &str) -> Result<Vec<u8>, BinaryPatchParseError> {
+fn decode_base85_lines(data: &[u8]) -> Result<Vec<u8>, BinaryPatchParseError> {
     // A rough estimate: In Base85, 5 chars -> 4 bytes
     let mut result = Vec::with_capacity(data.len() * 4 / 5);
 
-    for line in data.lines() {
+    for line in data.split(|&b| b == b'\n') {
+        let line = line.strip_suffix(b"\r".as_slice()).unwrap_or(line);
         if line.is_empty() {
             continue;
         }
 
-        let line_bytes = line.as_bytes();
-
-        let length = decode_line_length(line_bytes[0])
+        let length = decode_line_length(line[0])
             .ok_or(BinaryPatchParseErrorKind::InvalidLineLengthIndicator)?;
         let encoded = &line[1..];
         let start = result.len();
@@ -450,7 +451,7 @@ mod tests {
 
     #[test]
     fn parse_literal_format_simple() {
-        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let input = b"GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
         let (patch, consumed) = parse_binary_patch(input).unwrap();
 
         assert_eq!(consumed, input.len());
@@ -467,7 +468,7 @@ mod tests {
 
     #[test]
     fn parse_delta_format() {
-        let input = "GIT binary patch\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^BFm9#}av-trB0zxAOrvLx|\n\n";
+        let input = b"GIT binary patch\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^BFm9#}av-trB0zxAOrvLx|\n\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
         match &patch {
@@ -484,14 +485,14 @@ mod tests {
     #[test]
     fn parse_invalid_header() {
         // Without "GIT binary patch" marker, parse_binary_patch returns error
-        let input = "literal 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\n";
+        let input = b"literal 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\n";
         let err = parse_binary_patch(input).unwrap_err();
         assert_eq!(err.kind, BinaryPatchParseErrorKind::InvalidHeader);
     }
 
     #[test]
     fn parse_with_crlf_line_endings() {
-        let input = "GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
+        let input = b"GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
         let (patch, consumed) = parse_binary_patch(input).unwrap();
 
         assert_eq!(consumed, input.len());
@@ -509,7 +510,7 @@ mod tests {
     #[test]
     fn parse_mixed_format() {
         // Git can use different encoding for each direction
-        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\n";
+        let input = b"GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\ndelta 18\nccmV+t0PX*P2!IH%^Z^9`00000v-trB0x!=5aR2}S\n\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
         match &patch {
@@ -550,7 +551,7 @@ mod apply_tests {
 
     #[test]
     fn apply_literal_patch() {
-        let input = "GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let input = b"GIT binary patch\nliteral 10\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
         let modified = patch.apply(&[]).unwrap();
@@ -564,7 +565,7 @@ mod apply_tests {
     #[test]
     fn literal_size_mismatch() {
         // Declared size 99 but actual decompressed data is 10 bytes.
-        let input = "GIT binary patch\nliteral 99\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
+        let input = b"GIT binary patch\nliteral 99\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\n\nliteral 0\nKcmV+b0RR6000031\n\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
         let err = patch.apply(&[]).unwrap_err();
@@ -579,7 +580,7 @@ mod apply_tests {
 
     #[test]
     fn apply_with_crlf_line_endings() {
-        let input = "GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
+        let input = b"GIT binary patch\r\nliteral 10\r\nUcmV+l0QLU>0RjUA1qKHQ2>`DEE&u=k\r\n\r\nliteral 0\r\nKcmV+b0RR6000031\r\n\r\n";
         let (patch, _) = parse_binary_patch(input).unwrap();
 
         let modified = patch.apply(&[]).unwrap();
diff --git a/src/patch_set/parse.rs b/src/patch_set/parse.rs
index e552e647..a72b8234 100644
--- a/src/patch_set/parse.rs
+++ b/src/patch_set/parse.rs
@@ -255,9 +255,7 @@ fn next_gitdiff_patch<'a, T: Text + ?Sized>(
         // GitHeader::parse consumed the marker line but not the payload.
         // Use the recorded offset to pass input from the marker onward.
         let (_, binary_input) = ps.input.split_at(abs_patch_start + binary_patch_start);
-        // Binary patch data is always ASCII (base85-encoded).
-        let binary_input = binary_input.as_str_prefix();
-        let (binary_patch, consumed) = match parse_binary_patch(binary_input) {
+        let (binary_patch, consumed) = match parse_binary_patch(binary_input.as_bytes()) {
             Ok(result) => result,
             Err(e) => return Some(Err(e.into())),
         };
diff --git a/src/utils.rs b/src/utils.rs
index e337e6cd..c4914566 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -144,11 +144,6 @@ pub trait Text: Eq + Hash + ToOwned {
     fn find(&self, needle: &str) -> Option<usize>;
     fn split_at(&self, mid: usize) -> (&Self, &Self);
     fn as_str(&self) -> Option<&str>;
-    /// Returns the longest valid UTF-8 prefix.
-    ///
-    /// For `str` this is the entire input.
-    /// For `[u8]` this returns up to the first invalid UTF-8 byte.
-    fn as_str_prefix(&self) -> &str;
     fn as_bytes(&self) -> &[u8];
     #[allow(unused)]
     fn lines(&self) -> LineIter<'_, Self>;
@@ -210,10 +205,6 @@ impl Text for str {
         Some(self)
     }
 
-    fn as_str_prefix(&self) -> &str {
-        self
-    }
-
     fn as_bytes(&self) -> &[u8] {
         self.as_bytes()
     }
@@ -268,13 +259,6 @@ impl Text for [u8] {
         std::str::from_utf8(self).ok()
     }
 
-    fn as_str_prefix(&self) -> &str {
-        match std::str::from_utf8(self) {
-            Ok(s) => s,
-            Err(e) => std::str::from_utf8(&self[..e.valid_up_to()]).unwrap(),
-        }
-    }
-
     fn as_bytes(&self) -> &[u8] {
         self
     }