feat!: upgrade vendored HDiffPatch to v5.0.1, add diffSingleStream

BREAKING CHANGE: diffWithCovers is removed. It had no consumers (the HBC
transform pipeline ended up not using covers), and dropping it lets the
HDiffPatch submodule track pure upstream (v5.0.1, vendor/v5.0.1 branch on
the fork) with no custom patches to carry forward. lzma submodule moves
to v26.02 to match (new Z7_ST macro defined alongside _7ZIP_ST).

New API: diffSingleStream(oldPath, newPath, outDiffPath[, cb]) — streaming
block-match generation of the SAME single format diff() emits. Generation
memory stays O(match block): 100MB inputs measured at ~27MB RSS delta
(in-memory diff would need ~600MB). Output verified byte-exact through
the legacy v3.1.1 client patch core, so already-shipped clients can apply
these patches without any update.

Compat verified both ways: legacy-generated patches apply via v5 patch()
and v5-generated patches apply via the legacy prebuild; same-input patch
sizes are byte-identical and diff speed is unchanged. v5's default diff
progress printing is compiled out (_IS_OUT_DIFF_INFO=0) to keep server
worker logs clean. diff parameters are pinned to the historical values
(match score 3, step mem 256KB, lzma2 level 9 / 8MB dict / single thread)
so artifact characteristics stay continuous across the upgrade.

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

Author: sunnylqm

HDiffPatch

@@ -35,57 +35,21 @@ bun run test:bun   # run the same tests under the Bun runtime
 
 Compare two buffers and return a new hdiffpatch patch as return value.
 
-### diffWithCovers(originBuf, newBuf, covers[, options])
-
-Create a standard hdiffpatch patch while using caller-provided cover lines when
-possible. By default, the supplied covers replace HDiffPatch's internal cover
-selection.
-
-Each cover is `{ oldPos, newPos, len }`. Values may be numbers, decimal strings,
-or bigint values. The returned object is:
-
-```js
-{
-  diff: Buffer,
-  usedCovers: boolean,
-  requestedCoverCount: number,
-  nativeCoverCapacity: number,
-  finalCoverCount: number,
-  coverMode: 'replace' | 'merge' | 'native-coalesce',
-  nativeCovers?: HpatchCover[],
-  finalCovers?: HpatchCover[]
-}
-```
-
-The `diff` buffer is still a normal hdiffpatch payload and can be applied with
-`patch(originBuf, diff)` or an HDiffPatch-compatible apply side.
-
-Set `options.mode` to `merge` to keep HDiffPatch's native covers and only add
-caller covers in new-file ranges not already covered by native covers:
-
-```js
-const merged = hdiff.diffWithCovers(oldBuf, newBuf, covers, { mode: 'merge' });
-```
-
-Set `options.mode` to `native-coalesce` to keep HDiffPatch's native cover
-selection but coalesce adjacent native covers that have the same old/new offset
-delta across small gaps. This remains a standard hdiffpatch payload and is useful
-as a costed post-processing experiment:
-
-```js
-const coalesced = hdiff.diffWithCovers(oldBuf, newBuf, [], {
-  mode: 'native-coalesce',
-});
-```
+### diffSingleStream(oldPath, newPath, outDiffPath[, cb])
 
-Set `options.debugCovers` to `true` to include the native HDiffPatch cover list
-and the final listener cover list in the return value. This is for diagnostics;
-the default return shape avoids copying cover arrays.
+Create a **single-format** (same wire format as `diff()`) patch by streaming
+file paths with block matching — generation memory stays O(match block)
+regardless of input size (100MB inputs use ~30MB RSS). The output applies with
+`patch()`, `patchSingleStream()`, and any existing HDiffPatch single-format
+apply side, so legacy clients need no changes. Patch size is larger than the
+in-memory `diff()` for the same inputs; prefer `diff()` when memory allows.
+In sync mode returns `outDiffPath`; async callback signature is
+`(err, outDiffPath)`.
 
 ### patchSingleStream(oldPath, diffPath, outNewPath[, cb])
 
-Apply a single-compressed hpatch payload created by `diff` or `diffWithCovers`
-from files. This is the file-level apply path for the normal in-memory `diff`
+Apply a single-compressed hpatch payload created by `diff` or
+`diffSingleStream` from files. This is the file-level apply path for the normal in-memory `diff`
 format. In sync mode returns `outNewPath`. In async mode, callback signature is
 `(err, outNewPath)`.
 
@@ -111,7 +75,7 @@ hdp patch <oldFile> <diffFile> <outNew>
 
 Note: `hdp patch` auto-detects the diff format by its header, so it can apply
 both streaming diffs created by `hdp diff` and single-compressed diffs created
-by the in-memory `diff()` / `diffWithCovers()` APIs.
+by the in-memory `diff()` / streaming `diffSingleStream()` APIs.
 
 ## License
 

README.md

@@ -17,6 +17,8 @@
         "HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/digest_matcher.cpp",
         "HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.cpp",
         "HDiffPatch/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c",
+        "HDiffPatch/libHDiffPatch/HDiff/private_diff/match_block.cpp",
+        "HDiffPatch/libHDiffPatch/HDiff/private_diff/match_inplace.cpp",
         "lzma/C/LzFind.c",
         "lzma/C/LzmaDec.c",
         "lzma/C/LzmaEnc.c",
@@ -26,7 +28,9 @@
       "defines": [
         "_IS_NEED_DIR_DIFF_PATCH=0",
         "_7ZIP_ST",
+        "Z7_ST",
         "_IS_USED_MULTITHREAD=0",
+        "_IS_OUT_DIFF_INFO=0",
         "NAPI_VERSION=8"
       ],
       "include_dirs" : [

binding.gyp

@@ -4,35 +4,10 @@ export type BinaryLike = Buffer | ArrayBufferView;
 
 export type DiffCallback = (err: Error | null, result?: Buffer) => void;
 export type StreamCallback = (err: Error | null, outPath?: string) => void;
-export type HpatchCover = {
-  oldPos: number | string | bigint;
-  newPos: number | string | bigint;
-  len: number | string | bigint;
-};
-export type DiffWithCoversResult = {
-  diff: Buffer;
-  usedCovers: boolean;
-  requestedCoverCount: number;
-  nativeCoverCapacity: number;
-  finalCoverCount: number;
-  coverMode: 'replace' | 'merge' | 'native-coalesce';
-  nativeCovers?: HpatchCover[];
-  finalCovers?: HpatchCover[];
-};
-export type DiffWithCoversOptions = {
-  mode?: 'replace' | 'merge' | 'native-coalesce' | 'native_coalesce';
-  debugCovers?: boolean;
-};
 
 export interface NativeAddon {
   diff(oldBuf: BinaryLike, newBuf: BinaryLike): Buffer;
   diff(oldBuf: BinaryLike, newBuf: BinaryLike, cb: DiffCallback): void;
-  diffWithCovers(
-    oldBuf: BinaryLike,
-    newBuf: BinaryLike,
-    covers: HpatchCover[],
-    options?: DiffWithCoversOptions
-  ): DiffWithCoversResult;
   patch(oldBuf: BinaryLike, diffBuf: BinaryLike): Buffer;
   patch(oldBuf: BinaryLike, diffBuf: BinaryLike, cb: DiffCallback): void;
   diffStream(oldPath: string, newPath: string, outDiffPath: string): string;
@@ -49,6 +24,13 @@ export interface NativeAddon {
     outNewPath: string,
     cb: StreamCallback
   ): void;
+  diffSingleStream(oldPath: string, newPath: string, outDiffPath: string): string;
+  diffSingleStream(
+    oldPath: string,
+    newPath: string,
+    outDiffPath: string,
+    cb: StreamCallback,
+  ): void;
   patchSingleStream(oldPath: string, diffPath: string, outNewPath: string): string;
   patchSingleStream(
     oldPath: string,
@@ -66,12 +48,6 @@ export function diff(
   newBuf: BinaryLike,
   cb: DiffCallback
 ): void;
-export function diffWithCovers(
-  oldBuf: BinaryLike,
-  newBuf: BinaryLike,
-  covers: HpatchCover[],
-  options?: DiffWithCoversOptions
-): DiffWithCoversResult;
 
 export function patch(oldBuf: BinaryLike, diffBuf: BinaryLike): Buffer;
 export function patch(
@@ -103,6 +79,17 @@ export function patchStream(
   outNewPath: string,
   cb: StreamCallback
 ): void;
+export function diffSingleStream(
+  oldPath: string,
+  newPath: string,
+  outDiffPath: string,
+): string;
+export function diffSingleStream(
+  oldPath: string,
+  newPath: string,
+  outDiffPath: string,
+  cb: StreamCallback,
+): void;
 export function patchSingleStream(
   oldPath: string,
   diffPath: string,
@@ -118,10 +105,10 @@ export function patchSingleStream(
 declare const hdiffpatch: {
   native: NativeAddon;
   diff: typeof diff;
-  diffWithCovers: typeof diffWithCovers;
   patch: typeof patch;
   diffStream: typeof diffStream;
   patchStream: typeof patchStream;
+  diffSingleStream: typeof diffSingleStream;
   patchSingleStream: typeof patchSingleStream;
 };
 

index.d.ts

@@ -32,8 +32,8 @@ const native = loadNative();
 exports.native = native;
 
 exports.diff = native.diff;
-exports.diffWithCovers = native.diffWithCovers;
 exports.patch = native.patch;
 exports.diffStream = native.diffStream;
 exports.patchStream = native.patchStream;
+exports.diffSingleStream = native.diffSingleStream;
 exports.patchSingleStream = native.patchSingleStream;

index.js

@@ -1,6 +1,6 @@
 {
   "name": "node-hdiffpatch",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "description": "hdiffpatch port to node.js",
   "main": "index.js",
   "types": "index.d.ts",