wsx

var (
	ErrFrameTooLarge = errors.New("wsx: frame exceeds configured size")
	ErrInvalidOpcode = errors.New("wsx: invalid websocket opcode")
	ErrInvalidConfig = errors.New("wsx: invalid configuration")
	ErrAuthFailed    = errors.New("wsx: authentication failed")
	// ErrOriginNotAllowed is returned by UpgradeStrict when the request
	// Origin (or the absence of one) is rejected by the configured
	// allowlist. SEC-0008: the strict upgrade path is fail-closed, so
	// callers that omit OriginAllowlist and AllowAnyOrigin always see
	// this error.
	ErrOriginNotAllowed = errors.New("wsx: origin not allowed")

	// ErrBadUpgradeHeaders is returned when the Connection or Upgrade
	// request headers do not match the values required by RFC 6455.
	ErrBadUpgradeHeaders = errors.New("wsx: bad upgrade headers")
	// ErrUnsupportedVersion is returned when Sec-WebSocket-Version is
	// not "13" (the only version supported by this implementation).
	ErrUnsupportedVersion = errors.New("wsx: unsupported websocket version")
	// ErrNoHijack is returned when the supplied http.ResponseWriter
	// does not implement http.Hijacker, so the upgrade cannot proceed.
	ErrNoHijack = errors.New("wsx: response writer does not support hijack")
	// ErrInvalidWebSocketKey is returned when the Sec-WebSocket-Key
	// header is missing, malformed, or not 16 bytes after base64 decode.
	ErrInvalidWebSocketKey = errors.New("wsx: invalid sec-websocket-key")
	// ErrForbiddenOrigin is returned by Upgrade (the legacy fail-open
	// entry point) when the Origin header is non-empty and does not
	// match the configured allowlist.
	ErrForbiddenOrigin = errors.New("wsx: forbidden origin")
	// ErrInvalidUTF8 is returned when a text frame payload (op 0x1) or
	// a reassembled text message contains invalid UTF-8.
	ErrInvalidUTF8 = errors.New("wsx: invalid utf-8 in text frame")
	// ErrReservedBitsSet is returned when a frame has any of the
	// reserved bits (RSV1/RSV2/RSV3) set; this implementation does not
	// negotiate any extensions, so they MUST be zero.
	ErrReservedBitsSet = errors.New("wsx: reserved bits set on frame")
	// ErrUnmaskedClientFrame is returned when a server-side reader
	// receives an unmasked frame and unmasked reads are not permitted
	// (per RFC 6455, client→server frames must be masked).
	ErrUnmaskedClientFrame = errors.New("wsx: client frames must be masked")
	// ErrHandshakeMissingUpgrade is returned by Dial when the server
	// response is missing the required Upgrade: websocket header.
	ErrHandshakeMissingUpgrade = errors.New("wsx: websocket handshake failed: missing upgrade header")
	// ErrHandshakeInvalidAccept is returned by Dial when the server's
	// Sec-WebSocket-Accept header does not match the expected value.
	ErrHandshakeInvalidAccept = errors.New("wsx: websocket handshake failed: invalid accept key")
	// ErrControlTooLarge is returned when a control frame (close/ping/pong)
	// declares a payload longer than 125 bytes, which RFC 6455 §5.5
	// forbids. SEC-0055.
	ErrControlTooLarge = errors.New("wsx: control frame payload exceeds 125 bytes")
	// ErrFragmentedControl is returned when a control frame arrives with
	// FIN=0; RFC 6455 §5.5 forbids fragmenting control frames. SEC-0055.
	ErrFragmentedControl = errors.New("wsx: fragmented control frame")
	// ErrTooManyControlFrames is returned when more than maxPendingControl
	// ping/pong frames arrive interleaved within a single fragmented data
	// message; the pending queue is bounded so a peer cannot grow it
	// without limit mid-fragmentation. SEC-0055.
	ErrTooManyControlFrames = errors.New("wsx: too many interleaved control frames")
	// ErrTooManyFragments is returned when a single data message is split
	// across more than maxFragments continuation frames. The cumulative
	// byte budget (maxMessage) already bounds total size, but a peer can
	// stay under it while sending an unbounded number of tiny (even
	// zero-length) continuation frames, forcing per-frame parse work
	// indefinitely. The fragment cap fails closed (protocol error, 1009
	// "message too big" semantics). T-02.
	ErrTooManyFragments = errors.New("wsx: too many continuation fragments in message")
	// ErrPingFlood is returned when a peer streams more than maxPingStream
	// standalone (non-interleaved) ping/pong control frames in a row
	// without any intervening data message. A standalone ping stream is
	// otherwise unbounded: ReadMessage returns each ping to the caller, but
	// a caller in a read loop that ignores pings would spin forever on a
	// flood. The cap fails closed. T-02.
	ErrPingFlood = errors.New("wsx: too many consecutive control frames")
)

var (
	// ErrTotalCap is returned when the pod-wide concurrent-WS cap
	// (Config.MaxConnections / DefaultMaxConnections) is reached.
	ErrTotalCap = errors.New("ws upgrade rejected: pod connection cap")
	// ErrPerIPCap is returned when the per-remote-IP concurrent-WS
	// cap (Config.MaxConnectionsPerIP / DefaultMaxConnectionsPerIP)
	// is reached.
	ErrPerIPCap = errors.New("ws upgrade rejected: per-IP connection cap")
	// ErrRateCap is returned when the per-IP rolling-minute upgrade
	// rate cap (Config.UpgradeRatePerMin / DefaultUpgradeRatePerMin)
	// is exceeded.
	ErrRateCap = errors.New("ws upgrade rejected: per-IP rate cap")
)