Package-level declarations
Types
The outcome of MultiConnectionUDPServer.admit - the pre-accept screening decision for an incoming Iam handshake, evaluated on the listener thread before the REGISTERED reply and before any same-name supersede.
A single named, logical connection to one remote client of a MultiConnectionUDPServer.
The datagram-type tag carried as byte 0 of every post-REGISTERED datagram on the framed webtools-udp 2.x transport. The listener switches on this byte before it ever looks at a payload, so control traffic and application traffic no longer share the trimmed-UTF-8 namespace that the pre-2.0 classifier collided on.
Which delivery guarantee a UdpChannel provides. Each entry has its own sequence space and its own inbound handler (see Connection.channel / UdpChannel.actuateBytes).
Why a Connection managed by a MultiConnectionUDPServer stopped being addressable, as reported to MultiConnectionUDPServer.onClientDisconnect.
The server refused the handshake during MultiConnectionUDPClient.handshake: it replied REFUSED <reason> rather than REGISTERED. Distinct from a timeout (the server never answered) and from a malformed reply.
The public, socket-free handshake-bootstrap wire format a client needs: the verb that opens a handshake (Iam <name> [<credential>]), the accepted reply (REGISTERED <version>), and the refusal reply (REFUSED <reason>).
The server's handshake reply announced a different wire-protocol major than this build speaks. Raised by MultiConnectionUDPClient.handshake when the REGISTERED reply is not this build's exact REGISTERED 2: a bare REGISTERED from a pre-2.0 server (remoteVersion 1), or REGISTERED n for some other n.
A point-in-time snapshot of one connection's measured link quality, produced by the opt-in probe (MultiConnectionUDPClient.startProbe / Connection.startProbe). All figures come from the same instant, so RTT and loss are mutually consistent.
The client-side counterpart to MultiConnectionUDPServer: opens the Iam handshake, then owns the entire subsequent session, over one socket.
A UDP server that multiplexes all traffic for any number of clients over a single well-known "common" socket (COMMON_LISTEN_PORT).
A reliable message exceeded the configured cap. Never thrown; only ever the payload of a Result.failure from UdpChannel.send on a reliable channel. 2.0 does not fragment (docs/webtools-udp-protocol.md): split the message yourself, or raise reliableMaxMessageBytes up to UdpChannel.MAX_RELIABLE_MESSAGE_BYTES at the consumer's own IP-fragmentation risk. Unlike ReliableWindowFullException, this keeps its stack trace - it signals a programming or configuration mistake, where the trace is the diagnostic.
The supertype of every failure a reliable UdpChannel.send can report. Deliberately open, not sealed: a caller can catch/is-check one type today, and a future reliable-send failure can join this hierarchy in a minor version without breaking anyone's exhaustive when. abstract because nothing should ever construct or throw the bare supertype - only ReliableWindowFullException and ReliableMessageTooLargeException do, and only ever as a Result.failure payload, never thrown.
The reliable in-flight window is full - inFlight messages are already awaiting acknowledgement. Never thrown; only ever the payload of a Result.failure from UdpChannel.send on a reliable channel - the sibling of HandshakeRefusedException in that respect. This is backpressure, not an error: retry after the next retransmit tick, coalesce the message with a later one, or drop it.
The framed webtools-udp 2.x transport wire format: the 1-byte DatagramType prefix, the control-datagram encodings (keepaliveDatagram, probePingDatagram, probePongDatagram), and the unreliable application-data frame (unreliableDatagram). The handshake bootstrap stays plain UTF-8 text — see HandshakeWireFormat.
A delivery-mode-scoped view of one connection: send under this mode's guarantees, and bind the handler for traffic that arrives under it. Stateless and cheap - hold it, or fetch it per call; either is correct.
The production Connection: a socket-free handle to one multiplexed client of a MultiConnectionUDPServer.
A simple bidirectional UDP socket pair: one socket for sending to a fixed target address/port, and a separate socket bound to a local port for asynchronously receiving incoming datagrams on a background thread.