fix tests

bundle/bundle_test.go

···
 	"tangled.org/atscan.net/plcbundle/internal/types"
 )
 
+var (
+	bundleInfo = &storage.BundleInfo{
+		BundleNumber: 1,
+		Origin:       "test-origin",
+		ParentHash:   "",
+		Cursor:       "",
+		CreatedBy:    "test",
+		Hostname:     "test-host",
+	}
+)
+
 // TestIndex tests index operations
 func TestIndex(t *testing.T) {
+
 	t.Run("CreateNewIndex", func(t *testing.T) {
 		idx := bundleindex.NewIndex("test-origin")
 		if idx == nil {
···
 		path := filepath.Join(tmpDir, "test_bundle.jsonl.zst")
 
 		// Save
-		uncompHash, compHash, uncompSize, compSize, err := ops.SaveBundle(path, operations, nil)
+		uncompHash, compHash, uncompSize, compSize, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}

internal/storage/storage.go

···
 
 // SaveBundle saves operations with metadata containing RELATIVE frame offsets
 func (op *Operations) SaveBundle(path string, operations []plcclient.PLCOperation, bundleInfo *BundleInfo) (string, string, int64, int64, error) {
+	if bundleInfo == nil {
+		return "", "", 0, 0, fmt.Errorf("bundleInfo cannot be nil")
+	}
+
 	// 1. Calculate content
 	jsonlData := op.SerializeJSONL(operations)
 	contentSize := int64(len(jsonlData))
···
 		return nil, fmt.Errorf("failed to decompress: %w", err)
 	}
 
+	// DEFENSIVE: Validate we got actual data
+	if len(decompressed) == 0 {
+		return nil, fmt.Errorf("decompression produced empty result")
+	}
+
 	// Parse JSONL
-	return op.ParseJSONL(decompressed)
+	operations, err := op.ParseJSONL(decompressed)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse JSONL: %w", err)
+	}
+
+	// DEFENSIVE: Additional validation
+	if len(operations) == 0 {
+		return nil, fmt.Errorf("bundle contains no valid operations")
+	}
+
+	return operations, nil
 }
 
 // ========================================

internal/storage/storage_test.go

···
 	l.t.Log(v...)
 }
 
+var (
+	bundleInfo = &storage.BundleInfo{
+		BundleNumber: 1,
+		Origin:       "test-origin",
+		ParentHash:   "",
+		Cursor:       "",
+		CreatedBy:    "test",
+		Hostname:     "test-host",
+	}
+)
+
 // ====================================================================================
 // COMPRESSION TESTS
 // ====================================================================================
···
 				path := filepath.Join(tmpDir, tt.name+".jsonl.zst")
 
 				// Save
-				_, _, _, _, err := ops.SaveBundle(path, original, nil)
+				_, _, _, _, err := ops.SaveBundle(path, original, bundleInfo)
 				if err != nil {
 					t.Fatalf("SaveBundle failed: %v", err)
 				}
···
 		operations := makeTestOperations(10000)
 		path := filepath.Join(tmpDir, "compression_test.jsonl.zst")
 
-		_, _, uncompSize, compSize, err := ops.SaveBundle(path, operations, nil)
+		_, _, uncompSize, compSize, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 		operations := makeTestOperations(100)
 		path := filepath.Join(tmpDir, "integrity_test.jsonl.zst")
 
-		contentHash, compHash, _, _, err := ops.SaveBundle(path, operations, nil)
+		contentHash, compHash, _, _, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 		// Create test bundle
 		operations := makeTestOperations(10000)
 		path := filepath.Join(tmpDir, "parallel_test.jsonl.zst")
-		_, _, _, _, err := ops.SaveBundle(path, operations, nil)
+		_, _, _, _, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 		// Critical test - this is heavily used by DID lookups
 		operations := makeTestOperations(10000)
 		path := filepath.Join(tmpDir, "position_test.jsonl.zst")
-		_, _, _, _, err := ops.SaveBundle(path, operations, nil)
+		_, _, _, _, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 	t.Run("ConcurrentHashVerification", func(t *testing.T) {
 		operations := makeTestOperations(1000)
 		path := filepath.Join(tmpDir, "verify_test.jsonl.zst")
-		_, compHash, _, _, err := ops.SaveBundle(path, operations, nil)
+		_, compHash, _, _, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 	t.Run("TruncatedFile", func(t *testing.T) {
 		operations := makeTestOperations(100)
 		path := filepath.Join(tmpDir, "truncated.jsonl.zst")
-		ops.SaveBundle(path, operations, nil)
+		ops.SaveBundle(path, operations, bundleInfo)
 
 		// Read and truncate
 		data, _ := os.ReadFile(path)
···
 
 		// Manually compress invalid data
 		operations := makeTestOperations(10)
-		ops.SaveBundle(path, operations, nil) // Create valid file first
+		ops.SaveBundle(path, operations, bundleInfo) // Create valid file first
 
 		// Now corrupt it with invalid JSON
 		// This is hard to test properly since SaveBundle enforces valid data
···
 	t.Run("InvalidPosition", func(t *testing.T) {
 		operations := makeTestOperations(100)
 		path := filepath.Join(tmpDir, "position_test.jsonl.zst")
-		ops.SaveBundle(path, operations, nil)
+		ops.SaveBundle(path, operations, bundleInfo)
 
 		// Negative position
 		_, err := ops.LoadOperationAtPosition(path, -1)
···
 	t.Run("StreamRaw", func(t *testing.T) {
 		operations := makeTestOperations(100)
 		path := filepath.Join(tmpDir, "stream_raw.jsonl.zst")
-		_, _, _, _, err := ops.SaveBundle(path, operations, nil)
+		_, _, _, _, err := ops.SaveBundle(path, operations, bundleInfo)
 		if err != nil {
 			t.Fatalf("SaveBundle failed: %v", err)
 		}
···
 	t.Run("StreamDecompressed", func(t *testing.T) {
 		operations := makeTestOperations(100)
 		path := filepath.Join(tmpDir, "stream_decomp.jsonl.zst")
-		ops.SaveBundle(path, operations, nil)
+		ops.SaveBundle(path, operations, bundleInfo)
 
 		reader, err := ops.StreamDecompressed(path)
 		if err != nil {
···
 	b.Run("SaveBundle", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			path := filepath.Join(tmpDir, fmt.Sprintf("bench_%d.jsonl.zst", i))
-			ops.SaveBundle(path, operations, nil)
+			ops.SaveBundle(path, operations, bundleInfo)
 		}
 	})
 

server/server_test.go

···
 	l.t.Log(v...)
 }
 
+var (
+	bundleInfo = &storage.BundleInfo{
+		BundleNumber: 1,
+		Origin:       "test-origin",
+		ParentHash:   "",
+		Cursor:       "",
+		CreatedBy:    "test",
+		Hostname:     "test-host",
+	}
+)
+
 // ====================================================================================
 // HTTP ENDPOINT TESTS
 // ====================================================================================
···
 		path := filepath.Join(tmpDir, fmt.Sprintf("%06d.jsonl.zst", i))
 		ops := makeMinimalTestOperations(10000, i*10000) // Unique ops per bundle
 
-		contentHash, compHash, uncompSize, compSize, err := storageOps.SaveBundle(path, ops, nil)
+		contentHash, compHash, uncompSize, compSize, err := storageOps.SaveBundle(path, ops, bundleInfo)
 		if err != nil {
 			t.Fatalf("failed to save test bundle %d: %v", i, err)
 		}