fix: clear compressType label when single-format diff stores raw payload

HDiffPatch v5's single-format writer keeps the lzma2 compressType label
even when compression would expand the payload and it falls back to raw
storage (compressedSize==0). Old deployed decoders (HDiffPatch ~4.x, e.g.
react-native-update's vendored hpatch) decide whether to decompress from
the label alone, so they lzma2-decode raw bytes and fail with patch error
-4 — any tiny diff between near-identical bundles bricked the diff channel
on every fielded client.

diff()/diffWindow()/diffSingleStream() now post-normalize their output:
when the parsed header says compressedSize==0 with a non-empty label, the
label bytes are spliced out of the header (payload and all other fields
are byte-identical), restoring 1.x-compatible output. A shared helper
validates the HDIFFSF20& prefix and computes splice offsets for both the
in-memory and file paths. diffStream (HDIFF13) is unaffected: that format
carries per-stream sizes and old decoders already judge by compressedSize.

Tests: tiny raw-stored diffs assert an empty-label header and round-trip
via patch()/patchSingleStream() across all three writers; a compressible
case asserts the lzma2 label is kept. Cross-verified externally against
react-native-update's unpatched vendored decoder.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sunnylqm

src/hdiff.cpp

@@ -1,6 +1,8 @@
 #include "hdiff.h"
 #include "../HDiffPatch/libHDiffPatch/HDiff/diff.h"
+#include "../HDiffPatch/libHDiffPatch/HPatch/patch.h"
 #include "../HDiffPatch/file_for_patch.h"
+#include <cstring>
 #include <stdexcept>
 
 #define _CompressPlugin_lzma2
@@ -28,6 +30,8 @@ namespace {
     // 显式固定为旧值,保证与既有版本产出行为连续。
     const int kSingleMatchScore = 3;
     const size_t kPatchStepMemSize = 1024 * 256;
+    const char kSingleDiffPrefix[] = "HDIFFSF20&";
+    const size_t kSingleDiffPrefixSize = sizeof(kSingleDiffPrefix) - 1;
 
     struct FileStreamGuard {
         hpatch_TFileStreamInput oldStream{};
@@ -99,6 +103,155 @@ namespace {
             }
         }
     };
+
+    struct FileRewriteGuard {
+        hpatch_TFileStreamOutput stream{};
+        bool opened = false;
+
+        FileRewriteGuard() {
+            hpatch_TFileStreamOutput_init(&stream);
+        }
+        ~FileRewriteGuard() {
+            if (opened) hpatch_TFileStreamOutput_close(&stream);
+        }
+        void open(const char* path) {
+            if (!hpatch_TFileStreamOutput_reopen(&stream, path, ~(hpatch_StreamPos_t)0)) {
+                throw std::runtime_error("open diff file for rewrite failed.");
+            }
+            opened = true;
+            hpatch_TFileStreamOutput_setRandomOut(&stream, hpatch_TRUE);
+        }
+        void close() {
+            opened = false;
+            if (!hpatch_TFileStreamOutput_close(&stream)) {
+                throw std::runtime_error("close diff file failed.");
+            }
+        }
+    };
+
+    bool should_clear_single_raw_compress_type(const hpatch_singleCompressedDiffInfo& diffInfo,
+                                               size_t* outTypeLen) {
+        if ((diffInfo.compressedSize != 0) || (diffInfo.compressType[0] == '\0')) {
+            return false;
+        }
+        *outTypeLen = std::strlen(diffInfo.compressType);
+        if (*outTypeLen == 0) {
+            return false;
+        }
+        return true;
+    }
+
+    struct SingleRawCompressTypeSplice {
+        bool shouldSplice = false;
+        hpatch_StreamPos_t readPos = 0;
+        hpatch_StreamPos_t writePos = 0;
+        hpatch_StreamPos_t newSize = 0;
+    };
+
+    SingleRawCompressTypeSplice get_single_raw_compress_type_splice(
+            const hpatch_singleCompressedDiffInfo& diffInfo,
+            hpatch_StreamPos_t diffSize,
+            const uint8_t* prefixBytes) {
+        size_t typeLen = 0;
+        if (!should_clear_single_raw_compress_type(diffInfo, &typeLen)) {
+            return {};
+        }
+        if ((diffSize < kSingleDiffPrefixSize + typeLen + 1) ||
+            (0 != std::memcmp(prefixBytes, kSingleDiffPrefix, kSingleDiffPrefixSize))) {
+            throw std::runtime_error("single diff header layout error.");
+        }
+
+        SingleRawCompressTypeSplice splice;
+        splice.shouldSplice = true;
+        splice.readPos = kSingleDiffPrefixSize + typeLen;
+        splice.writePos = kSingleDiffPrefixSize;
+        splice.newSize = diffSize - typeLen;
+        return splice;
+    }
+
+    void normalize_single_raw_compress_type(std::vector<uint8_t>& diff) {
+        hpatch_singleCompressedDiffInfo diffInfo;
+        if (!getSingleCompressedDiffInfo_mem(&diffInfo, diff.data(), diff.data() + diff.size())) {
+            throw std::runtime_error("getSingleCompressedDiffInfo_mem() failed, invalid diff data!");
+        }
+
+        SingleRawCompressTypeSplice splice = get_single_raw_compress_type_splice(
+            diffInfo, diff.size(), diff.data());
+        if (!splice.shouldSplice) {
+            return;
+        }
+        diff.erase(diff.begin() + (size_t)splice.writePos,
+                   diff.begin() + (size_t)splice.readPos);
+    }
+
+    void normalize_single_raw_compress_type(const char* diffPath) {
+        hpatch_TFileStreamInput diffIn;
+        hpatch_TFileStreamInput_init(&diffIn);
+        bool diffInOpened = false;
+
+        hpatch_singleCompressedDiffInfo diffInfo;
+        hpatch_StreamPos_t oldDiffSize = 0;
+        uint8_t prefixBytes[kSingleDiffPrefixSize];
+        try {
+            if (!hpatch_TFileStreamInput_open(&diffIn, diffPath)) {
+                throw std::runtime_error("open diff file for read failed.");
+            }
+            diffInOpened = true;
+            oldDiffSize = diffIn.base.streamSize;
+            if ((oldDiffSize < kSingleDiffPrefixSize) ||
+                !diffIn.base.read(&diffIn.base, 0, prefixBytes,
+                                  prefixBytes + kSingleDiffPrefixSize)) {
+                throw std::runtime_error("single diff header layout error.");
+            }
+            if (!getSingleCompressedDiffInfo(&diffInfo, &diffIn.base, 0)) {
+                throw std::runtime_error("getSingleCompressedDiffInfo() failed, invalid diff data!");
+            }
+        } catch (...) {
+            if (diffInOpened) hpatch_TFileStreamInput_close(&diffIn);
+            throw;
+        }
+        diffInOpened = false;
+        if (!hpatch_TFileStreamInput_close(&diffIn)) {
+            throw std::runtime_error("close diff file failed.");
+        }
+
+        SingleRawCompressTypeSplice splice = get_single_raw_compress_type_splice(
+            diffInfo, oldDiffSize, prefixBytes);
+        if (!splice.shouldSplice) {
+            return;
+        }
+
+        FileRewriteGuard diffOut;
+        diffOut.open(diffPath);
+
+        const size_t kBufSize = hpatch_kFileIOBufBetterSize;
+        std::vector<uint8_t> buf(kBufSize);
+        hpatch_StreamPos_t readPos = splice.readPos;
+        hpatch_StreamPos_t writePos = splice.writePos;
+        while (readPos < oldDiffSize) {
+            hpatch_StreamPos_t readLen = oldDiffSize - readPos;
+            if (readLen > (hpatch_StreamPos_t)buf.size()) {
+                readLen = (hpatch_StreamPos_t)buf.size();
+            }
+            if (!diffOut.stream.base.read_writed(&diffOut.stream.base, readPos,
+                                                 buf.data(), buf.data() + (size_t)readLen)) {
+                throw std::runtime_error("read diff file for rewrite failed.");
+            }
+            if (!diffOut.stream.base.write(&diffOut.stream.base, writePos,
+                                           buf.data(), buf.data() + (size_t)readLen)) {
+                throw std::runtime_error("rewrite diff file failed.");
+            }
+            readPos += readLen;
+            writePos += readLen;
+        }
+        if (!hpatch_TFileStreamOutput_flush(&diffOut.stream)) {
+            throw std::runtime_error("flush diff file failed.");
+        }
+        if (!hpatch_TFileStreamOutput_truncate(&diffOut.stream, splice.newSize)) {
+            throw std::runtime_error("truncate diff file failed.");
+        }
+        diffOut.close();
+    }
 }
 
 void hdiff(const uint8_t* old, size_t oldsize, const uint8_t* _new, size_t newsize,
@@ -110,6 +263,7 @@ void hdiff(const uint8_t* old, size_t oldsize, const uint8_t* _new, size_t newsi
     create_single_compressed_diff(_new, _new + newsize, old, old + oldsize, out_codeBuf,
                                   &compressPlugin.base, kPatchStepMemSize,
                                   kSingleMatchScore);
+    normalize_single_raw_compress_type(out_codeBuf);
 
     if (!check_single_compressed_diff(_new, _new + newsize, old, old + oldsize,
                                       out_codeBuf.data(),
@@ -173,6 +327,7 @@ void hdiff_window(const char* oldPath,const char* newPath,const char* outDiffPat
                                          kSingleMatchScore);
 
     streams.closeDiffOut();
+    normalize_single_raw_compress_type(outDiffPath);
     streams.openDiffIn(outDiffPath);
     if (!check_single_compressed_diff(&streams.newStream.base, &streams.oldStream.base,
                                       &streams.diffInStream.base, decompressPlugin)) {
@@ -200,6 +355,7 @@ void hdiff_single_stream(const char* oldPath,const char* newPath,const char* out
                                          kMatchBlockSize_default);
 
     streams.closeDiffOut();
+    normalize_single_raw_compress_type(outDiffPath);
     streams.openDiffIn(outDiffPath);
     if (!check_single_compressed_diff(&streams.newStream.base, &streams.oldStream.base,
                                       &streams.diffInStream.base, decompressPlugin)) {

test/test.js

@@ -5,6 +5,23 @@ var fs = require("fs");
 var path = require("path");
 var os = require("os");
 
+function deterministicBytes(size, seed) {
+  var out = Buffer.allocUnsafe(size);
+  var x = seed >>> 0;
+  for (var i = 0; i < out.length; ++i) {
+    x ^= x << 13;
+    x ^= x >>> 17;
+    x ^= x << 5;
+    out[i] = x & 0xff;
+  }
+  return out;
+}
+
+function assertHeaderPrefix(diffData, prefix) {
+  var expected = Buffer.from(prefix, "latin1");
+  assert.deepStrictEqual(diffData.subarray(0, expected.length), expected);
+}
+
 console.log("Test 1: diff + patch = original (sync)...");
 var oldData = crypto.randomBytes(40960);
 var newData = Buffer.concat([
@@ -52,7 +69,56 @@ var uint8Patched = hdiffpatch.patch(uint8Old, uint8Diff);
 assert.deepStrictEqual(Buffer.from(uint8Patched), newData);
 console.log("  ✓ Uint8Array works");
 
-console.log("\nTest 5: diffSingleStream (single format, low-memory generation)...");
+console.log("\nTest 5: raw single-format diffs clear compressType...");
+var tinyOld = deterministicBytes(280 * 1024, 0x12345678);
+var tinyNew = Buffer.from(tinyOld);
+for (var i = 0; i < 17; ++i) {
+  tinyNew[Math.floor(tinyNew.length / 2) + i] ^= i + 1;
+}
+var tinyDiff = hdiffpatch.diff(tinyOld, tinyNew);
+assertHeaderPrefix(tinyDiff, "HDIFFSF20&\x00");
+assert.deepStrictEqual(hdiffpatch.patch(tinyOld, tinyDiff), tinyNew);
+
+var tinyDir = fs.mkdtempSync(path.join(os.tmpdir(), "hdiffpatch-raw-"));
+var tinyOldPath = path.join(tinyDir, "old.bin");
+var tinyNewPath = path.join(tinyDir, "new.bin");
+fs.writeFileSync(tinyOldPath, tinyOld);
+fs.writeFileSync(tinyNewPath, tinyNew);
+
+function assertRawLabelClearedForFileDiff(diffFn, name) {
+  var tinyDiffPath = path.join(tinyDir, name + ".diff");
+  var tinyOutPath = path.join(tinyDir, name + "-out.bin");
+  diffFn(tinyOldPath, tinyNewPath, tinyDiffPath);
+  var tinyFileDiff = fs.readFileSync(tinyDiffPath);
+  assertHeaderPrefix(tinyFileDiff, "HDIFFSF20&\x00");
+  assert.deepStrictEqual(hdiffpatch.patch(tinyOld, tinyFileDiff), tinyNew);
+  hdiffpatch.patchSingleStream(tinyOldPath, tinyDiffPath, tinyOutPath);
+  assert.deepStrictEqual(fs.readFileSync(tinyOutPath), tinyNew);
+}
+
+assertRawLabelClearedForFileDiff(
+  (oldPath, newPath, diffPath) =>
+    hdiffpatch.diffWindow(oldPath, newPath, diffPath, 8 * 1024 * 1024),
+  "window"
+);
+assertRawLabelClearedForFileDiff(hdiffpatch.diffSingleStream, "single");
+fs.rmSync(tinyDir, { recursive: true, force: true });
+console.log("  ✓ diff(), diffWindow(), and diffSingleStream() clear raw payload labels");
+
+console.log("\nTest 5a: compressed single-format diffs keep compressType...");
+var compressibleOld = deterministicBytes(280 * 1024, 0x9abcdef0);
+var repeated = Buffer.alloc(64 * 1024, "A");
+var compressibleNew = Buffer.concat([
+  compressibleOld.subarray(0, 128 * 1024),
+  repeated,
+  compressibleOld.subarray(128 * 1024)
+]);
+var compressibleDiff = hdiffpatch.diff(compressibleOld, compressibleNew);
+assertHeaderPrefix(compressibleDiff, "HDIFFSF20&lzma2\x00");
+assert.deepStrictEqual(hdiffpatch.patch(compressibleOld, compressibleDiff), compressibleNew);
+console.log("  ✓ lzma2 label remains when compression is used");
+
+console.log("\nTest 5b: diffSingleStream (single format, low-memory generation)...");
 var ssDir = fs.mkdtempSync(path.join(os.tmpdir(), "hdiffpatch-ss-"));
 var ssOldPath = path.join(ssDir, "old.bin");
 var ssNewPath = path.join(ssDir, "new.bin");
@@ -70,7 +136,7 @@ hdiffpatch.patchSingleStream(ssOldPath, ssDiffPath, ssOutPath);
 assert.deepStrictEqual(fs.readFileSync(ssOutPath), newData);
 console.log("  ✓ diffSingleStream output applies via patch() and patchSingleStream()");
 
-console.log("\nTest 5b: diffWindow (single format, window/fast-match generation)...");
+console.log("\nTest 5c: diffWindow (single format, window/fast-match generation)...");
 var winDiffPath = path.join(ssDir, "win.diff");
 var winOutPath = path.join(ssDir, "win-out.bin");
 var winDiffOut = hdiffpatch.diffWindow(ssOldPath, ssNewPath, winDiffPath);