h2

type H2 struct {
	//MaxHandlers:                  0,
	//MaxConcurrentStreams:         0,
	//MaxDecoderHeaderTableSize:    0,
	//MaxEncoderHeaderTableSize:    0,
	//MaxReadFrameSize:             0,
	//PermitProhibitedCipherSuites: false,
	//IdleTimeout:                  0,
	//MaxUploadBufferPerConnection: 0,
	//MaxUploadBufferPerStream:     0,
	//NewWriteScheduler:            nil,
	//CountError:                   nil,
	// Addr - included
	http.Server

	NetListener net.Listener `json:"-"`

	// The key is a route as defined by go ServerMux.
	// The value can be:
	// - a URL - in which case it's a reverse proxy
	// - a string that is a resource name - in which case it's a Handler
	// Other values like TCP proxy can be defined later.
	Routes map[string]string

	// The actual mux that is configured. Will be mapped to a H2C/H1 server by
	// default, assuming ambient or secure network.
	Mux *http.ServeMux `json:"-"`

	SSHStreamHandler func(net.Conn) error `json:"-"`

	// DialMeta opens a TCP connection to a client using -R on 80
	// or 443, using the FQDN. This and next 2 functions integrate
	// with the 'mesh' layer, discovering or using connections.
	DialMeta func(context.Context, string, string) (io.ReadWriteCloser, error) `json:"-"`

	FindRoundTripper func(ctx context.Context, urlOrHost string) (http.RoundTripper, error)

	// RegisterReverse handles a mapping of '-R' remote accept connections.
	// HTTP, SSH are treated specially.
	RegisterReverse func(ctx context.Context, host string, rt http.RoundTripper)

	TokenSource TokenSource `json:"-"`

	// ResourceStore is used to resolve resources, is a registry of types and
	// objects. We're looking for handlers.
	ResourceStore ResourceStore `json:"-"`

	Logger *slog.Logger
	// contains filtered or unexported fields
}

type H2C struct {
	http.Transport
}

type Proxy1 struct {
	URL string
	// contains filtered or unexported fields
}

type ResourceStore interface {
	Resource(ctx context.Context, name string) (any, error)
}

type Stats struct {
	Open time.Time

	// last receive from local (and send to remote)
	LastWrite time.Time

	// last receive from remote (and send to local)
	LastRead time.Time

	// Sent from client to server ( client is initiator of the proxy )
	SentBytes   int
	SentPackets int

	// Received from server to client
	RcvdBytes   int
	RcvdPackets int
}

type StreamHttpClient struct {
	StreamState

	Request  *http.Request
	Response *http.Response

	RequestInPipe io.WriteCloser
}

type StreamHttpServer struct {
	StreamState
	Request        *http.Request
	TLS            *tls.ConnectionState
	ResponseWriter http.ResponseWriter

	// If set, the function will be called when Close() is called.
	ReadCloser func()
}

type StreamState struct {

	// It is the key in the Active table.
	// Streams may also have local ids associated with the transport.
	StreamId string

	// WritErr indicates that Write failed - timeout or a RST closing the stream.
	WriteErr error `json:"-"`
	// ReadErr, if not nil, indicates that Read() failed - connection was closed with RST
	// or timedout instead of FIN
	ReadErr error `json:"-"`

	Stats

	// Original or infered destination.
	Dest string
}

type TokenSource interface {
	// GetToken for a given audience.
	GetToken(context.Context, string) (string, error)
}