рабочий вариант, но скороть 10 МБит

agents/rap-node-agent/cmd/fabric-loadtest/main.go

@@ -1621,7 +1621,7 @@ func verdict(report loadtestReport) (string, []string) {
 	reasons = append(reasons, targetAckVerdictReasons(report)...)
 	reasons = append(reasons, routePressureDistributionVerdictReasons(report)...)
 	reasons = append(reasons, targetEndpointPolicyVerdictReasons(report)...)
-	reasons = append(reasons, legacyRouteModeVerdictReasons(report)...)
+	reasons = append(reasons, disallowedRouteModeVerdictReasons(report)...)
 	reasons = append(reasons, routeModeCoverageVerdictReasons(report)...)
 	if len(reasons) > 0 {
 		return "fail", reasons
@@ -1846,25 +1846,22 @@ func targetEndpointPolicyVerdictReasons(report loadtestReport) []string {
 	return []string{fmt.Sprintf("non_quic_targets=%s", strings.Join(invalid, ","))}
 }
 
-func legacyRouteModeVerdictReasons(report loadtestReport) []string {
+func disallowedRouteModeVerdictReasons(report loadtestReport) []string {
 	if len(report.TargetStats) == 0 {
 		return nil
 	}
-	legacyModes := map[string]struct{}{
-		"relay":            {},
-		"outbound_reverse": {},
-		"websocket":        {},
-		"ws":               {},
-		"wss":              {},
-		"direct_http":      {},
-		"direct_https":     {},
-		"direct_tcp_tls":   {},
+	supportedModes := map[string]struct{}{
+		string(mesh.FabricRouteDirect):  {},
+		string(mesh.FabricRouteLAN):     {},
+		string(mesh.FabricRouteICE):     {},
+		string(mesh.FabricRouteReverse): {},
+		string(mesh.FabricRouteRelay):   {},
 	}
 	found := map[string]int{}
 	for _, stats := range report.TargetStats {
 		for mode, count := range stats.RouteModes {
 			mode = strings.ToLower(strings.TrimSpace(mode))
-			if _, legacy := legacyModes[mode]; legacy && count > 0 {
+			if _, supported := supportedModes[mode]; !supported && count > 0 {
 				found[mode] += count
 			}
 		}
@@ -1877,7 +1874,7 @@ func legacyRouteModeVerdictReasons(report loadtestReport) []string {
 		modes = append(modes, fmt.Sprintf("%s:%d", mode, count))
 	}
 	sort.Strings(modes)
-	return []string{fmt.Sprintf("legacy_route_modes_observed=%s", strings.Join(modes, ","))}
+	return []string{fmt.Sprintf("compat_route_modes_observed=%s", strings.Join(modes, ","))}
 }
 
 func routeModeCoverageVerdictReasons(report loadtestReport) []string {

agents/rap-node-agent/cmd/fabric-loadtest/main_test.go

@@ -38,7 +38,7 @@ func TestRouteModeCoverageVerdictRequiresMixedModes(t *testing.T) {
 	}
 }
 
-func TestLegacyRouteModeVerdictRejectsNonQUICModes(t *testing.T) {
+func TestDisallowedRouteModeVerdictRejectsNonQUICModes(t *testing.T) {
 	report := loadtestReport{
 		TargetStats: map[string]targetStats{
 			"a": {RouteModes: map[string]int{
@@ -49,12 +49,12 @@ func TestLegacyRouteModeVerdictRejectsNonQUICModes(t *testing.T) {
 			}},
 		},
 	}
-	reasons := legacyRouteModeVerdictReasons(report)
+	reasons := disallowedRouteModeVerdictReasons(report)
 	if len(reasons) != 1 ||
 		!strings.Contains(reasons[0], "relay:1") ||
 		!strings.Contains(reasons[0], "outbound_reverse:2") ||
 		!strings.Contains(reasons[0], "wss:3") {
-		t.Fatalf("reasons = %v, want legacy route mode failure", reasons)
+		t.Fatalf("reasons = %v, want compat route mode failure", reasons)
 	}
 
 	report.TargetStats["a"] = targetStats{RouteModes: map[string]int{
@@ -64,7 +64,7 @@ func TestLegacyRouteModeVerdictRejectsNonQUICModes(t *testing.T) {
 		string(mesh.FabricRouteReverse): 1,
 		string(mesh.FabricRouteRelay):   1,
 	}}
-	if reasons := legacyRouteModeVerdictReasons(report); len(reasons) != 0 {
+	if reasons := disallowedRouteModeVerdictReasons(report); len(reasons) != 0 {
 		t.Fatalf("reasons = %v, want QUIC modes accepted", reasons)
 	}
 }