conn

type H1State struct {
	RemoteAddr         string
	HijackFn           func() (net.Conn, error)                            // set by engine; nil if unsupported
	MaxRequestBodySize int64                                               // 0 = use default (100 MB)
	OnExpectContinue   func(method, path string, headers [][2]string) bool // nil = always accept
	OnDetach           func()                                              // set by engine; called on Context.Detach
	Detached           bool                                                // set by OnDetach; breaks pipelining loop

	// WSDataDelivery is set by the WebSocket middleware after upgrade (101 sent).
	// When non-nil and Detached, subsequent reads are delivered as raw bytes
	// to this callback instead of being parsed as H1 requests. The callback
	// is called on the event loop thread — it must not block.
	WSDataDelivery func(data []byte)

	// RawWriteFn is set after Detach. It writes raw bytes to the engine's
	// write buffer, bypassing H1 chunked encoding. Used by WebSocket for
	// frame writes.
	RawWriteFn func([]byte)

	// OnDetachClose is called by the engine when it closes a detached
	// connection (timeout, error, shutdown). The WebSocket middleware sets
	// this to close the io.Pipe and data channel, unblocking the handler
	// goroutine. Called under cs.detachMu — must not block.
	//
	// Detached-connection API surface — stable. The fields below
	// (OnDetachClose, OnError, PauseRecv, ResumeRecv, IdleDeadlineNs) form
	// the contract between the engine layer and any long-lived-connection
	// middleware (WebSocket, SSE, gRPC streaming, etc). They are part of
	// the celeris public API: changes require a major version bump.
	OnDetachClose func()

	// OnError is called by the engine when an I/O failure occurs on a
	// detached connection (read error, write error, EPIPE, ECONNRESET, etc).
	// The WebSocket middleware uses this to surface engine-side errors
	// from the next user-level Read or Write call. Called under cs.detachMu
	// — must not block.
	OnError func(err error)

	// PauseRecv and ResumeRecv are set by the engine in OnDetach. The
	// middleware calls them to apply TCP-level backpressure on the inbound
	// data path. They may be called from any goroutine and are no-ops if
	// the engine cannot pause reads (e.g. std hijacked path).
	PauseRecv  func()
	ResumeRecv func()

	// IdleDeadlineNs holds the absolute deadline (Unix nanoseconds) at
	// which a detached connection should be closed by the engine. The
	// WebSocket middleware updates this after each successful frame read;
	// the engine's idle sweep checks it on detached connections. 0 = no
	// deadline.
	IdleDeadlineNs atomic.Int64

	// EnableH2Upgrade, when true, permits this connection to honor a
	// valid RFC 7540 §3.2 h2c upgrade request. Set by the engine at
	// initProtocol time from resource.Config.EnableH2Upgrade.
	EnableH2Upgrade bool
	// UpgradeInfo is populated by ProcessH1 just before returning
	// ErrUpgradeH2C. The engine consumes it via switchToH2 and then clears
	// it. Always nil on a clean (non-upgrade) connection.
	UpgradeInfo *UpgradeInfo
	// contains filtered or unexported fields
}

type H2Config struct {
	MaxConcurrentStreams uint32
	InitialWindowSize    uint32
	MaxFrameSize         uint32
	MaxRequestBodySize   int64 // 0 = use default (100 MB)
}

type H2State struct {
	// contains filtered or unexported fields
}

type UpgradeInfo struct {
	// Settings is the base64url-decoded HTTP2-Settings payload. Each entry
	// is a 6-byte pair (u16 identifier + u32 value); length is always a
	// multiple of 6 (DecodeHTTP2Settings rejects others).
	Settings []byte
	// Method is the H1 request method (used to build the H2 :method
	// pseudo-header).
	Method string
	// URI is the raw request URI as sent on the request line (used for
	// :path).
	URI string
	// Headers are the request's non-hop-by-hop headers, lowercased,
	// excluding Upgrade/Connection/HTTP2-Settings (which are consumed by
	// the upgrade mechanism itself and do not belong on H2 stream 1).
	Headers [][2]string
	// Body holds the request body (may be empty).
	Body []byte
	// Remaining holds the bytes AFTER the H1 request in the recv buffer.
	// May contain 0 bytes, a partial H2 client preface, a full preface, or
	// preface + additional frames. The engine feeds this to ProcessH2
	// synchronously after switchToH2 so no data is dropped at the seam.
	Remaining []byte
}