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

agents/rap-node-agent/cmd/mesh-live-smoke/main.go

@@ -10,8 +10,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"math/big"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"time"
@@ -22,22 +20,21 @@ import (
 )
 
 type smokeNode struct {
-	Local   mesh.PeerIdentity
-	Runtime *mesh.SyntheticRuntime
-	URL     string
-	server  *httptest.Server
+	Local    mesh.PeerIdentity
+	Runtime  *mesh.SyntheticRuntime
+	Endpoint string
 }
 
 type smokeSyntheticTransport struct {
-	peers map[string]string
+	peers map[string]*mesh.SyntheticRuntime
 }
 
 func (t smokeSyntheticTransport) SendSynthetic(ctx context.Context, nextNodeID string, envelope mesh.SyntheticEnvelope) (mesh.SyntheticEnvelope, error) {
-	baseURL := t.peers[nextNodeID]
-	if baseURL == "" {
+	runtime := t.peers[nextNodeID]
+	if runtime == nil {
 		return mesh.SyntheticEnvelope{}, mesh.ErrSyntheticPeerUnavailable
 	}
-	return mesh.NewClient(baseURL).SendSynthetic(ctx, envelope)
+	return runtime.Receive(ctx, envelope)
 }
 
 type smokeReport struct {
@@ -104,8 +101,8 @@ func run(ctx context.Context) (smokeReport, error) {
 	relayRoute := smokeRoute("route-relay", []string{"node-a", "node-r", "node-b"})
 	routes := []mesh.SyntheticRoute{directRoute, relayRoute}
 	nodeAConfigPath, err := writeSmokeScopedConfig(nodeA.Local, map[string]string{
-		"node-r": nodeR.URL,
-		"node-b": nodeB.URL,
+		"node-r": nodeR.Endpoint,
+		"node-b": nodeB.Endpoint,
 	}, routes)
 	if err != nil {
 		return smokeReport{}, err
@@ -117,10 +114,19 @@ func run(ctx context.Context) (smokeReport, error) {
 
 	nodeA.Runtime = smokeRuntime(nodeA.Local, nodeAConfig.Routes, nodeAConfig.PeerEndpoints)
 	nodeR.Runtime = smokeRuntime(nodeR.Local, routes, map[string]string{
-		"node-b": nodeB.URL,
+		"node-b": nodeB.Endpoint,
 	})
 	nodeB.Runtime = smokeRuntime(nodeB.Local, routes, map[string]string{})
 
+	nodeA.Runtime = smokeRuntimeWithPeers(nodeA.Local, nodeAConfig.Routes, map[string]*mesh.SyntheticRuntime{
+		"node-r": nodeR.Runtime,
+		"node-b": nodeB.Runtime,
+	})
+	nodeR.Runtime = smokeRuntimeWithPeers(nodeR.Local, routes, map[string]*mesh.SyntheticRuntime{
+		"node-b": nodeB.Runtime,
+	})
+	nodeB.Runtime = smokeRuntimeWithPeers(nodeB.Local, routes, map[string]*mesh.SyntheticRuntime{})
+
 	directAck, err := nodeA.Runtime.SendProbe(ctx, directRoute.RouteID, mesh.SyntheticChannelFabricControl, "smoke-direct")
 	if err != nil {
 		return smokeReport{}, fmt.Errorf("direct probe: %w", err)
@@ -209,9 +215,9 @@ func run(ctx context.Context) (smokeReport, error) {
 		FabricSessionLatencyMS:  fabricSessionLatency.Milliseconds(),
 		FabricSessionEndpoint:   "quic://" + fabricQUICEndpoint,
 		PeerEndpoints: map[string]any{
-			"node-a": nodeA.URL,
-			"node-r": nodeR.URL,
-			"node-b": nodeB.URL,
+			"node-a": nodeA.Endpoint,
+			"node-r": nodeR.Endpoint,
+			"node-b": nodeB.Endpoint,
 		},
 	}, nil
 }
@@ -472,21 +478,21 @@ func writeSmokeScopedConfig(local mesh.PeerIdentity, peers map[string]string, ro
 }
 
 func newSmokeNode(local mesh.PeerIdentity) *smokeNode {
-	node := &smokeNode{Local: local}
-	node.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		mesh.Server{Local: node.Local, SyntheticRuntime: node.Runtime}.Handler().ServeHTTP(w, r)
-	}))
-	node.URL = node.server.URL
-	return node
-}
-
-func (n *smokeNode) Close() {
-	if n.server != nil {
-		n.server.Close()
+	return &smokeNode{
+		Local:    local,
+		Endpoint: "quic://smoke-" + local.NodeID,
 	}
 }
 
+func (n *smokeNode) Close() {
+}
+
 func smokeRuntime(local mesh.PeerIdentity, routes []mesh.SyntheticRoute, peers map[string]string) *mesh.SyntheticRuntime {
+	_ = peers
+	return smokeRuntimeWithPeers(local, routes, map[string]*mesh.SyntheticRuntime{})
+}
+
+func smokeRuntimeWithPeers(local mesh.PeerIdentity, routes []mesh.SyntheticRoute, peers map[string]*mesh.SyntheticRuntime) *mesh.SyntheticRuntime {
 	return mesh.NewSyntheticRuntime(mesh.SyntheticRuntimeConfig{
 		Enabled: true,
 		Local:   local,