fix: remove 100-chunk limit and isBlank skip in nullseed

Remove the 100-chunk limit in LongestMatchWith for non-reflink filesystems.
Also remove the isBlank optimization that skipped writing zeros entirely.

The isBlank skip relied on Truncate providing zeros, but on APFS (macOS)
Truncate creates sparse holes. When concurrent assembly workers write
adjacent chunks while the null seed skips its region, the file content
becomes non-deterministic. Always writing explicit zeros is safe on all
platforms and avoids this race condition.

Add TestAssembleOver100NullChunks which creates a file with 110 consecutive
max-size null chunks sandwiched between random data, verifies SHA-256 of
the assembled output.

Author: nsakaimbo

assemble_test.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"crypto/md5"
 	"crypto/rand"
+	"crypto/sha256"
 	"io"
 	"os"
 	"path/filepath"
@@ -401,6 +402,81 @@ func join(slices ...[]byte) []byte {
 	return out
 }
 
+// TestAssembleOver100NullChunks verifies that assembly produces a correct file
+// when the index contains >100 consecutive null chunks. This reproduces a bug
+// where nullChunkSeed.LongestMatchWith capped matches at 100 on non-reflink
+// filesystems, causing overflow null chunks to fall through to writeChunk
+// where the isBlank optimization silently skipped adjacent non-null data.
+func TestAssembleOver100NullChunks(t *testing.T) {
+	// Build an input file: random data | >100 max-size null chunks | random data.
+	// The null region must exceed 100 * ChunkSizeMaxDefault to trigger the bug.
+	randBlock := make([]byte, 4*ChunkSizeMaxDefault)
+	rand.Read(randBlock)
+
+	nullBlock := make([]byte, 110*ChunkSizeMaxDefault) // 110 consecutive null chunks
+
+	var input []byte
+	input = append(input, randBlock...)
+	input = append(input, nullBlock...)
+	input = append(input, randBlock...)
+
+	// Write the input to a temp file
+	inFile, err := os.CreateTemp("", "nullchunk-input-*")
+	require.NoError(t, err)
+	defer os.Remove(inFile.Name())
+	_, err = inFile.Write(input)
+	require.NoError(t, err)
+	inFile.Close()
+
+	// Record the SHA-256 of the original
+	expectedSum := sha256.Sum256(input)
+
+	// Chunk the file to produce an index
+	index, _, err := IndexFromFile(
+		context.Background(),
+		inFile.Name(),
+		10,
+		ChunkSizeMinDefault, ChunkSizeAvgDefault, ChunkSizeMaxDefault,
+		NewProgressBar(""),
+	)
+	require.NoError(t, err)
+
+	// Verify the index actually contains >100 consecutive null chunks
+	nullID := NewNullChunk(ChunkSizeMaxDefault).ID
+	maxRun := 0
+	run := 0
+	for _, c := range index.Chunks {
+		if c.ID == nullID {
+			run++
+			if run > maxRun {
+				maxRun = run
+			}
+		} else {
+			run = 0
+		}
+	}
+	require.Greater(t, maxRun, 100, "test input must produce >100 consecutive null chunks")
+
+	// Chop the file into a local store
+	store := t.TempDir()
+	s, err := NewLocalStore(store, StoreOptions{})
+	require.NoError(t, err)
+	require.NoError(t, ChopFile(context.Background(), inFile.Name(), index.Chunks, s, 10, NewProgressBar("")))
+
+	// Assemble into a new (non-existing) file — isBlank=true path
+	outFile := filepath.Join(t.TempDir(), "output")
+	_, err = AssembleFile(context.Background(), outFile, index, s, nil,
+		AssembleOptions{10, InvalidSeedActionBailOut},
+	)
+	require.NoError(t, err)
+
+	// Compare SHA-256
+	assembled, err := os.ReadFile(outFile)
+	require.NoError(t, err)
+	actualSum := sha256.Sum256(assembled)
+	require.Equal(t, expectedSum, actualSum, "SHA-256 of assembled file must match original")
+}
+
 func readCaibxFile(t *testing.T, indexLocation string) (idx Index) {
 	is, err := NewLocalIndexStore(filepath.Dir(indexLocation))
 	require.NoError(t, err)

nullseed.go

@@ -46,17 +46,12 @@ func (s *nullChunkSeed) LongestMatchWith(chunks []IndexChunk) (int, SeedSegment)
 	if len(chunks) == 0 {
 		return 0, nil
 	}
-	var (
-		n     int
-		limit int
-	)
-	if !s.canReflink {
-		limit = 100
-	}
+	// No limit needed: when isBlank=true, WriteInto skips without copying.
+	// When isBlank=false, we must still write zeros to overwrite stale data.
+	// The previous limit of 100 caused chunks beyond the limit to fall
+	// through to other code paths, leading to incorrect assembly.
+	var n int
 	for _, c := range chunks {
-		if limit != 0 && limit == n {
-			break
-		}
 		if c.ID != s.id {
 			break
 		}
@@ -108,13 +103,12 @@ func (s *nullChunkSection) WriteInto(dst *os.File, offset, length, blocksize uin
 		return 0, 0, fmt.Errorf("unable to copy %d bytes to %s : wrong size", length, dst.Name())
 	}
 
-	// When cloning isn't available we'd normally have to copy the 0 bytes into
-	// the target range. But if that's already blank (because it's a new/truncated
-	// file) there's no need to copy 0 bytes.
+	// Always write explicit zeros rather than relying on truncation.
+	// On some filesystems (e.g., APFS), Truncate creates sparse holes that
+	// can interact poorly with concurrent assembly workers, leading to
+	// non-deterministic corruption. Writing zeros explicitly is safe on all
+	// platforms and avoids the race.
 	if !s.canReflink {
-		if isBlank {
-			return 0, 0, nil
-		}
 		return s.copy(dst, offset, s.Size())
 	}
 	return s.clone(dst, offset, length, blocksize)