diff --git a/internal/protobuild/build.go b/internal/protobuild/build.go
index 645f0c1..8790d5f 100644
--- a/internal/protobuild/build.go
+++ b/internal/protobuild/build.go
@@ -144,6 +144,8 @@
 		case pref.EnumKind:
 			v = fd.Enum().Values().ByName(pref.Name(o)).Number()
 		}
+	case []byte:
+		return pref.ValueOf(append([]byte{}, o...))
 	}
 	return pref.ValueOf(v)
 }
diff --git a/proto/merge_test.go b/proto/merge_test.go
index 01b998d..48d8a41 100644
--- a/proto/merge_test.go
+++ b/proto/merge_test.go
@@ -5,377 +5,657 @@
 package proto_test
 
 import (
+	"fmt"
 	"reflect"
 	"sync"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/encoding/prototext"
 	"google.golang.org/protobuf/internal/encoding/pack"
+	"google.golang.org/protobuf/internal/protobuild"
 	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/testing/protocmp"
+	"google.golang.org/protobuf/types/dynamicpb"
 
+	legacypb "google.golang.org/protobuf/internal/testprotos/legacy"
 	testpb "google.golang.org/protobuf/internal/testprotos/test"
 	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
 )
 
+type testMerge struct {
+	desc  string
+	dst   protobuild.Message
+	src   protobuild.Message
+	want  protobuild.Message // if dst and want are nil, want = src
+	types []proto.Message
+}
+
+var testMerges = []testMerge{{
+	desc: "clone a large message",
+	src: protobuild.Message{
+		"optional_int32":       1001,
+		"optional_int64":       1002,
+		"optional_uint32":      1003,
+		"optional_uint64":      1004,
+		"optional_sint32":      1005,
+		"optional_sint64":      1006,
+		"optional_fixed32":     1007,
+		"optional_fixed64":     1008,
+		"optional_sfixed32":    1009,
+		"optional_sfixed64":    1010,
+		"optional_float":       1011.5,
+		"optional_double":      1012.5,
+		"optional_bool":        true,
+		"optional_string":      "string",
+		"optional_bytes":       []byte("bytes"),
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 100,
+		},
+		"repeated_int32":       []int32{1001, 2001},
+		"repeated_int64":       []int64{1002, 2002},
+		"repeated_uint32":      []uint32{1003, 2003},
+		"repeated_uint64":      []uint64{1004, 2004},
+		"repeated_sint32":      []int32{1005, 2005},
+		"repeated_sint64":      []int64{1006, 2006},
+		"repeated_fixed32":     []uint32{1007, 2007},
+		"repeated_fixed64":     []uint64{1008, 2008},
+		"repeated_sfixed32":    []int32{1009, 2009},
+		"repeated_sfixed64":    []int64{1010, 2010},
+		"repeated_float":       []float32{1011.5, 2011.5},
+		"repeated_double":      []float64{1012.5, 2012.5},
+		"repeated_bool":        []bool{true, false},
+		"repeated_string":      []string{"foo", "bar"},
+		"repeated_bytes":       []string{"FOO", "BAR"},
+		"repeated_nested_enum": []string{"FOO", "BAR"},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 200},
+			{"a": 300},
+		},
+	},
+}, {
+	desc: "clone maps",
+	src: protobuild.Message{
+		"map_int32_int32":       map[int32]int32{1056: 1156, 2056: 2156},
+		"map_int64_int64":       map[int64]int64{1057: 1157, 2057: 2157},
+		"map_uint32_uint32":     map[uint32]uint32{1058: 1158, 2058: 2158},
+		"map_uint64_uint64":     map[uint64]uint64{1059: 1159, 2059: 2159},
+		"map_sint32_sint32":     map[int32]int32{1060: 1160, 2060: 2160},
+		"map_sint64_sint64":     map[int64]int64{1061: 1161, 2061: 2161},
+		"map_fixed32_fixed32":   map[uint32]uint32{1062: 1162, 2062: 2162},
+		"map_fixed64_fixed64":   map[uint64]uint64{1063: 1163, 2063: 2163},
+		"map_sfixed32_sfixed32": map[int32]int32{1064: 1164, 2064: 2164},
+		"map_sfixed64_sfixed64": map[int64]int64{1065: 1165, 2065: 2165},
+		"map_int32_float":       map[int32]float32{1066: 1166.5, 2066: 2166.5},
+		"map_int32_double":      map[int32]float64{1067: 1167.5, 2067: 2167.5},
+		"map_bool_bool":         map[bool]bool{true: false, false: true},
+		"map_string_string":     map[string]string{"69.1.key": "69.1.val", "69.2.key": "69.2.val"},
+		"map_string_bytes":      map[string][]byte{"70.1.key": []byte("70.1.val"), "70.2.key": []byte("70.2.val")},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"71.1.key": {"a": 1171},
+			"71.2.key": {"a": 2171},
+		},
+		"map_string_nested_enum": map[string]string{"73.1.key": "FOO", "73.2.key": "BAR"},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof uint32",
+	src: protobuild.Message{
+		"oneof_uint32": 1111,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof string",
+	src: protobuild.Message{
+		"oneof_string": "string",
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof bytes",
+	src: protobuild.Message{
+		"oneof_bytes": "bytes",
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof bool",
+	src: protobuild.Message{
+		"oneof_bool": true,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof uint64",
+	src: protobuild.Message{
+		"oneof_uint64": 100,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof float",
+	src: protobuild.Message{
+		"oneof_float": 100,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof double",
+	src: protobuild.Message{
+		"oneof_double": 1111,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof enum",
+	src: protobuild.Message{
+		"oneof_enum": 1,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof message",
+	src: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 1,
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "clone oneof group",
+	src: protobuild.Message{
+		"oneofgroup": protobuild.Message{
+			"a": 1,
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}},
+}, {
+	desc: "merge bytes",
+	dst: protobuild.Message{
+		"optional_bytes":   []byte{1, 2, 3},
+		"repeated_bytes":   [][]byte{{1, 2}, {3, 4}},
+		"map_string_bytes": map[string][]byte{"alpha": {1, 2, 3}},
+	},
+	src: protobuild.Message{
+		"optional_bytes":   []byte{4, 5, 6},
+		"repeated_bytes":   [][]byte{{5, 6}, {7, 8}},
+		"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
+	},
+	want: protobuild.Message{
+		"optional_bytes":   []byte{4, 5, 6},
+		"repeated_bytes":   [][]byte{{1, 2}, {3, 4}, {5, 6}, {7, 8}},
+		"map_string_bytes": map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge singular fields",
+	dst: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1,
+			},
+		},
+	},
+	src: protobuild.Message{
+		"optional_int32":       2,
+		"optional_int64":       2,
+		"optional_uint32":      2,
+		"optional_uint64":      2,
+		"optional_sint32":      2,
+		"optional_sint64":      2,
+		"optional_fixed32":     2,
+		"optional_fixed64":     2,
+		"optional_sfixed32":    2,
+		"optional_sfixed64":    2,
+		"optional_float":       2,
+		"optional_double":      2,
+		"optional_bool":        true,
+		"optional_string":      "2",
+		"optional_bytes":       "2",
+		"optional_nested_enum": 2,
+		"optional_nested_message": protobuild.Message{
+			"a": 2,
+			"corecursive": protobuild.Message{
+				"optional_int64": 2,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"optional_int32":       2,
+		"optional_int64":       2,
+		"optional_uint32":      2,
+		"optional_uint64":      2,
+		"optional_sint32":      2,
+		"optional_sint64":      2,
+		"optional_fixed32":     2,
+		"optional_fixed64":     2,
+		"optional_sfixed32":    2,
+		"optional_sfixed64":    2,
+		"optional_float":       2,
+		"optional_double":      2,
+		"optional_bool":        true,
+		"optional_string":      "2",
+		"optional_bytes":       "2",
+		"optional_nested_enum": 2,
+		"optional_nested_message": protobuild.Message{
+			"a": 2,
+			"corecursive": protobuild.Message{
+				"optional_int64": 2,
+			},
+		},
+	},
+}, {
+	desc: "no merge of empty singular fields",
+	dst: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1,
+			},
+		},
+	},
+	src: protobuild.Message{
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int32": 2,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"optional_int32":       1,
+		"optional_int64":       1,
+		"optional_uint32":      1,
+		"optional_uint64":      1,
+		"optional_sint32":      1,
+		"optional_sint64":      1,
+		"optional_fixed32":     1,
+		"optional_fixed64":     1,
+		"optional_sfixed32":    1,
+		"optional_sfixed64":    1,
+		"optional_float":       1,
+		"optional_double":      1,
+		"optional_bool":        false,
+		"optional_string":      "1",
+		"optional_bytes":       "1",
+		"optional_nested_enum": 1,
+		"optional_nested_message": protobuild.Message{
+			"a": 1,
+			"corecursive": protobuild.Message{
+				"optional_int32": 2,
+				"optional_int64": 1,
+			},
+		},
+	},
+}, {
+	desc: "merge list fields",
+	dst: protobuild.Message{
+		"repeated_int32":       []int32{1, 2, 3},
+		"repeated_int64":       []int64{1, 2, 3},
+		"repeated_uint32":      []uint32{1, 2, 3},
+		"repeated_uint64":      []uint64{1, 2, 3},
+		"repeated_sint32":      []int32{1, 2, 3},
+		"repeated_sint64":      []int64{1, 2, 3},
+		"repeated_fixed32":     []uint32{1, 2, 3},
+		"repeated_fixed64":     []uint64{1, 2, 3},
+		"repeated_sfixed32":    []int32{1, 2, 3},
+		"repeated_sfixed64":    []int64{1, 2, 3},
+		"repeated_float":       []float32{1, 2, 3},
+		"repeated_double":      []float64{1, 2, 3},
+		"repeated_bool":        []bool{true},
+		"repeated_string":      []string{"a", "b", "c"},
+		"repeated_bytes":       []string{"a", "b", "c"},
+		"repeated_nested_enum": []int{1, 2, 3},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 100},
+			{"a": 200},
+		},
+	},
+	src: protobuild.Message{
+		"repeated_int32":       []int32{4, 5, 6},
+		"repeated_int64":       []int64{4, 5, 6},
+		"repeated_uint32":      []uint32{4, 5, 6},
+		"repeated_uint64":      []uint64{4, 5, 6},
+		"repeated_sint32":      []int32{4, 5, 6},
+		"repeated_sint64":      []int64{4, 5, 6},
+		"repeated_fixed32":     []uint32{4, 5, 6},
+		"repeated_fixed64":     []uint64{4, 5, 6},
+		"repeated_sfixed32":    []int32{4, 5, 6},
+		"repeated_sfixed64":    []int64{4, 5, 6},
+		"repeated_float":       []float32{4, 5, 6},
+		"repeated_double":      []float64{4, 5, 6},
+		"repeated_bool":        []bool{false},
+		"repeated_string":      []string{"d", "e", "f"},
+		"repeated_bytes":       []string{"d", "e", "f"},
+		"repeated_nested_enum": []int{4, 5, 6},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 300},
+			{"a": 400},
+		},
+	},
+	want: protobuild.Message{
+		"repeated_int32":       []int32{1, 2, 3, 4, 5, 6},
+		"repeated_int64":       []int64{1, 2, 3, 4, 5, 6},
+		"repeated_uint32":      []uint32{1, 2, 3, 4, 5, 6},
+		"repeated_uint64":      []uint64{1, 2, 3, 4, 5, 6},
+		"repeated_sint32":      []int32{1, 2, 3, 4, 5, 6},
+		"repeated_sint64":      []int64{1, 2, 3, 4, 5, 6},
+		"repeated_fixed32":     []uint32{1, 2, 3, 4, 5, 6},
+		"repeated_fixed64":     []uint64{1, 2, 3, 4, 5, 6},
+		"repeated_sfixed32":    []int32{1, 2, 3, 4, 5, 6},
+		"repeated_sfixed64":    []int64{1, 2, 3, 4, 5, 6},
+		"repeated_float":       []float32{1, 2, 3, 4, 5, 6},
+		"repeated_double":      []float64{1, 2, 3, 4, 5, 6},
+		"repeated_bool":        []bool{true, false},
+		"repeated_string":      []string{"a", "b", "c", "d", "e", "f"},
+		"repeated_bytes":       []string{"a", "b", "c", "d", "e", "f"},
+		"repeated_nested_enum": []int{1, 2, 3, 4, 5, 6},
+		"repeated_nested_message": []protobuild.Message{
+			{"a": 100},
+			{"a": 200},
+			{"a": 300},
+			{"a": 400},
+		},
+	},
+}, {
+	desc: "merge map fields",
+	dst: protobuild.Message{
+		"map_int32_int32":       map[int]int{1: 1, 3: 1},
+		"map_int64_int64":       map[int]int{1: 1, 3: 1},
+		"map_uint32_uint32":     map[int]int{1: 1, 3: 1},
+		"map_uint64_uint64":     map[int]int{1: 1, 3: 1},
+		"map_sint32_sint32":     map[int]int{1: 1, 3: 1},
+		"map_sint64_sint64":     map[int]int{1: 1, 3: 1},
+		"map_fixed32_fixed32":   map[int]int{1: 1, 3: 1},
+		"map_fixed64_fixed64":   map[int]int{1: 1, 3: 1},
+		"map_sfixed32_sfixed32": map[int]int{1: 1, 3: 1},
+		"map_sfixed64_sfixed64": map[int]int{1: 1, 3: 1},
+		"map_int32_float":       map[int]int{1: 1, 3: 1},
+		"map_int32_double":      map[int]int{1: 1, 3: 1},
+		"map_bool_bool":         map[bool]bool{true: true},
+		"map_string_string":     map[string]string{"a": "1", "ab": "1"},
+		"map_string_bytes":      map[string]string{"a": "1", "ab": "1"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"a": {"a": 1},
+			"ab": {
+				"a": 1,
+				"corecursive": protobuild.Message{
+					"map_int32_int32": map[int]int{1: 1, 3: 1},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"a": 1, "ab": 1},
+	},
+	src: protobuild.Message{
+		"map_int32_int32":       map[int]int{2: 2, 3: 2},
+		"map_int64_int64":       map[int]int{2: 2, 3: 2},
+		"map_uint32_uint32":     map[int]int{2: 2, 3: 2},
+		"map_uint64_uint64":     map[int]int{2: 2, 3: 2},
+		"map_sint32_sint32":     map[int]int{2: 2, 3: 2},
+		"map_sint64_sint64":     map[int]int{2: 2, 3: 2},
+		"map_fixed32_fixed32":   map[int]int{2: 2, 3: 2},
+		"map_fixed64_fixed64":   map[int]int{2: 2, 3: 2},
+		"map_sfixed32_sfixed32": map[int]int{2: 2, 3: 2},
+		"map_sfixed64_sfixed64": map[int]int{2: 2, 3: 2},
+		"map_int32_float":       map[int]int{2: 2, 3: 2},
+		"map_int32_double":      map[int]int{2: 2, 3: 2},
+		"map_bool_bool":         map[bool]bool{false: false},
+		"map_string_string":     map[string]string{"b": "2", "ab": "2"},
+		"map_string_bytes":      map[string]string{"b": "2", "ab": "2"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"b": {"a": 2},
+			"ab": {
+				"a": 2,
+				"corecursive": protobuild.Message{
+					"map_int32_int32": map[int]int{2: 2, 3: 2},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"b": 2, "ab": 2},
+	},
+	want: protobuild.Message{
+		"map_int32_int32":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int64_int64":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_uint32_uint32":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_uint64_uint64":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sint32_sint32":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sint64_sint64":     map[int]int{1: 1, 2: 2, 3: 2},
+		"map_fixed32_fixed32":   map[int]int{1: 1, 2: 2, 3: 2},
+		"map_fixed64_fixed64":   map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sfixed32_sfixed32": map[int]int{1: 1, 2: 2, 3: 2},
+		"map_sfixed64_sfixed64": map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int32_float":       map[int]int{1: 1, 2: 2, 3: 2},
+		"map_int32_double":      map[int]int{1: 1, 2: 2, 3: 2},
+		"map_bool_bool":         map[bool]bool{true: true, false: false},
+		"map_string_string":     map[string]string{"a": "1", "b": "2", "ab": "2"},
+		"map_string_bytes":      map[string]string{"a": "1", "b": "2", "ab": "2"},
+		"map_string_nested_message": map[string]protobuild.Message{
+			"a": {"a": 1},
+			"b": {"a": 2},
+			"ab": {
+				"a": 2,
+				"corecursive": protobuild.Message{
+					// The map item "ab" was entirely replaced, so
+					// this does not contain 1:1 from dst.
+					"map_int32_int32": map[int]int{2: 2, 3: 2},
+				},
+			},
+		},
+		"map_string_nested_enum": map[string]int{"a": 1, "b": 2, "ab": 2},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge oneof message fields",
+	dst: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 100,
+		},
+	},
+	src: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"corecursive": protobuild.Message{
+				"optional_int64": 1000,
+			},
+		},
+	},
+	want: protobuild.Message{
+		"oneof_nested_message": protobuild.Message{
+			"a": 100,
+			"corecursive": protobuild.Message{
+				"optional_int64": 1000,
+			},
+		},
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge oneof scalar fields",
+	dst: protobuild.Message{
+		"oneof_uint32": 100,
+	},
+	src: protobuild.Message{
+		"oneof_float": 3.14152,
+	},
+	want: protobuild.Message{
+		"oneof_float": 3.14152,
+	},
+	types: []proto.Message{&testpb.TestAllTypes{}, &test3pb.TestAllTypes{}},
+}, {
+	desc: "merge unknown fields",
+	dst: protobuild.Message{
+		protobuild.Unknown: pack.Message{
+			pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
+		}.Marshal(),
+	},
+	src: protobuild.Message{
+		protobuild.Unknown: pack.Message{
+			pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
+		}.Marshal(),
+	},
+	want: protobuild.Message{
+		protobuild.Unknown: pack.Message{
+			pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
+			pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
+		}.Marshal(),
+	},
+}, {
+	desc: "clone legacy message",
+	src: protobuild.Message{"f1": protobuild.Message{
+		"optional_int32":        1,
+		"optional_int64":        1,
+		"optional_uint32":       1,
+		"optional_uint64":       1,
+		"optional_sint32":       1,
+		"optional_sint64":       1,
+		"optional_fixed32":      1,
+		"optional_fixed64":      1,
+		"optional_sfixed32":     1,
+		"optional_sfixed64":     1,
+		"optional_float":        1,
+		"optional_double":       1,
+		"optional_bool":         true,
+		"optional_string":       "string",
+		"optional_bytes":        "bytes",
+		"optional_sibling_enum": 1,
+		"optional_sibling_message": protobuild.Message{
+			"f1": "value",
+		},
+		"repeated_int32":        []int32{1},
+		"repeated_int64":        []int64{1},
+		"repeated_uint32":       []uint32{1},
+		"repeated_uint64":       []uint64{1},
+		"repeated_sint32":       []int32{1},
+		"repeated_sint64":       []int64{1},
+		"repeated_fixed32":      []uint32{1},
+		"repeated_fixed64":      []uint64{1},
+		"repeated_sfixed32":     []int32{1},
+		"repeated_sfixed64":     []int64{1},
+		"repeated_float":        []float32{1},
+		"repeated_double":       []float64{1},
+		"repeated_bool":         []bool{true},
+		"repeated_string":       []string{"string"},
+		"repeated_bytes":        []string{"bytes"},
+		"repeated_sibling_enum": []int{1},
+		"repeated_sibling_message": []protobuild.Message{
+			{"f1": "1"},
+		},
+		"map_bool_int32":    map[bool]int{true: 1},
+		"map_bool_int64":    map[bool]int{true: 1},
+		"map_bool_uint32":   map[bool]int{true: 1},
+		"map_bool_uint64":   map[bool]int{true: 1},
+		"map_bool_sint32":   map[bool]int{true: 1},
+		"map_bool_sint64":   map[bool]int{true: 1},
+		"map_bool_fixed32":  map[bool]int{true: 1},
+		"map_bool_fixed64":  map[bool]int{true: 1},
+		"map_bool_sfixed32": map[bool]int{true: 1},
+		"map_bool_sfixed64": map[bool]int{true: 1},
+		"map_bool_float":    map[bool]int{true: 1},
+		"map_bool_double":   map[bool]int{true: 1},
+		"map_bool_bool":     map[bool]bool{true: false},
+		"map_bool_string":   map[bool]string{true: "1"},
+		"map_bool_bytes":    map[bool]string{true: "1"},
+		"map_bool_sibling_message": map[bool]protobuild.Message{
+			true: {"f1": "1"},
+		},
+		"map_bool_sibling_enum": map[bool]int{true: 1},
+		"oneof_sibling_message": protobuild.Message{
+			"f1": "1",
+		},
+	}},
+	types: []proto.Message{&legacypb.Legacy{}},
+}}
+
 func TestMerge(t *testing.T) {
-	tests := []struct {
-		desc string
-		dst  proto.Message
-		src  proto.Message
-		want proto.Message
+	for _, tt := range testMerges {
+		for _, mt := range templateMessages(tt.types...) {
+			t.Run(fmt.Sprintf("%s (%v)", tt.desc, mt.Descriptor().FullName()), func(t *testing.T) {
+				dst := mt.New().Interface()
+				tt.dst.Build(dst.ProtoReflect())
 
-		// If provided, mutator is run on src after merging.
-		// It reports whether a mutation is expected to be observable in dst
-		// if Shallow is enabled.
-		mutator func(proto.Message) bool
-	}{{
-		desc: "merge from nil message",
-		dst:  new(testpb.TestAllTypes),
-		src:  (*testpb.TestAllTypes)(nil),
-		want: new(testpb.TestAllTypes),
-	}, {
-		desc: "clone a large message",
-		dst:  new(testpb.TestAllTypes),
-		src: &testpb.TestAllTypes{
-			OptionalInt64:      proto.Int64(0),
-			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(1).Enum(),
-			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
-				A: proto.Int32(100),
-			},
-			RepeatedSfixed32: []int32{1, 2, 3},
-			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
-				{A: proto.Int32(200)},
-				{A: proto.Int32(300)},
-			},
-			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
-				"fizz": 400,
-				"buzz": 500,
-			},
-			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
-				"foo": {A: proto.Int32(600)},
-				"bar": {A: proto.Int32(700)},
-			},
-			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
-				&testpb.TestAllTypes_NestedMessage{
-					A: proto.Int32(800),
-				},
-			},
-		},
-		want: &testpb.TestAllTypes{
-			OptionalInt64:      proto.Int64(0),
-			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(1).Enum(),
-			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
-				A: proto.Int32(100),
-			},
-			RepeatedSfixed32: []int32{1, 2, 3},
-			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
-				{A: proto.Int32(200)},
-				{A: proto.Int32(300)},
-			},
-			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
-				"fizz": 400,
-				"buzz": 500,
-			},
-			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
-				"foo": {A: proto.Int32(600)},
-				"bar": {A: proto.Int32(700)},
-			},
-			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
-				&testpb.TestAllTypes_NestedMessage{
-					A: proto.Int32(800),
-				},
-			},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			*m.OptionalInt64++
-			*m.OptionalNestedEnum++
-			*m.OptionalNestedMessage.A++
-			m.RepeatedSfixed32[0]++
-			*m.RepeatedNestedMessage[0].A++
-			delete(m.MapStringNestedEnum, "fizz")
-			*m.MapStringNestedMessage["foo"].A++
-			*m.OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage.A++
-			return true
-		},
-	}, {
-		desc: "merge bytes",
-		dst: &testpb.TestAllTypes{
-			OptionalBytes:  []byte{1, 2, 3},
-			RepeatedBytes:  [][]byte{{1, 2}, {3, 4}},
-			MapStringBytes: map[string][]byte{"alpha": {1, 2, 3}},
-		},
-		src: &testpb.TestAllTypes{
-			OptionalBytes:  []byte{4, 5, 6},
-			RepeatedBytes:  [][]byte{{5, 6}, {7, 8}},
-			MapStringBytes: map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
-		},
-		want: &testpb.TestAllTypes{
-			OptionalBytes:  []byte{4, 5, 6},
-			RepeatedBytes:  [][]byte{{1, 2}, {3, 4}, {5, 6}, {7, 8}},
-			MapStringBytes: map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			m.OptionalBytes[0]++
-			m.RepeatedBytes[0][0]++
-			m.MapStringBytes["alpha"][0]++
-			return true
-		},
-	}, {
-		desc: "merge singular fields",
-		dst: &testpb.TestAllTypes{
-			OptionalInt32:      proto.Int32(1),
-			OptionalInt64:      proto.Int64(1),
-			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(10).Enum(),
-			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
-				A: proto.Int32(100),
-				Corecursive: &testpb.TestAllTypes{
-					OptionalInt64: proto.Int64(1000),
-				},
-			},
-		},
-		src: &testpb.TestAllTypes{
-			OptionalInt64:      proto.Int64(2),
-			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(20).Enum(),
-			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
-				A: proto.Int32(200),
-			},
-		},
-		want: &testpb.TestAllTypes{
-			OptionalInt32:      proto.Int32(1),
-			OptionalInt64:      proto.Int64(2),
-			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(20).Enum(),
-			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
-				A: proto.Int32(200),
-				Corecursive: &testpb.TestAllTypes{
-					OptionalInt64: proto.Int64(1000),
-				},
-			},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			*m.OptionalInt64++
-			*m.OptionalNestedEnum++
-			*m.OptionalNestedMessage.A++
-			return false // scalar mutations are not observable in shallow copy
-		},
-	}, {
-		desc: "merge list fields",
-		dst: &testpb.TestAllTypes{
-			RepeatedSfixed32: []int32{1, 2, 3},
-			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
-				{A: proto.Int32(100)},
-				{A: proto.Int32(200)},
-			},
-		},
-		src: &testpb.TestAllTypes{
-			RepeatedSfixed32: []int32{4, 5, 6},
-			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
-				{A: proto.Int32(300)},
-				{A: proto.Int32(400)},
-			},
-		},
-		want: &testpb.TestAllTypes{
-			RepeatedSfixed32: []int32{1, 2, 3, 4, 5, 6},
-			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
-				{A: proto.Int32(100)},
-				{A: proto.Int32(200)},
-				{A: proto.Int32(300)},
-				{A: proto.Int32(400)},
-			},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			m.RepeatedSfixed32[0]++
-			*m.RepeatedNestedMessage[0].A++
-			return true
-		},
-	}, {
-		desc: "merge map fields",
-		dst: &testpb.TestAllTypes{
-			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
-				"fizz": 100,
-				"buzz": 200,
-				"guzz": 300,
-			},
-			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
-				"foo": {A: proto.Int32(400)},
-			},
-		},
-		src: &testpb.TestAllTypes{
-			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
-				"fizz": 1000,
-				"buzz": 2000,
-			},
-			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
-				"foo": {A: proto.Int32(3000)},
-				"bar": {},
-			},
-		},
-		want: &testpb.TestAllTypes{
-			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
-				"fizz": 1000,
-				"buzz": 2000,
-				"guzz": 300,
-			},
-			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
-				"foo": {A: proto.Int32(3000)},
-				"bar": {},
-			},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			delete(m.MapStringNestedEnum, "fizz")
-			m.MapStringNestedMessage["bar"].A = proto.Int32(1)
-			return true
-		},
-	}, {
-		desc: "merge oneof message fields",
-		dst: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
-				&testpb.TestAllTypes_NestedMessage{
-					A: proto.Int32(100),
-				},
-			},
-		},
-		src: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
-				&testpb.TestAllTypes_NestedMessage{
-					Corecursive: &testpb.TestAllTypes{
-						OptionalInt64: proto.Int64(1000),
-					},
-				},
-			},
-		},
-		want: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
-				&testpb.TestAllTypes_NestedMessage{
-					A: proto.Int32(100),
-					Corecursive: &testpb.TestAllTypes{
-						OptionalInt64: proto.Int64(1000),
-					},
-				},
-			},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			*m.OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage.Corecursive.OptionalInt64++
-			return true
-		},
-	}, {
-		desc: "merge oneof scalar fields",
-		dst: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofUint32{100},
-		},
-		src: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofFloat{3.14152},
-		},
-		want: &testpb.TestAllTypes{
-			OneofField: &testpb.TestAllTypes_OneofFloat{3.14152},
-		},
-		mutator: func(mi proto.Message) bool {
-			m := mi.(*testpb.TestAllTypes)
-			m.OneofField.(*testpb.TestAllTypes_OneofFloat).OneofFloat++
-			return false // scalar mutations are not observable in shallow copy
-		},
-	}, {
-		desc: "merge extension fields",
-		dst: func() proto.Message {
-			m := new(testpb.TestAllExtensions)
-			proto.SetExtension(m, testpb.E_OptionalInt32, int32(32))
-			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
-				&testpb.TestAllExtensions_NestedMessage{
-					A: proto.Int32(50),
-				},
-			)
-			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{1, 2, 3})
-			return m
-		}(),
-		src: func() proto.Message {
-			m2 := new(testpb.TestAllExtensions)
-			proto.SetExtension(m2, testpb.E_OptionalInt64, int64(1000))
-			m := new(testpb.TestAllExtensions)
-			proto.SetExtension(m, testpb.E_OptionalInt64, int64(64))
-			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
-				&testpb.TestAllExtensions_NestedMessage{
-					Corecursive: m2,
-				},
-			)
-			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{4, 5, 6})
-			return m
-		}(),
-		want: func() proto.Message {
-			m2 := new(testpb.TestAllExtensions)
-			proto.SetExtension(m2, testpb.E_OptionalInt64, int64(1000))
-			m := new(testpb.TestAllExtensions)
-			proto.SetExtension(m, testpb.E_OptionalInt32, int32(32))
-			proto.SetExtension(m, testpb.E_OptionalInt64, int64(64))
-			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
-				&testpb.TestAllExtensions_NestedMessage{
-					A:           proto.Int32(50),
-					Corecursive: m2,
-				},
-			)
-			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{1, 2, 3, 4, 5, 6})
-			return m
-		}(),
-	}, {
-		desc: "merge unknown fields",
-		dst: func() proto.Message {
-			m := new(testpb.TestAllTypes)
-			m.ProtoReflect().SetUnknown(pack.Message{
-				pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
-			}.Marshal())
-			return m
-		}(),
-		src: func() proto.Message {
-			m := new(testpb.TestAllTypes)
-			m.ProtoReflect().SetUnknown(pack.Message{
-				pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
-			}.Marshal())
-			return m
-		}(),
-		want: func() proto.Message {
-			m := new(testpb.TestAllTypes)
-			m.ProtoReflect().SetUnknown(pack.Message{
-				pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
-				pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
-			}.Marshal())
-			return m
-		}(),
-	}}
+				src := mt.New().Interface()
+				tt.src.Build(src.ProtoReflect())
 
-	for _, tt := range tests {
-		t.Run(tt.desc, func(t *testing.T) {
-			// Merge should be semantically equivalent to unmarshaling the
-			// encoded form of src into the current dst.
-			b1, err := proto.MarshalOptions{AllowPartial: true}.Marshal(tt.dst)
-			if err != nil {
-				t.Fatalf("Marshal(dst) error: %v", err)
-			}
-			b2, err := proto.MarshalOptions{AllowPartial: true}.Marshal(tt.src)
-			if err != nil {
-				t.Fatalf("Marshal(src) error: %v", err)
-			}
-			dst := tt.dst.ProtoReflect().New().Interface()
-			err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(append(b1, b2...), dst)
-			if err != nil {
-				t.Fatalf("Unmarshal() error: %v", err)
-			}
-			if !proto.Equal(dst, tt.want) {
-				t.Fatalf("Unmarshal(Marshal(dst)+Marshal(src)) mismatch: got %v, want %v", dst, tt.want)
-			}
-
-			proto.Merge(tt.dst, tt.src)
-			if !proto.Equal(tt.dst, tt.want) {
-				t.Fatalf("Merge() mismatch:\n got %v\nwant %v", tt.dst, tt.want)
-			}
-			if tt.mutator != nil {
-				if !proto.Equal(tt.dst, tt.want) {
-					t.Fatalf("mutation observed in dest after modifying merge source:\n got %v\nwant %v", tt.dst, tt.want)
+				want := mt.New().Interface()
+				if tt.dst == nil && tt.want == nil {
+					tt.src.Build(want.ProtoReflect())
+				} else {
+					tt.want.Build(want.ProtoReflect())
 				}
-			}
-		})
+
+				// Merge should be semantically equivalent to unmarshaling the
+				// encoded form of src into the current dst.
+				b1, err := proto.MarshalOptions{AllowPartial: true}.Marshal(dst)
+				if err != nil {
+					t.Fatalf("Marshal(dst) error: %v", err)
+				}
+				b2, err := proto.MarshalOptions{AllowPartial: true}.Marshal(src)
+				if err != nil {
+					t.Fatalf("Marshal(src) error: %v", err)
+				}
+				unmarshaled := dst.ProtoReflect().New().Interface()
+				err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(append(b1, b2...), unmarshaled)
+				if err != nil {
+					t.Fatalf("Unmarshal() error: %v", err)
+				}
+				if !proto.Equal(unmarshaled, want) {
+					t.Fatalf("Unmarshal(Marshal(dst)+Marshal(src)) mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", unmarshaled, want, cmp.Diff(want, unmarshaled, protocmp.Transform()))
+				}
+
+				// Test heterogeneous MessageTypes by merging into a
+				// dynamic message.
+				ddst := dynamicpb.NewMessage(mt.Descriptor())
+				tt.dst.Build(ddst.ProtoReflect())
+				proto.Merge(ddst, src)
+				if !proto.Equal(ddst, want) {
+					t.Fatalf("Merge() into dynamic message mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", ddst, want, cmp.Diff(want, ddst, protocmp.Transform()))
+				}
+
+				proto.Merge(dst, src)
+				if !proto.Equal(dst, want) {
+					t.Fatalf("Merge() mismatch:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
+				}
+				mutateValue(protoreflect.ValueOfMessage(src.ProtoReflect()))
+				if !proto.Equal(dst, want) {
+					t.Fatalf("mutation observed after modifying source:\n got %v\nwant %v\ndiff (-want,+got):\n%v", dst, want, cmp.Diff(want, dst, protocmp.Transform()))
+				}
+
+			})
+		}
+	}
+}
+
+func TestMergeFromNil(t *testing.T) {
+	dst := &testpb.TestAllTypes{}
+	proto.Merge(dst, (*testpb.TestAllTypes)(nil))
+	if !proto.Equal(dst, &testpb.TestAllTypes{}) {
+		t.Errorf("destination should be empty after merging from nil message; got:\n%v", prototext.Format(dst))
 	}
 }
 
@@ -562,3 +842,64 @@
 		t.Errorf("Equal mismatch:\ngot  %v\nwant %v", got, want)
 	}
 }
+
+func TestClone(t *testing.T) {
+	want := &testpb.TestAllTypes{
+		OptionalInt32: proto.Int32(1),
+	}
+	got := proto.Clone(want).(*testpb.TestAllTypes)
+	if !proto.Equal(got, want) {
+		t.Errorf("Clone(src) != src:\n got %v\nwant %v", got, want)
+	}
+}
+
+// mutateValue changes a Value, returning a new value.
+//
+// For scalar values, it returns a value different from the input.
+// For Message, List, and Map values, it mutates the input and returns it.
+func mutateValue(v protoreflect.Value) protoreflect.Value {
+	switch v := v.Interface().(type) {
+	case bool:
+		return protoreflect.ValueOfBool(!v)
+	case protoreflect.EnumNumber:
+		return protoreflect.ValueOfEnum(v + 1)
+	case int32:
+		return protoreflect.ValueOfInt32(v + 1)
+	case int64:
+		return protoreflect.ValueOfInt64(v + 1)
+	case uint32:
+		return protoreflect.ValueOfUint32(v + 1)
+	case uint64:
+		return protoreflect.ValueOfUint64(v + 1)
+	case float32:
+		return protoreflect.ValueOfFloat32(v + 1)
+	case float64:
+		return protoreflect.ValueOfFloat64(v + 1)
+	case []byte:
+		for i := range v {
+			v[i]++
+		}
+		return protoreflect.ValueOfBytes(v)
+	case string:
+		return protoreflect.ValueOfString("_" + v)
+	case protoreflect.Message:
+		v.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool {
+			v.Set(fd, mutateValue(val))
+			return true
+		})
+		return protoreflect.ValueOfMessage(v)
+	case protoreflect.List:
+		for i := 0; i < v.Len(); i++ {
+			v.Set(i, mutateValue(v.Get(i)))
+		}
+		return protoreflect.ValueOfList(v)
+	case protoreflect.Map:
+		v.Range(func(mk protoreflect.MapKey, mv protoreflect.Value) bool {
+			v.Set(mk, mutateValue(mv))
+			return true
+		})
+		return protoreflect.ValueOfMap(v)
+	default:
+		panic(fmt.Sprintf("unknown value type %T", v))
+	}
+}
diff --git a/proto/testmessages_test.go b/proto/testmessages_test.go
index ca3ce3c..cfa3cd7 100644
--- a/proto/testmessages_test.go
+++ b/proto/testmessages_test.go
@@ -45,6 +45,22 @@
 	return messages
 }
 
+func templateMessages(messages ...proto.Message) []protoreflect.MessageType {
+	if len(messages) == 0 {
+		messages = []proto.Message{
+			(*testpb.TestAllTypes)(nil),
+			(*test3pb.TestAllTypes)(nil),
+			(*testpb.TestAllExtensions)(nil),
+		}
+	}
+	var out []protoreflect.MessageType
+	for _, m := range messages {
+		out = append(out, m.ProtoReflect().Type())
+	}
+	return out
+
+}
+
 var testValidMessages = []testProto{
 	{
 		desc:          "basic scalar types",
diff --git a/proto/weak_test.go b/proto/weak_test.go
index 15a18fb..0b582ba 100644
--- a/proto/weak_test.go
+++ b/proto/weak_test.go
@@ -9,6 +9,7 @@
 
 	"google.golang.org/protobuf/internal/encoding/pack"
 	"google.golang.org/protobuf/internal/flags"
+	"google.golang.org/protobuf/internal/protobuild"
 	"google.golang.org/protobuf/proto"
 
 	testpb "google.golang.org/protobuf/internal/testprotos/test"
@@ -19,6 +20,7 @@
 	if flags.ProtoLegacy {
 		testValidMessages = append(testValidMessages, testWeakValidMessages...)
 		testInvalidMessages = append(testInvalidMessages, testWeakInvalidMessages...)
+		testMerges = append(testMerges, testWeakMerges...)
 	}
 }
 
@@ -65,6 +67,36 @@
 	},
 }
 
+var testWeakMerges = []testMerge{
+	{
+		desc: "clone weak message",
+		src: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 1,
+			},
+		},
+		types: []proto.Message{&testpb.TestWeak{}},
+	}, {
+		desc: "merge weak message",
+		dst: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 1,
+			},
+		},
+		src: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 2,
+			},
+		},
+		want: protobuild.Message{
+			"weak_message1": protobuild.Message{
+				"a": 2,
+			},
+		},
+		types: []proto.Message{&testpb.TestWeak{}},
+	},
+}
+
 func TestWeakNil(t *testing.T) {
 	if !flags.ProtoLegacy {
 		t.SkipNow()