Add grpc multi conn

2025-08-22 17:46:48 +08:00 · 2024-12-19 10:45:35 +00:00
62 changed files with 1128 additions and 1089 deletions
--- a/README.md
+++ b/README.md
@@ -6,9 +6,7 @@

 ## Donation & NFTs

- **ETH/USDT/USDC: `0xDc3Fe44F0f25D13CACb1C4896CD0D321df3146Ee`**
- **Project X NFT: [Announcement of NFTs by Project X](https://github.com/XTLS/Xray-core/discussions/3633)**
- **REALITY NFT: [XHTTP: Beyond REALITY](https://github.com/XTLS/Xray-core/discussions/4113)**
+[Announcement of NFTs by Project X](https://github.com/XTLS/Xray-core/discussions/3633)

 ## License

--- a/app/dispatcher/default.go
+++ b/app/dispatcher/default.go
@@ -106,7 +106,7 @@ func init() {
 	common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
 		d := new(DefaultDispatcher)
 		if err := core.RequireFeatures(ctx, func(om outbound.Manager, router routing.Router, pm policy.Manager, sm stats.Manager, dc dns.Client) error {
-			core.OptionalFeatures(ctx, func(fdns dns.FakeDNSEngine) {
+			core.RequireFeatures(ctx, func(fdns dns.FakeDNSEngine) {
 				d.fdns = fdns
 			})
 			return d.Init(config.(*Config), om, router, pm, sm, dc)
--- a/app/dns/nameserver.go
+++ b/app/dns/nameserver.go
@@ -35,7 +35,7 @@ type Client struct {
 var errExpectedIPNonMatch = errors.New("expectIPs not match")

 // NewServer creates a name server object according to the network destination url.
-func NewServer(ctx context.Context, dest net.Destination, dispatcher routing.Dispatcher, queryStrategy QueryStrategy) (Server, error) {
+func NewServer(dest net.Destination, dispatcher routing.Dispatcher, queryStrategy QueryStrategy) (Server, error) {
 	if address := dest.Address; address.Family().IsDomain() {
 		u, err := url.Parse(address.Domain())
 		if err != nil {
@@ -55,11 +55,7 @@ func NewServer(ctx context.Context, dest net.Destination, dispatcher routing.Dis
 		case strings.EqualFold(u.Scheme, "tcp+local"): // DNS-over-TCP Local mode
 			return NewTCPLocalNameServer(u, queryStrategy)
 		case strings.EqualFold(u.String(), "fakedns"):
-			var fd dns.FakeDNSEngine
-			core.RequireFeatures(ctx, func(fdns dns.FakeDNSEngine) {
-				fd = fdns
-			})
-			return NewFakeDNSServer(fd), nil
+			return NewFakeDNSServer(), nil
 		}
 	}
 	if dest.Network == net.Network_Unknown {
@@ -84,7 +80,7 @@ func NewClient(

 	err := core.RequireFeatures(ctx, func(dispatcher routing.Dispatcher) error {
 		// Create a new server for each client for now
-		server, err := NewServer(ctx, ns.Address.AsDestination(), dispatcher, ns.GetQueryStrategy())
+		server, err := NewServer(ns.Address.AsDestination(), dispatcher, ns.GetQueryStrategy())
 		if err != nil {
 			return errors.New("failed to create nameserver").Base(err).AtWarning()
 		}
--- a/app/dns/nameserver_doh.go
+++ b/app/dns/nameserver_doh.go
@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"net/url"
 	"sync"
+	"sync/atomic"
 	"time"

 	"github.com/xtls/xray-core/common"
@@ -34,6 +35,7 @@ type DoHNameServer struct {
 	ips           map[string]*record
 	pub           *pubsub.Service
 	cleanup       *task.Periodic
+	reqID         uint32
 	httpClient    *http.Client
 	dohURL        string
 	name          string
@@ -220,7 +222,7 @@ func (s *DoHNameServer) updateIP(req *dnsRequest, ipRec *IPRecord) {
 }

 func (s *DoHNameServer) newReqID() uint16 {
-	return 0
+	return uint16(atomic.AddUint32(&s.reqID, 1))
 }

 func (s *DoHNameServer) sendQuery(ctx context.Context, domain string, clientIP net.IP, option dns_feature.IPOption) {
--- a/app/dns/nameserver_fakedns.go
+++ b/app/dns/nameserver_fakedns.go
@@ -5,6 +5,7 @@ import (

 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/dns"
 )

@@ -12,8 +13,8 @@ type FakeDNSServer struct {
 	fakeDNSEngine dns.FakeDNSEngine
 }

-func NewFakeDNSServer(fd dns.FakeDNSEngine) *FakeDNSServer {
-	return &FakeDNSServer{fakeDNSEngine: fd}
+func NewFakeDNSServer() *FakeDNSServer {
+	return &FakeDNSServer{}
 }

 func (FakeDNSServer) Name() string {
@@ -22,9 +23,12 @@ func (FakeDNSServer) Name() string {

 func (f *FakeDNSServer) QueryIP(ctx context.Context, domain string, _ net.IP, opt dns.IPOption, _ bool) ([]net.IP, error) {
 	if f.fakeDNSEngine == nil {
-		return nil, errors.New("Unable to locate a fake DNS Engine").AtError()
+		if err := core.RequireFeatures(ctx, func(fd dns.FakeDNSEngine) {
+			f.fakeDNSEngine = fd
+		}); err != nil {
+			return nil, errors.New("Unable to locate a fake DNS Engine").Base(err).AtError()
+		}
 	}
-
 	var ips []net.Address
 	if fkr0, ok := f.fakeDNSEngine.(dns.FakeDNSEngineRev0); ok {
 		ips = fkr0.GetFakeIPForDomain3(domain, opt.IPv4Enable, opt.IPv6Enable)
--- a/app/dns/nameserver_quic.go
+++ b/app/dns/nameserver_quic.go
@@ -6,9 +6,10 @@ import (
 	"encoding/binary"
 	"net/url"
 	"sync"
+	"sync/atomic"
 	"time"

-	"github.com/xtls/quic-go"
+	"github.com/quic-go/quic-go"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/buf"
 	"github.com/xtls/xray-core/common/errors"
@@ -36,6 +37,7 @@ type QUICNameServer struct {
 	ips           map[string]*record
 	pub           *pubsub.Service
 	cleanup       *task.Periodic
+	reqID         uint32
 	name          string
 	destination   *net.Destination
 	connection    quic.Connection
@@ -154,7 +156,7 @@ func (s *QUICNameServer) updateIP(req *dnsRequest, ipRec *IPRecord) {
 }

 func (s *QUICNameServer) newReqID() uint16 {
-	return 0
+	return uint16(atomic.AddUint32(&s.reqID, 1))
 }

 func (s *QUICNameServer) sendQuery(ctx context.Context, domain string, clientIP net.IP, option dns_feature.IPOption) {
--- a/app/observatory/burst/burstobserver.go
+++ b/app/observatory/burst/burstobserver.go
@@ -12,7 +12,6 @@ import (
 	"github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/extension"
 	"github.com/xtls/xray-core/features/outbound"
-	"github.com/xtls/xray-core/features/routing"
 	"google.golang.org/protobuf/proto"
 )

@@ -89,15 +88,13 @@ func (o *Observer) Close() error {

 func New(ctx context.Context, config *Config) (*Observer, error) {
 	var outboundManager outbound.Manager
-	var dispatcher routing.Dispatcher
-	err := core.RequireFeatures(ctx, func(om outbound.Manager, rd routing.Dispatcher) {
+	err := core.RequireFeatures(ctx, func(om outbound.Manager) {
 		outboundManager = om
-		dispatcher = rd
 	})
 	if err != nil {
 		return nil, errors.New("Cannot get depended features").Base(err)
 	}
-	hp := NewHealthPing(ctx, dispatcher, config.PingConfig)
+	hp := NewHealthPing(ctx, config.PingConfig)
 	return &Observer{
 		config: config,
 		ctx:    ctx,
--- a/app/observatory/burst/healthping.go
+++ b/app/observatory/burst/healthping.go
@@ -9,7 +9,6 @@ import (

 	"github.com/xtls/xray-core/common/dice"
 	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/features/routing"
 )

 // HealthPingSettings holds settings for health Checker
@@ -24,7 +23,6 @@ type HealthPingSettings struct {
 // HealthPing is the health checker for balancers
 type HealthPing struct {
 	ctx         context.Context
-	dispatcher  routing.Dispatcher
 	access      sync.Mutex
 	ticker      *time.Ticker
 	tickerClose chan struct{}
@@ -34,7 +32,7 @@ type HealthPing struct {
 }

 // NewHealthPing creates a new HealthPing with settings
-func NewHealthPing(ctx context.Context, dispatcher routing.Dispatcher, config *HealthPingConfig) *HealthPing {
+func NewHealthPing(ctx context.Context, config *HealthPingConfig) *HealthPing {
 	settings := &HealthPingSettings{}
 	if config != nil {
 		settings = &HealthPingSettings{
@@ -67,7 +65,6 @@ func NewHealthPing(ctx context.Context, dispatcher routing.Dispatcher, config *H
 	}
 	return &HealthPing{
 		ctx:      ctx,
-		dispatcher: dispatcher,
 		Settings: settings,
 		Results:  nil,
 	}
@@ -152,7 +149,6 @@ func (h *HealthPing) doCheck(tags []string, duration time.Duration, rounds int)
 		handler := tag
 		client := newPingClient(
 			h.ctx,
-			h.dispatcher,
 			h.Settings.Destination,
 			h.Settings.Timeout,
 			handler,
--- a/app/observatory/burst/ping.go
+++ b/app/observatory/burst/ping.go
@@ -6,7 +6,6 @@ import (
 	"time"

 	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/features/routing"
 	"github.com/xtls/xray-core/transport/internet/tagged"
 )

@@ -15,10 +14,10 @@ type pingClient struct {
 	httpClient  *http.Client
 }

-func newPingClient(ctx context.Context, dispatcher routing.Dispatcher, destination string, timeout time.Duration, handler string) *pingClient {
+func newPingClient(ctx context.Context, destination string, timeout time.Duration, handler string) *pingClient {
 	return &pingClient{
 		destination: destination,
-		httpClient:  newHTTPClient(ctx, dispatcher, handler, timeout),
+		httpClient:  newHTTPClient(ctx, handler, timeout),
 	}
 }

@@ -29,7 +28,7 @@ func newDirectPingClient(destination string, timeout time.Duration) *pingClient
 	}
 }

-func newHTTPClient(ctxv context.Context, dispatcher routing.Dispatcher, handler string, timeout time.Duration) *http.Client {
+func newHTTPClient(ctxv context.Context, handler string, timeout time.Duration) *http.Client {
 	tr := &http.Transport{
 		DisableKeepAlives: true,
 		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
@@ -37,7 +36,7 @@ func newHTTPClient(ctxv context.Context, dispatcher routing.Dispatcher, handler
 			if err != nil {
 				return nil, err
 			}
-			return tagged.Dialer(ctxv, dispatcher, dest, handler)
+			return tagged.Dialer(ctxv, dest, handler)
 		},
 	}
 	return &http.Client{
--- a/app/observatory/command/command.go
+++ b/app/observatory/command/command.go
@@ -38,7 +38,7 @@ func init() {
 		sv := &service{v: s}
 		err := s.RequireFeatures(func(Observatory extension.Observatory) {
 			sv.observatory = Observatory
-		}, false)
+		})
 		if err != nil {
 			return nil, err
 		}
--- a/app/observatory/observer.go
+++ b/app/observatory/observer.go
@@ -18,7 +18,6 @@ import (
 	"github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/features/extension"
 	"github.com/xtls/xray-core/features/outbound"
-	"github.com/xtls/xray-core/features/routing"
 	"github.com/xtls/xray-core/transport/internet/tagged"
 	"google.golang.org/protobuf/proto"
 )
@@ -33,7 +32,6 @@ type Observer struct {
 	finished *done.Instance

 	ohm outbound.Manager
-	dispatcher routing.Dispatcher
 }

 func (o *Observer) GetObservation(ctx context.Context) (proto.Message, error) {
@@ -133,7 +131,7 @@ func (o *Observer) probe(outbound string) ProbeResult {
 					return errors.New("cannot understand address").Base(err)
 				}
 				trackedCtx := session.TrackedConnectionError(o.ctx, errorCollectorForRequest)
-				conn, err := tagged.Dialer(trackedCtx, o.dispatcher, dest, outbound)
+				conn, err := tagged.Dialer(trackedCtx, dest, outbound)
 				if err != nil {
 					return errors.New("cannot dial remote address ", dest).Base(err)
 				}
@@ -217,10 +215,8 @@ func (o *Observer) findStatusLocationLockHolderOnly(outbound string) int {

 func New(ctx context.Context, config *Config) (*Observer, error) {
 	var outboundManager outbound.Manager
-	var dispatcher routing.Dispatcher
-	err := core.RequireFeatures(ctx, func(om outbound.Manager, rd routing.Dispatcher) {
+	err := core.RequireFeatures(ctx, func(om outbound.Manager) {
 		outboundManager = om
-		dispatcher = rd
 	})
 	if err != nil {
 		return nil, errors.New("Cannot get depended features").Base(err)
@@ -229,7 +225,6 @@ func New(ctx context.Context, config *Config) (*Observer, error) {
 		config: config,
 		ctx:    ctx,
 		ohm:    outboundManager,
-		dispatcher: dispatcher,
 	}, nil
 }

--- a/app/proxyman/command/command.go
+++ b/app/proxyman/command/command.go
@@ -177,7 +177,7 @@ func (s *service) Register(server *grpc.Server) {
 	common.Must(s.v.RequireFeatures(func(im inbound.Manager, om outbound.Manager) {
 		hs.ihm = im
 		hs.ohm = om
-	}, false))
+	}))
 	RegisterHandlerServiceServer(server, hs)

 	// For compatibility purposes
--- a/app/proxyman/config.pb.go
+++ b/app/proxyman/config.pb.go
@@ -534,8 +534,6 @@ type MultiplexingConfig struct {
 	XudpConcurrency int32 `protobuf:"varint,3,opt,name=xudpConcurrency,proto3" json:"xudpConcurrency,omitempty"`
 	// "reject" (default), "allow" or "skip".
 	XudpProxyUDP443 string `protobuf:"bytes,4,opt,name=xudpProxyUDP443,proto3" json:"xudpProxyUDP443,omitempty"`
-	// MaxReuseTimes for an connection
-	MaxReuseTimes int32 `protobuf:"varint,5,opt,name=maxReuseTimes,proto3" json:"maxReuseTimes,omitempty"`
 }

 func (x *MultiplexingConfig) Reset() {
@@ -596,13 +594,6 @@ func (x *MultiplexingConfig) GetXudpProxyUDP443() string {
 	return ""
 }

-func (x *MultiplexingConfig) GetMaxReuseTimes() int32 {
-	if x != nil {
-		return x.MaxReuseTimes
-	}
-	return 0
-}
-
 type AllocationStrategy_AllocationStrategyConcurrency struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -809,7 +800,7 @@ var file_app_proxyman_config_proto_rawDesc = []byte{
 	0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x11, 0x6d, 0x75, 0x6c, 0x74, 0x69,
 	0x70, 0x6c, 0x65, 0x78, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x19, 0x0a, 0x08,
 	0x76, 0x69, 0x61, 0x5f, 0x63, 0x69, 0x64, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x76, 0x69, 0x61, 0x43, 0x69, 0x64, 0x72, 0x22, 0xca, 0x01, 0x0a, 0x12, 0x4d, 0x75, 0x6c, 0x74,
+	0x76, 0x69, 0x61, 0x43, 0x69, 0x64, 0x72, 0x22, 0xa4, 0x01, 0x0a, 0x12, 0x4d, 0x75, 0x6c, 0x74,
 	0x69, 0x70, 0x6c, 0x65, 0x78, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18,
 	0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
 	0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63,
@@ -819,16 +810,13 @@ var file_app_proxyman_config_proto_rawDesc = []byte{
 	0x01, 0x28, 0x05, 0x52, 0x0f, 0x78, 0x75, 0x64, 0x70, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72,
 	0x65, 0x6e, 0x63, 0x79, 0x12, 0x28, 0x0a, 0x0f, 0x78, 0x75, 0x64, 0x70, 0x50, 0x72, 0x6f, 0x78,
 	0x79, 0x55, 0x44, 0x50, 0x34, 0x34, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x78,
-	0x75, 0x64, 0x70, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x55, 0x44, 0x50, 0x34, 0x34, 0x33, 0x12, 0x24,
-	0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x75, 0x73, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x75, 0x73, 0x65, 0x54,
-	0x69, 0x6d, 0x65, 0x73, 0x42, 0x55, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x72, 0x61, 0x79,
-	0x2e, 0x61, 0x70, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x6d, 0x61, 0x6e, 0x50, 0x01, 0x5a,
-	0x26, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x74, 0x6c, 0x73,
-	0x2f, 0x78, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x70,
-	0x72, 0x6f, 0x78, 0x79, 0x6d, 0x61, 0x6e, 0xaa, 0x02, 0x11, 0x58, 0x72, 0x61, 0x79, 0x2e, 0x41,
-	0x70, 0x70, 0x2e, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x6d, 0x61, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x75, 0x64, 0x70, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x55, 0x44, 0x50, 0x34, 0x34, 0x33, 0x42, 0x55,
+	0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x61, 0x70, 0x70, 0x2e, 0x70,
+	0x72, 0x6f, 0x78, 0x79, 0x6d, 0x61, 0x6e, 0x50, 0x01, 0x5a, 0x26, 0x67, 0x69, 0x74, 0x68, 0x75,
+	0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x74, 0x6c, 0x73, 0x2f, 0x78, 0x72, 0x61, 0x79, 0x2d,
+	0x63, 0x6f, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x6d, 0x61,
+	0x6e, 0xaa, 0x02, 0x11, 0x58, 0x72, 0x61, 0x79, 0x2e, 0x41, 0x70, 0x70, 0x2e, 0x50, 0x72, 0x6f,
+	0x78, 0x79, 0x6d, 0x61, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }

 var (
--- a/app/proxyman/config.proto
+++ b/app/proxyman/config.proto
@@ -95,6 +95,4 @@ message MultiplexingConfig {
  int32 xudpConcurrency = 3;
  // "reject" (default), "allow" or "skip".
  string xudpProxyUDP443 = 4;
-  // MaxReuseTimes for an connection
-  int32 maxReuseTimes = 5;
 }
--- a/app/proxyman/inbound/inbound.go
+++ b/app/proxyman/inbound/inbound.go
@@ -7,7 +7,6 @@ import (
 	"github.com/xtls/xray-core/app/proxyman"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/serial"
 	"github.com/xtls/xray-core/common/session"
 	"github.com/xtls/xray-core/core"
@@ -159,9 +158,6 @@ func NewHandler(ctx context.Context, config *core.InboundHandlerConfig) (inbound
 			Mark: streamSettings.SocketSettings.Mark,
 		})
 	}
-	if streamSettings != nil && streamSettings.ProtocolName == "splithttp" {
-		ctx = session.ContextWithAllowedNetwork(ctx, net.Network_UDP)
-	}

 	allocStrategy := receiverSettings.AllocationStrategy
 	if allocStrategy == nil || allocStrategy.Type == proxyman.AllocationStrategy_Always {
--- a/app/proxyman/outbound/handler.go
+++ b/app/proxyman/outbound/handler.go
@@ -114,12 +114,6 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou

 	if h.senderSettings != nil && h.senderSettings.MultiplexSettings != nil {
 		if config := h.senderSettings.MultiplexSettings; config.Enabled {
-			// MaxReuseTimes use 65535 as default, and it also means the upper limit of MaxReuseTimes
-			// Because in mux cool spec, connection ID is 2 bytes
-			MaxReuseTimes := uint32(65535)
-			if config.MaxReuseTimes != 0 && config.MaxReuseTimes < 65535 {
-				MaxReuseTimes = uint32(config.MaxReuseTimes)
-			}
 			if config.Concurrency < 0 {
 				h.mux = &mux.ClientManager{Enabled: false}
 			}
@@ -135,7 +129,7 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou
 							Dialer: h,
 							Strategy: mux.ClientStrategy{
 								MaxConcurrency: uint32(config.Concurrency),
-								MaxReuseTimes:  MaxReuseTimes,
+								MaxConnection:  128,
 							},
 						},
 					},
@@ -156,7 +150,7 @@ func NewHandler(ctx context.Context, config *core.OutboundHandlerConfig) (outbou
 							Dialer: h,
 							Strategy: mux.ClientStrategy{
 								MaxConcurrency: uint32(config.XudpConcurrency),
-								MaxReuseTimes:  128,
+								MaxConnection:  128,
 							},
 						},
 					},
--- a/app/router/balancing.go
+++ b/app/router/balancing.go
@@ -31,12 +31,6 @@ type RoundRobinStrategy struct {

 func (s *RoundRobinStrategy) InjectContext(ctx context.Context) {
 	s.ctx = ctx
-	if len(s.FallbackTag) > 0 {
-		common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
-			s.observatory = observatory
-			return nil
-		}))
-	}
 }

 func (s *RoundRobinStrategy) GetPrincipleTarget(strings []string) []string {
@@ -44,6 +38,12 @@ func (s *RoundRobinStrategy) GetPrincipleTarget(strings []string) []string {
 }

 func (s *RoundRobinStrategy) PickOutbound(tags []string) string {
+	if len(s.FallbackTag) > 0 && s.observatory == nil {
+		common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
+			s.observatory = observatory
+			return nil
+		}))
+	}
 	if s.observatory != nil {
 		observeReport, err := s.observatory.GetObservation(s.ctx)
 		if err == nil {
--- a/app/router/command/command.go
+++ b/app/router/command/command.go
@@ -135,7 +135,7 @@ func (s *service) Register(server *grpc.Server) {
 		vCoreDesc := RoutingService_ServiceDesc
 		vCoreDesc.ServiceName = "v2ray.core.app.router.command.RoutingService"
 		server.RegisterService(&vCoreDesc, rs)
-	}, false))
+	}))
 }

 func init() {
--- a/app/router/strategy_leastload.go
+++ b/app/router/strategy_leastload.go
@@ -58,12 +58,8 @@ type node struct {
 	RTTDeviationCost time.Duration
 }

-func (s *LeastLoadStrategy) InjectContext(ctx context.Context) {
-	s.ctx = ctx
-	common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
-		s.observer = observatory
-		return nil
-	}))
+func (l *LeastLoadStrategy) InjectContext(ctx context.Context) {
+	l.ctx = ctx
 }

 func (s *LeastLoadStrategy) PickOutbound(candidates []string) string {
@@ -140,8 +136,10 @@ func (s *LeastLoadStrategy) selectLeastLoad(nodes []*node) []*node {

 func (s *LeastLoadStrategy) getNodes(candidates []string, maxRTT time.Duration) []*node {
 	if s.observer == nil {
-		errors.LogError(s.ctx, "observer is nil")
-		return make([]*node, 0)
+		common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
+			s.observer = observatory
+			return nil
+		}))
 	}
 	observeResult, err := s.observer.GetObservation(s.ctx)
 	if err != nil {
--- a/app/router/strategy_leastping.go
+++ b/app/router/strategy_leastping.go
@@ -21,20 +21,19 @@ func (l *LeastPingStrategy) GetPrincipleTarget(strings []string) []string {

 func (l *LeastPingStrategy) InjectContext(ctx context.Context) {
 	l.ctx = ctx
-	common.Must(core.RequireFeatures(l.ctx, func(observatory extension.Observatory) error {
-		l.observatory = observatory
-		return nil
-	}))
 }

 func (l *LeastPingStrategy) PickOutbound(strings []string) string {
 	if l.observatory == nil {
-		errors.LogError(l.ctx, "observer is nil")
-		return ""
+		common.Must(core.RequireFeatures(l.ctx, func(observatory extension.Observatory) error {
+			l.observatory = observatory
+			return nil
+		}))
 	}
+
 	observeReport, err := l.observatory.GetObservation(l.ctx)
 	if err != nil {
-		errors.LogInfoInner(l.ctx, err, "cannot get observer report")
+		errors.LogInfoInner(l.ctx, err, "cannot get observe report")
 		return ""
 	}
 	outboundsList := outboundList(strings)
--- a/app/router/strategy_random.go
+++ b/app/router/strategy_random.go
@@ -20,12 +20,6 @@ type RandomStrategy struct {

 func (s *RandomStrategy) InjectContext(ctx context.Context) {
 	s.ctx = ctx
-	if len(s.FallbackTag) > 0 {
-		common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
-			s.observatory = observatory
-			return nil
-		}))
-	}
 }

 func (s *RandomStrategy) GetPrincipleTarget(strings []string) []string {
@@ -33,6 +27,12 @@ func (s *RandomStrategy) GetPrincipleTarget(strings []string) []string {
 }

 func (s *RandomStrategy) PickOutbound(candidates []string) string {
+	if len(s.FallbackTag) > 0 && s.observatory == nil {
+		common.Must(core.RequireFeatures(s.ctx, func(observatory extension.Observatory) error {
+			s.observatory = observatory
+			return nil
+		}))
+	}
 	if s.observatory != nil {
 		observeReport, err := s.observatory.GetObservation(s.ctx)
 		if err == nil {
--- a/common/common.go
+++ b/common/common.go
@@ -38,7 +38,7 @@ func Error2(v interface{}, err error) error {
 func envFile() (string, error) {
 	if file := os.Getenv("GOENV"); file != "" {
 		if file == "off" {
-			return "", errors.New("GOENV=off")
+			return "", fmt.Errorf("GOENV=off")
 		}
 		return file, nil
 	}
@@ -47,7 +47,7 @@ func envFile() (string, error) {
 		return "", err
 	}
 	if dir == "" {
-		return "", errors.New("missing user-config dir")
+		return "", fmt.Errorf("missing user-config dir")
 	}
 	return filepath.Join(dir, "go", "env"), nil
 }
@@ -60,7 +60,7 @@ func GetRuntimeEnv(key string) (string, error) {
 		return "", err
 	}
 	if file == "" {
-		return "", errors.New("missing runtime env file")
+		return "", fmt.Errorf("missing runtime env file")
 	}
 	var data []byte
 	var runtimeEnv string
--- a/common/mux/client.go
+++ b/common/mux/client.go
@@ -166,7 +166,7 @@ func (f *DialingWorkerFactory) Create() (*ClientWorker, error) {

 type ClientStrategy struct {
 	MaxConcurrency uint32
-	MaxReuseTimes  uint32
+	MaxConnection  uint32
 }

 type ClientWorker struct {
@@ -174,7 +174,6 @@ type ClientWorker struct {
 	link           transport.Link
 	done           *done.Instance
 	strategy       ClientStrategy
-	timeCretaed    time.Time
 }

 var (
@@ -189,7 +188,6 @@ func NewClientWorker(stream transport.Link, s ClientStrategy) (*ClientWorker, er
 		link:           stream,
 		done:           done.New(),
 		strategy:       s,
-		timeCretaed:    time.Now(),
 	}

 	go c.fetchOutput()
@@ -272,7 +270,7 @@ func fetchInput(ctx context.Context, s *Session, output buf.Writer) {

 func (m *ClientWorker) IsClosing() bool {
 	sm := m.sessionManager
-	if m.strategy.MaxReuseTimes > 0 && sm.Count() >= int(m.strategy.MaxReuseTimes) {
+	if m.strategy.MaxConnection > 0 && sm.Count() >= int(m.strategy.MaxConnection) {
 		return true
 	}
 	return false
@@ -300,8 +298,6 @@ func (m *ClientWorker) Dispatch(ctx context.Context, link *transport.Link) bool
 	if s == nil {
 		return false
 	}
-	errors.LogInfo(ctx, "allocated mux.cool subConnection ID: ", s.ID, "/", m.strategy.MaxReuseTimes)
-	errors.LogInfo(ctx, "living subConnections:", m.ActiveConnections(), "/", m.strategy.MaxConcurrency, ", this mux connection has been created for ", time.Since(m.timeCretaed).Truncate(time.Second))
 	s.input = link.Reader
 	s.output = link.Writer
 	go fetchInput(ctx, s, m.link.Writer)
--- a/common/mux/client_test.go
+++ b/common/mux/client_test.go
@@ -58,7 +58,7 @@ func TestClientWorkerClose(t *testing.T) {
 		Writer: w1,
 	}, mux.ClientStrategy{
 		MaxConcurrency: 4,
-		MaxReuseTimes:  4,
+		MaxConnection:  4,
 	})
 	common.Must(err)

@@ -68,7 +68,7 @@ func TestClientWorkerClose(t *testing.T) {
 		Writer: w2,
 	}, mux.ClientStrategy{
 		MaxConcurrency: 4,
-		MaxReuseTimes:  4,
+		MaxConnection:  4,
 	})
 	common.Must(err)

--- a/common/protocol/quic/sniff.go
+++ b/common/protocol/quic/sniff.go
@@ -8,7 +8,7 @@ import (
 	"encoding/binary"
 	"io"

-	"github.com/xtls/quic-go/quicvarint"
+	"github.com/quic-go/quic-go/quicvarint"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/buf"
 	"github.com/xtls/xray-core/common/bytespool"
--- a/common/reflect/marshal_test.go
+++ b/common/reflect/marshal_test.go
@@ -204,7 +204,9 @@ func getConfig() string {
 			  "security": "none",
 			  "wsSettings": {
 				"path": "/?ed=2048",
-				"host": "bing.com"
+				"headers": {
+				  "Host": "bing.com"
+				}
 			  }
 			}
 		  }
--- a/core/core.go
+++ b/core/core.go
@@ -18,8 +18,8 @@ import (

 var (
 	Version_x byte = 24
-	Version_y byte = 12
-	Version_z byte = 28
+	Version_y byte = 11
+	Version_z byte = 30
 )

 var (
--- a/core/xray.go
+++ b/core/xray.go
@@ -44,13 +44,22 @@ func getFeature(allFeatures []features.Feature, t reflect.Type) features.Feature
 	return nil
 }

-func (r *resolution) callbackResolution(allFeatures []features.Feature) error {
+func (r *resolution) resolve(allFeatures []features.Feature) (bool, error) {
+	var fs []features.Feature
+	for _, d := range r.deps {
+		f := getFeature(allFeatures, d)
+		if f == nil {
+			return false, nil
+		}
+		fs = append(fs, f)
+	}
+
 	callback := reflect.ValueOf(r.callback)
 	var input []reflect.Value
 	callbackType := callback.Type()
 	for i := 0; i < callbackType.NumIn(); i++ {
 		pt := callbackType.In(i)
-		for _, f := range allFeatures {
+		for _, f := range fs {
 			if reflect.TypeOf(f).AssignableTo(pt) {
 				input = append(input, reflect.ValueOf(f))
 				break
@@ -75,17 +84,15 @@ func (r *resolution) callbackResolution(allFeatures []features.Feature) error {
 		}
 	}

-	return err
+	return true, err
 }

 // Instance combines all Xray features.
 type Instance struct {
-	statusLock                 sync.Mutex
-	features                   []features.Feature
-	pendingResolutions         []resolution
-	pendingOptionalResolutions []resolution
-	running                    bool
-	resolveLock                sync.Mutex
+	access             sync.Mutex
+	features           []features.Feature
+	featureResolutions []resolution
+	running            bool

 	ctx context.Context
 }
@@ -146,14 +153,7 @@ func addOutboundHandlers(server *Instance, configs []*OutboundHandlerConfig) err
 // See Instance.RequireFeatures for more information.
 func RequireFeatures(ctx context.Context, callback interface{}) error {
 	v := MustFromContext(ctx)
-	return v.RequireFeatures(callback, false)
-}
-
-// OptionalFeatures is a helper function to aquire features from Instance in context.
-// See Instance.RequireFeatures for more information.
-func OptionalFeatures(ctx context.Context, callback interface{}) error {
-	v := MustFromContext(ctx)
-	return v.RequireFeatures(callback, true)
+	return v.RequireFeatures(callback)
 }

 // New returns a new Xray instance based on given configuration.
@@ -227,12 +227,9 @@ func initInstanceWithConfig(config *Config, server *Instance) (bool, error) {
 		}(),
 	)

-	server.resolveLock.Lock()
-	if server.pendingResolutions != nil {
-		server.resolveLock.Unlock()
+	if server.featureResolutions != nil {
 		return true, errors.New("not all dependencies are resolved.")
 	}
-	server.resolveLock.Unlock()

 	if err := addInboundHandlers(server, config.Inbound); err != nil {
 		return true, err
@@ -251,8 +248,8 @@ func (s *Instance) Type() interface{} {

 // Close shutdown the Xray instance.
 func (s *Instance) Close() error {
-	s.statusLock.Lock()
-	defer s.statusLock.Unlock()
+	s.access.Lock()
+	defer s.access.Unlock()

 	s.running = false

@@ -271,7 +268,7 @@ func (s *Instance) Close() error {

 // RequireFeatures registers a callback, which will be called when all dependent features are registered.
 // The callback must be a func(). All its parameters must be features.Feature.
-func (s *Instance) RequireFeatures(callback interface{}, optional bool) error {
+func (s *Instance) RequireFeatures(callback interface{}) error {
 	callbackType := reflect.TypeOf(callback)
 	if callbackType.Kind() != reflect.Func {
 		panic("not a function")
@@ -286,32 +283,17 @@ func (s *Instance) RequireFeatures(callback interface{}, optional bool) error {
 		deps:     featureTypes,
 		callback: callback,
 	}
-
-	s.resolveLock.Lock()
-	foundAll := true
-	for _, d := range r.deps {
-		f := getFeature(s.features, d)
-		if f == nil {
-			foundAll = false
-			break
-		}
-	}
-	if foundAll {
-		s.resolveLock.Unlock()
-		return r.callbackResolution(s.features)
-	} else {
-		if optional {
-			s.pendingOptionalResolutions = append(s.pendingOptionalResolutions, r)
-		} else {
-			s.pendingResolutions = append(s.pendingResolutions, r)
-		}
-		s.resolveLock.Unlock()
-		return nil
+	if finished, err := r.resolve(s.features); finished {
+		return err
 	}
+	s.featureResolutions = append(s.featureResolutions, r)
+	return nil
 }

 // AddFeature registers a feature into current Instance.
 func (s *Instance) AddFeature(feature features.Feature) error {
+	s.features = append(s.features, feature)
+
 	if s.running {
 		if err := feature.Start(); err != nil {
 			errors.LogInfoInner(s.ctx, err, "failed to start feature")
@@ -319,52 +301,27 @@ func (s *Instance) AddFeature(feature features.Feature) error {
 		return nil
 	}

-	s.resolveLock.Lock()
-	s.features = append(s.features, feature)
+	if s.featureResolutions == nil {
+		return nil
+	}

-	var availableResolution []resolution
-	var pending []resolution
-	for _, r := range s.pendingResolutions {
-		foundAll := true
-		for _, d := range r.deps {
-			f := getFeature(s.features, d)
-			if f == nil {
-				foundAll = false
-				break
-			}
+	var pendingResolutions []resolution
+	for _, r := range s.featureResolutions {
+		finished, err := r.resolve(s.features)
+		if finished && err != nil {
+			return err
 		}
-		if foundAll {
-			availableResolution = append(availableResolution, r)
-		} else {
-			pending = append(pending, r)
+		if !finished {
+			pendingResolutions = append(pendingResolutions, r)
 		}
 	}
-	s.pendingResolutions = pending
+	if len(pendingResolutions) == 0 {
+		s.featureResolutions = nil
+	} else if len(pendingResolutions) < len(s.featureResolutions) {
+		s.featureResolutions = pendingResolutions
+	}

-	var pendingOptional []resolution
-	for _, r := range s.pendingOptionalResolutions {
-		foundAll := true
-		for _, d := range r.deps {
-			f := getFeature(s.features, d)
-			if f == nil {
-				foundAll = false
-				break
-			}
-		}
-		if foundAll {
-			availableResolution = append(availableResolution, r)
-		} else {
-			pendingOptional = append(pendingOptional, r)
-		}
-	}
-	s.pendingOptionalResolutions = pendingOptional
-	s.resolveLock.Unlock()
-	
-	var err error
-	for _, r := range availableResolution {
-		err = r.callbackResolution(s.features) // only return the last error for now
-	}
-	return err
+	return nil
 }

 // GetFeature returns a feature of the given type, or nil if such feature is not registered.
@@ -377,8 +334,8 @@ func (s *Instance) GetFeature(featureType interface{}) features.Feature {
 //
 // xray:api:stable
 func (s *Instance) Start() error {
-	s.statusLock.Lock()
-	defer s.statusLock.Unlock()
+	s.access.Lock()
+	defer s.access.Unlock()

 	s.running = true
 	for _, f := range s.features {
--- a/core/xray_test.go
+++ b/core/xray_test.go
@@ -30,7 +30,7 @@ func TestXrayDependency(t *testing.T) {
 			t.Error("expected dns client fulfilled, but actually nil")
 		}
 		wait <- true
-	}, false)
+	})
 	instance.AddFeature(localdns.New())
 	<-wait
 }
--- a/go.mod
+++ b/go.mod
@@ -12,6 +12,7 @@ require (
 	github.com/miekg/dns v1.1.62
 	github.com/pelletier/go-toml v1.9.5
 	github.com/pires/go-proxyproto v0.8.0
+	github.com/quic-go/quic-go v0.46.0
 	github.com/refraction-networking/utls v1.6.7
 	github.com/sagernet/sing v0.5.1
 	github.com/sagernet/sing-shadowsocks v0.2.7
@@ -19,16 +20,15 @@ require (
 	github.com/stretchr/testify v1.10.0
 	github.com/v2fly/ss-bloomring v0.0.0-20210312155135-28617310f63e
 	github.com/vishvananda/netlink v1.3.0
-	github.com/xtls/quic-go v0.0.0-20241220091641-6f5777d1c087
 	github.com/xtls/reality v0.0.0-20240712055506-48f0b2d5ed6d
 	go4.org/netipx v0.0.0-20231129151722-fdeea329fbba
-	golang.org/x/crypto v0.31.0
-	golang.org/x/net v0.33.0
-	golang.org/x/sync v0.10.0
-	golang.org/x/sys v0.28.0
+	golang.org/x/crypto v0.29.0
+	golang.org/x/net v0.31.0
+	golang.org/x/sync v0.9.0
+	golang.org/x/sys v0.27.0
 	golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173
 	google.golang.org/grpc v1.67.1
-	google.golang.org/protobuf v1.36.1
+	google.golang.org/protobuf v1.35.2
 	gvisor.dev/gvisor v0.0.0-20231202080848-1f7806d17489
 	h12.io/socks v1.0.3
 	lukechampine.com/blake3 v1.3.0
@@ -51,7 +51,7 @@ require (
 	go.uber.org/mock v0.4.0 // indirect
 	golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc // indirect
 	golang.org/x/mod v0.18.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/text v0.20.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	golang.org/x/tools v0.22.0 // indirect
 	golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect
--- a/go.sum
+++ b/go.sum
@@ -48,6 +48,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
+github.com/quic-go/quic-go v0.46.0 h1:uuwLClEEyk1DNvchH8uCByQVjo3yKL9opKulExNDs7Y=
+github.com/quic-go/quic-go v0.46.0/go.mod h1:1dLehS7TIR64+vxGR70GDcatWTOtMX2PUtnKsjbTurI=
 github.com/refraction-networking/utls v1.6.7 h1:zVJ7sP1dJx/WtVuITug3qYUq034cDq9B2MR1K67ULZM=
 github.com/refraction-networking/utls v1.6.7/go.mod h1:BC3O4vQzye5hqpmDTWUqi4P5DDhzJfkV1tdqtawQIH0=
 github.com/riobard/go-bloom v0.0.0-20200614022211-cdc8013cb5b3 h1:f/FNXud6gA3MNr8meMVVGxhp+QBTqY91tM8HjEuMjGg=
@@ -68,8 +70,6 @@ github.com/vishvananda/netlink v1.3.0 h1:X7l42GfcV4S6E4vHTsw48qbrV+9PVojNfIhZcwQ
 github.com/vishvananda/netlink v1.3.0/go.mod h1:i6NetklAujEcC6fK0JPjT8qSwWyO0HLn4UKG+hGqeJs=
 github.com/vishvananda/netns v0.0.4 h1:Oeaw1EM2JMxD51g9uhtC0D7erkIjgmj8+JZc26m1YX8=
 github.com/vishvananda/netns v0.0.4/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
-github.com/xtls/quic-go v0.0.0-20241220091641-6f5777d1c087 h1:kKPg/cJPSKnE50VXVBskDYYSBkl4X3sMCIbTy+XKNGk=
-github.com/xtls/quic-go v0.0.0-20241220091641-6f5777d1c087/go.mod h1:mN9lAuc8Vt7eHvnQkDIH5+uHh+DcLmTBma9rLqk/rPY=
 github.com/xtls/reality v0.0.0-20240712055506-48f0b2d5ed6d h1:+B97uD9uHLgAAulhigmys4BVwZZypzK7gPN3WtpgRJg=
 github.com/xtls/reality v0.0.0-20240712055506-48f0b2d5ed6d/go.mod h1:dm4y/1QwzjGaK17ofi0Vs6NpKAHegZky8qk6J2JJZAE=
 github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
@@ -79,8 +79,8 @@ go4.org/netipx v0.0.0-20231129151722-fdeea329fbba h1:0b9z3AuHCjxk0x/opv64kcgZLBs
 go4.org/netipx v0.0.0-20231129151722-fdeea329fbba/go.mod h1:PLyyIXexvUFg3Owu6p/WfdlivPbZJsZdgWZlrGope/Y=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
 golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc h1:O9NuF4s+E/PvMIy+9IUZB9znFwUIXEWSstNjek6VpVg=
 golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
@@ -89,12 +89,12 @@ golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -103,14 +103,14 @@ golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -129,8 +129,8 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
 google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
 google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
-google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
-google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io=
+google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/infra/conf/grpc.go
+++ b/infra/conf/grpc.go
@@ -14,6 +14,7 @@ type GRPCConfig struct {
 	PermitWithoutStream bool   `json:"permit_without_stream"`
 	InitialWindowsSize  int32  `json:"initial_windows_size"`
 	UserAgent           string `json:"user_agent"`
+	MultiConnections	int32  `json:"multi_connections"`
 }

 func (g *GRPCConfig) Build() (proto.Message, error) {
@@ -37,5 +38,6 @@ func (g *GRPCConfig) Build() (proto.Message, error) {
 		PermitWithoutStream: g.PermitWithoutStream,
 		InitialWindowsSize:  g.InitialWindowsSize,
 		UserAgent:           g.UserAgent,
+		MultiConnections:    g.MultiConnections,
 	}, nil
 }
--- a/infra/conf/transport_internet.go
+++ b/infra/conf/transport_internet.go
@@ -163,15 +163,13 @@ func (c *WebSocketConfig) Build() (proto.Message, error) {
 			path = u.String()
 		}
 	}
-	// Priority (client): host > serverName > address
-	for k, v := range c.Headers {
-		if strings.ToLower(k) == "host" {
-			errors.PrintDeprecatedFeatureWarning(`"host" in "headers"`, `independent "host"`)
-			if c.Host == "" {
-				c.Host = v
-			}
-			delete(c.Headers, k)
-		}
+	// If http host is not set in the Host field, but in headers field, we add it to Host Field here.
+	// If we don't do that, http host will be overwritten as address.
+	// Host priority: Host field > headers field > address.
+	if c.Host == "" && c.Headers["host"] != "" {
+		c.Host = c.Headers["host"]
+	} else if c.Host == "" && c.Headers["Host"] != "" {
+		c.Host = c.Headers["Host"]
 	}
 	config := &websocket.Config{
 		Path:                path,
@@ -204,11 +202,15 @@ func (c *HttpUpgradeConfig) Build() (proto.Message, error) {
 			path = u.String()
 		}
 	}
-	// Priority (client): host > serverName > address
-	for k := range c.Headers {
-		if strings.ToLower(k) == "host" {
-			return nil, errors.New(`"headers" can't contain "host"`)
-		}
+	// If http host is not set in the Host field, but in headers field, we add it to Host Field here.
+	// If we don't do that, http host will be overwritten as address.
+	// Host priority: Host field > headers field > address.
+	if c.Host == "" && c.Headers["host"] != "" {
+		c.Host = c.Headers["host"]
+		delete(c.Headers, "host")
+	} else if c.Host == "" && c.Headers["Host"] != "" {
+		c.Host = c.Headers["Host"]
+		delete(c.Headers, "Host")
 	}
 	config := &httpupgrade.Config{
 		Path:                path,
@@ -223,30 +225,36 @@ func (c *HttpUpgradeConfig) Build() (proto.Message, error) {
 type SplitHTTPConfig struct {
 	Host                 string            `json:"host"`
 	Path                 string            `json:"path"`
-	Mode                 string            `json:"mode"`
 	Headers              map[string]string `json:"headers"`
-	XPaddingBytes        Int32Range        `json:"xPaddingBytes"`
-	NoGRPCHeader         bool              `json:"noGRPCHeader"`
+	ScMaxConcurrentPosts *Int32Range       `json:"scMaxConcurrentPosts"`
+	ScMaxEachPostBytes   *Int32Range       `json:"scMaxEachPostBytes"`
+	ScMinPostsIntervalMs *Int32Range       `json:"scMinPostsIntervalMs"`
 	NoSSEHeader          bool              `json:"noSSEHeader"`
-	ScMaxEachPostBytes   Int32Range        `json:"scMaxEachPostBytes"`
-	ScMinPostsIntervalMs Int32Range        `json:"scMinPostsIntervalMs"`
-	ScMaxBufferedPosts   int64             `json:"scMaxBufferedPosts"`
-	Xmux                 XmuxConfig        `json:"xmux"`
+	XPaddingBytes        *Int32Range       `json:"xPaddingBytes"`
+	Xmux                 Xmux              `json:"xmux"`
 	DownloadSettings     *StreamConfig     `json:"downloadSettings"`
+	Mode                 string            `json:"mode"`
 	Extra                json.RawMessage   `json:"extra"`
+	NoGRPCHeader         bool              `json:"noGRPCHeader"`
+	KeepAlivePeriod      int64             `json:"keepAlivePeriod"`
 }

-type XmuxConfig struct {
-	MaxConcurrency   Int32Range `json:"maxConcurrency"`
-	MaxConnections   Int32Range `json:"maxConnections"`
-	CMaxReuseTimes   Int32Range `json:"cMaxReuseTimes"`
-	HMaxRequestTimes Int32Range `json:"hMaxRequestTimes"`
-	HMaxReusableSecs Int32Range `json:"hMaxReusableSecs"`
-	HKeepAlivePeriod int64      `json:"hKeepAlivePeriod"`
+type Xmux struct {
+	MaxConcurrency *Int32Range `json:"maxConcurrency"`
+	MaxConnections *Int32Range `json:"maxConnections"`
+	CMaxReuseTimes *Int32Range `json:"cMaxReuseTimes"`
+	CMaxLifetimeMs *Int32Range `json:"cMaxLifetimeMs"`
 }

-func newRangeConfig(input Int32Range) *splithttp.RangeConfig {
-	return &splithttp.RangeConfig{
+func splithttpNewRandRangeConfig(input *Int32Range) *splithttp.RandRangeConfig {
+	if input == nil {
+		return &splithttp.RandRangeConfig{
+			From: 0,
+			To:   0,
+		}
+	}
+
+	return &splithttp.RandRangeConfig{
 		From: input.From,
 		To:   input.To,
 	}
@@ -266,6 +274,37 @@ func (c *SplitHTTPConfig) Build() (proto.Message, error) {
 		c = &extra
 	}

+	// If http host is not set in the Host field, but in headers field, we add it to Host Field here.
+	// If we don't do that, http host will be overwritten as address.
+	// Host priority: Host field > headers field > address.
+	if c.Host == "" && c.Headers["host"] != "" {
+		c.Host = c.Headers["host"]
+	} else if c.Host == "" && c.Headers["Host"] != "" {
+		c.Host = c.Headers["Host"]
+	}
+
+	if c.Xmux.MaxConnections != nil && c.Xmux.MaxConnections.To > 0 && c.Xmux.MaxConcurrency != nil && c.Xmux.MaxConcurrency.To > 0 {
+		return nil, errors.New("maxConnections cannot be specified together with maxConcurrency")
+	}
+
+	// Multiplexing config
+	muxProtobuf := splithttp.Multiplexing{
+		MaxConcurrency: splithttpNewRandRangeConfig(c.Xmux.MaxConcurrency),
+		MaxConnections: splithttpNewRandRangeConfig(c.Xmux.MaxConnections),
+		CMaxReuseTimes: splithttpNewRandRangeConfig(c.Xmux.CMaxReuseTimes),
+		CMaxLifetimeMs: splithttpNewRandRangeConfig(c.Xmux.CMaxLifetimeMs),
+	}
+
+	if muxProtobuf.MaxConcurrency.To == 0 &&
+		muxProtobuf.MaxConnections.To == 0 &&
+		muxProtobuf.CMaxReuseTimes.To == 0 &&
+		muxProtobuf.CMaxLifetimeMs.To == 0 {
+		muxProtobuf.MaxConcurrency.From = 16
+		muxProtobuf.MaxConcurrency.To = 32
+		muxProtobuf.CMaxReuseTimes.From = 64
+		muxProtobuf.CMaxReuseTimes.To = 128
+	}
+
 	switch c.Mode {
 	case "":
 		c.Mode = "auto"
@@ -274,46 +313,21 @@ func (c *SplitHTTPConfig) Build() (proto.Message, error) {
 		return nil, errors.New("unsupported mode: " + c.Mode)
 	}

-	// Priority (client): host > serverName > address
-	for k := range c.Headers {
-		if strings.ToLower(k) == "host" {
-			return nil, errors.New(`"headers" can't contain "host"`)
-		}
-	}
-
-	if c.Xmux.MaxConnections.To > 0 && c.Xmux.MaxConcurrency.To > 0 {
-		return nil, errors.New("maxConnections cannot be specified together with maxConcurrency")
-	}
-	if c.Xmux == (XmuxConfig{}) {
-		c.Xmux.MaxConcurrency.From = 16
-		c.Xmux.MaxConcurrency.To = 32
-		c.Xmux.HMaxRequestTimes.From = 600
-		c.Xmux.HMaxRequestTimes.To = 900
-		c.Xmux.HMaxReusableSecs.From = 1800
-		c.Xmux.HMaxReusableSecs.To = 3000
-	}
-
 	config := &splithttp.Config{
-		Host:                 c.Host,
 		Path:                 c.Path,
-		Mode:                 c.Mode,
-		Headers:              c.Headers,
-		XPaddingBytes:        newRangeConfig(c.XPaddingBytes),
-		NoGRPCHeader:         c.NoGRPCHeader,
+		Host:                 c.Host,
+		Header:               c.Headers,
+		ScMaxConcurrentPosts: splithttpNewRandRangeConfig(c.ScMaxConcurrentPosts),
+		ScMaxEachPostBytes:   splithttpNewRandRangeConfig(c.ScMaxEachPostBytes),
+		ScMinPostsIntervalMs: splithttpNewRandRangeConfig(c.ScMinPostsIntervalMs),
 		NoSSEHeader:          c.NoSSEHeader,
-		ScMaxEachPostBytes:   newRangeConfig(c.ScMaxEachPostBytes),
-		ScMinPostsIntervalMs: newRangeConfig(c.ScMinPostsIntervalMs),
-		ScMaxBufferedPosts:   c.ScMaxBufferedPosts,
-		Xmux: &splithttp.XmuxConfig{
-			MaxConcurrency:   newRangeConfig(c.Xmux.MaxConcurrency),
-			MaxConnections:   newRangeConfig(c.Xmux.MaxConnections),
-			CMaxReuseTimes:   newRangeConfig(c.Xmux.CMaxReuseTimes),
-			HMaxRequestTimes: newRangeConfig(c.Xmux.HMaxRequestTimes),
-			HMaxReusableSecs: newRangeConfig(c.Xmux.HMaxReusableSecs),
-			HKeepAlivePeriod: c.Xmux.HKeepAlivePeriod,
-		},
+		XPaddingBytes:        splithttpNewRandRangeConfig(c.XPaddingBytes),
+		Xmux:                 &muxProtobuf,
+		Mode:                 c.Mode,
+		NoGRPCHeader:         c.NoGRPCHeader,
+		KeepAlivePeriod:      c.KeepAlivePeriod,
 	}
-
+	var err error
 	if c.DownloadSettings != nil {
 		if c.Mode == "stream-one" {
 			return nil, errors.New(`Can not use "downloadSettings" in "stream-one" mode.`)
@@ -321,12 +335,10 @@ func (c *SplitHTTPConfig) Build() (proto.Message, error) {
 		if c.Extra != nil {
 			c.DownloadSettings.SocketSettings = nil
 		}
-		var err error
 		if config.DownloadSettings, err = c.DownloadSettings.Build(); err != nil {
 			return nil, errors.New(`Failed to build "downloadSettings".`).Base(err)
 		}
 	}
-
 	return config, nil
 }

@@ -438,7 +450,7 @@ func (c *TLSConfig) Build() (proto.Message, error) {
 	config.MaxVersion = c.MaxVersion
 	config.CipherSuites = c.CipherSuites
 	config.Fingerprint = strings.ToLower(c.Fingerprint)
-	if config.Fingerprint != "unsafe" && tls.GetFingerprint(config.Fingerprint) == nil {
+	if config.Fingerprint != "" && tls.GetFingerprint(config.Fingerprint) == nil {
 		return nil, errors.New(`unknown fingerprint: `, config.Fingerprint)
 	}
 	config.RejectUnknownSni = c.RejectUnknownSNI
@@ -584,13 +596,15 @@ func (c *REALITYConfig) Build() (proto.Message, error) {
 		config.ServerNames = c.ServerNames
 		config.MaxTimeDiff = c.MaxTimeDiff
 	} else {
-		config.Fingerprint = strings.ToLower(c.Fingerprint)
-		if config.Fingerprint == "unsafe" || config.Fingerprint == "hellogolang" {
-			return nil, errors.New(`invalid "fingerprint": `, config.Fingerprint)
+		if c.Fingerprint == "" {
+			return nil, errors.New(`empty "fingerprint"`)
 		}
-		if tls.GetFingerprint(config.Fingerprint) == nil {
+		if config.Fingerprint = strings.ToLower(c.Fingerprint); tls.GetFingerprint(config.Fingerprint) == nil {
 			return nil, errors.New(`unknown "fingerprint": `, config.Fingerprint)
 		}
+		if config.Fingerprint == "hellogolang" {
+			return nil, errors.New(`invalid "fingerprint": `, config.Fingerprint)
+		}
 		if len(c.ServerNames) != 0 {
 			return nil, errors.New(`non-empty "serverNames", please use "serverName" instead`)
 		}
--- a/infra/conf/xray.go
+++ b/infra/conf/xray.go
@@ -97,7 +97,6 @@ func (c *SniffingConfig) Build() (*proxyman.SniffingConfig, error) {
 type MuxConfig struct {
 	Enabled         bool   `json:"enabled"`
 	Concurrency     int16  `json:"concurrency"`
-	MaxReuseTimes   int32  `json:"maxReuseTimes"`
 	XudpConcurrency int16  `json:"xudpConcurrency"`
 	XudpProxyUDP443 string `json:"xudpProxyUDP443"`
 }
@@ -114,7 +113,6 @@ func (m *MuxConfig) Build() (*proxyman.MultiplexingConfig, error) {
 	return &proxyman.MultiplexingConfig{
 		Enabled:         m.Enabled,
 		Concurrency:     int32(m.Concurrency),
-		MaxReuseTimes:   m.MaxReuseTimes,
 		XudpConcurrency: int32(m.XudpConcurrency),
 		XudpProxyUDP443: m.XudpProxyUDP443,
 	}, nil
--- a/infra/conf/xray_test.go
+++ b/infra/conf/xray_test.go
@@ -48,7 +48,9 @@ func TestXrayConfig(t *testing.T) {
 					"streamSettings": {
 						"network": "ws",
 						"wsSettings": {
-							"host": "example.domain",
+							"headers": {
+								"host": "example.domain"
+							},
 							"path": ""
 						},
 						"tlsSettings": {
@@ -137,6 +139,9 @@ func TestXrayConfig(t *testing.T) {
 										ProtocolName: "websocket",
 										Settings: serial.ToTypedMessage(&websocket.Config{
 											Host: "example.domain",
+											Header: map[string]string{
+												"host": "example.domain",
+											},
 										}),
 									},
 								},
--- a/infra/vformat/main.go
+++ b/infra/vformat/main.go
@@ -1,7 +1,6 @@
 package main

 import (
-	"errors"
 	"flag"
 	"fmt"
 	"go/build"
@@ -19,7 +18,7 @@ var directory = flag.String("pwd", "", "Working directory of Xray vformat.")
 func envFile() (string, error) {
 	if file := os.Getenv("GOENV"); file != "" {
 		if file == "off" {
-			return "", errors.New("GOENV=off")
+			return "", fmt.Errorf("GOENV=off")
 		}
 		return file, nil
 	}
@@ -28,7 +27,7 @@ func envFile() (string, error) {
 		return "", err
 	}
 	if dir == "" {
-		return "", errors.New("missing user-config dir")
+		return "", fmt.Errorf("missing user-config dir")
 	}
 	return filepath.Join(dir, "go", "env"), nil
 }
@@ -41,7 +40,7 @@ func GetRuntimeEnv(key string) (string, error) {
 		return "", err
 	}
 	if file == "" {
-		return "", errors.New("missing runtime env file")
+		return "", fmt.Errorf("missing runtime env file")
 	}
 	var data []byte
 	var runtimeEnv string
--- a/infra/vprotogen/main.go
+++ b/infra/vprotogen/main.go
@@ -1,7 +1,6 @@
 package main

 import (
-	"errors"
 	"flag"
 	"fmt"
 	"go/build"
@@ -23,7 +22,7 @@ var directory = flag.String("pwd", "", "Working directory of Xray vprotogen.")
 func envFile() (string, error) {
 	if file := os.Getenv("GOENV"); file != "" {
 		if file == "off" {
-			return "", errors.New("GOENV=off")
+			return "", fmt.Errorf("GOENV=off")
 		}
 		return file, nil
 	}
@@ -32,7 +31,7 @@ func envFile() (string, error) {
 		return "", err
 	}
 	if dir == "" {
-		return "", errors.New("missing user-config dir")
+		return "", fmt.Errorf("missing user-config dir")
 	}
 	return filepath.Join(dir, "go", "env"), nil
 }
@@ -45,7 +44,7 @@ func GetRuntimeEnv(key string) (string, error) {
 		return "", err
 	}
 	if file == "" {
-		return "", errors.New("missing runtime env file")
+		return "", fmt.Errorf("missing runtime env file")
 	}
 	var data []byte
 	var runtimeEnv string
@@ -102,12 +101,12 @@ Download %s v%s or later from https://github.com/protocolbuffers/protobuf/releas
 func getProjectProtocVersion(url string) (string, error) {
 	resp, err := http.Get(url)
 	if err != nil {
-		return "", errors.New("can not get the version of protobuf used in xray project")
+		return "", fmt.Errorf("can not get the version of protobuf used in xray project")
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", errors.New("can not read from body")
+		return "", fmt.Errorf("can not read from body")
 	}
 	versionRegexp := regexp.MustCompile(`\/\/\s*protoc\s*v\d+\.(\d+\.\d+)`)
 	matched := versionRegexp.FindStringSubmatch(string(body))
--- a/main/commands/all/api/shared.go
+++ b/main/commands/all/api/shared.go
@@ -3,7 +3,6 @@ package api
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -102,7 +101,7 @@ func fetchHTTPContent(target string) ([]byte, error) {

 	content, err := buf.ReadAllToBytes(resp.Body)
 	if err != nil {
-		return nil, errors.New("failed to read HTTP response")
+		return nil, fmt.Errorf("failed to read HTTP response")
 	}

 	return content, nil
--- a/proxy/dns/dns.go
+++ b/proxy/dns/dns.go
@@ -27,7 +27,7 @@ func init() {
 	common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
 		h := new(Handler)
 		if err := core.RequireFeatures(ctx, func(dnsClient dns.Client, policyManager policy.Manager) error {
-			core.OptionalFeatures(ctx, func(fdns dns.FakeDNSEngine) {
+			core.RequireFeatures(ctx, func(fdns dns.FakeDNSEngine) {
 				h.fdns = fdns
 			})
 			return h.Init(config.(*Config), dnsClient, policyManager)
--- a/proxy/dokodemo/dokodemo.go
+++ b/proxy/dokodemo/dokodemo.go
@@ -2,7 +2,6 @@ package dokodemo

 import (
 	"context"
-	"runtime"
 	"sync/atomic"

 	"github.com/xtls/xray-core/common"
@@ -148,6 +147,10 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn st
 		return nil
 	}

+	tproxyRequest := func() error {
+		return nil
+	}
+
 	var writer buf.Writer
 	if network == net.Network_TCP {
 		writer = buf.NewWriter(conn)
@@ -177,12 +180,7 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn st
 				return err
 			}
 			writer = NewPacketWriter(pConn, &dest, mark, back)
-			defer func() {
-				runtime.Gosched()
-				common.Interrupt(link.Reader) // maybe duplicated
-				runtime.Gosched()
-				writer.(*PacketWriter).Close() // close fake UDP conns
-			}()
+			defer writer.(*PacketWriter).Close()
 			/*
 				sockopt := &internet.SocketConfig{
 					Tproxy: internet.SocketConfig_TProxy,
@@ -221,24 +219,17 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn st
 	responseDone := func() error {
 		defer timer.SetTimeout(plcy.Timeouts.UplinkOnly)

-		if network == net.Network_UDP && destinationOverridden {
-			buf.Copy(link.Reader, writer) // respect upload's timeout
-			return nil
-		}
-
 		if err := buf.Copy(link.Reader, writer, buf.UpdateActivity(timer)); err != nil {
 			return errors.New("failed to transport response").Base(err)
 		}
 		return nil
 	}

-	if err := task.Run(ctx,
-		task.OnSuccess(func() error { return task.Run(ctx, requestDone) }, task.Close(link.Writer)),
-		responseDone); err != nil {
-		runtime.Gosched()
-		common.Interrupt(link.Writer)
-		runtime.Gosched()
+	if err := task.Run(ctx, task.OnSuccess(func() error {
+		return task.Run(ctx, requestDone, tproxyRequest)
+	}, task.Close(link.Writer)), responseDone); err != nil {
 		common.Interrupt(link.Reader)
+		common.Interrupt(link.Writer)
 		return errors.New("connection ends").Base(err)
 	}

--- a/proxy/wireguard/server.go
+++ b/proxy/wireguard/server.go
@@ -144,15 +144,14 @@ func (s *Server) forwardConnection(dest net.Destination, conn net.Conn) {
 		Reason: "",
 	})

-	if s.info.inboundTag != nil {
-		ctx = session.ContextWithInbound(ctx, s.info.inboundTag)
-	}
-
 	// what's this?
 	// Session information should not be shared between different connections
 	// why reuse them in server level? This will cause incorrect destoverride and unexpected routing behavior.
 	// Disable it temporarily. Maybe s.info should be removed.

+	//  if s.info.inboundTag != nil {
+	//  ctx = session.ContextWithInbound(ctx, s.info.inboundTag)
+	//  }
 	//	if s.info.outboundTag != nil {
 	//		ctx = session.ContextWithOutbounds(ctx, []*session.Outbound{s.info.outboundTag})
 	//	}
--- a/transport/internet/grpc/config.pb.go
+++ b/transport/internet/grpc/config.pb.go
@@ -33,6 +33,7 @@ type Config struct {
 	PermitWithoutStream bool   `protobuf:"varint,6,opt,name=permit_without_stream,json=permitWithoutStream,proto3" json:"permit_without_stream,omitempty"`
 	InitialWindowsSize  int32  `protobuf:"varint,7,opt,name=initial_windows_size,json=initialWindowsSize,proto3" json:"initial_windows_size,omitempty"`
 	UserAgent           string `protobuf:"bytes,8,opt,name=user_agent,json=userAgent,proto3" json:"user_agent,omitempty"`
+	MultiConnections    int32  `protobuf:"varint,9,opt,name=multi_connections,json=multiConnections,proto3" json:"multi_connections,omitempty"`
 }

 func (x *Config) Reset() {
@@ -121,6 +122,13 @@ func (x *Config) GetUserAgent() string {
 	return ""
 }

+func (x *Config) GetMultiConnections() int32 {
+	if x != nil {
+		return x.MultiConnections
+	}
+	return 0
+}
+
 var File_transport_internet_grpc_config_proto protoreflect.FileDescriptor

 var file_transport_internet_grpc_config_proto_rawDesc = []byte{
@@ -128,7 +136,7 @@ var file_transport_internet_grpc_config_proto_rawDesc = []byte{
 	0x72, 0x6e, 0x65, 0x74, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
 	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x25, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61,
 	0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e,
-	0x67, 0x72, 0x70, 0x63, 0x2e, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x22, 0xc2, 0x02,
+	0x67, 0x72, 0x70, 0x63, 0x2e, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x22, 0xef, 0x02,
 	0x0a, 0x06, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
 	0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74,
 	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
@@ -149,10 +157,13 @@ var file_transport_internet_grpc_config_proto_rawDesc = []byte{
 	0x12, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x53,
 	0x69, 0x7a, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x61, 0x67, 0x65, 0x6e,
 	0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x75, 0x73, 0x65, 0x72, 0x41, 0x67, 0x65,
-	0x6e, 0x74, 0x42, 0x33, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
-	0x2f, 0x78, 0x74, 0x6c, 0x73, 0x2f, 0x78, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f,
-	0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
-	0x65, 0x74, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x63, 0x6f, 0x6e, 0x6e,
+	0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6d,
+	0x75, 0x6c, 0x74, 0x69, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42,
+	0x33, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x74,
+	0x6c, 0x73, 0x2f, 0x78, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x72, 0x61,
+	0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2f,
+	0x67, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }

 var (
--- a/transport/internet/grpc/config.proto
+++ b/transport/internet/grpc/config.proto
@@ -12,4 +12,5 @@ message Config {
  bool permit_without_stream = 6;
  int32 initial_windows_size = 7;
  string user_agent = 8;
+  int32 multi_connections = 9;
 }
--- a/transport/internet/grpc/dial.go
+++ b/transport/internet/grpc/dial.go
@@ -8,6 +8,7 @@ import (

 	"github.com/xtls/xray-core/common"
 	c "github.com/xtls/xray-core/common/ctx"
+	"github.com/xtls/xray-core/common/dice"
 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
 	"github.com/xtls/xray-core/common/session"
@@ -42,8 +43,61 @@ type dialerConf struct {
 	*internet.MemoryStreamConfig
 }

+type globalDialers struct {
+	connMap map[dialerConf][]*grpc.ClientConn
+}
+
+// getClientConn returns a client connection from the global dialer if the connections already reached the target number
+// otherwise return nil
+func (d *globalDialers) getClientConn(conf dialerConf) (*grpc.ClientConn, int) {
+	if d.connMap == nil {
+		d.connMap = make(map[dialerConf][]*grpc.ClientConn)
+	}
+	if d.connMap[conf] == nil {
+		d.connMap[conf] = []*grpc.ClientConn{}
+	}
+
+	conns := d.connMap[conf]
+
+	targetConnsNum := conf.MemoryStreamConfig.ProtocolSettings.(*Config).MultiConnections
+	if targetConnsNum > int32(len(conns)) {
+		return nil, 0
+	} else {
+		index := dice.Roll(len(conns))
+		return conns[index], index
+	}
+}
+
+// addClientConn adds a client connection to the global dialer
+func (d *globalDialers) addClientConn(conf dialerConf, conn *grpc.ClientConn) error {
+	if d.connMap == nil {
+		d.connMap = make(map[dialerConf][]*grpc.ClientConn)
+	}
+	if d.connMap[conf] == nil {
+		d.connMap[conf] = []*grpc.ClientConn{}
+	}
+
+	conns := d.connMap[conf]
+	targetConnsNum := conf.MemoryStreamConfig.ProtocolSettings.(*Config).MultiConnections
+	if targetConnsNum <= int32(len(conns)) {
+		return errors.New("failed to add client connection beacuse reach the limit")
+	} else {
+		conns = append(conns, conn)
+		d.connMap[conf] = conns
+		return nil
+	}
+}
+
+// updateClientConnWithIndex updates a client connection with the given index
+// in the case if the clientConn is shutting down, replace it with the new one
+func (d *globalDialers) updateClientConnWithIndex(conf dialerConf, conn *grpc.ClientConn, index int) error {
+	conns := d.connMap[conf]
+	conns[index] = conn
+	return nil
+}
+
 var (
-	globalDialerMap    map[dialerConf]*grpc.ClientConn
+	globalDialer       globalDialers
 	globalDialerAccess sync.Mutex
 )

@@ -77,15 +131,13 @@ func getGrpcClient(ctx context.Context, dest net.Destination, streamSettings *in
 	globalDialerAccess.Lock()
 	defer globalDialerAccess.Unlock()

-	if globalDialerMap == nil {
-		globalDialerMap = make(map[dialerConf]*grpc.ClientConn)
-	}
 	tlsConfig := tls.ConfigFromStreamSettings(streamSettings)
 	realityConfig := reality.ConfigFromStreamSettings(streamSettings)
 	sockopt := streamSettings.SocketSettings
 	grpcSettings := streamSettings.ProtocolSettings.(*Config)

-	if client, found := globalDialerMap[dialerConf{dest, streamSettings}]; found && client.GetState() != connectivity.Shutdown {
+	client, index := globalDialer.getClientConn(dialerConf{dest, streamSettings})
+	if client != nil && client.GetState() != connectivity.Shutdown {
 		return client, nil
 	}

@@ -183,6 +235,14 @@ func getGrpcClient(ctx context.Context, dest net.Destination, streamSettings *in
 		gonet.JoinHostPort(grpcDestHost, dest.Port.String()),
 		dialOptions...,
 	)
-	globalDialerMap[dialerConf{dest, streamSettings}] = conn
+	if client == nil {
+		err := globalDialer.addClientConn(dialerConf{dest, streamSettings}, conn)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if client != nil && client.GetState() == connectivity.Shutdown {
+		globalDialer.updateClientConnWithIndex(dialerConf{dest, streamSettings}, conn, index)
+	}
 	return conn, err
 }
--- a/transport/internet/httpupgrade/dialer.go
+++ b/transport/internet/httpupgrade/dialer.go
@@ -53,10 +53,9 @@ func dialhttpUpgrade(ctx context.Context, dest net.Destination, streamSettings *

 	var conn net.Conn
 	var requestURL url.URL
-	tConfig := tls.ConfigFromStreamSettings(streamSettings)
-	if tConfig != nil {
-		tlsConfig := tConfig.GetTLSConfig(tls.WithDestination(dest), tls.WithNextProto("http/1.1"))
-		if fingerprint := tls.GetFingerprint(tConfig.Fingerprint); fingerprint != nil {
+	if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
+		tlsConfig := config.GetTLSConfig(tls.WithDestination(dest), tls.WithNextProto("http/1.1"))
+		if fingerprint := tls.GetFingerprint(config.Fingerprint); fingerprint != nil {
 			conn = tls.UClient(pconn, tlsConfig, fingerprint)
 			if err := conn.(*tls.UConn).WebsocketHandshakeContext(ctx); err != nil {
 				return nil, err
@@ -70,17 +69,12 @@ func dialhttpUpgrade(ctx context.Context, dest net.Destination, streamSettings *
 		requestURL.Scheme = "http"
 	}

-	requestURL.Host = transportConfiguration.Host
-	if requestURL.Host == "" && tConfig != nil {
-		requestURL.Host = tConfig.ServerName
-	}
-	if requestURL.Host == "" {
-		requestURL.Host = dest.Address.String()
-	}
+	requestURL.Host = dest.NetAddr()
 	requestURL.Path = transportConfiguration.GetNormalizedPath()
 	req := &http.Request{
 		Method: http.MethodGet,
 		URL:    &requestURL,
+		Host:   transportConfiguration.Host,
 		Header: make(http.Header),
 	}
 	for key, value := range transportConfiguration.Header {
--- a/transport/internet/splithttp/browser_client.go
+++ b/transport/internet/splithttp/browser_client.go
@@ -3,6 +3,7 @@ package splithttp
 import (
 	"context"
 	"io"
+	"io/ioutil"
 	gonet "net"

 	"github.com/xtls/xray-core/transport/internet/browser_dialer"
@@ -13,16 +14,16 @@ import (
 // has no fields because everything is global state :O)
 type BrowserDialerClient struct{}

-func (c *BrowserDialerClient) IsClosed() bool {
+func (c *BrowserDialerClient) Open(ctx context.Context, pureURL string) (io.WriteCloser, io.ReadCloser) {
 	panic("not implemented yet")
 }

-func (c *BrowserDialerClient) OpenStream(ctx context.Context, url string, body io.Reader, uploadOnly bool) (io.ReadCloser, gonet.Addr, gonet.Addr, error) {
-	if body != nil {
-		panic("not implemented yet")
-	}
+func (c *BrowserDialerClient) OpenUpload(ctx context.Context, baseURL string) io.WriteCloser {
+	panic("not implemented yet")
+}

-	conn, err := browser_dialer.DialGet(url)
+func (c *BrowserDialerClient) OpenDownload(ctx context.Context, baseURL string) (io.ReadCloser, gonet.Addr, gonet.Addr, error) {
+	conn, err := browser_dialer.DialGet(baseURL)
 	dummyAddr := &gonet.IPAddr{}
 	if err != nil {
 		return nil, dummyAddr, dummyAddr, err
@@ -31,8 +32,8 @@ func (c *BrowserDialerClient) OpenStream(ctx context.Context, url string, body i
 	return websocket.NewConnection(conn, dummyAddr, nil, 0), conn.RemoteAddr(), conn.LocalAddr(), nil
 }

-func (c *BrowserDialerClient) PostPacket(ctx context.Context, url string, body io.Reader, contentLength int64) error {
-	bytes, err := io.ReadAll(body)
+func (c *BrowserDialerClient) SendUploadRequest(ctx context.Context, url string, payload io.ReadWriteCloser, contentLength int64) error {
+	bytes, err := ioutil.ReadAll(payload)
 	if err != nil {
 		return err
 	}
--- a/transport/internet/splithttp/client.go
+++ b/transport/internet/splithttp/client.go
@@ -18,87 +18,168 @@ import (

 // interface to abstract between use of browser dialer, vs net/http
 type DialerClient interface {
-	IsClosed() bool
+	// (ctx, baseURL, payload) -> err
+	// baseURL already contains sessionId and seq
+	SendUploadRequest(context.Context, string, io.ReadWriteCloser, int64) error

-	// ctx, url, body, uploadOnly
-	OpenStream(context.Context, string, io.Reader, bool) (io.ReadCloser, net.Addr, net.Addr, error)
+	// (ctx, baseURL) -> (downloadReader, remoteAddr, localAddr)
+	// baseURL already contains sessionId
+	OpenDownload(context.Context, string) (io.ReadCloser, net.Addr, net.Addr, error)

-	// ctx, url, body, contentLength
-	PostPacket(context.Context, string, io.Reader, int64) error
+	// (ctx, baseURL) -> uploadWriter
+	// baseURL already contains sessionId
+	OpenUpload(context.Context, string) io.WriteCloser
+
+	// (ctx, pureURL) -> (uploadWriter, downloadReader)
+	// pureURL can not contain sessionId
+	Open(context.Context, string) (io.WriteCloser, io.ReadCloser)
 }

 // implements splithttp.DialerClient in terms of direct network connections
 type DefaultDialerClient struct {
 	transportConfig *Config
 	client          *http.Client
-	closed          bool
-	httpVersion     string
+	isH2            bool
+	isH3            bool
 	// pool of net.Conn, created using dialUploadConn
 	uploadRawPool  *sync.Pool
 	dialUploadConn func(ctxInner context.Context) (net.Conn, error)
 }

-func (c *DefaultDialerClient) IsClosed() bool {
-	return c.closed
+func (c *DefaultDialerClient) Open(ctx context.Context, pureURL string) (io.WriteCloser, io.ReadCloser) {
+	reader, writer := io.Pipe()
+	req, _ := http.NewRequestWithContext(ctx, "POST", pureURL, reader)
+	req.Header = c.transportConfig.GetRequestHeader()
+	if !c.transportConfig.NoGRPCHeader {
+		req.Header.Set("Content-Type", "application/grpc")
+	}
+	wrc := &WaitReadCloser{Wait: make(chan struct{})}
+	go func() {
+		response, err := c.client.Do(req)
+		if err != nil || response.StatusCode != 200 {
+			if err != nil {
+				errors.LogInfoInner(ctx, err, "failed to open ", pureURL)
+			} else {
+				errors.LogInfo(ctx, "unexpected status ", response.StatusCode)
+			}
+			wrc.Close()
+			return
+		}
+		wrc.Set(response.Body)
+	}()
+	return writer, wrc
 }

-func (c *DefaultDialerClient) OpenStream(ctx context.Context, url string, body io.Reader, uploadOnly bool) (wrc io.ReadCloser, remoteAddr, localAddr gonet.Addr, err error) {
+func (c *DefaultDialerClient) OpenUpload(ctx context.Context, baseURL string) io.WriteCloser {
+	reader, writer := io.Pipe()
+	req, _ := http.NewRequestWithContext(ctx, "POST", baseURL, reader)
+	req.Header = c.transportConfig.GetRequestHeader()
+	if !c.transportConfig.NoGRPCHeader {
+		req.Header.Set("Content-Type", "application/grpc")
+	}
+	go c.client.Do(req)
+	return writer
+}
+
+func (c *DefaultDialerClient) OpenDownload(ctx context.Context, baseURL string) (io.ReadCloser, gonet.Addr, gonet.Addr, error) {
+	var remoteAddr gonet.Addr
+	var localAddr gonet.Addr
 	// this is done when the TCP/UDP connection to the server was established,
 	// and we can unblock the Dial function and print correct net addresses in
 	// logs
 	gotConn := done.New()
-	ctx = httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{
-		GotConn: func(connInfo httptrace.GotConnInfo) {
-			remoteAddr = connInfo.Conn.RemoteAddr()
-			localAddr = connInfo.Conn.LocalAddr()
-			gotConn.Close()
-		},
-	})

-	method := "GET"
-	if body != nil {
-		method = "POST"
-	}
-	req, _ := http.NewRequestWithContext(ctx, method, url, body)
-	req.Header = c.transportConfig.GetRequestHeader()
-	if method == "POST" && !c.transportConfig.NoGRPCHeader {
-		req.Header.Set("Content-Type", "application/grpc")
-	}
+	var downResponse io.ReadCloser
+	gotDownResponse := done.New()
+
+	ctx, ctxCancel := context.WithCancel(ctx)

-	wrc = &WaitReadCloser{Wait: make(chan struct{})}
 	go func() {
-		resp, err := c.client.Do(req)
+		trace := &httptrace.ClientTrace{
+			GotConn: func(connInfo httptrace.GotConnInfo) {
+				remoteAddr = connInfo.Conn.RemoteAddr()
+				localAddr = connInfo.Conn.LocalAddr()
+				gotConn.Close()
+			},
+		}
+
+		// in case we hit an error, we want to unblock this part
+		defer gotConn.Close()
+
+		ctx = httptrace.WithClientTrace(ctx, trace)
+
+		req, err := http.NewRequestWithContext(
+			ctx,
+			"GET",
+			baseURL,
+			nil,
+		)
 		if err != nil {
-			errors.LogInfoInner(ctx, err, "failed to "+method+" "+url)
-			gotConn.Close()
-			wrc.Close()
+			errors.LogInfoInner(ctx, err, "failed to construct download http request")
+			gotDownResponse.Close()
 			return
 		}
-		if resp.StatusCode != 200 && !uploadOnly {
-			// c.closed = true
-			errors.LogInfo(ctx, "unexpected status ", resp.StatusCode)
-		}
-		if resp.StatusCode != 200 || uploadOnly {
-			resp.Body.Close()
-			wrc.Close()
+
+		req.Header = c.transportConfig.GetRequestHeader()
+
+		response, err := c.client.Do(req)
+		gotConn.Close()
+		if err != nil {
+			errors.LogInfoInner(ctx, err, "failed to send download http request")
+			gotDownResponse.Close()
 			return
 		}
-		wrc.(*WaitReadCloser).Set(resp.Body)
+
+		if response.StatusCode != 200 {
+			response.Body.Close()
+			errors.LogInfo(ctx, "invalid status code on download:", response.Status)
+			gotDownResponse.Close()
+			return
+		}
+
+		downResponse = response.Body
+		gotDownResponse.Close()
 	}()

-	<-gotConn.Wait()
-	return
+	if !c.isH3 {
+		// in quic-go, sometimes gotConn is never closed for the lifetime of
+		// the entire connection, and the download locks up
+		// https://github.com/quic-go/quic-go/issues/3342
+		// for other HTTP versions, we want to block Dial until we know the
+		// remote address of the server, for logging purposes
+		<-gotConn.Wait()
+	}
+
+	lazyDownload := &LazyReader{
+		CreateReader: func() (io.Reader, error) {
+			<-gotDownResponse.Wait()
+			if downResponse == nil {
+				return nil, errors.New("downResponse failed")
+			}
+			return downResponse, nil
+		},
+	}
+
+	// workaround for https://github.com/quic-go/quic-go/issues/2143 --
+	// always cancel request context so that Close cancels any Read.
+	// Should then match the behavior of http2 and http1.
+	reader := downloadBody{
+		lazyDownload,
+		ctxCancel,
+	}
+
+	return reader, remoteAddr, localAddr, nil
 }

-func (c *DefaultDialerClient) PostPacket(ctx context.Context, url string, body io.Reader, contentLength int64) error {
-	req, err := http.NewRequestWithContext(ctx, "POST", url, body)
+func (c *DefaultDialerClient) SendUploadRequest(ctx context.Context, url string, payload io.ReadWriteCloser, contentLength int64) error {
+	req, err := http.NewRequest("POST", url, payload)
 	if err != nil {
 		return err
 	}
 	req.ContentLength = contentLength
 	req.Header = c.transportConfig.GetRequestHeader()

-	if c.httpVersion != "1.1" {
+	if c.isH2 || c.isH3 {
 		resp, err := c.client.Do(req)
 		if err != nil {
 			return err
@@ -107,7 +188,6 @@ func (c *DefaultDialerClient) PostPacket(ctx context.Context, url string, body i
 		defer resp.Body.Close()

 		if resp.StatusCode != 200 {
-			// c.closed = true
 			return errors.New("bad status code:", resp.Status)
 		}
 	} else {
@@ -142,8 +222,6 @@ func (c *DefaultDialerClient) PostPacket(ctx context.Context, url string, body i
 						return fmt.Errorf("error while reading response: %s", err.Error())
 					}
 					if resp.StatusCode != 200 {
-						// c.closed = true
-						// resp.Body.Close() // I'm not sure
 						return fmt.Errorf("got non-200 error response code: %d", resp.StatusCode)
 					}
 				}
@@ -167,6 +245,16 @@ func (c *DefaultDialerClient) PostPacket(ctx context.Context, url string, body i
 	return nil
 }

+type downloadBody struct {
+	io.Reader
+	cancel context.CancelFunc
+}
+
+func (c downloadBody) Close() error {
+	c.cancel()
+	return nil
+}
+
 type WaitReadCloser struct {
 	Wait chan struct{}
 	io.ReadCloser
--- a/transport/internet/splithttp/config.go
+++ b/transport/internet/splithttp/config.go
@@ -37,7 +37,7 @@ func (c *Config) GetNormalizedQuery() string {
 		query += "&"
 	}

-	paddingLen := c.GetNormalizedXPaddingBytes().rand()
+	paddingLen := c.GetNormalizedXPaddingBytes().roll()
 	if paddingLen > 0 {
 		query += "x_padding=" + strings.Repeat("0", int(paddingLen))
 	}
@@ -47,7 +47,7 @@ func (c *Config) GetNormalizedQuery() string {

 func (c *Config) GetRequestHeader() http.Header {
 	header := http.Header{}
-	for k, v := range c.Headers {
+	for k, v := range c.Header {
 		header.Add(k, v)
 	}

@@ -58,26 +58,26 @@ func (c *Config) WriteResponseHeader(writer http.ResponseWriter) {
 	// CORS headers for the browser dialer
 	writer.Header().Set("Access-Control-Allow-Origin", "*")
 	writer.Header().Set("Access-Control-Allow-Methods", "GET, POST")
-	paddingLen := c.GetNormalizedXPaddingBytes().rand()
+	paddingLen := c.GetNormalizedXPaddingBytes().roll()
 	if paddingLen > 0 {
 		writer.Header().Set("X-Padding", strings.Repeat("0", int(paddingLen)))
 	}
 }

-func (c *Config) GetNormalizedXPaddingBytes() RangeConfig {
-	if c.XPaddingBytes == nil || c.XPaddingBytes.To == 0 {
-		return RangeConfig{
+func (c *Config) GetNormalizedScMaxConcurrentPosts() RandRangeConfig {
+	if c.ScMaxConcurrentPosts == nil || c.ScMaxConcurrentPosts.To == 0 {
+		return RandRangeConfig{
 			From: 100,
-			To:   1000,
+			To:   100,
 		}
 	}

-	return *c.XPaddingBytes
+	return *c.ScMaxConcurrentPosts
 }

-func (c *Config) GetNormalizedScMaxEachPostBytes() RangeConfig {
+func (c *Config) GetNormalizedScMaxEachPostBytes() RandRangeConfig {
 	if c.ScMaxEachPostBytes == nil || c.ScMaxEachPostBytes.To == 0 {
-		return RangeConfig{
+		return RandRangeConfig{
 			From: 1000000,
 			To:   1000000,
 		}
@@ -86,9 +86,9 @@ func (c *Config) GetNormalizedScMaxEachPostBytes() RangeConfig {
 	return *c.ScMaxEachPostBytes
 }

-func (c *Config) GetNormalizedScMinPostsIntervalMs() RangeConfig {
+func (c *Config) GetNormalizedScMinPostsIntervalMs() RandRangeConfig {
 	if c.ScMinPostsIntervalMs == nil || c.ScMinPostsIntervalMs.To == 0 {
-		return RangeConfig{
+		return RandRangeConfig{
 			From: 30,
 			To:   30,
 		}
@@ -97,39 +97,20 @@ func (c *Config) GetNormalizedScMinPostsIntervalMs() RangeConfig {
 	return *c.ScMinPostsIntervalMs
 }

-func (c *Config) GetNormalizedScMaxBufferedPosts() int {
-	if c.ScMaxBufferedPosts == 0 {
-		return 30
-	}
-
-	return int(c.ScMaxBufferedPosts)
-}
-
-func (m *XmuxConfig) GetNormalizedMaxConcurrency() RangeConfig {
-	if m.MaxConcurrency == nil {
-		return RangeConfig{
-			From: 0,
-			To:   0,
+func (c *Config) GetNormalizedXPaddingBytes() RandRangeConfig {
+	if c.XPaddingBytes == nil || c.XPaddingBytes.To == 0 {
+		return RandRangeConfig{
+			From: 100,
+			To:   1000,
 		}
 	}

-	return *m.MaxConcurrency
+	return *c.XPaddingBytes
 }

-func (m *XmuxConfig) GetNormalizedMaxConnections() RangeConfig {
-	if m.MaxConnections == nil {
-		return RangeConfig{
-			From: 0,
-			To:   0,
-		}
-	}
-
-	return *m.MaxConnections
-}
-
-func (m *XmuxConfig) GetNormalizedCMaxReuseTimes() RangeConfig {
+func (m *Multiplexing) GetNormalizedCMaxReuseTimes() RandRangeConfig {
 	if m.CMaxReuseTimes == nil {
-		return RangeConfig{
+		return RandRangeConfig{
 			From: 0,
 			To:   0,
 		}
@@ -138,26 +119,36 @@ func (m *XmuxConfig) GetNormalizedCMaxReuseTimes() RangeConfig {
 	return *m.CMaxReuseTimes
 }

-func (m *XmuxConfig) GetNormalizedHMaxRequestTimes() RangeConfig {
-	if m.HMaxRequestTimes == nil {
-		return RangeConfig{
+func (m *Multiplexing) GetNormalizedCMaxLifetimeMs() RandRangeConfig {
+	if m.CMaxLifetimeMs == nil || m.CMaxLifetimeMs.To == 0 {
+		return RandRangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
-
-	return *m.HMaxRequestTimes
+	return *m.CMaxLifetimeMs
 }

-func (m *XmuxConfig) GetNormalizedHMaxReusableSecs() RangeConfig {
-	if m.HMaxReusableSecs == nil {
-		return RangeConfig{
+func (m *Multiplexing) GetNormalizedMaxConnections() RandRangeConfig {
+	if m.MaxConnections == nil {
+		return RandRangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}

-	return *m.HMaxReusableSecs
+	return *m.MaxConnections
+}
+
+func (m *Multiplexing) GetNormalizedMaxConcurrency() RandRangeConfig {
+	if m.MaxConcurrency == nil {
+		return RandRangeConfig{
+			From: 0,
+			To:   0,
+		}
+	}
+
+	return *m.MaxConcurrency
 }

 func init() {
@@ -166,7 +157,7 @@ func init() {
 	}))
 }

-func (c RangeConfig) rand() int32 {
+func (c RandRangeConfig) roll() int32 {
 	if c.From == c.To {
 		return c.From
 	}
--- a/transport/internet/splithttp/config.pb.go
+++ b/transport/internet/splithttp/config.pb.go
@@ -21,144 +21,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )

-type RangeConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	From int32 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
-	To   int32 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
-}
-
-func (x *RangeConfig) Reset() {
-	*x = RangeConfig{}
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[0]
-	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-	ms.StoreMessageInfo(mi)
-}
-
-func (x *RangeConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RangeConfig) ProtoMessage() {}
-
-func (x *RangeConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[0]
-	if x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RangeConfig.ProtoReflect.Descriptor instead.
-func (*RangeConfig) Descriptor() ([]byte, []int) {
-	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *RangeConfig) GetFrom() int32 {
-	if x != nil {
-		return x.From
-	}
-	return 0
-}
-
-func (x *RangeConfig) GetTo() int32 {
-	if x != nil {
-		return x.To
-	}
-	return 0
-}
-
-type XmuxConfig struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	MaxConcurrency   *RangeConfig `protobuf:"bytes,1,opt,name=maxConcurrency,proto3" json:"maxConcurrency,omitempty"`
-	MaxConnections   *RangeConfig `protobuf:"bytes,2,opt,name=maxConnections,proto3" json:"maxConnections,omitempty"`
-	CMaxReuseTimes   *RangeConfig `protobuf:"bytes,3,opt,name=cMaxReuseTimes,proto3" json:"cMaxReuseTimes,omitempty"`
-	HMaxRequestTimes *RangeConfig `protobuf:"bytes,4,opt,name=hMaxRequestTimes,proto3" json:"hMaxRequestTimes,omitempty"`
-	HMaxReusableSecs *RangeConfig `protobuf:"bytes,5,opt,name=hMaxReusableSecs,proto3" json:"hMaxReusableSecs,omitempty"`
-	HKeepAlivePeriod int64        `protobuf:"varint,6,opt,name=hKeepAlivePeriod,proto3" json:"hKeepAlivePeriod,omitempty"`
-}
-
-func (x *XmuxConfig) Reset() {
-	*x = XmuxConfig{}
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[1]
-	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-	ms.StoreMessageInfo(mi)
-}
-
-func (x *XmuxConfig) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*XmuxConfig) ProtoMessage() {}
-
-func (x *XmuxConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[1]
-	if x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use XmuxConfig.ProtoReflect.Descriptor instead.
-func (*XmuxConfig) Descriptor() ([]byte, []int) {
-	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *XmuxConfig) GetMaxConcurrency() *RangeConfig {
-	if x != nil {
-		return x.MaxConcurrency
-	}
-	return nil
-}
-
-func (x *XmuxConfig) GetMaxConnections() *RangeConfig {
-	if x != nil {
-		return x.MaxConnections
-	}
-	return nil
-}
-
-func (x *XmuxConfig) GetCMaxReuseTimes() *RangeConfig {
-	if x != nil {
-		return x.CMaxReuseTimes
-	}
-	return nil
-}
-
-func (x *XmuxConfig) GetHMaxRequestTimes() *RangeConfig {
-	if x != nil {
-		return x.HMaxRequestTimes
-	}
-	return nil
-}
-
-func (x *XmuxConfig) GetHMaxReusableSecs() *RangeConfig {
-	if x != nil {
-		return x.HMaxReusableSecs
-	}
-	return nil
-}
-
-func (x *XmuxConfig) GetHKeepAlivePeriod() int64 {
-	if x != nil {
-		return x.HKeepAlivePeriod
-	}
-	return 0
-}
-
 type Config struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -166,21 +28,22 @@ type Config struct {

 	Host                 string                 `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
 	Path                 string                 `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
-	Mode                 string                 `protobuf:"bytes,3,opt,name=mode,proto3" json:"mode,omitempty"`
-	Headers              map[string]string      `protobuf:"bytes,4,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	XPaddingBytes        *RangeConfig           `protobuf:"bytes,5,opt,name=xPaddingBytes,proto3" json:"xPaddingBytes,omitempty"`
-	NoGRPCHeader         bool                   `protobuf:"varint,6,opt,name=noGRPCHeader,proto3" json:"noGRPCHeader,omitempty"`
+	Header               map[string]string      `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	ScMaxConcurrentPosts *RandRangeConfig       `protobuf:"bytes,4,opt,name=scMaxConcurrentPosts,proto3" json:"scMaxConcurrentPosts,omitempty"`
+	ScMaxEachPostBytes   *RandRangeConfig       `protobuf:"bytes,5,opt,name=scMaxEachPostBytes,proto3" json:"scMaxEachPostBytes,omitempty"`
+	ScMinPostsIntervalMs *RandRangeConfig       `protobuf:"bytes,6,opt,name=scMinPostsIntervalMs,proto3" json:"scMinPostsIntervalMs,omitempty"`
 	NoSSEHeader          bool                   `protobuf:"varint,7,opt,name=noSSEHeader,proto3" json:"noSSEHeader,omitempty"`
-	ScMaxEachPostBytes   *RangeConfig           `protobuf:"bytes,8,opt,name=scMaxEachPostBytes,proto3" json:"scMaxEachPostBytes,omitempty"`
-	ScMinPostsIntervalMs *RangeConfig           `protobuf:"bytes,9,opt,name=scMinPostsIntervalMs,proto3" json:"scMinPostsIntervalMs,omitempty"`
-	ScMaxBufferedPosts   int64                  `protobuf:"varint,10,opt,name=scMaxBufferedPosts,proto3" json:"scMaxBufferedPosts,omitempty"`
-	Xmux                 *XmuxConfig            `protobuf:"bytes,11,opt,name=xmux,proto3" json:"xmux,omitempty"`
-	DownloadSettings     *internet.StreamConfig `protobuf:"bytes,12,opt,name=downloadSettings,proto3" json:"downloadSettings,omitempty"`
+	XPaddingBytes        *RandRangeConfig       `protobuf:"bytes,8,opt,name=xPaddingBytes,proto3" json:"xPaddingBytes,omitempty"`
+	Xmux                 *Multiplexing          `protobuf:"bytes,9,opt,name=xmux,proto3" json:"xmux,omitempty"`
+	DownloadSettings     *internet.StreamConfig `protobuf:"bytes,10,opt,name=downloadSettings,proto3" json:"downloadSettings,omitempty"`
+	Mode                 string                 `protobuf:"bytes,11,opt,name=mode,proto3" json:"mode,omitempty"`
+	NoGRPCHeader         bool                   `protobuf:"varint,12,opt,name=noGRPCHeader,proto3" json:"noGRPCHeader,omitempty"`
+	KeepAlivePeriod      int64                  `protobuf:"varint,13,opt,name=keepAlivePeriod,proto3" json:"keepAlivePeriod,omitempty"`
 }

 func (x *Config) Reset() {
 	*x = Config{}
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[2]
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[0]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -192,7 +55,7 @@ func (x *Config) String() string {
 func (*Config) ProtoMessage() {}

 func (x *Config) ProtoReflect() protoreflect.Message {
-	mi := &file_transport_internet_splithttp_config_proto_msgTypes[2]
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[0]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -205,7 +68,7 @@ func (x *Config) ProtoReflect() protoreflect.Message {

 // Deprecated: Use Config.ProtoReflect.Descriptor instead.
 func (*Config) Descriptor() ([]byte, []int) {
-	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{2}
+	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{0}
 }

 func (x *Config) GetHost() string {
@@ -222,32 +85,32 @@ func (x *Config) GetPath() string {
 	return ""
 }

-func (x *Config) GetMode() string {
+func (x *Config) GetHeader() map[string]string {
 	if x != nil {
-		return x.Mode
-	}
-	return ""
-}
-
-func (x *Config) GetHeaders() map[string]string {
-	if x != nil {
-		return x.Headers
+		return x.Header
 	}
 	return nil
 }

-func (x *Config) GetXPaddingBytes() *RangeConfig {
+func (x *Config) GetScMaxConcurrentPosts() *RandRangeConfig {
 	if x != nil {
-		return x.XPaddingBytes
+		return x.ScMaxConcurrentPosts
 	}
 	return nil
 }

-func (x *Config) GetNoGRPCHeader() bool {
+func (x *Config) GetScMaxEachPostBytes() *RandRangeConfig {
 	if x != nil {
-		return x.NoGRPCHeader
+		return x.ScMaxEachPostBytes
 	}
-	return false
+	return nil
+}
+
+func (x *Config) GetScMinPostsIntervalMs() *RandRangeConfig {
+	if x != nil {
+		return x.ScMinPostsIntervalMs
+	}
+	return nil
 }

 func (x *Config) GetNoSSEHeader() bool {
@@ -257,28 +120,14 @@ func (x *Config) GetNoSSEHeader() bool {
 	return false
 }

-func (x *Config) GetScMaxEachPostBytes() *RangeConfig {
+func (x *Config) GetXPaddingBytes() *RandRangeConfig {
 	if x != nil {
-		return x.ScMaxEachPostBytes
+		return x.XPaddingBytes
 	}
 	return nil
 }

-func (x *Config) GetScMinPostsIntervalMs() *RangeConfig {
-	if x != nil {
-		return x.ScMinPostsIntervalMs
-	}
-	return nil
-}
-
-func (x *Config) GetScMaxBufferedPosts() int64 {
-	if x != nil {
-		return x.ScMaxBufferedPosts
-	}
-	return 0
-}
-
-func (x *Config) GetXmux() *XmuxConfig {
+func (x *Config) GetXmux() *Multiplexing {
 	if x != nil {
 		return x.Xmux
 	}
@@ -292,6 +141,149 @@ func (x *Config) GetDownloadSettings() *internet.StreamConfig {
 	return nil
 }

+func (x *Config) GetMode() string {
+	if x != nil {
+		return x.Mode
+	}
+	return ""
+}
+
+func (x *Config) GetNoGRPCHeader() bool {
+	if x != nil {
+		return x.NoGRPCHeader
+	}
+	return false
+}
+
+func (x *Config) GetKeepAlivePeriod() int64 {
+	if x != nil {
+		return x.KeepAlivePeriod
+	}
+	return 0
+}
+
+type RandRangeConfig struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	From int32 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
+	To   int32 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
+}
+
+func (x *RandRangeConfig) Reset() {
+	*x = RandRangeConfig{}
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *RandRangeConfig) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RandRangeConfig) ProtoMessage() {}
+
+func (x *RandRangeConfig) ProtoReflect() protoreflect.Message {
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RandRangeConfig.ProtoReflect.Descriptor instead.
+func (*RandRangeConfig) Descriptor() ([]byte, []int) {
+	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *RandRangeConfig) GetFrom() int32 {
+	if x != nil {
+		return x.From
+	}
+	return 0
+}
+
+func (x *RandRangeConfig) GetTo() int32 {
+	if x != nil {
+		return x.To
+	}
+	return 0
+}
+
+type Multiplexing struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	MaxConcurrency *RandRangeConfig `protobuf:"bytes,1,opt,name=maxConcurrency,proto3" json:"maxConcurrency,omitempty"`
+	MaxConnections *RandRangeConfig `protobuf:"bytes,2,opt,name=maxConnections,proto3" json:"maxConnections,omitempty"`
+	CMaxReuseTimes *RandRangeConfig `protobuf:"bytes,3,opt,name=cMaxReuseTimes,proto3" json:"cMaxReuseTimes,omitempty"`
+	CMaxLifetimeMs *RandRangeConfig `protobuf:"bytes,4,opt,name=cMaxLifetimeMs,proto3" json:"cMaxLifetimeMs,omitempty"`
+}
+
+func (x *Multiplexing) Reset() {
+	*x = Multiplexing{}
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Multiplexing) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Multiplexing) ProtoMessage() {}
+
+func (x *Multiplexing) ProtoReflect() protoreflect.Message {
+	mi := &file_transport_internet_splithttp_config_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Multiplexing.ProtoReflect.Descriptor instead.
+func (*Multiplexing) Descriptor() ([]byte, []int) {
+	return file_transport_internet_splithttp_config_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *Multiplexing) GetMaxConcurrency() *RandRangeConfig {
+	if x != nil {
+		return x.MaxConcurrency
+	}
+	return nil
+}
+
+func (x *Multiplexing) GetMaxConnections() *RandRangeConfig {
+	if x != nil {
+		return x.MaxConnections
+	}
+	return nil
+}
+
+func (x *Multiplexing) GetCMaxReuseTimes() *RandRangeConfig {
+	if x != nil {
+		return x.CMaxReuseTimes
+	}
+	return nil
+}
+
+func (x *Multiplexing) GetCMaxLifetimeMs() *RandRangeConfig {
+	if x != nil {
+		return x.CMaxLifetimeMs
+	}
+	return nil
+}
+
 var File_transport_internet_splithttp_config_proto protoreflect.FileDescriptor

 var file_transport_internet_splithttp_config_proto_rawDesc = []byte{
@@ -302,98 +294,97 @@ var file_transport_internet_splithttp_config_proto_rawDesc = []byte{
 	0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x1a, 0x1f,
 	0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
 	0x65, 0x74, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
-	0x31, 0x0a, 0x0b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12,
-	0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x66, 0x72,
-	0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02,
-	0x74, 0x6f, 0x22, 0xf8, 0x03, 0x0a, 0x0a, 0x58, 0x6d, 0x75, 0x78, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x67, 0x12, 0x56, 0x0a, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65,
-	0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79,
-	0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
-	0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61,
-	0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f,
-	0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x56, 0x0a, 0x0e, 0x6d, 0x61, 0x78,
-	0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f,
-	0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69,
-	0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x67, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x56, 0x0a, 0x0e, 0x63, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x75, 0x73, 0x65, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79,
-	0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
-	0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61,
-	0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e, 0x63, 0x4d, 0x61, 0x78, 0x52,
-	0x65, 0x75, 0x73, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x10, 0x68, 0x4d, 0x61,
-	0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73,
-	0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70,
-	0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x52, 0x10, 0x68, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x10, 0x68, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x75,
-	0x73, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x65, 0x63, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74,
+	0xe4, 0x06, 0x0a, 0x06, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f,
+	0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x12,
+	0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61,
+	0x74, 0x68, 0x12, 0x4d, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x35, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70,
+	0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c,
+	0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x48, 0x65,
+	0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65,
+	0x72, 0x12, 0x66, 0x0a, 0x14, 0x73, 0x63, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x32, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74,
 	0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68,
-	0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52,
-	0x10, 0x68, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x75, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x65, 0x63,
-	0x73, 0x12, 0x2a, 0x0a, 0x10, 0x68, 0x4b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x50,
-	0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x68, 0x4b, 0x65,
-	0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xf8, 0x05,
-	0x0a, 0x06, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04,
-	0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68,
-	0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x6d, 0x6f, 0x64, 0x65, 0x12, 0x50, 0x0a, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18,
-	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61,
+	0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e,
+	0x66, 0x69, 0x67, 0x52, 0x14, 0x73, 0x63, 0x4d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x62, 0x0a, 0x12, 0x73, 0x63, 0x4d,
+	0x61, 0x78, 0x45, 0x61, 0x63, 0x68, 0x50, 0x6f, 0x73, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61,
 	0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e,
-	0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
-	0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x68,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x54, 0x0a, 0x0d, 0x78, 0x50, 0x61, 0x64, 0x64, 0x69,
-	0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
-	0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69,
-	0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74,
-	0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x78,
-	0x50, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x22, 0x0a, 0x0c,
-	0x6e, 0x6f, 0x47, 0x52, 0x50, 0x43, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x08, 0x52, 0x0c, 0x6e, 0x6f, 0x47, 0x52, 0x50, 0x43, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
-	0x12, 0x20, 0x0a, 0x0b, 0x6e, 0x6f, 0x53, 0x53, 0x45, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18,
-	0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x6e, 0x6f, 0x53, 0x53, 0x45, 0x48, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x12, 0x5e, 0x0a, 0x12, 0x73, 0x63, 0x4d, 0x61, 0x78, 0x45, 0x61, 0x63, 0x68, 0x50,
-	0x6f, 0x73, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e,
+	0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61,
+	0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x12, 0x73, 0x63, 0x4d, 0x61, 0x78,
+	0x45, 0x61, 0x63, 0x68, 0x50, 0x6f, 0x73, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x66, 0x0a,
+	0x14, 0x73, 0x63, 0x4d, 0x69, 0x6e, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x49, 0x6e, 0x74, 0x65, 0x72,
+	0x76, 0x61, 0x6c, 0x4d, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x72,
+	0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74,
+	0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e,
+	0x52, 0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52,
+	0x14, 0x73, 0x63, 0x4d, 0x69, 0x6e, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x49, 0x6e, 0x74, 0x65, 0x72,
+	0x76, 0x61, 0x6c, 0x4d, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x6e, 0x6f, 0x53, 0x53, 0x45, 0x48, 0x65,
+	0x61, 0x64, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x6e, 0x6f, 0x53, 0x53,
+	0x45, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x58, 0x0a, 0x0d, 0x78, 0x50, 0x61, 0x64, 0x64,
+	0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32,
 	0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e,
 	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74,
-	0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x12,
-	0x73, 0x63, 0x4d, 0x61, 0x78, 0x45, 0x61, 0x63, 0x68, 0x50, 0x6f, 0x73, 0x74, 0x42, 0x79, 0x74,
-	0x65, 0x73, 0x12, 0x62, 0x0a, 0x14, 0x73, 0x63, 0x4d, 0x69, 0x6e, 0x50, 0x6f, 0x73, 0x74, 0x73,
-	0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x4d, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x2e, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72,
-	0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74,
-	0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
-	0x52, 0x14, 0x73, 0x63, 0x4d, 0x69, 0x6e, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x49, 0x6e, 0x74, 0x65,
-	0x72, 0x76, 0x61, 0x6c, 0x4d, 0x73, 0x12, 0x2e, 0x0a, 0x12, 0x73, 0x63, 0x4d, 0x61, 0x78, 0x42,
-	0x75, 0x66, 0x66, 0x65, 0x72, 0x65, 0x64, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x12, 0x73, 0x63, 0x4d, 0x61, 0x78, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x65,
-	0x64, 0x50, 0x6f, 0x73, 0x74, 0x73, 0x12, 0x41, 0x0a, 0x04, 0x78, 0x6d, 0x75, 0x78, 0x18, 0x0b,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e,
+	0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x67, 0x52, 0x0d, 0x78, 0x50, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65,
+	0x73, 0x12, 0x43, 0x0a, 0x04, 0x78, 0x6d, 0x75, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x2f, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74,
+	0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68,
+	0x74, 0x74, 0x70, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x78, 0x69, 0x6e, 0x67,
+	0x52, 0x04, 0x78, 0x6d, 0x75, 0x78, 0x12, 0x51, 0x0a, 0x10, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f,
+	0x61, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x25, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72,
+	0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61,
+	0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64,
+	0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x22, 0x0a,
+	0x0c, 0x6e, 0x6f, 0x47, 0x52, 0x50, 0x43, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x6f, 0x47, 0x52, 0x50, 0x43, 0x48, 0x65, 0x61, 0x64, 0x65,
+	0x72, 0x12, 0x28, 0x0a, 0x0f, 0x6b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x50, 0x65,
+	0x72, 0x69, 0x6f, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x6b, 0x65, 0x65, 0x70,
+	0x41, 0x6c, 0x69, 0x76, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x1a, 0x39, 0x0a, 0x0b, 0x48,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
+	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
+	0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x35, 0x0a, 0x0f, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61,
+	0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f,
+	0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a,
+	0x02, 0x74, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x74, 0x6f, 0x22, 0xfe, 0x02,
+	0x0a, 0x0c, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x78, 0x69, 0x6e, 0x67, 0x12, 0x5a,
+	0x0a, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72,
+	0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74,
+	0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52,
+	0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43,
+	0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x5a, 0x0a, 0x0e, 0x6d, 0x61,
+	0x78, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70,
+	0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c,
+	0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5a, 0x0a, 0x0e, 0x63, 0x4d, 0x61, 0x78, 0x52, 0x65,
+	0x75, 0x73, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32,
+	0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e,
+	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74,
+	0x74, 0x70, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x67, 0x52, 0x0e, 0x63, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x75, 0x73, 0x65, 0x54, 0x69, 0x6d,
+	0x65, 0x73, 0x12, 0x5a, 0x0a, 0x0e, 0x63, 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x66, 0x65, 0x74, 0x69,
+	0x6d, 0x65, 0x4d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x72, 0x61,
+	0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x52,
+	0x61, 0x6e, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e,
+	0x63, 0x4d, 0x61, 0x78, 0x4c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x73, 0x42, 0x85,
+	0x01, 0x0a, 0x25, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e,
 	0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73,
-	0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x2e, 0x58, 0x6d, 0x75, 0x78, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x52, 0x04, 0x78, 0x6d, 0x75, 0x78, 0x12, 0x51, 0x0a, 0x10, 0x64, 0x6f, 0x77,
-	0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x0c, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73,
-	0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x53, 0x74,
-	0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x64, 0x6f, 0x77, 0x6e,
-	0x6c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x1a, 0x3a, 0x0a, 0x0c,
-	0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
-	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
-	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x85, 0x01, 0x0a, 0x25, 0x63, 0x6f, 0x6d,
-	0x2e, 0x78, 0x72, 0x61, 0x79, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e,
-	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74,
-	0x74, 0x70, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
-	0x2f, 0x78, 0x74, 0x6c, 0x73, 0x2f, 0x78, 0x72, 0x61, 0x79, 0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f,
-	0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
-	0x65, 0x74, 0x2f, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0xaa, 0x02, 0x21, 0x58,
-	0x72, 0x61, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x49, 0x6e,
-	0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x48, 0x74, 0x74, 0x70,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x70, 0x6c, 0x69, 0x74, 0x68, 0x74, 0x74, 0x70, 0x50, 0x01, 0x5a, 0x36, 0x67, 0x69, 0x74, 0x68,
+	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x74, 0x6c, 0x73, 0x2f, 0x78, 0x72, 0x61, 0x79,
+	0x2d, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2f,
+	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2f, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x68, 0x74,
+	0x74, 0x70, 0xaa, 0x02, 0x21, 0x58, 0x72, 0x61, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70,
+	0x6f, 0x72, 0x74, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x2e, 0x53, 0x70, 0x6c,
+	0x69, 0x74, 0x48, 0x74, 0x74, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }

 var (
@@ -410,24 +401,24 @@ func file_transport_internet_splithttp_config_proto_rawDescGZIP() []byte {

 var file_transport_internet_splithttp_config_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
 var file_transport_internet_splithttp_config_proto_goTypes = []any{
-	(*RangeConfig)(nil),           // 0: xray.transport.internet.splithttp.RangeConfig
-	(*XmuxConfig)(nil),            // 1: xray.transport.internet.splithttp.XmuxConfig
-	(*Config)(nil),                // 2: xray.transport.internet.splithttp.Config
-	nil,                           // 3: xray.transport.internet.splithttp.Config.HeadersEntry
+	(*Config)(nil),                // 0: xray.transport.internet.splithttp.Config
+	(*RandRangeConfig)(nil),       // 1: xray.transport.internet.splithttp.RandRangeConfig
+	(*Multiplexing)(nil),          // 2: xray.transport.internet.splithttp.Multiplexing
+	nil,                           // 3: xray.transport.internet.splithttp.Config.HeaderEntry
 	(*internet.StreamConfig)(nil), // 4: xray.transport.internet.StreamConfig
 }
 var file_transport_internet_splithttp_config_proto_depIdxs = []int32{
-	0,  // 0: xray.transport.internet.splithttp.XmuxConfig.maxConcurrency:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 1: xray.transport.internet.splithttp.XmuxConfig.maxConnections:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 2: xray.transport.internet.splithttp.XmuxConfig.cMaxReuseTimes:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 3: xray.transport.internet.splithttp.XmuxConfig.hMaxRequestTimes:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 4: xray.transport.internet.splithttp.XmuxConfig.hMaxReusableSecs:type_name -> xray.transport.internet.splithttp.RangeConfig
-	3,  // 5: xray.transport.internet.splithttp.Config.headers:type_name -> xray.transport.internet.splithttp.Config.HeadersEntry
-	0,  // 6: xray.transport.internet.splithttp.Config.xPaddingBytes:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 7: xray.transport.internet.splithttp.Config.scMaxEachPostBytes:type_name -> xray.transport.internet.splithttp.RangeConfig
-	0,  // 8: xray.transport.internet.splithttp.Config.scMinPostsIntervalMs:type_name -> xray.transport.internet.splithttp.RangeConfig
-	1,  // 9: xray.transport.internet.splithttp.Config.xmux:type_name -> xray.transport.internet.splithttp.XmuxConfig
-	4,  // 10: xray.transport.internet.splithttp.Config.downloadSettings:type_name -> xray.transport.internet.StreamConfig
+	3,  // 0: xray.transport.internet.splithttp.Config.header:type_name -> xray.transport.internet.splithttp.Config.HeaderEntry
+	1,  // 1: xray.transport.internet.splithttp.Config.scMaxConcurrentPosts:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 2: xray.transport.internet.splithttp.Config.scMaxEachPostBytes:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 3: xray.transport.internet.splithttp.Config.scMinPostsIntervalMs:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 4: xray.transport.internet.splithttp.Config.xPaddingBytes:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	2,  // 5: xray.transport.internet.splithttp.Config.xmux:type_name -> xray.transport.internet.splithttp.Multiplexing
+	4,  // 6: xray.transport.internet.splithttp.Config.downloadSettings:type_name -> xray.transport.internet.StreamConfig
+	1,  // 7: xray.transport.internet.splithttp.Multiplexing.maxConcurrency:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 8: xray.transport.internet.splithttp.Multiplexing.maxConnections:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 9: xray.transport.internet.splithttp.Multiplexing.cMaxReuseTimes:type_name -> xray.transport.internet.splithttp.RandRangeConfig
+	1,  // 10: xray.transport.internet.splithttp.Multiplexing.cMaxLifetimeMs:type_name -> xray.transport.internet.splithttp.RandRangeConfig
 	11, // [11:11] is the sub-list for method output_type
 	11, // [11:11] is the sub-list for method input_type
 	11, // [11:11] is the sub-list for extension type_name
--- a/transport/internet/splithttp/config.proto
+++ b/transport/internet/splithttp/config.proto
@@ -8,31 +8,30 @@ option java_multiple_files = true;

 import "transport/internet/config.proto";

-message RangeConfig {
-  int32 from = 1;
-  int32 to = 2;
-}
-
-message XmuxConfig {
-  RangeConfig maxConcurrency = 1;
-  RangeConfig maxConnections = 2;
-  RangeConfig cMaxReuseTimes = 3;
-  RangeConfig hMaxRequestTimes = 4;
-  RangeConfig hMaxReusableSecs = 5;
-  int64 hKeepAlivePeriod = 6;
-}
-
 message Config {
  string host = 1;
  string path = 2;
-  string mode = 3;
-  map<string, string> headers = 4;
-  RangeConfig xPaddingBytes = 5;
-  bool noGRPCHeader = 6;
+  map<string, string> header = 3;
+  RandRangeConfig scMaxConcurrentPosts = 4;
+  RandRangeConfig scMaxEachPostBytes = 5;
+  RandRangeConfig scMinPostsIntervalMs = 6;
  bool noSSEHeader = 7;
-  RangeConfig scMaxEachPostBytes = 8;
-  RangeConfig scMinPostsIntervalMs = 9;
-  int64 scMaxBufferedPosts = 10;
-  XmuxConfig xmux = 11;
-  xray.transport.internet.StreamConfig downloadSettings = 12;
+  RandRangeConfig xPaddingBytes = 8;
+  Multiplexing xmux = 9;
+  xray.transport.internet.StreamConfig downloadSettings = 10;
+  string mode = 11;
+  bool noGRPCHeader = 12;
+  int64 keepAlivePeriod = 13;
+}
+
+message RandRangeConfig {
+    int32 from = 1;
+    int32 to = 2;
+}
+
+message Multiplexing {
+  RandRangeConfig maxConcurrency = 1;
+  RandRangeConfig maxConnections = 2;
+  RandRangeConfig cMaxReuseTimes = 3;
+  RandRangeConfig cMaxLifetimeMs = 4;
 }
--- a/transport/internet/splithttp/dialer.go
+++ b/transport/internet/splithttp/dialer.go
@@ -3,23 +3,20 @@ package splithttp
 import (
 	"context"
 	gotls "crypto/tls"
-	"fmt"
 	"io"
 	"net/http"
-	"net/http/httptrace"
 	"net/url"
 	"strconv"
 	"sync"
-	"sync/atomic"
 	"time"

-	"github.com/xtls/quic-go"
-	"github.com/xtls/quic-go/http3"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/buf"
 	"github.com/xtls/xray-core/common/errors"
 	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/common/signal/done"
+	"github.com/xtls/xray-core/common/signal/semaphore"
 	"github.com/xtls/xray-core/common/uuid"
 	"github.com/xtls/xray-core/transport/internet"
 	"github.com/xtls/xray-core/transport/internet/browser_dialer"
@@ -46,11 +43,11 @@ type dialerConf struct {
 }

 var (
-	globalDialerMap    map[dialerConf]*XmuxManager
+	globalDialerMap    map[dialerConf]*muxManager
 	globalDialerAccess sync.Mutex
 )

-func getHTTPClient(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (DialerClient, *XmuxClient) {
+func getHTTPClient(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (DialerClient, *muxResource) {
 	realityConfig := reality.ConfigFromStreamSettings(streamSettings)

 	if browser_dialer.HasBrowserDialer() && realityConfig != nil {
@@ -61,56 +58,47 @@ func getHTTPClient(ctx context.Context, dest net.Destination, streamSettings *in
 	defer globalDialerAccess.Unlock()

 	if globalDialerMap == nil {
-		globalDialerMap = make(map[dialerConf]*XmuxManager)
+		globalDialerMap = make(map[dialerConf]*muxManager)
 	}

 	key := dialerConf{dest, streamSettings}

-	xmuxManager, found := globalDialerMap[key]
+	muxManager, found := globalDialerMap[key]

 	if !found {
 		transportConfig := streamSettings.ProtocolSettings.(*Config)
-		var xmuxConfig XmuxConfig
+		var mux Multiplexing
 		if transportConfig.Xmux != nil {
-			xmuxConfig = *transportConfig.Xmux
+			mux = *transportConfig.Xmux
 		}

-		xmuxManager = NewXmuxManager(xmuxConfig, func() XmuxConn {
+		muxManager = NewMuxManager(mux, func() interface{} {
 			return createHTTPClient(dest, streamSettings)
 		})
-		globalDialerMap[key] = xmuxManager
+		globalDialerMap[key] = muxManager
 	}

-	xmuxClient := xmuxManager.GetXmuxClient(ctx)
-	return xmuxClient.XmuxConn.(DialerClient), xmuxClient
-}
-
-func decideHTTPVersion(tlsConfig *tls.Config, realityConfig *reality.Config) string {
-	if realityConfig != nil {
-		return "2"
-	}
-	if tlsConfig == nil {
-		return "1.1"
-	}
-	if len(tlsConfig.NextProtocol) != 1 {
-		return "2"
-	}
-	if tlsConfig.NextProtocol[0] == "http/1.1" {
-		return "1.1"
-	}
-	if tlsConfig.NextProtocol[0] == "h3" {
-		return "3"
-	}
-	return "2"
+	res := muxManager.GetResource(ctx)
+	return res.Resource.(DialerClient), res
 }

 func createHTTPClient(dest net.Destination, streamSettings *internet.MemoryStreamConfig) DialerClient {
 	tlsConfig := tls.ConfigFromStreamSettings(streamSettings)
 	realityConfig := reality.ConfigFromStreamSettings(streamSettings)

-	httpVersion := decideHTTPVersion(tlsConfig, realityConfig)
-	if httpVersion == "3" {
-		dest.Network = net.Network_UDP // better to keep this line
+	isH2 := false
+	isH3 := false
+
+	if tlsConfig != nil {
+		isH2 = !(len(tlsConfig.NextProtocol) == 1 && tlsConfig.NextProtocol[0] == "http/1.1")
+		isH3 = len(tlsConfig.NextProtocol) == 1 && tlsConfig.NextProtocol[0] == "h3"
+	} else if realityConfig != nil {
+		isH2 = true
+		isH3 = false
+	}
+
+	if isH3 {
+		dest.Network = net.Network_UDP
 	}

 	var gotlsConfig *gotls.Config
@@ -145,14 +133,11 @@ func createHTTPClient(dest net.Destination, streamSettings *internet.MemoryStrea
 		return conn, nil
 	}

-	var keepAlivePeriod time.Duration
-	if streamSettings.ProtocolSettings.(*Config).Xmux != nil {
-		keepAlivePeriod = time.Duration(streamSettings.ProtocolSettings.(*Config).Xmux.HKeepAlivePeriod) * time.Second
-	}
+	keepAlivePeriod := time.Duration(streamSettings.ProtocolSettings.(*Config).KeepAlivePeriod) * time.Second

 	var transport http.RoundTripper

-	if httpVersion == "3" {
+	if isH3 {
 		if keepAlivePeriod == 0 {
 			keepAlivePeriod = quicgoH3KeepAlivePeriod
 		}
@@ -208,7 +193,7 @@ func createHTTPClient(dest net.Destination, streamSettings *internet.MemoryStrea
 				return quic.DialEarly(ctx, udpConn, udpAddr, tlsCfg, cfg)
 			},
 		}
-	} else if httpVersion == "2" {
+	} else if isH2 {
 		if keepAlivePeriod == 0 {
 			keepAlivePeriod = chromeH2KeepAlivePeriod
 		}
@@ -242,7 +227,8 @@ func createHTTPClient(dest net.Destination, streamSettings *internet.MemoryStrea
 		client: &http.Client{
 			Transport: transport,
 		},
-		httpVersion:    httpVersion,
+		isH2:           isH2,
+		isH3:           isH3,
 		uploadRawPool:  &sync.Pool{},
 		dialUploadConn: dialContext,
 	}
@@ -255,16 +241,17 @@ func init() {
 }

 func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (stat.Connection, error) {
+	errors.LogInfo(ctx, "dialing splithttp to ", dest)
+
+	var requestURL url.URL
+
+	transportConfiguration := streamSettings.ProtocolSettings.(*Config)
 	tlsConfig := tls.ConfigFromStreamSettings(streamSettings)
 	realityConfig := reality.ConfigFromStreamSettings(streamSettings)

-	httpVersion := decideHTTPVersion(tlsConfig, realityConfig)
-	if httpVersion == "3" {
-		dest.Network = net.Network_UDP
-	}
-
-	transportConfiguration := streamSettings.ProtocolSettings.(*Config)
-	var requestURL url.URL
+	scMaxConcurrentPosts := transportConfiguration.GetNormalizedScMaxConcurrentPosts()
+	scMaxEachPostBytes := transportConfiguration.GetNormalizedScMaxEachPostBytes()
+	scMinPostsIntervalMs := transportConfiguration.GetNormalizedScMinPostsIntervalMs()

 	if tlsConfig != nil || realityConfig != nil {
 		requestURL.Scheme = "https"
@@ -272,134 +259,106 @@ func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.Me
 		requestURL.Scheme = "http"
 	}
 	requestURL.Host = transportConfiguration.Host
-	if requestURL.Host == "" && tlsConfig != nil {
-		requestURL.Host = tlsConfig.ServerName
-	}
-	if requestURL.Host == "" && realityConfig != nil {
-		requestURL.Host = realityConfig.ServerName
-	}
 	if requestURL.Host == "" {
-		requestURL.Host = dest.Address.String()
+		requestURL.Host = dest.NetAddr()
 	}

 	sessionIdUuid := uuid.New()
 	requestURL.Path = transportConfiguration.GetNormalizedPath() + sessionIdUuid.String()
 	requestURL.RawQuery = transportConfiguration.GetNormalizedQuery()

-	httpClient, xmuxClient := getHTTPClient(ctx, dest, streamSettings)
+	httpClient, muxRes := getHTTPClient(ctx, dest, streamSettings)

-	mode := transportConfiguration.Mode
-	if mode == "" || mode == "auto" {
-		mode = "packet-up"
-		if httpVersion == "2" {
-			mode = "stream-up"
-		}
-		if realityConfig != nil && transportConfiguration.DownloadSettings == nil {
-			mode = "stream-one"
-		}
-	}
-
-	errors.LogInfo(ctx, fmt.Sprintf("XHTTP is dialing to %s, mode %s, HTTP version %s, host %s", dest, mode, httpVersion, requestURL.Host))
-
-	requestURL2 := requestURL
 	httpClient2 := httpClient
-	xmuxClient2 := xmuxClient
+	requestURL2 := requestURL
+	var muxRes2 *muxResource
 	if transportConfiguration.DownloadSettings != nil {
 		globalDialerAccess.Lock()
 		if streamSettings.DownloadSettings == nil {
 			streamSettings.DownloadSettings = common.Must2(internet.ToMemoryStreamConfig(transportConfiguration.DownloadSettings)).(*internet.MemoryStreamConfig)
-			if streamSettings.DownloadSettings.SocketSettings == nil {
-				streamSettings.DownloadSettings.SocketSettings = streamSettings.SocketSettings
-			}
 		}
 		globalDialerAccess.Unlock()
 		memory2 := streamSettings.DownloadSettings
-		dest2 := *memory2.Destination // just panic
-		tlsConfig2 := tls.ConfigFromStreamSettings(memory2)
-		realityConfig2 := reality.ConfigFromStreamSettings(memory2)
-		httpVersion2 := decideHTTPVersion(tlsConfig2, realityConfig2)
-		if httpVersion2 == "3" {
-			dest2.Network = net.Network_UDP
-		}
-		if tlsConfig2 != nil || realityConfig2 != nil {
+		httpClient2, muxRes2 = getHTTPClient(ctx, *memory2.Destination, memory2) // just panic
+		if tls.ConfigFromStreamSettings(memory2) != nil || reality.ConfigFromStreamSettings(memory2) != nil {
 			requestURL2.Scheme = "https"
 		} else {
 			requestURL2.Scheme = "http"
 		}
 		config2 := memory2.ProtocolSettings.(*Config)
 		requestURL2.Host = config2.Host
-		if requestURL2.Host == "" && tlsConfig2 != nil {
-			requestURL2.Host = tlsConfig2.ServerName
-		}
-		if requestURL2.Host == "" && realityConfig2 != nil {
-			requestURL2.Host = realityConfig2.ServerName
-		}
 		if requestURL2.Host == "" {
-			requestURL2.Host = dest2.Address.String()
+			requestURL2.Host = memory2.Destination.NetAddr()
 		}
 		requestURL2.Path = config2.GetNormalizedPath() + sessionIdUuid.String()
 		requestURL2.RawQuery = config2.GetNormalizedQuery()
-		httpClient2, xmuxClient2 = getHTTPClient(ctx, dest2, memory2)
-		errors.LogInfo(ctx, fmt.Sprintf("XHTTP is downloading from %s, mode %s, HTTP version %s, host %s", dest2, "stream-down", httpVersion2, requestURL2.Host))
 	}

-	if xmuxClient != nil {
-		xmuxClient.OpenUsage.Add(1)
+	mode := transportConfiguration.Mode
+	if mode == "" || mode == "auto" {
+		mode = "packet-up"
+		if (tlsConfig != nil && (len(tlsConfig.NextProtocol) != 1 || tlsConfig.NextProtocol[0] == "h2")) || realityConfig != nil {
+			mode = "stream-up"
+		}
+		if realityConfig != nil && transportConfiguration.DownloadSettings == nil {
+			mode = "stream-one"
+		}
 	}
-	if xmuxClient2 != nil && xmuxClient2 != xmuxClient {
-		xmuxClient2.OpenUsage.Add(1)
-	}
-	var closed atomic.Int32
+	errors.LogInfo(ctx, "XHTTP is using mode: "+mode)
+
+	var writer io.WriteCloser
+	var reader io.ReadCloser
+	var remoteAddr, localAddr net.Addr
+	var err error
+
+	if mode == "stream-one" {
+		requestURL.Path = transportConfiguration.GetNormalizedPath()
+		writer, reader = httpClient.Open(context.WithoutCancel(ctx), requestURL.String())
+		remoteAddr = &net.TCPAddr{}
+		localAddr = &net.TCPAddr{}
+	} else {
+		reader, remoteAddr, localAddr, err = httpClient2.OpenDownload(context.WithoutCancel(ctx), requestURL2.String())
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if muxRes != nil {
+		muxRes.OpenRequests.Add(1)
+	}
+	if muxRes2 != nil {
+		muxRes2.OpenRequests.Add(1)
+	}
+	closed := false

-	reader, writer := io.Pipe()
 	conn := splitConn{
-		writer: writer,
+		writer:     writer,
+		reader:     reader,
+		remoteAddr: remoteAddr,
+		localAddr:  localAddr,
 		onClose: func() {
-			if closed.Add(1) > 1 {
+			if closed {
 				return
 			}
-			if xmuxClient != nil {
-				xmuxClient.OpenUsage.Add(-1)
+			closed = true
+			if muxRes != nil {
+				muxRes.OpenRequests.Add(-1)
 			}
-			if xmuxClient2 != nil && xmuxClient2 != xmuxClient {
-				xmuxClient2.OpenUsage.Add(-1)
+			if muxRes2 != nil {
+				muxRes2.OpenRequests.Add(-1)
 			}
 		},
 	}

 	if mode == "stream-one" {
-		requestURL.Path = transportConfiguration.GetNormalizedPath()
-		if xmuxClient != nil {
-			xmuxClient.LeftRequests.Add(-1)
-		}
-		conn.reader, conn.remoteAddr, conn.localAddr, _ = httpClient.OpenStream(context.WithoutCancel(ctx), requestURL.String(), reader, false)
 		return stat.Connection(&conn), nil
-	} else { // stream-down
-		var err error
-		if xmuxClient2 != nil {
-			xmuxClient2.LeftRequests.Add(-1)
-		}
-		conn.reader, conn.remoteAddr, conn.localAddr, err = httpClient2.OpenStream(context.WithoutCancel(ctx), requestURL2.String(), nil, false)
-		if err != nil { // browser dialer only
-			return nil, err
-		}
 	}
 	if mode == "stream-up" {
-		if xmuxClient != nil {
-			xmuxClient.LeftRequests.Add(-1)
-		}
-		httpClient.OpenStream(ctx, requestURL.String(), reader, true)
+		conn.writer = httpClient.OpenUpload(ctx, requestURL.String())
 		return stat.Connection(&conn), nil
 	}

-	scMaxEachPostBytes := transportConfiguration.GetNormalizedScMaxEachPostBytes()
-	scMinPostsIntervalMs := transportConfiguration.GetNormalizedScMinPostsIntervalMs()
-
-	if scMaxEachPostBytes.From <= buf.Size {
-		panic("`scMaxEachPostBytes` should be bigger than " + strconv.Itoa(buf.Size))
-	}
-
-	maxUploadSize := scMaxEachPostBytes.rand()
+	maxUploadSize := scMaxEachPostBytes.roll()
 	// WithSizeLimit(0) will still allow single bytes to pass, and a lot of
 	// code relies on this behavior. Subtract 1 so that together with
 	// uploadWriter wrapper, exact size limits can be enforced
@@ -412,62 +371,54 @@ func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.Me
 	}

 	go func() {
-		var seq int64
-		var lastWrite time.Time
+		requestsLimiter := semaphore.New(int(scMaxConcurrentPosts.roll()))
+		var requestCounter int64

+		lastWrite := time.Now()
+
+		// by offloading the uploads into a buffered pipe, multiple conn.Write
+		// calls get automatically batched together into larger POST requests.
+		// without batching, bandwidth is extremely limited.
 		for {
-			wroteRequest := done.New()
-
-			ctx := httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{
-				WroteRequest: func(httptrace.WroteRequestInfo) {
-					wroteRequest.Close()
-				},
-			})
-
-			// this intentionally makes a shallow-copy of the struct so we
-			// can reassign Path (potentially concurrently)
-			url := requestURL
-			url.Path += "/" + strconv.FormatInt(seq, 10)
-			// reassign query to get different padding
-			url.RawQuery = transportConfiguration.GetNormalizedQuery()
-
-			seq += 1
-
-			if scMinPostsIntervalMs.From > 0 {
-				time.Sleep(time.Duration(scMinPostsIntervalMs.rand())*time.Millisecond - time.Since(lastWrite))
-			}
-
-			// by offloading the uploads into a buffered pipe, multiple conn.Write
-			// calls get automatically batched together into larger POST requests.
-			// without batching, bandwidth is extremely limited.
 			chunk, err := uploadPipeReader.ReadMultiBuffer()
 			if err != nil {
 				break
 			}

-			lastWrite = time.Now()
+			<-requestsLimiter.Wait()

-			if xmuxClient != nil && (xmuxClient.LeftRequests.Add(-1) <= 0 ||
-				(xmuxClient.UnreusableAt != time.Time{} && lastWrite.After(xmuxClient.UnreusableAt))) {
-				httpClient, xmuxClient = getHTTPClient(ctx, dest, streamSettings)
-			}
+			seq := requestCounter
+			requestCounter += 1

 			go func() {
-				err := httpClient.PostPacket(
+				defer requestsLimiter.Signal()
+
+				// this intentionally makes a shallow-copy of the struct so we
+				// can reassign Path (potentially concurrently)
+				url := requestURL
+				url.Path += "/" + strconv.FormatInt(seq, 10)
+				// reassign query to get different padding
+				url.RawQuery = transportConfiguration.GetNormalizedQuery()
+
+				err := httpClient.SendUploadRequest(
 					context.WithoutCancel(ctx),
 					url.String(),
 					&buf.MultiBufferContainer{MultiBuffer: chunk},
 					int64(chunk.Len()),
 				)
-				wroteRequest.Close()
 				if err != nil {
 					errors.LogInfoInner(ctx, err, "failed to send upload")
 					uploadPipeReader.Interrupt()
 				}
 			}()

-			if _, ok := httpClient.(*DefaultDialerClient); ok {
-				<-wroteRequest.Wait()
+			if scMinPostsIntervalMs.From > 0 {
+				roll := time.Duration(scMinPostsIntervalMs.roll()) * time.Millisecond
+				if time.Since(lastWrite) < roll {
+					time.Sleep(roll)
+				}
+
+				lastWrite = time.Now()
 			}
 		}
 	}()
--- a/transport/internet/splithttp/hub.go
+++ b/transport/internet/splithttp/hub.go
@@ -11,8 +11,8 @@ import (
 	"sync"
 	"time"

-	"github.com/xtls/quic-go"
-	"github.com/xtls/quic-go/http3"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3"
 	goreality "github.com/xtls/reality"
 	"github.com/xtls/xray-core/common"
 	"github.com/xtls/xray-core/common/errors"
@@ -78,7 +78,7 @@ func (h *requestHandler) upsertSession(sessionId string) *httpSession {
 	}

 	s := &httpSession{
-		uploadQueue:      NewUploadQueue(h.ln.config.GetNormalizedScMaxBufferedPosts()),
+		uploadQueue:      NewUploadQueue(int(h.ln.config.GetNormalizedScMaxConcurrentPosts().To)),
 		isFullyConnected: done.New(),
 	}

@@ -333,30 +333,30 @@ func ListenSH(ctx context.Context, address net.Address, port net.Port, streamSet
 			Net:  "unix",
 		}, streamSettings.SocketSettings)
 		if err != nil {
-			return nil, errors.New("failed to listen UNIX domain socket for XHTTP on ", address).Base(err)
+			return nil, errors.New("failed to listen unix domain socket(for SH) on ", address).Base(err)
 		}
-		errors.LogInfo(ctx, "listening UNIX domain socket for XHTTP on ", address)
+		errors.LogInfo(ctx, "listening unix domain socket(for SH) on ", address)
 	} else if l.isH3 { // quic
 		Conn, err := internet.ListenSystemPacket(context.Background(), &net.UDPAddr{
 			IP:   address.IP(),
 			Port: int(port),
 		}, streamSettings.SocketSettings)
 		if err != nil {
-			return nil, errors.New("failed to listen UDP for XHTTP/3 on ", address, ":", port).Base(err)
+			return nil, errors.New("failed to listen UDP(for SH3) on ", address, ":", port).Base(err)
 		}
 		h3listener, err := quic.ListenEarly(Conn, tlsConfig, nil)
 		if err != nil {
-			return nil, errors.New("failed to listen QUIC for XHTTP/3 on ", address, ":", port).Base(err)
+			return nil, errors.New("failed to listen QUIC(for SH3) on ", address, ":", port).Base(err)
 		}
 		l.h3listener = h3listener
-		errors.LogInfo(ctx, "listening QUIC for XHTTP/3 on ", address, ":", port)
+		errors.LogInfo(ctx, "listening QUIC(for SH3) on ", address, ":", port)

 		l.h3server = &http3.Server{
 			Handler: handler,
 		}
 		go func() {
 			if err := l.h3server.ServeListener(l.h3listener); err != nil {
-				errors.LogWarningInner(ctx, err, "failed to serve HTTP/3 for XHTTP/3")
+				errors.LogWarningInner(ctx, err, "failed to serve http3 for splithttp")
 			}
 		}()
 	} else { // tcp
@@ -369,9 +369,9 @@ func ListenSH(ctx context.Context, address net.Address, port net.Port, streamSet
 			Port: int(port),
 		}, streamSettings.SocketSettings)
 		if err != nil {
-			return nil, errors.New("failed to listen TCP for XHTTP on ", address, ":", port).Base(err)
+			return nil, errors.New("failed to listen TCP(for SH) on ", address, ":", port).Base(err)
 		}
-		errors.LogInfo(ctx, "listening TCP for XHTTP on ", address, ":", port)
+		errors.LogInfo(ctx, "listening TCP(for SH) on ", address, ":", port)
 	}

 	// tcp/unix (h1/h2)
@@ -397,7 +397,7 @@ func ListenSH(ctx context.Context, address net.Address, port net.Port, streamSet

 		go func() {
 			if err := l.server.Serve(l.listener); err != nil {
-				errors.LogWarningInner(ctx, err, "failed to serve HTTP for XHTTP")
+				errors.LogWarningInner(ctx, err, "failed to serve http for splithttp")
 			}
 		}()
 	}
--- a/transport/internet/splithttp/lazy_reader.go
+++ b/transport/internet/splithttp/lazy_reader.go
@@ -0,0 +1,47 @@
+package splithttp
+
+import (
+	"io"
+	"sync"
+)
+
+// Close is intentionally not supported by LazyReader because it's not clear
+// how CreateReader should be aborted in case of Close. It's best to wrap
+// LazyReader in another struct that handles Close correctly, or better, stop
+// using LazyReader entirely.
+type LazyReader struct {
+	readerSync   sync.Mutex
+	CreateReader func() (io.Reader, error)
+	reader       io.Reader
+	readerError  error
+}
+
+func (r *LazyReader) getReader() (io.Reader, error) {
+	r.readerSync.Lock()
+	defer r.readerSync.Unlock()
+	if r.reader != nil {
+		return r.reader, nil
+	}
+
+	if r.readerError != nil {
+		return nil, r.readerError
+	}
+
+	reader, err := r.CreateReader()
+	if err != nil {
+		r.readerError = err
+		return nil, err
+	}
+
+	r.reader = reader
+	return reader, nil
+}
+
+func (r *LazyReader) Read(b []byte) (int, error) {
+	reader, err := r.getReader()
+	if err != nil {
+		return 0, err
+	}
+	n, err := reader.Read(b)
+	return n, err
+}
--- a/transport/internet/splithttp/mux.go
+++ b/transport/internet/splithttp/mux.go
@@ -2,112 +2,101 @@ package splithttp

 import (
 	"context"
-	"crypto/rand"
-	"math"
-	"math/big"
+	"math/rand"
 	"sync/atomic"
 	"time"

 	"github.com/xtls/xray-core/common/errors"
 )

-type XmuxConn interface {
-	IsClosed() bool
+type muxResource struct {
+	Resource       interface{}
+	OpenRequests   atomic.Int32
+	leftUsage      int32
+	expirationTime time.Time
 }

-type XmuxClient struct {
-	XmuxConn     XmuxConn
-	OpenUsage    atomic.Int32
-	leftUsage    int32
-	LeftRequests atomic.Int32
-	UnreusableAt time.Time
+type muxManager struct {
+	newResourceFn func() interface{}
+	config        Multiplexing
+	concurrency   int32
+	connections   int32
+	instances     []*muxResource
 }

-type XmuxManager struct {
-	xmuxConfig  XmuxConfig
-	concurrency int32
-	connections int32
-	newConnFunc func() XmuxConn
-	xmuxClients []*XmuxClient
-}
-
-func NewXmuxManager(xmuxConfig XmuxConfig, newConnFunc func() XmuxConn) *XmuxManager {
-	return &XmuxManager{
-		xmuxConfig:  xmuxConfig,
-		concurrency: xmuxConfig.GetNormalizedMaxConcurrency().rand(),
-		connections: xmuxConfig.GetNormalizedMaxConnections().rand(),
-		newConnFunc: newConnFunc,
-		xmuxClients: make([]*XmuxClient, 0),
+func NewMuxManager(config Multiplexing, newResource func() interface{}) *muxManager {
+	return &muxManager{
+		config:        config,
+		concurrency:   config.GetNormalizedMaxConcurrency().roll(),
+		connections:   config.GetNormalizedMaxConnections().roll(),
+		newResourceFn: newResource,
+		instances:     make([]*muxResource, 0),
 	}
 }

-func (m *XmuxManager) newXmuxClient() *XmuxClient {
-	xmuxClient := &XmuxClient{
-		XmuxConn:  m.newConnFunc(),
-		leftUsage: -1,
-	}
-	if x := m.xmuxConfig.GetNormalizedCMaxReuseTimes().rand(); x > 0 {
-		xmuxClient.leftUsage = x - 1
-	}
-	xmuxClient.LeftRequests.Store(math.MaxInt32)
-	if x := m.xmuxConfig.GetNormalizedHMaxRequestTimes().rand(); x > 0 {
-		xmuxClient.LeftRequests.Store(x)
-	}
-	if x := m.xmuxConfig.GetNormalizedHMaxReusableSecs().rand(); x > 0 {
-		xmuxClient.UnreusableAt = time.Now().Add(time.Duration(x) * time.Second)
-	}
-	m.xmuxClients = append(m.xmuxClients, xmuxClient)
-	return xmuxClient
-}
+func (m *muxManager) GetResource(ctx context.Context) *muxResource {
+	m.removeExpiredConnections(ctx)

-func (m *XmuxManager) GetXmuxClient(ctx context.Context) *XmuxClient { // when locking
-	for i := 0; i < len(m.xmuxClients); {
-		xmuxClient := m.xmuxClients[i]
-		if xmuxClient.XmuxConn.IsClosed() ||
-			xmuxClient.leftUsage == 0 ||
-			xmuxClient.LeftRequests.Load() <= 0 ||
-			(xmuxClient.UnreusableAt != time.Time{} && time.Now().After(xmuxClient.UnreusableAt)) {
-			errors.LogDebug(ctx, "XMUX: removing xmuxClient, IsClosed() = ", xmuxClient.XmuxConn.IsClosed(),
-				", OpenUsage = ", xmuxClient.OpenUsage.Load(),
-				", leftUsage = ", xmuxClient.leftUsage,
-				", LeftRequests = ", xmuxClient.LeftRequests.Load(),
-				", UnreusableAt = ", xmuxClient.UnreusableAt)
-			m.xmuxClients = append(m.xmuxClients[:i], m.xmuxClients[i+1:]...)
-		} else {
-			i++
-		}
+	if m.connections > 0 && len(m.instances) < int(m.connections) {
+		errors.LogDebug(ctx, "xmux: creating client, connections=", len(m.instances))
+		return m.newResource()
 	}

-	if len(m.xmuxClients) == 0 {
-		errors.LogDebug(ctx, "XMUX: creating xmuxClient because xmuxClients is empty")
-		return m.newXmuxClient()
+	if len(m.instances) == 0 {
+		errors.LogDebug(ctx, "xmux: creating client because instances is empty, connections=", len(m.instances))
+		return m.newResource()
 	}

-	if m.connections > 0 && len(m.xmuxClients) < int(m.connections) {
-		errors.LogDebug(ctx, "XMUX: creating xmuxClient because maxConnections was not hit, xmuxClients = ", len(m.xmuxClients))
-		return m.newXmuxClient()
-	}
-
-	xmuxClients := make([]*XmuxClient, 0)
+	clients := make([]*muxResource, 0)
 	if m.concurrency > 0 {
-		for _, xmuxClient := range m.xmuxClients {
-			if xmuxClient.OpenUsage.Load() < m.concurrency {
-				xmuxClients = append(xmuxClients, xmuxClient)
+		for _, client := range m.instances {
+			openRequests := client.OpenRequests.Load()
+			if openRequests < m.concurrency {
+				clients = append(clients, client)
 			}
 		}
 	} else {
-		xmuxClients = m.xmuxClients
+		clients = m.instances
 	}

-	if len(xmuxClients) == 0 {
-		errors.LogDebug(ctx, "XMUX: creating xmuxClient because maxConcurrency was hit, xmuxClients = ", len(m.xmuxClients))
-		return m.newXmuxClient()
+	if len(clients) == 0 {
+		errors.LogDebug(ctx, "xmux: creating client because concurrency was hit, total clients=", len(m.instances))
+		return m.newResource()
 	}

-	i, _ := rand.Int(rand.Reader, big.NewInt(int64(len(xmuxClients))))
-	xmuxClient := xmuxClients[i.Int64()]
-	if xmuxClient.leftUsage > 0 {
-		xmuxClient.leftUsage -= 1
+	client := clients[rand.Intn(len(clients))]
+	if client.leftUsage > 0 {
+		client.leftUsage -= 1
+	}
+	return client
+}
+
+func (m *muxManager) newResource() *muxResource {
+	leftUsage := int32(-1)
+	if x := m.config.GetNormalizedCMaxReuseTimes().roll(); x > 0 {
+		leftUsage = x - 1
+	}
+	expirationTime := time.UnixMilli(0)
+	if x := m.config.GetNormalizedCMaxLifetimeMs().roll(); x > 0 {
+		expirationTime = time.Now().Add(time.Duration(x) * time.Millisecond)
+	}
+
+	client := &muxResource{
+		Resource:       m.newResourceFn(),
+		leftUsage:      leftUsage,
+		expirationTime: expirationTime,
+	}
+	m.instances = append(m.instances, client)
+	return client
+}
+
+func (m *muxManager) removeExpiredConnections(ctx context.Context) {
+	for i := 0; i < len(m.instances); i++ {
+		client := m.instances[i]
+		if client.leftUsage == 0 || (client.expirationTime != time.UnixMilli(0) && time.Now().After(client.expirationTime)) {
+			errors.LogDebug(ctx, "xmux: removing client, leftUsage = ", client.leftUsage, ", expirationTime = ", client.expirationTime)
+			m.instances = append(m.instances[:i], m.instances[i+1:]...)
+			i--
+		}
 	}
-	return xmuxClient
 }
--- a/transport/internet/splithttp/mux_test.go
+++ b/transport/internet/splithttp/mux_test.go
@@ -9,84 +9,80 @@ import (

 type fakeRoundTripper struct{}

-func (f *fakeRoundTripper) IsClosed() bool {
-	return false
-}
-
 func TestMaxConnections(t *testing.T) {
-	xmuxConfig := XmuxConfig{
-		MaxConnections: &RangeConfig{From: 4, To: 4},
+	config := Multiplexing{
+		MaxConnections: &RandRangeConfig{From: 4, To: 4},
 	}

-	xmuxManager := NewXmuxManager(xmuxConfig, func() XmuxConn {
+	mux := NewMuxManager(config, func() interface{} {
 		return &fakeRoundTripper{}
 	})

-	xmuxClients := make(map[interface{}]struct{})
+	clients := make(map[interface{}]struct{})
 	for i := 0; i < 8; i++ {
-		xmuxClients[xmuxManager.GetXmuxClient(context.Background())] = struct{}{}
+		clients[mux.GetResource(context.Background())] = struct{}{}
 	}

-	if len(xmuxClients) != 4 {
-		t.Error("did not get 4 distinct clients, got ", len(xmuxClients))
+	if len(clients) != 4 {
+		t.Error("did not get 4 distinct clients, got ", len(clients))
 	}
 }

 func TestCMaxReuseTimes(t *testing.T) {
-	xmuxConfig := XmuxConfig{
-		CMaxReuseTimes: &RangeConfig{From: 2, To: 2},
+	config := Multiplexing{
+		CMaxReuseTimes: &RandRangeConfig{From: 2, To: 2},
 	}

-	xmuxManager := NewXmuxManager(xmuxConfig, func() XmuxConn {
+	mux := NewMuxManager(config, func() interface{} {
 		return &fakeRoundTripper{}
 	})

-	xmuxClients := make(map[interface{}]struct{})
+	clients := make(map[interface{}]struct{})
 	for i := 0; i < 64; i++ {
-		xmuxClients[xmuxManager.GetXmuxClient(context.Background())] = struct{}{}
+		clients[mux.GetResource(context.Background())] = struct{}{}
 	}

-	if len(xmuxClients) != 32 {
-		t.Error("did not get 32 distinct clients, got ", len(xmuxClients))
+	if len(clients) != 32 {
+		t.Error("did not get 32 distinct clients, got ", len(clients))
 	}
 }

 func TestMaxConcurrency(t *testing.T) {
-	xmuxConfig := XmuxConfig{
-		MaxConcurrency: &RangeConfig{From: 2, To: 2},
+	config := Multiplexing{
+		MaxConcurrency: &RandRangeConfig{From: 2, To: 2},
 	}

-	xmuxManager := NewXmuxManager(xmuxConfig, func() XmuxConn {
+	mux := NewMuxManager(config, func() interface{} {
 		return &fakeRoundTripper{}
 	})

-	xmuxClients := make(map[interface{}]struct{})
+	clients := make(map[interface{}]struct{})
 	for i := 0; i < 64; i++ {
-		xmuxClient := xmuxManager.GetXmuxClient(context.Background())
-		xmuxClient.OpenUsage.Add(1)
-		xmuxClients[xmuxClient] = struct{}{}
+		client := mux.GetResource(context.Background())
+		client.OpenRequests.Add(1)
+		clients[client] = struct{}{}
 	}

-	if len(xmuxClients) != 32 {
-		t.Error("did not get 32 distinct clients, got ", len(xmuxClients))
+	if len(clients) != 32 {
+		t.Error("did not get 32 distinct clients, got ", len(clients))
 	}
 }

 func TestDefault(t *testing.T) {
-	xmuxConfig := XmuxConfig{}
+	config := Multiplexing{}

-	xmuxManager := NewXmuxManager(xmuxConfig, func() XmuxConn {
+	mux := NewMuxManager(config, func() interface{} {
 		return &fakeRoundTripper{}
 	})

-	xmuxClients := make(map[interface{}]struct{})
+	clients := make(map[interface{}]struct{})
 	for i := 0; i < 64; i++ {
-		xmuxClient := xmuxManager.GetXmuxClient(context.Background())
-		xmuxClient.OpenUsage.Add(1)
-		xmuxClients[xmuxClient] = struct{}{}
+		client := mux.GetResource(context.Background())
+		client.OpenRequests.Add(1)
+		clients[client] = struct{}{}
 	}

-	if len(xmuxClients) != 1 {
-		t.Error("did not get 1 distinct clients, got ", len(xmuxClients))
+	if len(clients) != 1 {
+		t.Error("did not get 1 distinct clients, got ", len(clients))
 	}
 }
--- a/transport/internet/splithttp/splithttp_test.go
+++ b/transport/internet/splithttp/splithttp_test.go
@@ -109,7 +109,7 @@ func TestDialWithRemoteAddr(t *testing.T) {

 	conn, err := Dial(context.Background(), net.TCPDestination(net.DomainAddress("localhost"), listenPort), &internet.MemoryStreamConfig{
 		ProtocolName:     "splithttp",
-		ProtocolSettings: &Config{Path: "sh", Headers: map[string]string{"X-Forwarded-For": "1.1.1.1"}},
+		ProtocolSettings: &Config{Path: "sh", Header: map[string]string{"X-Forwarded-For": "1.1.1.1"}},
 	})

 	common.Must(err)
@@ -423,7 +423,7 @@ func Test_maxUpload(t *testing.T) {
 		ProtocolName: "splithttp",
 		ProtocolSettings: &Config{
 			Path: "/sh",
-			ScMaxEachPostBytes: &RangeConfig{
+			ScMaxEachPostBytes: &RandRangeConfig{
 				From: 10000,
 				To:   10000,
 			},
--- a/transport/internet/splithttp/upload_queue.go
+++ b/transport/internet/splithttp/upload_queue.go
@@ -52,7 +52,7 @@ func (h *uploadQueue) Push(p Packet) error {
 		if p.Reader != nil {
 			p.Reader.Close()
 		}
-		return errors.New("packet queue closed")
+		return errors.New("splithttp packet queue closed")
 	}

 	h.pushedPackets <- p
--- a/transport/internet/tagged/tagged.go
+++ b/transport/internet/tagged/tagged.go
@@ -4,9 +4,8 @@ import (
 	"context"

 	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/features/routing"
 )

-type DialFunc func(ctx context.Context, dispatcher routing.Dispatcher, dest net.Destination, tag string) (net.Conn, error)
+type DialFunc func(ctx context.Context, dest net.Destination, tag string) (net.Conn, error)

 var Dialer DialFunc
--- a/transport/internet/tagged/taggedimpl/impl.go
+++ b/transport/internet/tagged/taggedimpl/impl.go
@@ -12,10 +12,17 @@ import (
 	"github.com/xtls/xray-core/transport/internet/tagged"
 )

-func DialTaggedOutbound(ctx context.Context, dispatcher routing.Dispatcher, dest net.Destination, tag string) (net.Conn, error) {
+func DialTaggedOutbound(ctx context.Context, dest net.Destination, tag string) (net.Conn, error) {
+	var dispatcher routing.Dispatcher
 	if core.FromContext(ctx) == nil {
 		return nil, errors.New("Instance context variable is not in context, dial denied. ")
 	}
+	if err := core.RequireFeatures(ctx, func(dispatcherInstance routing.Dispatcher) {
+		dispatcher = dispatcherInstance
+	}); err != nil {
+		return nil, errors.New("Required Feature dispatcher not resolved").Base(err)
+	}
+
 	content := new(session.Content)
 	content.SkipDNSResolve = true

--- a/transport/internet/tls/tls.go
+++ b/transport/internet/tls/tls.go
@@ -165,7 +165,7 @@ func init() {

 func GetFingerprint(name string) (fingerprint *utls.ClientHelloID) {
 	if name == "" {
-		return &utls.HelloChrome_Auto
+		return
 	}
 	if fingerprint = PresetFingerprints[name]; fingerprint != nil {
 		return
@@ -191,7 +191,6 @@ var PresetFingerprints = map[string]*utls.ClientHelloID{
 	"qq":         &utls.HelloQQ_Auto,
 	"random":     nil,
 	"randomized": nil,
-	"unsafe":     nil,
 }

 var ModernFingerprints = map[string]*utls.ClientHelloID{
--- a/transport/internet/websocket/config.go
+++ b/transport/internet/websocket/config.go
@@ -23,6 +23,7 @@ func (c *Config) GetRequestHeader() http.Header {
 	for k, v := range c.Header {
 		header.Add(k, v)
 	}
+	header.Set("Host", c.Host)
 	return header
 }

--- a/transport/internet/websocket/dialer.go
+++ b/transport/internet/websocket/dialer.go
@@ -58,12 +58,11 @@ func dialWebSocket(ctx context.Context, dest net.Destination, streamSettings *in

 	protocol := "ws"

-	tConfig := tls.ConfigFromStreamSettings(streamSettings)
-	if tConfig != nil {
+	if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
 		protocol = "wss"
-		tlsConfig := tConfig.GetTLSConfig(tls.WithDestination(dest), tls.WithNextProto("http/1.1"))
+		tlsConfig := config.GetTLSConfig(tls.WithDestination(dest), tls.WithNextProto("http/1.1"))
 		dialer.TLSClientConfig = tlsConfig
-		if fingerprint := tls.GetFingerprint(tConfig.Fingerprint); fingerprint != nil {
+		if fingerprint := tls.GetFingerprint(config.Fingerprint); fingerprint != nil {
 			dialer.NetDialTLSContext = func(_ context.Context, _, addr string) (gonet.Conn, error) {
 				// Like the NetDial in the dialer
 				pconn, err := internet.DialSystem(ctx, dest, streamSettings.SocketSettings)
@@ -104,14 +103,6 @@ func dialWebSocket(ctx context.Context, dest net.Destination, streamSettings *in
 	}

 	header := wsSettings.GetRequestHeader()
-	// See dialer.DialContext()
-	header.Set("Host", wsSettings.Host)
-	if header.Get("Host") == "" && tConfig != nil {
-		header.Set("Host", tConfig.ServerName)
-	}
-	if header.Get("Host") == "" {
-		header.Set("Host", dest.Address.String())
-	}
 	if ed != nil {
 		// RawURLEncoding is support by both V2Ray/V2Fly and XRay.
 		header.Set("Sec-WebSocket-Protocol", base64.RawURLEncoding.EncodeToString(ed))