fix(storage): re-resolve merge conflicts from main

The initial merge left unresolved conflict markers and didn't account
for main's []*BuildMap → []BuildMap migration (PR #2319) or the
simplified mapping resolution (PR #2318). This properly reconciles
our compression branch (FrameTable support, BuildFiles, V4 format)
with those changes: value-type BuildMap slices, sort.Search lookup,
and ApplyFrames as a standalone function to avoid mixed receivers.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: levb

packages/orchestrator/pkg/sandbox/build_upload.go

@@ -200,7 +200,8 @@ func (p *PendingBuildInfo) applyToHeader(h *headers.Header, fileType string) err
 	// Track frame cursor per build to avoid O(N²) rescanning.
 	cursors := make(map[string]int)
 
-	for _, mapping := range h.Mapping {
+	for i := range h.Mapping {
+		mapping := &h.Mapping[i]
 		key := pendingBuildInfoKey(mapping.BuildId.String(), fileType)
 		info := p.get(key)
 
@@ -209,7 +210,7 @@ func (p *PendingBuildInfo) applyToHeader(h *headers.Header, fileType string) err
 		}
 
 		cursor := cursors[key]
-		next, err := mapping.SetFrames(info.ft, cursor)
+		next, err := headers.ApplyFrames(mapping, info.ft, cursor)
 		if err != nil {
 			return fmt.Errorf("apply frames to mapping at offset %d for build %s: %w",
 				mapping.Offset, mapping.BuildId.String(), err)

packages/shared/pkg/storage/header/mapping.go

@@ -22,22 +22,12 @@ type BuildMap struct {
 	FrameTable         *storage.FrameTable
 }
 
-<<<<<<< HEAD
-func (mapping *BuildMap) Copy() *BuildMap {
-	return &BuildMap{
-		Offset:             mapping.Offset,
-		Length:             mapping.Length,
-		BuildId:            mapping.BuildId,
-		BuildStorageOffset: mapping.BuildStorageOffset,
-		FrameTable:         mapping.FrameTable,
-	}
-}
-
-// SetFrames associates compression frame information with this mapping,
-// starting the scan from frame index `from` and
-// returning the next cursor position. Use this when applying frames to a
-// sorted sequence of mappings to avoid O(N²) rescanning.
-func (mapping *BuildMap) SetFrames(frameTable *storage.FrameTable, from int) (int, error) {
+// setFrames associates compression frame information with mapping,
+// ApplyFrames extracts the FrameTable subset that covers mapping's storage range,
+// assigns it to mapping.FrameTable, and returns the next cursor position.
+// Use cursor-chaining when applying frames to a sorted sequence of mappings
+// to avoid O(N²) rescanning.
+func ApplyFrames(mapping *BuildMap, frameTable *storage.FrameTable, from int) (int, error) {
 	if frameTable == nil {
 		return from, nil
 	}
@@ -58,8 +48,6 @@ func (mapping *BuildMap) SetFrames(frameTable *storage.FrameTable, from int) (in
 	return next, nil
 }
 
-=======
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 func CreateMapping(
 	buildId *uuid.UUID,
 	dirty *bitset.BitSet,
@@ -114,15 +102,9 @@ func CreateMapping(
 //
 // It returns a new set of mappings that covers the whole size.
 func MergeMappings(
-<<<<<<< HEAD
-	baseMapping []*BuildMap,
-	diffMapping []*BuildMap,
-) ([]*BuildMap, error) {
-=======
 	baseMapping []BuildMap,
 	diffMapping []BuildMap,
-) []BuildMap {
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
+) ([]BuildMap, error) {
 	if len(diffMapping) == 0 {
 		return baseMapping, nil
 	}
@@ -195,24 +177,19 @@ func MergeMappings(
 			frameCursor := 0
 
 			if leftBaseLength > 0 {
-				mappings = append(mappings, BuildMap{
-					Offset:  base.Offset,
-					Length:  uint64(leftBaseLength),
-					BuildId: base.BuildId,
-					// the build storage offset is the same as the base mapping
+				leftBase := BuildMap{
+					Offset:             base.Offset,
+					Length:             uint64(leftBaseLength),
+					BuildId:            base.BuildId,
 					BuildStorageOffset: base.BuildStorageOffset,
-<<<<<<< HEAD
 				}
 				var err error
-				frameCursor, err = leftBase.SetFrames(base.FrameTable, 0)
+				frameCursor, err = ApplyFrames(&leftBase, base.FrameTable, 0)
 				if err != nil {
 					return nil, fmt.Errorf("set frames for left split at offset %d: %w", leftBase.Offset, err)
 				}
 
 				mappings = append(mappings, leftBase)
-=======
-				})
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 			}
 
 			mappings = append(mappings, diff)
@@ -223,20 +200,17 @@ func MergeMappings(
 			rightBaseLength := int64(base.Length) - rightBaseShift
 
 			if rightBaseLength > 0 {
-				baseMapping[baseIdx] = BuildMap{
+				rightBase := BuildMap{
 					Offset:             base.Offset + uint64(rightBaseShift),
 					Length:             uint64(rightBaseLength),
 					BuildId:            base.BuildId,
 					BuildStorageOffset: base.BuildStorageOffset + uint64(rightBaseShift),
 				}
-<<<<<<< HEAD
-				if _, err := rightBase.SetFrames(base.FrameTable, frameCursor); err != nil {
+				if _, err := ApplyFrames(&rightBase, base.FrameTable, frameCursor); err != nil {
 					return nil, fmt.Errorf("set frames for right split at offset %d: %w", rightBase.Offset, err)
 				}
 
 				baseMapping[baseIdx] = rightBase
-=======
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 			} else {
 				baseIdx++
 			}
@@ -256,20 +230,17 @@ func MergeMappings(
 			rightBaseLength := int64(base.Length) - rightBaseShift
 
 			if rightBaseLength > 0 {
-				baseMapping[baseIdx] = BuildMap{
+				rightBase := BuildMap{
 					Offset:             base.Offset + uint64(rightBaseShift),
 					Length:             uint64(rightBaseLength),
 					BuildId:            base.BuildId,
 					BuildStorageOffset: base.BuildStorageOffset + uint64(rightBaseShift),
 				}
-<<<<<<< HEAD
-				if _, err := rightBase.SetFrames(base.FrameTable, 0); err != nil {
+				if _, err := ApplyFrames(&rightBase, base.FrameTable, 0); err != nil {
 					return nil, fmt.Errorf("set frames for right split at offset %d: %w", rightBase.Offset, err)
 				}
 
 				baseMapping[baseIdx] = rightBase
-=======
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 			} else {
 				baseIdx++
 			}
@@ -283,21 +254,17 @@ func MergeMappings(
 			leftBaseLength := int64(diff.Offset) - int64(base.Offset)
 
 			if leftBaseLength > 0 {
-				mappings = append(mappings, BuildMap{
+				leftBase := BuildMap{
 					Offset:             base.Offset,
 					Length:             uint64(leftBaseLength),
 					BuildId:            base.BuildId,
 					BuildStorageOffset: base.BuildStorageOffset,
-<<<<<<< HEAD
 				}
-				if _, err := leftBase.SetFrames(base.FrameTable, 0); err != nil {
+				if _, err := ApplyFrames(&leftBase, base.FrameTable, 0); err != nil {
 					return nil, fmt.Errorf("set frames for left split at offset %d: %w", leftBase.Offset, err)
 				}
 
 				mappings = append(mappings, leftBase)
-=======
-				})
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 			}
 
 			baseIdx++
@@ -315,55 +282,34 @@ func MergeMappings(
 }
 
 // NormalizeMappings joins adjacent mappings that have the same buildId.
-<<<<<<< HEAD
 // When merging mappings, FrameTables are also merged by extending the first
 // mapping's FrameTable with frames from subsequent mappings.
-func NormalizeMappings(mappings []*BuildMap) []*BuildMap {
-=======
 func NormalizeMappings(mappings []BuildMap) []BuildMap {
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 	if len(mappings) == 0 {
 		return nil
 	}
 
 	result := make([]BuildMap, 0, len(mappings))
 
-<<<<<<< HEAD
-	// Start with a copy of the first mapping (Copy() now includes FrameTable)
-	current := mappings[0].Copy()
+	current := mappings[0]
 
 	for i := 1; i < len(mappings); i++ {
 		mp := mappings[i]
 		if mp.BuildId != current.BuildId {
-			// BuildId changed, add the current map to results and start a new one
 			result = append(result, current)
-			current = mp.Copy() // New copy (includes FrameTable)
+			current = mp
 		} else {
 			// Same BuildId, merge: add the length and extend FrameTable
 			current.Length += mp.Length
 
 			// Extend FrameTable if the mapping being merged has one
 			if mp.FrameTable != nil {
 				if current.FrameTable == nil {
-					// Current has no FrameTable but merged one does - take it
 					current.FrameTable = mp.FrameTable
 				} else {
-					// Both have FrameTables - extend current's with mp's frames
-					// The frames are contiguous subsets, so we append non-overlapping frames
 					current.FrameTable = mergeFrameTables(current.FrameTable, mp.FrameTable)
 				}
 			}
-=======
-	current := mappings[0]
-
-	for i := 1; i < len(mappings); i++ {
-		mp := mappings[i]
-		if mp.BuildId == current.BuildId {
-			current.Length += mp.Length
-		} else {
-			result = append(result, current)
-			current = mp
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
 		}
 	}
 

packages/shared/pkg/storage/header/mapping_test.go

@@ -727,7 +727,7 @@ func makeFrameTable(n int, frameU, frameC int32) *storage.FrameTable {
 	return ft
 }
 
-func assertFrameTable(t *testing.T, label string, m *BuildMap, startU, startC int64, nFrames int, frameU, frameC int32) {
+func assertFrameTable(t *testing.T, label string, m BuildMap, startU, startC int64, nFrames int, frameU, frameC int32) {
 	t.Helper()
 
 	require.NotNil(t, m.FrameTable, "%s: FrameTable should not be nil", label)
@@ -756,21 +756,21 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 	baseFT := makeFrameTable(6, frameU, frameC)
 
 	tests := map[string]struct {
-		base     []*BuildMap
-		diff     []*BuildMap
-		validate func(t *testing.T, merged []*BuildMap)
+		base     []BuildMap
+		diff     []BuildMap
+		validate func(t *testing.T, merged []BuildMap)
 	}{
 		"diff inside base — left and right get correct frame subsets": {
-			base: []*BuildMap{{
+			base: []BuildMap{{
 				Offset: 0, Length: 6 * blockSize,
 				BuildId: compBaseID, BuildStorageOffset: 0,
 				FrameTable: baseFT,
 			}},
-			diff: []*BuildMap{{
+			diff: []BuildMap{{
 				Offset: 2 * blockSize, Length: 2 * blockSize,
 				BuildId: compDiffID,
 			}},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				require.Len(t, m, 3)
 
@@ -788,19 +788,19 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 		},
 
 		"base after diff with overlap — right split keeps tail frames": {
-			base: []*BuildMap{
+			base: []BuildMap{
 				{Offset: 0, Length: 1 * blockSize, BuildId: plainID},
 				{
 					Offset: 1 * blockSize, Length: 4 * blockSize,
 					BuildId: compBaseID, BuildStorageOffset: 0,
 					FrameTable: makeFrameTable(4, frameU, frameC),
 				},
 			},
-			diff: []*BuildMap{{
+			diff: []BuildMap{{
 				Offset: 0, Length: 3 * blockSize,
 				BuildId: compDiffID,
 			}},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				require.Len(t, m, 2)
 
@@ -814,19 +814,19 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 		},
 
 		"diff after base with overlap — left split keeps head frames": {
-			base: []*BuildMap{
+			base: []BuildMap{
 				{
 					Offset: 0, Length: 4 * blockSize,
 					BuildId: compBaseID, BuildStorageOffset: 0,
 					FrameTable: makeFrameTable(4, frameU, frameC),
 				},
 				{Offset: 4 * blockSize, Length: 2 * blockSize, BuildId: plainID},
 			},
-			diff: []*BuildMap{{
+			diff: []BuildMap{{
 				Offset: 2 * blockSize, Length: 4 * blockSize,
 				BuildId: compDiffID,
 			}},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				require.Len(t, m, 2)
 
@@ -839,16 +839,16 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 		},
 
 		"two diffs split same base into three pieces": {
-			base: []*BuildMap{{
+			base: []BuildMap{{
 				Offset: 0, Length: 6 * blockSize,
 				BuildId: compBaseID, BuildStorageOffset: 0,
 				FrameTable: baseFT,
 			}},
-			diff: []*BuildMap{
+			diff: []BuildMap{
 				{Offset: 1 * blockSize, Length: 1 * blockSize, BuildId: compDiffID},
 				{Offset: 4 * blockSize, Length: 1 * blockSize, BuildId: compDiffID},
 			},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				require.Len(t, m, 5)
 
@@ -863,15 +863,15 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 		},
 
 		"nil FrameTable base — splits work without frames": {
-			base: []*BuildMap{{
+			base: []BuildMap{{
 				Offset: 0, Length: 4 * blockSize,
 				BuildId: compBaseID, BuildStorageOffset: 0,
 			}},
-			diff: []*BuildMap{{
+			diff: []BuildMap{{
 				Offset: 1 * blockSize, Length: 2 * blockSize,
 				BuildId: compDiffID,
 			}},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				require.Len(t, m, 3)
 				assert.Nil(t, m[0].FrameTable)
@@ -883,12 +883,12 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 			// Simulates a real multi-layer header: three builds (A, B, C) each
 			// with their own FrameTable. A diff lands inside build B, splitting
 			// it. Builds A and C must pass through with FrameTables intact.
-			base: func() []*BuildMap {
+			base: func() []BuildMap {
 				buildA := uuid.New()
 				buildB := compBaseID
 				buildC := uuid.New()
 
-				return []*BuildMap{
+				return []BuildMap{
 					{
 						Offset: 0, Length: 2 * blockSize,
 						BuildId: buildA, BuildStorageOffset: 0,
@@ -906,11 +906,11 @@ func TestMergeMappings_FrameTableSplits(t *testing.T) {
 					},
 				}
 			}(),
-			diff: []*BuildMap{{
+			diff: []BuildMap{{
 				Offset: 3 * blockSize, Length: 2 * blockSize,
 				BuildId: compDiffID,
 			}},
-			validate: func(t *testing.T, m []*BuildMap) {
+			validate: func(t *testing.T, m []BuildMap) {
 				t.Helper()
 				// Expected: A(untouched) | B-left[0..1) | diff | B-right[3..4) | C(untouched)
 				require.Len(t, m, 5)

packages/shared/pkg/storage/header/metadata.go

@@ -82,11 +82,7 @@ type DiffMetadata struct {
 func (d *DiffMetadata) toDiffMapping(
 	ctx context.Context,
 	buildID uuid.UUID,
-<<<<<<< HEAD
-) ([]*BuildMap, error) {
-=======
-) (mapping []BuildMap) {
->>>>>>> f98f20f7d1f207b34d12f6e8b570e4c10c35aa31
+) ([]BuildMap, error) {
 	dirtyMappings := CreateMapping(
 		&buildID,
 		d.Dirty,