diff --git a/backend/vendor/github.com/enetx/g/bytes_compdecomp.go b/backend/vendor/github.com/enetx/g/bytes_compdecomp.go
new file mode 100644
index 00000000..93af3da8
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/bytes_compdecomp.go
@@ -0,0 +1,128 @@
+package g
+
+import (
+	"bytes"
+	"compress/flate"
+	"compress/gzip"
+	"compress/zlib"
+	"io"
+)
+
+type (
+	// A struct that wraps Bytes for compression.
+	bcompress struct{ bytes Bytes }
+
+	// A struct that wraps Bytes for decompression.
+	bdecompress struct{ bytes Bytes }
+)
+
+// Compress returns a bcompress struct wrapping the given Bytes.
+func (bs Bytes) Compress() bcompress { return bcompress{bs} }
+
+// Decompress returns a bdecompress struct wrapping the given Bytes.
+func (bs Bytes) Decompress() bdecompress { return bdecompress{bs} }
+
+// Zlib compresses the wrapped Bytes using the zlib compression algorithm and
+// returns the compressed data as Bytes.
+func (c bcompress) Zlib() Bytes {
+	buffer := new(bytes.Buffer)
+	writer := zlib.NewWriter(buffer)
+
+	_, _ = writer.Write(c.bytes)
+	_ = writer.Flush()
+	_ = writer.Close()
+
+	return buffer.Bytes()
+}
+
+// Zlib decompresses the wrapped Bytes using the zlib compression algorithm and
+// returns the decompressed data as a Result[Bytes].
+func (d bdecompress) Zlib() Result[Bytes] {
+	reader, err := zlib.NewReader(bytes.NewReader(d.bytes))
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	defer reader.Close()
+
+	buffer := new(bytes.Buffer)
+	if _, err := io.Copy(buffer, reader); err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(Bytes(buffer.Bytes()))
+}
+
+// Gzip compresses the wrapped Bytes using the gzip compression format and
+// returns the compressed data as Bytes.
+func (c bcompress) Gzip() Bytes {
+	buffer := new(bytes.Buffer)
+	writer := gzip.NewWriter(buffer)
+
+	_, _ = writer.Write(c.bytes)
+	_ = writer.Flush()
+	_ = writer.Close()
+
+	return buffer.Bytes()
+}
+
+// Gzip decompresses the wrapped Bytes using the gzip compression format and
+// returns the decompressed data as a Result[Bytes].
+func (d bdecompress) Gzip() Result[Bytes] {
+	reader, err := gzip.NewReader(bytes.NewReader(d.bytes))
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	defer reader.Close()
+
+	buffer := new(bytes.Buffer)
+	if _, err := io.Copy(buffer, reader); err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(Bytes(buffer.Bytes()))
+}
+
+// Flate compresses the wrapped Bytes using the flate (deflate) compression
+// algorithm and returns the compressed data as Bytes.
+// It accepts an optional compression level. If no level is provided, it
+// defaults to 7. The level is clamped to the valid flate range [-2, 9] to
+// avoid an invalid-level error that would otherwise return a nil writer and
+// panic on use.
+func (c bcompress) Flate(level ...int) Bytes {
+	buffer := new(bytes.Buffer)
+
+	l := 7
+	if len(level) != 0 {
+		l = level[0]
+	}
+
+	if l < flate.HuffmanOnly {
+		l = flate.HuffmanOnly
+	} else if l > flate.BestCompression {
+		l = flate.BestCompression
+	}
+
+	writer, _ := flate.NewWriter(buffer, l)
+
+	_, _ = writer.Write(c.bytes)
+	_ = writer.Flush()
+	_ = writer.Close()
+
+	return buffer.Bytes()
+}
+
+// Flate decompresses the wrapped Bytes using the flate (deflate) compression
+// algorithm and returns the decompressed data as a Result[Bytes].
+func (d bdecompress) Flate() Result[Bytes] {
+	reader := flate.NewReader(bytes.NewReader(d.bytes))
+	defer reader.Close()
+
+	buffer := new(bytes.Buffer)
+	if _, err := io.Copy(buffer, reader); err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(Bytes(buffer.Bytes()))
+}
diff --git a/backend/vendor/github.com/enetx/g/bytes_encdec.go b/backend/vendor/github.com/enetx/g/bytes_encdec.go
new file mode 100644
index 00000000..8df5f751
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/bytes_encdec.go
@@ -0,0 +1,344 @@
+package g
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"html"
+	"net/url"
+	"strconv"
+
+	json "encoding/json/v2"
+)
+
+type (
+	// A struct that wraps Bytes for encoding.
+	bencode struct{ bytes Bytes }
+
+	// A struct that wraps Bytes for decoding.
+	bdecode struct{ bytes Bytes }
+)
+
+// Encode returns a bencode struct wrapping the given Bytes.
+func (bs Bytes) Encode() bencode { return bencode{bs} }
+
+// Decode returns a bdecode struct wrapping the given Bytes.
+func (bs Bytes) Decode() bdecode { return bdecode{bs} }
+
+// Base64 encodes the wrapped Bytes using standard Base64 (with padding).
+func (e bencode) Base64() Bytes {
+	out := make(Bytes, base64.StdEncoding.EncodedLen(len(e.bytes)))
+	base64.StdEncoding.Encode(out, e.bytes)
+	return out
+}
+
+// Base64Raw encodes the wrapped Bytes using standard Base64 without padding.
+func (e bencode) Base64Raw() Bytes {
+	out := make(Bytes, base64.RawStdEncoding.EncodedLen(len(e.bytes)))
+	base64.RawStdEncoding.Encode(out, e.bytes)
+	return out
+}
+
+// Base64URL encodes the wrapped Bytes using URL-safe Base64 (with padding).
+func (e bencode) Base64URL() Bytes {
+	out := make(Bytes, base64.URLEncoding.EncodedLen(len(e.bytes)))
+	base64.URLEncoding.Encode(out, e.bytes)
+	return out
+}
+
+// Base64RawURL encodes the wrapped Bytes using URL-safe Base64 without padding.
+func (e bencode) Base64RawURL() Bytes {
+	out := make(Bytes, base64.RawURLEncoding.EncodedLen(len(e.bytes)))
+	base64.RawURLEncoding.Encode(out, e.bytes)
+	return out
+}
+
+// Base64 decodes the wrapped Bytes as standard Base64 (with padding) and returns Result[Bytes].
+func (d bdecode) Base64() Result[Bytes] {
+	out := make(Bytes, base64.StdEncoding.DecodedLen(len(d.bytes)))
+	n, err := base64.StdEncoding.Decode(out, d.bytes)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(out[:n])
+}
+
+// Base64Raw decodes the wrapped Bytes as standard Base64 without padding and returns Result[Bytes].
+func (d bdecode) Base64Raw() Result[Bytes] {
+	out := make(Bytes, base64.RawStdEncoding.DecodedLen(len(d.bytes)))
+	n, err := base64.RawStdEncoding.Decode(out, d.bytes)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(out[:n])
+}
+
+// Base64URL decodes the wrapped Bytes as URL-safe Base64 (with padding) and returns Result[Bytes].
+func (d bdecode) Base64URL() Result[Bytes] {
+	out := make(Bytes, base64.URLEncoding.DecodedLen(len(d.bytes)))
+	n, err := base64.URLEncoding.Decode(out, d.bytes)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(out[:n])
+}
+
+// Base64RawURL decodes the wrapped Bytes as URL-safe Base64 without padding and returns Result[Bytes].
+func (d bdecode) Base64RawURL() Result[Bytes] {
+	out := make(Bytes, base64.RawURLEncoding.DecodedLen(len(d.bytes)))
+	n, err := base64.RawURLEncoding.Decode(out, d.bytes)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(out[:n])
+}
+
+// Hex hex-encodes the wrapped Bytes and returns the result as Bytes.
+func (e bencode) Hex() Bytes {
+	out := make(Bytes, hex.EncodedLen(len(e.bytes)))
+	hex.Encode(out, e.bytes)
+	return out
+}
+
+// Hex hex-decodes the wrapped Bytes and returns the decoded result as Result[Bytes].
+func (d bdecode) Hex() Result[Bytes] {
+	out := make(Bytes, hex.DecodedLen(len(d.bytes)))
+	n, err := hex.Decode(out, d.bytes)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(out[:n])
+}
+
+// XOR encodes the wrapped Bytes using XOR cipher with the given key.
+//
+// Warning: a repeating-key XOR cipher is not a security primitive and provides
+// no real confidentiality. Use it only for lightweight obfuscation, never to
+// protect secrets.
+func (e bencode) XOR(key Bytes) Bytes {
+	if len(key) == 0 {
+		return e.bytes.Clone()
+	}
+
+	out := make(Bytes, len(e.bytes))
+	for i, b := range e.bytes {
+		out[i] = b ^ key[i%len(key)]
+	}
+
+	return out
+}
+
+// XOR decodes the wrapped Bytes using XOR cipher with the given key.
+func (d bdecode) XOR(key Bytes) Bytes { return d.bytes.Encode().XOR(key) }
+
+// Binary converts the wrapped Bytes to its binary representation as Bytes.
+func (e bencode) Binary() Bytes {
+	var b Builder
+	b.Grow(e.bytes.Len() * 8)
+
+	for _, c := range e.bytes {
+		for bit := 7; bit >= 0; bit-- {
+			b.WriteByte('0' + (c>>uint(bit))&1)
+		}
+	}
+
+	return b.String().Bytes()
+}
+
+// Binary converts the wrapped binary Bytes back to raw Bytes as Result[Bytes].
+func (d bdecode) Binary() Result[Bytes] {
+	if len(d.bytes)%8 != 0 {
+		return Err[Bytes](ErrInvalidBinaryLength)
+	}
+
+	out := make(Bytes, 0, len(d.bytes)/8)
+
+	for i := 0; i+8 <= len(d.bytes); i += 8 {
+		var b byte
+		for j := range 8 {
+			c := d.bytes[i+j]
+			if c != '0' && c != '1' {
+				return Err[Bytes](ErrInvalidBinaryDigit)
+			}
+			b = b<<1 | (c - '0')
+		}
+
+		out = append(out, b)
+	}
+
+	return Ok(out)
+}
+
+// JSON encodes the wrapped Bytes as a JSON string using encoding/json/v2 and
+// returns the result as Result[Bytes].
+//
+// The bytes are treated as text, mirroring String.Encode().JSON.
+//
+// v2 semantics: Bytes containing invalid UTF-8 yield Err — use Base64/Hex
+// encoding for arbitrary binary data.
+// Unlike encoding/json v1, the output does not HTML-escape '<', '>', '&' or the
+// line separators U+2028/U+2029 — they are emitted raw. Escape the output
+// yourself before embedding it in HTML or <script> contexts.
+func (e bencode) JSON() Result[Bytes] {
+	jsonData, err := json.Marshal(string(e.bytes))
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(Bytes(jsonData))
+}
+
+// JSON decodes the wrapped JSON string using encoding/json/v2 and returns the
+// result as Result[Bytes].
+//
+// v2 semantics: a JSON string containing invalid UTF-8 yields Err instead of
+// being decoded with U+FFFD replacements.
+func (d bdecode) JSON() Result[Bytes] {
+	var data String
+	err := json.Unmarshal(d.bytes, &data)
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(data.Bytes())
+}
+
+// URL encodes the wrapped Bytes, leaving the RFC 2396 reserved characters
+// (";/?:@&=+$,") unescaped and query-escaping the rest. If safe characters are
+// provided, they replace that default set and will not be encoded.
+//
+// Unlike String.Encode().URL, which matches safe characters by rune, matching
+// here is byte-wise; with ASCII-only safe sets the output is identical to the
+// String version for valid UTF-8 input. Non-UTF-8 bytes are percent-encoded
+// verbatim, so the encoding is lossless for arbitrary binary input.
+func (e bencode) URL(safe ...Bytes) Bytes {
+	reserved := Bytes(";/?:@&=+$,")
+	if len(safe) != 0 {
+		reserved = safe[0]
+	}
+
+	out := make(Bytes, 0, len(e.bytes))
+
+	for _, c := range e.bytes {
+		if reserved.IndexByte(c) != -1 {
+			out = append(out, c)
+			continue
+		}
+
+		out = appendQueryEscaped(out, c)
+	}
+
+	return out
+}
+
+const upperhex = "0123456789ABCDEF"
+
+// appendQueryEscaped appends c to dst using url.QueryEscape semantics:
+// unreserved bytes (A-Z, a-z, 0-9, '-', '_', '.', '~') pass through unchanged,
+// a space becomes '+', and every other byte is percent-encoded.
+func appendQueryEscaped(dst Bytes, c byte) Bytes {
+	switch {
+	case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z', '0' <= c && c <= '9',
+		c == '-', c == '_', c == '.', c == '~':
+		return append(dst, c)
+	case c == ' ':
+		return append(dst, '+')
+	default:
+		return append(dst, '%', upperhex[c>>4], upperhex[c&0xF])
+	}
+}
+
+// URL URL-decodes the wrapped Bytes and returns the decoded result as Result[Bytes].
+func (d bdecode) URL() Result[Bytes] {
+	result, err := url.QueryUnescape(string(d.bytes))
+	if err != nil {
+		return Err[Bytes](err)
+	}
+
+	return Ok(Bytes(result))
+}
+
+// HTML HTML-encodes the wrapped Bytes, escaping the characters <, >, &, ' and ".
+// All other bytes, including non-UTF-8 sequences, pass through unchanged.
+func (e bencode) HTML() Bytes { return Bytes(html.EscapeString(string(e.bytes))) }
+
+// HTML HTML-decodes the wrapped Bytes, unescaping HTML entities.
+// Bytes that are not part of an entity, including non-UTF-8 sequences, pass through unchanged.
+func (d bdecode) HTML() Bytes { return Bytes(html.UnescapeString(string(d.bytes))) }
+
+// Rot13 encodes the wrapped Bytes using the ROT13 cipher.
+//
+// The rotation is byte-wise over the ASCII letters A-Z and a-z; all other
+// bytes, including those of multibyte UTF-8 runes, are left untouched, so the
+// output is identical to String.Encode().Rot13 for valid UTF-8 input.
+//
+// WARNING: ROT13 is NOT a security primitive. It is a fixed letter-substitution
+// cipher with no key and is trivially reversible. Use it only for obfuscation.
+func (e bencode) Rot13() Bytes {
+	out := make(Bytes, len(e.bytes))
+
+	for i, c := range e.bytes {
+		switch {
+		case c >= 'A' && c <= 'Z':
+			out[i] = 'A' + (c-'A'+13)%26
+		case c >= 'a' && c <= 'z':
+			out[i] = 'a' + (c-'a'+13)%26
+		default:
+			out[i] = c
+		}
+	}
+
+	return out
+}
+
+// Rot13 decodes the wrapped Bytes using the ROT13 cipher.
+func (d bdecode) Rot13() Bytes { return d.bytes.Encode().Rot13() }
+
+// Octal returns the octal representation of the wrapped Bytes.
+//
+// Unlike String.Encode().Octal, which encodes Unicode code points, this
+// implementation is byte-wise: each byte is rendered as its octal value
+// (0-377), separated by spaces. The two representations match only for
+// ASCII input.
+func (e bencode) Octal() Bytes {
+	var tmp [3]byte
+
+	out := make(Bytes, 0, len(e.bytes)*4)
+
+	for i, c := range e.bytes {
+		if i != 0 {
+			out = append(out, ' ')
+		}
+
+		out = append(out, strconv.AppendUint(tmp[:0], uint64(c), 8)...)
+	}
+
+	return out
+}
+
+// Octal decodes the octal representation back to Bytes.
+// An empty input returns empty Bytes, mirroring bencode.Octal on empty input.
+// Each space-separated token must represent a valid byte value in the octal
+// range [0, 377]; anything else yields an error.
+func (d bdecode) Octal() Result[Bytes] {
+	if d.bytes.IsEmpty() {
+		return Ok(Bytes(""))
+	}
+
+	out := make(Bytes, 0, (len(d.bytes)+1)/2)
+
+	for _, v := range d.bytes.Split(Bytes(" ")) {
+		n, err := strconv.ParseUint(v.StringUnsafe().Std(), 8, 8)
+		if err != nil {
+			return Err[Bytes](err)
+		}
+
+		out = append(out, byte(n))
+	}
+
+	return Ok(out)
+}
diff --git a/backend/vendor/github.com/enetx/g/bytes_text.go b/backend/vendor/github.com/enetx/g/bytes_text.go
new file mode 100644
index 00000000..feb7c674
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/bytes_text.go
@@ -0,0 +1,521 @@
+package g
+
+import "strings"
+
+// IsASCII checks if all bytes in the Bytes are ASCII bytes.
+func (bs Bytes) IsASCII() bool {
+	for i := range bs {
+		if bs[i] >= 0x80 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// IsDigit checks if the Bytes is non-empty and all bytes are ASCII digits ('0'-'9').
+// Unlike String.IsDigit, which is rune-aware and accepts Unicode digits, this method
+// operates byte-wise and only recognizes ASCII digits.
+func (bs Bytes) IsDigit() bool {
+	if bs.IsEmpty() {
+		return false
+	}
+
+	for i := range bs {
+		if bs[i] < '0' || bs[i] > '9' {
+			return false
+		}
+	}
+
+	return true
+}
+
+// ReplaceMulti performs multiple replacements within the Bytes.
+//
+// The replacements are provided as pairs of old and new Bytes, in the same
+// order as in String.ReplaceMulti. Replacements are performed in a single pass:
+// at each position the first matching pattern in argument order wins, and
+// matches do not overlap. The number of arguments must be even; otherwise the
+// method panics.
+//
+// Both this method and String.ReplaceMulti match patterns as raw byte
+// sequences, so the two versions behave identically on the same data.
+//
+// Parameters:
+//
+// - oldnew ...Bytes: Pairs of Bytes to be replaced. Specify as many pairs as needed.
+//
+// Returns:
+//
+// - Bytes: A new Bytes with replacements applied. The receiver is not modified.
+//
+// Example usage:
+//
+//	original := g.Bytes("Hello, world! This is a test.")
+//	replaced := original.ReplaceMulti(
+//	    g.Bytes("Hello"), g.Bytes("Greetings"),
+//	    g.Bytes("world"), g.Bytes("universe"),
+//	    g.Bytes("test"), g.Bytes("example"),
+//	)
+//	// replaced contains "Greetings, universe! This is a example."
+func (bs Bytes) ReplaceMulti(oldnew ...Bytes) Bytes {
+	pairs := make([]string, len(oldnew))
+	for i, b := range oldnew {
+		pairs[i] = string(b)
+	}
+
+	return Bytes(strings.NewReplacer(pairs...).Replace(bs.StringUnsafe().Std()))
+}
+
+// Remove removes all occurrences of the specified patterns from the Bytes.
+//
+// Both this method and String.Remove match patterns as raw byte sequences,
+// so the two versions behave identically on the same data.
+//
+// Parameters:
+//
+// - patterns ...Bytes: Patterns to be removed from the Bytes. Specify as many patterns as needed.
+//
+// Returns:
+//
+//   - Bytes: A new Bytes with all specified patterns removed. The receiver is
+//     not modified. If no patterns are given, the original Bytes is returned.
+//
+// Example usage:
+//
+//	original := g.Bytes("Hello, world! This is a test.")
+//	modified := original.Remove(
+//	    g.Bytes("Hello"),
+//	    g.Bytes("test"),
+//	)
+//	// modified contains ", world! This is a ."
+func (bs Bytes) Remove(patterns ...Bytes) Bytes {
+	if len(patterns) == 0 {
+		return bs
+	}
+
+	pairs := make([]string, len(patterns)*2)
+	for i, pattern := range patterns {
+		pairs[i*2] = string(pattern)
+		pairs[i*2+1] = ""
+	}
+
+	return Bytes(strings.NewReplacer(pairs...).Replace(bs.StringUnsafe().Std()))
+}
+
+// ReplaceNth returns a new Bytes with the nth occurrence of oldB
+// replaced with newB. If there aren't enough occurrences of oldB, the
+// original Bytes is returned. If n is less than -1, the original Bytes
+// is also returned. If n is -1, the last occurrence of oldB is replaced with newB.
+//
+// Both this method and String.ReplaceNth match patterns as raw byte sequences,
+// so the two versions behave identically on the same data.
+//
+// Returns:
+//
+//   - Bytes: A new Bytes with the nth occurrence of oldB replaced with newB.
+//     The receiver is not modified.
+//
+// Example usage:
+//
+//	bs := g.Bytes("The quick brown dog jumped over the lazy dog.")
+//	result := bs.ReplaceNth(g.Bytes("dog"), g.Bytes("fox"), 2)
+//	fmt.Println(result)
+//
+// Output: "The quick brown dog jumped over the lazy fox.".
+func (bs Bytes) ReplaceNth(oldB, newB Bytes, n Int) Bytes {
+	if n < -1 || oldB.IsEmpty() {
+		return bs
+	}
+
+	count, i := Int(0), Int(0)
+
+	for {
+		pos := bs[i:].Index(oldB)
+		if pos == -1 {
+			break
+		}
+
+		pos += i
+		count++
+
+		if count == n || (n == -1 && bs[pos+oldB.Len():].Index(oldB) == -1) {
+			result := make(Bytes, 0, bs.Len()+newB.Len()-oldB.Len())
+			result = append(result, bs[:pos]...)
+			result = append(result, newB...)
+			result = append(result, bs[pos+oldB.Len():]...)
+
+			return result
+		}
+
+		i = pos + oldB.Len()
+	}
+
+	return bs
+}
+
+// Chunks splits the Bytes into chunks of the specified size.
+//
+// This function iterates through the Bytes, creating chunks of the specified size.
+// If size is less than or equal to 0 or the Bytes is empty, it returns nil.
+// If size is greater than or equal to the length of the Bytes, it returns the
+// original Bytes as the only chunk.
+//
+// Unlike String.Chunks, which counts runes, the chunk size is measured in
+// bytes, so multibyte UTF-8 sequences may be split across chunks.
+//
+// The returned chunks are subslices sharing memory with the original Bytes,
+// as with Split; clone them if independent copies are needed.
+//
+// Parameters:
+//
+// - size (Int): The size of the chunks to split the Bytes into.
+//
+// Returns:
+//
+// - []Bytes: the chunks of the specified size.
+//
+// Example usage:
+//
+//	bs := g.Bytes("Hello, World!")
+//	chunks := bs.Chunks(4)
+//
+// chunks contains {"Hell", "o, W", "orld", "!"}.
+func (bs Bytes) Chunks(size Int) []Bytes {
+	if size.Lte(0) || bs.IsEmpty() {
+		return nil
+	}
+
+	n := size.Std()
+	l := len(bs)
+
+	if n >= l {
+		return []Bytes{bs}
+	}
+
+	result := make([]Bytes, 0, (l+n-1)/n)
+	for i := 0; i < l; i += n {
+		result = append(result, bs[i:min(i+n, l)])
+	}
+
+	return result
+}
+
+func (bs Bytes) Cut(start, end Bytes, rmtags ...bool) (Bytes, Bytes) {
+	if start.IsEmpty() || end.IsEmpty() {
+		return bs, Bytes("")
+	}
+
+	startIndex := bs.Index(start)
+	if startIndex == -1 {
+		return bs, Bytes("")
+	}
+
+	startEnd := startIndex + start.Len()
+	endIndex := bs[startEnd:].Index(end)
+	if endIndex == -1 {
+		return bs, Bytes("")
+	}
+
+	cut := bs[startEnd : startEnd+endIndex]
+
+	if len(rmtags) == 0 || !rmtags[0] {
+		return bs, cut
+	}
+
+	tail := startEnd + endIndex + end.Len()
+
+	remainder := make(Bytes, 0, startIndex+(bs.Len()-tail))
+	remainder = append(remainder, bs[:startIndex]...)
+	remainder = append(remainder, bs[tail:]...)
+
+	return remainder, cut
+}
+
+// SubBytes extracts a subrange from the Bytes starting at the 'start' index and ending before the 'end' index.
+// The function also supports an optional 'step' parameter to define the increment between indices in the result.
+// If 'start' or 'end' index is negative, they represent positions relative to the end of the Bytes:
+// - A negative 'start' index indicates the position from the end of the Bytes, moving backward.
+// - A negative 'end' index indicates the position from the end of the Bytes.
+// The function ensures that indices are adjusted to fall within the valid range of the Bytes' length.
+// Out-of-bounds indices are clamped to the Bytes' bounds instead of panicking;
+// if 'start' exceeds 'end' (for a positive step) the result is an empty Bytes.
+//
+// Unlike String.SubString, which indexes runes, all indices and the step are
+// measured in bytes, so a boundary that falls inside a multibyte UTF-8 sequence
+// splits the rune and the result may not be valid UTF-8. A negative step
+// reverses bytes, not runes.
+//
+// The result is a newly allocated Bytes; the receiver is not modified.
+func (bs Bytes) SubBytes(start, end Int, step ...Int) Bytes {
+	n := bs.Len()
+
+	clamp := func(i Int) Int {
+		if i < 0 {
+			i += n
+		}
+
+		if i < 0 {
+			return 0
+		}
+
+		if i > n {
+			return n
+		}
+
+		return i
+	}
+
+	start, end = clamp(start), clamp(end)
+
+	st := Int(1)
+	if len(step) > 0 {
+		st = step[0]
+	}
+
+	// For a negative step the iteration starts AT start and moves down,
+	// so a start clamped to n must begin at the last element.
+	if st < 0 && start == n {
+		start--
+	}
+
+	if st == 1 {
+		if start >= end {
+			return Bytes{}
+		}
+
+		return Bytes(append([]byte(nil), bs[start:end]...))
+	}
+
+	if (start >= end && st > 0) || (start <= end && st < 0) || st == 0 {
+		return Bytes{}
+	}
+
+	var out []byte
+
+	if st > 0 {
+		for i := start; i < end; i += st {
+			out = append(out, bs[i])
+		}
+	} else {
+		for i := start; i > end; i += st {
+			out = append(out, bs[i])
+		}
+	}
+
+	return Bytes(out)
+}
+
+// Similarity calculates the similarity between two Bytes using the
+// Levenshtein distance algorithm and returns the similarity percentage as a Float.
+//
+// The function compares two Bytes using the Levenshtein distance,
+// which measures the difference between two sequences by counting the number
+// of single-byte edits required to change one sequence into the other.
+// The similarity is then calculated by normalizing the distance by the maximum
+// length of the two input Bytes.
+//
+// Unlike String.Similarity, which compares runes, this method operates byte-wise,
+// so multibyte UTF-8 sequences are compared byte by byte.
+//
+// Parameters:
+//
+// - obs (Bytes): The Bytes to compare with bs.
+//
+// Returns:
+//
+// - Float: The similarity percentage between the two Bytes as a value between 0 and 100.
+//
+// Example usage:
+//
+//	b1 := g.Bytes("kitten")
+//	b2 := g.Bytes("sitting")
+//	similarity := b1.Similarity(b2) // 57.14285714285714
+func (bs Bytes) Similarity(obs Bytes) Float {
+	if bs.Eq(obs) {
+		return 100
+	}
+
+	if bs.IsEmpty() || obs.IsEmpty() {
+		return 0
+	}
+
+	s1, s2 := bs, obs
+
+	n1, n2 := len(s1), len(s2)
+
+	if n1 > n2 {
+		s1, s2, n1, n2 = s2, s1, n2, n1
+	}
+
+	distance := make([]int, n1+1)
+
+	for i, b2 := range s2 {
+		prev := i + 1
+
+		for j, b1 := range s1 {
+			current := distance[j]
+			if b2 != b1 {
+				current = min(distance[j]+1, min(prev+1, distance[j+1]+1))
+			}
+
+			distance[j], prev = prev, current
+		}
+
+		distance[n1] = prev
+	}
+
+	return Float(1-float64(distance[n1])/float64(max(n1, n2))) * 100
+}
+
+// Truncate shortens the Bytes to the specified maximum length. If the Bytes exceeds the
+// specified length, it is truncated, and an ellipsis ("...") is appended to indicate the truncation.
+//
+// If the length of the Bytes is less than or equal to the specified maximum length, the
+// original Bytes is returned unchanged.
+//
+// Unlike String.Truncate, which is rune-aware, this method truncates based on the number
+// of bytes, so multibyte UTF-8 sequences may be split.
+//
+// Parameters:
+//   - max: The maximum number of bytes allowed in the resulting Bytes.
+//
+// Returns:
+//   - A new Bytes truncated to the specified maximum length with "..." appended
+//     if truncation occurs. Otherwise, returns the original Bytes.
+//
+// Example usage:
+//
+//	bs := g.Bytes("Hello, World!")
+//	result := bs.Truncate(5)
+//	// result: "Hello..."
+//
+//	bs2 := g.Bytes("Short")
+//	result2 := bs2.Truncate(10)
+//	// result2: "Short"
+func (bs Bytes) Truncate(max Int) Bytes {
+	if max.IsNegative() {
+		return bs
+	}
+
+	if bs.Len() <= max {
+		return bs
+	}
+
+	return append(bs[:max:max], "..."...)
+}
+
+// LeftJustify justifies the Bytes to the left by adding padding to the right, up to the
+// specified length. If the length of the Bytes is already greater than or equal to the specified
+// length, or the pad is empty, the original Bytes is returned.
+//
+// The padding Bytes is repeated as necessary to fill the remaining length.
+// The padding is added to the right of the Bytes.
+//
+// Unlike String.LeftJustify, which counts runes, both length and padding are
+// measured in bytes.
+//
+// Parameters:
+//   - length: The desired length of the resulting justified Bytes.
+//   - pad: The Bytes used as padding.
+//
+// Example usage:
+//
+//	bs := g.Bytes("Hello")
+//	result := bs.LeftJustify(10, g.Bytes("..."))
+//	// result: "Hello....."
+func (bs Bytes) LeftJustify(length Int, pad Bytes) Bytes {
+	if bs.Len() >= length || pad.IsEmpty() {
+		return bs
+	}
+
+	buf := make(Bytes, 0, length)
+	buf = append(buf, bs...)
+	buf = appendPadding(buf, pad, length-bs.Len())
+
+	return buf
+}
+
+// RightJustify justifies the Bytes to the right by adding padding to the left, up to the
+// specified length. If the length of the Bytes is already greater than or equal to the specified
+// length, or the pad is empty, the original Bytes is returned.
+//
+// The padding Bytes is repeated as necessary to fill the remaining length.
+// The padding is added to the left of the Bytes.
+//
+// Unlike String.RightJustify, which counts runes, both length and padding are
+// measured in bytes.
+//
+// Parameters:
+//   - length: The desired length of the resulting justified Bytes.
+//   - pad: The Bytes used as padding.
+//
+// Example usage:
+//
+//	bs := g.Bytes("Hello")
+//	result := bs.RightJustify(10, g.Bytes("..."))
+//	// result: ".....Hello"
+func (bs Bytes) RightJustify(length Int, pad Bytes) Bytes {
+	if bs.Len() >= length || pad.IsEmpty() {
+		return bs
+	}
+
+	buf := make(Bytes, 0, length)
+	buf = appendPadding(buf, pad, length-bs.Len())
+	buf = append(buf, bs...)
+
+	return buf
+}
+
+// Center justifies the Bytes by adding padding on both sides, up to the specified length.
+// If the length of the Bytes is already greater than or equal to the specified length, or the
+// pad is empty, the original Bytes is returned.
+//
+// The padding Bytes is repeated as necessary to evenly distribute the remaining length on both
+// sides.
+// The padding is added to the left and right of the Bytes.
+//
+// Unlike String.Center, which counts runes, both length and padding are
+// measured in bytes.
+//
+// Parameters:
+//   - length: The desired length of the resulting justified Bytes.
+//   - pad: The Bytes used as padding.
+//
+// Example usage:
+//
+//	bs := g.Bytes("Hello")
+//	result := bs.Center(10, g.Bytes("..."))
+//	// result: "..Hello..."
+func (bs Bytes) Center(length Int, pad Bytes) Bytes {
+	slen := bs.Len()
+	if slen >= length || pad.IsEmpty() {
+		return bs
+	}
+
+	remains := length - slen
+
+	buf := make(Bytes, 0, length)
+	buf = appendPadding(buf, pad, remains/2)
+	buf = append(buf, bs...)
+	buf = appendPadding(buf, pad, (remains+1)/2)
+
+	return buf
+}
+
+// appendPadding appends the padding Bytes to buf to fill the remaining length.
+// It repeats the padding Bytes as necessary and appends any remaining bytes from
+// the padding Bytes.
+func appendPadding(buf, pad Bytes, remains Int) Bytes {
+	padlen := pad.Len()
+
+	for range remains / padlen {
+		buf = append(buf, pad...)
+	}
+
+	if rem := remains % padlen; rem != 0 {
+		buf = append(buf, pad[:rem]...)
+	}
+
+	return buf
+}
diff --git a/backend/vendor/github.com/enetx/g/doc.go b/backend/vendor/github.com/enetx/g/doc.go
new file mode 100644
index 00000000..28bb5f8b
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/doc.go
@@ -0,0 +1,77 @@
+// Package g provides an ergonomic standard library extension for Go:
+// monadic error handling, rich generic containers, lazy iterators with
+// type-changing generic methods (Go 1.27+), and ergonomic wrappers for
+// primitive types and the filesystem.
+//
+// # Monads
+//
+// [Option] represents an optional value (Some/None) and [Result] represents
+// success or failure (Ok/Err). Both offer chainable combinators — Map, Then,
+// UnwrapOr, MapOr, Inspect and friends — so error and nil handling become
+// expressions instead of if-ladders.
+//
+// # Containers
+//
+//   - [Slice]: an extended slice with 90+ methods.
+//   - [Map]: a map with ergonomic accessors and entry API.
+//   - [MapOrd]: an insertion-ordered map.
+//   - [MapSafe]: a concurrency-safe map.
+//   - [Set]: a hash set with algebraic operations (union, intersection, ...).
+//   - [Deque]: a double-ended queue backed by a ring buffer.
+//   - [Heap]: a binary min/max heap driven by a comparison function.
+//
+// # Iterators
+//
+// Every container exposes an Iter method returning lazy sequences (Heap
+// additionally offers a draining IntoIter) —
+// [Seq] for values, [Seq2] for key-value pairs, [SeqSlices] for grouped
+// windows/chunks and [SeqResult] for fallible streams — built on g's own
+// dependency-free iterator core. With Go 1.27 generic methods, transformations
+// can change the element type mid-chain:
+//
+//	g.SliceOf(1, 2, 3).Iter().Map[string](strconv.Itoa).Collect().Slice() // Slice[string]
+//
+// Iterators are lazy: nothing is computed until a consumer (Collect, ForEach,
+// Fold, ...) runs the chain.
+//
+// # Primitive wrappers
+//
+// [String], [Int], [Float] and [Bytes] wrap the built-in types with fluent
+// methods, including conversion pipelines via Encode/Decode (Base64, Hex,
+// Octal, Binary, JSON, ...), Compress/Decompress (gzip, zlib, flate)
+// and Hash (MD5, SHA1, SHA256, SHA512).
+//
+// # Subpackages
+//
+//   - fs: File and Dir — chainable, Result-based file and directory
+//     operations, including lazy line/chunk iterators over file contents.
+//   - rx: compiled regular expressions with a compile-once, rich matching API.
+//   - rand: all randomness (numbers, choices, samples, shuffles, strings)
+//     in one place.
+//   - pool: a generic goroutine pool with limits, rate limiting and streaming.
+//   - cmp: ordering primitives (cmp.Ordering, cmp.Cmp) used by sorts and heaps.
+//   - f: predicate combinators for filters (f.Eq, f.Gt, f.Contains, ...).
+//   - ref: pointer helpers (ref.Of).
+//   - constraints: generic type constraints shared across the library.
+//   - dbg: debugging helpers that print expressions with source locations.
+//
+// # Panics
+//
+// The library reports failures through [Result] and [Option]; panics are
+// reserved for programmer errors. Only two families of API panic:
+//
+//   - the Unwrap/Expect family on [Option] and [Result] (Unwrap, UnwrapErr,
+//     Expect) when called on the wrong variant;
+//   - documented index-based operations (e.g. Slice.Swap/Insert/Replace/SubSlice,
+//     Deque.Insert/Swap) when given out-of-range indices, and constructors with
+//     documented preconditions (e.g. NewHeap with a nil comparison function).
+//
+// Everything else returns Option/Result instead of panicking.
+//
+// # Security
+//
+// [Format] placeholders resolve data only: each dot-segment selects a map
+// key, a MapOrd key, a slice/array index or a struct field — placeholders
+// cannot invoke methods. Note that an untrusted template string can still
+// choose which of the supplied argument data is printed.
+package g
diff --git a/backend/vendor/github.com/enetx/g/entry.go b/backend/vendor/github.com/enetx/g/entry.go
new file mode 100644
index 00000000..e0923002
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/entry.go
@@ -0,0 +1,178 @@
+package g
+
+// Entry is a sealed interface representing a view into a single Map entry.
+//
+// Entry provides an API for in-place manipulation of map entries, enabling
+// efficient "get or insert" patterns without redundant lookups.
+//
+// The interface is sealed to ensure type safety; implementations are limited
+// to [OccupiedEntry] (when the key exists) and [VacantEntry] (when the key
+// is absent). Use a type switch to access type-specific methods like Get,
+// Insert, or Remove.
+//
+// Common usage patterns:
+//
+//	// Increment existing value or insert default
+//	m.Entry("counter").AndModify(func(v *int) { *v++ }).OrInsert(1)
+//
+//	// Insert only if absent
+//	m.Entry("key").OrInsert(defaultValue)
+//
+//	// Insert with lazy initialization
+//	m.Entry("key").OrInsertWith(func() V { return expensiveComputation() })
+//
+//	// Type switch for fine-grained control
+//	switch e := m.Entry("key").(type) {
+//	case OccupiedEntry[string, int]:
+//	    fmt.Println("exists:", e.Get())
+//	case VacantEntry[string, int]:
+//	    e.Insert(42)
+//	}
+//
+// An Entry is a short-lived view of the key state observed by Map.Entry.
+// Do not retain it across external insertion or removal of the same key;
+// obtain a fresh Entry after structurally changing that key.
+type Entry[K comparable, V any] interface {
+	sealed()
+	Key() K
+	OrInsert(value V) V
+	OrInsertWith(fn func() V) V
+	OrInsertWithKey(fn func(K) V) V
+	OrDefault() V
+	AndModify(fn func(*V)) Entry[K, V]
+}
+
+// OccupiedEntry represents a view into a map entry that is known to be present.
+//
+// It is typically obtained from Map.Entry(key) when the key already exists.
+// OccupiedEntry allows inspecting, modifying, replacing, or removing the value
+// associated with the key without performing additional map lookups.
+type OccupiedEntry[K comparable, V any] struct {
+	m   Map[K, V]
+	key K
+}
+
+// sealed prevents external implementations of the Entry interface.
+func (OccupiedEntry[K, V]) sealed() {}
+
+// Key returns the key of this occupied entry.
+func (e OccupiedEntry[K, V]) Key() K { return e.key }
+
+// Get returns the current value associated with the key.
+//
+// The value is returned by copy, consistent with Go map semantics.
+func (e OccupiedEntry[K, V]) Get() V { return e.m[e.key] }
+
+// Insert replaces the value in the map with the provided one
+// and returns the previous value.
+//
+// The key remains present in the map.
+func (e OccupiedEntry[K, V]) Insert(value V) V {
+	old := e.m[e.key]
+	e.m[e.key] = value
+	return old
+}
+
+// Remove removes the entry from the map and returns the previously stored value.
+//
+// After this call, the key is no longer present in the map.
+func (e OccupiedEntry[K, V]) Remove() V {
+	v := e.m[e.key]
+	delete(e.m, e.key)
+	return v
+}
+
+// OrInsert returns the existing value without modifying the map.
+//
+// For OccupiedEntry, this is equivalent to Get since the key already exists.
+func (e OccupiedEntry[K, V]) OrInsert(value V) V { return e.Get() }
+
+// OrInsertWith returns the existing value without invoking the function.
+//
+// For OccupiedEntry, the function is never called since the key already exists.
+func (e OccupiedEntry[K, V]) OrInsertWith(fn func() V) V { return e.Get() }
+
+// OrInsertWithKey returns the existing value without invoking the function.
+//
+// For OccupiedEntry, the function is never called since the key already exists.
+func (e OccupiedEntry[K, V]) OrInsertWithKey(fn func(K) V) V { return e.Get() }
+
+// OrDefault returns the existing value.
+//
+// For OccupiedEntry, this is equivalent to Get since the key already exists.
+func (e OccupiedEntry[K, V]) OrDefault() V { return e.Get() }
+
+// AndModify applies the provided function to the value stored in the map
+// and returns the entry for method chaining.
+//
+// The function receives a pointer to a copy of the value; after modification,
+// the updated value is written back to the map.
+// The entry must not be used after the same key is externally removed or replaced.
+//
+// Example:
+//
+//	m.Entry("count").AndModify(func(v *int) { *v++ }).OrInsert(1)
+func (e OccupiedEntry[K, V]) AndModify(fn func(*V)) Entry[K, V] {
+	v := e.m[e.key]
+	fn(&v)
+	e.m[e.key] = v
+	return e
+}
+
+// VacantEntry represents a view into a map entry that is known to be absent.
+//
+// It is typically obtained from Map.Entry(key) when the key does not exist.
+// VacantEntry allows inserting a value for the key in a controlled manner.
+type VacantEntry[K comparable, V any] struct {
+	m   Map[K, V]
+	key K
+}
+
+// sealed prevents external implementations of the Entry interface.
+func (VacantEntry[K, V]) sealed() {}
+
+// Key returns the key that would be used for insertion.
+func (e VacantEntry[K, V]) Key() K { return e.key }
+
+// Insert inserts the provided value into the map and returns it.
+//
+// After this call, the key is present in the map with the given value.
+func (e VacantEntry[K, V]) Insert(value V) V {
+	e.m[e.key] = value
+	return value
+}
+
+// OrInsert inserts the provided value and returns it.
+//
+// This is the primary method for inserting values via VacantEntry.
+func (e VacantEntry[K, V]) OrInsert(value V) V { return e.Insert(value) }
+
+// OrInsertWith inserts the value returned by the function and returns it.
+//
+// The function is guaranteed to be called exactly once.
+// Use this when computing the default value is expensive.
+func (e VacantEntry[K, V]) OrInsertWith(fn func() V) V { return e.Insert(fn()) }
+
+// OrInsertWithKey inserts the value returned by the function and returns it.
+//
+// The function receives the entry key and is guaranteed to be called exactly once.
+// Use this when the default value depends on the key.
+func (e VacantEntry[K, V]) OrInsertWithKey(fn func(K) V) V {
+	return e.Insert(fn(e.key))
+}
+
+// OrDefault inserts the zero value of V into the map and returns it.
+//
+// This is useful for types where the zero value is a valid initial state,
+// such as numeric types (0), slices (nil), or structs with zero defaults.
+func (e VacantEntry[K, V]) OrDefault() V {
+	var zero V
+	return e.Insert(zero)
+}
+
+// AndModify does nothing for VacantEntry and returns the entry unchanged.
+//
+// Since there is no existing value to modify, the function is not called.
+// This allows fluent chaining like Entry(k).AndModify(f).OrInsert(v)
+// to work correctly regardless of whether the key exists.
+func (e VacantEntry[K, V]) AndModify(fn func(*V)) Entry[K, V] { return e }
diff --git a/backend/vendor/github.com/enetx/g/entry_ordered.go b/backend/vendor/github.com/enetx/g/entry_ordered.go
new file mode 100644
index 00000000..0643c5b9
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/entry_ordered.go
@@ -0,0 +1,184 @@
+package g
+
+import "slices"
+
+// OrdEntry is a sealed interface representing a view into a single MapOrd entry.
+//
+// OrdEntry provides an API for in-place manipulation of ordered map entries,
+// enabling efficient "get or insert" patterns without redundant lookups while
+// preserving insertion order.
+//
+// The interface is sealed to ensure type safety; implementations are limited
+// to [OccupiedOrdEntry] (when the key exists) and [VacantOrdEntry] (when the
+// key is absent). Use a type switch to access type-specific methods like Get,
+// Insert, or Remove.
+//
+// Common usage patterns:
+//
+//	// Increment existing value or insert default
+//	mo.Entry("counter").AndModify(func(v *int) { *v++ }).OrInsert(1)
+//
+//	// Insert only if absent (appends to end)
+//	mo.Entry("key").OrInsert(defaultValue)
+//
+//	// Type switch for fine-grained control
+//	switch e := mo.Entry("key").(type) {
+//	case OccupiedOrdEntry[string, int]:
+//	    fmt.Println("exists:", e.Get())
+//	case VacantOrdEntry[string, int]:
+//	    e.Insert(42)
+//	}
+type OrdEntry[K comparable, V any] interface {
+	sealed()
+	Key() K
+	OrInsert(value V) V
+	OrInsertWith(fn func() V) V
+	OrInsertWithKey(fn func(K) V) V
+	OrDefault() V
+	AndModify(fn func(*V)) OrdEntry[K, V]
+}
+
+// OccupiedOrdEntry represents a view into an ordered map entry that is known
+// to be present.
+//
+// It is typically obtained from MapOrd.Entry(key) when the key already exists.
+// OccupiedOrdEntry provides access to the key and the value stored in the
+// underlying ordered slice, allowing inspection, modification, replacement, or
+// removal. The key's position is resolved once, when the entry is created,
+// and reused directly by every operation. The entry is therefore only valid
+// as long as the MapOrd is not structurally mutated (Remove, SortBy, Clear)
+// between creation and use; obtain a fresh entry after such mutations.
+type OccupiedOrdEntry[K comparable, V any] struct {
+	mo  *MapOrd[K, V]
+	key K
+	idx int
+}
+
+// sealed prevents external implementations of the OrdEntry interface.
+func (OccupiedOrdEntry[K, V]) sealed() {}
+
+// Key returns the key of this occupied entry.
+func (e OccupiedOrdEntry[K, V]) Key() K { return e.key }
+
+// Get returns the current value associated with the key.
+//
+// The value is returned by copy.
+func (e OccupiedOrdEntry[K, V]) Get() V { return (*e.mo)[e.idx].Value }
+
+// Insert replaces the value at the entry's position with the provided value
+// and returns the previously stored value.
+//
+// The position of the entry in the ordered map is preserved.
+func (e OccupiedOrdEntry[K, V]) Insert(value V) V {
+	old := (*e.mo)[e.idx].Value
+	(*e.mo)[e.idx].Value = value
+
+	return old
+}
+
+// Remove removes the entry from the ordered map and returns the previously
+// stored value.
+//
+// This operation preserves the relative order of the remaining entries.
+// After this call, the key is no longer present in the map and the entry
+// must not be used again.
+func (e OccupiedOrdEntry[K, V]) Remove() V {
+	v := (*e.mo)[e.idx].Value
+	*e.mo = slices.Delete(*e.mo, e.idx, e.idx+1)
+
+	return v
+}
+
+// OrInsert returns the existing value without modifying the map.
+//
+// For OccupiedOrdEntry, this is equivalent to Get since the key already exists.
+func (e OccupiedOrdEntry[K, V]) OrInsert(value V) V { return e.Get() }
+
+// OrInsertWith returns the existing value without invoking the function.
+//
+// For OccupiedOrdEntry, the function is never called since the key already exists.
+func (e OccupiedOrdEntry[K, V]) OrInsertWith(fn func() V) V { return e.Get() }
+
+// OrInsertWithKey returns the existing value without invoking the function.
+//
+// For OccupiedOrdEntry, the function is never called since the key already exists.
+func (e OccupiedOrdEntry[K, V]) OrInsertWithKey(fn func(K) V) V { return e.Get() }
+
+// OrDefault returns the existing value.
+//
+// For OccupiedOrdEntry, this is equivalent to Get since the key already exists.
+func (e OccupiedOrdEntry[K, V]) OrDefault() V { return e.Get() }
+
+// AndModify applies the provided function to the value stored at the entry's
+// position and returns the entry for method chaining.
+//
+// The function receives a pointer to the actual value stored in the ordered map,
+// allowing in-place modification.
+//
+// Example:
+//
+//	m.Entry("count").AndModify(func(v *int) { *v++ }).OrInsert(1)
+func (e OccupiedOrdEntry[K, V]) AndModify(fn func(*V)) OrdEntry[K, V] {
+	fn(&(*e.mo)[e.idx].Value)
+	return e
+}
+
+// VacantOrdEntry represents a view into an ordered map entry that is known
+// to be absent.
+//
+// It is typically obtained from MapOrd.Entry(key) when the key does not exist.
+// VacantOrdEntry allows inserting a new key-value pair into the ordered map.
+type VacantOrdEntry[K comparable, V any] struct {
+	mo  *MapOrd[K, V]
+	key K
+}
+
+// sealed prevents external implementations of the OrdEntry interface.
+func (VacantOrdEntry[K, V]) sealed() {}
+
+// Key returns the key that would be used for insertion.
+func (e VacantOrdEntry[K, V]) Key() K { return e.key }
+
+// Insert inserts a new key-value pair into the ordered map and returns the value.
+//
+// The new entry is appended to the end of the ordered map.
+// After this call, the key is present in the map with the given value.
+func (e VacantOrdEntry[K, V]) Insert(value V) V {
+	*e.mo = append(*e.mo, Pair[K, V]{Key: e.key, Value: value})
+	return value
+}
+
+// OrInsert inserts the provided value and returns it.
+//
+// This is the primary method for inserting values via VacantOrdEntry.
+func (e VacantOrdEntry[K, V]) OrInsert(value V) V { return e.Insert(value) }
+
+// OrInsertWith inserts the value returned by the function and returns it.
+//
+// The function is guaranteed to be called exactly once.
+// Use this when computing the default value is expensive.
+func (e VacantOrdEntry[K, V]) OrInsertWith(fn func() V) V { return e.Insert(fn()) }
+
+// OrInsertWithKey inserts the value returned by the function and returns it.
+//
+// The function receives the entry key and is guaranteed to be called exactly once.
+// Use this when the default value depends on the key.
+func (e VacantOrdEntry[K, V]) OrInsertWithKey(fn func(K) V) V {
+	return e.Insert(fn(e.key))
+}
+
+// OrDefault inserts the zero value of V into the ordered map and returns it.
+//
+// This is useful for types where the zero value is a valid initial state,
+// such as numeric types (0), slices (nil), or structs with zero defaults.
+func (e VacantOrdEntry[K, V]) OrDefault() V {
+	var zero V
+	return e.Insert(zero)
+}
+
+// AndModify does nothing for VacantOrdEntry and returns the entry unchanged.
+//
+// Since there is no existing value to modify, the function is not called.
+// This allows fluent chaining like Entry(k).AndModify(f).OrInsert(v)
+// to work correctly regardless of whether the key exists.
+func (e VacantOrdEntry[K, V]) AndModify(fn func(*V)) OrdEntry[K, V] { return e }
diff --git a/backend/vendor/github.com/enetx/g/entry_safe.go b/backend/vendor/github.com/enetx/g/entry_safe.go
new file mode 100644
index 00000000..dfdc7628
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/entry_safe.go
@@ -0,0 +1,335 @@
+package g
+
+// SafeEntry is a sealed interface representing a view into a single MapSafe entry.
+//
+// SafeEntry provides an API for in-place manipulation of concurrent map entries,
+// enabling efficient "get or insert" patterns that are safe for concurrent use
+// by multiple goroutines.
+//
+// The interface is sealed to ensure type safety; implementations are limited
+// to [OccupiedSafeEntry] (when the key exists) and [VacantSafeEntry] (when the
+// key is absent). Use a type switch to access type-specific methods like Get,
+// Insert, or Remove.
+//
+// Concurrency notes:
+//   - AndModify uses a compare-and-swap (CAS) loop for atomic updates
+//   - AndModify may invoke its callback more than once when CAS retries; the
+//     callback must not perform non-idempotent external side effects
+//   - VacantSafeEntry stores pending modifications to handle insertion races
+//   - All operations are safe for concurrent use without external locking
+//
+// Common usage patterns:
+//
+//	// Thread-safe increment or insert (safe for concurrent goroutines)
+//	ms.Entry("counter").AndModify(func(v *int) { *v++ }).OrInsert(1)
+//
+//	// Thread-safe insert only if absent
+//	ms.Entry("key").OrInsert(defaultValue)
+//
+//	// Type switch for fine-grained control
+//	switch e := ms.Entry("key").(type) {
+//	case OccupiedSafeEntry[string, int]:
+//	    fmt.Println("exists:", e.Get())
+//	case VacantSafeEntry[string, int]:
+//	    e.Insert(42)
+//	}
+type SafeEntry[K comparable, V any] interface {
+	sealed()
+	Key() K
+	OrInsert(value V) V
+	OrInsertWith(fn func() V) V
+	OrInsertWithKey(fn func(K) V) V
+	OrDefault() V
+	AndModify(fn func(*V)) SafeEntry[K, V]
+}
+
+// OccupiedSafeEntry represents a view into a concurrent map entry that is known
+// to be present.
+//
+// It is typically obtained from MapSafe.Entry(key) when the key exists.
+// All operations on OccupiedSafeEntry are safe for concurrent use.
+type OccupiedSafeEntry[K comparable, V any] struct {
+	m   *MapSafe[K, V]
+	key K
+}
+
+// sealed prevents external implementations of the SafeEntry interface.
+func (OccupiedSafeEntry[K, V]) sealed() {}
+
+// Key returns the key of this entry.
+func (e OccupiedSafeEntry[K, V]) Key() K { return e.key }
+
+// Get returns the current value associated with the key.
+//
+// If the key is concurrently removed, the zero value of V is returned.
+func (e OccupiedSafeEntry[K, V]) Get() V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return *actual.(*V)
+	}
+	var zero V
+	return zero
+}
+
+// Insert replaces the value associated with the key and returns the previous value.
+//
+// The replacement is performed atomically with respect to other map operations.
+func (e OccupiedSafeEntry[K, V]) Insert(value V) V {
+	e.m.structMu.RLock()
+	defer e.m.structMu.RUnlock()
+
+	old, loaded := e.m.data.Swap(e.key, &value)
+	if loaded {
+		return *old.(*V)
+	}
+
+	e.m.count.Add(1)
+	var zero V
+	return zero
+}
+
+// Remove removes the entry from the map and returns the previously stored value.
+//
+// If the key is concurrently removed, the zero value of V is returned.
+func (e OccupiedSafeEntry[K, V]) Remove() V {
+	e.m.structMu.RLock()
+	defer e.m.structMu.RUnlock()
+
+	if actual, loaded := e.m.data.LoadAndDelete(e.key); loaded {
+		e.m.count.Add(-1)
+		return *actual.(*V)
+	}
+
+	var zero V
+	return zero
+}
+
+// OrInsert returns the existing value without modifying the map.
+// If the key was concurrently removed, the value is inserted as for a vacant entry.
+func (e OccupiedSafeEntry[K, V]) OrInsert(value V) V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return *actual.(*V)
+	}
+
+	return VacantSafeEntry[K, V]{m: e.m, key: e.key}.OrInsert(value)
+}
+
+// OrInsertWith returns the existing value if present, or inserts the result
+// of fn() and returns it.
+//
+// Note: Due to concurrent access, fn() may be invoked even if another
+// goroutine inserts the key between the check and insertion. In this case,
+// the result of fn() is discarded and the existing value is returned.
+func (e OccupiedSafeEntry[K, V]) OrInsertWith(fn func() V) V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return *actual.(*V)
+	}
+
+	return VacantSafeEntry[K, V]{m: e.m, key: e.key}.OrInsertWith(fn)
+}
+
+// OrInsertWithKey returns the existing value without invoking the function.
+// If the key was concurrently removed, fn is invoked with the key and its
+// result inserted as for a vacant entry.
+func (e OccupiedSafeEntry[K, V]) OrInsertWithKey(fn func(K) V) V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return *actual.(*V)
+	}
+
+	return VacantSafeEntry[K, V]{m: e.m, key: e.key}.OrInsertWithKey(fn)
+}
+
+// OrDefault returns the existing value.
+// If the key was concurrently removed, the zero value of V is inserted and returned.
+func (e OccupiedSafeEntry[K, V]) OrDefault() V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return *actual.(*V)
+	}
+
+	var zero V
+	return VacantSafeEntry[K, V]{m: e.m, key: e.key}.Insert(zero)
+}
+
+// AndModify applies the provided function to the value associated with the key
+// and returns the entry.
+//
+// The modification is performed using a compare-and-swap loop.
+// The function receives a pointer to a copy of the value; the updated value
+// is written back atomically.
+// Under contention, fn may be invoked more than once before CAS succeeds.
+// It should only modify the provided value and must not rely on exactly-once
+// external side effects.
+//
+// If the key is concurrently removed, AndModify becomes a no-op.
+func (e OccupiedSafeEntry[K, V]) AndModify(fn func(*V)) SafeEntry[K, V] {
+	for {
+		actual, ok := e.m.data.Load(e.key)
+		if !ok {
+			return e
+		}
+
+		oldPtr := actual.(*V)
+		newVal := *oldPtr
+		fn(&newVal)
+
+		if e.m.data.CompareAndSwap(e.key, oldPtr, &newVal) {
+			return e
+		}
+	}
+}
+
+// VacantSafeEntry represents a view into a concurrent map entry that is known
+// to be absent at the time of creation.
+//
+// It is typically obtained from MapSafe.Entry(key) when the key does not exist.
+// All operations on VacantSafeEntry are safe for concurrent use.
+//
+// The modify field stores a pending modification function from AndModify,
+// which will be applied if OrInsert loses a race with another goroutine.
+type VacantSafeEntry[K comparable, V any] struct {
+	m      *MapSafe[K, V]
+	key    K
+	modify func(*V)
+}
+
+// sealed prevents external implementations of the SafeEntry interface.
+func (VacantSafeEntry[K, V]) sealed() {}
+
+// Key returns the key that would be used for insertion.
+func (e VacantSafeEntry[K, V]) Key() K { return e.key }
+
+// applyPending applies the pending AndModify function (if any) to the value now
+// stored under the key, then returns the resulting stored value.
+//
+// It is used by the Or* methods when an insert loses the race to a concurrent
+// goroutine: the modification registered via AndModify must still be applied to
+// the value that actually won the race. If the key has since been removed,
+// fallback (the value observed during the failed insert) is returned instead.
+func (e VacantSafeEntry[K, V]) applyPending(fallback *V) V {
+	if e.modify != nil {
+		OccupiedSafeEntry[K, V]{m: e.m, key: e.key}.AndModify(e.modify)
+		if val, ok := e.m.data.Load(e.key); ok {
+			return *val.(*V)
+		}
+	}
+
+	return *fallback
+}
+
+// Insert inserts the provided value into the map and returns the stored value.
+//
+// If another goroutine inserts the same key concurrently, the existing value
+// is returned instead. Equivalent to OrInsert for VacantSafeEntry.
+func (e VacantSafeEntry[K, V]) Insert(value V) V { return e.OrInsert(value) }
+
+// OrInsert inserts the provided value and returns the stored value.
+//
+// If another goroutine inserts the same key concurrently (the insert "loses
+// the race"), the existing value is used instead. In this case, if a pending
+// modification was registered via AndModify, it is applied atomically to the
+// existing value before returning.
+//
+// This ensures that chained calls like Entry(k).AndModify(f).OrInsert(v)
+// behave correctly under concurrent access: under contended insertion the
+// modification is applied to the winning value.
+//
+// Edge case: if the key is also removed by another goroutine between the lost
+// insert and the modify, the modification has nothing to apply to and the
+// pre-modify value observed during the failed insert is returned. In that
+// narrow window the modification can be lost.
+func (e VacantSafeEntry[K, V]) OrInsert(value V) V {
+	e.m.structMu.RLock()
+	defer e.m.structMu.RUnlock()
+
+	actual, loaded := e.m.data.LoadOrStore(e.key, &value)
+	if !loaded {
+		e.m.count.Add(1)
+	}
+
+	if loaded {
+		return e.applyPending(actual.(*V))
+	}
+
+	return *actual.(*V)
+}
+
+// OrInsertWith inserts the value returned by the function and returns the
+// stored value.
+//
+// Note: Due to lock-free implementation, fn() is evaluated before the atomic
+// insertion. If another goroutine inserts the key concurrently, the result
+// of fn() may be discarded and the existing value is returned instead.
+func (e VacantSafeEntry[K, V]) OrInsertWith(fn func() V) V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return e.applyPending(actual.(*V))
+	}
+
+	e.m.structMu.RLock()
+	defer e.m.structMu.RUnlock()
+
+	actual, loaded := e.m.data.LoadOrStore(e.key, new(fn()))
+	if !loaded {
+		e.m.count.Add(1)
+	}
+
+	if loaded {
+		return e.applyPending(actual.(*V))
+	}
+
+	return *actual.(*V)
+}
+
+// OrInsertWithKey inserts the value returned by the function and returns the
+// stored value.
+//
+// Note: Due to lock-free implementation, fn() is evaluated before the atomic
+// insertion. If another goroutine inserts the key concurrently, the result
+// of fn() may be discarded and the existing value is returned instead.
+func (e VacantSafeEntry[K, V]) OrInsertWithKey(fn func(K) V) V {
+	if actual, ok := e.m.data.Load(e.key); ok {
+		return e.applyPending(actual.(*V))
+	}
+
+	e.m.structMu.RLock()
+	defer e.m.structMu.RUnlock()
+
+	actual, loaded := e.m.data.LoadOrStore(e.key, new(fn(e.key)))
+	if !loaded {
+		e.m.count.Add(1)
+	}
+
+	if loaded {
+		return e.applyPending(actual.(*V))
+	}
+
+	return *actual.(*V)
+}
+
+// OrDefault inserts the zero value of V into the map and returns the stored value.
+//
+// If another goroutine inserts the same key concurrently and a pending
+// modification was registered via AndModify, it is applied atomically
+// to the existing value before returning.
+func (e VacantSafeEntry[K, V]) OrDefault() V {
+	var zero V
+	return e.OrInsert(zero)
+}
+
+// AndModify registers a modification function to be applied to the value.
+//
+// If the key was concurrently inserted by another goroutine since this
+// VacantSafeEntry was created, the modification is applied immediately
+// via OccupiedSafeEntry.AndModify.
+//
+// Otherwise, the function is stored and will be applied later by OrInsert
+// if it loses the race to insert the key. This ensures that the pattern
+// Entry(k).AndModify(f).OrInsert(v) correctly increments existing values
+// even under heavy concurrent access.
+//
+// Returns the appropriate SafeEntry for method chaining.
+func (e VacantSafeEntry[K, V]) AndModify(fn func(*V)) SafeEntry[K, V] {
+	if _, ok := e.m.data.Load(e.key); ok {
+		return OccupiedSafeEntry[K, V]{m: e.m, key: e.key}.AndModify(fn)
+	}
+
+	return VacantSafeEntry[K, V]{m: e.m, key: e.key, modify: fn}
+}
diff --git a/backend/vendor/github.com/enetx/g/float_math.go b/backend/vendor/github.com/enetx/g/float_math.go
new file mode 100644
index 00000000..e6037e71
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/float_math.go
@@ -0,0 +1,158 @@
+package g
+
+import "math"
+
+// IsNaN reports whether the Float is an IEEE 754 "not-a-number" value.
+func (f Float) IsNaN() bool { return math.IsNaN(f.Std()) }
+
+// IsInf reports whether the Float is an infinity, either positive or negative.
+func (f Float) IsInf() bool { return math.IsInf(f.Std(), 0) }
+
+// IsFinite reports whether the Float is neither NaN nor an infinity.
+func (f Float) IsFinite() bool { return !f.IsNaN() && !f.IsInf() }
+
+// IsNormal reports whether the Float is a normal IEEE 754 number:
+// neither zero, subnormal, infinite, nor NaN.
+func (f Float) IsNormal() bool {
+	exp := f.Bits() >> 52 & 0x7ff
+
+	return exp != 0 && exp != 0x7ff
+}
+
+// Signum returns a Float representing the sign of the Float:
+// 1 if the sign bit is clear (including +0), -1 if the sign bit is set (including -0),
+// and NaN if the Float is NaN.
+func (f Float) Signum() Float {
+	if f.IsNaN() {
+		return f
+	}
+
+	return Float(math.Copysign(1, f.Std()))
+}
+
+// IsSignPositive reports whether the Float has a positive sign bit.
+// This includes +0.0 and positive infinity.
+// Note: NaN carries a sign bit too, so a NaN with a clear sign bit (e.g. math.NaN())
+// is reported as sign-positive; use IsNaN to detect NaN itself.
+func (f Float) IsSignPositive() bool { return !math.Signbit(f.Std()) }
+
+// IsSignNegative reports whether the Float has a negative sign bit.
+// This includes -0.0 and negative infinity.
+// Note: NaN carries a sign bit too, so a NaN with a set sign bit (e.g.
+// math.Copysign(math.NaN(), -1)) is reported as sign-negative; use IsNaN to
+// detect NaN itself.
+func (f Float) IsSignNegative() bool { return math.Signbit(f.Std()) }
+
+// Ceil returns the least integer value greater than or equal to the Float.
+func (f Float) Ceil() Float { return Float(math.Ceil(f.Std())) }
+
+// Floor returns the greatest integer value less than or equal to the Float.
+func (f Float) Floor() Float { return Float(math.Floor(f.Std())) }
+
+// Trunc returns the integer part of the Float, rounding toward zero.
+func (f Float) Trunc() Float { return Float(math.Trunc(f.Std())) }
+
+// Fract returns the fractional part of the Float (f - f.Trunc()).
+// For NaN and ±Inf the result is NaN.
+func (f Float) Fract() Float { return f - f.Trunc() }
+
+// Clamp restricts the Float to the inclusive range [min, max].
+// If the Float is NaN, NaN is returned.
+// The caller must ensure min <= max and that neither bound is NaN: this method
+// does not panic on an invalid range — a NaN bound never
+// compares true, so the corresponding check is silently skipped, and with
+// min > max the lower bound wins.
+func (f Float) Clamp(min, max Float) Float {
+	if f < min {
+		return min
+	}
+
+	if f > max {
+		return max
+	}
+
+	return f
+}
+
+// Recip returns the reciprocal (multiplicative inverse) of the Float, 1/f.
+func (f Float) Recip() Float { return 1 / f }
+
+// Copysign returns a Float with the magnitude of the Float and the sign of sign.
+func (f Float) Copysign(sign Float) Float { return Float(math.Copysign(f.Std(), sign.Std())) }
+
+// MulAdd returns f*b + c computed as a fused multiply-add with only one rounding.
+func (f Float) MulAdd(b, c Float) Float { return Float(math.FMA(f.Std(), b.Std(), c.Std())) }
+
+// Hypot returns Sqrt(f*f + b*b), avoiding unnecessary overflow and underflow.
+func (f Float) Hypot(b Float) Float { return Float(math.Hypot(f.Std(), b.Std())) }
+
+// Cbrt returns the cube root of the Float.
+func (f Float) Cbrt() Float { return Float(math.Cbrt(f.Std())) }
+
+// Exp returns e**f, the base-e exponential of the Float.
+func (f Float) Exp() Float { return Float(math.Exp(f.Std())) }
+
+// Exp2 returns 2**f, the base-2 exponential of the Float.
+func (f Float) Exp2() Float { return Float(math.Exp2(f.Std())) }
+
+// ExpM1 returns e**f - 1, which is more accurate than Exp().Sub(1) when the Float is near zero.
+func (f Float) ExpM1() Float { return Float(math.Expm1(f.Std())) }
+
+// Ln returns the natural logarithm of the Float.
+func (f Float) Ln() Float { return Float(math.Log(f.Std())) }
+
+// Ln1p returns the natural logarithm of 1 plus the Float,
+// which is more accurate than Add(1).Ln() when the Float is near zero.
+func (f Float) Ln1p() Float { return Float(math.Log1p(f.Std())) }
+
+// Log2 returns the base-2 logarithm of the Float.
+func (f Float) Log2() Float { return Float(math.Log2(f.Std())) }
+
+// Log10 returns the base-10 logarithm of the Float.
+func (f Float) Log10() Float { return Float(math.Log10(f.Std())) }
+
+// Sin returns the sine of the Float (in radians).
+func (f Float) Sin() Float { return Float(math.Sin(f.Std())) }
+
+// Cos returns the cosine of the Float (in radians).
+func (f Float) Cos() Float { return Float(math.Cos(f.Std())) }
+
+// Tan returns the tangent of the Float (in radians).
+func (f Float) Tan() Float { return Float(math.Tan(f.Std())) }
+
+// Asin returns the arcsine of the Float, in radians.
+func (f Float) Asin() Float { return Float(math.Asin(f.Std())) }
+
+// Acos returns the arccosine of the Float, in radians.
+func (f Float) Acos() Float { return Float(math.Acos(f.Std())) }
+
+// Atan returns the arctangent of the Float, in radians.
+func (f Float) Atan() Float { return Float(math.Atan(f.Std())) }
+
+// Atan2 returns the arctangent of f/b (with f as y and b as x), in radians,
+// using the signs of the two to determine the quadrant of the result.
+func (f Float) Atan2(b Float) Float { return Float(math.Atan2(f.Std(), b.Std())) }
+
+// Sinh returns the hyperbolic sine of the Float.
+func (f Float) Sinh() Float { return Float(math.Sinh(f.Std())) }
+
+// Cosh returns the hyperbolic cosine of the Float.
+func (f Float) Cosh() Float { return Float(math.Cosh(f.Std())) }
+
+// Tanh returns the hyperbolic tangent of the Float.
+func (f Float) Tanh() Float { return Float(math.Tanh(f.Std())) }
+
+// Asinh returns the inverse hyperbolic sine of the Float.
+func (f Float) Asinh() Float { return Float(math.Asinh(f.Std())) }
+
+// Acosh returns the inverse hyperbolic cosine of the Float.
+func (f Float) Acosh() Float { return Float(math.Acosh(f.Std())) }
+
+// Atanh returns the inverse hyperbolic tangent of the Float.
+func (f Float) Atanh() Float { return Float(math.Atanh(f.Std())) }
+
+// ToDegrees converts the Float from radians to degrees.
+func (f Float) ToDegrees() Float { return f * (180 / math.Pi) }
+
+// ToRadians converts the Float from degrees to radians.
+func (f Float) ToRadians() Float { return f * (math.Pi / 180) }
diff --git a/backend/vendor/github.com/enetx/g/fs/dir.go b/backend/vendor/github.com/enetx/g/fs/dir.go
new file mode 100644
index 00000000..ab5c34df
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/fs/dir.go
@@ -0,0 +1,580 @@
+package fs
+
+import (
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"github.com/enetx/g"
+)
+
+// Dir is a struct representing a directory path.
+type Dir struct {
+	path g.String // Directory path.
+}
+
+// NewDir returns a new Dir instance with the given path.
+func NewDir(path g.String) *Dir { return &Dir{path: path} }
+
+// Chown changes the ownership of the directory to the specified UID and GID.
+// It uses os.Chown to modify ownership and returns a Result[*Dir] indicating success or failure.
+func (d *Dir) Chown(uid, gid int) g.Result[*Dir] {
+	err := os.Chown(d.path.Std(), uid, gid)
+	if err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(d)
+}
+
+// Stat retrieves information about the directory represented by the Dir instance.
+// It returns a Result[fs.FileInfo] containing details about the directory's metadata.
+func (d *Dir) Stat() g.Result[fs.FileInfo] {
+	path := d.Path()
+	if path.IsErr() {
+		return g.Err[fs.FileInfo](path.Err())
+	}
+
+	return g.ResultOf(os.Stat(path.Ok().Std()))
+}
+
+// Lstat retrieves information about the symbolic link represented by the Dir instance.
+// It returns a Result[fs.FileInfo] containing details about the symbolic link's metadata.
+// Unlike Stat, Lstat does not follow the link and provides information about the link itself.
+func (d *Dir) Lstat() g.Result[fs.FileInfo] {
+	path := d.Path()
+	if path.IsErr() {
+		return g.Err[fs.FileInfo](path.Err())
+	}
+
+	return g.ResultOf(os.Lstat(path.Ok().Std()))
+}
+
+// IsLink checks if the directory is a symbolic link.
+func (d *Dir) IsLink() bool {
+	stat := d.Lstat()
+	return stat.IsOk() && stat.Ok().Mode()&os.ModeSymlink != 0
+}
+
+// CreateTempDir creates a new temporary directory in the specified directory with the
+// specified name pattern and returns a Result, which contains a pointer to the Dir
+// or an error if the operation fails.
+// If no directory is specified, the default directory for temporary directories is used.
+// If no name pattern is specified, the default pattern "*" is used.
+//
+// Parameters:
+//
+// - args ...String: A variadic parameter specifying the directory and/or name
+// pattern for the temporary directory.
+//
+// Returns:
+//
+// - *Dir: A pointer to the Dir representing the temporary directory.
+//
+// Example usage:
+//
+// tmpdir := fs.CreateTempDir()                     // Creates a temporary directory with default settings
+// tmpdirWithDir := fs.CreateTempDir("mydir")       // Creates a temporary directory in "mydir" directory
+// tmpdirWithPattern := fs.CreateTempDir("", "tmp") // Creates a temporary directory with "tmp" pattern
+func CreateTempDir(args ...g.String) g.Result[*Dir] {
+	dir := ""
+	pattern := "*"
+
+	if len(args) != 0 {
+		if len(args) > 1 {
+			pattern = args[1].Std()
+		}
+
+		dir = args[0].Std()
+	}
+
+	tmpDir, err := os.MkdirTemp(dir, pattern)
+	if err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(NewDir(g.String(tmpDir)))
+}
+
+// TempDir returns the default directory to use for temporary files.
+//
+// On Unix systems, it returns $TMPDIR if non-empty, else /tmp.
+// On Windows, it uses GetTempPath, returning the first non-empty
+// value from %TMP%, %TEMP%, %USERPROFILE%, or the Windows directory.
+// On Plan 9, it returns /tmp.
+//
+// The directory is neither guaranteed to exist nor have accessible
+// permissions.
+func TempDir() *Dir { return NewDir(g.String(os.TempDir())) }
+
+// Remove attempts to delete the directory and its contents.
+// It returns a Result, which contains either the *Dir or an error.
+// If the directory does not exist, Remove returns a successful Result with *Dir set.
+// Any error that occurs during removal will be of type *PathError.
+func (d *Dir) Remove() g.Result[*Dir] {
+	if err := os.RemoveAll(d.String().Std()); err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(d)
+}
+
+// Copy copies the contents of the current directory to the destination directory.
+//
+// Parameters:
+//
+// - dest (String): The destination directory where the contents of the current directory should be copied.
+//
+// - followLinks (optional): A boolean indicating whether to follow symbolic links during the walk.
+// If true, symbolic links are followed; otherwise, they are skipped.
+//
+// Returns:
+//
+// - Result[*Dir]: A Result type containing either a pointer to a new Dir instance representing the destination directory or an error.
+//
+// Example usage:
+//
+//	sourceDir := fs.NewDir("path/to/source")
+//	destinationDirResult := sourceDir.Copy("path/to/destination")
+//	if destinationDirResult.IsErr() {
+//		// Handle error
+//	}
+//	destinationDir := destinationDirResult.Ok()
+func (d *Dir) Copy(dest g.String, followLinks ...bool) g.Result[*Dir] {
+	files := g.NewSlice[*File]()
+
+	for r := range d.Walk() {
+		if r.IsErr() {
+			return g.Err[*Dir](r.Err())
+		}
+		files.Push(r.Ok())
+	}
+
+	root := d.Path()
+	if root.IsErr() {
+		return g.Err[*Dir](root.Err())
+	}
+
+	destRoot := NewDir(dest).Path()
+	if destRoot.IsErr() {
+		return g.Err[*Dir](destRoot.Err())
+	}
+
+	follow := true
+	if len(followLinks) > 0 {
+		follow = followLinks[0]
+	}
+
+	for f := range files.Iter() {
+		path := f.Path()
+		if path.IsErr() {
+			return g.Err[*Dir](path.Err())
+		}
+
+		relpath, err := filepath.Rel(root.Ok().Std(), path.Ok().Std())
+		if err != nil {
+			return g.Err[*Dir](err)
+		}
+
+		destpath := g.String(filepath.Join(destRoot.Ok().Std(), relpath))
+
+		// Skip every symlink (file or directory) when not following links;
+		// a symlink to a regular file is not an IsDir entry, so the skip must
+		// happen before the IsDir branch to avoid dereferencing the link.
+		if !follow && f.IsLink() {
+			continue
+		}
+
+		stat := f.Stat()
+		if stat.IsErr() {
+			return g.Err[*Dir](stat.Err())
+		}
+
+		if stat.Ok().IsDir() {
+			if r := NewDir(destpath).CreateAll(stat.Ok().Mode()); r.IsErr() {
+				return r
+			}
+
+			continue
+		}
+
+		if r := f.Copy(destpath, stat.Ok().Mode()); r.IsErr() {
+			return g.Err[*Dir](r.Err())
+		}
+	}
+
+	return g.Ok(NewDir(dest))
+}
+
+// Create creates a new directory with the specified mode (optional).
+//
+// Parameters:
+//
+// - mode (os.FileMode, optional): The file mode for the new directory.
+// If not provided, it defaults to DirDefault (0755).
+//
+// Returns:
+//
+// - *Dir: A pointer to the Dir instance on which the method was called.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	createdDir := dir.Create(0755) // Optional mode argument
+func (d *Dir) Create(mode ...os.FileMode) g.Result[*Dir] {
+	dmode := os.FileMode(g.DirDefault)
+	if len(mode) > 0 {
+		dmode = mode[0]
+	}
+	if err := os.Mkdir(d.path.Std(), dmode); err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(d)
+}
+
+// Join joins the current directory path with the given path elements, returning the joined path.
+//
+// Parameters:
+//
+// - elem (...String): One or more String values representing path elements to
+// be joined with the current directory path.
+//
+// Returns:
+//
+// - String: The resulting joined path as an String.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	joinedPath := dir.Join("subdir", "file.txt")
+func (d *Dir) Join(elem ...g.String) g.Result[g.String] {
+	path := d.Path()
+	if path.IsErr() {
+		return g.Err[g.String](path.Err())
+	}
+
+	parts := make([]string, len(elem)+1)
+	parts[0] = path.Ok().Std()
+	for i, part := range elem {
+		parts[i+1] = part.Std()
+	}
+
+	return g.Ok(g.String(filepath.Join(parts...)))
+}
+
+// SetPath sets the path of the current directory.
+//
+// Parameters:
+//
+// - path (String): The new path to be set for the current directory.
+//
+// Returns:
+//
+// - *Dir: A pointer to the updated Dir instance with the new path.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	dir.SetPath("new/path/to/directory")
+func (d *Dir) SetPath(path g.String) *Dir {
+	d.path = path
+	return d
+}
+
+// CreateAll creates all directories along the given path, with the specified mode (optional).
+//
+// Parameters:
+//
+// - mode ...os.FileMode (optional): The file mode to be used when creating the directories.
+// If not provided, it defaults to the value of DirDefault constant (0755).
+//
+// Returns:
+//
+// - *Dir: A pointer to the Dir instance representing the created directories.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	dir.CreateAll()
+//	dir.CreateAll(0755)
+func (d *Dir) CreateAll(mode ...os.FileMode) g.Result[*Dir] {
+	path := d.Path()
+	if path.IsErr() {
+		return g.Err[*Dir](path.Err())
+	}
+
+	dmode := os.FileMode(g.DirDefault)
+	if len(mode) > 0 {
+		dmode = mode[0]
+	}
+
+	err := os.MkdirAll(path.Ok().Std(), dmode)
+	if err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(d)
+}
+
+// Rename renames the current directory to the new path.
+//
+// Parameters:
+//
+// - newpath String: The new path for the directory.
+//
+// Returns:
+//
+// - Result[*Dir]: A Result containing a pointer to the Dir instance representing
+// the renamed directory, or an error if the rename fails.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	dir.Rename("path/to/new_directory")
+func (d *Dir) Rename(newpath g.String) g.Result[*Dir] {
+	if rd := NewDir(g.String(filepath.Dir(filepath.Clean(newpath.Std())))).CreateAll(); rd.IsErr() {
+		return rd
+	}
+
+	if err := os.Rename(d.path.Std(), newpath.Std()); err != nil {
+		return g.Err[*Dir](err)
+	}
+
+	return g.Ok(NewDir(newpath))
+}
+
+// Path returns the absolute path of the current directory.
+//
+// Returns:
+//
+// - Result[String]: The absolute path of the current directory as a String,
+// or an error if the path cannot be converted to an absolute path.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	absPath := dir.Path()
+func (d *Dir) Path() g.Result[g.String] {
+	path, err := filepath.Abs(d.path.Std())
+	if err != nil {
+		return g.Err[g.String](err)
+	}
+
+	return g.Ok(g.String(path))
+}
+
+// Exists checks if the current directory exists.
+//
+// Returns:
+//
+// - bool: true if the current directory exists, false otherwise.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	exists := dir.Exists()
+func (d *Dir) Exists() bool {
+	path := d.Path()
+	if path.IsErr() {
+		return false
+	}
+
+	info, err := os.Stat(path.Ok().Std())
+	return err == nil && info.IsDir()
+}
+
+// Read lazily iterates over the content of the current directory and yields a
+// File for each entry. Entries are read in bounded batches and retain the
+// filesystem order; callers that need sorted output can collect and sort them.
+//
+// Returns:
+//   - SeqResult[*File]: A sequence of Result[*File] instances representing each file and directory
+//     in the current directory. It returns an error if reading the directory fails.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory")
+//	files := dir.Read()
+//	for file := range files {
+//	    fmt.Println(file.Ok().Name())
+//	}
+func (d *Dir) Read() g.SeqResult[*File] {
+	return func(yield func(g.Result[*File]) bool) {
+		dpath := d.Path()
+		if dpath.IsErr() {
+			yield(g.Err[*File](dpath.Err()))
+			return
+		}
+
+		directory, err := os.Open(dpath.Ok().Std())
+		if err != nil {
+			yield(g.Err[*File](err))
+			return
+		}
+
+		defer directory.Close()
+
+		const batchSize = 128
+		base := dpath.Ok().Std()
+
+		for {
+			entries, readErr := directory.ReadDir(batchSize)
+			for _, entry := range entries {
+				if !yield(g.Ok(NewFile(filepath.Join(base, entry.Name())))) {
+					return
+				}
+			}
+
+			switch readErr {
+			case nil:
+				continue
+			case io.EOF:
+				return
+			default:
+				yield(g.Err[*File](readErr))
+				return
+			}
+		}
+	}
+}
+
+// Glob iterates over files in the current directory matching a specified pattern and yields File instances for each match.
+// This method utilizes a lazy evaluation strategy, processing files as they are needed.
+//
+// Returns:
+//   - SeqResult[*File]: A sequence of Result[*File] instances representing the files that match the
+//     provided pattern in the current directory. It returns an error if the glob operation fails.
+//
+// Example usage:
+//
+//	dir := fs.NewDir("path/to/directory/*.txt")
+//	files := dir.Glob()
+//	for file := range files {
+//	    fmt.Println(file.Ok().Name())
+//	}
+func (d *Dir) Glob() g.SeqResult[*File] {
+	return func(yield func(g.Result[*File]) bool) {
+		matches, err := filepath.Glob(d.path.Std())
+		if err != nil {
+			yield(g.Err[*File](err))
+			return
+		}
+
+		for _, match := range matches {
+			file := NewFile(g.String(match)).Path()
+			if file.IsErr() {
+				yield(g.Err[*File](file.Err()))
+				return
+			}
+
+			if !yield(g.Ok(NewFile(file.Ok()))) {
+				return
+			}
+		}
+	}
+}
+
+// Walk returns a lazy sequence of all files and directories under the current Dir.
+// You can customize inclusion/exclusion using SeqResult methods (Exclude, Filter, etc.).
+//
+// Example usage:
+//
+//	NewDir("path/to/dir").
+//	  Walk().
+//	  Exclude((*File).IsLink).
+//	  ForEach(func(r Result[*File]) {
+//	      if r.IsOk() {
+//	          fmt.Println(r.Ok().Path().Ok().Std())
+//	      }
+//	  })
+func (d *Dir) Walk() g.SeqResult[*File] {
+	return func(yield func(g.Result[*File]) bool) {
+		stack := g.SliceOf(d)
+		stopped := false
+
+		// Track resolved directory paths already scheduled for traversal so a
+		// symlink (or hardlinked dir) pointing back into an ancestor does not
+		// drive the stack into unbounded recursion.
+		visited := g.NewSet[g.String]()
+		if root := d.Path(); root.IsOk() {
+			visited.Insert(root.Ok())
+		}
+
+		for !stack.IsEmpty() && !stopped {
+			current := stack.Pop()
+			if current.IsNone() {
+				break
+			}
+
+			current.Some().Read().Range(func(r g.Result[*File]) bool {
+				if r.IsErr() {
+					if !yield(r) {
+						stopped = true
+						return false
+					}
+					return true
+				}
+
+				file := r.Ok()
+				if !yield(g.Ok(file)) {
+					stopped = true
+					return false
+				}
+
+				// Use Lstat so that a symbolic link to a directory is reported
+				// but not descended into; following it (via Stat) is what makes
+				// symlink cycles loop forever.
+				lstat := file.Lstat()
+				if lstat.IsErr() {
+					if !yield(g.Err[*File](lstat.Err())) {
+						stopped = true
+						return false
+					}
+					return true
+				}
+
+				if lstat.Ok().Mode()&os.ModeSymlink != 0 {
+					return true
+				}
+
+				if lstat.Ok().IsDir() {
+					path := file.Path()
+					if path.IsErr() {
+						if !yield(g.Err[*File](path.Err())) {
+							stopped = true
+							return false
+						}
+						return true
+					}
+
+					if visited.Contains(path.Ok()) {
+						return true
+					}
+
+					visited.Insert(path.Ok())
+					stack.Push(NewDir(path.Ok()))
+				}
+
+				return true
+			})
+
+			if stopped {
+				return
+			}
+		}
+	}
+}
+
+// String returns the String representation of the current directory's path.
+func (d *Dir) String() g.String { return d.path }
+
+// Print writes the content of the Dir to the standard output (console)
+// and returns the Dir unchanged.
+func (d *Dir) Print() *Dir { fmt.Print(d); return d }
+
+// Println writes the content of the Dir to the standard output (console) with a newline
+// and returns the Dir unchanged.
+func (d *Dir) Println() *Dir { fmt.Println(d); return d }
diff --git a/backend/vendor/github.com/enetx/g/fs/encdec.go b/backend/vendor/github.com/enetx/g/fs/encdec.go
new file mode 100644
index 00000000..cbac87ef
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/fs/encdec.go
@@ -0,0 +1,155 @@
+package fs
+
+import (
+	"encoding/gob"
+	json "encoding/json/v2"
+
+	"github.com/enetx/g"
+)
+
+type (
+	// fencode represents a wrapper for file encoding.
+	fencode struct{ f *File }
+
+	// fdecode represents a wrapper for file decoding.
+	fdecode struct{ f *File }
+)
+
+// Encode returns an fencode struct wrapping the given file for encoding.
+func (f *File) Encode() fencode { return fencode{f} }
+
+// Decode returns an fdecode struct wrapping the given file for decoding.
+func (f *File) Decode() fdecode { return fdecode{f} }
+
+// Gob encodes the provided data using the encoding/gob package and writes it to the file.
+// It returns a Result[*File] indicating the success or failure of the encoding operation.
+//
+// The created file is closed automatically before the method returns.
+//
+// Usage:
+//
+//	data := g.SliceOf(1, 2, 3, 4)
+//	result := fs.NewFile("somefile.gob").Encode().Gob(data)
+//
+// Parameters:
+//   - data: The data to be encoded and written to the file.
+//
+// Returns:
+//   - Result[*File]: A Result containing a *File if the operation is successful; otherwise, an error Result.
+func (fe fencode) Gob(data any) g.Result[*File] {
+	r := fe.f.Create()
+	if r.IsErr() {
+		return r
+	}
+
+	defer r.Ok().Close()
+
+	if err := gob.NewEncoder(r.Ok().Std()).Encode(data); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return r
+}
+
+// Gob decodes data from the file using the encoding/gob package and populates the provided data structure.
+// It returns a Result[*File] indicating the success or failure of the decoding operation.
+//
+// The file is closed automatically before the method returns.
+//
+// Usage:
+//
+//	var data g.Slice[int]
+//	result := fs.NewFile("somefile.gob").Decode().Gob(&data)
+//
+// Parameters:
+//   - data: A pointer to the data structure where the decoded data will be stored.
+//
+// Returns:
+//   - Result[*File]: A Result containing a *File if the operation is successful; otherwise, an error Result.
+func (fd fdecode) Gob(data any) g.Result[*File] {
+	r := fd.f.Open()
+	if r.IsErr() {
+		return r
+	}
+
+	defer r.Ok().Close()
+
+	if err := gob.NewDecoder(r.Ok().Std()).Decode(data); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return r
+}
+
+// JSON encodes the provided data using the encoding/json/v2 package and writes it to the file.
+// It returns a Result[*File] indicating the success or failure of the encoding operation.
+//
+// The created file is closed automatically before the method returns.
+//
+// Breaking changes (v2 semantics) compared to the previous encoding/json v1 implementation:
+//   - nil slices are marshaled as [] and nil maps as {} (v1 emitted null for both);
+//   - strings containing invalid UTF-8 yield Err (v1 replaced invalid sequences with U+FFFD);
+//   - no trailing newline is written after the JSON value (v1's Encoder.Encode appended '\n');
+//   - '<', '>', '&' and U+2028/U+2029 are emitted raw (v1's Encoder HTML-escaped them).
+//
+// Usage:
+//
+//	data := g.SliceOf(1, 2, 3, 4)
+//	result := fs.NewFile("somefile.json").Encode().JSON(data)
+//
+// Parameters:
+//   - data: The data to be encoded and written to the file.
+//
+// Returns:
+//   - Result[*File]: A Result containing a *File if the operation is successful; otherwise, an error Result.
+func (fe fencode) JSON(data any) g.Result[*File] {
+	r := fe.f.Create()
+	if r.IsErr() {
+		return r
+	}
+
+	defer r.Ok().Close()
+
+	if err := json.MarshalWrite(r.Ok().Std(), data); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return r
+}
+
+// JSON decodes data from the file using the encoding/json/v2 package and populates the provided data structure.
+// It returns a Result[*File] indicating the success or failure of the decoding operation.
+//
+// The file is closed automatically before the method returns.
+//
+// Breaking changes (v2 semantics) compared to the previous encoding/json v1 implementation:
+//   - duplicate object member names yield Err (v1 silently kept the last value);
+//   - struct field name matching is case-sensitive (v1 fell back to case-insensitive matching);
+//   - JSON strings containing invalid UTF-8 yield Err (v1 decoded them with U+FFFD replacements);
+//   - the file must contain exactly one JSON value: non-whitespace data after the
+//     top-level value yields Err (v1's Decoder.Decode read one value and ignored the rest).
+//
+// Usage:
+//
+//	var data g.Slice[int]
+//	result := fs.NewFile("somefile.json").Decode().JSON(&data)
+//
+// Parameters:
+//   - data: A pointer to the data structure where the decoded data will be stored.
+//
+// Returns:
+//   - Result[*File]: A Result containing a *File if the operation is successful; otherwise, an error Result.
+func (fd fdecode) JSON(data any) g.Result[*File] {
+	r := fd.f.Open()
+	if r.IsErr() {
+		return r
+	}
+
+	defer r.Ok().Close()
+
+	if err := json.UnmarshalRead(r.Ok().Std(), data); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return r
+}
diff --git a/backend/vendor/github.com/enetx/g/fs/errors.go b/backend/vendor/github.com/enetx/g/fs/errors.go
new file mode 100644
index 00000000..0997016d
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/fs/errors.go
@@ -0,0 +1,17 @@
+package fs
+
+import "fmt"
+
+// ErrFileNotExist represents an error for when a file does not exist.
+type ErrFileNotExist struct{ Msg string }
+
+// Error returns the error message for ErrFileNotExist.
+func (e *ErrFileNotExist) Error() string { return fmt.Sprintf("no such file: %s", e.Msg) }
+
+// ErrFileClosed represents an error for when a file is already closed.
+type ErrFileClosed struct{ Msg string }
+
+// Error returns the error message for ErrFileClosed.
+func (e *ErrFileClosed) Error() string {
+	return fmt.Sprintf("%s: file is already closed and unlocked", e.Msg)
+}
diff --git a/backend/vendor/github.com/enetx/g/fs/file.go b/backend/vendor/github.com/enetx/g/fs/file.go
new file mode 100644
index 00000000..0b801fa3
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/fs/file.go
@@ -0,0 +1,778 @@
+// Package fs provides chainable, Result-based filesystem operations (File, Dir),
+// including lazy SeqResult iterators over file lines and chunks.
+package fs
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"github.com/enetx/g"
+	"github.com/enetx/g/internal/filelock"
+	"github.com/enetx/g/internal/mimesniff"
+)
+
+// errChunkSize is the shared error yielded by File.Chunks and File.ChunksRaw
+// when the requested chunk size is not positive.
+var errChunkSize = errors.New("chunk size must be > 0")
+
+// File is a struct that represents a file.
+type File struct {
+	file  *os.File // Underlying os.File.
+	name  g.String // File name.
+	guard bool     // Guard indicates whether the file is protected against concurrent access.
+}
+
+type fileReader struct {
+	owner *File
+	file  *os.File
+}
+
+func (r fileReader) Read(p []byte) (int, error) { return r.file.Read(p) }
+func (r fileReader) Close() error {
+	if r.owner.file == r.file {
+		return r.owner.Close()
+	}
+
+	return r.file.Close()
+}
+
+// NewFile returns a new File instance with the given name.
+func NewFile[T ~string](name T) *File { return &File{name: g.String(name)} }
+
+// Lines returns a new iterator instance that can be used to read the file
+// line by line.
+//
+// Example usage:
+//
+//	// Open a new file with the specified name "text.txt"
+//	fs.NewFile("text.txt").
+//		Lines().                 // Read the file line by line
+//		Skip(3).                 // Skip the first 3 lines
+//		Exclude(f.IsZero).       // Exclude empty lines
+//		Dedup().                 // Remove consecutive duplicate lines
+//		Map(g.String.Upper).     // Convert each line to uppercase
+//		ForEach(func(s g.Result[g.String]) { s.Ok().Print() }) // For each line, print it
+//
+//	// Output:
+//	// UPPERCASED_LINE4
+//	// UPPERCASED_LINE5
+//	// UPPERCASED_LINE6
+func (f *File) Lines() g.SeqResult[g.String] {
+	return func(yield func(g.Result[g.String]) bool) {
+		if f.file == nil {
+			if r := f.Open(); r.IsErr() {
+				yield(g.Err[g.String](r.Err()))
+				return
+			}
+		}
+
+		defer f.Close()
+
+		scanner := bufio.NewScanner(f.file)
+		scanner.Split(bufio.ScanLines)
+
+		for scanner.Scan() {
+			if !yield(g.Ok(g.String(scanner.Text()))) {
+				return
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			yield(g.Err[g.String](err))
+			return
+		}
+	}
+}
+
+// LinesRaw returns a new iterator instance that reads the file line by line,
+// yielding each line as a Bytes slice (raw []byte).
+//
+// This version avoids intermediate string allocations by working directly with byte slices.
+// The returned Bytes are copies of the scanner buffer and are safe to retain.
+//
+// Returns:
+//
+// - SeqResult[Bytes]: An iterator over raw byte lines from the file.
+//
+// Example usage:
+//
+//	fs.NewFile("text.txt").
+//		LinesRaw().                // Read raw byte lines
+//		Filter(func(b g.Bytes) bool {
+//			return len(b) > 0
+//		}).
+//		ForEach(func(line g.Result[g.Bytes]) {
+//			line.Ok().Print()
+//		})
+//
+// Output:
+// LINE_1
+// LINE_2
+// ...
+//
+// Note: Each line is copied before yielding to avoid scanner buffer reuse issues.
+func (f *File) LinesRaw() g.SeqResult[g.Bytes] {
+	return func(yield func(g.Result[g.Bytes]) bool) {
+		if f.file == nil {
+			if r := f.Open(); r.IsErr() {
+				yield(g.Err[g.Bytes](r.Err()))
+				return
+			}
+		}
+
+		defer f.Close()
+
+		scanner := bufio.NewScanner(f.file)
+		scanner.Split(bufio.ScanLines)
+
+		for scanner.Scan() {
+			line := make(g.Bytes, len(scanner.Bytes()))
+			copy(line, scanner.Bytes())
+			if !yield(g.Ok(line)) {
+				return
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			yield(g.Err[g.Bytes](err))
+			return
+		}
+	}
+}
+
+// Chunks returns a new iterator instance that can be used to read the file
+// in fixed-size chunks of the specified size in bytes.
+//
+// Parameters:
+//
+// - size (int): The size of each chunk in bytes.
+//
+// Example usage:
+//
+//	// Open a new file with the specified name "text.txt"
+//	fs.NewFile("text.txt").
+//		Chunks(100).              // Read the file in chunks of 100 bytes
+//		Map(g.String.Upper).      // Convert each chunk to uppercase
+//		ForEach(func(s g.Result[g.String]) { s.Ok().Print() }) // For each chunk, print it
+//
+//	// Output:
+//	// UPPERCASED_CHUNK1
+//	// UPPERCASED_CHUNK2
+//	// UPPERCASED_CHUNK3
+func (f *File) Chunks(size g.Int) g.SeqResult[g.String] {
+	return func(yield func(g.Result[g.String]) bool) {
+		if size.Lte(0) {
+			yield(g.Err[g.String](errChunkSize))
+			return
+		}
+
+		if f.file == nil {
+			if r := f.Open(); r.IsErr() {
+				yield(g.Err[g.String](r.Err()))
+				return
+			}
+		}
+
+		defer f.Close()
+
+		buffer := make([]byte, size)
+
+		for {
+			n, err := f.file.Read(buffer)
+			if err != nil && err != io.EOF {
+				yield(g.Err[g.String](err))
+				return
+			}
+
+			if n == 0 {
+				break
+			}
+
+			if !yield(g.Ok(g.String(buffer[:n]))) {
+				return
+			}
+		}
+	}
+}
+
+// ChunksRaw returns a new iterator instance that reads the file in fixed-size
+// chunks of bytes, yielding each chunk as a Bytes slice.
+//
+// This method avoids intermediate string allocations and operates directly on byte slices.
+// Each chunk is copied from the underlying buffer to make it safe for downstream use.
+//
+// Parameters:
+//
+// - size (Int): The size of each chunk in bytes. Must be > 0.
+//
+// Returns:
+//
+// - SeqResult[Bytes]: An iterator over raw byte chunks from the file.
+//
+// Example usage:
+//
+//	fs.NewFile("text.txt").
+//		ChunksRaw(128).            // Read raw 128-byte chunks
+//		ForEach(func(chunk g.Result[g.Bytes]) {
+//			chunk.Ok().Print()
+//		})
+//
+// Output:
+// RAW_CHUNK_1
+// RAW_CHUNK_2
+// ...
+//
+// Note: Each chunk is copied from the buffer to ensure memory safety.
+func (f *File) ChunksRaw(size g.Int) g.SeqResult[g.Bytes] {
+	return func(yield func(g.Result[g.Bytes]) bool) {
+		if size.Lte(0) {
+			yield(g.Err[g.Bytes](errChunkSize))
+			return
+		}
+
+		if f.file == nil {
+			if r := f.Open(); r.IsErr() {
+				yield(g.Err[g.Bytes](r.Err()))
+				return
+			}
+		}
+
+		defer f.Close()
+
+		buf := make([]byte, size)
+
+		for {
+			n, err := f.file.Read(buf)
+			if err != nil && err != io.EOF {
+				yield(g.Err[g.Bytes](err))
+				return
+			}
+
+			if n == 0 {
+				break
+			}
+
+			chunk := make(g.Bytes, n)
+			copy(chunk, buf[:n])
+
+			if !yield(g.Ok(chunk)) {
+				return
+			}
+		}
+	}
+}
+
+// Append appends the given content to the file, with the specified mode (optional).
+// If no FileMode is provided, the default FileMode (0644) is used.
+// Don't forget to close the file!
+func (f *File) Append(content g.String, mode ...os.FileMode) g.Result[*File] {
+	if f.file == nil {
+		if r := f.createAll(); r.IsErr() {
+			return r
+		}
+
+		fmode := os.FileMode(g.FileDefault)
+		if len(mode) > 0 {
+			fmode = mode[0]
+		}
+
+		if r := f.OpenFile(os.O_APPEND|os.O_CREATE|os.O_WRONLY, fmode); r.IsErr() {
+			return r
+		}
+	}
+
+	if _, err := f.file.WriteString(content.Std()); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// Chmod changes the mode of the file.
+func (f *File) Chmod(mode os.FileMode) g.Result[*File] {
+	var err error
+	if f.file != nil {
+		err = f.file.Chmod(mode)
+	} else {
+		err = os.Chmod(f.name.Std(), mode)
+	}
+
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// Chown changes the owner of the file.
+func (f *File) Chown(uid, gid int) g.Result[*File] {
+	var err error
+	if f.file != nil {
+		err = f.file.Chown(uid, gid)
+	} else {
+		err = os.Chown(f.name.Std(), uid, gid)
+	}
+
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// Seek sets the file offset for the next Read or Write operation. The offset
+// is specified by the 'offset' parameter, and the 'whence' parameter determines
+// the reference point for the offset.
+//
+// The 'offset' parameter specifies the new offset in bytes relative to the
+// reference point determined by 'whence'. If 'whence' is set to io.SeekStart,
+// io.SeekCurrent, or io.SeekEnd, the offset is relative to the start of the file,
+// the current offset, or the end of the file, respectively.
+//
+// If the file is not open, this method will attempt to open it. If the open
+// operation fails, an error is returned.
+//
+// If the Seek operation fails, the file is closed, and an error is returned.
+//
+// Example:
+//
+//	file := fs.NewFile("example.txt")
+//	result := file.Seek(100, io.SeekStart)
+//	if result.Err() != nil {
+//	    log.Fatal(result.Err())
+//	}
+//
+// Parameters:
+//   - offset: The new offset in bytes.
+//   - whence: The reference point for the offset (io.SeekStart, io.SeekCurrent, or io.SeekEnd).
+//
+// Don't forget to close the file!
+func (f *File) Seek(offset int64, whence int) g.Result[*File] {
+	if f.file == nil {
+		if r := f.Open(); r.IsErr() {
+			return r
+		}
+	}
+
+	if _, err := f.file.Seek(offset, whence); err != nil {
+		f.Close()
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// Close closes the File and unlocks its underlying file, if it is not already closed.
+func (f *File) Close() error {
+	if f.file == nil {
+		return &ErrFileClosed{f.name.Std()}
+	}
+
+	var err error
+
+	if f.guard {
+		err = filelock.Unlock(f.file)
+	}
+
+	if closeErr := f.file.Close(); closeErr != nil {
+		err = errors.Join(err, closeErr)
+	}
+
+	f.file = nil
+
+	return err
+}
+
+// Copy copies the file to the specified destination, with the specified mode (optional).
+// If no mode is provided, the default FileMode (0644) is used.
+func (f *File) Copy(dest g.String, mode ...os.FileMode) g.Result[*File] {
+	if r := f.Open(); r.IsErr() {
+		return r
+	}
+
+	defer f.Close()
+
+	nf := NewFile(dest)
+	if f.guard {
+		nf.guard = true
+	}
+
+	return nf.WriteFromReader(f.file, mode...)
+}
+
+// Create is similar to os.Create; if the file is guarded, the returned file is write-locked.
+// Don't forget to close the file!
+func (f *File) Create() g.Result[*File] {
+	return f.OpenFile(os.O_RDWR|os.O_CREATE|os.O_TRUNC, g.FileCreate)
+}
+
+// Dir returns the directory the file is in as a Dir instance.
+func (f *File) Dir() g.Result[*Dir] {
+	dirPath := f.dirPath()
+	if dirPath.IsErr() {
+		return g.Err[*Dir](dirPath.Err())
+	}
+
+	return g.Ok(NewDir(dirPath.Ok()))
+}
+
+// Exists checks if the file exists.
+func (f *File) Exists() bool {
+	_, err := os.Stat(f.name.Std())
+	return err == nil
+}
+
+// Ext returns the file extension.
+func (f *File) Ext() g.String { return g.String(filepath.Ext(f.name.Std())) }
+
+// Guard sets a lock on the file to protect it from concurrent access.
+// It returns the File instance with the guard enabled.
+func (f *File) Guard() *File {
+	f.guard = true
+	return f
+}
+
+// MimeType returns the MIME type of the file as Result[String].
+func (f *File) MimeType() g.Result[g.String] {
+	if r := f.Open(); r.IsErr() {
+		return g.Err[g.String](r.Err())
+	}
+
+	defer f.Close()
+
+	buff := make([]byte, mimesniff.SniffLen)
+
+	bytesRead, err := f.file.ReadAt(buff, 0)
+	if err != nil && err != io.EOF {
+		return g.Err[g.String](err)
+	}
+
+	buff = buff[:bytesRead]
+
+	return g.Ok(g.String(mimesniff.DetectContentType(buff)))
+}
+
+// Name returns the name of the file.
+func (f *File) Name() g.String {
+	if f.file != nil {
+		return g.String(filepath.Base(f.file.Name()))
+	}
+
+	return g.String(filepath.Base(f.name.Std()))
+}
+
+// Open is like os.Open; if the file is guarded, the returned file is read-locked.
+// Don't forget to close the file!
+func (f *File) Open() g.Result[*File] { return f.OpenFile(os.O_RDONLY, 0) }
+
+// OpenFile is like os.OpenFile; if the file is guarded, the returned file is locked.
+// If flag includes os.O_WRONLY or os.O_RDWR, the file is write-locked;
+// otherwise, it is read-locked.
+// Don't forget to close the file!
+func (f *File) OpenFile(flag int, perm fs.FileMode) g.Result[*File] {
+	file, err := os.OpenFile(f.name.Std(), flag&^os.O_TRUNC, perm)
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	if f.guard {
+		switch flag & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR) {
+		case os.O_WRONLY, os.O_RDWR:
+			err = filelock.Lock(file)
+		default:
+			err = filelock.RLock(file)
+		}
+
+		if err != nil {
+			file.Close()
+			return g.Err[*File](err)
+		}
+	}
+
+	if flag&os.O_TRUNC == os.O_TRUNC {
+		if err := file.Truncate(0); err != nil {
+			if fi, statErr := file.Stat(); statErr != nil || fi.Mode().IsRegular() {
+				if f.guard {
+					filelock.Unlock(file)
+				}
+
+				file.Close()
+
+				return g.Err[*File](err)
+			}
+		}
+	}
+
+	// Release any descriptor already held by this File before reassigning,
+	// otherwise re-opening (e.g. WriteFromReader on an open handle) leaks the
+	// previous fd and orphans its advisory lock.
+	if f.file != nil {
+		if f.guard {
+			filelock.Unlock(f.file)
+		}
+
+		f.file.Close()
+	}
+
+	f.file = file
+
+	return g.Ok(f)
+}
+
+// Path returns the absolute path of the file.
+func (f *File) Path() g.Result[g.String] { return f.filePath() }
+
+// Print writes the content of the File to the standard output (console)
+// and returns the File unchanged.
+func (f *File) Print() *File { fmt.Print(f.Read().UnwrapOrDefault()); return f }
+
+// Println writes the content of the File to the standard output (console) with a newline
+// and returns the File unchanged.
+func (f *File) Println() *File { fmt.Println(f.Read().UnwrapOrDefault()); return f }
+
+// Read opens the named file (read-locked if the file is guarded) and returns its contents.
+func (f *File) Read() g.Result[g.String] {
+	if r := f.Open(); r.IsErr() {
+		return g.Err[g.String](r.Err())
+	}
+
+	defer f.Close()
+
+	content, err := io.ReadAll(f.file)
+	if err != nil {
+		return g.Err[g.String](err)
+	}
+
+	return g.Ok(g.String(content))
+}
+
+// Reader returns an io.ReadCloser for reading the file's contents.
+// If the file is not already open, it attempts to open it automatically.
+// The caller is responsible for closing the returned reader to release system resources.
+func (f *File) Reader() g.Result[io.ReadCloser] {
+	if f.file == nil {
+		if r := f.Open(); r.IsErr() {
+			return g.Err[io.ReadCloser](r.Err())
+		}
+	}
+
+	return g.Ok[io.ReadCloser](fileReader{owner: f, file: f.file})
+}
+
+// Remove removes the file.
+func (f *File) Remove() g.Result[*File] {
+	if err := os.Remove(f.name.Std()); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// Rename renames the file to the specified new path.
+func (f *File) Rename(newpath g.String) g.Result[*File] {
+	if !f.Exists() {
+		return g.Err[*File](&ErrFileNotExist{f.name.Std()})
+	}
+
+	nf := NewFile(newpath)
+	if f.guard {
+		nf.guard = true
+	}
+
+	if r := nf.createAll(); r.IsErr() {
+		return r
+	}
+
+	if err := os.Rename(f.name.Std(), newpath.Std()); err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(nf)
+}
+
+// Split splits the file path into its directory and file components.
+func (f *File) Split() (*Dir, *File) {
+	path := f.Path()
+	if path.IsErr() {
+		return nil, nil
+	}
+
+	dir, file := filepath.Split(path.Ok().Std())
+
+	return NewDir(g.String(dir)), NewFile(g.String(file))
+}
+
+// Stat returns the fs.FileInfo of the file.
+// It calls the file's Stat method if the file is open, or os.Stat otherwise.
+func (f *File) Stat() g.Result[fs.FileInfo] {
+	if f.file != nil {
+		return g.ResultOf(f.file.Stat())
+	}
+
+	return g.ResultOf(os.Stat(f.name.Std()))
+}
+
+// Lstat retrieves information about the symbolic link represented by the *File instance.
+// It returns a Result[fs.FileInfo] containing details about the symbolic link's metadata.
+// Unlike Stat, Lstat does not follow the link and provides information about the link itself.
+func (f *File) Lstat() g.Result[fs.FileInfo] {
+	return g.ResultOf(os.Lstat(f.name.Std()))
+}
+
+// IsDir checks if the file is a directory.
+func (f *File) IsDir() bool {
+	stat := f.Stat()
+	return stat.IsOk() && stat.Ok().IsDir()
+}
+
+// IsLink checks if the file is a symbolic link.
+func (f *File) IsLink() bool {
+	stat := f.Lstat()
+	return stat.IsOk() && stat.Ok().Mode()&os.ModeSymlink != 0
+}
+
+// Std returns the underlying *os.File instance.
+// Don't forget to close the file with Close!
+func (f *File) Std() *os.File { return f.file }
+
+// CreateTemp creates a new temporary file in the specified directory with the
+// specified name pattern and returns a Result, which contains a pointer to the File
+// or an error if the operation fails.
+// If no directory is specified, the default directory for temporary files is used.
+// If no name pattern is specified, the default pattern "*" is used.
+//
+// Parameters:
+//
+// - args ...String: A variadic parameter specifying the directory and/or name
+// pattern for the temporary file.
+//
+// Returns:
+//
+// - *File: A pointer to the File representing the temporary file.
+//
+// Example usage:
+//
+//	tmpfile := fs.CreateTempFile()                     // Creates a temporary file with default settings
+//	tmpfileWithDir := fs.CreateTempFile("mydir")       // Creates a temporary file in "mydir" directory
+//	tmpfileWithPattern := fs.CreateTempFile("", "tmp") // Creates a temporary file with "tmp" pattern
+//
+// Call .Guard() on the result to lock it; no guard state is set implicitly.
+func CreateTempFile(args ...g.String) g.Result[*File] {
+	dir := ""
+	pattern := "*"
+
+	if len(args) != 0 {
+		if len(args) > 1 {
+			pattern = args[1].Std()
+		}
+
+		dir = args[0].Std()
+	}
+
+	tmpfile, err := os.CreateTemp(dir, pattern)
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	ntmpfile := NewFile(g.String(tmpfile.Name()))
+	ntmpfile.file = tmpfile
+
+	defer ntmpfile.Close()
+
+	return g.Ok(ntmpfile)
+}
+
+// Write opens the named file (creating it with the given permissions if needed)
+// and overwrites it with the given content; if the file is guarded, it is
+// write-locked while writing.
+func (f *File) Write(content g.String, mode ...os.FileMode) g.Result[*File] {
+	return f.WriteFromReader(content.Reader(), mode...)
+}
+
+// WriteFromReader takes an io.Reader (scr) as input and writes the data from the reader into the file.
+// If no FileMode is provided, the default FileMode (0644) is used.
+func (f *File) WriteFromReader(scr io.Reader, mode ...os.FileMode) g.Result[*File] {
+	if f.file == nil {
+		if r := f.createAll(); r.IsErr() {
+			return r
+		}
+	}
+
+	filePath := f.filePath()
+	if filePath.IsErr() {
+		return g.Err[*File](filePath.Err())
+	}
+
+	fmode := os.FileMode(g.FileDefault)
+	if len(mode) > 0 {
+		fmode = mode[0]
+	}
+
+	if r := f.OpenFile(os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fmode); r.IsErr() {
+		return g.Err[*File](r.Err())
+	}
+
+	defer f.Close()
+
+	_, err := io.Copy(f.file, scr)
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	err = f.file.Sync()
+	if err != nil {
+		return g.Err[*File](err)
+	}
+
+	return g.Ok(f)
+}
+
+// dirPath returns the absolute path of the directory containing the file.
+func (f *File) dirPath() g.Result[g.String] {
+	name := f.name.Std()
+	if info, err := os.Stat(name); err == nil && info.IsDir() {
+		path, err := filepath.Abs(name)
+		if err != nil {
+			return g.Err[g.String](err)
+		}
+
+		return g.Ok(g.String(path))
+	}
+
+	path, err := filepath.Abs(filepath.Dir(name))
+	if err != nil {
+		return g.Err[g.String](err)
+	}
+
+	return g.Ok(g.String(path))
+}
+
+// filePath returns the full file path, including the directory and file name.
+func (f *File) filePath() g.Result[g.String] {
+	path, err := filepath.Abs(f.name.Std())
+	if err != nil {
+		return g.Err[g.String](err)
+	}
+
+	return g.Ok(g.String(path))
+}
+
+func (f *File) createAll() g.Result[*File] {
+	dirPath := f.dirPath()
+	if dirPath.IsErr() {
+		return g.Err[*File](dirPath.Err())
+	}
+
+	if !f.Exists() {
+		if err := os.MkdirAll(dirPath.Ok().Std(), g.DirDefault); err != nil {
+			return g.Err[*File](err)
+		}
+	}
+
+	return g.Ok(f)
+}
diff --git a/backend/vendor/github.com/enetx/g/int_checked.go b/backend/vendor/github.com/enetx/g/int_checked.go
new file mode 100644
index 00000000..726df9e5
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/int_checked.go
@@ -0,0 +1,196 @@
+package g
+
+import "math"
+
+// CheckedAdd adds two Ints, returning None if the addition overflows.
+func (i Int) CheckedAdd(b Int) Option[Int] {
+	sum := i + b
+	if (b > 0 && sum < i) || (b < 0 && sum > i) {
+		return None[Int]()
+	}
+
+	return Some(sum)
+}
+
+// CheckedSub subtracts b from the Int, returning None if the subtraction overflows.
+func (i Int) CheckedSub(b Int) Option[Int] {
+	diff := i - b
+	if (b < 0 && diff < i) || (b > 0 && diff > i) {
+		return None[Int]()
+	}
+
+	return Some(diff)
+}
+
+// CheckedMul multiplies two Ints, returning None if the multiplication overflows.
+func (i Int) CheckedMul(b Int) Option[Int] {
+	if i == 0 || b == 0 {
+		return Some(Int(0))
+	}
+
+	if i == -1 {
+		return b.CheckedNeg()
+	}
+
+	if b == -1 {
+		return i.CheckedNeg()
+	}
+
+	c := i * b
+	if c/b != i {
+		return None[Int]()
+	}
+
+	return Some(c)
+}
+
+// CheckedDiv divides the Int by b, returning None if b is zero or the division overflows.
+func (i Int) CheckedDiv(b Int) Option[Int] {
+	if b == 0 || (i == math.MinInt && b == -1) {
+		return None[Int]()
+	}
+
+	return Some(i / b)
+}
+
+// CheckedRem computes the remainder of the Int divided by b, returning None if b is zero
+// or the operation overflows (i == MinInt and b == -1).
+func (i Int) CheckedRem(b Int) Option[Int] {
+	if b == 0 || (i == math.MinInt && b == -1) {
+		return None[Int]()
+	}
+
+	return Some(i % b)
+}
+
+// CheckedNeg negates the Int, returning None if the negation overflows (i == MinInt).
+func (i Int) CheckedNeg() Option[Int] {
+	if i == math.MinInt {
+		return None[Int]()
+	}
+
+	return Some(-i)
+}
+
+// CheckedAbs returns the absolute value of the Int, returning None if it overflows (i == MinInt).
+func (i Int) CheckedAbs() Option[Int] {
+	if i == math.MinInt {
+		return None[Int]()
+	}
+
+	if i < 0 {
+		return Some(-i)
+	}
+
+	return Some(i)
+}
+
+// CheckedPow raises the Int to the power of exp using exponentiation by squaring,
+// returning None if exp is negative or the computation overflows. An exp of zero yields Some(1).
+func (i Int) CheckedPow(exp Int) Option[Int] {
+	if exp < 0 {
+		return None[Int]()
+	}
+
+	result, base := Int(1), i
+
+	for exp > 0 {
+		if exp&1 == 1 {
+			r := result.CheckedMul(base)
+			if r.IsNone() {
+				return None[Int]()
+			}
+
+			result = r.Some()
+		}
+
+		exp >>= 1
+
+		if exp > 0 {
+			b := base.CheckedMul(base)
+			if b.IsNone() {
+				return None[Int]()
+			}
+
+			base = b.Some()
+		}
+	}
+
+	return Some(result)
+}
+
+// SaturatingAdd adds two Ints, clamping the result to MinInt or MaxInt on overflow.
+func (i Int) SaturatingAdd(b Int) Int {
+	sum := i + b
+	if b > 0 && sum < i {
+		return math.MaxInt
+	}
+
+	if b < 0 && sum > i {
+		return math.MinInt
+	}
+
+	return sum
+}
+
+// SaturatingSub subtracts b from the Int, clamping the result to MinInt or MaxInt on overflow.
+func (i Int) SaturatingSub(b Int) Int {
+	diff := i - b
+	if b < 0 && diff < i {
+		return math.MaxInt
+	}
+
+	if b > 0 && diff > i {
+		return math.MinInt
+	}
+
+	return diff
+}
+
+// SaturatingMul multiplies two Ints, clamping the result to MinInt or MaxInt on overflow.
+func (i Int) SaturatingMul(b Int) Int {
+	if c := i.CheckedMul(b); c.IsSome() {
+		return c.Some()
+	}
+
+	if (i > 0) == (b > 0) {
+		return math.MaxInt
+	}
+
+	return math.MinInt
+}
+
+// OverflowingAdd adds two Ints, returning the wrapped result and a flag indicating overflow.
+func (i Int) OverflowingAdd(b Int) (Int, bool) {
+	sum := i + b
+
+	return sum, (b > 0 && sum < i) || (b < 0 && sum > i)
+}
+
+// OverflowingSub subtracts b from the Int, returning the wrapped result and a flag indicating overflow.
+func (i Int) OverflowingSub(b Int) (Int, bool) {
+	diff := i - b
+
+	return diff, (b < 0 && diff < i) || (b > 0 && diff > i)
+}
+
+// OverflowingMul multiplies two Ints, returning the wrapped result and a flag indicating overflow.
+func (i Int) OverflowingMul(b Int) (Int, bool) {
+	return i * b, i.CheckedMul(b).IsNone()
+}
+
+// Clamp restricts the Int to the inclusive range [min, max].
+// The caller must ensure min <= max: this method does not
+// panic on an inverted range — the lower bound is checked first, so the result
+// is unspecified when min > max.
+func (i Int) Clamp(min, max Int) Int {
+	if i < min {
+		return min
+	}
+
+	if i > max {
+		return max
+	}
+
+	return i
+}
diff --git a/backend/vendor/github.com/enetx/g/internal/mimesniff/sniff.go b/backend/vendor/github.com/enetx/g/internal/mimesniff/sniff.go
new file mode 100644
index 00000000..b2d8498e
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/internal/mimesniff/sniff.go
@@ -0,0 +1,314 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+
+// Package mimesniff is a verbatim copy of the Go standard library's content
+// sniffer (`net/http/internal/sniff.go`), reproduced here under the Go BSD-3
+// licence; see the Go Authors copyright header at the top of this file.
+//
+// It exists so that fs.File.MimeType does not have to import net/http. That
+// one import would pull crypto/tls, crypto/x509 and the whole FIPS-140 tree
+// into the dependency closure of the fs package and everything that imports
+// it. The sniffer itself needs only bytes and encoding/binary.
+//
+// Keep this file a verbatim copy: it implements https://mimesniff.spec.whatwg.org/
+// and any local edit silently diverges File.MimeType from net/http's result.
+// To refresh it, re-copy from GOROOT and re-apply only the package clause.
+package mimesniff
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+// The algorithm uses at most SniffLen bytes to make its decision.
+const SniffLen = 512
+
+// DetectContentType implements the algorithm described
+// at https://mimesniff.spec.whatwg.org/ to determine the
+// Content-Type of the given data. It considers at most the
+// first 512 bytes of data. DetectContentType always returns
+// a valid MIME type: if it cannot determine a more specific one, it
+// returns "application/octet-stream".
+func DetectContentType(data []byte) string {
+	if len(data) > SniffLen {
+		data = data[:SniffLen]
+	}
+
+	// Index of the first non-whitespace byte in data.
+	firstNonWS := 0
+	for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
+	}
+
+	for _, sig := range sniffSignatures {
+		if ct := sig.match(data, firstNonWS); ct != "" {
+			return ct
+		}
+	}
+
+	return "application/octet-stream" // fallback
+}
+
+// isWS reports whether the provided byte is a whitespace byte (0xWS)
+// as defined in https://mimesniff.spec.whatwg.org/#terminology.
+func isWS(b byte) bool {
+	switch b {
+	case '\t', '\n', '\x0c', '\r', ' ':
+		return true
+	}
+	return false
+}
+
+// isTT reports whether the provided byte is a tag-terminating byte (0xTT)
+// as defined in https://mimesniff.spec.whatwg.org/#terminology.
+func isTT(b byte) bool {
+	switch b {
+	case ' ', '>':
+		return true
+	}
+	return false
+}
+
+type sniffSig interface {
+	// match returns the MIME type of the data, or "" if unknown.
+	match(data []byte, firstNonWS int) string
+}
+
+// Data matching the table in section 6.
+var sniffSignatures = []sniffSig{
+	htmlSig("<!DOCTYPE HTML"),
+	htmlSig("<HTML"),
+	htmlSig("<HEAD"),
+	htmlSig("<SCRIPT"),
+	htmlSig("<IFRAME"),
+	htmlSig("<H1"),
+	htmlSig("<DIV"),
+	htmlSig("<FONT"),
+	htmlSig("<TABLE"),
+	htmlSig("<A"),
+	htmlSig("<STYLE"),
+	htmlSig("<TITLE"),
+	htmlSig("<B"),
+	htmlSig("<BODY"),
+	htmlSig("<BR"),
+	htmlSig("<P"),
+	htmlSig("<!--"),
+	&maskedSig{
+		mask:   []byte("\xFF\xFF\xFF\xFF\xFF"),
+		pat:    []byte("<?xml"),
+		skipWS: true,
+		ct:     "text/xml; charset=utf-8"},
+	&exactSig{[]byte("%PDF-"), "application/pdf"},
+	&exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
+
+	// UTF BOMs.
+	&maskedSig{
+		mask: []byte("\xFF\xFF\x00\x00"),
+		pat:  []byte("\xFE\xFF\x00\x00"),
+		ct:   "text/plain; charset=utf-16be",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\x00\x00"),
+		pat:  []byte("\xFF\xFE\x00\x00"),
+		ct:   "text/plain; charset=utf-16le",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\x00"),
+		pat:  []byte("\xEF\xBB\xBF\x00"),
+		ct:   "text/plain; charset=utf-8",
+	},
+
+	// Image types
+	// For posterity, we originally returned "image/vnd.microsoft.icon" from
+	// https://tools.ietf.org/html/draft-ietf-websec-mime-sniff-03#section-7
+	// https://codereview.appspot.com/4746042
+	// but that has since been replaced with "image/x-icon" in Section 6.2
+	// of https://mimesniff.spec.whatwg.org/#matching-an-image-type-pattern
+	&exactSig{[]byte("\x00\x00\x01\x00"), "image/x-icon"},
+	&exactSig{[]byte("\x00\x00\x02\x00"), "image/x-icon"},
+	&exactSig{[]byte("BM"), "image/bmp"},
+	&exactSig{[]byte("GIF87a"), "image/gif"},
+	&exactSig{[]byte("GIF89a"), "image/gif"},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
+		pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
+		ct:   "image/webp",
+	},
+	&exactSig{[]byte("\x89PNG\x0D\x0A\x1A\x0A"), "image/png"},
+	&exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
+
+	// Audio and Video types
+	// Enforce the pattern match ordering as prescribed in
+	// https://mimesniff.spec.whatwg.org/#matching-an-audio-or-video-type-pattern
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
+		pat:  []byte("FORM\x00\x00\x00\x00AIFF"),
+		ct:   "audio/aiff",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF"),
+		pat:  []byte("ID3"),
+		ct:   "audio/mpeg",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\xFF"),
+		pat:  []byte("OggS\x00"),
+		ct:   "application/ogg",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),
+		pat:  []byte("MThd\x00\x00\x00\x06"),
+		ct:   "audio/midi",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
+		pat:  []byte("RIFF\x00\x00\x00\x00AVI "),
+		ct:   "video/avi",
+	},
+	&maskedSig{
+		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
+		pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
+		ct:   "audio/wave",
+	},
+	// 6.2.0.2. video/mp4
+	mp4Sig{},
+	// 6.2.0.3. video/webm
+	&exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
+
+	// Font types
+	&maskedSig{
+		// 34 NULL bytes followed by the string "LP"
+		pat: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00LP"),
+		// 34 NULL bytes followed by \xF\xF
+		mask: []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"),
+		ct:   "application/vnd.ms-fontobject",
+	},
+	&exactSig{[]byte("\x00\x01\x00\x00"), "font/ttf"},
+	&exactSig{[]byte("OTTO"), "font/otf"},
+	&exactSig{[]byte("ttcf"), "font/collection"},
+	&exactSig{[]byte("wOFF"), "font/woff"},
+	&exactSig{[]byte("wOF2"), "font/woff2"},
+
+	// Archive types
+	&exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
+	&exactSig{[]byte("PK\x03\x04"), "application/zip"},
+	// RAR's signatures are incorrectly defined by the MIME spec as per
+	//    https://github.com/whatwg/mimesniff/issues/63
+	// However, RAR Labs correctly defines it at:
+	//    https://www.rarlab.com/technote.htm#rarsign
+	// so we use the definition from RAR Labs.
+	// TODO: do whatever the spec ends up doing.
+	&exactSig{[]byte("Rar!\x1A\x07\x00"), "application/x-rar-compressed"},     // RAR v1.5-v4.0
+	&exactSig{[]byte("Rar!\x1A\x07\x01\x00"), "application/x-rar-compressed"}, // RAR v5+
+
+	&exactSig{[]byte("\x00\x61\x73\x6D"), "application/wasm"},
+
+	textSig{}, // should be last
+}
+
+type exactSig struct {
+	sig []byte
+	ct  string
+}
+
+func (e *exactSig) match(data []byte, firstNonWS int) string {
+	if bytes.HasPrefix(data, e.sig) {
+		return e.ct
+	}
+	return ""
+}
+
+type maskedSig struct {
+	mask, pat []byte
+	skipWS    bool
+	ct        string
+}
+
+func (m *maskedSig) match(data []byte, firstNonWS int) string {
+	// pattern matching algorithm section 6
+	// https://mimesniff.spec.whatwg.org/#pattern-matching-algorithm
+
+	if m.skipWS {
+		data = data[firstNonWS:]
+	}
+	if len(m.pat) != len(m.mask) {
+		return ""
+	}
+	if len(data) < len(m.pat) {
+		return ""
+	}
+	for i, pb := range m.pat {
+		maskedData := data[i] & m.mask[i]
+		if maskedData != pb {
+			return ""
+		}
+	}
+	return m.ct
+}
+
+type htmlSig []byte
+
+func (h htmlSig) match(data []byte, firstNonWS int) string {
+	data = data[firstNonWS:]
+	if len(data) < len(h)+1 {
+		return ""
+	}
+	for i, b := range h {
+		db := data[i]
+		if 'A' <= b && b <= 'Z' {
+			db &= 0xDF
+		}
+		if b != db {
+			return ""
+		}
+	}
+	// Next byte must be a tag-terminating byte(0xTT).
+	if !isTT(data[len(h)]) {
+		return ""
+	}
+	return "text/html; charset=utf-8"
+}
+
+var mp4ftype = []byte("ftyp")
+var mp4 = []byte("mp4")
+
+type mp4Sig struct{}
+
+func (mp4Sig) match(data []byte, firstNonWS int) string {
+	// https://mimesniff.spec.whatwg.org/#signature-for-mp4
+	// c.f. section 6.2.1
+	if len(data) < 12 {
+		return ""
+	}
+	boxSize := int(binary.BigEndian.Uint32(data[:4]))
+	if len(data) < boxSize || boxSize%4 != 0 {
+		return ""
+	}
+	if !bytes.Equal(data[4:8], mp4ftype) {
+		return ""
+	}
+	for st := 8; st < boxSize; st += 4 {
+		if st == 12 {
+			// Ignores the four bytes that correspond to the version number of the "major brand".
+			continue
+		}
+		if bytes.Equal(data[st:st+3], mp4) {
+			return "video/mp4"
+		}
+	}
+	return ""
+}
+
+type textSig struct{}
+
+func (textSig) match(data []byte, firstNonWS int) string {
+	// c.f. section 5, step 4.
+	for _, b := range data[firstNonWS:] {
+		switch {
+		case b <= 0x08,
+			b == 0x0B,
+			0x0E <= b && b <= 0x1A,
+			0x1C <= b && b <= 0x1F:
+			return ""
+		}
+	}
+	return "text/plain; charset=utf-8"
+}
diff --git a/backend/vendor/github.com/enetx/g/map_convert.go b/backend/vendor/github.com/enetx/g/map_convert.go
new file mode 100644
index 00000000..3cd0180f
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/map_convert.go
@@ -0,0 +1,80 @@
+package g
+
+// Conversions between the three map types live here as free functions rather
+// than methods. As methods they weld Map, MapOrd and MapSafe into one
+// instantiation cluster: any package touching one of them would compile the
+// methods of all three (and everything those methods mention, transitively).
+// As free functions each conversion costs only the packages that call it.
+
+// MapOrdFromMap converts a standard Map to an ordered Map.
+func MapOrdFromMap[K comparable, V any](m Map[K, V]) MapOrd[K, V] {
+	mo := make(MapOrd[K, V], 0, len(m))
+	for k, v := range m {
+		mo = append(mo, Pair[K, V]{Key: k, Value: v})
+	}
+
+	return mo
+}
+
+// MapSafeFromMap converts a standard Map to a thread-safe Map.
+func MapSafeFromMap[K comparable, V any](m Map[K, V]) *MapSafe[K, V] {
+	ms := NewMapSafe[K, V]()
+	for k, v := range m {
+		ms.Insert(k, v)
+	}
+
+	return ms
+}
+
+// MapFromMapOrd converts an ordered Map to a standard Map.
+func MapFromMapOrd[K comparable, V any](mo MapOrd[K, V]) Map[K, V] {
+	m := NewMap[K, V](mo.Len())
+	for _, p := range mo {
+		m[p.Key] = p.Value
+	}
+
+	return m
+}
+
+// MapSafeFromMapOrd converts an ordered Map to a thread-safe Map.
+func MapSafeFromMapOrd[K comparable, V any](mo MapOrd[K, V]) *MapSafe[K, V] {
+	ms := NewMapSafe[K, V]()
+	for _, p := range mo {
+		ms.Insert(p.Unpack())
+	}
+
+	return ms
+}
+
+// MapFromMapSafe converts the MapSafe to a standard Map by taking a snapshot of its
+// current key-value pairs.
+//
+// The returned Map is an independent, non-thread-safe copy; subsequent
+// mutations to the MapSafe are not reflected in it.
+func MapFromMapSafe[K comparable, V any](ms *MapSafe[K, V]) Map[K, V] {
+	m := NewMap[K, V](ms.Len())
+
+	ms.data.Range(func(key, value any) bool {
+		m[key.(K)] = *(value.(*V))
+		return true
+	})
+
+	return m
+}
+
+// MapOrdFromMapSafe converts the MapSafe to an ordered Map by taking a snapshot of its
+// current key-value pairs.
+//
+// Because MapSafe does not track insertion order, the order of the returned
+// MapOrd is unspecified. The returned MapOrd is an independent, non-thread-safe
+// copy; subsequent mutations to the MapSafe are not reflected in it.
+func MapOrdFromMapSafe[K comparable, V any](ms *MapSafe[K, V]) MapOrd[K, V] {
+	mo := NewMapOrd[K, V](ms.Len())
+
+	ms.data.Range(func(key, value any) bool {
+		mo = append(mo, Pair[K, V]{Key: key.(K), Value: *(value.(*V))})
+		return true
+	})
+
+	return mo
+}
diff --git a/backend/vendor/github.com/enetx/g/mutex.go b/backend/vendor/github.com/enetx/g/mutex.go
new file mode 100644
index 00000000..db14a75f
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/mutex.go
@@ -0,0 +1,68 @@
+package g
+
+import "sync"
+
+// Mutex is a mutual exclusion lock that protects a value of type T.
+// Unlike sync.Mutex, it binds the protected data to the lock itself,
+// making it impossible to access the data without holding the lock.
+//
+// A Mutex must not be copied after first use: it embeds a sync.Mutex and a
+// copy would protect a different value than the original (go vet's copylocks
+// analyzer flags such copies). Always pass a *Mutex, never a Mutex by value.
+type Mutex[T any] struct {
+	mu  sync.Mutex
+	val T
+}
+
+// MutexGuard provides access to the value protected by a Mutex.
+// The guard must be explicitly unlocked when done.
+//
+// A guard holds pointers into its owning Mutex; copying the guard and calling
+// Unlock on more than one copy unlocks the same underlying lock twice, which
+// panics. Use each guard exactly once and do not copy it.
+type MutexGuard[T any] struct {
+	mu  *sync.Mutex
+	val *T
+}
+
+// NewMutex creates a new Mutex containing the given value.
+func NewMutex[T any](value T) *Mutex[T] { return &Mutex[T]{val: value} }
+
+// Lock acquires the mutex and returns a guard that provides access to the protected value.
+// The caller must call Unlock on the guard when done (typically via defer).
+func (m *Mutex[T]) Lock() MutexGuard[T] {
+	m.mu.Lock()
+	return MutexGuard[T]{mu: &m.mu, val: &m.val}
+}
+
+// With acquires the mutex, calls fn with a pointer to the protected value,
+// and releases the mutex when fn returns.
+// This is a convenience method that eliminates the need for manual Lock/Unlock management.
+func (m *Mutex[T]) With(fn func(*T)) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	fn(&m.val)
+}
+
+// TryLock attempts to acquire the mutex without blocking.
+// Returns Some(guard) if successful, None if the mutex is already locked.
+func (m *Mutex[T]) TryLock() Option[MutexGuard[T]] {
+	if m.mu.TryLock() {
+		return Some(MutexGuard[T]{mu: &m.mu, val: &m.val})
+	}
+
+	return None[MutexGuard[T]]()
+}
+
+// Get returns a copy of the protected value.
+func (g MutexGuard[T]) Get() T { return *g.val }
+
+// Set replaces the protected value with a new one.
+func (g MutexGuard[T]) Set(value T) { *g.val = value }
+
+// Deref returns a pointer to the protected value for direct manipulation.
+func (g MutexGuard[T]) Deref() *T { return g.val }
+
+// Unlock releases the mutex. Must be called when done with the guard.
+func (g MutexGuard[T]) Unlock() { g.mu.Unlock() }
diff --git a/backend/vendor/github.com/enetx/g/option_json.go b/backend/vendor/github.com/enetx/g/option_json.go
new file mode 100644
index 00000000..d4dff091
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/option_json.go
@@ -0,0 +1,91 @@
+package g
+
+import (
+	"encoding/json/jsontext"
+	json "encoding/json/v2"
+)
+
+// jsonNull is the JSON literal returned when marshaling a None Option.
+// It is a package-level value to avoid allocating a new []byte on every None marshal.
+//
+// NOTE: callers (encoding/json) must not mutate the returned slice; the standard
+// library treats Marshaler output as read-only, so sharing this backing array is safe.
+var jsonNull = []byte("null")
+
+// MarshalJSON implements the json.Marshaler interface (encoding/json v1) for Option[T].
+// Some(value) is marshaled as the JSON representation of value.
+// None is marshaled as null.
+//
+// BREAKING: the implementation is backed by encoding/json/v2, which changes some
+// edge-case semantics compared to the previous encoding/json implementation:
+//   - Some of a nil slice marshals as [] and Some of a nil map marshals as {},
+//     rather than null.
+//   - Strings containing invalid UTF-8 are rejected with an error instead of
+//     being silently replaced with U+FFFD.
+func (o Option[T]) MarshalJSON() ([]byte, error) {
+	if o.IsNone() {
+		return jsonNull, nil
+	}
+
+	return json.Marshal(o.v)
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface (encoding/json v1) for Option[T].
+// JSON null is unmarshaled as None.
+// Any other valid JSON value is unmarshaled as Some(value).
+//
+// BREAKING: the implementation is backed by encoding/json/v2, which is stricter
+// than the previous encoding/json implementation: duplicate object keys inside
+// the value are rejected, struct field names match case-sensitively, and strings
+// containing invalid UTF-8 are rejected.
+func (o *Option[T]) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		*o = None[T]()
+		return nil
+	}
+
+	var v T
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+
+	*o = Some(v)
+	return nil
+}
+
+// MarshalJSONTo implements the json.MarshalerTo interface (encoding/json/v2) for Option[T].
+// encoding/json/v2 prefers this method over MarshalJSON.
+// Some(value) is encoded as the JSON representation of value; None is encoded as null.
+//
+// Because None and JSON null share one representation, nested Options collapse:
+// Some(None) marshals to null and unmarshals back as None. Wrap the inner
+// Option in a struct (or use Result) when the distinction must survive a round trip.
+func (o Option[T]) MarshalJSONTo(enc *jsontext.Encoder) error {
+	if o.IsNone() {
+		return enc.WriteToken(jsontext.Null)
+	}
+
+	return json.MarshalEncode(enc, o.v)
+}
+
+// UnmarshalJSONFrom implements the json.UnmarshalerFrom interface (encoding/json/v2) for Option[T].
+// encoding/json/v2 prefers this method over UnmarshalJSON.
+// JSON null is decoded as None; any other value is decoded into T as Some(value).
+func (o *Option[T]) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
+	if dec.PeekKind() == 'n' {
+		if _, err := dec.ReadToken(); err != nil {
+			return err
+		}
+
+		*o = None[T]()
+		return nil
+	}
+
+	var v T
+	if err := json.UnmarshalDecode(dec, &v); err != nil {
+		return err
+	}
+
+	*o = Some(v)
+	return nil
+}
diff --git a/backend/vendor/github.com/enetx/g/option_sql.go b/backend/vendor/github.com/enetx/g/option_sql.go
new file mode 100644
index 00000000..3e63d277
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/option_sql.go
@@ -0,0 +1,239 @@
+package g
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"fmt"
+	"math"
+	"time"
+)
+
+// Scan implements the database/sql.Scanner interface for Option[T].
+//
+// Behavior:
+//   - If src is nil, the Option is set to None (SQL NULL).
+//   - If T implements sql.Scanner, its Scan method is used.
+//   - If src can be directly assigned to T, it is assigned as-is.
+//   - Otherwise, common database type conversions are attempted (e.g., int64 → int, []byte → string).
+//
+// Supported conversions (common SQL types):
+//   - INTEGER    → int, int8, int16, int32, int64, uint*
+//   - REAL       → float32, float64
+//   - TEXT       → string, []byte
+//   - BLOB       → []byte
+//   - BOOLEAN    → bool
+//   - TIMESTAMP  → time.Time
+//
+// Driver-owned []byte buffers (BLOB/TEXT) are copied before being stored, so the
+// scanned Option keeps a value that is safe to retain across subsequent rows
+// (per the database/sql Scanner contract).
+//
+// Returns an error if the value cannot be converted to T.
+func (o *Option[T]) Scan(src any) error {
+	if src == nil {
+		*o = None[T]()
+		return nil
+	}
+
+	var v T
+
+	if scanner, ok := any(&v).(sql.Scanner); ok {
+		if err := scanner.Scan(src); err != nil {
+			return err
+		}
+		*o = Some(v)
+		return nil
+	}
+
+	if val, ok := src.(T); ok {
+		// Copy driver-owned []byte buffers before storing: database/sql may
+		// overwrite the backing array on the next row (database/sql contract).
+		if b, isBytes := any(val).([]byte); isBytes {
+			val = any(append([]byte(nil), b...)).(T)
+		}
+		*o = Some(val)
+		return nil
+	}
+
+	if converted, ok := convertToT[T](src); ok {
+		*o = Some(converted)
+		return nil
+	}
+
+	return fmt.Errorf("Option.Scan: cannot scan %T into %T", src, v)
+}
+
+// Value implements the database/sql/driver.Valuer interface for Option[T].
+//
+// Behavior:
+//   - If the Option is None, returns nil (SQL NULL).
+//   - If T implements driver.Valuer, its Value method is used.
+//   - If the underlying value is already a valid driver.Value type (int64, float64, bool, []byte, string, time.Time), it is returned directly.
+//   - Otherwise, safe conversions are applied (int → int64, uint → int64, float32 → float64).
+//
+// Returns an error if the value cannot be converted to a driver.Value.
+func (o Option[T]) Value() (driver.Value, error) {
+	if o.IsNone() {
+		return nil, nil
+	}
+
+	if valuer, ok := any(o.v).(driver.Valuer); ok {
+		return valuer.Value()
+	}
+
+	switch val := any(o.v).(type) {
+	case int64, float64, bool, []byte, string, time.Time:
+		return val, nil
+	default:
+		if converted, ok := convertToDriverValue(val); ok {
+			return converted, nil
+		}
+	}
+
+	return nil, fmt.Errorf("Option.Value: unsupported type %T", o.v)
+}
+
+// convertToT attempts to safely convert a source value from database/sql
+// into type T, supporting common database types without using reflection.
+//
+// Only standard Go primitive types are supported:
+//   - int64 → int, int8, int16, int32, uint*, uint64 (if fits)
+//   - float64 → float32, float64
+//   - string / []byte → string
+//   - []byte / string → []byte
+//   - bool → bool
+//   - time.Time → time.Time
+//
+// Returns the converted value and true on success, otherwise the zero value of T and false.
+func convertToT[T any](src any) (T, bool) {
+	var zero T
+
+	switch any(zero).(type) {
+	case int:
+		if i64, ok := src.(int64); ok && fitsInt(i64) {
+			return any(int(i64)).(T), true
+		}
+	case int8:
+		if i64, ok := src.(int64); ok && fitsInt8(i64) {
+			return any(int8(i64)).(T), true
+		}
+	case int16:
+		if i64, ok := src.(int64); ok && fitsInt16(i64) {
+			return any(int16(i64)).(T), true
+		}
+	case int32:
+		if i64, ok := src.(int64); ok && fitsInt32(i64) {
+			return any(int32(i64)).(T), true
+		}
+	case int64:
+		if i64, ok := src.(int64); ok {
+			return any(i64).(T), true
+		}
+	case uint:
+		if i64, ok := src.(int64); ok && i64 >= 0 {
+			return any(uint(i64)).(T), true
+		}
+	case uint8:
+		if i64, ok := src.(int64); ok && i64 >= 0 && i64 <= math.MaxUint8 {
+			return any(uint8(i64)).(T), true
+		}
+	case uint16:
+		if i64, ok := src.(int64); ok && i64 >= 0 && i64 <= math.MaxUint16 {
+			return any(uint16(i64)).(T), true
+		}
+	case uint32:
+		if i64, ok := src.(int64); ok && i64 >= 0 && i64 <= math.MaxUint32 {
+			return any(uint32(i64)).(T), true
+		}
+	case uint64:
+		if i64, ok := src.(int64); ok && i64 >= 0 {
+			return any(uint64(i64)).(T), true
+		}
+	case float32:
+		if f64, ok := src.(float64); ok {
+			return any(float32(f64)).(T), true
+		}
+	case float64:
+		if f64, ok := src.(float64); ok {
+			return any(f64).(T), true
+		}
+	case string:
+		switch v := src.(type) {
+		case string:
+			return any(v).(T), true
+		case []byte:
+			return any(string(v)).(T), true
+		}
+	case []byte:
+		switch v := src.(type) {
+		case []byte:
+			// Copy the driver-owned buffer: database/sql may reuse it on the next row.
+			return any(append([]byte(nil), v...)).(T), true
+		case string:
+			return any([]byte(v)).(T), true
+		}
+	case bool:
+		if b, ok := src.(bool); ok {
+			return any(b).(T), true
+		}
+	case time.Time:
+		if t, ok := src.(time.Time); ok {
+			return any(t).(T), true
+		}
+	}
+
+	return zero, false
+}
+
+// convertToDriverValue safely converts primitive Go types to a value
+// compatible with database/sql driver.Value.
+//
+// Supported conversions:
+//   - int, int8, int16, int32 → int64
+//   - uint8, uint16, uint32 → int64
+//   - uint, uint64 → int64 (only if <= math.MaxInt64)
+//   - float32 → float64
+//
+// Returns the converted value and true on success, otherwise nil and false.
+func convertToDriverValue(val any) (driver.Value, bool) {
+	switch v := val.(type) {
+	case int:
+		return int64(v), true
+	case int8:
+		return int64(v), true
+	case int16:
+		return int64(v), true
+	case int32:
+		return int64(v), true
+	case uint:
+		if uint64(v) <= math.MaxInt64 {
+			return int64(v), true
+		}
+	case uint8:
+		return int64(v), true
+	case uint16:
+		return int64(v), true
+	case uint32:
+		return int64(v), true
+	case uint64:
+		if v <= math.MaxInt64 {
+			return int64(v), true
+		}
+	case float32:
+		return float64(v), true
+	}
+
+	return nil, false
+}
+
+// fitsInt returns true if i fits in a Go int.
+func fitsInt(i int64) bool { return i >= math.MinInt && i <= math.MaxInt }
+
+// fitsInt8 returns true if i fits in an int8.
+func fitsInt8(i int64) bool { return i >= math.MinInt8 && i <= math.MaxInt8 }
+
+// fitsInt16 returns true if i fits in an int16.
+func fitsInt16(i int64) bool { return i >= math.MinInt16 && i <= math.MaxInt16 }
+
+// fitsInt32 returns true if i fits in an int32.
+func fitsInt32(i int64) bool { return i >= math.MinInt32 && i <= math.MaxInt32 }
diff --git a/backend/vendor/github.com/enetx/g/print_fmt.go b/backend/vendor/github.com/enetx/g/print_fmt.go
new file mode 100644
index 00000000..044a03a5
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/print_fmt.go
@@ -0,0 +1,1038 @@
+package g
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"unicode/utf8"
+)
+
+type fmtAlign int
+
+const (
+	alignNone   fmtAlign = iota
+	alignLeft            // '<'
+	alignRight           // '>'
+	alignCenter          // '^'
+)
+
+type fmtSign int
+
+const (
+	signNone  fmtSign = iota
+	signPlus          // '+'
+	signMinus         // '-'
+	signSpace         // ' '
+)
+
+type fmtSpec struct {
+	fill      rune
+	align     fmtAlign
+	sign      fmtSign
+	alternate bool
+	zeroPad   bool
+	width     Int
+	precision Int
+	verb      byte
+}
+
+func splitFmtSpec(placeholder String) (String, String) {
+	if i := findUnparenColon(placeholder); i >= 0 {
+		return placeholder[:i], placeholder[i+1:]
+	}
+
+	return placeholder, ""
+}
+
+func findUnparenColon(placeholder String) Int {
+	depth := 0
+
+	for i := Int(0); i < placeholder.Len(); i++ {
+		switch placeholder[i] {
+		case '(':
+			depth++
+		case ')':
+			depth--
+		case ':':
+			if depth == 0 {
+				return i
+			}
+		}
+	}
+
+	return -1
+}
+
+// maxFmtDigits caps the accumulated width/precision value to avoid huge
+// allocations or integer overflow on absurd inputs like {:99999999999999999999}.
+// 1<<20 is far larger than any reasonable field width while staying well below
+// int range on every platform.
+const maxFmtDigits = 1 << 20
+
+func parseDigits(runes []rune, pos int) (int, int, bool) {
+	n, has := 0, false
+
+	for pos < len(runes) && runes[pos] >= '0' && runes[pos] <= '9' {
+		if n <= maxFmtDigits {
+			n = min(n*10+int(runes[pos]-'0'), maxFmtDigits)
+		}
+
+		pos++
+		has = true
+	}
+
+	return n, pos, has
+}
+
+func validFmtSpec(spec String) bool {
+	runes := []rune(spec)
+	pos := 0
+
+	if pos < len(runes) {
+		if pos+1 < len(runes) && isAlign(runes[pos+1]) {
+			pos += 2
+		} else if isAlign(runes[pos]) {
+			pos++
+		}
+	}
+
+	if pos < len(runes) && (runes[pos] == '+' || runes[pos] == '-' || runes[pos] == ' ') {
+		pos++
+	}
+
+	if pos < len(runes) && runes[pos] == '#' {
+		pos++
+	}
+
+	if pos < len(runes) && runes[pos] == '0' {
+		pos++
+	}
+
+	_, pos, _ = parseDigits(runes, pos)
+	if pos < len(runes) && runes[pos] == '.' {
+		pos++
+		_, pos, _ = parseDigits(runes, pos)
+	}
+
+	if pos == len(runes) {
+		return true
+	}
+
+	verb := runes[pos]
+
+	pos++
+	if pos != len(runes) {
+		return false
+	}
+
+	switch verb {
+	case 'd', 'c', 'q', 'U', 'x', 'X', 'o', 'b', 'e', 'E', 'T', 'p', '?', 'w', 's', 'f':
+		return true
+	default:
+		return false
+	}
+}
+
+func parseFmtSpec(spec String) fmtSpec {
+	if isASCIIFmtSpec(spec) {
+		return parseASCIIFmtSpec(spec)
+	}
+
+	return parseRuneFmtSpec(spec)
+}
+
+func isASCIIFmtSpec(spec String) bool {
+	for i := Int(0); i < spec.Len(); i++ {
+		if spec[i] >= utf8.RuneSelf {
+			return false
+		}
+	}
+
+	return true
+}
+
+func parseASCIIDigits(spec String, pos Int) (int, Int, bool) {
+	n, has := 0, false
+	for pos < spec.Len() && spec[pos] >= '0' && spec[pos] <= '9' {
+		if n <= maxFmtDigits {
+			n = min(n*10+int(spec[pos]-'0'), maxFmtDigits)
+		}
+
+		pos++
+		has = true
+	}
+
+	return n, pos, has
+}
+
+func parseASCIIFmtSpec(spec String) fmtSpec {
+	fs := fmtSpec{fill: ' ', width: -1, precision: -1}
+	pos := Int(0)
+
+	if pos < spec.Len() {
+		if pos+1 < spec.Len() && isAlign(rune(spec[pos+1])) {
+			fs.fill = rune(spec[pos])
+			fs.align = toAlign(rune(spec[pos+1]))
+			pos += 2
+		} else if isAlign(rune(spec[pos])) {
+			fs.align = toAlign(rune(spec[pos]))
+			pos++
+		}
+	}
+
+	if pos < spec.Len() {
+		switch spec[pos] {
+		case '+':
+			fs.sign = signPlus
+			pos++
+		case '-':
+			fs.sign = signMinus
+			pos++
+		case ' ':
+			fs.sign = signSpace
+			pos++
+		}
+	}
+
+	if pos < spec.Len() && spec[pos] == '#' {
+		fs.alternate = true
+		pos++
+	}
+
+	if pos < spec.Len() && spec[pos] == '0' && fs.align == alignNone {
+		fs.zeroPad = true
+		pos++
+	}
+
+	if n, next, ok := parseASCIIDigits(spec, pos); ok {
+		fs.width, pos = Int(n), next
+	}
+
+	if pos < spec.Len() && spec[pos] == '.' {
+		pos++
+		if n, next, ok := parseASCIIDigits(spec, pos); ok {
+			fs.precision, pos = Int(n), next
+		} else {
+			fs.precision = 0
+		}
+	}
+
+	if pos < spec.Len() {
+		fs.verb = spec[pos]
+	}
+
+	return fs
+}
+
+func parseRuneFmtSpec(spec String) fmtSpec {
+	fs := fmtSpec{fill: ' ', width: -1, precision: -1}
+
+	runes := []rune(spec)
+	pos := 0
+
+	// parse [[fill]align]
+	if pos < len(runes) {
+		if pos+1 < len(runes) && isAlign(runes[pos+1]) {
+			fs.fill = runes[pos]
+			fs.align = toAlign(runes[pos+1])
+			pos += 2
+		} else if isAlign(runes[pos]) {
+			fs.align = toAlign(runes[pos])
+			pos++
+		}
+	}
+
+	// parse [sign]
+	if pos < len(runes) {
+		switch runes[pos] {
+		case '+':
+			fs.sign = signPlus
+			pos++
+		case '-':
+			fs.sign = signMinus
+			pos++
+		case ' ':
+			fs.sign = signSpace
+			pos++
+		}
+	}
+
+	// parse [#]
+	if pos < len(runes) && runes[pos] == '#' {
+		fs.alternate = true
+		pos++
+	}
+
+	// parse [0]
+	if pos < len(runes) && runes[pos] == '0' && fs.align == alignNone {
+		fs.zeroPad = true
+		pos++
+	}
+
+	// parse [width]
+	if n, np, ok := parseDigits(runes, pos); ok {
+		fs.width = Int(n)
+		pos = np
+	}
+
+	// parse [.precision]
+	if pos < len(runes) && runes[pos] == '.' {
+		pos++
+
+		if n, np, ok := parseDigits(runes, pos); ok {
+			fs.precision = Int(n)
+			pos = np
+		} else {
+			fs.precision = 0
+		}
+	}
+
+	// parse [type]
+	if pos < len(runes) {
+		fs.verb = byte(runes[pos])
+	}
+
+	return fs
+}
+
+func isAlign(r rune) bool { return r == '<' || r == '>' || r == '^' }
+
+func toAlign(r rune) fmtAlign {
+	switch r {
+	case '<':
+		return alignLeft
+	case '>':
+		return alignRight
+	default:
+		return alignCenter
+	}
+}
+
+func applyFmtSpec(value any, spec fmtSpec) String {
+	var s String
+
+	switch spec.verb {
+	case 'd':
+		s = fmtDecimal(value, spec)
+	case 'c':
+		s = fmtCharacter(value)
+	case 'q':
+		s = fmtQuoted(value)
+	case 'U':
+		s = fmtUnicode(value, spec.alternate)
+	case 'x':
+		s = fmtIntBase(value, 16, fmtAltPrefix("0x", spec), spec, false)
+	case 'X':
+		s = fmtIntBase(value, 16, fmtAltPrefix("0x", spec), spec, true)
+	case 'o':
+		s = fmtIntBase(value, 8, fmtAltPrefix("0o", spec), spec, false)
+	case 'b':
+		s = fmtIntBase(value, 2, fmtAltPrefix("0b", spec), spec, false)
+	case 'e':
+		s = fmtExponential(value, spec, 'e')
+	case 'E':
+		s = fmtExponential(value, spec, 'E')
+	case 'T':
+		s = String(fmt.Sprintf("%T", value))
+	case 'p':
+		s = String(fmt.Sprintf("%p", value))
+	case '?':
+		if spec.alternate {
+			s = fmtPrettyDebug(value)
+		} else {
+			s = String(fmt.Sprintf("%#v", value))
+		}
+	default:
+		s = fmtDefault(value, spec)
+	}
+
+	return fmtPad(s, spec, fmtIsNumeric(value))
+}
+
+func tryAppendNativeSpec(builder *Builder, value any, spec fmtSpec) bool {
+	return tryAppendNativeIntSpec(builder, value, spec) ||
+		tryAppendNativeTextSpec(builder, value, spec)
+}
+
+// tryAppendNativeIntSpec handles the common integer representations directly in
+// the destination builder. It avoids the temporary strings otherwise produced
+// by strconv.Format*, sign/prefix concatenation, and padding.
+func tryAppendNativeIntSpec(builder *Builder, value any, spec fmtSpec) bool {
+	base := 10
+	prefix := String("")
+	upper := false
+
+	switch spec.verb {
+	case 'd':
+	case 'x':
+		base = 16
+		if spec.alternate {
+			prefix = "0x"
+		}
+	case 'X':
+		base, upper = 16, true
+		if spec.alternate {
+			prefix = "0x"
+		}
+	case 'o':
+		base = 8
+		if spec.alternate {
+			prefix = "0o"
+		}
+	case 'b':
+		base = 2
+		if spec.alternate {
+			prefix = "0b"
+		}
+	default:
+		return false
+	}
+
+	var storage [128]byte
+	digits := storage[:0]
+	negative := false
+	if u, ok := fmtToUint64(value); ok {
+		digits = strconv.AppendUint(digits, u, base)
+	} else if i, ok := fmtToInt64(value); ok {
+		negative = i < 0
+		if negative {
+			// -(i+1)+1 is safe for MinInt64.
+			digits = strconv.AppendUint(digits, uint64(-(i+1))+1, base)
+		} else {
+			digits = strconv.AppendUint(digits, uint64(i), base)
+		}
+	} else {
+		return false
+	}
+
+	if upper {
+		for i, ch := range digits {
+			if ch >= 'a' && ch <= 'f' {
+				digits[i] = ch - ('a' - 'A')
+			}
+		}
+	}
+
+	var sign byte
+	if negative {
+		sign = '-'
+	} else if spec.sign == signPlus {
+		sign = '+'
+	} else if spec.sign == signSpace {
+		sign = ' '
+	}
+
+	contentLen := Int(len(digits)) + prefix.Len()
+	if sign != 0 {
+		contentLen++
+	}
+	padding := Int(0)
+	if spec.width > contentLen {
+		padding = spec.width - contentLen
+	}
+
+	if spec.zeroPad && spec.align == alignNone {
+		if sign != 0 {
+			builder.WriteByte(sign)
+		}
+		builder.WriteString(prefix)
+		for range padding {
+			builder.WriteByte('0')
+		}
+		builder.Write(digits)
+		return true
+	}
+
+	align := spec.align
+	if align == alignNone {
+		align = alignRight
+	}
+
+	left, right := Int(0), Int(0)
+	switch align {
+	case alignLeft:
+		right = padding
+	case alignRight:
+		left = padding
+	default:
+		left = padding / 2
+		right = padding - left
+	}
+
+	for range left {
+		builder.WriteRune(spec.fill)
+	}
+
+	if sign != 0 {
+		builder.WriteByte(sign)
+	}
+
+	builder.WriteString(prefix)
+	builder.Write(digits)
+
+	for range right {
+		builder.WriteRune(spec.fill)
+	}
+
+	return true
+}
+
+// tryAppendNativeTextSpec writes character, quoted, and Unicode representations
+// without allocating intermediate strings.
+func tryAppendNativeTextSpec(builder *Builder, value any, spec fmtSpec) bool {
+	var storage [128]byte
+	content := storage[:0]
+
+	switch spec.verb {
+	case 'c':
+		r, ok := fmtToRune(value)
+		if !ok {
+			return false
+		}
+		content = utf8.AppendRune(content, r)
+	case 'q':
+		switch v := value.(type) {
+		case string:
+			content = strconv.AppendQuote(content, v)
+		case String:
+			content = strconv.AppendQuote(content, v.Std())
+		case []byte:
+			content = strconv.AppendQuote(content, string(v))
+		case Bytes:
+			content = strconv.AppendQuote(content, string(v))
+		default:
+			r, ok := fmtToRune(value)
+			if !ok {
+				return false
+			}
+			content = strconv.AppendQuoteRune(content, r)
+		}
+	case 'U':
+		r, ok := fmtToRune(value)
+		if !ok || !utf8.ValidRune(r) {
+			return false
+		}
+		content = append(content, 'U', '+')
+		var digits [8]byte
+		hex := strconv.AppendInt(digits[:0], int64(r), 16)
+		for padding := 4 - len(hex); padding > 0; padding-- {
+			content = append(content, '0')
+		}
+		for _, ch := range hex {
+			if ch >= 'a' && ch <= 'f' {
+				ch -= 'a' - 'A'
+			}
+			content = append(content, ch)
+		}
+		if spec.alternate && strconv.IsPrint(r) {
+			content = append(content, ' ')
+			content = strconv.AppendQuoteRune(content, r)
+		}
+	default:
+		return false
+	}
+
+	appendNativePadded(builder, content, utf8.RuneCount(content), spec, fmtIsNumeric(value))
+	return true
+}
+
+func fmtToRune(value any) (rune, bool) {
+	if u, ok := fmtToUint64(value); ok {
+		return rune(u), true
+	}
+	if i, ok := fmtToSignedInt64(value); ok {
+		return rune(i), true
+	}
+	return 0, false
+}
+
+func appendNativePadded(builder *Builder, content []byte, runes int, spec fmtSpec, isNum bool) {
+	padding := spec.width - Int(runes)
+	if padding <= 0 {
+		builder.Write(content)
+		return
+	}
+
+	fill := spec.fill
+	align := spec.align
+	if spec.zeroPad && align == alignNone && isNum {
+		fill, align = '0', alignRight
+	} else if align == alignNone {
+		if isNum {
+			align = alignRight
+		} else {
+			align = alignLeft
+		}
+	}
+
+	left, right := Int(0), Int(0)
+	switch align {
+	case alignLeft:
+		right = padding
+	case alignRight:
+		left = padding
+	default:
+		left = padding / 2
+		right = padding - left
+	}
+
+	for range left {
+		builder.WriteRune(fill)
+	}
+	builder.Write(content)
+	for range right {
+		builder.WriteRune(fill)
+	}
+}
+
+func fmtDecimal(value any, spec fmtSpec) String {
+	if u, ok := fmtToUint64(value); ok {
+		return fmtApplySign(String(strconv.FormatUint(u, 10)), true, spec)
+	}
+
+	if i, ok := fmtToSignedInt64(value); ok {
+		s := String(strconv.FormatInt(i, 10))
+		return fmtApplySign(s, i >= 0, spec)
+	}
+
+	return String(fmt.Sprint(value))
+}
+
+func fmtCharacter(value any) String {
+	if u, ok := fmtToUint64(value); ok {
+		return String(string(rune(u)))
+	}
+
+	if i, ok := fmtToSignedInt64(value); ok {
+		return String(string(rune(i)))
+	}
+
+	return String(fmt.Sprintf("%c", value))
+}
+
+func fmtQuoted(value any) String {
+	switch v := value.(type) {
+	case string:
+		return String(strconv.Quote(v))
+	case String:
+		return String(strconv.Quote(v.Std()))
+	case []byte:
+		return String(strconv.Quote(string(v)))
+	case Bytes:
+		return String(strconv.Quote(string(v)))
+	}
+
+	if u, ok := fmtToUint64(value); ok {
+		return String(strconv.QuoteRune(rune(u)))
+	}
+
+	if i, ok := fmtToSignedInt64(value); ok {
+		return String(strconv.QuoteRune(rune(i)))
+	}
+
+	return String(fmt.Sprintf("%q", value))
+}
+
+func fmtUnicode(value any, alternate bool) String {
+	var r rune
+	if u, ok := fmtToUint64(value); ok {
+		r = rune(u)
+	} else if i, ok := fmtToSignedInt64(value); ok {
+		r = rune(i)
+	} else {
+		verb := "%U"
+		if alternate {
+			verb = "%#U"
+		}
+		return String(fmt.Sprintf(verb, value))
+	}
+
+	if alternate {
+		return String(fmt.Sprintf("%#U", r))
+	}
+
+	return String(fmt.Sprintf("%U", r))
+}
+
+func fmtAltPrefix(prefix String, spec fmtSpec) String {
+	if spec.alternate {
+		return prefix
+	}
+
+	return ""
+}
+
+func fmtIntBase(value any, base int, prefix String, spec fmtSpec, upper bool) String {
+	format := func(s String) String {
+		if upper {
+			return prefix + s.Upper()
+		}
+
+		return prefix + s
+	}
+
+	if u, ok := fmtToUint64(value); ok {
+		return format(String(strconv.FormatUint(u, base)))
+	}
+
+	if i, ok := fmtToInt64(value); ok {
+		s := format(String(strconv.FormatInt(abs64(i), base)))
+
+		if i < 0 {
+			return "-" + s
+		}
+
+		return fmtApplySign(s, true, spec)
+	}
+
+	return String(fmt.Sprint(value))
+}
+
+func fmtDefault(value any, spec fmtSpec) String {
+	prec := -1
+	if spec.precision >= 0 {
+		prec = spec.precision.Std()
+	}
+
+	if prec >= 0 || spec.sign != signNone {
+		if f, ok := fmtToFloat64(value); ok {
+			return fmtApplySign(
+				String(strconv.FormatFloat(f, 'f', prec, 64)), f >= 0, spec,
+			)
+		}
+
+		if spec.sign != signNone {
+			if i, ok := fmtToInt64(value); ok {
+				return fmtApplySign(
+					String(strconv.FormatInt(abs64(i), 10)), i >= 0, spec,
+				)
+			}
+
+			// uint64 values above MaxInt64 don't fit in int64; format them
+			// unsigned so the requested sign (e.g. {:+}) is still applied.
+			if u, ok := fmtToUint64(value); ok {
+				return fmtApplySign(
+					String(strconv.FormatUint(u, 10)), true, spec,
+				)
+			}
+		}
+	}
+
+	s := String(fmt.Sprint(value))
+	if prec >= 0 && s.LenRunes() > spec.precision {
+		return String([]rune(s)[:spec.precision])
+	}
+
+	return s
+}
+
+func fmtExponential(value any, spec fmtSpec, verb byte) String {
+	prec := 6
+	if spec.precision >= 0 {
+		prec = spec.precision.Std()
+	}
+
+	f, ok := fmtToFloat64(value)
+	if !ok {
+		var i int64
+		if i, ok = fmtToInt64(value); ok {
+			f = float64(i)
+		}
+	}
+
+	if ok {
+		return fmtApplySign(
+			String(strconv.FormatFloat(f, verb, prec, 64)), f >= 0, spec,
+		)
+	}
+
+	return String(fmt.Sprint(value))
+}
+
+func fmtApplySign(s String, positive bool, spec fmtSpec) String {
+	if !positive {
+		if s[0] != '-' {
+			return "-" + s
+		}
+
+		return s
+	}
+
+	switch spec.sign {
+	case signPlus:
+		return "+" + s
+	case signSpace:
+		return " " + s
+	}
+
+	return s
+}
+
+func fmtPad(s String, spec fmtSpec, isNum bool) String {
+	if spec.width.IsNegative() || s.LenRunes() >= spec.width {
+		return s
+	}
+
+	// zero-pad: sign-aware
+	if spec.zeroPad && spec.align == alignNone && isNum {
+		return fmtZeroPad(s, spec.width)
+	}
+
+	// default alignment: right for numbers, left for strings
+	align := spec.align
+	if align == alignNone {
+		if isNum {
+			align = alignRight
+		} else {
+			align = alignLeft
+		}
+	}
+
+	return fmtJustify(s, spec.width, spec.fill, align)
+}
+
+func fmtJustify(s String, width Int, fill rune, align fmtAlign) String {
+	remaining := width - s.LenRunes()
+	left, right := Int(0), Int(0)
+
+	switch align {
+	case alignLeft:
+		right = remaining
+	case alignRight:
+		left = remaining
+	default:
+		left = remaining / 2
+		right = remaining - left
+	}
+
+	var b Builder
+	b.Grow(s.Len() + remaining*Int(utf8.RuneLen(fill)))
+
+	for range left {
+		b.WriteRune(fill)
+	}
+
+	b.WriteString(s)
+
+	for range right {
+		b.WriteRune(fill)
+	}
+
+	return b.String()
+}
+
+func fmtZeroPad(s String, width Int) String {
+	var sign byte
+
+	body := s
+	if s.Len() > 0 && (s[0] == '+' || s[0] == '-' || s[0] == ' ') {
+		sign = s[0]
+		body = s[1:]
+	}
+
+	var prefix String
+	if body.Len() > 1 && body[0] == '0' && (body[1] == 'x' || body[1] == 'X' || body[1] == 'b' || body[1] == 'o') {
+		prefix = body[:2]
+		body = body[2:]
+	}
+
+	padLen := width - body.LenRunes() - prefix.Len()
+	if sign != 0 {
+		padLen--
+	}
+
+	var b Builder
+	b.Grow(width)
+
+	if sign != 0 {
+		b.WriteByte(sign)
+	}
+
+	b.WriteString(prefix)
+
+	for range padLen {
+		b.WriteByte('0')
+	}
+
+	b.WriteString(body)
+
+	return b.String()
+}
+
+func fmtPrettyDebug(value any) String {
+	return fmtIndentDebug(String(fmt.Sprintf("%#v", value)))
+}
+
+func fmtIndentDebug(s String) String {
+	var b Builder
+	b.Grow(s.Len() + 16)
+
+	indent := Int(0)
+	inString := false
+	escaped := false
+	pad := String("  ")
+
+	for i := Int(0); i < s.Len(); i++ {
+		ch := s[i]
+
+		if inString {
+			b.WriteByte(ch)
+
+			// Track escapes with a running toggle so that a closing quote
+			// preceded by an escaped backslash (`\\"`) is not mistaken for an
+			// escaped quote. A single-char lookback would leave inString stuck.
+			if escaped {
+				escaped = false
+			} else if ch == '\\' {
+				escaped = true
+			} else if ch == '"' {
+				inString = false
+			}
+
+			continue
+		}
+
+		if ch == '"' {
+			inString = true
+			escaped = false
+			b.WriteByte(ch)
+
+			continue
+		}
+
+		switch ch {
+		case '{', '[':
+			indent++
+			b.WriteByte(ch)
+			b.WriteByte('\n')
+			writeIndent(&b, pad, indent)
+		case '}', ']':
+			indent--
+			b.WriteByte('\n')
+			writeIndent(&b, pad, indent)
+			b.WriteByte(ch)
+		case ',':
+			b.WriteByte(ch)
+			b.WriteByte('\n')
+			writeIndent(&b, pad, indent)
+		default:
+			b.WriteByte(ch)
+		}
+	}
+
+	return b.String()
+}
+
+func writeIndent(b *Builder, pad String, indent Int) {
+	for range indent {
+		b.WriteString(pad)
+	}
+}
+
+func fmtIsNumeric(value any) bool {
+	switch value.(type) {
+	case int, int8, int16, int32, int64,
+		uint, uint8, uint16, uint32, uint64,
+		float32, float64,
+		Int, Float:
+		return true
+	}
+
+	return false
+}
+
+func fmtToInt64(value any) (int64, bool) {
+	switch v := value.(type) {
+	case Int:
+		return int64(v), true
+	case int:
+		return int64(v), true
+	case int8:
+		return int64(v), true
+	case int16:
+		return int64(v), true
+	case int32:
+		return int64(v), true
+	case int64:
+		return v, true
+	case uint:
+		return int64(v), true
+	case uint8:
+		return int64(v), true
+	case uint16:
+		return int64(v), true
+	case uint32:
+		return int64(v), true
+	case uint64:
+		if v <= math.MaxInt64 {
+			return int64(v), true
+		}
+
+		return 0, false
+	case Float:
+		return int64(v), true
+	case float32:
+		return int64(v), true
+	case float64:
+		return int64(v), true
+	}
+
+	return 0, false
+}
+
+func fmtToSignedInt64(value any) (int64, bool) {
+	switch v := value.(type) {
+	case Int:
+		return int64(v), true
+	case int:
+		return int64(v), true
+	case int8:
+		return int64(v), true
+	case int16:
+		return int64(v), true
+	case int32:
+		return int64(v), true
+	case int64:
+		return v, true
+	}
+
+	return 0, false
+}
+
+func fmtToUint64(value any) (uint64, bool) {
+	switch v := value.(type) {
+	case uint:
+		return uint64(v), true
+	case uint8:
+		return uint64(v), true
+	case uint16:
+		return uint64(v), true
+	case uint32:
+		return uint64(v), true
+	case uint64:
+		return v, true
+	}
+
+	return 0, false
+}
+
+func fmtToFloat64(value any) (float64, bool) {
+	switch v := value.(type) {
+	case Float:
+		return float64(v), true
+	case float32:
+		return float64(v), true
+	case float64:
+		return v, true
+	}
+
+	return 0, false
+}
+
+func abs64(i int64) int64 {
+	if i < 0 {
+		return -i
+	}
+
+	return i
+}
diff --git a/backend/vendor/github.com/enetx/g/rand/secure.go b/backend/vendor/github.com/enetx/g/rand/secure.go
new file mode 100644
index 00000000..61992e85
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/rand/secure.go
@@ -0,0 +1,98 @@
+package rand
+
+import (
+	crand "crypto/rand"
+	"encoding/binary"
+
+	"github.com/enetx/g"
+)
+
+// SecureBytes returns length cryptographically secure random bytes drawn from
+// crypto/rand. A zero or negative length yields nil.
+//
+// Unlike the rest of this package, the result is safe for keys, tokens and
+// other security-sensitive material.
+func SecureBytes(length g.Int) g.Bytes {
+	if length <= 0 {
+		return nil
+	}
+
+	buf := make(g.Bytes, length)
+	if _, err := crand.Read(buf); err != nil {
+		panic(err) // crypto/rand.Read does not fail on supported platforms
+	}
+
+	return buf
+}
+
+// SecureString generates a cryptographically secure random String of the
+// specified length, selecting characters from predefined sets. If additional
+// character sets are provided, only those are used; the default set
+// (g.ASCIILetters and g.Digits) is excluded unless explicitly provided.
+//
+// If length is zero or negative, an empty String is returned. If an explicit
+// letter set is provided but resolves to empty, an empty String is returned as
+// well.
+//
+// Characters are drawn from crypto/rand with rejection sampling, so the
+// selection is uniform (no modulo bias). Unlike [String], the result is safe
+// for tokens, one-time codes and other security-sensitive material.
+//
+//	rand.SecureString(32)          // 32 alphanumeric characters
+//	rand.SecureString(6, g.Digits) // 6-digit one-time code
+func SecureString(length g.Int, letters ...g.String) g.String {
+	if length <= 0 {
+		return ""
+	}
+
+	var chars []rune
+	if len(letters) != 0 {
+		var buf g.Builder
+		for _, set := range letters {
+			_, _ = buf.WriteString(set)
+		}
+
+		chars = buf.String().Runes()
+	} else {
+		chars = (g.ASCIILetters + g.Digits).Runes()
+	}
+
+	n := len(chars)
+	if n == 0 {
+		return ""
+	}
+
+	var b g.Builder
+	b.Grow(length)
+
+	for range length {
+		b.WriteRune(chars[secureIndex(n)])
+	}
+
+	return b.String()
+}
+
+// secureIndex returns a uniform random index in [0, n) drawn from crypto/rand,
+// using rejection sampling to avoid modulo bias.
+func secureIndex(n int) int {
+	if n == 1 {
+		return 0
+	}
+
+	// Values at or above limit fall into the biased tail and are redrawn.
+	// A limit of zero means 2^32 is an exact multiple of n — nothing to reject.
+	limit := uint32((1 << 32 / uint64(n)) * uint64(n))
+
+	var buf [4]byte
+
+	for {
+		if _, err := crand.Read(buf[:]); err != nil {
+			panic(err) // crypto/rand.Read does not fail on supported platforms
+		}
+
+		v := binary.BigEndian.Uint32(buf[:])
+		if limit == 0 || v < limit {
+			return int(v % uint32(n))
+		}
+	}
+}
diff --git a/backend/vendor/github.com/enetx/g/result_json.go b/backend/vendor/github.com/enetx/g/result_json.go
new file mode 100644
index 00000000..9cb0e2ce
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/result_json.go
@@ -0,0 +1,204 @@
+package g
+
+import (
+	"encoding/json/jsontext"
+	json "encoding/json/v2"
+	"errors"
+)
+
+// errResultJSONShape is returned when a Result document is not a JSON object
+// with exactly one of the keys "ok" or "err".
+var errResultJSONShape = errors.New("g.Result: expected a JSON object with exactly one of the keys \"ok\" or \"err\"")
+
+// MarshalJSON implements the json.Marshaler interface (encoding/json v1) for Result[T].
+// The encoding is externally tagged:
+// Ok(value) is marshaled as {"ok": <json of value>} and Err(err) is marshaled
+// as {"err": "<err.Error()>"}.
+//
+// If marshaling the contained value fails, that error is returned.
+//
+// BREAKING: the implementation is backed by encoding/json/v2, which changes some
+// edge-case semantics compared to the previous encoding/json implementation:
+//   - Ok of a nil slice marshals as {"ok":[]} and Ok of a nil map as {"ok":{}},
+//     rather than {"ok":null}.
+//   - Strings containing invalid UTF-8 (in the Ok value or the error message)
+//     are rejected with an error instead of being silently replaced with U+FFFD.
+//
+// NOTE: only the error message is serialized. The concrete error type and any
+// wrapped errors are lost — after a round trip, errors.Is/errors.As chains no
+// longer match.
+func (r Result[T]) MarshalJSON() ([]byte, error) {
+	if r.IsErr() {
+		msg, err := json.Marshal(r.err.Error())
+		if err != nil {
+			return nil, err
+		}
+
+		return append(append([]byte(`{"err":`), msg...), '}'), nil
+	}
+
+	v, err := json.Marshal(r.v)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(append([]byte(`{"ok":`), v...), '}'), nil
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface (encoding/json v1) for Result[T].
+// It expects the externally tagged encoding produced by MarshalJSON: a JSON
+// object with exactly one of the keys "ok" or "err".
+//
+// BREAKING: the implementation is backed by encoding/json/v2, so duplicate keys
+// are rejected — a document that repeats the same key ({"ok":1,"ok":2}) is now
+// an unmarshal error instead of the previous encoding/json last-wins semantics.
+//
+// {"err": "msg"} is unmarshaled as Err(errors.New("msg")); the value must be
+// a JSON string. {"ok": <v>} is unmarshaled as Ok with v decoded into T —
+// {"ok": null} decodes null into T following the encoding/json/v2 rules
+// (zero/nil). Anything else (both keys, neither key, extra keys, duplicate
+// keys, a non-object, or JSON null) is an unmarshal error.
+//
+// NOTE: only the error message survives a round trip. The original error type
+// is not restored — the decoded error is a plain errors.New value, so
+// errors.Is/errors.As chains against the original error no longer match.
+func (r *Result[T]) UnmarshalJSON(data []byte) error {
+	var raw map[string]jsontext.Value
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+
+	// JSON null decodes into a nil map without error; reject it explicitly.
+	if raw == nil || len(raw) != 1 {
+		return errResultJSONShape
+	}
+
+	if msg, ok := raw["err"]; ok {
+		if string(msg) == "null" {
+			return errors.New("g.Result: \"err\" value must be a JSON string, got null")
+		}
+
+		var s string
+		if err := json.Unmarshal(msg, &s); err != nil {
+			return err
+		}
+
+		*r = Err[T](errors.New(s))
+		return nil
+	}
+
+	value, ok := raw["ok"]
+	if !ok {
+		return errResultJSONShape
+	}
+
+	var v T
+	if err := json.Unmarshal(value, &v); err != nil {
+		return err
+	}
+
+	*r = Ok(v)
+	return nil
+}
+
+// MarshalJSONTo implements the json.MarshalerTo interface (encoding/json/v2) for Result[T].
+// encoding/json/v2 prefers this method over MarshalJSON.
+// The encoding matches MarshalJSON: Ok(value) is encoded as {"ok": <json of value>}
+// and Err(err) is encoded as {"err": "<err.Error()>"}.
+func (r Result[T]) MarshalJSONTo(enc *jsontext.Encoder) error {
+	if err := enc.WriteToken(jsontext.BeginObject); err != nil {
+		return err
+	}
+
+	if r.IsErr() {
+		if err := enc.WriteToken(jsontext.String("err")); err != nil {
+			return err
+		}
+
+		if err := enc.WriteToken(jsontext.String(r.err.Error())); err != nil {
+			return err
+		}
+	} else {
+		if err := enc.WriteToken(jsontext.String("ok")); err != nil {
+			return err
+		}
+
+		if err := json.MarshalEncode(enc, r.v); err != nil {
+			return err
+		}
+	}
+
+	return enc.WriteToken(jsontext.EndObject)
+}
+
+// UnmarshalJSONFrom implements the json.UnmarshalerFrom interface (encoding/json/v2) for Result[T].
+// encoding/json/v2 prefers this method over UnmarshalJSON.
+// It expects a JSON object with exactly one member whose key is "ok" or "err",
+// as produced by MarshalJSONTo.
+//
+// Duplicate keys are rejected: the strict single-member contract refuses any
+// second object member (a duplicate key included) before the v2 decoder's own
+// duplicate-name check even fires, and the encoding/json/v2 decoder itself
+// forbids duplicate object member names by default. Presence of both distinct
+// keys, extra keys, neither key, a non-object, or JSON null is likewise an
+// unmarshal error.
+func (r *Result[T]) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
+	if dec.PeekKind() != '{' {
+		// Surface the underlying syntax error for malformed input; otherwise
+		// report the shape violation (null, array, string, number, bool).
+		if _, err := dec.ReadToken(); err != nil {
+			return err
+		}
+
+		return errResultJSONShape
+	}
+
+	if _, err := dec.ReadToken(); err != nil { // consume '{'
+		return err
+	}
+
+	if dec.PeekKind() == '}' {
+		return errResultJSONShape // empty object
+	}
+
+	name, err := dec.ReadToken()
+	if err != nil {
+		return err
+	}
+
+	var res Result[T]
+
+	switch name.String() {
+	case "err":
+		if dec.PeekKind() != '"' {
+			return errors.New("g.Result: \"err\" value must be a JSON string")
+		}
+
+		var s string
+		if err := json.UnmarshalDecode(dec, &s); err != nil {
+			return err
+		}
+
+		res = Err[T](errors.New(s))
+	case "ok":
+		var v T
+		if err := json.UnmarshalDecode(dec, &v); err != nil {
+			return err
+		}
+
+		res = Ok(v)
+	default:
+		return errResultJSONShape
+	}
+
+	if dec.PeekKind() != '}' {
+		return errResultJSONShape // a second member: both keys, extra or duplicate keys
+	}
+
+	if _, err := dec.ReadToken(); err != nil { // consume '}'
+		return err
+	}
+
+	*r = res
+	return nil
+}
diff --git a/backend/vendor/github.com/enetx/g/rwlock.go b/backend/vendor/github.com/enetx/g/rwlock.go
new file mode 100644
index 00000000..695de933
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/rwlock.go
@@ -0,0 +1,119 @@
+package g
+
+import "sync"
+
+// RwLock is a reader-writer lock that protects a value of type T.
+// It allows multiple readers or a single writer at any point in time.
+// Unlike sync.RWMutex, it binds the protected data to the lock itself,
+// making it impossible to access the data without holding the lock.
+//
+// An RwLock must not be copied after first use: it embeds a sync.RWMutex and a
+// copy would protect a different value than the original (go vet's copylocks
+// analyzer flags such copies). Always pass an *RwLock, never an RwLock by value.
+type RwLock[T any] struct {
+	mu  sync.RWMutex
+	val T
+}
+
+// RwLockReadGuard provides read-only access to the value protected by an RwLock.
+// Multiple read guards can exist simultaneously.
+//
+// A guard holds pointers into its owning RwLock; copying the guard and calling
+// Unlock on more than one copy releases the same read lock twice, which panics.
+// Use each guard exactly once and do not copy it.
+type RwLockReadGuard[T any] struct {
+	mu  *sync.RWMutex
+	val *T
+}
+
+// RwLockWriteGuard provides exclusive read-write access to the value protected by an RwLock.
+// Only one write guard can exist at a time, and no read guards can coexist with it.
+//
+// A guard holds pointers into its owning RwLock; copying the guard and calling
+// Unlock on more than one copy releases the same write lock twice, which panics.
+// Use each guard exactly once and do not copy it.
+type RwLockWriteGuard[T any] struct {
+	mu  *sync.RWMutex
+	val *T
+}
+
+// NewRwLock creates a new RwLock containing the given value.
+func NewRwLock[T any](value T) *RwLock[T] { return &RwLock[T]{val: value} }
+
+// RWith acquires a read lock, calls fn with a copy of the protected value,
+// and releases the lock when fn returns.
+// The value is passed by copy to prevent accidental mutation under a read lock.
+func (r *RwLock[T]) RWith(fn func(T)) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	fn(r.val)
+}
+
+// With acquires a write lock, calls fn with a pointer to the protected value,
+// and releases the lock when fn returns.
+// This is a convenience method that eliminates the need for manual Lock/Unlock management.
+func (r *RwLock[T]) With(fn func(*T)) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	fn(&r.val)
+}
+
+// Read acquires a read lock and returns a guard that provides read-only access.
+// Multiple goroutines can hold read locks simultaneously.
+// The caller must call Unlock on the guard when done (typically via defer).
+func (r *RwLock[T]) Read() RwLockReadGuard[T] {
+	r.mu.RLock()
+	return RwLockReadGuard[T]{mu: &r.mu, val: &r.val}
+}
+
+// Write acquires a write lock and returns a guard that provides exclusive access.
+// No other readers or writers can access the value while this guard exists.
+// The caller must call Unlock on the guard when done (typically via defer).
+func (r *RwLock[T]) Write() RwLockWriteGuard[T] {
+	r.mu.Lock()
+	return RwLockWriteGuard[T]{mu: &r.mu, val: &r.val}
+}
+
+// TryRead attempts to acquire a read lock without blocking.
+// Returns Some(guard) if successful, None if a write lock is held.
+func (r *RwLock[T]) TryRead() Option[RwLockReadGuard[T]] {
+	if r.mu.TryRLock() {
+		return Some(RwLockReadGuard[T]{mu: &r.mu, val: &r.val})
+	}
+
+	return None[RwLockReadGuard[T]]()
+}
+
+// TryWrite attempts to acquire a write lock without blocking.
+// Returns Some(guard) if successful, None if any lock is held.
+func (r *RwLock[T]) TryWrite() Option[RwLockWriteGuard[T]] {
+	if r.mu.TryLock() {
+		return Some(RwLockWriteGuard[T]{mu: &r.mu, val: &r.val})
+	}
+
+	return None[RwLockWriteGuard[T]]()
+}
+
+// Get returns a copy of the protected value.
+func (g RwLockReadGuard[T]) Get() T { return *g.val }
+
+// Deref returns a pointer to the protected value for direct access.
+// Note: modifying through this pointer would be a logic error.
+func (g RwLockReadGuard[T]) Deref() *T { return g.val }
+
+// Unlock releases the read lock. Must be called when done with the guard.
+func (g RwLockReadGuard[T]) Unlock() { g.mu.RUnlock() }
+
+// Get returns a copy of the protected value.
+func (g RwLockWriteGuard[T]) Get() T { return *g.val }
+
+// Set replaces the protected value with a new one.
+func (g RwLockWriteGuard[T]) Set(value T) { *g.val = value }
+
+// Deref returns a pointer to the protected value for direct manipulation.
+func (g RwLockWriteGuard[T]) Deref() *T { return g.val }
+
+// Unlock releases the write lock. Must be called when done with the guard.
+func (g RwLockWriteGuard[T]) Unlock() { g.mu.Unlock() }
diff --git a/backend/vendor/github.com/enetx/g/seq.go b/backend/vendor/github.com/enetx/g/seq.go
new file mode 100644
index 00000000..41fb4219
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/seq.go
@@ -0,0 +1,1959 @@
+package g
+
+import (
+	"context"
+	"iter"
+	"reflect"
+	"slices"
+
+	"github.com/enetx/g/f"
+
+	"github.com/enetx/g/cmp"
+	"github.com/enetx/g/constraints"
+)
+
+// Seq is an iterator over sequences of individual values.
+type Seq[V any] func(yield func(V) bool)
+
+// SeqSlices is an iterator over slices of sequences of individual values.
+//
+// It is a distinct named type rather than Seq[[]V]: a named Seq[[]V] mentioned
+// from Seq[V]'s method set (Chunks, Windows, ChunkBy, Combinations,
+// Permutations) would be an instantiation cycle the compiler rejects.
+type SeqSlices[V any] func(yield func([]V) bool)
+
+// Range returns a Seq[T] yielding a sequence of integers of type T,
+// starting at start, incrementing by step, and ending before stop (exclusive).
+//
+//   - If step is omitted, it defaults to 1.
+//   - If step is 0, the sequence is empty.
+//   - If step does not move toward stop (e.g., positive step with start > stop),
+//     the sequence is empty.
+//
+// Examples:
+//   - Range(0, 5) yields [0, 1, 2, 3, 4]
+//   - Range(5, 0, -1) yields [5, 4, 3, 2, 1]
+func Range[T constraints.Integer](start, stop T, step ...T) Seq[T] {
+	stepValue := T(1)
+	if len(step) > 0 {
+		stepValue = step[0]
+	}
+
+	return func(yield func(T) bool) {
+		if stepValue == 0 {
+			return
+		}
+
+		if stepValue > 0 {
+			for i := start; i < stop; i += stepValue {
+				if !yield(i) {
+					return
+				}
+			}
+		} else {
+			for i := start; i > stop; i += stepValue {
+				if !yield(i) {
+					return
+				}
+			}
+		}
+	}
+}
+
+// RangeInclusive returns a Seq[T] yielding a sequence of integers of type T,
+// starting at start, incrementing by step, and ending at stop (inclusive).
+//
+//   - If step is omitted, it defaults to 1.
+//   - If step is 0, the sequence is empty.
+//   - If step does not move toward stop (e.g., positive step with start > stop),
+//     the sequence is empty.
+//
+// Examples:
+//   - RangeInclusive(0, 5) yields [0, 1, 2, 3, 4, 5]
+//   - RangeInclusive(5, 0, -1) yields [5, 4, 3, 2, 1, 0]
+func RangeInclusive[T constraints.Integer](start, stop T, step ...T) Seq[T] {
+	stepValue := T(1)
+	if len(step) > 0 {
+		stepValue = step[0]
+	}
+
+	return func(yield func(T) bool) {
+		if stepValue == 0 {
+			return
+		}
+
+		if stepValue > 0 {
+			for i := start; i <= stop; i += stepValue {
+				if !yield(i) {
+					return
+				}
+			}
+		} else {
+			for i := start; i >= stop; i += stepValue {
+				if !yield(i) {
+					return
+				}
+			}
+		}
+	}
+}
+
+// Pull converts the "push-style" iterator sequence seq
+// into a "pull-style" iterator accessed by the two functions
+// next and stop.
+//
+// Next returns the next value in the sequence
+// and a boolean indicating whether the value is valid.
+// When the sequence is over, next returns the zero V and false.
+// It is valid to call next after reaching the end of the sequence
+// or after calling stop. These calls will continue
+// to return the zero V and false.
+//
+// Stop ends the iteration. It must be called when the caller is
+// no longer interested in next values and next has not yet
+// signaled that the sequence is over (with a false boolean return).
+// It is valid to call stop multiple times and when next has
+// already returned false.
+//
+// It is an error to call next or stop from multiple goroutines
+// simultaneously.
+func (seq Seq[V]) Pull() (func() (V, bool), func()) { return seq.seqPull() }
+
+// All checks whether all elements in the iterator satisfy the provided condition.
+// This function is useful when you want to determine if all elements in an iterator
+// meet a specific criteria.
+//
+// Parameters:
+// - fn func(V) bool: A function that returns a boolean indicating whether the element satisfies
+// the condition.
+//
+// Returns:
+// - bool: True if all elements in the iterator satisfy the condition, false otherwise.
+//
+// Example usage:
+//
+//	slice := g.SliceOf(1, 2, 3, 4, 5, 6, 7, -1, -2)
+//	isPositive := func(num int) bool { return num > 0 }
+//	allPositive := slice.Iter().All(isPositive)
+//
+// The resulting allPositive will be true if all elements returned by the iterator are positive.
+func (seq Seq[V]) All(fn func(v V) bool) bool {
+	all := true
+
+	seq(func(v V) bool {
+		if !fn(v) {
+			all = false
+			return false
+		}
+
+		return true
+	})
+
+	return all
+}
+
+// Any checks whether any element in the iterator satisfies the provided condition.
+// This function is useful when you want to determine if at least one element in an iterator
+// meets a specific criteria.
+//
+// Parameters:
+// - fn func(V) bool: A function that returns a boolean indicating whether the element satisfies
+// the condition.
+//
+// Returns:
+// - bool: True if at least one element in the iterator satisfies the condition, false otherwise.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 3, 5, 7, 9}
+//	isEven := func(num int) bool { return num%2 == 0 }
+//	anyEven := slice.Iter().Any(isEven)
+//
+// The resulting anyEven will be true if at least one element returned by the iterator is even.
+func (seq Seq[V]) Any(fn func(V) bool) bool {
+	found := false
+
+	seq(func(v V) bool {
+		if fn(v) {
+			found = true
+			return false
+		}
+
+		return true
+	})
+
+	return found
+}
+
+// Chain concatenates the current iterator with other iterators, returning a new iterator.
+//
+// The function creates a new iterator that combines the elements of the current iterator
+// with elements from the provided iterators in the order they are given.
+//
+// Params:
+//
+// - seqs ([]Seq[V]): Other iterators to be concatenated with the current iterator.
+//
+// Returns:
+//
+// - Seq[V]: A new iterator containing elements from the current iterator and the provided iterators.
+//
+// Example usage:
+//
+//	iter1 := g.Slice[int]{1, 2, 3}.Iter()
+//	iter2 := g.Slice[int]{4, 5, 6}.Iter()
+//	iter1.Chain(iter2).Collect().Slice().Print()
+//
+// Output: [1, 2, 3, 4, 5, 6]
+//
+// The resulting iterator will contain elements from both iterators in the specified order.
+func (seq Seq[V]) Chain(seqs ...Seq[V]) Seq[V] {
+	return func(yield func(V) bool) {
+		proceed := true
+
+		seq(func(v V) bool {
+			if !yield(v) {
+				proceed = false
+				return false
+			}
+
+			return true
+		})
+
+		if !proceed {
+			return
+		}
+
+		for _, rest := range seqs {
+			rest(func(v V) bool {
+				if !yield(v) {
+					proceed = false
+					return false
+				}
+
+				return true
+			})
+
+			if !proceed {
+				return
+			}
+		}
+	}
+}
+
+// Chunks returns an iterator that yields chunks of elements of the specified size.
+//
+// The function creates a new iterator that yields chunks of elements from the original iterator,
+// with each chunk containing elements of the specified size.
+//
+// Params:
+//
+// - n (Int): The size of each chunk.
+//
+// Returns:
+//
+// - SeqSlices[V]: An iterator yielding chunks of elements of the specified size.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5, 6}
+//	chunks := slice.Iter().Chunks(2).Collect().Slices()
+//
+// Output: [Slice[1, 2] Slice[3, 4] Slice[5, 6]]
+//
+// The resulting iterator will yield chunks of elements, each containing the specified number of elements.
+func (seq Seq[V]) Chunks(n Int) SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		size := n.Std()
+		if size <= 0 {
+			return
+		}
+
+		chunk := make([]V, 0, size)
+
+		seq(func(v V) bool {
+			chunk = append(chunk, v)
+			if len(chunk) == size {
+				if !yield(chunk) {
+					return false
+				}
+
+				chunk = make([]V, 0, size)
+			}
+
+			return true
+		})
+
+		if len(chunk) > 0 {
+			yield(chunk)
+		}
+	}
+}
+
+// Collect returns a collector over the grouped sequence; its Slices method
+// materializes the groups. Collect itself is lazy and does not consume the
+// sequence.
+func (seqs SeqSlices[V]) Collect() collectorS[V] { return collectorS[V]{seqs} }
+
+// collectorS materializes a grouped sequence; build one with
+// SeqSlices.Collect.
+type collectorS[V any] struct{ seq SeqSlices[V] }
+
+// Slices consumes the sequence and returns the groups as a plain []Slice.
+// (Returning a g.Slice here would re-close the instantiation cycle that keeps
+// SeqSlices a separate type: Slice[Slice[V]].Iter().Chunks() would need
+// SeqSlices[Slice[V]], and so on forever.)
+func (c collectorS[V]) Slices() []Slice[V] {
+	collection := make([]Slice[V], 0)
+
+	c.seq(func(v []V) bool {
+		chunk := make(Slice[V], len(v))
+		copy(chunk, v)
+		collection = append(collection, chunk)
+		return true
+	})
+
+	return collection
+}
+
+// Map transforms each group (sub-slice) in the iterator using the given function.
+//
+// The function creates a new lazy iterator by applying the provided function to each
+// group produced by the original iterator, preserving the streaming pipeline.
+//
+// Params:
+//
+// - fn (func(Slice[V]) Slice[U]): The function used to transform each group.
+// The element type of the resulting groups may differ.
+//
+// Returns:
+//
+// - SeqSlices[U]: An iterator yielding the transformed groups.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4}
+//	doubled := slice.Iter().
+//		Chunks(2).
+//		Map(func(chunk g.Slice[int]) g.Slice[int] {
+//			return chunk.Iter().Map(func(v int) int { return v * 2 }).Collect().Slice()
+//		}).
+//		Collect().Slices()
+//	// Output: [Slice[2, 4] Slice[6, 8]]
+func (seqs SeqSlices[V]) Map[U any](fn func(Slice[V]) Slice[U]) SeqSlices[U] {
+	return func(yield func([]U) bool) {
+		seqs(func(v []V) bool {
+			return yield(fn(Slice[V](v)))
+		})
+	}
+}
+
+// Filter returns a new iterator containing only the groups (sub-slices) that satisfy
+// the provided function.
+//
+// The function applies the provided function to each group produced by the original
+// iterator. If the function returns true for a group, that group is included in the
+// resulting iterator.
+//
+// Params:
+//
+// - fn (func(Slice[V]) bool): The predicate applied to each group.
+//
+// Returns:
+//
+// - SeqSlices[V]: An iterator yielding the groups that satisfy the given condition.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5, 6}
+//	pairs := slice.Iter().
+//		Chunks(2).
+//		Filter(func(chunk g.Slice[int]) bool { return chunk.Len() == 2 }).
+//		Collect().Slices()
+func (seqs SeqSlices[V]) Filter(fn func(Slice[V]) bool) SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		seqs(func(v []V) bool {
+			if fn(Slice[V](v)) {
+				return yield(v)
+			}
+			return true
+		})
+	}
+}
+
+// ForEach iterates through all groups (sub-slices) and applies the given function to each.
+//
+// Params:
+//
+// - fn (func(Slice[V])): The function to apply to each group.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4}
+//	slice.Iter().Chunks(2).ForEach(func(chunk g.Slice[int]) {
+//		fmt.Println(chunk)
+//	})
+func (seqs SeqSlices[V]) ForEach(fn func(s Slice[V])) {
+	seqs(func(v []V) bool {
+		fn(Slice[V](v))
+		return true
+	})
+}
+
+// Flatten flattens the iterator of groups (sub-slices) into a single Seq[V],
+// yielding the elements of each group in order.
+//
+// Returns:
+//
+// - Seq[V]: A single iterator containing the elements from each group in sequence.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5, 6}
+//	flat := slice.Iter().Chunks(2).Flatten().Collect().Slice()
+//	// Output: Slice[1, 2, 3, 4, 5, 6]
+func (seqs SeqSlices[V]) Flatten() Seq[V] {
+	return func(yield func(V) bool) {
+		seqs(func(v []V) bool {
+			for _, item := range v {
+				if !yield(item) {
+					return false
+				}
+			}
+			return true
+		})
+	}
+}
+
+// Count consumes the iterator, counting the number of iterations and returning it.
+func (seq Seq[V]) Count() Int {
+	count := Int(0)
+	seq(func(V) bool { count++; return true })
+
+	return count
+}
+
+// CounterBy tallies elements by fn(element), returning a Seq2[K, Int] that yields
+// each key with the number of elements that produced it: fn is applied to every
+// element, and elements whose keys collide are merged into one bucket with their
+// counts summed. Key order is first-seen; the source is consumed when the
+// returned sequence is iterated. The key type must be comparable; for identity
+// counting pass the identity function (func(v V) V { return v }).
+//
+// Example usage:
+//
+//	words.Iter().CounterBy(func(w String) Int { return w.Len() })
+//	// yields 5:2, 4:1 — counts by word length, in first-seen order
+func (seq Seq[V]) CounterBy[K comparable](fn func(V) K) Seq2[K, Int] {
+	return func(yield func(K, Int) bool) {
+		order := NewSlice[K]()
+		counts := NewMap[K, Int]()
+
+		seq(func(v V) bool {
+			k := fn(v)
+			if !counts.Contains(k) {
+				order.Push(k)
+			}
+
+			counts[k]++
+
+			return true
+		})
+
+		for _, k := range order {
+			if !yield(k, counts[k]) {
+				return
+			}
+		}
+	}
+}
+
+// ChunkBy groups CONSECUTIVE elements of the sequence into chunks based on a
+// custom equality function. It is not an SQL-style
+// GroupBy: elements are never reordered or bucketed by key, so equal elements
+// that are not adjacent end up in different chunks.
+//
+// The provided function `fn` takes two consecutive elements `a` and `b` and returns `true`
+// if they belong to the same chunk, or `false` if a new chunk should start.
+// The function returns a `SeqSlices[V]`, where each `[]V` represents a run of consecutive
+// elements that satisfy the provided equality condition.
+//
+// Notes:
+//   - Each chunk is returned as a copy of the elements, since `Seq` does not guarantee
+//     that elements share the same backing array.
+//
+// Parameters:
+//   - fn (func(a, b V) bool): Function that determines whether two consecutive elements belong to the same chunk.
+//
+// Returns:
+//   - SeqSlices[V]: An iterator yielding slices, each containing one chunk.
+//
+// Example usage:
+//
+//	slice := g.SliceOf(1, 1, 2, 3, 2, 3, 4)
+//	chunks := slice.Iter().ChunkBy(func(a, b int) bool { return a <= b }).Collect().Slices()
+//	// Output: [Slice[1, 1, 2, 3] Slice[2, 3, 4]]
+//
+// The resulting iterator will yield runs of consecutive elements according to the provided function.
+func (seq Seq[V]) ChunkBy(fn func(a, b V) bool) SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		var (
+			group []V
+			prev  V
+		)
+
+		first := true
+		cont := true
+
+		seq(func(v V) bool {
+			if first {
+				group = []V{v}
+				prev = v
+				first = false
+
+				return true
+			}
+
+			if fn(prev, v) {
+				group = append(group, v)
+				prev = v
+
+				return true
+			}
+
+			out := make([]V, len(group))
+			copy(out, group)
+
+			if !yield(out) {
+				cont = false
+				return false
+			}
+
+			group = []V{v}
+			prev = v
+
+			return true
+		})
+
+		if cont && len(group) > 0 {
+			out := make([]V, len(group))
+			copy(out, group)
+			_ = yield(out)
+		}
+	}
+}
+
+// Combinations generates all combinations of length 'size' from the sequence.
+func (seq Seq[V]) Combinations(size Int) SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		slice := seq.seqToSlice()
+
+		n := len(slice)
+		k := size.Std()
+
+		if k > n || k <= 0 {
+			return
+		}
+
+		indices := make([]int, k)
+		for i := range indices {
+			indices[i] = i
+		}
+
+		for {
+			combination := make([]V, k)
+			for i, idx := range indices {
+				combination[i] = slice[idx]
+			}
+
+			if !yield(combination) {
+				return
+			}
+
+			i := k - 1
+			for i >= 0 && indices[i] == n-k+i {
+				i--
+			}
+
+			if i < 0 {
+				break
+			}
+
+			indices[i]++
+			for j := i + 1; j < k; j++ {
+				indices[j] = indices[j-1] + 1
+			}
+		}
+	}
+}
+
+// Cycle returns an iterator that endlessly repeats the elements of the current sequence.
+func (seq Seq[V]) Cycle() Seq[V] {
+	return func(yield func(V) bool) {
+		for {
+			yielded := false
+			keep := true
+
+			seq(func(v V) bool {
+				yielded = true
+				if !yield(v) {
+					keep = false
+					return false
+				}
+
+				return true
+			})
+
+			if !keep || !yielded {
+				return
+			}
+		}
+	}
+}
+
+// Enumerate adds an index to each element in the iterator.
+//
+// Returns:
+//
+// - Seq2[Int, V]: An iterator yielding (index, value) pairs, where the first
+// element of the pair is the index and the second element is the original element from the
+// iterator.
+//
+// Example usage:
+//
+//	ps := g.SliceOf[g.String]("bbb", "ddd", "xxx", "aaa", "ccc").
+//		Iter().
+//		Enumerate().
+//		Collect().MapOrd[g.Int, g.String]()
+//
+//	ps.Print()
+//
+// Output: MapOrd{0:bbb, 1:ddd, 2:xxx, 3:aaa, 4:ccc}
+func (seq Seq[V]) Enumerate() Seq2[Int, V] {
+	return func(yield func(Int, V) bool) {
+		index := Int(0)
+
+		seq(func(v V) bool {
+			result := yield(index, v)
+			index++
+
+			return result
+		})
+	}
+}
+
+// Dedup creates a new iterator that removes consecutive duplicate elements from the original iterator,
+// leaving only one occurrence of each unique element. If the iterator is sorted, all elements will be unique.
+//
+// Parameters:
+// - None
+//
+// Returns:
+// - Seq[V]: A new iterator with consecutive duplicates removed.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 2, 3, 4, 4, 4, 5}
+//	iter := slice.Iter().Dedup()
+//	result := iter.Collect().Slice()
+//	result.Print()
+//
+// Output: [1 2 3 4 5]
+//
+// The resulting iterator will contain only unique elements, removing consecutive duplicates.
+func (seq Seq[V]) Dedup() Seq[V] {
+	if isValueComparable[V]() {
+		return Seq[V](seq.seqDedupBy(func(a, b V) bool {
+			return any(a) == any(b)
+		}))
+	}
+
+	return Seq[V](seq.seqDedupBy(func(a, b V) bool {
+		return reflect.DeepEqual(a, b)
+	}))
+}
+
+// Filter returns a new iterator containing only the elements that satisfy the provided function.
+//
+// The function applies the provided function to each element of the iterator.
+// If the function returns true for an element, that element is included in the resulting iterator.
+//
+// Parameters:
+//
+// - fn (func(V) bool): The function to be applied to each element of the iterator
+// to determine if it should be included in the result.
+//
+// Returns:
+//
+// - Seq[V]: A new iterator containing the elements that satisfy the given condition.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5}
+//	even := slice.Iter().
+//		Filter(
+//			func(val int) bool {
+//				return val%2 == 0
+//			}).
+//		Collect().Slice()
+//	even.Print()
+//
+// Output: [2 4].
+//
+// The resulting iterator will contain only the elements that satisfy the provided function.
+func (seq Seq[V]) Filter(fn func(V) bool) Seq[V] {
+	return func(yield func(V) bool) {
+		seq(func(v V) bool {
+			if fn(v) {
+				return yield(v)
+			}
+
+			return true
+		})
+	}
+}
+
+// Exclude returns a new iterator excluding elements that satisfy the provided function.
+//
+// The function applies the provided function to each element of the iterator.
+// If the function returns true for an element, that element is excluded from the resulting iterator.
+//
+// Parameters:
+//
+// - fn (func(V) bool): The function to be applied to each element of the iterator
+// to determine if it should be excluded from the result.
+//
+// Returns:
+//
+// - Seq[V]: A new iterator containing the elements that do not satisfy the given condition.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5}
+//	notEven := slice.Iter().
+//		Exclude(
+//			func(val int) bool {
+//				return val%2 == 0
+//			}).
+//		Collect().Slice()
+//	notEven.Print()
+//
+// Output: [1, 3, 5]
+//
+// The resulting iterator will contain only the elements that do not satisfy the provided function.
+func (seq Seq[V]) Exclude(fn func(V) bool) Seq[V] {
+	return func(yield func(V) bool) {
+		seq(func(v V) bool {
+			if !fn(v) {
+				return yield(v)
+			}
+
+			return true
+		})
+	}
+}
+
+// Fold accumulates values in the iterator using a function.
+//
+// The function iterates through the elements of the iterator, accumulating values
+// using the provided function and an initial value.
+//
+// Params:
+//
+//   - init (A): The initial value for accumulation. The accumulator type may differ
+//     from the element type.
+//   - fn (func(A, V) A): The function that accumulates values; it takes the accumulator
+//     and an element and returns the new accumulator.
+//
+// Returns:
+//
+// - A: The accumulated value after applying the function to all elements.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5}
+//	sum := slice.Iter().
+//		Fold(0,
+//			func(acc, val int) int {
+//				return acc + val
+//			})
+//	fmt.Println(sum)
+//
+// Output: 15.
+//
+// The resulting value will be the accumulation of elements based on the provided function.
+func (seq Seq[V]) Fold[A any](init A, fn func(acc A, val V) A) A {
+	seq(func(v V) bool { init = fn(init, v); return true })
+	return init
+}
+
+// SumBy maps each element to a numeric value via fn and returns the sum of those values.
+// An empty sequence yields the zero value of S. The result type S is chosen by fn,
+// independent of the element type V.
+//
+// Params:
+//   - fn (func(V) S): Projects an element to the numeric value to be summed.
+//
+// Returns:
+//   - S: The sum of the projected values.
+//
+// Example usage:
+//
+//	words := g.SliceOf[g.String]("a", "bb", "ccc")
+//	total := words.Iter().SumBy(func(s g.String) g.Int { return s.Len() })
+//	fmt.Println(total) // 6
+func (seq Seq[V]) SumBy[S constraints.Number](fn func(V) S) S {
+	var zero S
+	return seq.Fold(zero, func(acc S, v V) S { return acc + fn(v) })
+}
+
+// ProductBy maps each element to a numeric value via fn and returns their product.
+// An empty sequence yields the multiplicative identity, one.
+func (seq Seq[V]) ProductBy[S constraints.Number](fn func(V) S) S {
+	return seq.Fold(S(1), func(acc S, v V) S { return acc * fn(v) })
+}
+
+// FindMap applies fn to each element and returns the first Some result, or None
+// if fn returns None for every element.
+func (seq Seq[V]) FindMap[U any](fn func(V) Option[U]) Option[U] {
+	var result Option[U]
+
+	seq(func(v V) bool {
+		if o := fn(v); o.IsSome() {
+			result = o
+			return false
+		}
+
+		return true
+	})
+
+	return result
+}
+
+// Reduce aggregates elements of the sequence using the provided function.
+// The first element of the sequence is used as the initial accumulator value.
+// If the sequence is empty, it returns None[V].
+//
+// Params:
+//   - fn (func(V, V) V): Function that combines two values into one.
+//
+// Returns:
+//   - Option[V]: The accumulated value wrapped in Some, or None if the sequence is empty.
+//
+// Example:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5}
+//	product := slice.Iter().Reduce(func(a, b int) int { return a * b })
+//	if product.IsSome() {
+//	    fmt.Println(product.Some()) // 120
+//	} else {
+//	    fmt.Println("empty")
+//	}
+func (seq Seq[V]) Reduce(fn func(a, b V) V) Option[V] {
+	var result V
+
+	first := true
+
+	seq(func(v V) bool {
+		if first {
+			result = v
+			first = false
+		} else {
+			result = fn(result, v)
+		}
+
+		return true
+	})
+
+	return OptionOf(result, !first)
+}
+
+// ForEach iterates through all elements and applies the given function to each.
+//
+// The function applies the provided function to each element of the iterator.
+//
+// Params:
+//
+// - fn (func(V)): The function to apply to each element.
+//
+// Example usage:
+//
+//	iter := g.Slice[int]{1, 2, 3, 4, 5}.Iter()
+//	iter.ForEach(func(val int) {
+//	    fmt.Println(val) // Replace this with the function logic you need.
+//	})
+//
+// The provided function will be applied to each element in the iterator.
+func (seq Seq[V]) ForEach(fn func(v V)) {
+	seq(func(v V) bool { fn(v); return true })
+}
+
+// Flatten recursively flattens nested slices and arrays inside each element,
+// yielding the leaf elements in order.
+//
+// The function relies on reflection: slices and arrays at any depth are
+// descended into, and only leaf values assignable to V are yielded.
+//
+// Returns:
+//
+// - Seq[V]: A single iterator containing the flattened leaf elements.
+//
+// Example usage:
+//
+//	nestedSlice := g.Slice[any]{
+//		1,
+//		g.SliceOf(2, 3),
+//		"abc",
+//		g.SliceOf("def", "ghi"),
+//		g.SliceOf(4.5, 6.7),
+//	}
+//
+//	nestedSlice.Iter().Flatten().Collect().Slice().Print()
+//
+// Output: Slice[1, 2, 3, abc, def, ghi, 4.5, 6.7]
+//
+// The resulting iterator will contain elements from each iterator in sequence.
+func (seq Seq[V]) Flatten() Seq[V] {
+	return func(yield func(V) bool) {
+		seq(func(item V) bool {
+			return flattenValue(item, yield)
+		})
+	}
+}
+
+// Inspect creates a new iterator that wraps around the current iterator
+// and allows inspecting each element as it passes through.
+func (seq Seq[V]) Inspect(fn func(v V)) Seq[V] {
+	return func(yield func(V) bool) { seq(func(v V) bool { fn(v); return yield(v) }) }
+}
+
+// Intersperse inserts the provided separator between elements of the iterator.
+//
+// The function creates a new iterator that inserts the given separator between each
+// consecutive pair of elements in the original iterator.
+//
+// Params:
+//
+// - sep (V): The separator to intersperse between elements.
+//
+// Returns:
+//
+// - Seq[V]: An iterator containing elements with the separator interspersed.
+//
+// Example usage:
+//
+//	g.Slice[string]{"Hello", "World", "!"}.
+//		Iter().
+//		Intersperse(" ").
+//		Collect().
+//		Slice().
+//		Join().
+//		Print()
+//
+// Output: "Hello World !".
+//
+// The resulting iterator will contain elements with the separator interspersed.
+func (seq Seq[V]) Intersperse(sep V) Seq[V] {
+	return func(yield func(V) bool) {
+		first := true
+
+		seq(func(v V) bool {
+			if !first {
+				if !yield(sep) {
+					return false
+				}
+			}
+
+			first = false
+
+			return yield(v)
+		})
+	}
+}
+
+// Map transforms each element in the iterator using the given function.
+//
+// The function creates a new iterator by applying the provided function to each element
+// of the original iterator.
+//
+// Params:
+//
+//   - transform (func(V) U): The function used to transform elements. The result
+//     type may differ from the element type.
+//
+// Returns:
+//
+// - Seq[U]: A iterator containing elements transformed by the provided function.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3}
+//	strs := slice.
+//		Iter().
+//		Map(
+//			func(val int) g.String {
+//				return g.Int(val * 2).String()
+//			}).
+//		Collect().Slice()
+//	strs.Print()
+//
+// Output: Slice[2, 4, 6].
+//
+// The resulting iterator will contain elements transformed by the provided function.
+func (seq Seq[V]) Map[U any](transform func(V) U) Seq[U] {
+	return func(yield func(U) bool) { seq(func(v V) bool { return yield(transform(v)) }) }
+}
+
+// FlatMap applies a function to each element that returns an iterator, then flattens the results.
+//
+// The function transforms each element into a sequence and then concatenates all sequences
+// into a single flat sequence.
+//
+// Params:
+//
+// - fn (func(V) Seq[U]): The function that transforms each element into a sequence.
+// The element type of the resulting sequences may differ.
+//
+// Returns:
+//
+// - Seq[U]: A flattened sequence containing all elements from the transformed sequences.
+//
+// Example usage:
+//
+//	words := g.Slice[string]{"hello world", "foo bar"}.Iter()
+//	chars := words.FlatMap(func(s string) Seq[string] {
+//		return g.String(s).Split("")
+//	})
+//	// chars will yield: "h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d", "f", "o", "o", " ", "b", "a", "r"
+//
+//	numbers := g.Slice[int]{1, 2, 3}.Iter()
+//	expanded := numbers.FlatMap(func(n int) Seq[int] {
+//		return g.Slice[int]{n, n*10, n*100}.Iter()
+//	})
+//	// expanded will yield: 1, 10, 100, 2, 20, 200, 3, 30, 300
+func (seq Seq[V]) FlatMap[U any](fn func(V) Seq[U]) Seq[U] {
+	return func(yield func(U) bool) {
+		seq(func(v V) bool {
+			keep := true
+
+			fn(v)(func(u U) bool {
+				if !yield(u) {
+					keep = false
+					return false
+				}
+
+				return true
+			})
+
+			return keep
+		})
+	}
+}
+
+// FilterMap applies a function to each element and filters out None results.
+//
+// The function transforms and filters in a single pass. Elements where the function
+// returns None are filtered out, and elements where it returns Some are unwrapped
+// and included in the result.
+//
+// Params:
+//
+//   - fn (func(V) Option[U]): The function that transforms and filters elements.
+//     Returns Some(value) to include the transformed value, or None to filter it out.
+//     The result type may differ from the element type.
+//
+// Returns:
+//
+// - Seq[U]: A sequence containing only the successfully transformed elements.
+//
+// Example usage:
+//
+//	strings := g.Slice[string]{"1", "2", "abc", "3", "xyz"}.Iter()
+//	numbers := strings.FilterMap(func(s string) Option[int] {
+//		if n, err := strconv.Atoi(s); err == nil {
+//			return Some(n)
+//		}
+//		return None[int]()
+//	})
+//	// numbers will yield: 1, 2, 3
+//
+//	values := g.Slice[int]{1, -2, 3, -4, 5}.Iter()
+//	positiveDoubled := values.FilterMap(func(n int) Option[int] {
+//		if n > 0 {
+//			return Some(n * 2)
+//		}
+//		return None[int]()
+//	})
+//	// positiveDoubled will yield: 2, 6, 10
+func (seq Seq[V]) FilterMap[U any](fn func(V) Option[U]) Seq[U] {
+	return func(yield func(U) bool) {
+		seq(func(v V) bool {
+			if u, ok := fn(v).Option(); ok {
+				return yield(u)
+			}
+
+			return true
+		})
+	}
+}
+
+// TryMap applies a fallible transform to each element and enters the Result
+// pipeline, producing a SeqResult[U]. It is the bridge from a plain sequence
+// into SeqResult: map each element to a Result[U] and continue with the
+// SeqResult terminals (TryCollect, SumBy, ...), which choose the Err policy.
+//
+// TryMap itself is lazy and consumer-driven: it yields fn(v) for each element
+// and leaves the Err policy to the terminal — TryCollect / Fold / Reduce /
+// SumBy / All / Any / First short-circuit on the first Err, while Collect and
+// Count traverse every element.
+//
+// Example usage:
+//
+//	// "abc" fails to parse -> the whole batch short-circuits
+//	res := g.SliceOf[g.String]("1", "2", "3").
+//		Iter().
+//		TryMap(g.String.TryInt).
+//		TryCollect() // Ok(Slice[1, 2, 3])
+//
+//	sum := g.SliceOf[g.String]("1", "2", "3").
+//		Iter().
+//		TryMap(g.String.TryInt).
+//		SumBy(f.Id) // Ok(6)
+func (seq Seq[V]) TryMap[U any](fn func(V) Result[U]) SeqResult[U] {
+	return func(yield func(Result[U]) bool) {
+		seq(func(v V) bool {
+			return yield(fn(v))
+		})
+	}
+}
+
+// Partition divides the elements of the iterator into two separate slices based on a given predicate function.
+//
+// The function takes a predicate function 'fn', which should return true or false for each element in the iterator.
+// Elements for which 'fn' returns true are collected into the left slice, while those for which 'fn' returns false
+// are collected into the right slice.
+//
+// Params:
+//
+// - fn (func(V) bool): The predicate function used to determine the placement of elements.
+//
+// Returns:
+//
+// - (Slice[V], Slice[V]): Two slices representing elements that satisfy and don't satisfy the predicate, respectively.
+//
+// Example usage:
+//
+//	evens, odds := g.Slice[int]{1, 2, 3, 4, 5}.
+//		Iter().
+//		Partition(
+//			func(v int) bool {
+//				return v%2 == 0
+//			})
+//
+//	fmt.Println("Even numbers:", evens) // Output: Even numbers: Slice[2, 4]
+//	fmt.Println("Odd numbers:", odds)   // Output: Odd numbers: Slice[1, 3, 5]
+//
+// The resulting two slices will contain elements separated based on whether they satisfy the predicate or not.
+func (seq Seq[V]) Partition(fn func(v V) bool) (Slice[V], Slice[V]) {
+	var left, right Slice[V]
+
+	seq(func(v V) bool {
+		if fn(v) {
+			left = append(left, v)
+		} else {
+			right = append(right, v)
+		}
+
+		return true
+	})
+
+	return left, right
+}
+
+// Permutations generates all permutations of the elements.
+//
+// The function uses a recursive approach to generate all the permutations of the elements.
+// If the iterator is empty, the resulting iterator is empty as well; a single-element
+// iterator yields exactly one permutation.
+//
+// Returns:
+//
+// - SeqSlices[V]: An iterator yielding slices, each containing one permutation of the
+// elements in the iterator.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3}
+//	perms := slice.Iter().Permutations().Collect().Slices()
+//	for _, perm := range perms {
+//	    fmt.Println(perm)
+//	}
+//
+// Output:
+//
+// Slice[1, 2, 3]
+// Slice[2, 1, 3]
+// Slice[3, 1, 2]
+// Slice[1, 3, 2]
+// Slice[2, 3, 1]
+// Slice[3, 2, 1]
+//
+// The resulting iterator will yield slices representing all possible permutations
+// of the elements in the original iterator.
+func (seq Seq[V]) Permutations() SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		slice := seq.seqToSlice()
+
+		n := len(slice)
+		if n == 0 {
+			return
+		}
+
+		var generate func(int) bool
+
+		generate = func(k int) bool {
+			if k == 1 {
+				perm := make([]V, n)
+				copy(perm, slice)
+
+				return yield(perm)
+			}
+
+			for i := range k {
+				if !generate(k - 1) {
+					return false
+				}
+
+				if k%2 == 0 {
+					slice[i], slice[k-1] = slice[k-1], slice[i]
+				} else {
+					slice[0], slice[k-1] = slice[k-1], slice[0]
+				}
+			}
+
+			return true
+		}
+
+		generate(n)
+	}
+}
+
+// Range iterates through elements until the given function returns false.
+//
+// The function iterates through the elements of the iterator and applies the provided function
+// to each element. It stops iteration when the function returns false for an element.
+//
+// Params:
+//
+// - fn (func(V) bool): The function that evaluates elements for continuation of iteration.
+//
+// Example usage:
+//
+//	iter := g.Slice[int]{1, 2, 3, 4, 5}.Iter()
+//	iter.Range(func(val int) bool {
+//	    fmt.Println(val) // Replace this with the function logic you need.
+//	    return val < 5 // Replace this with the condition for continuing iteration.
+//	})
+//
+// The iteration will stop when the provided function returns false for an element.
+func (seq Seq[V]) Range(fn func(v V) bool) {
+	seq(fn)
+}
+
+// Skip returns a new iterator skipping the first n elements.
+//
+// The function creates a new iterator that skips the first n elements of the current iterator
+// and returns an iterator starting from the (n+1)th element.
+//
+// Params:
+//
+// - n (Int): The number of elements to skip from the beginning of the iterator.
+// Negative values are treated as zero.
+//
+// Returns:
+//
+// - Seq[V]: An iterator that starts after skipping the first n elements.
+//
+// Example usage:
+//
+//	iter := g.Slice[int]{1, 2, 3, 4, 5, 6}.Iter()
+//	iter.Skip(3).Collect().Slice().Print()
+//
+// Output: [4, 5, 6]
+//
+// The resulting iterator will start after skipping the specified number of elements.
+func (seq Seq[V]) Skip(n Int) Seq[V] {
+	return func(yield func(V) bool) {
+		if n <= 0 {
+			seq(yield)
+			return
+		}
+
+		count := Int(0)
+
+		seq(func(v V) bool {
+			if count < n {
+				count++
+				return true
+			}
+
+			return yield(v)
+		})
+	}
+}
+
+// StepBy creates a new iterator that iterates over every N-th element of the original iterator.
+// This function is useful when you want to skip a specific number of elements between each iteration.
+//
+// Parameters:
+// - n Int: The step size, indicating how many elements to skip between each iteration.
+//
+// Returns:
+// - Seq[V]: A new iterator that produces elements from the original iterator with a step size of N.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+//	iter := slice.Iter().StepBy(3)
+//	result := iter.Collect().Slice()
+//	result.Print()
+//
+// Output: Slice[1, 4, 7, 10]
+//
+// The resulting iterator will produce elements from the original iterator with a step size of N.
+func (seq Seq[V]) StepBy(n Int) Seq[V] {
+	return func(yield func(V) bool) {
+		if n <= 0 {
+			return
+		}
+
+		index := Int(0)
+
+		seq(func(v V) bool {
+			if index%n == 0 {
+				if !yield(v) {
+					return false
+				}
+			}
+
+			index++
+
+			return true
+		})
+	}
+}
+
+// SortBy applies a custom sorting function to the elements in the iterator
+// and returns a new iterator containing the sorted elements.
+//
+// The sorting function 'fn' should take two arguments, 'a' and 'b' of type V,
+// and return a cmp.Ordering: cmp.Less orders 'a' before 'b', cmp.More after it.
+//
+// Example:
+//
+//	g.SliceOf[g.String]("a", "c", "b").
+//		Iter().
+//		SortBy(func(a, b g.String) cmp.Ordering { return b.Cmp(a) }).
+//		Collect().
+//		Slice().
+//		Print()
+//
+// Output: Slice[c, b, a]
+//
+// The returned iterator is of type Seq[V], which implements the iterator
+// interface for further iteration over the sorted elements.
+func (seq Seq[V]) SortBy(fn func(a, b V) cmp.Ordering) Seq[V] {
+	slice := seq.seqToSlice()
+	slices.SortFunc(slice, func(a, b V) int { return int(fn(a, b)) })
+
+	return seqFromSlice(slice)
+}
+
+// Take returns a new iterator with the first n elements.
+// The function creates a new iterator containing the first n elements from the original iterator.
+func (seq Seq[V]) Take(n Int) Seq[V] {
+	return func(yield func(V) bool) {
+		if n <= 0 {
+			return
+		}
+
+		count := Int(0)
+
+		seq(func(v V) bool {
+			if count >= n {
+				return false
+			}
+
+			count++
+
+			return yield(v)
+		})
+	}
+}
+
+// First returns the first element from the sequence.
+func (seq Seq[V]) First() Option[V] {
+	var result V
+
+	found := false
+
+	seq(func(v V) bool {
+		result = v
+		found = true
+
+		return false
+	})
+
+	return OptionOf(result, found)
+}
+
+// Last returns the last element from the sequence.
+func (seq Seq[V]) Last() Option[V] {
+	var result V
+
+	found := false
+
+	seq(func(v V) bool {
+		result = v
+		found = true
+
+		return true
+	})
+
+	return OptionOf(result, found)
+}
+
+// Nth returns the nth element (0-indexed) in the sequence.
+func (seq Seq[V]) Nth(n Int) Option[V] {
+	var result V
+
+	found := false
+	index := Int(0)
+
+	seq(func(v V) bool {
+		if index == n {
+			result = v
+			found = true
+
+			return false
+		}
+
+		index++
+
+		return true
+	})
+
+	return OptionOf(result, found)
+}
+
+// Chan converts the iterator into a channel, optionally with context(s).
+//
+// The function converts the elements of the iterator into a channel for streaming purposes.
+// Optionally, it accepts context(s) to handle cancellation or timeout scenarios.
+//
+// Params:
+//
+// - ctxs (context.Context): Optional context(s) to control the channel behavior (e.g., cancellation).
+//
+// Returns:
+//
+// - chan V: A channel containing the elements from the iterator.
+//
+// Example usage:
+//
+//	iter := g.Slice[int]{1, 2, 3}.Iter()
+//	ctx, cancel := context.WithCancel(context.Background())
+//	defer cancel() // Ensure cancellation to avoid goroutine leaks.
+//	ch := iter.Chan(ctx)
+//	for val := range ch {
+//	    fmt.Println(val)
+//	}
+//
+// The resulting channel allows streaming elements from the iterator with optional context handling.
+func (seq Seq[V]) Chan(ctxs ...context.Context) chan V {
+	ctx := context.Background()
+	if len(ctxs) > 0 {
+		ctx = ctxs[0]
+	}
+
+	ch := make(chan V)
+
+	go func() {
+		defer close(ch)
+
+		if err := ctx.Err(); err != nil {
+			return
+		}
+
+		seq(func(v V) bool {
+			select {
+			case <-ctx.Done():
+				return false
+			case ch <- v:
+				return true
+			}
+		})
+	}()
+
+	return ch
+}
+
+// Unique returns an iterator with only unique elements.
+//
+// The function returns an iterator containing only the unique elements from the original iterator.
+//
+// Returns:
+//
+// - Seq[V]: An iterator containing unique elements from the original iterator.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 2, 4, 5, 3}
+//	unique := slice.Iter().Unique().Collect().Slice()
+//	unique.Print()
+//
+// Output: [1, 2, 3, 4, 5].
+//
+// The resulting iterator will contain only unique elements from the original iterator.
+func (seq Seq[V]) Unique() Seq[V] {
+	return func(yield func(V) bool) {
+		seen := make(map[any]struct{})
+
+		seq(func(v V) bool {
+			k := any(v)
+			if _, exists := seen[k]; !exists {
+				seen[k] = struct{}{}
+				return yield(v)
+			}
+
+			return true
+		})
+	}
+}
+
+// Zip combines elements from the current sequence and another sequence into pairs.
+// The element types of the two sequences may differ. Iteration stops when either
+// sequence is exhausted.
+func (seq Seq[V]) Zip[U any](two Seq[U]) Seq2[V, U] {
+	return func(yield func(V, U) bool) {
+		next, stop := seq.seqPull()
+		defer stop()
+
+		nextU, stopU := two.seqPull()
+		defer stopU()
+
+		for {
+			v, ok := next()
+			if !ok {
+				return
+			}
+
+			u, ok := nextU()
+			if !ok {
+				return
+			}
+
+			if !yield(v, u) {
+				return
+			}
+		}
+	}
+}
+
+// Scan accumulates values of the iterator using a function, yielding all intermediate states.
+//
+// The function takes an initial accumulator value and a function that combines the accumulator
+// with each element. It yields the initial value followed by each accumulated state.
+//
+// Params:
+//
+// - init (A): The initial accumulator value. The accumulator type may differ from the element type.
+// - fn (func(acc A, val V) A): The function that combines the accumulator with each element.
+//
+// Returns:
+//
+// - Seq[A]: A sequence of all intermediate accumulator states.
+//
+// Example usage:
+//
+//	numbers := g.Slice[int]{1, 2, 3, 4}.Iter()
+//	sums := numbers.Scan(0, func(acc, val int) int {
+//		return acc + val
+//	})
+//	// sums will yield: 0, 1, 3, 6, 10
+//
+//	words := g.Slice[string]{"a", "b", "c"}.Iter()
+//	concatenated := words.Scan("", func(acc, val string) string {
+//		return acc + val
+//	})
+//	// concatenated will yield: "", "a", "ab", "abc"
+func (seq Seq[V]) Scan[A any](init A, fn func(acc A, val V) A) Seq[A] {
+	return func(yield func(A) bool) {
+		if !yield(init) {
+			return
+		}
+
+		acc := init
+
+		seq(func(v V) bool {
+			acc = fn(acc, v)
+			return yield(acc)
+		})
+	}
+}
+
+// Find searches for an element in the iterator that satisfies the provided function.
+//
+// The function iterates through the elements of the iterator and returns the first element
+// for which the provided function returns true.
+//
+// Params:
+//
+// - fn (func(V) bool): The function used to test elements for a condition.
+//
+// Returns:
+//
+// - Option[V]: An Option containing the first element that satisfies the condition; None if not found.
+//
+// Example usage:
+//
+//	iter := g.Slice[int]{1, 2, 3, 4, 5}.Iter()
+//
+//	found := iter.Find(func(i int) bool {
+//		return i == 2
+//	})
+//
+//	if found.IsSome() {
+//		fmt.Println("Found:", found.Some())
+//	} else {
+//		fmt.Println("Not found.")
+//	}
+//
+// The resulting Option may contain the first element that satisfies the condition, or None if not found.
+func (seq Seq[V]) Find(fn func(v V) bool) Option[V] {
+	var result V
+
+	found := false
+
+	seq(func(v V) bool {
+		if fn(v) {
+			result = v
+			found = true
+
+			return false
+		}
+
+		return true
+	})
+
+	return OptionOf(result, found)
+}
+
+// Windows returns an iterator that yields sliding windows of elements of the specified size.
+//
+// The function creates a new iterator that yields windows of elements from the original iterator,
+// where each window is a slice containing elements of the specified size and moves one element at a time.
+//
+// Params:
+//
+// - n (Int): The size of each window.
+//
+// Returns:
+//
+// - SeqSlices[V]: An iterator yielding sliding windows of elements of the specified size.
+//
+// Example usage:
+//
+//	slice := g.Slice[int]{1, 2, 3, 4, 5, 6}
+//	windows := slice.Iter().Windows(3).Collect().Slices()
+//
+// Output: [Slice[1, 2, 3] Slice[2, 3, 4] Slice[3, 4, 5] Slice[4, 5, 6]]
+//
+// The resulting iterator will yield sliding windows of elements, each containing the specified number of elements.
+func (seq Seq[V]) Windows(n Int) SeqSlices[V] {
+	return func(yield func([]V) bool) {
+		size := n.Std()
+		if size <= 0 {
+			return
+		}
+
+		window := make([]V, 0, size)
+
+		seq(func(v V) bool {
+			window = append(window, v)
+			if len(window) == size {
+				windowCopy := make([]V, size)
+				copy(windowCopy, window)
+
+				if !yield(windowCopy) {
+					return false
+				}
+
+				window = window[1:]
+			}
+
+			return true
+		})
+	}
+}
+
+// Context allows the iteration to be controlled with a context.Context.
+func (seq Seq[V]) Context(ctx context.Context) Seq[V] {
+	return func(yield func(V) bool) {
+		if err := ctx.Err(); err != nil {
+			return
+		}
+
+		seq(func(v V) bool {
+			select {
+			case <-ctx.Done():
+				return false
+			default:
+				return yield(v)
+			}
+		})
+	}
+}
+
+// MaxBy returns the maximum element in the sequence using the provided comparison function.
+func (seq Seq[V]) MaxBy(fn func(V, V) cmp.Ordering) Option[V] {
+	var max V
+
+	found := false
+
+	seq(func(v V) bool {
+		if !found || fn(max, v) == cmp.Less {
+			max = v
+			found = true
+		}
+
+		return true
+	})
+
+	return OptionOf(max, found)
+}
+
+// MinBy returns the minimum element in the sequence using the provided comparison function.
+func (seq Seq[V]) MinBy(fn func(V, V) cmp.Ordering) Option[V] {
+	var min V
+
+	found := false
+
+	seq(func(v V) bool {
+		if !found || fn(v, min) == cmp.Less {
+			min = v
+			found = true
+		}
+
+		return true
+	})
+
+	return OptionOf(min, found)
+}
+
+// Next extracts the next element from the iterator and advances it.
+//
+// This method consumes the next element from the iterator and returns it wrapped in an Option.
+// The iterator itself is modified to point to the remaining elements.
+// This is similar to calling Pull() but more convenient for single-element extraction.
+//
+// Returns:
+// - Option[V]: Some(value) if an element exists, None if the iterator is exhausted.
+func (seq *Seq[V]) Next() Option[V] {
+	if value, remaining, ok := (*seq).seqNext(); ok {
+		*seq = Seq[V](remaining)
+		return Some(value)
+	}
+
+	return None[V]()
+}
+
+// FromChan converts a channel into an iterator.
+//
+// This function takes a channel as input and converts its elements into an iterator,
+// allowing seamless integration of channels into iterator-based processing pipelines.
+// It continuously reads from the channel until it's closed,
+// yielding each element to the provided yield function.
+//
+// Parameters:
+// - ch (<-chan V): The input channel to convert into an iterator.
+//
+// Returns:
+// - Seq[V]: An iterator that yields elements from the channel.
+//
+// Example usage:
+//
+//	ch := make(chan int)
+//	go func() {
+//		defer close(ch)
+//		for i := 1; i <= 5; i++ {
+//			ch <- i
+//		}
+//	}()
+//
+//	// Convert the channel into an iterator and apply filtering and mapping operations.
+//	g.FromChan(ch).
+//		Filter(func(i int) bool { return i%2 == 0 }). // Filter even numbers.
+//		Map(func(i int) int { return i * 2 }).        // Double each element.
+//		Collect().Slice().                            // Collect the results into a slice.
+//		Print()                                       // Print the collected results.
+//
+// Output: Slice[4, 8]
+//
+// The resulting iterator will yield elements from the provided channel, filtering out odd numbers,
+// doubling each even number, and finally collecting the results into a slice.
+func FromChan[V any](ch <-chan V) Seq[V] {
+	return Seq[V](seqFromChan(ch))
+}
+
+// TakeWhile yields elements while the predicate returns true, stopping at the first false.
+func (seq Seq[V]) TakeWhile(fn func(V) bool) Seq[V] {
+	return func(yield func(V) bool) {
+		seq(func(v V) bool {
+			if !fn(v) {
+				return false
+			}
+
+			return yield(v)
+		})
+	}
+}
+
+// SkipWhile skips elements while the predicate returns true, then yields the rest.
+func (seq Seq[V]) SkipWhile(fn func(V) bool) Seq[V] {
+	return func(yield func(V) bool) {
+		skipping := true
+
+		seq(func(v V) bool {
+			if skipping && fn(v) {
+				return true
+			}
+
+			skipping = false
+
+			return yield(v)
+		})
+	}
+}
+
+// ── iterator core (value sequences), ported from github.com/enetx/iter (MIT) ──
+
+// seqDedupBy removes consecutive elements where the provided function returns the same value.
+func (seq Seq[T]) seqDedupBy(eq func(a, b T) bool) Seq[T] {
+	return func(yield func(T) bool) {
+		var prev T
+		first := true
+		seq(func(v T) bool {
+			if first || !eq(prev, v) {
+				prev = v
+				first = false
+				return yield(v)
+			}
+			return true
+		})
+	}
+}
+
+// seqFromChan creates a sequence from a channel.
+// The sequence will stop when the channel is closed.
+func seqFromChan[T any](ch <-chan T) Seq[T] {
+	return func(yield func(T) bool) {
+		for v := range ch {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// seqFromSlice creates a sequence that iterates over the given slice in forward order.
+func seqFromSlice[T any](sl []T) Seq[T] {
+	return func(yield func(T) bool) {
+		for _, v := range sl {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// seqNext extracts the first element from the sequence and returns the remaining sequence.
+// Returns (value, remainingSeq, true) if an element exists, or (zero, nil, false) if empty.
+func (seq Seq[T]) seqNext() (T, Seq[T], bool) {
+	next, stop := seq.seqPull()
+
+	first, ok := next()
+	if !ok {
+		stop()
+		var zero T
+		return zero, nil, false
+	}
+
+	// The remaining sequence continues from the same pull iterator, so the source
+	// is walked exactly once. This makes Next O(1) per element and correct for
+	// non-deterministic sources (e.g. map-backed sets, channels), at the cost of
+	// the remaining sequence being single-use.
+	remaining := func(yield func(T) bool) {
+		defer stop()
+		for {
+			v, ok := next()
+			if !ok {
+				return
+			}
+			if !yield(v) {
+				return
+			}
+		}
+	}
+
+	return first, remaining, true
+}
+
+// seqPull converts a push-style iterator (Seq) to a pull-style iterator.
+// Returns a next function that yields the next value and a boolean indicating if valid,
+// and a stop function that should be called to release resources.
+func (seq Seq[T]) seqPull() (next func() (T, bool), stop func()) {
+	return iter.Pull(iter.Seq[T](seq))
+}
+
+// seqToSlice collects all elements from the sequence into a slice.
+func (seq Seq[T]) seqToSlice() []T {
+	out := make([]T, 0)
+	seq(func(v T) bool {
+		out = append(out, v)
+		return true
+	})
+	return out
+}
+
+// ── shared helpers (formerly iter_shared.go) ──
+
+// isValueComparable reports whether values of type V can be compared with ==
+// (V is a comparable type and not the bare interface any). It is the shared
+// guard used by Dedup/Unique across the container and iterator types.
+func isValueComparable[V any]() bool {
+	return f.IsComparable[V]() && reflect.TypeFor[V]().Kind() != reflect.Interface
+}
+
+// flattenValue recursively descends slices and arrays within item, emitting each
+// leaf element assignable to V. It stops and returns false as soon as emit
+// returns false. It backs the Flatten method across the Seq types.
+func flattenValue[V any](item any, emit func(V) bool) bool {
+	rv := reflect.ValueOf(item)
+	switch rv.Kind() {
+	case reflect.Slice, reflect.Array:
+		for i := range rv.Len() {
+			if !flattenValue(rv.Index(i).Interface(), emit) {
+				return false
+			}
+		}
+	default:
+		if v, ok := item.(V); ok {
+			if !emit(v) {
+				return false
+			}
+		}
+	}
+
+	return true
+}
diff --git a/backend/vendor/github.com/enetx/g/seq2.go b/backend/vendor/github.com/enetx/g/seq2.go
new file mode 100644
index 00000000..779ad3c2
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/seq2.go
@@ -0,0 +1,1152 @@
+package g
+
+import (
+	"context"
+	"iter"
+	"reflect"
+	"slices"
+
+	"github.com/enetx/g/cmp"
+	"github.com/enetx/g/constraints"
+)
+
+// Seq2 is an iterator over sequences of ordered pairs of values, most commonly ordered key-value pairs.
+type Seq2[K, V any] func(yield func(K, V) bool)
+
+// Pull converts the “push-style” iterator sequence seq
+// into a “pull-style” iterator accessed by the two functions
+// next and stop.
+//
+// Next returns the next pair in the sequence
+// and a boolean indicating whether the pair is valid.
+// When the sequence is over, next returns a pair of zero values and false.
+// It is valid to call next after reaching the end of the sequence
+// or after calling stop. These calls will continue
+// to return a pair of zero values and false.
+//
+// Stop ends the iteration. It must be called when the caller is
+// no longer interested in next values and next has not yet
+// signaled that the sequence is over (with a false boolean return).
+// It is valid to call stop multiple times and when next has
+// already returned false.
+//
+// It is an error to call next or stop from multiple goroutines
+// simultaneously.
+func (seq Seq2[K, V]) Pull() (func() (K, V, bool), func()) {
+	return seq.seq2Pull()
+}
+
+// All checks whether all key-value pairs in the iterator satisfy the provided condition.
+// This function is useful when you want to determine if all pairs in an iterator
+// meet a specific criteria.
+//
+// Parameters:
+// - fn (func(K, V) bool): A function that returns a boolean indicating whether the pair satisfies
+// the condition.
+//
+// Returns:
+// - bool: True if all pairs in the iterator satisfy the condition, false otherwise.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[g.String, g.Int]()
+//	m.Insert("a", 1)
+//	m.Insert("b", 2)
+//	allPositive := m.Iter().All(func(_ g.String, v g.Int) bool { return v > 0 })
+//
+// The resulting allPositive will be true if all values returned by the iterator are positive.
+func (seq Seq2[K, V]) All(fn func(K, V) bool) bool {
+	all := true
+
+	seq(func(k K, v V) bool {
+		if !fn(k, v) {
+			all = false
+			return false
+		}
+
+		return true
+	})
+
+	return all
+}
+
+// Any checks whether any key-value pair in the iterator satisfies the provided condition.
+// This function is useful when you want to determine if at least one pair in an iterator
+// meets a specific criteria.
+//
+// Parameters:
+// - fn (func(K, V) bool): A function that returns a boolean indicating whether the pair satisfies
+// the condition.
+//
+// Returns:
+// - bool: True if at least one pair in the iterator satisfies the condition, false otherwise.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[g.String, g.Int]()
+//	m.Insert("a", 1)
+//	m.Insert("b", 2)
+//	anyEven := m.Iter().Any(func(_ g.String, v g.Int) bool { return v%2 == 0 })
+//
+// The resulting anyEven will be true if at least one value returned by the iterator is even.
+func (seq Seq2[K, V]) Any(fn func(K, V) bool) bool {
+	found := false
+
+	seq(func(k K, v V) bool {
+		if fn(k, v) {
+			found = true
+			return false
+		}
+
+		return true
+	})
+
+	return found
+}
+
+// Keys returns an iterator over the keys of the key-value pairs.
+func (seq Seq2[K, V]) Keys() Seq[K] {
+	return func(yield func(K) bool) { seq(func(k K, _ V) bool { return yield(k) }) }
+}
+
+// Values returns an iterator over the values of the key-value pairs.
+func (seq Seq2[K, V]) Values() Seq[V] {
+	return func(yield func(V) bool) { seq(func(_ K, v V) bool { return yield(v) }) }
+}
+
+// Unzip consumes the sequence and collects the keys and values
+// of each pair into two separate slices.
+func (seq Seq2[K, V]) Unzip() (Slice[K], Slice[V]) {
+	var (
+		keys   Slice[K]
+		values Slice[V]
+	)
+
+	seq(func(k K, v V) bool {
+		keys = append(keys, k)
+		values = append(values, v)
+
+		return true
+	})
+
+	return keys, values
+}
+
+// SortBy applies a custom sorting function to the elements in the iterator
+// and returns a new iterator containing the sorted elements.
+//
+// The sorting function 'fn' should take two arguments, 'a' and 'b', of type Pair[K, V],
+// and return a cmp.Ordering: cmp.Less orders 'a' before 'b', cmp.More after it.
+//
+// Example:
+//
+//	m := g.NewMapOrd[g.Int, g.String]()
+//	m.Insert(6, "bb")
+//	m.Insert(0, "dd")
+//	m.Insert(1, "aa")
+//	m.Insert(5, "xx")
+//	m.Insert(2, "cc")
+//	m.Insert(3, "ff")
+//	m.Insert(4, "zz")
+//
+//	m.Iter().
+//		SortBy(
+//			func(a, b g.Pair[g.Int, g.String]) cmp.Ordering {
+//				return a.Key.Cmp(b.Key)
+//				// return a.Value.Cmp(b.Value)
+//			}).
+//		Collect().
+//		MapOrd[g.Int, g.String]().
+//		Print()
+//
+// Output: MapOrd{0:dd, 1:aa, 2:cc, 3:ff, 4:zz, 5:xx, 6:bb}
+//
+// The returned iterator is of type Seq2[K, V], which implements the iterator
+// interface for further iteration over the sorted elements.
+func (seq Seq2[K, V]) SortBy(fn func(a, b Pair[K, V]) cmp.Ordering) Seq2[K, V] {
+	buf := seq.seq2ToPairs()
+	slices.SortFunc(buf, func(a, b Pair[K, V]) int { return int(fn(a, b)) })
+
+	return seqFromPairs(buf)
+}
+
+// SortByKey applies a custom sorting function to the keys in the iterator
+// and returns a new iterator containing the sorted elements.
+//
+// The sorting function 'fn' should take two arguments, 'a' and 'b', of type K,
+// and return a cmp.Ordering: cmp.Less orders 'a' before 'b', cmp.More after it.
+//
+// Example:
+//
+//	m := g.NewMapOrd[g.Int, g.String]()
+//	m.Insert(6, "bb")
+//	m.Insert(0, "dd")
+//	m.Insert(1, "aa")
+//	m.Insert(5, "xx")
+//	m.Insert(2, "cc")
+//	m.Insert(3, "ff")
+//	m.Insert(4, "zz")
+//
+//	m.Iter().
+//		SortByKey(g.Int.Cmp).
+//		Collect().
+//		MapOrd[g.Int, g.String]().
+//		Print()
+//
+// Output: MapOrd{0:dd, 1:aa, 2:cc, 3:ff, 4:zz, 5:xx, 6:bb}
+func (seq Seq2[K, V]) SortByKey(fn func(a, b K) cmp.Ordering) Seq2[K, V] {
+	buf := seq.seq2ToPairs()
+	slices.SortFunc(buf, func(a, b Pair[K, V]) int { return int(fn(a.Key, b.Key)) })
+
+	return seqFromPairs(buf)
+}
+
+// SortByValue applies a custom sorting function to the values in the iterator
+// and returns a new iterator containing the sorted elements.
+//
+// The sorting function 'fn' should take two arguments, 'a' and 'b', of type V,
+// and return a cmp.Ordering: cmp.Less orders 'a' before 'b', cmp.More after it.
+//
+// Example:
+//
+//	m := g.NewMapOrd[g.Int, g.String]()
+//	m.Insert(6, "bb")
+//	m.Insert(0, "dd")
+//	m.Insert(1, "aa")
+//	m.Insert(5, "xx")
+//	m.Insert(2, "cc")
+//	m.Insert(3, "ff")
+//	m.Insert(4, "zz")
+//
+//	m.Iter().
+//		SortByValue(g.String.Cmp).
+//		Collect().
+//		MapOrd[g.Int, g.String]().
+//		Print()
+//
+// Output: MapOrd{1:aa, 6:bb, 2:cc, 0:dd, 3:ff, 5:xx, 4:zz}
+func (seq Seq2[K, V]) SortByValue(fn func(a, b V) cmp.Ordering) Seq2[K, V] {
+	buf := seq.seq2ToPairs()
+	slices.SortFunc(buf, func(a, b Pair[K, V]) int { return int(fn(a.Value, b.Value)) })
+
+	return seqFromPairs(buf)
+}
+
+// Inspect creates a new iterator that wraps around the current iterator
+// and allows inspecting each key-value pair as it passes through.
+func (seq Seq2[K, V]) Inspect(fn func(k K, v V)) Seq2[K, V] {
+	return func(yield func(K, V) bool) { seq(func(k K, v V) bool { fn(k, v); return yield(k, v) }) }
+}
+
+// StepBy creates a new iterator that iterates over every N-th element of the original iterator.
+// This function is useful when you want to skip a specific number of elements between each iteration.
+//
+// Parameters:
+// - n Int: The step size, indicating how many elements to skip between each iteration.
+//
+// Returns:
+// - Seq2[K, V]: A new iterator that produces key-value pairs from the original iterator with a step size of N.
+//
+// Example usage:
+//
+//	mapIter := g.MapOrd[string, int]{{"one", 1}, {"two", 2}, {"three", 3}}.Iter()
+//	iter := mapIter.StepBy(2)
+//	iter.Collect().MapOrd[string, int]().Print()
+//
+// Output: MapOrd{one:1, three:3}
+//
+// The resulting iterator will produce key-value pairs from the original iterator with a step size of N.
+func (seq Seq2[K, V]) StepBy(n Int) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		if n <= 0 {
+			return
+		}
+
+		index := Int(0)
+
+		seq(func(k K, v V) bool {
+			if index%n == 0 {
+				if !yield(k, v) {
+					return false
+				}
+			}
+
+			index++
+
+			return true
+		})
+	}
+}
+
+// Chain concatenates the current iterator with other iterators, returning a new iterator.
+//
+// The function creates a new iterator that combines the elements of the current iterator
+// with elements from the provided iterators in the order they are given.
+//
+// Params:
+//
+// - seqs ([]Seq2[K, V]): Other iterators to be concatenated with the current iterator.
+//
+// Returns:
+//
+// - Seq2[K, V]: A new iterator containing elements from the current iterator and the provided iterators.
+//
+// Example usage:
+//
+//	m1 := g.NewMapOrd[int, string]()
+//	m1.Insert(1, "a")
+//
+//	m2 := g.NewMapOrd[int, string]()
+//	m2.Insert(2, "b")
+//
+//	// Concatenating iterators and collecting the result.
+//	m1.Iter().Chain(m2.Iter()).Collect().MapOrd[int, string]().Print()
+//
+// Output: MapOrd{1:a, 2:b}
+//
+// The resulting iterator will contain elements from both iterators in the specified order.
+func (seq Seq2[K, V]) Chain(seqs ...Seq2[K, V]) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		proceed := true
+
+		seq(func(k K, v V) bool {
+			if !yield(k, v) {
+				proceed = false
+				return false
+			}
+
+			return true
+		})
+
+		if !proceed {
+			return
+		}
+
+		for _, rest := range seqs {
+			rest(func(k K, v V) bool {
+				if !yield(k, v) {
+					proceed = false
+					return false
+				}
+
+				return true
+			})
+
+			if !proceed {
+				return
+			}
+		}
+	}
+}
+
+// Count consumes the iterator, counting the number of iterations and returning it.
+func (seq Seq2[K, V]) Count() Int {
+	count := Int(0)
+	seq(func(K, V) bool { count++; return true })
+
+	return count
+}
+
+// Skip returns a new iterator skipping the first n elements.
+//
+// The function creates a new iterator that skips the first n elements of the current iterator
+// and returns an iterator starting from the (n+1)th element.
+//
+// Params:
+//
+// - n (Int): The number of elements to skip from the beginning of the iterator.
+// Negative values are treated as zero.
+//
+// Returns:
+//
+// - Seq2[K, V]: An iterator that starts after skipping the first n elements.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[int, string]()
+//	m.Insert(1, "a")
+//	m.Insert(2, "b")
+//	m.Insert(3, "c")
+//	m.Insert(4, "d")
+//
+//	// Skipping the first two elements and collecting the rest.
+//	m.Iter().Skip(2).Collect().MapOrd[int, string]().Print()
+//
+// Output: MapOrd{3:c, 4:d}
+//
+// The resulting iterator will start after skipping the specified number of elements.
+func (seq Seq2[K, V]) Skip(n Int) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		if n <= 0 {
+			seq(yield)
+			return
+		}
+
+		count := Int(0)
+
+		seq(func(k K, v V) bool {
+			if count < n {
+				count++
+				return true
+			}
+
+			return yield(k, v)
+		})
+	}
+}
+
+// Exclude returns a new iterator excluding elements that satisfy the provided function.
+//
+// The function creates a new iterator excluding elements from the current iterator
+// for which the provided function returns true.
+//
+// Params:
+//
+// - fn (func(K, V) bool): The function used to determine exclusion criteria for elements.
+//
+// Returns:
+//
+// - Seq2[K, V]: A new iterator excluding elements that satisfy the given condition.
+//
+// Example usage:
+//
+//	mo := g.NewMapOrd[int, int]()
+//	mo.Insert(1, 1)
+//	mo.Insert(2, 2)
+//	mo.Insert(3, 3)
+//	mo.Insert(4, 4)
+//	mo.Insert(5, 5)
+//
+//	notEven := mo.Iter().
+//		Exclude(
+//			func(k, v int) bool {
+//				return v%2 == 0
+//			}).
+//		Collect().MapOrd[int, int]()
+//	notEven.Print()
+//
+// Output: MapOrd{1:1, 3:3, 5:5}
+//
+// The resulting iterator will exclude elements based on the provided condition.
+func (seq Seq2[K, V]) Exclude(fn func(K, V) bool) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		seq(func(k K, v V) bool {
+			if !fn(k, v) {
+				return yield(k, v)
+			}
+
+			return true
+		})
+	}
+}
+
+// Filter returns a new iterator containing only the elements that satisfy the provided function.
+//
+// The function creates a new iterator including elements from the current iterator
+// for which the provided function returns true.
+//
+// Params:
+//
+// - fn (func(K, V) bool): The function used to determine inclusion criteria for elements.
+//
+// Returns:
+//
+// - Seq2[K, V]: A new iterator containing elements that satisfy the given condition.
+//
+// Example usage:
+//
+//	mo := g.NewMapOrd[int, int]()
+//	mo.Insert(1, 1)
+//	mo.Insert(2, 2)
+//	mo.Insert(3, 3)
+//	mo.Insert(4, 4)
+//	mo.Insert(5, 5)
+//
+//	even := mo.Iter().
+//		Filter(
+//			func(k, v int) bool {
+//				return v%2 == 0
+//			}).
+//		Collect().MapOrd[int, int]()
+//	even.Print()
+//
+// Output: MapOrd{2:2, 4:4}
+//
+// The resulting iterator will include elements based on the provided condition.
+func (seq Seq2[K, V]) Filter(fn func(K, V) bool) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		seq(func(k K, v V) bool {
+			if fn(k, v) {
+				return yield(k, v)
+			}
+
+			return true
+		})
+	}
+}
+
+// FilterByKey returns a new iterator lazily yielding only the pairs whose key
+// satisfies the provided predicate; values are not inspected.
+//
+// It lifts a single-parameter predicate to the pair-wise Filter — composes
+// with f.* factories:
+//
+//	mo.Iter().FilterByKey(f.Eq("host"))
+func (seq Seq2[K, V]) FilterByKey(fn func(K) bool) Seq2[K, V] {
+	return seq.Filter(func(k K, _ V) bool { return fn(k) })
+}
+
+// FilterByValue returns a new iterator lazily yielding only the pairs whose
+// value satisfies the provided predicate; keys are not inspected.
+//
+// It lifts a single-parameter predicate to the pair-wise Filter — composes
+// with f.* factories:
+//
+//	mo.Iter().FilterByValue(f.Gt(10))
+func (seq Seq2[K, V]) FilterByValue(fn func(V) bool) Seq2[K, V] {
+	return seq.Filter(func(_ K, v V) bool { return fn(v) })
+}
+
+// Find searches for an element in the iterator that satisfies the provided function.
+//
+// The function iterates through the elements of the iterator and returns the first element
+// for which the provided function returns true.
+//
+// Params:
+//
+// - fn (func(K, V) bool): The function used to test elements for a condition.
+//
+// Returns:
+//
+// - Option[Pair[K, V]]: An Option containing the first pair that satisfies the condition; None if not found.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[int, int]()
+//	m.Insert(1, 1)
+//	f := m.Iter().Find(func(_ int, v int) bool { return v == 1 })
+//	if f.IsSome() {
+//		print(f.Some().Key)
+//	}
+//
+// The resulting Option may contain the first element that satisfies the condition, or None if not found.
+func (seq Seq2[K, V]) Find(fn func(k K, v V) bool) Option[Pair[K, V]] {
+	var result Option[Pair[K, V]]
+
+	seq(func(k K, v V) bool {
+		if fn(k, v) {
+			result = Some(Pair[K, V]{Key: k, Value: v})
+			return false
+		}
+
+		return true
+	})
+
+	return result
+}
+
+// ForEach iterates through all elements and applies the given function to each key-value pair.
+//
+// The function applies the provided function to each key-value pair in the iterator.
+//
+// Params:
+//
+// - fn (func(K, V)): The function to be applied to each key-value pair in the iterator.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[int, int]()
+//	m.Insert(1, 1)
+//	m.Insert(2, 2)
+//	m.Insert(3, 3)
+//	m.Insert(4, 4)
+//	m.Insert(5, 5)
+//
+//	m.Iter().ForEach(func(key, val int) {
+//	    // Process key-value pair
+//	})
+//
+// The provided function will be applied to each key-value pair in the iterator.
+func (seq Seq2[K, V]) ForEach(fn func(k K, v V)) {
+	seq(func(k K, v V) bool { fn(k, v); return true })
+}
+
+// Map creates a new iterator by applying the given function to each key-value pair.
+//
+// The function creates a new iterator by applying the provided function to each key-value pair in the iterator.
+//
+// Params:
+//
+// - transform (func(K, V) (K2, V2)): The function used to transform each key-value pair
+// in the iterator. The key and value types of the result may differ.
+//
+// Returns:
+//
+// - Seq2[K2, V2]: A new iterator containing transformed key-value pairs.
+//
+// Example usage:
+//
+//	mo := g.NewMapOrd[int, int]()
+//	mo.Insert(1, 1)
+//	mo.Insert(2, 2)
+//	mo.Insert(3, 3)
+//	mo.Insert(4, 4)
+//	mo.Insert(5, 5)
+//
+//	momap := mo.Iter().
+//		Map(
+//			func(k, v int) (int, int) {
+//				return k * k, v * v
+//			}).
+//		Collect().MapOrd[int, int]()
+//
+//	momap.Print()
+//
+// Output: MapOrd{1:1, 4:4, 9:9, 16:16, 25:25}
+//
+// The resulting iterator will contain transformed key-value pairs.
+func (seq Seq2[K, V]) Map[K2, V2 any](transform func(K, V) (K2, V2)) Seq2[K2, V2] {
+	return func(yield func(K2, V2) bool) {
+		seq(func(k K, v V) bool { return yield(transform(k, v)) })
+	}
+}
+
+// FilterMap applies a function to each key-value pair and filters out None results.
+//
+// Pairs where the function returns None are filtered out; pairs where it returns
+// Some(Pair) are transformed and included in the result. Key and value types may differ
+// from the input types.
+func (seq Seq2[K, V]) FilterMap[K2, V2 any](fn func(K, V) Option[Pair[K2, V2]]) Seq2[K2, V2] {
+	return func(yield func(K2, V2) bool) {
+		seq(func(k K, v V) bool {
+			if pair, ok := fn(k, v).Option(); ok {
+				return yield(pair.Unpack())
+			}
+
+			return true
+		})
+	}
+}
+
+// Range iterates through elements until the given function returns false.
+//
+// The function iterates through the key-value pairs in the iterator, applying the provided function to each pair.
+// It continues iterating until the function returns false.
+//
+// Params:
+//
+// - fn (func(K, V) bool): The function to be applied to each key-value pair in the iterator.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[int, int]()
+//	m.Insert(1, 1)
+//	m.Insert(2, 2)
+//	m.Insert(3, 3)
+//	m.Insert(4, 4)
+//	m.Insert(5, 5)
+//
+//	m.Iter().Range(func(k, v int) bool {
+//	    fmt.Println(v) // Replace this with the function logic you need.
+//	    return v < 5 // Replace this with the condition for continuing iteration.
+//	})
+//
+// The iteration will stop when the provided function returns false.
+func (seq Seq2[K, V]) Range(fn func(k K, v V) bool) {
+	seq(fn)
+}
+
+// Context allows the iteration to be controlled with a context.Context.
+func (seq Seq2[K, V]) Context(ctx context.Context) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		if err := ctx.Err(); err != nil {
+			return
+		}
+
+		seq(func(k K, v V) bool {
+			select {
+			case <-ctx.Done():
+				return false
+			default:
+				return yield(k, v)
+			}
+		})
+	}
+}
+
+// Take returns a new iterator with the first n elements.
+// The function creates a new iterator containing the first n elements from the original iterator.
+func (seq Seq2[K, V]) Take(n Int) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		if n <= 0 {
+			return
+		}
+
+		count := Int(0)
+
+		seq(func(k K, v V) bool {
+			if count >= n {
+				return false
+			}
+
+			count++
+
+			return yield(k, v)
+		})
+	}
+}
+
+// First returns the first key-value pair from the sequence.
+func (seq Seq2[K, V]) First() Option[Pair[K, V]] {
+	var result Option[Pair[K, V]]
+
+	seq(func(k K, v V) bool {
+		result = Some(Pair[K, V]{Key: k, Value: v})
+		return false
+	})
+
+	return result
+}
+
+// Last returns the last key-value pair from the sequence.
+func (seq Seq2[K, V]) Last() Option[Pair[K, V]] {
+	var result Option[Pair[K, V]]
+
+	seq(func(k K, v V) bool {
+		result = Some(Pair[K, V]{Key: k, Value: v})
+		return true
+	})
+
+	return result
+}
+
+// Nth returns the nth key-value pair (0-indexed) in the sequence.
+func (seq Seq2[K, V]) Nth(n Int) Option[Pair[K, V]] {
+	var result Option[Pair[K, V]]
+
+	index := Int(0)
+
+	seq(func(k K, v V) bool {
+		if index == n {
+			result = Some(Pair[K, V]{Key: k, Value: v})
+			return false
+		}
+
+		index++
+
+		return true
+	})
+
+	return result
+}
+
+// Chan converts the iterator into a channel, optionally with context(s).
+//
+// The function converts the key-value pairs from the iterator into a channel, allowing iterative processing
+// using channels. It can be used to stream key-value pairs for concurrent or asynchronous operations.
+//
+// Params:
+//
+// - ctxs (...context.Context): Optional context(s) that can be used to cancel or set deadlines for the operation.
+//
+// Returns:
+//
+// - chan Pair[K, V]: A channel emitting key-value pairs from the iterator.
+//
+// Example usage:
+//
+//	m := g.NewMapOrd[int, int]()
+//	m.Insert(1, 1)
+//	m.Insert(2, 2)
+//	m.Insert(3, 3)
+//	m.Insert(4, 4)
+//	m.Insert(5, 5)
+//
+//	ctx, cancel := context.WithCancel(context.Background())
+//	defer cancel() // Ensure cancellation to avoid goroutine leaks.
+//
+//	ch := m.Iter().Chan(ctx)
+//	for pair := range ch {
+//	    // Process key-value pair from the channel
+//	}
+//
+// The function converts the iterator into a channel to allow sequential or concurrent processing of key-value pairs.
+func (seq Seq2[K, V]) Chan(ctxs ...context.Context) chan Pair[K, V] {
+	ctx := context.Background()
+	if len(ctxs) > 0 {
+		ctx = ctxs[0]
+	}
+
+	ch := make(chan Pair[K, V])
+
+	go func() {
+		defer close(ch)
+
+		if err := ctx.Err(); err != nil {
+			return
+		}
+
+		seq(func(k K, v V) bool {
+			select {
+			case <-ctx.Done():
+				return false
+			case ch <- Pair[K, V]{k, v}:
+				return true
+			}
+		})
+	}()
+
+	return ch
+}
+
+// Next extracts the next key-value pair from the iterator and advances it.
+//
+// This method consumes the next key-value pair from the iterator and returns them wrapped in an Option.
+// The iterator itself is modified to point to the remaining elements.
+//
+// Returns:
+// - Option[Pair[K, V]]: Some(Pair{Key, Value}) if a pair exists, None if the iterator is exhausted.
+func (seq *Seq2[K, V]) Next() Option[Pair[K, V]] {
+	if key, value, remaining, ok := (*seq).seq2Next(); ok {
+		*seq = Seq2[K, V](remaining)
+		return Some(Pair[K, V]{Key: key, Value: value})
+	}
+
+	return None[Pair[K, V]]()
+}
+
+// Fold reduces the sequence of key-value pairs to a single value using an accumulator.
+// The accumulator type may differ from the key and value types.
+func (seq Seq2[K, V]) Fold[A any](init A, fn func(acc A, k K, v V) A) A {
+	seq(func(k K, v V) bool { init = fn(init, k, v); return true })
+	return init
+}
+
+// SumBy maps each key-value pair to a numeric value via fn and returns the sum of those values,
+// visiting pairs in insertion order. An empty sequence yields the zero value of S.
+func (seq Seq2[K, V]) SumBy[S constraints.Number](fn func(K, V) S) S {
+	var zero S
+	return seq.Fold(zero, func(acc S, k K, v V) S { return acc + fn(k, v) })
+}
+
+// ProductBy maps each key-value pair to a numeric value via fn and returns their
+// product, in insertion order. An empty sequence yields the multiplicative
+// identity, one.
+func (seq Seq2[K, V]) ProductBy[S constraints.Number](fn func(K, V) S) S {
+	return seq.Fold(S(1), func(acc S, k K, v V) S { return acc * fn(k, v) })
+}
+
+// FindMap applies fn to each key-value pair in insertion order and returns the
+// first Some result, or None if fn returns None for every pair.
+func (seq Seq2[K, V]) FindMap[U any](fn func(K, V) Option[U]) Option[U] {
+	var result Option[U]
+
+	seq(func(k K, v V) bool {
+		if o := fn(k, v); o.IsSome() {
+			result = o
+			return false
+		}
+
+		return true
+	})
+
+	return result
+}
+
+// TryMap applies a fallible transform to each key-value pair and enters the
+// Result pipeline, producing a SeqResult[U]. See [Seq.TryMap] for the full
+// contract.
+func (seq Seq2[K, V]) TryMap[U any](fn func(K, V) Result[U]) SeqResult[U] {
+	return func(yield func(Result[U]) bool) {
+		seq(func(k K, v V) bool {
+			return yield(fn(k, v))
+		})
+	}
+}
+
+// TakeWhile yields key-value pairs while the predicate returns true, stopping at the first false.
+func (seq Seq2[K, V]) TakeWhile(fn func(K, V) bool) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		seq(func(k K, v V) bool {
+			if !fn(k, v) {
+				return false
+			}
+
+			return yield(k, v)
+		})
+	}
+}
+
+// SkipWhile skips key-value pairs while the predicate returns true, then yields the rest.
+func (seq Seq2[K, V]) SkipWhile(fn func(K, V) bool) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		skipping := true
+
+		seq(func(k K, v V) bool {
+			if skipping && fn(k, v) {
+				return true
+			}
+
+			skipping = false
+
+			return yield(k, v)
+		})
+	}
+}
+
+// Dedup returns a new iterator that removes consecutive pairs with duplicate keys,
+// keeping the first pair of each run; values are not inspected. If the sequence is
+// sorted by key, all keys will be unique. It mirrors [Seq.Dedup], comparing keys
+// with == when K is a comparable type and falling back to reflect.DeepEqual
+// otherwise.
+//
+// Example usage:
+//
+//	mo := g.MapOrd[g.Int, g.String]{{1, "a"}, {1, "b"}, {2, "c"}}
+//	mo.Iter().Dedup().Collect().MapOrd[g.Int, g.String]().Print()
+//
+// Output: MapOrd{1:a, 2:c}
+func (seq Seq2[K, V]) Dedup() Seq2[K, V] {
+	eq := func(a, b K) bool { return reflect.DeepEqual(a, b) }
+	if isValueComparable[K]() {
+		eq = func(a, b K) bool { return any(a) == any(b) }
+	}
+
+	return func(yield func(K, V) bool) {
+		var prev K
+
+		first := true
+
+		seq(func(k K, v V) bool {
+			if first || !eq(prev, k) {
+				prev = k
+				first = false
+
+				return yield(k, v)
+			}
+
+			return true
+		})
+	}
+}
+
+// Unique returns a new iterator yielding only the first pair for each distinct key;
+// later pairs with an already-seen key are dropped and values are not inspected.
+// It mirrors [Seq.Unique]. The keys are tracked in a map, so a key type that is
+// not hashable at runtime (e.g. a slice, map, function, or a struct containing
+// one) panics with "hash of unhashable type".
+//
+// Example usage:
+//
+//	mo := g.MapOrd[g.Int, g.String]{{1, "a"}, {2, "b"}, {1, "c"}}
+//	mo.Iter().Unique().Collect().MapOrd[g.Int, g.String]().Print()
+//
+// Output: MapOrd{1:a, 2:b}
+func (seq Seq2[K, V]) Unique() Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		seen := make(map[any]struct{})
+
+		seq(func(k K, v V) bool {
+			key := any(k)
+			if _, exists := seen[key]; !exists {
+				seen[key] = struct{}{}
+				return yield(k, v)
+			}
+
+			return true
+		})
+	}
+}
+
+// MaxBy returns the maximum pair in the sequence using the provided comparison
+// function, mirroring [Seq.MaxBy]. It returns None if the sequence is empty.
+func (seq Seq2[K, V]) MaxBy(fn func(a, b Pair[K, V]) cmp.Ordering) Option[Pair[K, V]] {
+	var max Pair[K, V]
+
+	found := false
+
+	seq(func(k K, v V) bool {
+		pair := Pair[K, V]{Key: k, Value: v}
+		if !found || fn(max, pair) == cmp.Less {
+			max = pair
+			found = true
+		}
+
+		return true
+	})
+
+	return OptionOf(max, found)
+}
+
+// MinBy returns the minimum pair in the sequence using the provided comparison
+// function, mirroring [Seq.MinBy]. It returns None if the sequence is empty.
+func (seq Seq2[K, V]) MinBy(fn func(a, b Pair[K, V]) cmp.Ordering) Option[Pair[K, V]] {
+	var min Pair[K, V]
+
+	found := false
+
+	seq(func(k K, v V) bool {
+		pair := Pair[K, V]{Key: k, Value: v}
+		if !found || fn(pair, min) == cmp.Less {
+			min = pair
+			found = true
+		}
+
+		return true
+	})
+
+	return OptionOf(min, found)
+}
+
+// Reduce aggregates the pairs of the sequence using the provided function,
+// mirroring [Seq.Reduce]. The first pair is used as the initial accumulator
+// value. It returns None if the sequence is empty.
+func (seq Seq2[K, V]) Reduce(fn func(a, b Pair[K, V]) Pair[K, V]) Option[Pair[K, V]] {
+	var acc Pair[K, V]
+
+	first := true
+
+	seq(func(k K, v V) bool {
+		pair := Pair[K, V]{Key: k, Value: v}
+		if first {
+			acc = pair
+			first = false
+		} else {
+			acc = fn(acc, pair)
+		}
+
+		return true
+	})
+
+	return OptionOf(acc, !first)
+}
+
+// Scan accumulates the pairs of the sequence using a function, yielding the
+// initial value followed by each intermediate accumulator state, mirroring
+// [Seq.Scan]. The accumulator type may differ from the key and value types.
+//
+// Example usage:
+//
+//	mo := g.MapOrd[g.String, g.Int]{{"a", 1}, {"b", 2}, {"c", 3}}
+//	sums := mo.Iter().Scan(0, func(acc int, _ g.String, v g.Int) int {
+//		return acc + int(v)
+//	})
+//	// sums will yield: 0, 1, 3, 6
+func (seq Seq2[K, V]) Scan[A any](init A, fn func(acc A, k K, v V) A) Seq[A] {
+	return func(yield func(A) bool) {
+		if !yield(init) {
+			return
+		}
+
+		acc := init
+
+		seq(func(k K, v V) bool {
+			acc = fn(acc, k, v)
+			return yield(acc)
+		})
+	}
+}
+
+// Intersperse inserts the provided separator pair between each consecutive pair
+// of elements in the original iterator, mirroring [Seq.Intersperse].
+func (seq Seq2[K, V]) Intersperse(sep Pair[K, V]) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		first := true
+
+		seq(func(k K, v V) bool {
+			if !first && !yield(sep.Unpack()) {
+				return false
+			}
+
+			first = false
+
+			return yield(k, v)
+		})
+	}
+}
+
+// MapTo transforms each pair into a single value using the given function,
+// returning a value sequence of the results. It complements [Seq2.Map], which
+// keeps the pair shape.
+func (seq Seq2[K, V]) MapTo[T any](fn func(K, V) T) Seq[T] {
+	return func(yield func(T) bool) {
+		seq(func(k K, v V) bool { return yield(fn(k, v)) })
+	}
+}
+
+// ── iterator core (key-value sequences), ported from github.com/enetx/iter (MIT) ──
+
+// seq2Next extracts the first key-value pair from the sequence and returns the remaining sequence.
+// Returns (key, value, remainingSeq, true) if a pair exists, or (zeroK, zeroV, nil, false) if empty.
+//
+// Example:
+//
+//	s := Map[int, string]{1: "a", 2: "b", 3: "c"}.Iter()
+//	k, v, rest, ok := s.seq2Next()
+//	// k = 1, v = "a", ok = true (order not guaranteed for maps)
+//	// rest yields remaining pairs
+//
+//	k2, v2, rest2, ok2 := rest.seq2Next()
+//	// k2 = 2, v2 = "b", ok2 = true
+//	// rest2 yields remaining pairs
+func (seq Seq2[K, V]) seq2Next() (K, V, Seq2[K, V], bool) {
+	next, stop := seq.seq2Pull()
+
+	firstK, firstV, ok := next()
+	if !ok {
+		stop()
+		var zeroK K
+		var zeroV V
+		return zeroK, zeroV, nil, false
+	}
+
+	// The remaining sequence continues from the same pull iterator, so the source
+	// is walked exactly once. This makes Next O(1) per element and correct for
+	// non-deterministic sources (e.g. maps), at the cost of the remaining
+	// sequence being single-use.
+	remaining := func(yield func(K, V) bool) {
+		defer stop()
+		for {
+			k, v, ok := next()
+			if !ok {
+				return
+			}
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+
+	return firstK, firstV, remaining, true
+}
+
+// seq2Pull converts a push-style iterator (Seq2) to a pull-style iterator.
+func (seq Seq2[K, V]) seq2Pull() (next func() (K, V, bool), stop func()) {
+	return iter.Pull2(iter.Seq2[K, V](seq))
+}
+
+// seq2ToPairs collects all key-value pairs into a slice of Pair structs.
+func (seq Seq2[K, V]) seq2ToPairs() []Pair[K, V] {
+	out := make([]Pair[K, V], 0)
+	seq(func(k K, v V) bool {
+		out = append(out, Pair[K, V]{k, v})
+		return true
+	})
+	return out
+}
+
+// seqFromPairs creates a Seq2 from a slice of key-value pairs.
+//
+// Example:
+//
+//	pairs := []Pair[int, string]{{1, "a"}, {2, "b"}}
+//	s := seqFromPairs(pairs)
+func seqFromPairs[K, V any](pairs []Pair[K, V]) Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for _, p := range pairs {
+			if !yield(p.Unpack()) {
+				return
+			}
+		}
+	}
+}
diff --git a/backend/vendor/github.com/enetx/g/seq_collect.go b/backend/vendor/github.com/enetx/g/seq_collect.go
new file mode 100644
index 00000000..5c47f40e
--- /dev/null
+++ b/backend/vendor/github.com/enetx/g/seq_collect.go
@@ -0,0 +1,147 @@
+package g
+
+import "github.com/enetx/g/cmp"
+
+// Collect returns a collector over the sequence. Collect itself is lazy and
+// does not consume the sequence; only the collector's materializer methods do,
+// turning the elements into a concrete container:
+//
+//	s.Iter().Filter(fn).Collect().Slice()
+//	s.Iter().Filter(fn).Collect().Set[int]()
+//	s.Iter().Collect().Heap(cmp.Cmp)
+//	s.Iter().Collect().Deque()
+//
+// Set (like Map/MapOrd/MapSafe on the key-value collector) takes the element
+// type as an explicit type argument: Go checks constraints at method
+// DECLARATION, where the sequence's own type parameter is still `any`, so a
+// method of Seq[V any] can never mention Set[V] — the comparable constraint
+// must live on the method's own type parameter, and that parameter cannot be
+// inferred from zero arguments. The other collectors need no annotations.
+func (seq Seq[V]) Collect() collector[V] { return collector[V]{seq} }
+
+// Collect returns a collector over the key-value sequence. Collect itself is
+// lazy and does not consume the sequence; only the collector's materializer
+// methods do, turning the pairs into a concrete container:
+//
+//	m.Iter().FilterByKey(fn).Collect().Pairs()
+//	m.Iter().FilterByKey(fn).Collect().Map[string, string]()
+//	mo.Iter().Collect().MapOrd[string, string]()
+func (seq Seq2[K, V]) Collect() collector2[K, V] { return collector2[K, V]{seq} }
+
+// collector materializes a value sequence into containers; build one with
+// Seq.Collect.
+type collector[V any] struct{ seq Seq[V] }
+
+// collector2 materializes a key-value sequence into containers; build one with
+// Seq2.Collect.
+type collector2[K, V any] struct{ seq Seq2[K, V] }
+
+// Slice consumes the sequence and returns its elements as a Slice.
+func (c collector[V]) Slice() Slice[V] { return c.seq.seqToSlice() }
+
+// Deque consumes the sequence and returns its elements as a Deque, preserving
+// order.
+func (c collector[V]) Deque() *Deque[V] {
+	result := NewDeque[V]()
+
+	c.seq(func(v V) bool {
+		result.PushBack(v)
+		return true
+	})
+
+	return result
+}
+
+// Heap consumes the sequence and returns its elements as a Heap ordered by
+// compareFn.
+func (c collector[V]) Heap(compareFn func(V, V) cmp.Ordering) *Heap[V] {
+	result := NewHeap(compareFn)
+
+	c.seq(func(v V) bool {
+		result.Push(v)
+		return true
+	})
+
+	return result
+}
+
+// Set consumes the sequence and returns its elements as a Set, deduplicating
+// them. The element type is passed explicitly — Collect().Set[int]() — because
+// the sequence's own type parameter cannot carry the comparable constraint;
+// each element is converted at runtime and a mismatched type argument panics.
+func (c collector[V]) Set[W comparable]() Set[W] {
+	collection := make(Set[W])
+
+	c.seq(func(v V) bool {
+		collection[any(v).(W)] = Unit{}
+		return true
+	})
+
+	return collection
+}
+
+// Pairs consumes the sequence and returns its elements as plain pairs.
+func (c collector2[K, V]) Pairs() []Pair[K, V] {
+	var result []Pair[K, V]
+
+	c.seq(func(k K, v V) bool {
+		result = append(result, Pair[K, V]{Key: k, Value: v})
+		return true
+	})
+
+	return result
+}
+
+// Map consumes the key-value sequence and returns it as a Map; later keys
+// overwrite earlier ones. Both types are passed explicitly, mirroring the
+// container's own signature — Collect().Map[string, int]() — because the
+// sequence's key parameter cannot carry the comparable constraint; the pairs
+// are converted at runtime and a mismatched type argument panics.
+func (c collector2[K, V]) Map[K2 comparable, V2 any]() Map[K2, V2] {
+	collection := NewMap[K2, V2]()
+
+	c.seq(func(k K, v V) bool {
+		collection[any(k).(K2)] = any(v).(V2)
+		return true
+	})
+
+	return collection
+}
+
+// MapSafe consumes the key-value sequence and returns it as a thread-safe
+// MapSafe; later keys overwrite earlier ones. Both types are passed explicitly
+// — Collect().MapSafe[string, int]() — see [collector2.Map].
+func (c collector2[K, V]) MapSafe[K2 comparable, V2 any]() *MapSafe[K2, V2] {
+	collection := NewMapSafe[K2, V2]()
+
+	c.seq(func(k K, v V) bool {
+		collection.Insert(any(k).(K2), any(v).(V2))
+		return true
+	})
+
+	return collection
+}
+
+// MapOrd consumes the key-value sequence and returns it as a MapOrd, keeping
+// first-seen key order; a repeated key updates the value in place. Both types
+// are passed explicitly — Collect().MapOrd[string, int]() — see
+// [collector2.Map].
+func (c collector2[K, V]) MapOrd[K2 comparable, V2 any]() MapOrd[K2, V2] {
+	collection := NewMapOrd[K2, V2]()
+	idx := make(map[K2]int)
+
+	c.seq(func(k K, v V) bool {
+		key := any(k).(K2)
+		if i, ok := idx[key]; ok {
+			collection[i].Value = any(v).(V2)
+			return true
+		}
+
+		collection = append(collection, Pair[K2, V2]{Key: key, Value: any(v).(V2)})
+		idx[key] = len(collection) - 1
+
+		return true
+	})
+
+	return collection
+}
diff --git a/backend/vendor/github.com/enetx/http/clientconn.go b/backend/vendor/github.com/enetx/http/clientconn.go
new file mode 100644
index 00000000..87b88727
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http/clientconn.go
@@ -0,0 +1,456 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"github.com/enetx/http/httptrace"
+	"net/url"
+	"sync"
+)
+
+// A ClientConn is a client connection to an HTTP server.
+//
+// Unlike a [Transport], a ClientConn represents a single connection.
+// Most users should use a Transport rather than creating client connections directly.
+type ClientConn struct {
+	cc genericClientConn
+
+	stateHookMu      sync.Mutex
+	userStateHook    func(*ClientConn)
+	stateHookRunning bool
+	lastAvailable    int
+	lastInFlight     int
+	lastClosed       bool
+}
+
+// newClientConner is the interface implemented by HTTP/2 transports to create new client conns.
+//
+// The http package (this package) needs a way to ask the http2 package to
+// create a client connection.
+//
+// Transport.TLSNextProto["h2"] contains a function which appears to do this,
+// but for historical reasons it does not: The TLSNextProto function adds a
+// *tls.Conn to the http2.Transport's connection pool and returns a RoundTripper
+// which is backed by that connection pool. NewClientConn needs a way to get a
+// single client connection out of the http2 package.
+//
+// The http2 package registers a RoundTripper with Transport.RegisterProtocol.
+// If this RoundTripper implements newClientConner, then Transport.NewClientConn will use
+// it to create new HTTP/2 client connections.
+type newClientConner interface {
+	// NewClientConn creates a new client connection from a net.Conn.
+	//
+	// The RoundTripper returned by NewClientConn must implement genericClientConn.
+	// (We don't define NewClientConn as returning genericClientConn,
+	// because either we'd need to make genericClientConn an exported type
+	// or define it as a type alias. Neither is particularly appealing.)
+	//
+	// The state hook passed here is the internal state hook
+	// (ClientConn.maybeRunStateHook). The internal state hook calls
+	// the user state hook (if any), which is set by the user with
+	// ClientConn.SetStateHook.
+	//
+	// The client connection should arrange to call the internal state hook
+	// when the connection closes, when requests complete, and when the
+	// connection concurrency limit changes.
+	//
+	// The client connection must call the internal state hook when the connection state
+	// changes asynchronously, such as when a request completes.
+	//
+	// The internal state hook need not be called after synchronous changes to the state:
+	// Close, Reserve, Release, and RoundTrip calls which don't start a request
+	// do not need to call the hook.
+	//
+	// The general idea is that if we call (for example) Close,
+	// we know that the connection state has probably changed and we
+	// don't need the state hook to tell us that.
+	// However, if the connection closes asynchronously
+	// (because, for example, the other end of the conn closed it),
+	// the state hook needs to inform us.
+	NewClientConn(nc net.Conn, internalStateHook func()) (RoundTripper, error)
+}
+
+// genericClientConn is an interface implemented by HTTP/2 client conns
+// returned from newClientConner.NewClientConn.
+//
+// See the newClientConner doc comment for more information.
+type genericClientConn interface {
+	Close() error
+	Err() error
+	RoundTrip(req *Request) (*Response, error)
+	Reserve() error
+	Release()
+	Available() int
+	InFlight() int
+}
+
+// NewClientConn creates a new client connection to the given address.
+//
+// If scheme is "http", the connection is unencrypted.
+// If scheme is "https", the connection uses TLS.
+//
+// The protocol used for the new connection is determined by the scheme,
+// Transport.Protocols configuration field, and protocols supported by the
+// server. See Transport.Protocols for more details.
+//
+// If Transport.Proxy is set and indicates that a request sent to the given
+// address should use a proxy, the new connection uses that proxy.
+//
+// NewClientConn always creates a new connection,
+// even if the Transport has an existing cached connection to the given host.
+//
+// The new connection is not added to the Transport's connection cache,
+// and will not be used by [Transport.RoundTrip].
+// It does not count against the MaxIdleConns and MaxConnsPerHost limits.
+//
+// The caller is responsible for closing the new connection.
+func (t *Transport) NewClientConn(ctx context.Context, scheme, address string) (*ClientConn, error) {
+	t.nextProtoOnce.Do(t.onceSetNextProtoDefaults)
+
+	switch scheme {
+	case "http", "https":
+	default:
+		return nil, fmt.Errorf("net/http: invalid scheme %q", scheme)
+	}
+
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+	if port == "" {
+		port = schemePort(scheme)
+	}
+
+	var proxyURL *url.URL
+	if t.Proxy != nil {
+		// Transport.Proxy takes a *Request, so create a fake one to pass it.
+		req := &Request{
+			ctx:    ctx,
+			Method: "GET",
+			URL: &url.URL{
+				Scheme: scheme,
+				Host:   host,
+				Path:   "/",
+			},
+			Proto:      "HTTP/1.1",
+			ProtoMajor: 1,
+			ProtoMinor: 1,
+			Header:     make(Header),
+			Body:       NoBody,
+			Host:       host,
+		}
+		var err error
+		proxyURL, err = t.Proxy(req)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	cm := connectMethod{
+		targetScheme: scheme,
+		targetAddr:   net.JoinHostPort(host, port),
+		proxyURL:     proxyURL,
+	}
+
+	// The state hook is a bit tricky:
+	// The persistConn has a state hook which calls ClientConn.maybeRunStateHook,
+	// which in turn calls the user-provided state hook (if any).
+	//
+	// ClientConn.maybeRunStateHook handles debouncing hook calls for both
+	// HTTP/1 and HTTP/2.
+	//
+	// Since there's no need to change the persistConn's hook, we set it at creation time.
+	cc := &ClientConn{}
+	const isClientConn = true
+	pconn, err := t.dialConn(ctx, cm, isClientConn, cc.maybeRunStateHook)
+	if err != nil {
+		return nil, err
+	}
+
+	// Note that cc.maybeRunStateHook may have been called
+	// in the short window between dialConn and now.
+	// This is fine.
+	cc.stateHookMu.Lock()
+	defer cc.stateHookMu.Unlock()
+	if pconn.alt != nil {
+		// If pconn.alt is set, this is a connection implemented in another package
+		// (probably x/net/http2) or the bundled copy in h2_bundle.go.
+		gc, ok := pconn.alt.(genericClientConn)
+		if !ok {
+			return nil, errors.New("http: NewClientConn returned something that is not a ClientConn")
+		}
+		cc.cc = gc
+		cc.lastAvailable = gc.Available()
+	} else {
+		// This is an HTTP/1 connection.
+		pconn.availch = make(chan struct{}, 1)
+		pconn.availch <- struct{}{}
+		cc.cc = http1ClientConn{pconn}
+		cc.lastAvailable = 1
+	}
+	return cc, nil
+}
+
+// Close closes the connection.
+// Outstanding RoundTrip calls are interrupted.
+func (cc *ClientConn) Close() error {
+	defer cc.maybeRunStateHook()
+	return cc.cc.Close()
+}
+
+// Err reports any fatal connection errors.
+// It returns nil if the connection is usable.
+// If it returns non-nil, the connection can no longer be used.
+func (cc *ClientConn) Err() error {
+	return cc.cc.Err()
+}
+
+func validateClientConnRequest(req *Request) error {
+	if req.URL == nil {
+		return errors.New("http: nil Request.URL")
+	}
+	if req.Header == nil {
+		return errors.New("http: nil Request.Header")
+	}
+	// Validate the outgoing headers.
+	if err := validateHeaders(req.Header); err != "" {
+		return fmt.Errorf("http: invalid header %s", err)
+	}
+	// Validate the outgoing trailers too.
+	if err := validateHeaders(req.Trailer); err != "" {
+		return fmt.Errorf("http: invalid trailer %s", err)
+	}
+	if req.Method != "" && !validMethod(req.Method) {
+		return fmt.Errorf("http: invalid method %q", req.Method)
+	}
+	if req.URL.Host == "" {
+		return errors.New("http: no Host in request URL")
+	}
+	return nil
+}
+
+// RoundTrip implements the [RoundTripper] interface.
+//
+// The request is sent on the client connection,
+// regardless of the URL being requested or any proxy settings.
+//
+// If the connection is at its concurrency limit,
+// RoundTrip waits for the connection to become available
+// before sending the request.
+func (cc *ClientConn) RoundTrip(req *Request) (*Response, error) {
+	defer cc.maybeRunStateHook()
+	if err := validateClientConnRequest(req); err != nil {
+		cc.Release()
+		return nil, err
+	}
+	return cc.cc.RoundTrip(req)
+}
+
+// Available reports the number of requests that may be sent
+// to the connection without blocking.
+// It returns 0 if the connection is closed.
+func (cc *ClientConn) Available() int {
+	return cc.cc.Available()
+}
+
+// InFlight reports the number of requests in flight,
+// including reserved requests.
+// It returns 0 if the connection is closed.
+func (cc *ClientConn) InFlight() int {
+	return cc.cc.InFlight()
+}
+
+// Reserve reserves a concurrency slot on the connection.
+// If Reserve returns nil, one additional RoundTrip call may be made
+// without waiting for an existing request to complete.
+//
+// The reserved concurrency slot is accounted as an in-flight request.
+// A successful call to RoundTrip will decrement the Available count
+// and increment the InFlight count.
+//
+// Each successful call to Reserve should be followed by exactly one call
+// to RoundTrip or Release, which will consume or release the reservation.
+//
+// If the connection is closed or at its concurrency limit,
+// Reserve returns an error.
+func (cc *ClientConn) Reserve() error {
+	defer cc.maybeRunStateHook()
+	return cc.cc.Reserve()
+}
+
+// Release releases an unused concurrency slot reserved by Reserve.
+// If there are no reserved concurrency slots, it has no effect.
+func (cc *ClientConn) Release() {
+	defer cc.maybeRunStateHook()
+	cc.cc.Release()
+}
+
+// shouldRunStateHook returns the user's state hook if we should call it,
+// or nil if we don't need to call it at this time.
+func (cc *ClientConn) shouldRunStateHook(stopRunning bool) func(*ClientConn) {
+	cc.stateHookMu.Lock()
+	defer cc.stateHookMu.Unlock()
+	if cc.cc == nil {
+		return nil
+	}
+	if stopRunning {
+		cc.stateHookRunning = false
+	}
+	if cc.userStateHook == nil {
+		return nil
+	}
+	if cc.stateHookRunning {
+		return nil
+	}
+	var (
+		available = cc.Available()
+		inFlight  = cc.InFlight()
+		closed    = cc.Err() != nil
+	)
+	var hook func(*ClientConn)
+	if available > cc.lastAvailable || inFlight < cc.lastInFlight || closed != cc.lastClosed {
+		hook = cc.userStateHook
+		cc.stateHookRunning = true
+	}
+	cc.lastAvailable = available
+	cc.lastInFlight = inFlight
+	cc.lastClosed = closed
+	return hook
+}
+
+func (cc *ClientConn) maybeRunStateHook() {
+	hook := cc.shouldRunStateHook(false)
+	if hook == nil {
+		return
+	}
+	// Run the hook synchronously.
+	//
+	// This means that if, for example, the user calls resp.Body.Close to finish a request,
+	// the Close call will synchronously run the hook, giving the hook the chance to
+	// return the ClientConn to a connection pool before the next request is made.
+	hook(cc)
+	// The connection state may have changed while the hook was running,
+	// in which case we need to run it again.
+	//
+	// If we do need to run the hook again, do so in a new goroutine to avoid blocking
+	// the current goroutine indefinitely.
+	hook = cc.shouldRunStateHook(true)
+	if hook != nil {
+		go func() {
+			for hook != nil {
+				hook(cc)
+				hook = cc.shouldRunStateHook(true)
+			}
+		}()
+	}
+}
+
+// SetStateHook arranges for f to be called when the state of the connection changes.
+// At most one call to f is made at a time.
+// If the connection's state has changed since it was created,
+// f is called immediately in a separate goroutine.
+// f may be called synchronously from RoundTrip or Response.Body.Close.
+//
+// If SetStateHook is called multiple times, the new hook replaces the old one.
+// If f is nil, no further calls will be made to f after SetStateHook returns.
+//
+// f is called when Available increases (more requests may be sent on the connection),
+// InFlight decreases (existing requests complete), or Err begins returning non-nil
+// (the connection is no longer usable).
+func (cc *ClientConn) SetStateHook(f func(*ClientConn)) {
+	cc.stateHookMu.Lock()
+	cc.userStateHook = f
+	cc.stateHookMu.Unlock()
+	cc.maybeRunStateHook()
+}
+
+// http1ClientConn is a genericClientConn implementation backed by
+// an HTTP/1 *persistConn (pconn.alt is nil).
+type http1ClientConn struct {
+	pconn *persistConn
+}
+
+func (cc http1ClientConn) RoundTrip(req *Request) (*Response, error) {
+	ctx := req.Context()
+	trace := httptrace.ContextClientTrace(ctx)
+
+	// Convert Request.Cancel into context cancelation.
+	ctx, cancel := context.WithCancelCause(req.Context())
+	if req.Cancel != nil {
+		go awaitLegacyCancel(ctx, cancel, req)
+	}
+
+	treq := &transportRequest{Request: req, trace: trace, ctx: ctx, cancel: cancel}
+	resp, err := cc.pconn.roundTrip(treq)
+	if err != nil {
+		return nil, err
+	}
+	resp.Request = req
+	return resp, nil
+}
+
+func (cc http1ClientConn) Close() error {
+	cc.pconn.close(errors.New("ClientConn closed"))
+	return nil
+}
+
+func (cc http1ClientConn) Err() error {
+	select {
+	case <-cc.pconn.closech:
+		return cc.pconn.closed
+	default:
+		return nil
+	}
+}
+
+func (cc http1ClientConn) Available() int {
+	cc.pconn.mu.Lock()
+	defer cc.pconn.mu.Unlock()
+	if cc.pconn.closed != nil || cc.pconn.reserved || cc.pconn.inFlight {
+		return 0
+	}
+	return 1
+}
+
+func (cc http1ClientConn) InFlight() int {
+	cc.pconn.mu.Lock()
+	defer cc.pconn.mu.Unlock()
+	if cc.pconn.closed == nil && (cc.pconn.reserved || cc.pconn.inFlight) {
+		return 1
+	}
+	return 0
+}
+
+func (cc http1ClientConn) Reserve() error {
+	cc.pconn.mu.Lock()
+	defer cc.pconn.mu.Unlock()
+	if cc.pconn.closed != nil {
+		return cc.pconn.closed
+	}
+	select {
+	case <-cc.pconn.availch:
+	default:
+		return errors.New("connection is unavailable")
+	}
+	cc.pconn.reserved = true
+	return nil
+}
+
+func (cc http1ClientConn) Release() {
+	cc.pconn.mu.Lock()
+	defer cc.pconn.mu.Unlock()
+	if cc.pconn.reserved {
+		select {
+		case cc.pconn.availch <- struct{}{}:
+		default:
+			panic("cannot release reservation")
+		}
+		cc.pconn.reserved = false
+	}
+}
diff --git a/backend/vendor/github.com/enetx/http2/client_priority_go126.go b/backend/vendor/github.com/enetx/http2/client_priority_go126.go
new file mode 100644
index 00000000..e9bead2a
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http2/client_priority_go126.go
@@ -0,0 +1,20 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.27
+
+package http2
+
+import "github.com/enetx/http"
+
+// Support for go.dev/issue/75500 is added in Go 1.27. In case anyone uses
+// x/net with versions before Go 1.27, we return true here so that their write
+// scheduler will still be the round-robin write scheduler rather than the RFC
+// 9218 write scheduler. That way, older users of Go will not see a sudden
+// change of behavior just from importing x/net.
+//
+// TODO(nsh): remove this file after x/net go.mod is at Go 1.27.
+func clientPriorityDisabled(_ *http.Server) bool {
+	return true
+}
diff --git a/backend/vendor/github.com/enetx/http2/client_priority_go127.go b/backend/vendor/github.com/enetx/http2/client_priority_go127.go
new file mode 100644
index 00000000..e26356e8
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http2/client_priority_go127.go
@@ -0,0 +1,13 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.27
+
+package http2
+
+import "github.com/enetx/http"
+
+func clientPriorityDisabled(s *http.Server) bool {
+	return s.DisableClientPriority
+}
diff --git a/backend/vendor/github.com/enetx/http2/httpsfv/httpsfv.go b/backend/vendor/github.com/enetx/http2/httpsfv/httpsfv.go
new file mode 100644
index 00000000..4ae2ca5b
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http2/httpsfv/httpsfv.go
@@ -0,0 +1,665 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package httpsfv provides functionality for dealing with HTTP Structured
+// Field Values.
+package httpsfv
+
+import (
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+func isLCAlpha(b byte) bool {
+	return (b >= 'a' && b <= 'z')
+}
+
+func isAlpha(b byte) bool {
+	return isLCAlpha(b) || (b >= 'A' && b <= 'Z')
+}
+
+func isDigit(b byte) bool {
+	return b >= '0' && b <= '9'
+}
+
+func isVChar(b byte) bool {
+	return b >= 0x21 && b <= 0x7e
+}
+
+func isSP(b byte) bool {
+	return b == 0x20
+}
+
+func isTChar(b byte) bool {
+	if isAlpha(b) || isDigit(b) {
+		return true
+	}
+	return slices.Contains([]byte{'!', '#', '$', '%', '&', '\'', '*', '+', '-', '.', '^', '_', '`', '|', '~'}, b)
+}
+
+func countLeftWhitespace(s string) int {
+	i := 0
+	for _, ch := range []byte(s) {
+		if ch != ' ' && ch != '\t' {
+			break
+		}
+		i++
+	}
+	return i
+}
+
+// https://www.rfc-editor.org/rfc/rfc4648#section-8.
+func decOctetHex(ch1, ch2 byte) (ch byte, ok bool) {
+	decBase16 := func(in byte) (out byte, ok bool) {
+		if !isDigit(in) && !(in >= 'a' && in <= 'f') {
+			return 0, false
+		}
+		if isDigit(in) {
+			return in - '0', true
+		}
+		return in - 'a' + 10, true
+	}
+
+	if ch1, ok = decBase16(ch1); !ok {
+		return 0, ok
+	}
+	if ch2, ok = decBase16(ch2); !ok {
+		return 0, ok
+	}
+	return ch1<<4 | ch2, true
+}
+
+// ParseList parses a list from a given HTTP Structured Field Values.
+//
+// Given an HTTP SFV string that represents a list, it will call the given
+// function using each of the members and parameters contained in the list.
+// This allows the caller to extract information out of the list.
+//
+// This function will return once it encounters the end of the string, or
+// something that is not a list. If it cannot consume the entire given
+// string, the ok value returned will be false.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-list.
+func ParseList(s string, f func(member, param string)) (ok bool) {
+	for len(s) != 0 {
+		var member, param string
+		if len(s) != 0 && s[0] == '(' {
+			if member, s, ok = consumeBareInnerList(s, nil); !ok {
+				return ok
+			}
+		} else {
+			if member, s, ok = consumeBareItem(s); !ok {
+				return ok
+			}
+		}
+		if param, s, ok = consumeParameter(s, nil); !ok {
+			return ok
+		}
+		if f != nil {
+			f(member, param)
+		}
+
+		s = s[countLeftWhitespace(s):]
+		if len(s) == 0 {
+			break
+		}
+		if s[0] != ',' {
+			return false
+		}
+		s = s[1:]
+		s = s[countLeftWhitespace(s):]
+		if len(s) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// consumeBareInnerList consumes an inner list
+// (https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-inner-list),
+// except for the inner list's top-most parameter.
+// For example, given `(a;b c;d);e`, it will consume only `(a;b c;d)`.
+func consumeBareInnerList(s string, f func(bareItem, param string)) (consumed, rest string, ok bool) {
+	if len(s) == 0 || s[0] != '(' {
+		return "", s, false
+	}
+	rest = s[1:]
+	for len(rest) != 0 {
+		var bareItem, param string
+		rest = rest[countLeftWhitespace(rest):]
+		if len(rest) != 0 && rest[0] == ')' {
+			rest = rest[1:]
+			break
+		}
+		if bareItem, rest, ok = consumeBareItem(rest); !ok {
+			return "", s, ok
+		}
+		if param, rest, ok = consumeParameter(rest, nil); !ok {
+			return "", s, ok
+		}
+		if len(rest) == 0 || (rest[0] != ')' && !isSP(rest[0])) {
+			return "", s, false
+		}
+		if f != nil {
+			f(bareItem, param)
+		}
+	}
+	return s[:len(s)-len(rest)], rest, true
+}
+
+// ParseBareInnerList parses a bare inner list from a given HTTP Structured
+// Field Values.
+//
+// We define a bare inner list as an inner list
+// (https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-inner-list),
+// without the top-most parameter of the inner list. For example, given the
+// inner list `(a;b c;d);e`, the bare inner list would be `(a;b c;d)`.
+//
+// Given an HTTP SFV string that represents a bare inner list, it will call the
+// given function using each of the bare item and parameter within the bare
+// inner list. This allows the caller to extract information out of the bare
+// inner list.
+//
+// This function will return once it encounters the end of the bare inner list,
+// or something that is not a bare inner list. If it cannot consume the entire
+// given string, the ok value returned will be false.
+func ParseBareInnerList(s string, f func(bareItem, param string)) (ok bool) {
+	_, rest, ok := consumeBareInnerList(s, f)
+	return rest == "" && ok
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-item.
+func consumeItem(s string, f func(bareItem, param string)) (consumed, rest string, ok bool) {
+	var bareItem, param string
+	if bareItem, rest, ok = consumeBareItem(s); !ok {
+		return "", s, ok
+	}
+	if param, rest, ok = consumeParameter(rest, nil); !ok {
+		return "", s, ok
+	}
+	if f != nil {
+		f(bareItem, param)
+	}
+	return s[:len(s)-len(rest)], rest, true
+}
+
+// ParseItem parses an item from a given HTTP Structured Field Values.
+//
+// Given an HTTP SFV string that represents an item, it will call the given
+// function once, with the bare item and the parameter of the item. This allows
+// the caller to extract information out of the item.
+//
+// This function will return once it encounters the end of the string, or
+// something that is not an item. If it cannot consume the entire given
+// string, the ok value returned will be false.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-item.
+func ParseItem(s string, f func(bareItem, param string)) (ok bool) {
+	_, rest, ok := consumeItem(s, f)
+	return rest == "" && ok
+}
+
+// ParseDictionary parses a dictionary from a given HTTP Structured Field
+// Values.
+//
+// Given an HTTP SFV string that represents a dictionary, it will call the
+// given function using each of the keys, values, and parameters contained in
+// the dictionary. This allows the caller to extract information out of the
+// dictionary.
+//
+// This function will return once it encounters the end of the string, or
+// something that is not a dictionary. If it cannot consume the entire given
+// string, the ok value returned will be false.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-dictionary.
+func ParseDictionary(s string, f func(key, val, param string)) (ok bool) {
+	for len(s) != 0 {
+		var key, val, param string
+		val = "?1" // Default value for empty val is boolean true.
+		if key, s, ok = consumeKey(s); !ok {
+			return ok
+		}
+		if len(s) != 0 && s[0] == '=' {
+			s = s[1:]
+			if len(s) != 0 && s[0] == '(' {
+				if val, s, ok = consumeBareInnerList(s, nil); !ok {
+					return ok
+				}
+			} else {
+				if val, s, ok = consumeBareItem(s); !ok {
+					return ok
+				}
+			}
+		}
+		if param, s, ok = consumeParameter(s, nil); !ok {
+			return ok
+		}
+		if f != nil {
+			f(key, val, param)
+		}
+		s = s[countLeftWhitespace(s):]
+		if len(s) == 0 {
+			break
+		}
+		if s[0] == ',' {
+			s = s[1:]
+		}
+		s = s[countLeftWhitespace(s):]
+		if len(s) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#parse-param.
+func consumeParameter(s string, f func(key, val string)) (consumed, rest string, ok bool) {
+	rest = s
+	for len(rest) != 0 {
+		var key, val string
+		val = "?1" // Default value for empty val is boolean true.
+		if rest[0] != ';' {
+			break
+		}
+		rest = rest[1:]
+		rest = rest[countLeftWhitespace(rest):]
+		key, rest, ok = consumeKey(rest)
+		if !ok {
+			return "", s, ok
+		}
+		if len(rest) != 0 && rest[0] == '=' {
+			rest = rest[1:]
+			val, rest, ok = consumeBareItem(rest)
+			if !ok {
+				return "", s, ok
+			}
+		}
+		if f != nil {
+			f(key, val)
+		}
+	}
+	return s[:len(s)-len(rest)], rest, true
+}
+
+// ParseParameter parses a parameter from a given HTTP Structured Field Values.
+//
+// Given an HTTP SFV string that represents a parameter, it will call the given
+// function using each of the keys and values contained in the parameter. This
+// allows the caller to extract information out of the parameter.
+//
+// This function will return once it encounters the end of the string, or
+// something that is not a parameter. If it cannot consume the entire given
+// string, the ok value returned will be false.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#parse-param.
+func ParseParameter(s string, f func(key, val string)) (ok bool) {
+	_, rest, ok := consumeParameter(s, f)
+	return rest == "" && ok
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-key.
+func consumeKey(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 || (!isLCAlpha(s[0]) && s[0] != '*') {
+		return "", s, false
+	}
+	i := 0
+	for _, ch := range []byte(s) {
+		if !isLCAlpha(ch) && !isDigit(ch) && !slices.Contains([]byte("_-.*"), ch) {
+			break
+		}
+		i++
+	}
+	return s[:i], s[i:], true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-integer-or-decim.
+func consumeIntegerOrDecimal(s string) (consumed, rest string, ok bool) {
+	var i, signOffset, periodIndex int
+	var isDecimal bool
+	if i < len(s) && s[i] == '-' {
+		i++
+		signOffset++
+	}
+	if i >= len(s) {
+		return "", s, false
+	}
+	if !isDigit(s[i]) {
+		return "", s, false
+	}
+	for i < len(s) {
+		ch := s[i]
+		if isDigit(ch) {
+			i++
+			continue
+		}
+		if !isDecimal && ch == '.' {
+			if i-signOffset > 12 {
+				return "", s, false
+			}
+			periodIndex = i
+			isDecimal = true
+			i++
+			continue
+		}
+		break
+	}
+	if !isDecimal && i-signOffset > 15 {
+		return "", s, false
+	}
+	if isDecimal {
+		if i-signOffset > 16 {
+			return "", s, false
+		}
+		if s[i-1] == '.' {
+			return "", s, false
+		}
+		if i-periodIndex-1 > 3 {
+			return "", s, false
+		}
+	}
+	return s[:i], s[i:], true
+}
+
+// ParseInteger parses an integer from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid integer. It returns the
+// parsed integer and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-integer-or-decim.
+func ParseInteger(s string) (parsed int64, ok bool) {
+	if _, rest, ok := consumeIntegerOrDecimal(s); !ok || rest != "" {
+		return 0, false
+	}
+	if n, err := strconv.ParseInt(s, 10, 64); err == nil {
+		return n, true
+	}
+	return 0, false
+}
+
+// ParseDecimal parses a decimal from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid decimal. It returns the
+// parsed decimal and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-an-integer-or-decim.
+func ParseDecimal(s string) (parsed float64, ok bool) {
+	if _, rest, ok := consumeIntegerOrDecimal(s); !ok || rest != "" {
+		return 0, false
+	}
+	if !strings.Contains(s, ".") {
+		return 0, false
+	}
+	if n, err := strconv.ParseFloat(s, 64); err == nil {
+		return n, true
+	}
+	return 0, false
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-string.
+func consumeString(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 || s[0] != '"' {
+		return "", s, false
+	}
+	for i := 1; i < len(s); i++ {
+		switch ch := s[i]; ch {
+		case '\\':
+			if i+1 >= len(s) {
+				return "", s, false
+			}
+			i++
+			if ch = s[i]; ch != '"' && ch != '\\' {
+				return "", s, false
+			}
+		case '"':
+			return s[:i+1], s[i+1:], true
+		default:
+			if !isVChar(ch) && !isSP(ch) {
+				return "", s, false
+			}
+		}
+	}
+	return "", s, false
+}
+
+// ParseString parses a Go string from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid string. It returns the
+// parsed string and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-string.
+func ParseString(s string) (parsed string, ok bool) {
+	if _, rest, ok := consumeString(s); !ok || rest != "" {
+		return "", false
+	}
+	return s[1 : len(s)-1], true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-token
+func consumeToken(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 || (!isAlpha(s[0]) && s[0] != '*') {
+		return "", s, false
+	}
+	i := 0
+	for _, ch := range []byte(s) {
+		if !isTChar(ch) && !slices.Contains([]byte(":/"), ch) {
+			break
+		}
+		i++
+	}
+	return s[:i], s[i:], true
+}
+
+// ParseToken parses a token from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid token. It returns the
+// parsed token and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-token
+func ParseToken(s string) (parsed string, ok bool) {
+	if _, rest, ok := consumeToken(s); !ok || rest != "" {
+		return "", false
+	}
+	return s, true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-byte-sequence.
+func consumeByteSequence(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 || s[0] != ':' {
+		return "", s, false
+	}
+	for i := 1; i < len(s); i++ {
+		if ch := s[i]; ch == ':' {
+			return s[:i+1], s[i+1:], true
+		}
+		if ch := s[i]; !isAlpha(ch) && !isDigit(ch) && !slices.Contains([]byte("+/="), ch) {
+			return "", s, false
+		}
+	}
+	return "", s, false
+}
+
+// ParseByteSequence parses a byte sequence from a given HTTP Structured Field
+// Values.
+//
+// The entire HTTP SFV string must consist of a valid byte sequence. It returns
+// the parsed byte sequence and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-byte-sequence.
+func ParseByteSequence(s string) (parsed []byte, ok bool) {
+	if _, rest, ok := consumeByteSequence(s); !ok || rest != "" {
+		return nil, false
+	}
+	return []byte(s[1 : len(s)-1]), true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-boolean.
+func consumeBoolean(s string) (consumed, rest string, ok bool) {
+	if len(s) >= 2 && (s[:2] == "?0" || s[:2] == "?1") {
+		return s[:2], s[2:], true
+	}
+	return "", s, false
+}
+
+// ParseBoolean parses a boolean from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid boolean. It returns the
+// parsed boolean and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-boolean.
+func ParseBoolean(s string) (parsed bool, ok bool) {
+	if _, rest, ok := consumeBoolean(s); !ok || rest != "" {
+		return false, false
+	}
+	return s == "?1", true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-date.
+func consumeDate(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 || s[0] != '@' {
+		return "", s, false
+	}
+	if _, rest, ok = consumeIntegerOrDecimal(s[1:]); !ok {
+		return "", s, ok
+	}
+	consumed = s[:len(s)-len(rest)]
+	if slices.Contains([]byte(consumed), '.') {
+		return "", s, false
+	}
+	return consumed, rest, ok
+}
+
+// ParseDate parses a date from a given HTTP Structured Field Values.
+//
+// The entire HTTP SFV string must consist of a valid date. It returns the
+// parsed date and an ok boolean value, indicating success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-date.
+func ParseDate(s string) (parsed time.Time, ok bool) {
+	if _, rest, ok := consumeDate(s); !ok || rest != "" {
+		return time.Time{}, false
+	}
+	if n, ok := ParseInteger(s[1:]); !ok {
+		return time.Time{}, false
+	} else {
+		return time.Unix(n, 0), true
+	}
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-display-string.
+func consumeDisplayString(s string) (consumed, rest string, ok bool) {
+	// To prevent excessive allocation, especially when input is large, we
+	// maintain a buffer of 4 bytes to keep track of the last rune we
+	// encounter. This way, we can validate that the display string conforms to
+	// UTF-8 without actually building the whole string.
+	var lastRune [4]byte
+	var runeLen int
+	isPartOfValidRune := func(ch byte) bool {
+		lastRune[runeLen] = ch
+		runeLen++
+		if utf8.FullRune(lastRune[:runeLen]) {
+			r, s := utf8.DecodeRune(lastRune[:runeLen])
+			if r == utf8.RuneError {
+				return false
+			}
+			copy(lastRune[:], lastRune[s:runeLen])
+			runeLen -= s
+			return true
+		}
+		return runeLen <= 4
+	}
+
+	if len(s) <= 1 || s[:2] != `%"` {
+		return "", s, false
+	}
+	i := 2
+	for i < len(s) {
+		ch := s[i]
+		if !isVChar(ch) && !isSP(ch) {
+			return "", s, false
+		}
+		switch ch {
+		case '"':
+			if runeLen > 0 {
+				return "", s, false
+			}
+			return s[:i+1], s[i+1:], true
+		case '%':
+			if i+2 >= len(s) {
+				return "", s, false
+			}
+			if ch, ok = decOctetHex(s[i+1], s[i+2]); !ok {
+				return "", s, ok
+			}
+			if ok = isPartOfValidRune(ch); !ok {
+				return "", s, ok
+			}
+			i += 3
+		default:
+			if ok = isPartOfValidRune(ch); !ok {
+				return "", s, ok
+			}
+			i++
+		}
+	}
+	return "", s, false
+}
+
+// ParseDisplayString parses a display string from a given HTTP Structured
+// Field Values.
+//
+// The entire HTTP SFV string must consist of a valid display string. It
+// returns the parsed display string and an ok boolean value, indicating
+// success or not.
+//
+// https://www.rfc-editor.org/rfc/rfc9651.html#name-parsing-a-display-string.
+func ParseDisplayString(s string) (parsed string, ok bool) {
+	if _, rest, ok := consumeDisplayString(s); !ok || rest != "" {
+		return "", false
+	}
+	// consumeDisplayString() already validates that we have a valid display
+	// string. Therefore, we can just construct the display string, without
+	// validating it again.
+	s = s[2 : len(s)-1]
+	var b strings.Builder
+	for i := 0; i < len(s); {
+		if s[i] == '%' {
+			decoded, _ := decOctetHex(s[i+1], s[i+2])
+			b.WriteByte(decoded)
+			i += 3
+			continue
+		}
+		b.WriteByte(s[i])
+		i++
+	}
+	return b.String(), true
+}
+
+// https://www.rfc-editor.org/rfc/rfc9651.html#parse-bare-item.
+func consumeBareItem(s string) (consumed, rest string, ok bool) {
+	if len(s) == 0 {
+		return "", s, false
+	}
+	ch := s[0]
+	switch {
+	case ch == '-' || isDigit(ch):
+		return consumeIntegerOrDecimal(s)
+	case ch == '"':
+		return consumeString(s)
+	case ch == '*' || isAlpha(ch):
+		return consumeToken(s)
+	case ch == ':':
+		return consumeByteSequence(s)
+	case ch == '?':
+		return consumeBoolean(s)
+	case ch == '@':
+		return consumeDate(s)
+	case ch == '%':
+		return consumeDisplayString(s)
+	default:
+		return "", s, false
+	}
+}
diff --git a/backend/vendor/github.com/enetx/http2/writesched_priority_rfc9218.go b/backend/vendor/github.com/enetx/http2/writesched_priority_rfc9218.go
new file mode 100644
index 00000000..dfbfc1eb
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http2/writesched_priority_rfc9218.go
@@ -0,0 +1,224 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package http2
+
+import (
+	"fmt"
+	"math"
+)
+
+type streamMetadata struct {
+	location *writeQueue
+	priority PriorityParam
+}
+
+type priorityWriteSchedulerRFC9218 struct {
+	// control contains control frames (SETTINGS, PING, etc.).
+	control writeQueue
+
+	// heads contain the head of a circular list of streams.
+	// We put these heads within a nested array that represents urgency and
+	// incremental, as defined in
+	// https://www.rfc-editor.org/rfc/rfc9218.html#name-priority-parameters.
+	// 8 represents u=0 up to u=7, and 2 represents i=false and i=true.
+	heads [8][2]*writeQueue
+
+	// streams contains a mapping between each stream ID and their metadata, so
+	// we can quickly locate them when needing to, for example, adjust their
+	// priority.
+	streams map[uint32]streamMetadata
+
+	// queuePool are empty queues for reuse.
+	queuePool writeQueuePool
+
+	// prioritizeIncremental is used to determine whether we should prioritize
+	// incremental streams or not, when urgency is the same in a given Pop()
+	// call.
+	prioritizeIncremental bool
+
+	// priorityUpdateBuf is used to buffer the most recent PRIORITY_UPDATE we
+	// receive per https://www.rfc-editor.org/rfc/rfc9218.html#name-the-priority_update-frame.
+	priorityUpdateBuf struct {
+		// streamID being 0 means that the buffer is empty. This is a safe
+		// assumption as PRIORITY_UPDATE for stream 0 is a PROTOCOL_ERROR.
+		streamID uint32
+		priority PriorityParam
+	}
+}
+
+func newPriorityWriteSchedulerRFC9218() WriteScheduler {
+	ws := &priorityWriteSchedulerRFC9218{
+		streams: make(map[uint32]streamMetadata),
+	}
+	return ws
+}
+
+func (ws *priorityWriteSchedulerRFC9218) OpenStream(streamID uint32, opt OpenStreamOptions) {
+	if ws.streams[streamID].location != nil {
+		panic(fmt.Errorf("stream %d already opened", streamID))
+	}
+	if streamID == ws.priorityUpdateBuf.streamID {
+		ws.priorityUpdateBuf.streamID = 0
+		opt.priority = ws.priorityUpdateBuf.priority
+	}
+	q := ws.queuePool.get()
+	ws.streams[streamID] = streamMetadata{
+		location: q,
+		priority: opt.priority,
+	}
+
+	u, i := opt.priority.urgency, opt.priority.incremental
+	if ws.heads[u][i] == nil {
+		ws.heads[u][i] = q
+		q.next = q
+		q.prev = q
+	} else {
+		// Queues are stored in a ring.
+		// Insert the new stream before ws.head, putting it at the end of the list.
+		q.prev = ws.heads[u][i].prev
+		q.next = ws.heads[u][i]
+		q.prev.next = q
+		q.next.prev = q
+	}
+}
+
+func (ws *priorityWriteSchedulerRFC9218) CloseStream(streamID uint32) {
+	metadata := ws.streams[streamID]
+	q, u, i := metadata.location, metadata.priority.urgency, metadata.priority.incremental
+	if q == nil {
+		return
+	}
+	if q.next == q {
+		// This was the only open stream.
+		ws.heads[u][i] = nil
+	} else {
+		q.prev.next = q.next
+		q.next.prev = q.prev
+		if ws.heads[u][i] == q {
+			ws.heads[u][i] = q.next
+		}
+	}
+	delete(ws.streams, streamID)
+	ws.queuePool.put(q)
+}
+
+func (ws *priorityWriteSchedulerRFC9218) AdjustStream(streamID uint32, priority PriorityParam) {
+	metadata := ws.streams[streamID]
+	q, u, i := metadata.location, metadata.priority.urgency, metadata.priority.incremental
+	if q == nil {
+		ws.priorityUpdateBuf.streamID = streamID
+		ws.priorityUpdateBuf.priority = priority
+		return
+	}
+
+	// Remove stream from current location.
+	if q.next == q {
+		// This was the only open stream.
+		ws.heads[u][i] = nil
+	} else {
+		q.prev.next = q.next
+		q.next.prev = q.prev
+		if ws.heads[u][i] == q {
+			ws.heads[u][i] = q.next
+		}
+	}
+
+	// Insert stream to the new queue.
+	u, i = priority.urgency, priority.incremental
+	if ws.heads[u][i] == nil {
+		ws.heads[u][i] = q
+		q.next = q
+		q.prev = q
+	} else {
+		// Queues are stored in a ring.
+		// Insert the new stream before ws.head, putting it at the end of the list.
+		q.prev = ws.heads[u][i].prev
+		q.next = ws.heads[u][i]
+		q.prev.next = q
+		q.next.prev = q
+	}
+
+	// Update the metadata.
+	ws.streams[streamID] = streamMetadata{
+		location: q,
+		priority: priority,
+	}
+}
+
+func (ws *priorityWriteSchedulerRFC9218) Push(wr FrameWriteRequest) {
+	if wr.isControl() {
+		ws.control.push(wr)
+		return
+	}
+	q := ws.streams[wr.StreamID()].location
+	if q == nil {
+		// This is a closed stream.
+		// wr should not be a HEADERS or DATA frame.
+		// We push the request onto the control queue.
+		if wr.DataSize() > 0 {
+			panic("add DATA on non-open stream")
+		}
+		ws.control.push(wr)
+		return
+	}
+	q.push(wr)
+}
+
+func (ws *priorityWriteSchedulerRFC9218) Pop() (FrameWriteRequest, bool) {
+	// Control and RST_STREAM frames first.
+	if !ws.control.empty() {
+		return ws.control.shift(), true
+	}
+
+	// On the next Pop(), we want to prioritize incremental if we prioritized
+	// non-incremental request of the same urgency this time. Vice-versa.
+	// i.e. when there are incremental and non-incremental requests at the same
+	// priority, we give 50% of our bandwidth to the incremental ones in
+	// aggregate and 50% to the first non-incremental one (since
+	// non-incremental streams do not use round-robin writes).
+	ws.prioritizeIncremental = !ws.prioritizeIncremental
+
+	// Always prioritize lowest u (i.e. highest urgency level).
+	for u := range ws.heads {
+		for i := range ws.heads[u] {
+			// When we want to prioritize incremental, we try to pop i=true
+			// first before i=false when u is the same.
+			if ws.prioritizeIncremental {
+				i = (i + 1) % 2
+			}
+			q := ws.heads[u][i]
+			if q == nil {
+				continue
+			}
+			for {
+				if wr, ok := q.consume(math.MaxInt32); ok {
+					if i == 1 {
+						// For incremental streams, we update head to q.next so
+						// we can round-robin between multiple streams that can
+						// immediately benefit from partial writes.
+						ws.heads[u][i] = q.next
+					} else {
+						// For non-incremental streams, we try to finish one to
+						// completion rather than doing round-robin. However,
+						// we update head here so that if q.consume() is !ok
+						// (e.g. the stream has no more frame to consume), head
+						// is updated to the next q that has frames to consume
+						// on future iterations. This way, we do not prioritize
+						// writing to unavailable stream on next Pop() calls,
+						// preventing head-of-line blocking.
+						ws.heads[u][i] = q
+					}
+					return wr, true
+				}
+				q = q.next
+				if q == ws.heads[u][i] {
+					break
+				}
+			}
+
+		}
+	}
+	return FrameWriteRequest{}, false
+}
diff --git a/backend/vendor/github.com/enetx/http3/README.md b/backend/vendor/github.com/enetx/http3/README.md
new file mode 100644
index 00000000..0e2ed4c5
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/README.md
@@ -0,0 +1,9 @@
+# HTTP/3
+
+[![Documentation](https://img.shields.io/badge/docs-quic--go.net-red?style=flat)](https://quic-go.net/docs/)
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/quic-go/quic-go/http3)](https://pkg.go.dev/github.com/quic-go/quic-go/http3)
+
+This package implements HTTP/3 ([RFC 9114](https://datatracker.ietf.org/doc/html/rfc9114)), including QPACK ([RFC 9204](https://datatracker.ietf.org/doc/html/rfc9204)) and HTTP Datagrams ([RFC 9297](https://datatracker.ietf.org/doc/html/rfc9297)).
+It aims to provide feature parity with the standard library's HTTP/1.1 and HTTP/2 implementation.
+
+Detailed documentation can be found on [quic-go.net](https://quic-go.net/docs/).
diff --git a/backend/vendor/github.com/enetx/http3/body.go b/backend/vendor/github.com/enetx/http3/body.go
new file mode 100644
index 00000000..ffc57bce
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/body.go
@@ -0,0 +1,137 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"io"
+	"sync"
+
+	"github.com/quic-go/quic-go"
+)
+
+// Settingser allows waiting for and retrieving the peer's HTTP/3 settings.
+type Settingser interface {
+	// ReceivedSettings returns a channel that is closed once the peer's SETTINGS frame was received.
+	// Settings can be obtained from the Settings method after the channel was closed.
+	ReceivedSettings() <-chan struct{}
+	// Settings returns the settings received on this connection.
+	// It is only valid to call this function after the channel returned by ReceivedSettings was closed.
+	Settings() *Settings
+}
+
+var errTooMuchData = errors.New("peer sent too much data")
+
+// The body is used in the requestBody (for a http.Request) and the responseBody (for a http.Response).
+type body struct {
+	str *Stream
+
+	remainingContentLength int64
+	violatedContentLength  bool
+	hasContentLength       bool
+}
+
+func newBody(str *Stream, contentLength int64) *body {
+	b := &body{str: str}
+	if contentLength >= 0 {
+		b.hasContentLength = true
+		b.remainingContentLength = contentLength
+	}
+	return b
+}
+
+func (r *body) StreamID() quic.StreamID { return r.str.StreamID() }
+
+func (r *body) checkContentLengthViolation() error {
+	if !r.hasContentLength {
+		return nil
+	}
+	if r.remainingContentLength < 0 || r.remainingContentLength == 0 && r.str.hasMoreData() {
+		if !r.violatedContentLength {
+			r.str.CancelRead(quic.StreamErrorCode(ErrCodeMessageError))
+			r.str.CancelWrite(quic.StreamErrorCode(ErrCodeMessageError))
+			r.violatedContentLength = true
+		}
+		return errTooMuchData
+	}
+	return nil
+}
+
+func (r *body) Read(b []byte) (int, error) {
+	if err := r.checkContentLengthViolation(); err != nil {
+		return 0, err
+	}
+	if r.hasContentLength {
+		b = b[:min(int64(len(b)), r.remainingContentLength)]
+	}
+	n, err := r.str.Read(b)
+	r.remainingContentLength -= int64(n)
+	if err := r.checkContentLengthViolation(); err != nil {
+		return n, err
+	}
+	return n, maybeReplaceError(err)
+}
+
+func (r *body) Close() error {
+	r.str.CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
+	return nil
+}
+
+type requestBody struct {
+	body
+	connCtx      context.Context
+	rcvdSettings <-chan struct{}
+	getSettings  func() *Settings
+}
+
+var _ io.ReadCloser = &requestBody{}
+
+func newRequestBody(str *Stream, contentLength int64, connCtx context.Context, rcvdSettings <-chan struct{}, getSettings func() *Settings) *requestBody {
+	return &requestBody{
+		body:         *newBody(str, contentLength),
+		connCtx:      connCtx,
+		rcvdSettings: rcvdSettings,
+		getSettings:  getSettings,
+	}
+}
+
+type hijackableBody struct {
+	body body
+
+	// only set for the http.Response
+	// The channel is closed when the user is done with this response:
+	// either when Read() errors, or when Close() is called.
+	reqDone     chan<- struct{}
+	reqDoneOnce sync.Once
+}
+
+var _ io.ReadCloser = &hijackableBody{}
+
+func newResponseBody(str *Stream, contentLength int64, done chan<- struct{}) *hijackableBody {
+	return &hijackableBody{
+		body:    *newBody(str, contentLength),
+		reqDone: done,
+	}
+}
+
+func (r *hijackableBody) Read(b []byte) (int, error) {
+	n, err := r.body.Read(b)
+	if err != nil {
+		r.requestDone()
+	}
+	return n, maybeReplaceError(err)
+}
+
+func (r *hijackableBody) requestDone() {
+	if r.reqDone != nil {
+		r.reqDoneOnce.Do(func() {
+			close(r.reqDone)
+		})
+	}
+}
+
+func (r *hijackableBody) Close() error {
+	r.requestDone()
+	// If the EOF was read, CancelRead() is a no-op.
+	r.body.str.CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
+	return nil
+}
diff --git a/backend/vendor/github.com/enetx/http3/capsule.go b/backend/vendor/github.com/enetx/http3/capsule.go
new file mode 100644
index 00000000..224ff230
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/capsule.go
@@ -0,0 +1,61 @@
+package http3
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// CapsuleType is the type of the capsule
+type CapsuleType uint64
+
+// CapsuleProtocolHeader is the header value used to advertise support for the capsule protocol
+const CapsuleProtocolHeader = "Capsule-Protocol"
+
+type exactReader struct {
+	R io.LimitedReader
+}
+
+func (r *exactReader) Read(b []byte) (int, error) {
+	n, err := r.R.Read(b)
+	if err == io.EOF && r.R.N > 0 {
+		return n, io.ErrUnexpectedEOF
+	}
+	return n, err
+}
+
+// ParseCapsule parses the header of a Capsule.
+// It returns an io.Reader that can be used to read the Capsule value.
+// The Capsule value must be read entirely (i.e. until the io.EOF) before using r again.
+func ParseCapsule(r quicvarint.Reader) (CapsuleType, io.Reader, error) {
+	cbr := countingByteReader{Reader: r}
+	ct, err := quicvarint.Read(&cbr)
+	if err != nil {
+		// If an io.EOF is returned without consuming any bytes, return it unmodified.
+		// Otherwise, return an io.ErrUnexpectedEOF.
+		if err == io.EOF && cbr.NumRead > 0 {
+			return 0, nil, io.ErrUnexpectedEOF
+		}
+		return 0, nil, err
+	}
+	l, err := quicvarint.Read(r)
+	if err != nil {
+		if err == io.EOF {
+			return 0, nil, io.ErrUnexpectedEOF
+		}
+		return 0, nil, err
+	}
+	return CapsuleType(ct), &exactReader{R: io.LimitedReader{R: r, N: int64(l)}}, nil
+}
+
+// WriteCapsule writes a capsule
+func WriteCapsule(w quicvarint.Writer, ct CapsuleType, value []byte) error {
+	b := make([]byte, 0, 16)
+	b = quicvarint.Append(b, uint64(ct))
+	b = quicvarint.Append(b, uint64(len(value)))
+	if _, err := w.Write(b); err != nil {
+		return err
+	}
+	_, err := w.Write(value)
+	return err
+}
diff --git a/backend/vendor/github.com/enetx/http3/client.go b/backend/vendor/github.com/enetx/http3/client.go
new file mode 100644
index 00000000..97fe8e3e
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/client.go
@@ -0,0 +1,508 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/textproto"
+	"sync"
+	"time"
+
+	"github.com/enetx/g"
+	"github.com/enetx/http"
+	"github.com/enetx/http/httptrace"
+
+	"github.com/enetx/http3/qlog"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter"
+
+	"github.com/quic-go/qpack"
+)
+
+const (
+	// MethodGet0RTT allows a GET request to be sent using 0-RTT.
+	// Note that 0-RTT doesn't provide replay protection and should only be used for idempotent requests.
+	MethodGet0RTT = "GET_0RTT"
+	// MethodHead0RTT allows a HEAD request to be sent using 0-RTT.
+	// Note that 0-RTT doesn't provide replay protection and should only be used for idempotent requests.
+	MethodHead0RTT = "HEAD_0RTT"
+)
+
+const (
+	defaultUserAgent              = "quic-go HTTP/3"
+	defaultMaxResponseHeaderBytes = 10 * 1 << 20 // 10 MB
+)
+
+var errGoAway = errors.New("connection in graceful shutdown")
+
+type errConnUnusable struct{ e error }
+
+func (e *errConnUnusable) Unwrap() error { return e.e }
+func (e *errConnUnusable) Error() string { return fmt.Sprintf("http3: conn unusable: %s", e.e.Error()) }
+
+const max1xxResponses = 5 // arbitrary bound on number of informational responses
+
+var defaultQuicConfig = &quic.Config{
+	MaxIncomingStreams: -1, // don't allow the server to create bidirectional streams
+	KeepAlivePeriod:    10 * time.Second,
+}
+
+// ClientConn is an HTTP/3 client doing requests to a single remote server.
+type ClientConn struct {
+	conn    *quic.Conn
+	rawConn *rawConn
+
+	decoder *qpack.Decoder
+
+	// Additional HTTP/3 settings.
+	// It is invalid to specify any settings defined by RFC 9114 (HTTP/3) and RFC 9297 (HTTP Datagrams).
+	additionalSettings g.MapOrd[uint64, uint64]
+
+	// maxResponseHeaderBytes specifies a limit on how many response bytes are
+	// allowed in the server's response header.
+	maxResponseHeaderBytes int
+
+	// disableCompression, if true, prevents the Transport from requesting compression with an
+	// "Accept-Encoding: gzip" request header when the Request contains no existing Accept-Encoding value.
+	// If the Transport requests gzip on its own and gets a gzipped response, it's transparently
+	// decoded in the Response.Body.
+	// However, if the user explicitly requested gzip it is not automatically uncompressed.
+	disableCompression bool
+
+	streamMx     sync.Mutex
+	maxStreamID  quic.StreamID // set once a GOAWAY frame is received
+	lastStreamID quic.StreamID // the highest stream ID that was opened
+
+	qlogger qlogwriter.Recorder
+	logger  *slog.Logger
+
+	requestWriter *requestWriter
+}
+
+var _ http.RoundTripper = &ClientConn{}
+
+func newClientConn(
+	conn *quic.Conn,
+	enableDatagrams bool,
+	additionalSettings g.MapOrd[uint64, uint64],
+	maxResponseHeaderBytes int,
+	disableCompression bool,
+	logger *slog.Logger,
+) *ClientConn {
+	var qlogger qlogwriter.Recorder
+	if qlogTrace := conn.QlogTrace(); qlogTrace != nil && qlogTrace.SupportsSchemas(qlog.EventSchema) {
+		qlogger = qlogTrace.AddProducer()
+	}
+	c := &ClientConn{
+		conn:               conn,
+		additionalSettings: additionalSettings,
+		disableCompression: disableCompression,
+		maxStreamID:        invalidStreamID,
+		lastStreamID:       invalidStreamID,
+		logger:             logger,
+		qlogger:            qlogger,
+		decoder:            qpack.NewDecoder(),
+	}
+	if maxResponseHeaderBytes <= 0 {
+		c.maxResponseHeaderBytes = defaultMaxResponseHeaderBytes
+	} else {
+		c.maxResponseHeaderBytes = maxResponseHeaderBytes
+	}
+	c.requestWriter = newRequestWriter()
+	c.rawConn = newRawConn(
+		conn,
+		enableDatagrams,
+		c.onStreamsEmpty,
+		c.handleControlStream,
+		qlogger,
+		c.logger,
+	)
+	// send the SETTINGs frame, using 0-RTT data, if possible
+	go func() {
+		_, err := c.rawConn.openControlStream(&settingsFrame{
+			Datagram: enableDatagrams,
+			Other:    additionalSettings,
+			// MaxFieldSectionSize: int64(c.maxResponseHeaderBytes),
+		})
+		if err != nil {
+			if c.logger != nil {
+				c.logger.Debug("setting up connection failed", "error", err)
+			}
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeInternalError), "")
+			return
+		}
+	}()
+	return c
+}
+
+// OpenRequestStream opens a new request stream on the HTTP/3 connection.
+func (c *ClientConn) OpenRequestStream(ctx context.Context) (*RequestStream, error) {
+	return c.openRequestStream(ctx, c.requestWriter, nil, c.disableCompression, c.maxResponseHeaderBytes)
+}
+
+func (c *ClientConn) openRequestStream(
+	ctx context.Context,
+	requestWriter *requestWriter,
+	reqDone chan<- struct{},
+	disableCompression bool,
+	maxHeaderBytes int,
+) (*RequestStream, error) {
+	c.streamMx.Lock()
+	maxStreamID := c.maxStreamID
+	var nextStreamID quic.StreamID
+	if c.lastStreamID == invalidStreamID {
+		nextStreamID = 0
+	} else {
+		nextStreamID = c.lastStreamID + 4
+	}
+	c.streamMx.Unlock()
+	// Streams with stream ID equal to or greater than the stream ID carried in the GOAWAY frame
+	// will be rejected, see section 5.2 of RFC 9114.
+	if maxStreamID != invalidStreamID && nextStreamID >= maxStreamID {
+		return nil, errGoAway
+	}
+
+	str, err := c.conn.OpenStreamSync(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	c.streamMx.Lock()
+	// take the maximum here, as multiple OpenStreamSync calls might have returned concurrently
+	if c.lastStreamID == invalidStreamID {
+		c.lastStreamID = str.StreamID()
+	} else {
+		c.lastStreamID = max(c.lastStreamID, str.StreamID())
+	}
+	// check again, in case a (or another) GOAWAY frame was received
+	maxStreamID = c.maxStreamID
+	c.streamMx.Unlock()
+
+	if maxStreamID != invalidStreamID && str.StreamID() >= maxStreamID {
+		str.CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
+		str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestCanceled))
+		return nil, errGoAway
+	}
+
+	hstr := c.rawConn.TrackStream(str)
+	rsp := &http.Response{}
+	trace := httptrace.ContextClientTrace(ctx)
+	return newRequestStream(
+		newStream(hstr, c.rawConn, trace, func(r io.Reader, hf *headersFrame) error {
+			hdr, err := decodeTrailers(r, hf, maxHeaderBytes, c.decoder, c.qlogger, str.StreamID())
+			if err != nil {
+				return err
+			}
+			rsp.Trailer = hdr
+			return nil
+		}, c.qlogger),
+		requestWriter,
+		reqDone,
+		c.decoder,
+		disableCompression,
+		maxHeaderBytes,
+		rsp,
+	), nil
+}
+
+func (c *ClientConn) handleUnidirectionalStream(str *quic.ReceiveStream) {
+	c.rawConn.handleUnidirectionalStream(str, false)
+}
+
+func (c *ClientConn) handleControlStream(str *quic.ReceiveStream, fp *frameParser) {
+	for {
+		f, err := fp.ParseNext(c.qlogger)
+		if err != nil {
+			var serr *quic.StreamError
+			if err == io.EOF || errors.As(err, &serr) {
+				c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeClosedCriticalStream), "")
+				return
+			}
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameError), "")
+			return
+		}
+		// GOAWAY is the only frame allowed at this point:
+		// * unexpected frames are ignored by the frame parser
+		// * we don't support any extension that might add support for more frames
+		goaway, ok := f.(*goAwayFrame)
+		if !ok {
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameUnexpected), "")
+			return
+		}
+		if goaway.StreamID%4 != 0 { // client-initiated, bidirectional streams
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeIDError), "")
+			return
+		}
+		c.streamMx.Lock()
+		// the server is not allowed to increase the Stream ID in subsequent GOAWAY frames
+		if c.maxStreamID != invalidStreamID && goaway.StreamID > c.maxStreamID {
+			c.streamMx.Unlock()
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeIDError), "")
+			return
+		}
+		c.maxStreamID = goaway.StreamID
+		c.streamMx.Unlock()
+
+		hasActiveStreams := c.rawConn.hasActiveStreams()
+		// immediately close the connection if there are currently no active requests
+		if !hasActiveStreams {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeNoError), "")
+			return
+		}
+	}
+}
+
+func (c *ClientConn) onStreamsEmpty() {
+	c.streamMx.Lock()
+	defer c.streamMx.Unlock()
+
+	// The server is performing a graceful shutdown.
+	if c.maxStreamID != invalidStreamID {
+		c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeNoError), "")
+	}
+}
+
+// RoundTrip executes a request and returns a response
+func (c *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) {
+	rsp, err := c.roundTrip(req)
+	if err != nil && req.Context().Err() != nil {
+		// if the context was canceled, return the context cancellation error
+		err = req.Context().Err()
+	}
+	return rsp, err
+}
+
+func (c *ClientConn) roundTrip(req *http.Request) (*http.Response, error) {
+	// Immediately send out this request, if this is a 0-RTT request.
+	switch req.Method {
+	case MethodGet0RTT:
+		// don't modify the original request
+		reqCopy := *req
+		req = &reqCopy
+		req.Method = http.MethodGet
+	case MethodHead0RTT:
+		// don't modify the original request
+		reqCopy := *req
+		req = &reqCopy
+		req.Method = http.MethodHead
+	default:
+		// wait for the handshake to complete
+		select {
+		case <-c.conn.HandshakeComplete():
+		case <-req.Context().Done():
+			return nil, req.Context().Err()
+		}
+	}
+
+	// It is only possible to send an Extended CONNECT request once the SETTINGS were received.
+	// See section 3 of RFC 8441.
+	if isExtendedConnectRequest(req) {
+		connCtx := c.conn.Context()
+		// wait for the server's SETTINGS frame to arrive
+		select {
+		case <-c.rawConn.ReceivedSettings():
+		case <-connCtx.Done():
+			return nil, context.Cause(connCtx)
+		}
+		if !c.rawConn.Settings().EnableExtendedConnect {
+			return nil, errors.New("http3: server didn't enable Extended CONNECT")
+		}
+	}
+
+	reqDone := make(chan struct{})
+	str, err := c.openRequestStream(
+		req.Context(),
+		c.requestWriter,
+		reqDone,
+		c.disableCompression,
+		c.maxResponseHeaderBytes,
+	)
+	if err != nil {
+		return nil, &errConnUnusable{e: err}
+	}
+
+	// Request Cancellation:
+	// This go routine keeps running even after RoundTripOpt() returns.
+	// It is shut down when the application is done processing the body.
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		select {
+		case <-req.Context().Done():
+			str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestCanceled))
+			str.CancelRead(quic.StreamErrorCode(ErrCodeRequestCanceled))
+		case <-reqDone:
+		}
+	}()
+
+	rsp, err := c.doRequest(req, str)
+	if err != nil { // if any error occurred
+		close(reqDone)
+		<-done
+		return nil, maybeReplaceError(err)
+	}
+	return rsp, maybeReplaceError(err)
+}
+
+// ReceivedSettings returns a channel that is closed once the server's HTTP/3 settings were received.
+// Settings can be obtained from the Settings method after the channel was closed.
+func (c *ClientConn) ReceivedSettings() <-chan struct{} {
+	return c.rawConn.ReceivedSettings()
+}
+
+// Settings returns the HTTP/3 settings for this connection.
+// It is only valid to call this function after the channel returned by ReceivedSettings was closed.
+func (c *ClientConn) Settings() *Settings {
+	return c.rawConn.Settings()
+}
+
+// CloseWithError closes the connection with the given error code and message.
+// It is invalid to call this function after the connection was closed.
+func (c *ClientConn) CloseWithError(code quic.ApplicationErrorCode, msg string) error {
+	return c.conn.CloseWithError(code, msg)
+}
+
+// Context returns a context that is cancelled when the connection is closed.
+func (c *ClientConn) Context() context.Context {
+	return c.conn.Context()
+}
+
+// cancelingReader reads from the io.Reader.
+// It cancels writing on the stream if any error other than io.EOF occurs.
+type cancelingReader struct {
+	r   io.Reader
+	str *RequestStream
+}
+
+func (r *cancelingReader) Read(b []byte) (int, error) {
+	n, err := r.r.Read(b)
+	if err != nil && err != io.EOF {
+		r.str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestCanceled))
+	}
+	return n, err
+}
+
+func (c *ClientConn) sendRequestBody(str *RequestStream, body io.ReadCloser, contentLength int64) error {
+	defer body.Close()
+	buf := make([]byte, bodyCopyBufferSize)
+	sr := &cancelingReader{str: str, r: body}
+	if contentLength == -1 {
+		_, err := io.CopyBuffer(str, sr, buf)
+		return err
+	}
+
+	// make sure we don't send more bytes than the content length
+	n, err := io.CopyBuffer(str, io.LimitReader(sr, contentLength), buf)
+	if err != nil {
+		return err
+	}
+	var extra int64
+	extra, err = io.CopyBuffer(io.Discard, sr, buf)
+	n += extra
+	if n > contentLength {
+		str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestCanceled))
+		return fmt.Errorf("http: ContentLength=%d with Body length %d", contentLength, n)
+	}
+	return err
+}
+
+func (c *ClientConn) doRequest(req *http.Request, str *RequestStream) (*http.Response, error) {
+	trace := httptrace.ContextClientTrace(req.Context())
+	var sendingReqFailed bool
+	if err := str.sendRequestHeader(req); err != nil {
+		traceWroteRequest(trace, err)
+		if c.logger != nil {
+			c.logger.Debug("error writing request", "error", err)
+		}
+		sendingReqFailed = true
+	}
+	if !sendingReqFailed {
+		if req.Body == nil {
+			traceWroteRequest(trace, nil)
+			str.Close()
+		} else {
+			// send the request body asynchronously
+			go func() {
+				defer str.Close()
+				contentLength := int64(-1)
+				// According to the documentation for http.Request.ContentLength,
+				// a value of 0 with a non-nil Body is also treated as unknown content length.
+				if req.ContentLength > 0 {
+					contentLength = req.ContentLength
+				}
+				err := c.sendRequestBody(str, req.Body, contentLength)
+				traceWroteRequest(trace, err)
+				if err != nil {
+					if c.logger != nil {
+						c.logger.Debug("error writing request", "error", err)
+					}
+					return
+				}
+
+				if len(req.Trailer) > 0 {
+					if err := str.sendRequestTrailer(req); err != nil {
+						if c.logger != nil {
+							c.logger.Debug("error writing trailers", "error", err)
+						}
+					}
+				}
+			}()
+		}
+	}
+
+	// copy from net/http: support 1xx responses
+	var num1xx int // number of informational 1xx headers received
+	var res *http.Response
+	for {
+		var err error
+		res, err = str.ReadResponse()
+		if err != nil {
+			return nil, err
+		}
+		resCode := res.StatusCode
+		is1xx := 100 <= resCode && resCode <= 199
+		// treat 101 as a terminal status, see https://github.com/golang/go/issues/26161
+		is1xxNonTerminal := is1xx && resCode != http.StatusSwitchingProtocols
+		if is1xxNonTerminal {
+			num1xx++
+			if num1xx > max1xxResponses {
+				str.CancelRead(quic.StreamErrorCode(ErrCodeExcessiveLoad))
+				str.CancelWrite(quic.StreamErrorCode(ErrCodeExcessiveLoad))
+				return nil, errors.New("http3: too many 1xx informational responses")
+			}
+			traceGot1xxResponse(trace, resCode, textproto.MIMEHeader(res.Header))
+			if resCode == http.StatusContinue {
+				traceGot100Continue(trace)
+			}
+			continue
+		}
+		break
+	}
+	connState := c.conn.ConnectionState().TLS
+	res.TLS = &connState
+	res.Request = req
+	return res, nil
+}
+
+// RawClientConn is a low-level HTTP/3 client connection.
+// It allows the application to take control of the stream accept loops,
+// giving the application the ability to handle streams originating from the server.
+type RawClientConn struct {
+	*ClientConn
+}
+
+// HandleUnidirectionalStream handles an incoming unidirectional stream.
+func (c *RawClientConn) HandleUnidirectionalStream(str *quic.ReceiveStream) {
+	c.rawConn.handleUnidirectionalStream(str, false)
+}
+
+// HandleBidirectionalStream handles an incoming bidirectional stream.
+func (c *ClientConn) HandleBidirectionalStream(str *quic.Stream) {
+	// According to RFC 9114, the server is not allowed to open bidirectional streams.
+	c.rawConn.CloseWithError(
+		quic.ApplicationErrorCode(ErrCodeStreamCreationError),
+		fmt.Sprintf("server opened bidirectional stream %d", str.StreamID()),
+	)
+}
diff --git a/backend/vendor/github.com/enetx/http3/conn.go b/backend/vendor/github.com/enetx/http3/conn.go
new file mode 100644
index 00000000..944e459c
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/conn.go
@@ -0,0 +1,318 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"sync"
+	"sync/atomic"
+
+	"github.com/enetx/http3/qlog"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+const maxQuarterStreamID = 1<<60 - 1
+
+// invalidStreamID is a stream ID that is invalid. The first valid stream ID in QUIC is 0.
+const invalidStreamID = quic.StreamID(-1)
+
+// rawConn is an HTTP/3 connection.
+// It provides HTTP/3 specific functionality by wrapping a quic.Conn,
+// in particular handling of unidirectional HTTP/3 streams, SETTINGS and datagrams.
+type rawConn struct {
+	conn *quic.Conn
+
+	logger *slog.Logger
+
+	enableDatagrams bool
+
+	streamMx sync.Mutex
+	streams  map[quic.StreamID]*stateTrackingStream
+
+	rcvdControlStr      atomic.Bool
+	rcvdQPACKEncoderStr atomic.Bool
+	rcvdQPACKDecoderStr atomic.Bool
+	controlStrHandler   func(*quic.ReceiveStream, *frameParser) // is called *after* the SETTINGS frame was parsed
+
+	onStreamsEmpty func()
+
+	settings         *Settings
+	receivedSettings chan struct{}
+
+	qlogger   qlogwriter.Recorder
+	qloggerWG sync.WaitGroup // tracks goroutines that may produce qlog events
+}
+
+func newRawConn(
+	quicConn *quic.Conn,
+	enableDatagrams bool,
+	onStreamsEmpty func(),
+	controlStrHandler func(*quic.ReceiveStream, *frameParser),
+	qlogger qlogwriter.Recorder,
+	logger *slog.Logger,
+) *rawConn {
+	c := &rawConn{
+		conn:              quicConn,
+		logger:            logger,
+		enableDatagrams:   enableDatagrams,
+		receivedSettings:  make(chan struct{}),
+		streams:           make(map[quic.StreamID]*stateTrackingStream),
+		qlogger:           qlogger,
+		onStreamsEmpty:    onStreamsEmpty,
+		controlStrHandler: controlStrHandler,
+	}
+	if qlogger != nil {
+		context.AfterFunc(quicConn.Context(), c.closeQlogger)
+	}
+	return c
+}
+
+func (c *rawConn) OpenUniStream() (*quic.SendStream, error) {
+	return c.conn.OpenUniStream()
+}
+
+// openControlStream opens the control stream and sends the SETTINGS frame.
+// It returns the control stream (needed by the server for sending GOAWAY later).
+func (c *rawConn) openControlStream(settings *settingsFrame) (*quic.SendStream, error) {
+	c.qloggerWG.Add(1)
+	defer c.qloggerWG.Done()
+
+	str, err := c.conn.OpenUniStream()
+	if err != nil {
+		return nil, err
+	}
+	b := make([]byte, 0, 64)
+	b = quicvarint.Append(b, streamTypeControlStream)
+	b = settings.Append(b)
+	if c.qlogger != nil {
+		sf := qlog.SettingsFrame{
+			MaxFieldSectionSize: settings.MaxFieldSectionSize,
+			Other:               settings.Other.Iter().Collect().Map[uint64, uint64](),
+		}
+		if settings.Datagram {
+			sf.Datagram = pointer(true)
+		}
+		if settings.ExtendedConnect {
+			sf.ExtendedConnect = pointer(true)
+		}
+		c.qlogger.RecordEvent(qlog.FrameCreated{
+			StreamID: str.StreamID(),
+			Raw:      qlog.RawInfo{Length: len(b)},
+			Frame:    qlog.Frame{Frame: sf},
+		})
+	}
+	if _, err := str.Write(b); err != nil {
+		return nil, err
+	}
+	return str, nil
+}
+
+func (c *rawConn) TrackStream(str *quic.Stream) *stateTrackingStream {
+	hstr := newStateTrackingStream(str, c, func(b []byte) error { return c.sendDatagram(str.StreamID(), b) })
+
+	c.streamMx.Lock()
+	c.streams[str.StreamID()] = hstr
+	c.qloggerWG.Add(1)
+	c.streamMx.Unlock()
+	return hstr
+}
+
+func (c *rawConn) RemoteAddr() net.Addr {
+	return c.conn.RemoteAddr()
+}
+
+func (c *rawConn) ConnectionState() quic.ConnectionState {
+	return c.conn.ConnectionState()
+}
+
+func (c *rawConn) clearStream(id quic.StreamID) {
+	c.streamMx.Lock()
+	defer c.streamMx.Unlock()
+
+	if _, ok := c.streams[id]; ok {
+		delete(c.streams, id)
+		c.qloggerWG.Done()
+	}
+	if len(c.streams) == 0 {
+		c.onStreamsEmpty()
+	}
+}
+
+func (c *rawConn) hasActiveStreams() bool {
+	c.streamMx.Lock()
+	defer c.streamMx.Unlock()
+
+	return len(c.streams) > 0
+}
+
+func (c *rawConn) CloseWithError(code quic.ApplicationErrorCode, msg string) error {
+	return c.conn.CloseWithError(code, msg)
+}
+
+func (c *rawConn) handleUnidirectionalStream(str *quic.ReceiveStream, isServer bool) {
+	c.qloggerWG.Add(1)
+	defer c.qloggerWG.Done()
+
+	streamType, err := quicvarint.Read(quicvarint.NewReader(str))
+	if err != nil {
+		if c.logger != nil {
+			c.logger.Debug("reading stream type on stream failed", "stream ID", str.StreamID(), "error", err)
+		}
+		return
+	}
+	// We're only interested in the control stream here.
+	switch streamType {
+	case streamTypeControlStream:
+	case streamTypeQPACKEncoderStream:
+		if isFirst := c.rcvdQPACKEncoderStr.CompareAndSwap(false, true); !isFirst {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeStreamCreationError), "duplicate QPACK encoder stream")
+		}
+		// Our QPACK implementation doesn't use the dynamic table yet.
+		return
+	case streamTypeQPACKDecoderStream:
+		if isFirst := c.rcvdQPACKDecoderStr.CompareAndSwap(false, true); !isFirst {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeStreamCreationError), "duplicate QPACK decoder stream")
+		}
+		// Our QPACK implementation doesn't use the dynamic table yet.
+		return
+	case streamTypePushStream:
+		if isServer {
+			// only the server can push
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeStreamCreationError), "")
+		} else {
+			// we never increased the Push ID, so we don't expect any push streams
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeIDError), "")
+		}
+		return
+	default:
+		str.CancelRead(quic.StreamErrorCode(ErrCodeStreamCreationError))
+		return
+	}
+	// Only a single control stream is allowed.
+	if isFirstControlStr := c.rcvdControlStr.CompareAndSwap(false, true); !isFirstControlStr {
+		c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeStreamCreationError), "duplicate control stream")
+		return
+	}
+	c.handleControlStream(str)
+}
+
+func (c *rawConn) handleControlStream(str *quic.ReceiveStream) {
+	fp := &frameParser{closeConn: c.conn.CloseWithError, r: str, streamID: str.StreamID()}
+	f, err := fp.ParseNext(c.qlogger)
+	if err != nil {
+		var serr *quic.StreamError
+		if err == io.EOF || errors.As(err, &serr) {
+			c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeClosedCriticalStream), "")
+			return
+		}
+		c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameError), "")
+		return
+	}
+	sf, ok := f.(*settingsFrame)
+	if !ok {
+		c.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeMissingSettings), "")
+		return
+	}
+	c.settings = &Settings{
+		EnableDatagrams:       sf.Datagram,
+		EnableExtendedConnect: sf.ExtendedConnect,
+		Other:                 sf.Other,
+	}
+	close(c.receivedSettings)
+	if sf.Datagram {
+		// If datagram support was enabled on our side as well as on the server side,
+		// we can expect it to have been negotiated both on the transport and on the HTTP/3 layer.
+		// Note: ConnectionState() will block until the handshake is complete (relevant when using 0-RTT).
+		if c.enableDatagrams && !c.ConnectionState().SupportsDatagrams.Remote {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeSettingsError), "missing QUIC Datagram support")
+			return
+		}
+		c.qloggerWG.Go(func() {
+			if err := c.receiveDatagrams(); err != nil {
+				if c.logger != nil {
+					c.logger.Debug("receiving datagrams failed", "error", err)
+				}
+			}
+		})
+	}
+
+	if c.controlStrHandler != nil {
+		c.controlStrHandler(str, fp)
+	}
+}
+
+func (c *rawConn) sendDatagram(streamID quic.StreamID, b []byte) error {
+	// TODO: this creates a lot of garbage and an additional copy
+	data := make([]byte, 0, len(b)+8)
+	quarterStreamID := uint64(streamID / 4)
+	data = quicvarint.Append(data, uint64(streamID/4))
+	data = append(data, b...)
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.DatagramCreated{
+			QuarterStreamID: quarterStreamID,
+			Raw: qlog.RawInfo{
+				Length:        len(data),
+				PayloadLength: len(b),
+			},
+		})
+	}
+	return c.conn.SendDatagram(data)
+}
+
+func (c *rawConn) receiveDatagrams() error {
+	for {
+		b, err := c.conn.ReceiveDatagram(context.Background())
+		if err != nil {
+			return err
+		}
+		quarterStreamID, n, err := quicvarint.Parse(b)
+		if err != nil {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeDatagramError), "")
+			return fmt.Errorf("could not read quarter stream id: %w", err)
+		}
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.DatagramParsed{
+				QuarterStreamID: quarterStreamID,
+				Raw: qlog.RawInfo{
+					Length:        len(b),
+					PayloadLength: len(b) - n,
+				},
+			})
+		}
+		if quarterStreamID > maxQuarterStreamID {
+			c.CloseWithError(quic.ApplicationErrorCode(ErrCodeDatagramError), "")
+			return fmt.Errorf("invalid quarter stream id: %w", err)
+		}
+		streamID := quic.StreamID(4 * quarterStreamID)
+		c.streamMx.Lock()
+		dg, ok := c.streams[streamID]
+		c.streamMx.Unlock()
+		if !ok {
+			continue
+		}
+		dg.enqueueDatagram(b[n:])
+	}
+}
+
+// ReceivedSettings returns a channel that is closed once the peer's SETTINGS frame was received.
+// Settings can be optained from the Settings method after the channel was closed.
+func (c *rawConn) ReceivedSettings() <-chan struct{} { return c.receivedSettings }
+
+// Settings returns the settings received on this connection.
+// It is only valid to call this function after the channel returned by ReceivedSettings was closed.
+func (c *rawConn) Settings() *Settings { return c.settings }
+
+// closeQlogger waits for all goroutines that may produce qlog events to finish,
+// then closes the qlogger.
+func (c *rawConn) closeQlogger() {
+	if c.qlogger == nil {
+		return
+	}
+	c.qloggerWG.Wait()
+	c.qlogger.Close()
+}
diff --git a/backend/vendor/github.com/enetx/http3/error.go b/backend/vendor/github.com/enetx/http3/error.go
new file mode 100644
index 00000000..82fdae6a
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/error.go
@@ -0,0 +1,63 @@
+package http3
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/quic-go/quic-go"
+)
+
+// Error is returned from the round tripper (for HTTP clients)
+// and inside the HTTP handler (for HTTP servers) if an HTTP/3 error occurs.
+// See section 8 of RFC 9114.
+type Error struct {
+	Remote       bool
+	ErrorCode    ErrCode
+	ErrorMessage string
+}
+
+var _ error = &Error{}
+
+func (e *Error) Error() string {
+	s := e.ErrorCode.string()
+	if s == "" {
+		s = fmt.Sprintf("H3 error (%#x)", uint64(e.ErrorCode))
+	}
+	// Usually errors are remote. Only make it explicit for local errors.
+	if !e.Remote {
+		s += " (local)"
+	}
+	if e.ErrorMessage != "" {
+		s += ": " + e.ErrorMessage
+	}
+	return s
+}
+
+func (e *Error) Is(target error) bool {
+	t, ok := target.(*Error)
+	return ok && e.ErrorCode == t.ErrorCode && e.Remote == t.Remote
+}
+
+func maybeReplaceError(err error) error {
+	if err == nil {
+		return nil
+	}
+
+	var (
+		e      Error
+		strErr *quic.StreamError
+		appErr *quic.ApplicationError
+	)
+	switch {
+	default:
+		return err
+	case errors.As(err, &strErr):
+		e.Remote = strErr.Remote
+		e.ErrorCode = ErrCode(strErr.ErrorCode)
+	case errors.As(err, &appErr):
+		e.Remote = appErr.Remote
+		e.ErrorCode = ErrCode(appErr.ErrorCode)
+		e.ErrorMessage = appErr.ErrorMessage
+	}
+	return &e
+}
diff --git a/backend/vendor/github.com/enetx/http3/error_codes.go b/backend/vendor/github.com/enetx/http3/error_codes.go
new file mode 100644
index 00000000..d0b10a1f
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/error_codes.go
@@ -0,0 +1,84 @@
+package http3
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go"
+)
+
+type ErrCode quic.ApplicationErrorCode
+
+const (
+	ErrCodeNoError                  ErrCode = 0x100
+	ErrCodeGeneralProtocolError     ErrCode = 0x101
+	ErrCodeInternalError            ErrCode = 0x102
+	ErrCodeStreamCreationError      ErrCode = 0x103
+	ErrCodeClosedCriticalStream     ErrCode = 0x104
+	ErrCodeFrameUnexpected          ErrCode = 0x105
+	ErrCodeFrameError               ErrCode = 0x106
+	ErrCodeExcessiveLoad            ErrCode = 0x107
+	ErrCodeIDError                  ErrCode = 0x108
+	ErrCodeSettingsError            ErrCode = 0x109
+	ErrCodeMissingSettings          ErrCode = 0x10a
+	ErrCodeRequestRejected          ErrCode = 0x10b
+	ErrCodeRequestCanceled          ErrCode = 0x10c
+	ErrCodeRequestIncomplete        ErrCode = 0x10d
+	ErrCodeMessageError             ErrCode = 0x10e
+	ErrCodeConnectError             ErrCode = 0x10f
+	ErrCodeVersionFallback          ErrCode = 0x110
+	ErrCodeDatagramError            ErrCode = 0x33
+	ErrCodeQPACKDecompressionFailed ErrCode = 0x200
+)
+
+func (e ErrCode) String() string {
+	s := e.string()
+	if s != "" {
+		return s
+	}
+	return fmt.Sprintf("unknown error code: %#x", uint16(e))
+}
+
+func (e ErrCode) string() string {
+	switch e {
+	case ErrCodeNoError:
+		return "H3_NO_ERROR"
+	case ErrCodeGeneralProtocolError:
+		return "H3_GENERAL_PROTOCOL_ERROR"
+	case ErrCodeInternalError:
+		return "H3_INTERNAL_ERROR"
+	case ErrCodeStreamCreationError:
+		return "H3_STREAM_CREATION_ERROR"
+	case ErrCodeClosedCriticalStream:
+		return "H3_CLOSED_CRITICAL_STREAM"
+	case ErrCodeFrameUnexpected:
+		return "H3_FRAME_UNEXPECTED"
+	case ErrCodeFrameError:
+		return "H3_FRAME_ERROR"
+	case ErrCodeExcessiveLoad:
+		return "H3_EXCESSIVE_LOAD"
+	case ErrCodeIDError:
+		return "H3_ID_ERROR"
+	case ErrCodeSettingsError:
+		return "H3_SETTINGS_ERROR"
+	case ErrCodeMissingSettings:
+		return "H3_MISSING_SETTINGS"
+	case ErrCodeRequestRejected:
+		return "H3_REQUEST_REJECTED"
+	case ErrCodeRequestCanceled:
+		return "H3_REQUEST_CANCELLED"
+	case ErrCodeRequestIncomplete:
+		return "H3_INCOMPLETE_REQUEST"
+	case ErrCodeMessageError:
+		return "H3_MESSAGE_ERROR"
+	case ErrCodeConnectError:
+		return "H3_CONNECT_ERROR"
+	case ErrCodeVersionFallback:
+		return "H3_VERSION_FALLBACK"
+	case ErrCodeDatagramError:
+		return "H3_DATAGRAM_ERROR"
+	case ErrCodeQPACKDecompressionFailed:
+		return "QPACK_DECOMPRESSION_FAILED"
+	default:
+		return ""
+	}
+}
diff --git a/backend/vendor/github.com/enetx/http3/frames.go b/backend/vendor/github.com/enetx/http3/frames.go
new file mode 100644
index 00000000..6817b692
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/frames.go
@@ -0,0 +1,339 @@
+package http3
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/enetx/g"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// FrameType is the frame type of a HTTP/3 frame
+type FrameType uint64
+
+type frame any
+
+// The maximum length of an encoded HTTP/3 frame header is 16:
+// The frame has a type and length field, both QUIC varints (maximum 8 bytes in length)
+const frameHeaderLen = 16
+
+type countingByteReader struct {
+	quicvarint.Reader
+	NumRead int
+}
+
+func (r *countingByteReader) ReadByte() (byte, error) {
+	b, err := r.Reader.ReadByte()
+	if err == nil {
+		r.NumRead++
+	}
+	return b, err
+}
+
+func (r *countingByteReader) Read(b []byte) (int, error) {
+	n, err := r.Reader.Read(b)
+	r.NumRead += n
+	return n, err
+}
+
+func (r *countingByteReader) Reset() {
+	r.NumRead = 0
+}
+
+type frameParser struct {
+	r         io.Reader
+	streamID  quic.StreamID
+	closeConn func(quic.ApplicationErrorCode, string) error
+}
+
+func (p *frameParser) ParseNext(qlogger qlogwriter.Recorder) (frame, error) {
+	r := &countingByteReader{Reader: quicvarint.NewReader(p.r)}
+	for {
+		t, err := quicvarint.Read(r)
+		if err != nil {
+			return nil, err
+		}
+		l, err := quicvarint.Read(r)
+		if err != nil {
+			return nil, err
+		}
+
+		switch t {
+		case 0x0: // DATA
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw: qlog.RawInfo{
+						Length:        int(l) + r.NumRead,
+						PayloadLength: int(l),
+					},
+					Frame: qlog.Frame{Frame: qlog.DataFrame{}},
+				})
+			}
+			return &dataFrame{Length: l}, nil
+		case 0x1: // HEADERS
+			return &headersFrame{
+				Length:    l,
+				headerLen: r.NumRead,
+			}, nil
+		case 0x4: // SETTINGS
+			return parseSettingsFrame(r, l, p.streamID, qlogger)
+		case 0x3: // unsupported: CANCEL_PUSH
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw:      qlog.RawInfo{Length: r.NumRead, PayloadLength: int(l)},
+					Frame:    qlog.Frame{Frame: qlog.CancelPushFrame{}},
+				})
+			}
+		case 0x5: // unsupported: PUSH_PROMISE
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw:      qlog.RawInfo{Length: r.NumRead, PayloadLength: int(l)},
+					Frame:    qlog.Frame{Frame: qlog.PushPromiseFrame{}},
+				})
+			}
+		case 0x7: // GOAWAY
+			return parseGoAwayFrame(r, l, p.streamID, qlogger)
+		case 0xd: // unsupported: MAX_PUSH_ID
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw:      qlog.RawInfo{Length: r.NumRead, PayloadLength: int(l)},
+					Frame:    qlog.Frame{Frame: qlog.MaxPushIDFrame{}},
+				})
+			}
+		case 0x2, 0x6, 0x8, 0x9: // reserved frame types
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw:      qlog.RawInfo{Length: r.NumRead + int(l), PayloadLength: int(l)},
+					Frame:    qlog.Frame{Frame: qlog.ReservedFrame{Type: t}},
+				})
+			}
+			p.closeConn(quic.ApplicationErrorCode(ErrCodeFrameUnexpected), "")
+			return nil, fmt.Errorf("http3: reserved frame type: %d", t)
+		default:
+			// unknown frame types
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameParsed{
+					StreamID: p.streamID,
+					Raw:      qlog.RawInfo{Length: r.NumRead, PayloadLength: int(l)},
+					Frame:    qlog.Frame{Frame: qlog.UnknownFrame{Type: t}},
+				})
+			}
+		}
+
+		// skip over the payload
+		if _, err := io.CopyN(io.Discard, r, int64(l)); err != nil {
+			return nil, err
+		}
+		r.Reset()
+	}
+}
+
+type dataFrame struct {
+	Length uint64
+}
+
+func (f *dataFrame) Append(b []byte) []byte {
+	b = quicvarint.Append(b, 0x0)
+	return quicvarint.Append(b, f.Length)
+}
+
+type headersFrame struct {
+	Length    uint64
+	headerLen int // number of bytes read for type and length field
+}
+
+func (f *headersFrame) Append(b []byte) []byte {
+	b = quicvarint.Append(b, 0x1)
+	return quicvarint.Append(b, f.Length)
+}
+
+const (
+	// SETTINGS_MAX_FIELD_SECTION_SIZE
+	settingMaxFieldSectionSize = 0x6
+	// Extended CONNECT, RFC 9220
+	settingExtendedConnect = 0x8
+	// HTTP Datagrams, RFC 9297
+	settingDatagram = 0x33
+)
+
+type settingsFrame struct {
+	MaxFieldSectionSize int64 // SETTINGS_MAX_FIELD_SECTION_SIZE, -1 if not set
+
+	Datagram        bool                     // HTTP Datagrams, RFC 9297
+	ExtendedConnect bool                     // Extended CONNECT, RFC 9220
+	Other           g.MapOrd[uint64, uint64] // all settings that we don't explicitly recognize
+}
+
+func pointer[T any](v T) *T {
+	return &v
+}
+
+func parseSettingsFrame(
+	r *countingByteReader,
+	l uint64,
+	streamID quic.StreamID,
+	qlogger qlogwriter.Recorder,
+) (*settingsFrame, error) {
+	if l > 8*(1<<10) {
+		return nil, fmt.Errorf("unexpected size for SETTINGS frame: %d", l)
+	}
+	buf := make([]byte, l)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		if err == io.ErrUnexpectedEOF {
+			return nil, io.EOF
+		}
+		return nil, err
+	}
+	frame := &settingsFrame{MaxFieldSectionSize: -1}
+	b := bytes.NewReader(buf)
+	settingsFrame := qlog.SettingsFrame{MaxFieldSectionSize: -1}
+	var readMaxFieldSectionSize, readDatagram, readExtendedConnect bool
+	for b.Len() > 0 {
+		id, err := quicvarint.Read(b)
+		if err != nil { // should not happen. We allocated the whole frame already.
+			return nil, err
+		}
+		val, err := quicvarint.Read(b)
+		if err != nil { // should not happen. We allocated the whole frame already.
+			return nil, err
+		}
+
+		switch id {
+		case settingMaxFieldSectionSize:
+			if readMaxFieldSectionSize {
+				return nil, fmt.Errorf("duplicate setting: %d", id)
+			}
+			readMaxFieldSectionSize = true
+			frame.MaxFieldSectionSize = int64(val)
+			settingsFrame.MaxFieldSectionSize = int64(val)
+		case settingExtendedConnect:
+			if readExtendedConnect {
+				return nil, fmt.Errorf("duplicate setting: %d", id)
+			}
+			readExtendedConnect = true
+			if val != 0 && val != 1 {
+				return nil, fmt.Errorf("invalid value for SETTINGS_ENABLE_CONNECT_PROTOCOL: %d", val)
+			}
+			frame.ExtendedConnect = val == 1
+			if qlogger != nil {
+				settingsFrame.ExtendedConnect = pointer(frame.ExtendedConnect)
+			}
+		case settingDatagram:
+			if readDatagram {
+				return nil, fmt.Errorf("duplicate setting: %d", id)
+			}
+			readDatagram = true
+			if val != 0 && val != 1 {
+				return nil, fmt.Errorf("invalid value for SETTINGS_H3_DATAGRAM: %d", val)
+			}
+			frame.Datagram = val == 1
+			if qlogger != nil {
+				settingsFrame.Datagram = pointer(frame.Datagram)
+			}
+		default:
+			if frame.Other.Contains(id) {
+				return nil, fmt.Errorf("duplicate setting: %d", id)
+			}
+			if frame.Other == nil {
+				frame.Other = g.NewMapOrd[uint64, uint64]()
+			}
+			frame.Other.Insert(id, val)
+		}
+	}
+	if qlogger != nil {
+		settingsFrame.Other = frame.Other.Iter().Collect().Map[uint64, uint64]()
+
+		qlogger.RecordEvent(qlog.FrameParsed{
+			StreamID: streamID,
+			Raw: qlog.RawInfo{
+				Length:        r.NumRead,
+				PayloadLength: int(l),
+			},
+			Frame: qlog.Frame{Frame: settingsFrame},
+		})
+	}
+	return frame, nil
+}
+
+func (f *settingsFrame) Append(b []byte) []byte {
+	b = quicvarint.Append(b, 0x4)
+	var l int
+	if f.MaxFieldSectionSize > 0 { // enetx
+		// if f.MaxFieldSectionSize >= 0 {
+		l += quicvarint.Len(settingMaxFieldSectionSize) + quicvarint.Len(uint64(f.MaxFieldSectionSize))
+	}
+	for id, val := range f.Other.Iter() {
+		l += quicvarint.Len(id) + quicvarint.Len(val)
+	}
+	if f.Datagram {
+		l += quicvarint.Len(settingDatagram) + quicvarint.Len(1)
+	}
+	if f.ExtendedConnect {
+		l += quicvarint.Len(settingExtendedConnect) + quicvarint.Len(1)
+	}
+	b = quicvarint.Append(b, uint64(l))
+	if f.MaxFieldSectionSize > 0 {
+		// if f.MaxFieldSectionSize >= 0 { // enetx
+		b = quicvarint.Append(b, settingMaxFieldSectionSize)
+		b = quicvarint.Append(b, uint64(f.MaxFieldSectionSize))
+	}
+	if f.Datagram {
+		b = quicvarint.Append(b, settingDatagram)
+		b = quicvarint.Append(b, 1)
+	}
+	if f.ExtendedConnect {
+		b = quicvarint.Append(b, settingExtendedConnect)
+		b = quicvarint.Append(b, 1)
+	}
+	for id, val := range f.Other.Iter() {
+		b = quicvarint.Append(b, id)
+		b = quicvarint.Append(b, val)
+	}
+	return b
+}
+
+type goAwayFrame struct {
+	StreamID quic.StreamID
+}
+
+func parseGoAwayFrame(
+	r *countingByteReader,
+	l uint64,
+	streamID quic.StreamID,
+	qlogger qlogwriter.Recorder,
+) (*goAwayFrame, error) {
+	frame := &goAwayFrame{}
+	startLen := r.NumRead
+	id, err := quicvarint.Read(r)
+	if err != nil {
+		return nil, err
+	}
+	if r.NumRead-startLen != int(l) {
+		return nil, errors.New("GOAWAY frame: inconsistent length")
+	}
+	frame.StreamID = quic.StreamID(id)
+	if qlogger != nil {
+		qlogger.RecordEvent(qlog.FrameParsed{
+			StreamID: streamID,
+			Raw:      qlog.RawInfo{Length: r.NumRead, PayloadLength: int(l)},
+			Frame:    qlog.Frame{Frame: qlog.GoAwayFrame{StreamID: frame.StreamID}},
+		})
+	}
+	return frame, nil
+}
+
+func (f *goAwayFrame) Append(b []byte) []byte {
+	b = quicvarint.Append(b, 0x7)
+	b = quicvarint.Append(b, uint64(quicvarint.Len(uint64(f.StreamID))))
+	return quicvarint.Append(b, uint64(f.StreamID))
+}
diff --git a/backend/vendor/github.com/enetx/http3/gzip_reader.go b/backend/vendor/github.com/enetx/http3/gzip_reader.go
new file mode 100644
index 00000000..01983ac7
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/gzip_reader.go
@@ -0,0 +1,39 @@
+package http3
+
+// copied from net/transport.go
+
+// gzipReader wraps a response body so it can lazily
+// call gzip.NewReader on the first call to Read
+import (
+	"compress/gzip"
+	"io"
+)
+
+// call gzip.NewReader on the first call to Read
+type gzipReader struct {
+	body io.ReadCloser // underlying Response.Body
+	zr   *gzip.Reader  // lazily-initialized gzip reader
+	zerr error         // sticky error
+}
+
+func newGzipReader(body io.ReadCloser) io.ReadCloser {
+	return &gzipReader{body: body}
+}
+
+func (gz *gzipReader) Read(p []byte) (n int, err error) {
+	if gz.zerr != nil {
+		return 0, gz.zerr
+	}
+	if gz.zr == nil {
+		gz.zr, err = gzip.NewReader(gz.body)
+		if err != nil {
+			gz.zerr = err
+			return 0, err
+		}
+	}
+	return gz.zr.Read(p)
+}
+
+func (gz *gzipReader) Close() error {
+	return gz.body.Close()
+}
diff --git a/backend/vendor/github.com/enetx/http3/headers.go b/backend/vendor/github.com/enetx/http3/headers.go
new file mode 100644
index 00000000..b3582885
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/headers.go
@@ -0,0 +1,429 @@
+package http3
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"github.com/enetx/http"
+	"net/textproto"
+	"net/url"
+	"slices"
+	"strconv"
+	"strings"
+
+	"golang.org/x/net/http/httpguts"
+
+	"github.com/quic-go/qpack"
+	"github.com/quic-go/quic-go"
+	"github.com/enetx/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+type qpackError struct{ err error }
+
+func (e *qpackError) Error() string { return fmt.Sprintf("qpack: %v", e.err) }
+func (e *qpackError) Unwrap() error { return e.err }
+
+var errHeaderTooLarge = errors.New("http3: headers too large")
+
+type header struct {
+	// Pseudo header fields defined in RFC 9114
+	Path      string
+	Method    string
+	Authority string
+	Scheme    string
+	Status    string
+	// for Extended connect
+	Protocol string
+	// parsed and deduplicated. -1 if no Content-Length header is sent
+	ContentLength int64
+	// all non-pseudo headers
+	Headers http.Header
+}
+
+// connection-specific header fields must not be sent on HTTP/3
+var invalidHeaderFields = [...]string{
+	"connection",
+	"keep-alive",
+	"proxy-connection",
+	"transfer-encoding",
+	"upgrade",
+}
+
+func parseHeaders(decodeFn qpack.DecodeFunc, isRequest bool, sizeLimit int, headerFields *[]qpack.HeaderField) (header, error) {
+	hdr := header{Headers: make(http.Header)}
+	var readFirstRegularHeader, readContentLength bool
+	var contentLengthStr string
+	for {
+		h, err := decodeFn()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return header{}, &qpackError{err}
+		}
+		if headerFields != nil {
+			*headerFields = append(*headerFields, h)
+		}
+		// RFC 9114, section 4.2.2:
+		// The size of a field list is calculated based on the uncompressed size of fields,
+		// including the length of the name and value in bytes plus an overhead of 32 bytes for each field.
+		sizeLimit -= len(h.Name) + len(h.Value) + 32
+		if sizeLimit < 0 {
+			return header{}, errHeaderTooLarge
+		}
+		if err := validateHeaderFieldNameAndValue(h); err != nil {
+			return header{}, err
+		}
+		if h.IsPseudo() {
+			if readFirstRegularHeader {
+				// all pseudo headers must appear before regular header fields, see section 4.3 of RFC 9114
+				return header{}, fmt.Errorf("received pseudo header %s after a regular header field", h.Name)
+			}
+			var isResponsePseudoHeader bool  // pseudo headers are either valid for requests or for responses
+			var isDuplicatePseudoHeader bool // pseudo headers are allowed to appear exactly once
+			switch h.Name {
+			case ":path":
+				isDuplicatePseudoHeader = hdr.Path != ""
+				hdr.Path = h.Value
+			case ":method":
+				isDuplicatePseudoHeader = hdr.Method != ""
+				hdr.Method = h.Value
+			case ":authority":
+				isDuplicatePseudoHeader = hdr.Authority != ""
+				hdr.Authority = h.Value
+			case ":protocol": // RFC 9220
+				isDuplicatePseudoHeader = hdr.Protocol != ""
+				hdr.Protocol = h.Value
+			case ":scheme":
+				isDuplicatePseudoHeader = hdr.Scheme != ""
+				hdr.Scheme = h.Value
+			case ":status":
+				isDuplicatePseudoHeader = hdr.Status != ""
+				hdr.Status = h.Value
+				isResponsePseudoHeader = true
+			default:
+				return header{}, fmt.Errorf("unknown pseudo header: %s", h.Name)
+			}
+			if isDuplicatePseudoHeader {
+				return header{}, fmt.Errorf("duplicate pseudo header: %s", h.Name)
+			}
+			if isRequest && isResponsePseudoHeader {
+				return header{}, fmt.Errorf("invalid request pseudo header: %s", h.Name)
+			}
+			if !isRequest && !isResponsePseudoHeader {
+				return header{}, fmt.Errorf("invalid response pseudo header: %s", h.Name)
+			}
+		} else {
+			if err := validateRegularHeaderField(h); err != nil {
+				return header{}, err
+			}
+			readFirstRegularHeader = true
+			switch h.Name {
+			case "content-length":
+				// Ignore duplicate Content-Length headers.
+				// Fail if the duplicates differ.
+				if !readContentLength {
+					readContentLength = true
+					contentLengthStr = h.Value
+				} else if contentLengthStr != h.Value {
+					return header{}, fmt.Errorf("contradicting content lengths (%s and %s)", contentLengthStr, h.Value)
+				}
+			default:
+				hdr.Headers.Add(h.Name, h.Value)
+			}
+		}
+	}
+	hdr.ContentLength = -1
+	if len(contentLengthStr) > 0 {
+		// use ParseUint instead of ParseInt, so that parsing fails on negative values
+		cl, err := strconv.ParseUint(contentLengthStr, 10, 63)
+		if err != nil {
+			return header{}, fmt.Errorf("invalid content length: %w", err)
+		}
+		hdr.Headers.Set("Content-Length", contentLengthStr)
+		hdr.ContentLength = int64(cl)
+	}
+	return hdr, nil
+}
+
+func validateHeaderFieldNameAndValue(h qpack.HeaderField) error {
+	// field names need to be lowercase, see section 4.2 of RFC 9114
+	if strings.ToLower(h.Name) != h.Name {
+		return fmt.Errorf("header field is not lower-case: %s", h.Name)
+	}
+	if !httpguts.ValidHeaderFieldValue(h.Value) {
+		return fmt.Errorf("invalid header field value for %s: %q", h.Name, h.Value)
+	}
+	return nil
+}
+
+func validateRegularHeaderField(h qpack.HeaderField) error {
+	if !httpguts.ValidHeaderFieldName(h.Name) {
+		return fmt.Errorf("invalid header field name: %q", h.Name)
+	}
+	if slices.Contains(invalidHeaderFields[:], h.Name) {
+		return fmt.Errorf("invalid header field name: %q", h.Name)
+	}
+	if h.Name == "te" && h.Value != "trailers" {
+		return fmt.Errorf("invalid TE header field value: %q", h.Value)
+	}
+	return nil
+}
+
+func validateTrailerHeaderField(h qpack.HeaderField) error {
+	if err := validateRegularHeaderField(h); err != nil {
+		return err
+	}
+	if !httpguts.ValidTrailerHeader(h.Name) {
+		return fmt.Errorf("invalid trailer field name: %q", h.Name)
+	}
+	return nil
+}
+
+func parseTrailers(decodeFn qpack.DecodeFunc, sizeLimit int, headerFields *[]qpack.HeaderField) (http.Header, error) {
+	h := make(http.Header)
+	for {
+		hf, err := decodeFn()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, &qpackError{err}
+		}
+		if headerFields != nil {
+			*headerFields = append(*headerFields, hf)
+		}
+		// RFC 9114, section 4.2.2:
+		// The size of a field list is calculated based on the uncompressed size of fields,
+		// including the length of the name and value in bytes plus an overhead of 32 bytes for each field.
+		sizeLimit -= len(hf.Name) + len(hf.Value) + 32
+		if sizeLimit < 0 {
+			return nil, errHeaderTooLarge
+		}
+		if err := validateHeaderFieldNameAndValue(hf); err != nil {
+			return nil, err
+		}
+		if hf.IsPseudo() {
+			return nil, fmt.Errorf("http3: received pseudo header in trailer: %s", hf.Name)
+		}
+		if err := validateTrailerHeaderField(hf); err != nil {
+			return nil, err
+		}
+		h.Add(hf.Name, hf.Value)
+	}
+	return h, nil
+}
+
+func requestFromHeaders(decodeFn qpack.DecodeFunc, sizeLimit int, headerFields *[]qpack.HeaderField) (*http.Request, error) {
+	hdr, err := parseHeaders(decodeFn, true, sizeLimit, headerFields)
+	if err != nil {
+		return nil, err
+	}
+	// concatenate cookie headers, see https://tools.ietf.org/html/rfc6265#section-5.4
+	if len(hdr.Headers["Cookie"]) > 0 {
+		hdr.Headers.Set("Cookie", strings.Join(hdr.Headers["Cookie"], "; "))
+	}
+
+	isConnect := hdr.Method == http.MethodConnect
+	// Extended CONNECT, see https://datatracker.ietf.org/doc/html/rfc8441#section-4
+	isExtendedConnected := isConnect && hdr.Protocol != ""
+	if isExtendedConnected {
+		if !validExtendedConnectProtocol(hdr.Protocol) {
+			return nil, fmt.Errorf("invalid :protocol: %q", hdr.Protocol)
+		}
+		if hdr.Scheme == "" || hdr.Path == "" || hdr.Authority == "" {
+			return nil, errors.New("extended CONNECT: :scheme, :path and :authority must not be empty")
+		}
+	} else if isConnect {
+		if hdr.Path != "" || hdr.Authority == "" { // normal CONNECT
+			return nil, errors.New(":path must be empty and :authority must not be empty")
+		}
+	} else if len(hdr.Path) == 0 || len(hdr.Authority) == 0 || len(hdr.Method) == 0 {
+		return nil, errors.New(":path, :authority and :method must not be empty")
+	}
+
+	if !isExtendedConnected && len(hdr.Protocol) > 0 {
+		return nil, errors.New(":protocol must be empty")
+	}
+
+	var u *url.URL
+	var requestURI string
+
+	protocol := "HTTP/3.0"
+
+	if isConnect {
+		u = &url.URL{}
+		if isExtendedConnected {
+			u, err = url.ParseRequestURI(hdr.Path)
+			if err != nil {
+				return nil, err
+			}
+			protocol = hdr.Protocol
+		} else {
+			u.Path = hdr.Path
+		}
+		requestURI = hdr.Authority
+	} else {
+		u, err = url.ParseRequestURI(hdr.Path)
+		if err != nil {
+			return nil, fmt.Errorf("invalid request URI: %w", err)
+		}
+		requestURI = hdr.Path
+	}
+	u.Scheme = hdr.Scheme
+	u.Host = hdr.Authority
+
+	req := &http.Request{
+		Method:        hdr.Method,
+		URL:           u,
+		Proto:         protocol,
+		ProtoMajor:    3,
+		ProtoMinor:    0,
+		Header:        hdr.Headers,
+		Body:          nil,
+		ContentLength: hdr.ContentLength,
+		Host:          hdr.Authority,
+		RequestURI:    requestURI,
+	}
+	req.Trailer = extractAnnouncedTrailers(req.Header)
+	return req, nil
+}
+
+func validExtendedConnectProtocol(protocol string) bool {
+	// RFC 9220 specifies that the semantics of the :protocol pseudo are the same as defined in RFC 8441.
+	// RFC 8441, Section 4 specifies that :protocol is a single value from the HTTP Upgrade Token Registry.
+	// RFC 9110, Section 16.7 specifies that HTTP Upgrade Token Registry uses token grammar.
+	// Therefore, ValidHeaderFieldName is the right syntax check here, despite the misleading name.
+	return httpguts.ValidHeaderFieldName(protocol)
+}
+
+// updateResponseFromHeaders sets up http.Response as an HTTP/3 response,
+// using the decoded qpack header filed.
+// It is only called for the HTTP header (and not the HTTP trailer).
+// It takes an http.Response as an argument to allow the caller to set the trailer later on.
+func updateResponseFromHeaders(rsp *http.Response, decodeFn qpack.DecodeFunc, sizeLimit int, headerFields *[]qpack.HeaderField) error {
+	hdr, err := parseHeaders(decodeFn, false, sizeLimit, headerFields)
+	if err != nil {
+		return err
+	}
+	if hdr.Status == "" {
+		return errors.New("missing :status field")
+	}
+	rsp.Proto = "HTTP/3.0"
+	rsp.ProtoMajor = 3
+	rsp.Header = hdr.Headers
+	rsp.Trailer = extractAnnouncedTrailers(rsp.Header)
+	rsp.ContentLength = hdr.ContentLength
+
+	status, err := strconv.Atoi(hdr.Status)
+	if err != nil {
+		return fmt.Errorf("invalid status code: %w", err)
+	}
+	rsp.StatusCode = status
+	rsp.Status = hdr.Status + " " + http.StatusText(status)
+	return nil
+}
+
+// extractAnnouncedTrailers extracts trailer keys from the "Trailer" header.
+// It returns a map with the announced keys set to nil values, and removes the "Trailer" header.
+// It handles both duplicate as well as comma-separated values for the Trailer header.
+// For example:
+//
+//	Trailer: Trailer1, Trailer2
+//	Trailer: Trailer3
+//
+// Will result in a map containing the keys "Trailer1", "Trailer2", "Trailer3" with nil values.
+func extractAnnouncedTrailers(header http.Header) http.Header {
+	rawTrailers, ok := header["Trailer"]
+	if !ok {
+		return nil
+	}
+
+	trailers := make(http.Header)
+	for _, rawVal := range rawTrailers {
+		for val := range strings.SplitSeq(rawVal, ",") {
+			trailers[http.CanonicalHeaderKey(textproto.TrimString(val))] = nil
+		}
+	}
+	delete(header, "Trailer")
+	return trailers
+}
+
+// writeTrailers encodes and writes HTTP trailers as a HEADERS frame.
+// It returns true if trailers were written, false if there were no trailers to write.
+func writeTrailers(wr io.Writer, trailers http.Header, streamID quic.StreamID, qlogger qlogwriter.Recorder) (bool, error) {
+	var hasValues bool
+	for k, vals := range trailers {
+		if httpguts.ValidTrailerHeader(k) && len(vals) > 0 {
+			hasValues = true
+			break
+		}
+	}
+	if !hasValues {
+		return false, nil
+	}
+
+	var buf bytes.Buffer
+	enc := qpack.NewEncoder(&buf)
+	var headerFields []qlog.HeaderField
+	if qlogger != nil {
+		headerFields = make([]qlog.HeaderField, 0, len(trailers))
+	}
+
+	for k, vals := range trailers {
+		if len(vals) == 0 {
+			continue
+		}
+		if !httpguts.ValidTrailerHeader(k) {
+			continue
+		}
+		lowercaseKey := strings.ToLower(k)
+		for _, v := range vals {
+			if err := enc.WriteField(qpack.HeaderField{Name: lowercaseKey, Value: v}); err != nil {
+				return false, err
+			}
+			if qlogger != nil {
+				headerFields = append(headerFields, qlog.HeaderField{Name: lowercaseKey, Value: v})
+			}
+		}
+	}
+
+	b := make([]byte, 0, frameHeaderLen+buf.Len())
+	b = (&headersFrame{Length: uint64(buf.Len())}).Append(b)
+	b = append(b, buf.Bytes()...)
+	if qlogger != nil {
+		qlogCreatedHeadersFrame(qlogger, streamID, len(b), buf.Len(), headerFields)
+	}
+	_, err := wr.Write(b)
+	return true, err
+}
+
+func decodeTrailers(r io.Reader, hf *headersFrame, maxHeaderBytes int, decoder *qpack.Decoder, qlogger qlogwriter.Recorder, streamID quic.StreamID) (http.Header, error) {
+	if hf.Length > uint64(maxHeaderBytes) {
+		maybeQlogInvalidHeadersFrame(qlogger, streamID, hf.Length)
+		return nil, fmt.Errorf("http3: HEADERS frame too large: %d bytes (max: %d)", hf.Length, maxHeaderBytes)
+	}
+
+	b := make([]byte, hf.Length)
+	if _, err := io.ReadFull(r, b); err != nil {
+		return nil, err
+	}
+	decodeFn := decoder.Decode(b)
+	var fields []qpack.HeaderField
+	var headerFields *[]qpack.HeaderField
+	if qlogger != nil {
+		fields = make([]qpack.HeaderField, 0, 16)
+		headerFields = &fields
+	}
+	trailers, err := parseTrailers(decodeFn, maxHeaderBytes, headerFields)
+	if err != nil {
+		maybeQlogInvalidHeadersFrame(qlogger, streamID, hf.Length)
+		return nil, err
+	}
+	if qlogger != nil {
+		qlogParsedHeadersFrame(qlogger, streamID, hf, fields)
+	}
+	return trailers, nil
+}
diff --git a/backend/vendor/github.com/enetx/http3/httpcommon/header.go b/backend/vendor/github.com/enetx/http3/httpcommon/header.go
new file mode 100644
index 00000000..5e245ac4
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/httpcommon/header.go
@@ -0,0 +1,130 @@
+package httpcommon
+
+import (
+	"github.com/enetx/http"
+	"sort"
+	"strings"
+	"sync"
+)
+
+const (
+	// HeaderOrderKey is a magic key for ResponseWriter.Header map keys
+	// that, if present, defines a header order that will be used to
+	// write the headers onto wire. The order of the list defined how the headers
+	// will be sorted. A defined key goes before an undefined key.
+	//
+	// This is the only way to specify some order, because maps don't
+	// have a a stable iteration order. If no order is given, headers will
+	// be sorted lexicographically.
+	//
+	// According to RFC-2616 it is good practice to send general-header fields
+	// first, followed by request-header or response-header fields and ending
+	// with entity-header fields.
+	HeaderOrderKey = "Header-Order:"
+
+	// PHeaderOrderKey is a magic key for setting http3 pseudo header order.
+	// If the header is nil it will use regular GoLang header order.
+	// Valid fields are :authority, :method, :path, :scheme, :protocol
+	PHeaderOrderKey = "PHeader-Order:"
+)
+
+// HeaderKeyValues represents a key-value pair for headers
+type HeaderKeyValues struct {
+	Key    string
+	Values []string
+}
+
+// A HeaderSorter implements sort.Interface by sorting a []HeaderKeyValues
+// by key. It's used as a pointer, so it can fit in a sort.Interface
+// interface value without allocation.
+type HeaderSorter struct {
+	kvs   []HeaderKeyValues
+	order map[string]int
+}
+
+func (s *HeaderSorter) Len() int      { return len(s.kvs) }
+func (s *HeaderSorter) Swap(i, j int) { s.kvs[i], s.kvs[j] = s.kvs[j], s.kvs[i] }
+func (s *HeaderSorter) Less(i, j int) bool {
+	// If the order isn't defined, sort lexicographically.
+	if s.order == nil {
+		return s.kvs[i].Key < s.kvs[j].Key
+	}
+
+	idxi, iok := s.order[strings.ToLower(s.kvs[i].Key)]
+	idxj, jok := s.order[strings.ToLower(s.kvs[j].Key)]
+	if !iok && !jok {
+		return s.kvs[i].Key < s.kvs[j].Key
+	} else if !iok && jok {
+		return false
+	} else if iok && !jok {
+		return true
+	}
+
+	return idxi < idxj
+}
+
+var headerSorterPool = sync.Pool{
+	New: func() any { return new(HeaderSorter) },
+}
+
+var lock = sync.RWMutex{}
+
+// SortedKeyValues returns h's keys sorted in the returned kvs
+// slice. The HeaderSorter used to sort is also returned, for possible
+// return to headerSorterPool.
+func SortedKeyValues(h http.Header, exclude map[string]bool) (kvs []HeaderKeyValues, hs *HeaderSorter) {
+	hs = headerSorterPool.Get().(*HeaderSorter)
+	if cap(hs.kvs) < len(h) {
+		hs.kvs = make([]HeaderKeyValues, 0, len(h))
+	}
+
+	kvs = hs.kvs[:0]
+	for k, vv := range h {
+		lock.RLock()
+		if !exclude[k] {
+			kvs = append(kvs, HeaderKeyValues{k, vv})
+		}
+		lock.RUnlock()
+	}
+
+	hs.kvs = kvs
+	// Clear any order left over from a previous SortedKeyValuesBy call on a
+	// sorter that was returned to the pool; otherwise a default-order request
+	// would inherit a stale custom order and sort non-lexicographically.
+	hs.order = nil
+	sort.Sort(hs)
+
+	return kvs, hs
+}
+
+// SortedKeyValuesBy returns headers sorted by specified order
+func SortedKeyValuesBy(
+	h http.Header,
+	order map[string]int,
+	exclude map[string]bool,
+) (kvs []HeaderKeyValues, hs *HeaderSorter) {
+	hs = headerSorterPool.Get().(*HeaderSorter)
+	if cap(hs.kvs) < len(h) {
+		hs.kvs = make([]HeaderKeyValues, 0, len(h))
+	}
+
+	kvs = hs.kvs[:0]
+	for k, vv := range h {
+		lock.RLock()
+		if !exclude[k] {
+			kvs = append(kvs, HeaderKeyValues{k, vv})
+		}
+		lock.RUnlock()
+	}
+
+	hs.kvs = kvs
+	hs.order = order
+	sort.Sort(hs)
+
+	return kvs, hs
+}
+
+// ReturnSorter returns a header sorter to the pool
+func ReturnSorter(hs *HeaderSorter) {
+	headerSorterPool.Put(hs)
+}
diff --git a/backend/vendor/github.com/enetx/http3/ip_addr.go b/backend/vendor/github.com/enetx/http3/ip_addr.go
new file mode 100644
index 00000000..876a1e35
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/ip_addr.go
@@ -0,0 +1,48 @@
+package http3
+
+import (
+	"net"
+	"strings"
+)
+
+// An addrList represents a list of network endpoint addresses.
+// Copy from [net.addrList] and change type from [net.Addr] to [net.IPAddr]
+type addrList []net.IPAddr
+
+// isIPv4 reports whether addr contains an IPv4 address.
+func isIPv4(addr net.IPAddr) bool {
+	return addr.IP.To4() != nil
+}
+
+// isNotIPv4 reports whether addr does not contain an IPv4 address.
+func isNotIPv4(addr net.IPAddr) bool { return !isIPv4(addr) }
+
+// forResolve returns the most appropriate address in address for
+// a call to ResolveTCPAddr, ResolveUDPAddr, or ResolveIPAddr.
+// IPv4 is preferred, unless addr contains an IPv6 literal.
+func (addrs addrList) forResolve(network, addr string) net.IPAddr {
+	var want6 bool
+	switch network {
+	case "ip":
+		// IPv6 literal (addr does NOT contain a port)
+		want6 = strings.ContainsRune(addr, ':')
+	case "tcp", "udp":
+		// IPv6 literal. (addr contains a port, so look for '[')
+		want6 = strings.ContainsRune(addr, '[')
+	}
+	if want6 {
+		return addrs.first(isNotIPv4)
+	}
+	return addrs.first(isIPv4)
+}
+
+// first returns the first address which satisfies strategy, or if
+// none do, then the first address of any kind.
+func (addrs addrList) first(strategy func(net.IPAddr) bool) net.IPAddr {
+	for _, addr := range addrs {
+		if strategy(addr) {
+			return addr
+		}
+	}
+	return addrs[0]
+}
diff --git a/backend/vendor/github.com/enetx/http3/mockgen.go b/backend/vendor/github.com/enetx/http3/mockgen.go
new file mode 100644
index 00000000..38a6f021
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/mockgen.go
@@ -0,0 +1,11 @@
+//go:build gomock || generate
+
+package http3
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -mock_names=TestClientConnInterface=MockClientConn  -package http3 -destination mock_clientconn_test.go github.com/quic-go/quic-go/http3 TestClientConnInterface"
+type TestClientConnInterface = clientConn
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -mock_names=DatagramStream=MockDatagramStream  -package http3 -destination mock_datagram_stream_test.go github.com/quic-go/quic-go/http3 DatagramStream"
+type DatagramStream = datagramStream
+
+//go:generate sh -c "go tool mockgen -typed -package http3 -destination mock_quic_listener_test.go github.com/quic-go/quic-go/http3 QUICListener"
diff --git a/backend/vendor/github.com/enetx/http3/qlog.go b/backend/vendor/github.com/enetx/http3/qlog.go
new file mode 100644
index 00000000..cd771489
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/qlog.go
@@ -0,0 +1,56 @@
+package http3
+
+import (
+	"github.com/quic-go/quic-go"
+	"github.com/enetx/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+
+	"github.com/quic-go/qpack"
+)
+
+func maybeQlogInvalidHeadersFrame(qlogger qlogwriter.Recorder, streamID quic.StreamID, l uint64) {
+	if qlogger != nil {
+		qlogger.RecordEvent(qlog.FrameParsed{
+			StreamID: streamID,
+			Raw:      qlog.RawInfo{PayloadLength: int(l)},
+			Frame:    qlog.Frame{Frame: qlog.HeadersFrame{}},
+		})
+	}
+}
+
+func qlogParsedHeadersFrame(qlogger qlogwriter.Recorder, streamID quic.StreamID, hf *headersFrame, hfs []qpack.HeaderField) {
+	headerFields := make([]qlog.HeaderField, len(hfs))
+	for i, hf := range hfs {
+		headerFields[i] = qlog.HeaderField{
+			Name:  hf.Name,
+			Value: hf.Value,
+		}
+	}
+	qlogger.RecordEvent(qlog.FrameParsed{
+		StreamID: streamID,
+		Raw: qlog.RawInfo{
+			Length:        int(hf.Length) + hf.headerLen,
+			PayloadLength: int(hf.Length),
+		},
+		Frame: qlog.Frame{Frame: qlog.HeadersFrame{
+			HeaderFields: headerFields,
+		}},
+	})
+}
+
+func qlogCreatedHeadersFrame(qlogger qlogwriter.Recorder, streamID quic.StreamID, length, payloadLength int, hfs []qlog.HeaderField) {
+	headerFields := make([]qlog.HeaderField, len(hfs))
+	for i, hf := range hfs {
+		headerFields[i] = qlog.HeaderField{
+			Name:  hf.Name,
+			Value: hf.Value,
+		}
+	}
+	qlogger.RecordEvent(qlog.FrameCreated{
+		StreamID: streamID,
+		Raw:      qlog.RawInfo{Length: length, PayloadLength: payloadLength},
+		Frame: qlog.Frame{Frame: qlog.HeadersFrame{
+			HeaderFields: headerFields,
+		}},
+	})
+}
diff --git a/backend/vendor/github.com/enetx/http3/qlog/event.go b/backend/vendor/github.com/enetx/http3/qlog/event.go
new file mode 100644
index 00000000..b5bbe112
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/qlog/event.go
@@ -0,0 +1,138 @@
+package qlog
+
+import (
+	"time"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+type encoderHelper struct {
+	enc *jsontext.Encoder
+	err error
+}
+
+func (h *encoderHelper) WriteToken(t jsontext.Token) {
+	if h.err != nil {
+		return
+	}
+	h.err = h.enc.WriteToken(t)
+}
+
+type RawInfo struct {
+	Length        int // full packet length, including header and AEAD authentication tag
+	PayloadLength int // length of the packet payload, excluding AEAD tag
+}
+
+func (i RawInfo) HasValues() bool {
+	return i.Length != 0 || i.PayloadLength != 0
+}
+
+func (i RawInfo) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if i.Length != 0 {
+		h.WriteToken(jsontext.String("length"))
+		h.WriteToken(jsontext.Uint(uint64(i.Length)))
+	}
+	if i.PayloadLength != 0 {
+		h.WriteToken(jsontext.String("payload_length"))
+		h.WriteToken(jsontext.Uint(uint64(i.PayloadLength)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type FrameParsed struct {
+	StreamID quic.StreamID
+	Raw      RawInfo
+	Frame    Frame
+}
+
+func (e FrameParsed) Name() string { return "http3:frame_parsed" }
+
+func (e FrameParsed) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Uint(uint64(e.StreamID)))
+	if e.Raw.HasValues() {
+		h.WriteToken(jsontext.String("raw"))
+		if err := e.Raw.encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.String("frame"))
+	if err := e.Frame.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type FrameCreated struct {
+	StreamID quic.StreamID
+	Raw      RawInfo
+	Frame    Frame
+}
+
+func (e FrameCreated) Name() string { return "http3:frame_created" }
+
+func (e FrameCreated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Uint(uint64(e.StreamID)))
+	if e.Raw.HasValues() {
+		h.WriteToken(jsontext.String("raw"))
+		if err := e.Raw.encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.String("frame"))
+	if err := e.Frame.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type DatagramCreated struct {
+	QuarterStreamID uint64
+	Raw             RawInfo
+}
+
+func (e DatagramCreated) Name() string { return "http3:datagram_created" }
+
+func (e DatagramCreated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("quarter_stream_id"))
+	h.WriteToken(jsontext.Uint(e.QuarterStreamID))
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type DatagramParsed struct {
+	QuarterStreamID uint64
+	Raw             RawInfo
+}
+
+func (e DatagramParsed) Name() string { return "http3:datagram_parsed" }
+
+func (e DatagramParsed) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("quarter_stream_id"))
+	h.WriteToken(jsontext.Uint(e.QuarterStreamID))
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/enetx/http3/qlog/frame.go b/backend/vendor/github.com/enetx/http3/qlog/frame.go
new file mode 100644
index 00000000..b404453d
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/qlog/frame.go
@@ -0,0 +1,220 @@
+package qlog
+
+import (
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+// Frame represents an HTTP/3 frame.
+type Frame struct {
+	Frame any
+}
+
+func (f Frame) encode(enc *jsontext.Encoder) error {
+	switch frame := f.Frame.(type) {
+	case DataFrame:
+		return frame.encode(enc)
+	case HeadersFrame:
+		return frame.encode(enc)
+	case GoAwayFrame:
+		return frame.encode(enc)
+	case SettingsFrame:
+		return frame.encode(enc)
+	case PushPromiseFrame:
+		return frame.encode(enc)
+	case CancelPushFrame:
+		return frame.encode(enc)
+	case MaxPushIDFrame:
+		return frame.encode(enc)
+	case ReservedFrame:
+		return frame.encode(enc)
+	case UnknownFrame:
+		return frame.encode(enc)
+	}
+	// This shouldn't happen if the code is correctly logging frames.
+	// Write a null token to produce valid JSON.
+	return enc.WriteToken(jsontext.Null)
+}
+
+// A DataFrame is a DATA frame
+type DataFrame struct{}
+
+func (f *DataFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("data"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type HeaderField struct {
+	Name  string
+	Value string
+}
+
+// A HeadersFrame is a HEADERS frame
+type HeadersFrame struct {
+	HeaderFields []HeaderField
+}
+
+func (f *HeadersFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("headers"))
+	if len(f.HeaderFields) > 0 {
+		h.WriteToken(jsontext.String("header_fields"))
+		h.WriteToken(jsontext.BeginArray)
+		for _, f := range f.HeaderFields {
+			h.WriteToken(jsontext.BeginObject)
+			h.WriteToken(jsontext.String("name"))
+			h.WriteToken(jsontext.String(f.Name))
+			h.WriteToken(jsontext.String("value"))
+			h.WriteToken(jsontext.String(f.Value))
+			h.WriteToken(jsontext.EndObject)
+		}
+		h.WriteToken(jsontext.EndArray)
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A GoAwayFrame is a GOAWAY frame
+type GoAwayFrame struct {
+	StreamID quic.StreamID
+}
+
+func (f *GoAwayFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("goaway"))
+	h.WriteToken(jsontext.String("id"))
+	h.WriteToken(jsontext.Uint(uint64(f.StreamID)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type SettingsFrame struct {
+	MaxFieldSectionSize int64
+	Datagram            *bool
+	ExtendedConnect     *bool
+	Other               map[uint64]uint64
+}
+
+func (f *SettingsFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("settings"))
+	h.WriteToken(jsontext.String("settings"))
+	h.WriteToken(jsontext.BeginArray)
+	if f.MaxFieldSectionSize >= 0 {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_max_field_section_size"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Uint(uint64(f.MaxFieldSectionSize)))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if f.Datagram != nil {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_h3_datagram"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Bool(*f.Datagram))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if f.ExtendedConnect != nil {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_enable_connect_protocol"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Bool(*f.ExtendedConnect))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if len(f.Other) > 0 {
+		for k, v := range f.Other {
+			h.WriteToken(jsontext.BeginObject)
+			h.WriteToken(jsontext.String("name"))
+			h.WriteToken(jsontext.String("unknown"))
+			h.WriteToken(jsontext.String("name_bytes"))
+			h.WriteToken(jsontext.Uint(k))
+			h.WriteToken(jsontext.String("value"))
+			h.WriteToken(jsontext.Uint(v))
+			h.WriteToken(jsontext.EndObject)
+		}
+	}
+	h.WriteToken(jsontext.EndArray)
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A PushPromiseFrame is a PUSH_PROMISE frame
+type PushPromiseFrame struct{}
+
+func (f *PushPromiseFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("push_promise"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A CancelPushFrame is a CANCEL_PUSH frame
+type CancelPushFrame struct{}
+
+func (f *CancelPushFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("cancel_push"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A MaxPushIDFrame is a MAX_PUSH_ID frame
+type MaxPushIDFrame struct{}
+
+func (f *MaxPushIDFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("max_push_id"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A ReservedFrame is one of the reserved frame types
+type ReservedFrame struct {
+	Type uint64
+}
+
+func (f *ReservedFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("reserved"))
+	h.WriteToken(jsontext.String("frame_type_bytes"))
+	h.WriteToken(jsontext.Uint(f.Type))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// An UnknownFrame is an unknown frame type
+type UnknownFrame struct {
+	Type uint64
+}
+
+func (f *UnknownFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("unknown"))
+	h.WriteToken(jsontext.String("frame_type_bytes"))
+	h.WriteToken(jsontext.Uint(f.Type))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/enetx/http3/qlog/qlog_dir.go b/backend/vendor/github.com/enetx/http3/qlog/qlog_dir.go
new file mode 100644
index 00000000..898d17c6
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/qlog/qlog_dir.go
@@ -0,0 +1,15 @@
+package qlog
+
+import (
+	"context"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+const EventSchema = "urn:ietf:params:qlog:events:http3-12"
+
+func DefaultConnectionTracer(ctx context.Context, isClient bool, connID quic.ConnectionID) qlogwriter.Trace {
+	return qlog.DefaultConnectionTracerWithSchemas(ctx, isClient, connID, []string{qlog.EventSchema, EventSchema})
+}
diff --git a/backend/vendor/github.com/enetx/http3/request_writer.go b/backend/vendor/github.com/enetx/http3/request_writer.go
new file mode 100644
index 00000000..8d4c0443
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/request_writer.go
@@ -0,0 +1,379 @@
+package http3
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"github.com/enetx/http"
+	"github.com/enetx/http/httptrace"
+	"strconv"
+	"strings"
+	"sync"
+
+	"golang.org/x/net/http/httpguts"
+	"golang.org/x/net/http2/hpack"
+	"golang.org/x/net/idna"
+
+	"github.com/quic-go/qpack"
+	"github.com/quic-go/quic-go"
+	"github.com/enetx/http3/httpcommon"
+	"github.com/enetx/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+const bodyCopyBufferSize = 8 * 1024
+
+type requestWriter struct {
+	mutex     sync.Mutex
+	encoder   *qpack.Encoder
+	headerBuf *bytes.Buffer
+}
+
+func newRequestWriter() *requestWriter {
+	headerBuf := &bytes.Buffer{}
+	encoder := qpack.NewEncoder(headerBuf)
+	return &requestWriter{
+		encoder:   encoder,
+		headerBuf: headerBuf,
+	}
+}
+
+func (w *requestWriter) WriteRequestHeader(wr io.Writer, req *http.Request, gzip bool, streamID quic.StreamID, qlogger qlogwriter.Recorder) error {
+	buf := &bytes.Buffer{}
+	if err := w.writeHeaders(buf, req, gzip, streamID, qlogger); err != nil {
+		return err
+	}
+	if _, err := wr.Write(buf.Bytes()); err != nil {
+		return err
+	}
+	trace := httptrace.ContextClientTrace(req.Context())
+	traceWroteHeaders(trace)
+	return nil
+}
+
+func (w *requestWriter) writeHeaders(wr io.Writer, req *http.Request, gzip bool, streamID quic.StreamID, qlogger qlogwriter.Recorder) error {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+	defer w.encoder.Close()
+	defer w.headerBuf.Reset()
+
+	var trailers string
+	if len(req.Trailer) > 0 {
+		keys := make([]string, 0, len(req.Trailer))
+		for k := range req.Trailer {
+			if httpguts.ValidTrailerHeader(k) {
+				keys = append(keys, k)
+			}
+		}
+		trailers = strings.Join(keys, ", ")
+	}
+
+	headerFields, err := w.encodeHeaders(req, gzip, trailers, actualContentLength(req), qlogger != nil)
+	if err != nil {
+		return err
+	}
+
+	b := make([]byte, 0, 128)
+	b = (&headersFrame{Length: uint64(w.headerBuf.Len())}).Append(b)
+	if qlogger != nil {
+		qlogCreatedHeadersFrame(qlogger, streamID, len(b)+w.headerBuf.Len(), w.headerBuf.Len(), headerFields)
+	}
+	if _, err := wr.Write(b); err != nil {
+		return err
+	}
+	_, err = wr.Write(w.headerBuf.Bytes())
+	return err
+}
+
+func isExtendedConnectRequest(req *http.Request) bool {
+	return req.Method == http.MethodConnect && req.Proto != "" && req.Proto != "HTTP/1.1"
+}
+
+// copied from net/transport.go
+// Modified to support Extended CONNECT:
+// Contrary to what the godoc for the http.Request says,
+// we do respect the Proto field if the method is CONNECT.
+//
+// The returned header fields are only set if doQlog is true.
+func (w *requestWriter) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64, doQlog bool) ([]qlog.HeaderField, error) {
+	host := req.Host
+	if host == "" {
+		host = req.URL.Host
+	}
+	host, err := httpguts.PunycodeHostPort(host)
+	if err != nil {
+		return nil, err
+	}
+	if !httpguts.ValidHostHeader(host) {
+		return nil, errors.New("http3: invalid Host header")
+	}
+
+	// http.NewRequest sets this field to HTTP/1.1
+	isExtendedConnect := isExtendedConnectRequest(req)
+	if isExtendedConnect && !validExtendedConnectProtocol(req.Proto) {
+		return nil, fmt.Errorf("invalid request :protocol %q", req.Proto)
+	}
+
+	var path string
+	if req.Method != http.MethodConnect || isExtendedConnect {
+		path = req.URL.RequestURI()
+		if !validPseudoPath(path) {
+			orig := path
+			path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host)
+			if !validPseudoPath(path) {
+				if req.URL.Opaque != "" {
+					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
+				} else {
+					return nil, fmt.Errorf("invalid request :path %q", orig)
+				}
+			}
+		}
+	}
+
+	// Check for any invalid headers and return an error before we
+	// potentially pollute our hpack state. (We want to be able to
+	// continue to reuse the hpack encoder for future requests)
+	for k, vv := range req.Header {
+		// Skip validation for special header order keys
+		if k == httpcommon.HeaderOrderKey || k == httpcommon.PHeaderOrderKey {
+			continue
+		}
+		if !httpguts.ValidHeaderFieldName(k) {
+			return nil, fmt.Errorf("invalid HTTP header name %q", k)
+		}
+		for _, v := range vv {
+			if !httpguts.ValidHeaderFieldValue(v) {
+				return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
+			}
+		}
+	}
+
+	enumerateHeaders := func(f func(name, value string)) {
+		// Handle pseudo-headers with order support
+		pHeaderOrder, hasPHeaderOrder := req.Header[httpcommon.PHeaderOrderKey]
+		
+		if hasPHeaderOrder {
+			// Follow pseudo header order
+			for _, p := range pHeaderOrder {
+				switch p {
+				case ":authority":
+					f(":authority", host)
+				case ":method":
+					f(":method", req.Method)
+				case ":path":
+					if req.Method != http.MethodConnect || isExtendedConnect {
+						f(":path", path)
+					}
+				case ":scheme":
+					if req.Method != http.MethodConnect || isExtendedConnect {
+						f(":scheme", req.URL.Scheme)
+					}
+				case ":protocol":
+					if isExtendedConnect {
+						f(":protocol", req.Proto)
+					}
+				default:
+					continue
+				}
+			}
+		} else {
+			// Default pseudo-header order
+			f(":authority", host)
+			f(":method", req.Method)
+			if req.Method != http.MethodConnect || isExtendedConnect {
+				f(":path", path)
+				f(":scheme", req.URL.Scheme)
+			}
+			if isExtendedConnect {
+				f(":protocol", req.Proto)
+			}
+		}
+		
+		if trailers != "" {
+			f("trailer", trailers)
+		}
+
+		// Handle regular headers with order support
+		exclude := make(map[string]bool)
+		exclude[httpcommon.HeaderOrderKey] = true
+		exclude[httpcommon.PHeaderOrderKey] = true
+		
+		var kvs []httpcommon.HeaderKeyValues
+		var sorter *httpcommon.HeaderSorter
+		
+		if headerOrder, hasHeaderOrder := req.Header[httpcommon.HeaderOrderKey]; hasHeaderOrder {
+			order := make(map[string]int)
+			for i, v := range headerOrder {
+				order[v] = i
+			}
+			kvs, sorter = httpcommon.SortedKeyValuesBy(req.Header, order, exclude)
+		} else {
+			kvs, sorter = httpcommon.SortedKeyValues(req.Header, exclude)
+		}
+		
+		var didUA bool
+		for _, kv := range kvs {
+			k := kv.Key
+			vv := kv.Values
+			
+			if strings.EqualFold(k, "host") || strings.EqualFold(k, "content-length") {
+				// Host is :authority, already sent.
+				// Content-Length is automatic, set below.
+				continue
+			} else if strings.EqualFold(k, "connection") || strings.EqualFold(k, "proxy-connection") ||
+				strings.EqualFold(k, "transfer-encoding") || strings.EqualFold(k, "upgrade") ||
+				strings.EqualFold(k, "keep-alive") {
+				// Per 8.1.2.2 Connection-Specific Header
+				// Fields, don't send connection-specific
+				// fields. We have already checked if any
+				// are error-worthy so just ignore the rest.
+				continue
+			} else if strings.EqualFold(k, "user-agent") {
+				// Match Go's http1 behavior: at most one
+				// User-Agent. If set to nil or empty string,
+				// then omit it. Otherwise if not mentioned,
+				// include the default (below).
+				didUA = true
+				if len(vv) < 1 {
+					continue
+				}
+				vv = vv[:1]
+				if vv[0] == "" {
+					continue
+				}
+
+			}
+
+			for _, v := range vv {
+				f(k, v)
+			}
+		}
+		
+		httpcommon.ReturnSorter(sorter)
+		
+		if shouldSendReqContentLength(req.Method, contentLength) {
+			f("content-length", strconv.FormatInt(contentLength, 10))
+		}
+		if addGzipHeader {
+			f("accept-encoding", "gzip")
+		}
+		if !didUA {
+			f("user-agent", defaultUserAgent)
+		}
+	}
+
+	// Do a first pass over the headers counting bytes to ensure
+	// we don't exceed cc.peerMaxHeaderListSize. This is done as a
+	// separate pass before encoding the headers to prevent
+	// modifying the hpack state.
+	hlSize := uint64(0)
+	enumerateHeaders(func(name, value string) {
+		hf := hpack.HeaderField{Name: name, Value: value}
+		hlSize += uint64(hf.Size())
+	})
+
+	// TODO: check maximum header list size
+	// if hlSize > cc.peerMaxHeaderListSize {
+	// 	return errRequestHeaderListSize
+	// }
+
+	trace := httptrace.ContextClientTrace(req.Context())
+	traceHeaders := traceHasWroteHeaderField(trace)
+
+	// Header list size is ok. Write the headers.
+	var headerFields []qlog.HeaderField
+	if doQlog {
+		headerFields = make([]qlog.HeaderField, 0, len(req.Header))
+	}
+	enumerateHeaders(func(name, value string) {
+		name = strings.ToLower(name)
+		w.encoder.WriteField(qpack.HeaderField{Name: name, Value: value})
+		if traceHeaders {
+			traceWroteHeaderField(trace, name, value)
+		}
+		if doQlog {
+			headerFields = append(headerFields, qlog.HeaderField{Name: name, Value: value})
+		}
+	})
+
+	return headerFields, nil
+}
+
+// authorityAddr returns a given authority (a host/IP, or host:port / ip:port)
+// and returns a host:port. The port 443 is added if needed.
+func authorityAddr(authority string) (addr string) {
+	host, port, err := net.SplitHostPort(authority)
+	if err != nil { // authority didn't have a port
+		port = "443"
+		host = authority
+	}
+	if a, err := idna.ToASCII(host); err == nil {
+		host = a
+	}
+	// IPv6 address literal, without a port:
+	if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
+		return host + ":" + port
+	}
+	return net.JoinHostPort(host, port)
+}
+
+// validPseudoPath reports whether v is a valid :path pseudo-header
+// value. It must be either:
+//
+//	*) a non-empty string starting with '/'
+//	*) the string '*', for OPTIONS requests.
+//
+// For now this is only used a quick check for deciding when to clean
+// up Opaque URLs before sending requests from the Transport.
+// See golang.org/issue/16847
+//
+// We used to enforce that the path also didn't start with "//", but
+// Google's GFE accepts such paths and Chrome sends them, so ignore
+// that part of the spec. See golang.org/issue/19103.
+func validPseudoPath(v string) bool {
+	return (len(v) > 0 && v[0] == '/') || v == "*"
+}
+
+// actualContentLength returns a sanitized version of
+// req.ContentLength, where 0 actually means zero (not unknown) and -1
+// means unknown.
+func actualContentLength(req *http.Request) int64 {
+	if req.Body == nil {
+		return 0
+	}
+	if req.ContentLength != 0 {
+		return req.ContentLength
+	}
+	return -1
+}
+
+// shouldSendReqContentLength reports whether the http2.Transport should send
+// a "content-length" request header. This logic is basically a copy of the net/http
+// transferWriter.shouldSendContentLength.
+// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
+// -1 means unknown.
+func shouldSendReqContentLength(method string, contentLength int64) bool {
+	if contentLength > 0 {
+		return true
+	}
+	if contentLength < 0 {
+		return false
+	}
+	// For zero bodies, whether we send a content-length depends on the method.
+	// It also kinda doesn't matter for http2 either way, with END_STREAM.
+	switch method {
+	case "POST", "PUT", "PATCH":
+		return true
+	default:
+		return false
+	}
+}
+
+// WriteRequestTrailer writes HTTP trailers to the stream.
+// It should be called after the request body has been fully written.
+func (w *requestWriter) WriteRequestTrailer(wr io.Writer, req *http.Request, streamID quic.StreamID, qlogger qlogwriter.Recorder) error {
+	_, err := writeTrailers(wr, req.Trailer, streamID, qlogger)
+	return err
+}
diff --git a/backend/vendor/github.com/enetx/http3/response_writer.go b/backend/vendor/github.com/enetx/http3/response_writer.go
new file mode 100644
index 00000000..56ef3ced
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/response_writer.go
@@ -0,0 +1,372 @@
+package http3
+
+import (
+	"bytes"
+	"fmt"
+	"log/slog"
+	"github.com/enetx/http"
+	"net/textproto"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/quic-go/qpack"
+	"github.com/enetx/http3/qlog"
+
+	"golang.org/x/net/http/httpguts"
+)
+
+// The HTTPStreamer allows taking over a HTTP/3 stream. The interface is implemented by the http.ResponseWriter.
+// When a stream is taken over, it's the caller's responsibility to close the stream.
+type HTTPStreamer interface {
+	HTTPStream() *Stream
+}
+
+const maxSmallResponseSize = 4096
+
+type responseWriter struct {
+	str *Stream
+
+	conn     *rawConn
+	header   http.Header
+	trailers map[string]struct{}
+	buf      []byte
+	status   int // status code passed to WriteHeader
+
+	// for responses smaller than maxSmallResponseSize, we buffer calls to Write,
+	// and automatically add the Content-Length header
+	smallResponseBuf []byte
+
+	contentLen     int64 // if handler set valid Content-Length header
+	numWritten     int64 // bytes written
+	headerComplete bool  // set once WriteHeader is called with a status code >= 200
+	headerWritten  bool  // set once the response header has been serialized to the stream
+	isHead         bool
+	trailerWritten bool // set once the response trailers has been serialized to the stream
+
+	hijacked bool // set on HTTPStream is called
+
+	logger *slog.Logger
+}
+
+var (
+	_ http.ResponseWriter = &responseWriter{}
+	_ http.Flusher        = &responseWriter{}
+	_ Settingser          = &responseWriter{}
+	_ HTTPStreamer        = &responseWriter{}
+	// make sure that we implement (some of the) methods used by the http.ResponseController
+	_ interface {
+		SetReadDeadline(time.Time) error
+		SetWriteDeadline(time.Time) error
+		Flush()
+		FlushError() error
+	} = &responseWriter{}
+)
+
+func newResponseWriter(str *Stream, conn *rawConn, isHead bool, logger *slog.Logger) *responseWriter {
+	return &responseWriter{
+		str:    str,
+		conn:   conn,
+		header: http.Header{},
+		buf:    make([]byte, frameHeaderLen),
+		isHead: isHead,
+		logger: logger,
+	}
+}
+
+func (w *responseWriter) Header() http.Header {
+	return w.header
+}
+
+func (w *responseWriter) WriteHeader(status int) {
+	if w.headerComplete {
+		return
+	}
+
+	// http status must be 3 digits
+	if status < 100 || status > 999 {
+		panic(fmt.Sprintf("invalid WriteHeader code %v", status))
+	}
+	w.status = status
+
+	// immediately write 1xx headers
+	if status < 200 {
+		w.writeHeader(status)
+		return
+	}
+
+	// We're done with headers once we write a status >= 200.
+	w.headerComplete = true
+	// Add Date header.
+	// This is what the standard library does.
+	// Can be disabled by setting the Date header to nil.
+	if _, ok := w.header["Date"]; !ok {
+		w.header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
+	}
+	// Content-Length checking
+	// use ParseUint instead of ParseInt, as negative values are invalid
+	if clen := w.header.Get("Content-Length"); clen != "" {
+		if cl, err := strconv.ParseUint(clen, 10, 63); err == nil {
+			w.contentLen = int64(cl)
+		} else {
+			// emit a warning for malformed Content-Length and remove it
+			logger := w.logger
+			if logger == nil {
+				logger = slog.Default()
+			}
+			logger.Error("Malformed Content-Length", "value", clen)
+			w.header.Del("Content-Length")
+		}
+	}
+}
+
+func (w *responseWriter) sniffContentType(p []byte) {
+	// If no content type, apply sniffing algorithm to body.
+	// We can't use `w.header.Get` here since if the Content-Type was set to nil, we shouldn't do sniffing.
+	_, haveType := w.header["Content-Type"]
+
+	// If the Content-Encoding was set and is non-blank, we shouldn't sniff the body.
+	hasCE := w.header.Get("Content-Encoding") != ""
+	if !hasCE && !haveType && len(p) > 0 {
+		w.header.Set("Content-Type", http.DetectContentType(p))
+	}
+}
+
+func (w *responseWriter) Write(p []byte) (int, error) {
+	bodyAllowed := bodyAllowedForStatus(w.status)
+	if !w.headerComplete {
+		w.sniffContentType(p)
+		w.WriteHeader(http.StatusOK)
+		bodyAllowed = true
+	}
+	if !bodyAllowed {
+		return 0, http.ErrBodyNotAllowed
+	}
+
+	w.numWritten += int64(len(p))
+	if w.contentLen != 0 && w.numWritten > w.contentLen {
+		return 0, http.ErrContentLength
+	}
+
+	if w.isHead {
+		return len(p), nil
+	}
+
+	if !w.headerWritten {
+		// Buffer small responses.
+		// This allows us to automatically set the Content-Length field.
+		if len(w.smallResponseBuf)+len(p) < maxSmallResponseSize {
+			w.smallResponseBuf = append(w.smallResponseBuf, p...)
+			return len(p), nil
+		}
+	}
+	return w.doWrite(p)
+}
+
+func (w *responseWriter) doWrite(p []byte) (int, error) {
+	if !w.headerWritten {
+		w.sniffContentType(w.smallResponseBuf)
+		if err := w.writeHeader(w.status); err != nil {
+			return 0, maybeReplaceError(err)
+		}
+		w.headerWritten = true
+	}
+
+	l := uint64(len(w.smallResponseBuf) + len(p))
+	if l == 0 {
+		return 0, nil
+	}
+	df := &dataFrame{Length: l}
+	w.buf = w.buf[:0]
+	w.buf = df.Append(w.buf)
+	if w.str.qlogger != nil {
+		w.str.qlogger.RecordEvent(qlog.FrameCreated{
+			StreamID: w.str.StreamID(),
+			Raw:      qlog.RawInfo{Length: len(w.buf) + int(l), PayloadLength: int(l)},
+			Frame:    qlog.Frame{Frame: qlog.DataFrame{}},
+		})
+	}
+	if _, err := w.str.writeUnframed(w.buf); err != nil {
+		return 0, maybeReplaceError(err)
+	}
+	if len(w.smallResponseBuf) > 0 {
+		if _, err := w.str.writeUnframed(w.smallResponseBuf); err != nil {
+			return 0, maybeReplaceError(err)
+		}
+		w.smallResponseBuf = nil
+	}
+	var n int
+	if len(p) > 0 {
+		var err error
+		n, err = w.str.writeUnframed(p)
+		if err != nil {
+			return n, maybeReplaceError(err)
+		}
+	}
+	return n, nil
+}
+
+func (w *responseWriter) writeHeader(status int) error {
+	var headerFields []qlog.HeaderField // only used for qlog
+	var headers bytes.Buffer
+	enc := qpack.NewEncoder(&headers)
+	if err := enc.WriteField(qpack.HeaderField{Name: ":status", Value: strconv.Itoa(status)}); err != nil {
+		return err
+	}
+	if w.str.qlogger != nil {
+		headerFields = append(headerFields, qlog.HeaderField{Name: ":status", Value: strconv.Itoa(status)})
+	}
+
+	// Handle trailer fields
+	if vals, ok := w.header["Trailer"]; ok {
+		for _, val := range vals {
+			for trailer := range strings.SplitSeq(val, ",") {
+				// We need to convert to the canonical header key value here because this will be called when using
+				// headers.Add or headers.Set.
+				trailer = textproto.CanonicalMIMEHeaderKey(strings.TrimSpace(trailer))
+				w.declareTrailer(trailer)
+			}
+		}
+	}
+
+	for k, v := range w.header {
+		if _, excluded := w.trailers[k]; excluded {
+			continue
+		}
+		// Ignore "Trailer:" prefixed headers
+		if strings.HasPrefix(k, http.TrailerPrefix) {
+			continue
+		}
+		for index := range v {
+			name := strings.ToLower(k)
+			value := v[index]
+			if err := enc.WriteField(qpack.HeaderField{Name: name, Value: value}); err != nil {
+				return err
+			}
+			if w.str.qlogger != nil {
+				headerFields = append(headerFields, qlog.HeaderField{Name: name, Value: value})
+			}
+		}
+	}
+
+	buf := make([]byte, 0, frameHeaderLen+headers.Len())
+	buf = (&headersFrame{Length: uint64(headers.Len())}).Append(buf)
+	buf = append(buf, headers.Bytes()...)
+
+	if w.str.qlogger != nil {
+		qlogCreatedHeadersFrame(w.str.qlogger, w.str.StreamID(), len(buf), headers.Len(), headerFields)
+	}
+
+	_, err := w.str.writeUnframed(buf)
+	return err
+}
+
+func (w *responseWriter) FlushError() error {
+	if !w.headerComplete {
+		w.WriteHeader(http.StatusOK)
+	}
+	_, err := w.doWrite(nil)
+	return err
+}
+
+func (w *responseWriter) flushTrailers() {
+	if w.trailerWritten {
+		return
+	}
+	if err := w.writeTrailers(); err != nil {
+		if w.logger != nil {
+			w.logger.Debug("could not write trailers", "error", err)
+		}
+	}
+}
+
+func (w *responseWriter) Flush() {
+	if err := w.FlushError(); err != nil {
+		if w.logger != nil {
+			w.logger.Debug("could not flush to stream", "error", err)
+		}
+	}
+}
+
+// declareTrailer adds a trailer to the trailer list, while also validating that the trailer has a
+// valid name.
+func (w *responseWriter) declareTrailer(k string) {
+	if !httpguts.ValidTrailerHeader(k) {
+		// Forbidden by RFC 9110, section 6.5.1.
+		if w.logger != nil {
+			w.logger.Debug("ignoring invalid trailer", slog.String("header", k))
+		}
+		return
+	}
+	if w.trailers == nil {
+		w.trailers = make(map[string]struct{})
+	}
+	w.trailers[k] = struct{}{}
+}
+
+// writeTrailers will write trailers to the stream if there are any.
+func (w *responseWriter) writeTrailers() error {
+	// promote headers added via "Trailer:" convention as trailers, these can be added after
+	// streaming the status/headers have been written.
+	for k := range w.header {
+		if strings.HasPrefix(k, http.TrailerPrefix) {
+			w.declareTrailer(k)
+		}
+	}
+
+	if len(w.trailers) == 0 {
+		return nil
+	}
+
+	trailers := make(http.Header, len(w.trailers))
+	for trailer := range w.trailers {
+		if vals, ok := w.header[trailer]; ok {
+			trailers[strings.TrimPrefix(trailer, http.TrailerPrefix)] = vals
+		}
+	}
+
+	written, err := writeTrailers(w.str.datagramStream, trailers, w.str.StreamID(), w.str.qlogger)
+	if written {
+	w.trailerWritten = true
+	}
+	return err
+}
+
+func (w *responseWriter) HTTPStream() *Stream {
+	w.hijacked = true
+	w.Flush()
+	return w.str
+}
+
+func (w *responseWriter) wasStreamHijacked() bool { return w.hijacked }
+
+func (w *responseWriter) ReceivedSettings() <-chan struct{} {
+	return w.conn.ReceivedSettings()
+}
+
+func (w *responseWriter) Settings() *Settings {
+	return w.conn.Settings()
+}
+
+func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
+	return w.str.SetReadDeadline(deadline)
+}
+
+func (w *responseWriter) SetWriteDeadline(deadline time.Time) error {
+	return w.str.SetWriteDeadline(deadline)
+}
+
+// copied from http2/http2.go
+// bodyAllowedForStatus reports whether a given response status code
+// permits a body. See RFC 2616, section 4.4.
+func bodyAllowedForStatus(status int) bool {
+	switch {
+	case status >= 100 && status <= 199:
+		return false
+	case status == http.StatusNoContent:
+		return false
+	case status == http.StatusNotModified:
+		return false
+	}
+	return true
+}
diff --git a/backend/vendor/github.com/enetx/http3/server.go b/backend/vendor/github.com/enetx/http3/server.go
new file mode 100644
index 00000000..b5cc8638
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/server.go
@@ -0,0 +1,740 @@
+package http3
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"slices"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/enetx/g"
+	"github.com/enetx/http"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// NextProtoH3 is the ALPN protocol negotiated during the TLS handshake, for QUIC v1 and v2.
+const NextProtoH3 = "h3"
+
+// StreamType is the stream type of a unidirectional stream.
+type StreamType uint64
+
+const (
+	streamTypeControlStream      = 0
+	streamTypePushStream         = 1
+	streamTypeQPACKEncoderStream = 2
+	streamTypeQPACKDecoderStream = 3
+)
+
+// A QUICListener listens for incoming QUIC connections.
+type QUICListener interface {
+	Accept(context.Context) (*quic.Conn, error)
+	Addr() net.Addr
+	io.Closer
+}
+
+var _ QUICListener = &quic.EarlyListener{}
+
+// ConfigureTLSConfig creates a new tls.Config which can be used
+// to create a quic.Listener meant for serving HTTP/3.
+func ConfigureTLSConfig(tlsConf *tls.Config) *tls.Config {
+	// Workaround for https://github.com/golang/go/issues/60506.
+	// This initializes the session tickets _before_ cloning the config.
+	_, _ = tlsConf.DecryptTicket(nil, tls.ConnectionState{})
+	config := tlsConf.Clone()
+	config.NextProtos = []string{NextProtoH3}
+	if gfc := config.GetConfigForClient; gfc != nil {
+		config.GetConfigForClient = func(ch *tls.ClientHelloInfo) (*tls.Config, error) {
+			conf, err := gfc(ch)
+			if conf == nil || err != nil {
+				return conf, err
+			}
+			return ConfigureTLSConfig(conf), nil
+		}
+	}
+	return config
+}
+
+// contextKey is a value for use with context.WithValue. It's used as
+// a pointer so it fits in an interface{} without allocation.
+type contextKey struct {
+	name string
+}
+
+func (k *contextKey) String() string { return "quic-go/http3 context value " + k.name }
+
+// ServerContextKey is a context key. It can be used in HTTP
+// handlers with Context.Value to access the server that
+// started the handler. The associated value will be of
+// type *http3.Server.
+var ServerContextKey = &contextKey{"http3-server"}
+
+// RemoteAddrContextKey is a context key. It can be used in
+// HTTP handlers with Context.Value to access the remote
+// address of the connection. The associated value will be of
+// type net.Addr.
+//
+// Use this value instead of [http.Request.RemoteAddr] if you
+// require access to the remote address of the connection rather
+// than its string representation.
+var RemoteAddrContextKey = &contextKey{"remote-addr"}
+
+// listener contains info about specific listener added with addListener
+type listener struct {
+	ln   *QUICListener
+	port int // 0 means that no info about port is available
+
+	// if this listener was constructed by the application, it won't be closed when the server is closed
+	createdLocally bool
+}
+
+// Server is a HTTP/3 server.
+type Server struct {
+	// Addr optionally specifies the UDP address for the server to listen on,
+	// in the form "host:port".
+	//
+	// When used by ListenAndServe and ListenAndServeTLS methods, if empty,
+	// ":https" (port 443) is used. See net.Dial for details of the address
+	// format.
+	//
+	// Otherwise, if Port is not set and underlying QUIC listeners do not
+	// have valid port numbers, the port part is used in Alt-Svc headers set
+	// with SetQUICHeaders.
+	Addr string
+
+	// Port is used in Alt-Svc response headers set with SetQUICHeaders. If
+	// needed Port can be manually set when the Server is created.
+	//
+	// This is useful when a Layer 4 firewall is redirecting UDP traffic and
+	// clients must use a port different from the port the Server is
+	// listening on.
+	Port int
+
+	// TLSConfig provides a TLS configuration for use by server. It must be
+	// set for ListenAndServe and Serve methods.
+	TLSConfig *tls.Config
+
+	// QUICConfig provides the parameters for QUIC connection created with Serve.
+	// If nil, it uses reasonable default values.
+	//
+	// Configured versions are also used in Alt-Svc response header set with SetQUICHeaders.
+	QUICConfig *quic.Config
+
+	// Handler is the HTTP request handler to use. If not set, defaults to
+	// http.NotFound.
+	Handler http.Handler
+
+	// EnableDatagrams enables support for HTTP/3 datagrams (RFC 9297).
+	// If set to true, QUICConfig.EnableDatagrams will be set.
+	EnableDatagrams bool
+
+	// MaxHeaderBytes controls the maximum number of bytes the server will
+	// read parsing the request HEADERS frame. It does not limit the size of
+	// the request body. If zero or negative, http.DefaultMaxHeaderBytes is
+	// used.
+	MaxHeaderBytes int
+
+	// AdditionalSettings specifies additional HTTP/3 settings.
+	// It is invalid to specify any settings defined by RFC 9114 (HTTP/3) and RFC 9297 (HTTP Datagrams).
+	AdditionalSettings g.MapOrd[uint64, uint64]
+
+	// IdleTimeout specifies how long until idle clients connection should be
+	// closed. Idle refers only to the HTTP/3 layer, activity at the QUIC layer
+	// like PING frames are not considered.
+	// If zero or negative, there is no timeout.
+	IdleTimeout time.Duration
+
+	// ConnContext optionally specifies a function that modifies the context used for a new connection c.
+	// The provided ctx has a ServerContextKey value.
+	ConnContext func(ctx context.Context, c *quic.Conn) context.Context
+
+	Logger *slog.Logger
+
+	mutex     sync.RWMutex
+	listeners []listener
+
+	closed           bool
+	closeCtx         context.Context    // canceled when the server is closed
+	closeCancel      context.CancelFunc // cancels the closeCtx
+	graceCtx         context.Context    // canceled when the server is closed or gracefully closed
+	graceCancel      context.CancelFunc // cancels the graceCtx
+	connCount        atomic.Int64
+	connHandlingDone chan struct{}
+
+	altSvcHeader string
+}
+
+// ListenAndServe listens on the UDP address s.Addr and calls s.Handler to handle HTTP/3 requests on incoming connections.
+//
+// If s.Addr is blank, ":https" is used.
+func (s *Server) ListenAndServe() error {
+	ln, err := s.setupListenerForConn(s.TLSConfig, nil)
+	if err != nil {
+		return err
+	}
+	defer s.removeListener(ln)
+
+	return s.serveListener(*ln)
+}
+
+// ListenAndServeTLS listens on the UDP address s.Addr and calls s.Handler to handle HTTP/3 requests on incoming connections.
+//
+// If s.Addr is blank, ":https" is used.
+func (s *Server) ListenAndServeTLS(certFile, keyFile string) error {
+	var err error
+	certs := make([]tls.Certificate, 1)
+	certs[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+	if err != nil {
+		return err
+	}
+	// We currently only use the cert-related stuff from tls.Config,
+	// so we don't need to make a full copy.
+	ln, err := s.setupListenerForConn(&tls.Config{Certificates: certs}, nil)
+	if err != nil {
+		return err
+	}
+	defer s.removeListener(ln)
+
+	return s.serveListener(*ln)
+}
+
+// Serve an existing UDP connection.
+// It is possible to reuse the same connection for outgoing connections.
+// Closing the server does not close the connection.
+func (s *Server) Serve(conn net.PacketConn) error {
+	ln, err := s.setupListenerForConn(s.TLSConfig, conn)
+	if err != nil {
+		return err
+	}
+	defer s.removeListener(ln)
+
+	return s.serveListener(*ln)
+}
+
+// init initializes the contexts used for shutting down the server.
+// It must be called with the mutex held.
+func (s *Server) init() {
+	if s.closeCtx == nil {
+		s.closeCtx, s.closeCancel = context.WithCancel(context.Background())
+		s.graceCtx, s.graceCancel = context.WithCancel(s.closeCtx)
+	}
+	s.connHandlingDone = make(chan struct{}, 1)
+}
+
+func (s *Server) decreaseConnCount() {
+	if s.connCount.Add(-1) == 0 && s.graceCtx.Err() != nil {
+		close(s.connHandlingDone)
+	}
+}
+
+// ServeQUICConn serves a single QUIC connection.
+func (s *Server) ServeQUICConn(conn *quic.Conn) error {
+	s.mutex.Lock()
+	if s.closed {
+		s.mutex.Unlock()
+		return http.ErrServerClosed
+	}
+
+	s.init()
+	s.mutex.Unlock()
+
+	s.connCount.Add(1)
+	defer s.decreaseConnCount()
+
+	return s.handleConn(conn)
+}
+
+// ServeListener serves an existing QUIC listener.
+// Make sure you use http3.ConfigureTLSConfig to configure a tls.Config
+// and use it to construct a http3-friendly QUIC listener.
+// Closing the server does not close the listener. It is the application's responsibility to close them.
+// ServeListener always returns a non-nil error. After Shutdown or Close, the returned error is http.ErrServerClosed.
+func (s *Server) ServeListener(ln QUICListener) error {
+	s.mutex.Lock()
+	if err := s.addListener(&ln, false); err != nil {
+		s.mutex.Unlock()
+		return err
+	}
+	s.mutex.Unlock()
+	defer s.removeListener(&ln)
+
+	return s.serveListener(ln)
+}
+
+func (s *Server) serveListener(ln QUICListener) error {
+	for {
+		conn, err := ln.Accept(s.graceCtx)
+		// server closed
+		if errors.Is(err, quic.ErrServerClosed) || s.graceCtx.Err() != nil {
+			return http.ErrServerClosed
+		}
+		if err != nil {
+			return err
+		}
+		s.connCount.Add(1)
+		go func() {
+			defer s.decreaseConnCount()
+			if err := s.handleConn(conn); err != nil {
+				if s.Logger != nil {
+					s.Logger.Debug("handling connection failed", "error", err)
+				}
+			}
+		}()
+	}
+}
+
+var errServerWithoutTLSConfig = errors.New("use of http3.Server without TLSConfig")
+
+func (s *Server) setupListenerForConn(tlsConf *tls.Config, conn net.PacketConn) (*QUICListener, error) {
+	if tlsConf == nil {
+		return nil, errServerWithoutTLSConfig
+	}
+
+	baseConf := ConfigureTLSConfig(tlsConf)
+	quicConf := s.QUICConfig
+	if quicConf == nil {
+		quicConf = &quic.Config{Allow0RTT: true}
+	} else {
+		quicConf = s.QUICConfig.Clone()
+	}
+	if s.EnableDatagrams {
+		quicConf.EnableDatagrams = true
+	}
+
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	closed := s.closed
+	if closed {
+		return nil, http.ErrServerClosed
+	}
+
+	var ln QUICListener
+	var err error
+	if conn == nil {
+		addr := s.Addr
+		if addr == "" {
+			addr = ":https"
+		}
+		ln, err = quic.ListenAddrEarly(addr, baseConf, quicConf)
+	} else {
+		ln, err = quic.ListenEarly(conn, baseConf, quicConf)
+	}
+	if err != nil {
+		return nil, err
+	}
+	if err := s.addListener(&ln, true); err != nil {
+		return nil, err
+	}
+	return &ln, nil
+}
+
+func extractPort(addr string) (int, error) {
+	_, portStr, err := net.SplitHostPort(addr)
+	if err != nil {
+		return 0, err
+	}
+
+	portInt, err := net.LookupPort("tcp", portStr)
+	if err != nil {
+		return 0, err
+	}
+	return portInt, nil
+}
+
+func (s *Server) generateAltSvcHeader() {
+	if len(s.listeners) == 0 {
+		// Don't announce any ports since no one is listening for connections
+		s.altSvcHeader = ""
+		return
+	}
+
+	// This code assumes that we will use protocol.SupportedVersions if no quic.Config is passed.
+
+	var altSvc []string
+	addPort := func(port int) {
+		altSvc = append(altSvc, fmt.Sprintf(`%s=":%d"; ma=2592000`, NextProtoH3, port))
+	}
+
+	if s.Port != 0 {
+		// if Port is specified, we must use it instead of the
+		// listener addresses since there's a reason it's specified.
+		addPort(s.Port)
+	} else {
+		// if we have some listeners assigned, try to find ports
+		// which we can announce, otherwise nothing should be announced
+		validPortsFound := false
+		for _, info := range s.listeners {
+			if info.port != 0 {
+				addPort(info.port)
+				validPortsFound = true
+			}
+		}
+		if !validPortsFound {
+			if port, err := extractPort(s.Addr); err == nil {
+				addPort(port)
+			}
+		}
+	}
+
+	s.altSvcHeader = strings.Join(altSvc, ",")
+}
+
+func (s *Server) addListener(l *QUICListener, createdLocally bool) error {
+	if s.closed {
+		return http.ErrServerClosed
+	}
+	s.init()
+
+	laddr := (*l).Addr()
+	if port, err := extractPort(laddr.String()); err == nil {
+		s.listeners = append(s.listeners, listener{ln: l, port: port, createdLocally: createdLocally})
+	} else {
+		logger := s.Logger
+		if logger == nil {
+			logger = slog.Default()
+		}
+		logger.Error("Unable to extract port from listener, will not be announced using SetQUICHeaders", "local addr", laddr, "error", err)
+		s.listeners = append(s.listeners, listener{ln: l, port: 0, createdLocally: createdLocally})
+	}
+	s.generateAltSvcHeader()
+	return nil
+}
+
+func (s *Server) removeListener(l *QUICListener) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	s.listeners = slices.DeleteFunc(s.listeners, func(info listener) bool {
+		return info.ln == l
+	})
+	s.generateAltSvcHeader()
+}
+
+func (s *Server) NewRawServerConn(conn *quic.Conn) (*RawServerConn, error) {
+	hconn, _, _, err := s.newRawServerConn(conn)
+	if err != nil {
+		return nil, err
+		}
+	return hconn, nil
+	}
+
+func (s *Server) newRawServerConn(conn *quic.Conn) (*RawServerConn, *quic.SendStream, qlogwriter.Recorder, error) {
+	var qlogger qlogwriter.Recorder
+	if qlogTrace := conn.QlogTrace(); qlogTrace != nil && qlogTrace.SupportsSchemas(qlog.EventSchema) {
+		qlogger = qlogTrace.AddProducer()
+	}
+	connCtx := conn.Context()
+	connCtx = context.WithValue(connCtx, ServerContextKey, s)
+	connCtx = context.WithValue(connCtx, http.LocalAddrContextKey, conn.LocalAddr())
+	connCtx = context.WithValue(connCtx, RemoteAddrContextKey, conn.RemoteAddr())
+	if s.ConnContext != nil {
+		connCtx = s.ConnContext(connCtx, conn)
+		if connCtx == nil {
+			panic("http3: ConnContext returned nil")
+		}
+	}
+	hconn := newRawServerConn(
+		conn,
+		s.EnableDatagrams,
+		s.IdleTimeout,
+		qlogger,
+		s.Logger,
+		connCtx,
+		s.Handler,
+		s.maxHeaderBytes(),
+	)
+
+	// open the control stream and send a SETTINGS frame, it's also used to send a GOAWAY frame later
+	// when the server is gracefully closed
+	ctrlStr, err := hconn.openControlStream(&settingsFrame{
+		MaxFieldSectionSize: int64(s.maxHeaderBytes()),
+		Datagram:            s.EnableDatagrams,
+		ExtendedConnect:     true,
+		Other:               s.AdditionalSettings,
+	})
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("opening the control stream failed: %w", err)
+	}
+	return hconn, ctrlStr, qlogger, nil
+}
+
+// handleConn handles the HTTP/3 exchange on a QUIC connection.
+// It blocks until all HTTP handlers for all streams have returned.
+func (s *Server) handleConn(conn *quic.Conn) error {
+	hconn, ctrlStr, qlogger, err := s.newRawServerConn(conn)
+	if err != nil {
+		return err
+	}
+
+	var wg sync.WaitGroup
+	wg.Go(func() {
+		for {
+			str, err := conn.AcceptUniStream(context.Background())
+			if err != nil {
+				return
+			}
+			go hconn.HandleUnidirectionalStream(str)
+		}
+	})
+
+	var nextStreamID quic.StreamID
+	var handleErr error
+	var inGracefulShutdown bool
+	// Process all requests immediately.
+	// It's the client's responsibility to decide which requests are eligible for 0-RTT.
+	ctx := s.graceCtx
+	for {
+		// The context used here is:
+		// * before graceful shutdown: s.graceCtx
+		// * after graceful shutdown: s.closeCtx
+		// This allows us to keep accepting (and resetting) streams after graceful shutdown has started.
+		str, err := conn.AcceptStream(ctx)
+		if err != nil {
+			// the underlying connection was closed (by either side)
+			if conn.Context().Err() != nil {
+				var appErr *quic.ApplicationError
+				if !errors.As(err, &appErr) || appErr.ErrorCode != quic.ApplicationErrorCode(ErrCodeNoError) {
+					handleErr = fmt.Errorf("accepting stream failed: %w", err)
+				}
+				break
+			}
+			// server (not gracefully) closed, close the connection immediately
+			if s.closeCtx.Err() != nil {
+				hconn.CloseWithError(quic.ApplicationErrorCode(ErrCodeNoError), "")
+				handleErr = http.ErrServerClosed
+				break
+			}
+			inGracefulShutdown = s.graceCtx.Err() != nil
+			if !inGracefulShutdown {
+				var appErr *quic.ApplicationError
+				if !errors.As(err, &appErr) || appErr.ErrorCode != quic.ApplicationErrorCode(ErrCodeNoError) {
+					handleErr = fmt.Errorf("accepting stream failed: %w", err)
+				}
+				break
+			}
+
+			// gracefully closed, send GOAWAY frame and wait for requests to complete or grace period to end
+			// new requests will be rejected and shouldn't be sent
+			if qlogger != nil {
+				qlogger.RecordEvent(qlog.FrameCreated{
+					StreamID: ctrlStr.StreamID(),
+					Frame:    qlog.Frame{Frame: qlog.GoAwayFrame{StreamID: nextStreamID}},
+				})
+			}
+			// Send the GOAWAY frame in a separate Goroutine.
+			// Sending might block if the peer didn't grant enough flow control credit.
+			// Write is guaranteed to return once the connection is closed.
+			wg.Go(func() {
+				_, _ = ctrlStr.Write((&goAwayFrame{StreamID: nextStreamID}).Append(nil))
+			})
+			ctx = s.closeCtx
+			continue
+		}
+		if inGracefulShutdown {
+			str.CancelRead(quic.StreamErrorCode(ErrCodeRequestRejected))
+			str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestRejected))
+			continue
+		}
+
+		nextStreamID = str.StreamID() + 4
+		wg.Go(func() {
+			// HandleRequestStream will return once the request has been handled,
+			// or the underlying connection is closed.
+			hconn.HandleRequestStream(str)
+		})
+	}
+	wg.Wait()
+	return handleErr
+}
+
+func (s *Server) maxHeaderBytes() int {
+	if s.MaxHeaderBytes <= 0 {
+		return http.DefaultMaxHeaderBytes
+	}
+	return s.MaxHeaderBytes
+}
+
+// Close the server immediately, aborting requests and sending CONNECTION_CLOSE frames to connected clients.
+// Close in combination with ListenAndServe() (instead of Serve()) may race if it is called before a UDP socket is established.
+// It is the caller's responsibility to close any connection passed to ServeQUICConn.
+func (s *Server) Close() error {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	s.closed = true
+	// server is never used
+	if s.closeCtx == nil {
+		return nil
+	}
+	s.closeCancel()
+
+	var err error
+	for _, l := range s.listeners {
+		if l.createdLocally {
+			if cerr := (*l.ln).Close(); cerr != nil && err == nil {
+				err = cerr
+			}
+		}
+	}
+	if s.connCount.Load() == 0 {
+		return err
+	}
+	// wait for all connections to be closed
+	<-s.connHandlingDone
+	return err
+}
+
+// Shutdown gracefully shuts down the server without interrupting any active connections.
+// The server sends a GOAWAY frame first, then or for all running requests to complete.
+// Shutdown in combination with ListenAndServe may race if it is called before a UDP socket is established.
+// It is recommended to use Serve instead.
+func (s *Server) Shutdown(ctx context.Context) error {
+	s.mutex.Lock()
+	s.closed = true
+	// server was never used
+	if s.closeCtx == nil {
+		s.mutex.Unlock()
+		return nil
+	}
+	s.graceCancel()
+
+	// close all listeners
+	var closeErrs []error
+	for _, l := range s.listeners {
+		if l.createdLocally {
+			if err := (*l.ln).Close(); err != nil {
+				closeErrs = append(closeErrs, err)
+			}
+		}
+	}
+	s.mutex.Unlock()
+	if len(closeErrs) > 0 {
+		return errors.Join(closeErrs...)
+	}
+
+	if s.connCount.Load() == 0 {
+		return s.Close()
+	}
+	select {
+	case <-s.connHandlingDone: // all connections were closed
+		// When receiving a GOAWAY frame, HTTP/3 clients are expected to close the connection
+		// once all requests were successfully handled...
+		return s.Close()
+	case <-ctx.Done():
+		// ... however, clients handling long-lived requests (and misbehaving clients),
+		// might not do so before the context is cancelled.
+		// In this case, we close the server, which closes all existing connections
+		// (expect those passed to ServeQUICConn).
+		_ = s.Close()
+		return ctx.Err()
+	}
+}
+
+// ErrNoAltSvcPort is the error returned by SetQUICHeaders when no port was found
+// for Alt-Svc to announce. This can happen if listening on a PacketConn without a port
+// (UNIX socket, for example) and no port is specified in Server.Port or Server.Addr.
+var ErrNoAltSvcPort = errors.New("no port can be announced, specify it explicitly using Server.Port or Server.Addr")
+
+// SetQUICHeaders can be used to set the proper headers that announce that this server supports HTTP/3.
+// The values set by default advertise all the ports the server is listening on, but can be
+// changed to a specific port by setting Server.Port before launching the server.
+// If no listener's Addr().String() returns an address with a valid port, Server.Addr will be used
+// to extract the port, if specified.
+// For example, a server launched using ListenAndServe on an address with port 443 would set:
+//
+//	Alt-Svc: h3=":443"; ma=2592000
+func (s *Server) SetQUICHeaders(hdr http.Header) error {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+
+	if s.altSvcHeader == "" {
+		return ErrNoAltSvcPort
+	}
+	// use the map directly to avoid constant canonicalization since the key is already canonicalized
+	hdr["Alt-Svc"] = append(hdr["Alt-Svc"], s.altSvcHeader)
+	return nil
+}
+
+// ListenAndServeQUIC listens on the UDP network address addr and calls the
+// handler for HTTP/3 requests on incoming connections. http.DefaultServeMux is
+// used when handler is nil.
+func ListenAndServeQUIC(addr, certFile, keyFile string, handler http.Handler) error {
+	server := &Server{
+		Addr:    addr,
+		Handler: handler,
+	}
+	return server.ListenAndServeTLS(certFile, keyFile)
+}
+
+// ListenAndServeTLS listens on the given network address for both TLS/TCP and QUIC
+// connections in parallel. It returns if one of the two returns an error.
+// http.DefaultServeMux is used when handler is nil.
+// The correct Alt-Svc headers for QUIC are set.
+func ListenAndServeTLS(addr, certFile, keyFile string, handler http.Handler) error {
+	// Load certs
+	var err error
+	certs := make([]tls.Certificate, 1)
+	certs[0], err = tls.LoadX509KeyPair(certFile, keyFile)
+	if err != nil {
+		return err
+	}
+	// We currently only use the cert-related stuff from tls.Config,
+	// so we don't need to make a full copy.
+	config := &tls.Config{
+		Certificates: certs,
+	}
+
+	if addr == "" {
+		addr = ":https"
+	}
+
+	// Open the listeners
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return err
+	}
+	udpConn, err := net.ListenUDP("udp", udpAddr)
+	if err != nil {
+		return err
+	}
+	defer udpConn.Close()
+
+	if handler == nil {
+		handler = http.DefaultServeMux
+	}
+	// Start the servers
+	quicServer := &Server{
+		TLSConfig: config,
+		Handler:   handler,
+	}
+
+	hErr := make(chan error, 1)
+	qErr := make(chan error, 1)
+	go func() {
+		hErr <- http.ListenAndServeTLS(addr, certFile, keyFile, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			quicServer.SetQUICHeaders(w.Header())
+			handler.ServeHTTP(w, r)
+		}))
+	}()
+	go func() {
+		qErr <- quicServer.Serve(udpConn)
+	}()
+
+	select {
+	case err := <-hErr:
+		quicServer.Close()
+		return err
+	case err := <-qErr:
+		// Cannot close the HTTP server or wait for requests to complete properly :/
+		return err
+	}
+}
diff --git a/backend/vendor/github.com/enetx/http3/server_conn.go b/backend/vendor/github.com/enetx/http3/server_conn.go
new file mode 100644
index 00000000..29529187
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/server_conn.go
@@ -0,0 +1,261 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"io"
+	"log/slog"
+	"github.com/enetx/http"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/quic-go/qpack"
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// RawServerConn is an HTTP/3 server connection.
+// It can be used for advanced use cases where the application wants to manage the QUIC connection lifecycle.
+type RawServerConn struct {
+	rawConn rawConn
+
+	idleTimeout time.Duration
+	idleTimer   *time.Timer
+
+	serverContext  context.Context
+	requestHandler http.Handler
+	maxHeaderBytes int
+
+	decoder *qpack.Decoder
+
+	qlogger qlogwriter.Recorder
+	logger  *slog.Logger
+}
+
+func newRawServerConn(
+	conn *quic.Conn,
+	enableDatagrams bool,
+	idleTimeout time.Duration,
+	qlogger qlogwriter.Recorder,
+	logger *slog.Logger,
+	serverContext context.Context,
+	requestHandler http.Handler,
+	maxHeaderBytes int,
+) *RawServerConn {
+	c := &RawServerConn{
+		idleTimeout:    idleTimeout,
+		serverContext:  serverContext,
+		requestHandler: requestHandler,
+		maxHeaderBytes: maxHeaderBytes,
+		decoder:        qpack.NewDecoder(),
+		qlogger:        qlogger,
+		logger:         logger,
+	}
+	c.rawConn = *newRawConn(conn, enableDatagrams, c.onStreamsEmpty, nil, qlogger, logger)
+	if idleTimeout > 0 {
+		c.idleTimer = time.AfterFunc(idleTimeout, c.onIdleTimer)
+	}
+	return c
+}
+
+func (c *RawServerConn) onStreamsEmpty() {
+	if c.idleTimeout > 0 {
+		c.idleTimer.Reset(c.idleTimeout)
+	}
+}
+
+func (c *RawServerConn) onIdleTimer() {
+	c.CloseWithError(quic.ApplicationErrorCode(ErrCodeNoError), "idle timeout")
+}
+
+// CloseWithError closes the connection with the given error code and message.
+func (c *RawServerConn) CloseWithError(code quic.ApplicationErrorCode, msg string) error {
+	if c.idleTimer != nil {
+		c.idleTimer.Stop()
+	}
+	return c.rawConn.CloseWithError(code, msg)
+}
+
+// HandleRequestStream handles an HTTP/3 request on a bidirectional request stream.
+// The stream can either be obtained by calling AcceptStream on the underlying QUIC connection,
+// or (internally) by using the server's stream accept loop.
+func (c *RawServerConn) HandleRequestStream(str *quic.Stream) {
+	hstr := c.rawConn.TrackStream(str)
+	c.handleRequestStream(hstr)
+}
+
+func (c *RawServerConn) requestMaxHeaderBytes() int {
+	if c.maxHeaderBytes <= 0 {
+		return http.DefaultMaxHeaderBytes
+	}
+	return c.maxHeaderBytes
+}
+
+func (c *RawServerConn) openControlStream(settings *settingsFrame) (*quic.SendStream, error) {
+	return c.rawConn.openControlStream(settings)
+}
+
+func (c *RawServerConn) handleRequestStream(str *stateTrackingStream) {
+	if c.idleTimeout > 0 {
+		// This only applies if the stream is the first active stream,
+		// but it's ok to stop a stopped timer.
+		c.idleTimer.Stop()
+	}
+
+	conn := &c.rawConn
+	qlogger := c.qlogger
+	decoder := c.decoder
+	connCtx := c.serverContext
+	maxHeaderBytes := c.requestMaxHeaderBytes()
+
+	fp := &frameParser{closeConn: conn.CloseWithError, r: str, streamID: str.StreamID()}
+	frame, err := fp.ParseNext(qlogger)
+	if err != nil {
+		str.CancelRead(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		return
+	}
+	hf, ok := frame.(*headersFrame)
+	if !ok {
+		conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameUnexpected), "expected first frame to be a HEADERS frame")
+		return
+	}
+	if hf.Length > uint64(maxHeaderBytes) {
+		maybeQlogInvalidHeadersFrame(qlogger, str.StreamID(), hf.Length)
+		// stop the client from sending more data
+		str.CancelRead(quic.StreamErrorCode(ErrCodeExcessiveLoad))
+		// send a 431 Response (Request Header Fields Too Large)
+		c.rejectWithHeaderFieldsTooLarge(str)
+		return
+	}
+	headerBlock := make([]byte, hf.Length)
+	if _, err := io.ReadFull(str, headerBlock); err != nil {
+		maybeQlogInvalidHeadersFrame(qlogger, str.StreamID(), hf.Length)
+		str.CancelRead(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		return
+	}
+	decodeFn := decoder.Decode(headerBlock)
+	var hfs []qpack.HeaderField
+	if qlogger != nil {
+		hfs = make([]qpack.HeaderField, 0, 16)
+	}
+	req, err := requestFromHeaders(decodeFn, maxHeaderBytes, &hfs)
+	if qlogger != nil {
+		qlogParsedHeadersFrame(qlogger, str.StreamID(), hf, hfs)
+	}
+	if err != nil {
+		if errors.Is(err, errHeaderTooLarge) {
+			// stop the client from sending more data
+			str.CancelRead(quic.StreamErrorCode(ErrCodeExcessiveLoad))
+			// send a 431 Response (Request Header Fields Too Large)
+			c.rejectWithHeaderFieldsTooLarge(str)
+			return
+		}
+
+		errCode := ErrCodeMessageError
+		var qpackErr *qpackError
+		if errors.As(err, &qpackErr) {
+			errCode = ErrCodeQPACKDecompressionFailed
+		}
+		str.CancelRead(quic.StreamErrorCode(errCode))
+		str.CancelWrite(quic.StreamErrorCode(errCode))
+		return
+	}
+
+	connState := conn.ConnectionState().TLS
+	req.TLS = &connState
+	req.RemoteAddr = conn.RemoteAddr().String()
+
+	// Check that the client doesn't send more data in DATA frames than indicated by the Content-Length header (if set).
+	// See section 4.1.2 of RFC 9114.
+	contentLength := int64(-1)
+	if _, ok := req.Header["Content-Length"]; ok && req.ContentLength >= 0 {
+		contentLength = req.ContentLength
+	}
+	hstr := newStream(str, conn, nil, func(r io.Reader, hf *headersFrame) error {
+		trailers, err := decodeTrailers(r, hf, maxHeaderBytes, decoder, qlogger, str.StreamID())
+		if err != nil {
+			return err
+		}
+		req.Trailer = trailers
+		return nil
+	}, qlogger)
+	body := newRequestBody(hstr, contentLength, connCtx, conn.ReceivedSettings(), conn.Settings)
+	req.Body = body
+
+	if c.logger != nil {
+		c.logger.Debug("handling request", "method", req.Method, "host", req.Host, "uri", req.RequestURI)
+	}
+
+	ctx, cancel := context.WithCancel(connCtx)
+	req = req.WithContext(ctx)
+	context.AfterFunc(str.Context(), cancel)
+
+	r := newResponseWriter(hstr, conn, req.Method == http.MethodHead, c.logger)
+	handler := c.requestHandler
+	if handler == nil {
+		handler = http.DefaultServeMux
+	}
+
+	// It's the client's responsibility to decide which requests are eligible for 0-RTT.
+	var panicked bool
+	func() {
+		defer func() {
+			if p := recover(); p != nil {
+				panicked = true
+				if p == http.ErrAbortHandler {
+					return
+				}
+				// Copied from net/http/server.go
+				const size = 64 << 10
+				buf := make([]byte, size)
+				buf = buf[:runtime.Stack(buf, false)]
+				logger := c.logger
+				if logger == nil {
+					logger = slog.Default()
+				}
+				logger.Error("http3: panic serving", "arg", p, "trace", string(buf))
+			}
+		}()
+		handler.ServeHTTP(r, req)
+	}()
+
+	if r.wasStreamHijacked() {
+		return
+	}
+
+	// abort the stream when there is a panic
+	if panicked {
+		str.CancelRead(quic.StreamErrorCode(ErrCodeInternalError))
+		str.CancelWrite(quic.StreamErrorCode(ErrCodeInternalError))
+		return
+	}
+
+	// response not written to the client yet, set Content-Length
+	if !r.headerWritten {
+		if _, haveCL := r.header["Content-Length"]; !haveCL {
+			r.header.Set("Content-Length", strconv.FormatInt(r.numWritten, 10))
+		}
+	}
+	r.Flush()
+	r.flushTrailers()
+
+	// If the EOF was read by the handler, CancelRead() is a no-op.
+	str.CancelRead(quic.StreamErrorCode(ErrCodeNoError))
+	str.Close()
+}
+
+func (c *RawServerConn) rejectWithHeaderFieldsTooLarge(str *stateTrackingStream) {
+	hstr := newStream(str, &c.rawConn, nil, nil, c.qlogger)
+	defer hstr.Close()
+	r := newResponseWriter(hstr, &c.rawConn, false, c.logger)
+	r.WriteHeader(http.StatusRequestHeaderFieldsTooLarge)
+	r.Flush()
+}
+
+// HandleUnidirectionalStream handles an incoming unidirectional stream.
+func (c *RawServerConn) HandleUnidirectionalStream(str *quic.ReceiveStream) {
+	c.rawConn.handleUnidirectionalStream(str, true)
+}
diff --git a/backend/vendor/github.com/enetx/http3/state_tracking_stream.go b/backend/vendor/github.com/enetx/http3/state_tracking_stream.go
new file mode 100644
index 00000000..6c7fa52d
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/state_tracking_stream.go
@@ -0,0 +1,173 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+
+	"github.com/quic-go/quic-go"
+)
+
+const streamDatagramQueueLen = 32
+
+// stateTrackingStream is an implementation of quic.Stream that delegates
+// to an underlying stream
+// it takes care of proxying send and receive errors onto an implementation of
+// the errorSetter interface (intended to be occupied by a datagrammer)
+// it is also responsible for clearing the stream based on its ID from its
+// parent connection, this is done through the streamClearer interface when
+// both the send and receive sides are closed
+type stateTrackingStream struct {
+	*quic.Stream
+
+	sendDatagram func([]byte) error
+	hasData      chan struct{}
+	queue        [][]byte // TODO: use a ring buffer
+
+	mx      sync.Mutex
+	sendErr error
+	recvErr error
+
+	clearer streamClearer
+}
+
+var _ datagramStream = &stateTrackingStream{}
+
+type streamClearer interface {
+	clearStream(quic.StreamID)
+}
+
+func newStateTrackingStream(s *quic.Stream, clearer streamClearer, sendDatagram func([]byte) error) *stateTrackingStream {
+	t := &stateTrackingStream{
+		Stream:       s,
+		clearer:      clearer,
+		sendDatagram: sendDatagram,
+		hasData:      make(chan struct{}, 1),
+	}
+
+	context.AfterFunc(s.Context(), func() {
+		t.closeSend(context.Cause(s.Context()))
+	})
+
+	return t
+}
+
+func (s *stateTrackingStream) closeSend(e error) {
+	s.mx.Lock()
+	defer s.mx.Unlock()
+
+	// clear the stream the first time both the send
+	// and receive are finished
+	if s.sendErr == nil {
+		if s.recvErr != nil {
+			s.clearer.clearStream(s.StreamID())
+		}
+		s.sendErr = e
+	}
+}
+
+func (s *stateTrackingStream) closeReceive(e error) {
+	s.mx.Lock()
+	defer s.mx.Unlock()
+
+	// clear the stream the first time both the send
+	// and receive are finished
+	if s.recvErr == nil {
+		if s.sendErr != nil {
+			s.clearer.clearStream(s.StreamID())
+		}
+		s.recvErr = e
+		s.signalHasDatagram()
+	}
+}
+
+func (s *stateTrackingStream) Close() error {
+	s.closeSend(errors.New("write on closed stream"))
+	return s.Stream.Close()
+}
+
+func (s *stateTrackingStream) CancelWrite(e quic.StreamErrorCode) {
+	s.closeSend(&quic.StreamError{StreamID: s.StreamID(), ErrorCode: e})
+	s.Stream.CancelWrite(e)
+}
+
+func (s *stateTrackingStream) Write(b []byte) (int, error) {
+	n, err := s.Stream.Write(b)
+	if err != nil && !errors.Is(err, os.ErrDeadlineExceeded) {
+		s.closeSend(err)
+	}
+	return n, err
+}
+
+func (s *stateTrackingStream) CancelRead(e quic.StreamErrorCode) {
+	s.closeReceive(&quic.StreamError{StreamID: s.StreamID(), ErrorCode: e})
+	s.Stream.CancelRead(e)
+}
+
+func (s *stateTrackingStream) Read(b []byte) (int, error) {
+	n, err := s.Stream.Read(b)
+	if err != nil && !errors.Is(err, os.ErrDeadlineExceeded) {
+		s.closeReceive(err)
+	}
+	return n, err
+}
+
+func (s *stateTrackingStream) SendDatagram(b []byte) error {
+	s.mx.Lock()
+	sendErr := s.sendErr
+	s.mx.Unlock()
+	if sendErr != nil {
+		return sendErr
+	}
+
+	return s.sendDatagram(b)
+}
+
+func (s *stateTrackingStream) signalHasDatagram() {
+	select {
+	case s.hasData <- struct{}{}:
+	default:
+	}
+}
+
+func (s *stateTrackingStream) enqueueDatagram(data []byte) {
+	s.mx.Lock()
+	defer s.mx.Unlock()
+
+	if s.recvErr != nil {
+		return
+	}
+	if len(s.queue) >= streamDatagramQueueLen {
+		return
+	}
+	s.queue = append(s.queue, data)
+	s.signalHasDatagram()
+}
+
+func (s *stateTrackingStream) ReceiveDatagram(ctx context.Context) ([]byte, error) {
+start:
+	s.mx.Lock()
+	if len(s.queue) > 0 {
+		data := s.queue[0]
+		s.queue = s.queue[1:]
+		s.mx.Unlock()
+		return data, nil
+	}
+	if receiveErr := s.recvErr; receiveErr != nil {
+		s.mx.Unlock()
+		return nil, receiveErr
+	}
+	s.mx.Unlock()
+
+	select {
+	case <-ctx.Done():
+		return nil, context.Cause(ctx)
+	case <-s.hasData:
+	}
+	goto start
+}
+
+func (s *stateTrackingStream) QUICStream() *quic.Stream {
+	return s.Stream
+}
diff --git a/backend/vendor/github.com/enetx/http3/stream.go b/backend/vendor/github.com/enetx/http3/stream.go
new file mode 100644
index 00000000..0fc03be9
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/stream.go
@@ -0,0 +1,406 @@
+package http3
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"github.com/enetx/http"
+	"github.com/enetx/http/httptrace"
+	"time"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/http3/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+
+	"github.com/quic-go/qpack"
+)
+
+type datagramStream interface {
+	io.ReadWriteCloser
+	CancelRead(quic.StreamErrorCode)
+	CancelWrite(quic.StreamErrorCode)
+	StreamID() quic.StreamID
+	Context() context.Context
+	SetDeadline(time.Time) error
+	SetReadDeadline(time.Time) error
+	SetWriteDeadline(time.Time) error
+	SendDatagram(b []byte) error
+	ReceiveDatagram(ctx context.Context) ([]byte, error)
+
+	QUICStream() *quic.Stream
+}
+
+// A Stream is an HTTP/3 stream.
+//
+// When writing to and reading from the stream, data is framed in HTTP/3 DATA frames.
+type Stream struct {
+	datagramStream
+	conn        *rawConn
+	frameParser *frameParser
+
+	buf []byte // used as a temporary buffer when writing the HTTP/3 frame headers
+
+	bytesRemainingInFrame uint64
+
+	qlogger qlogwriter.Recorder
+
+	parseTrailer  func(io.Reader, *headersFrame) error
+	parsedTrailer bool
+}
+
+func newStream(
+	str datagramStream,
+	conn *rawConn,
+	trace *httptrace.ClientTrace,
+	parseTrailer func(io.Reader, *headersFrame) error,
+	qlogger qlogwriter.Recorder,
+) *Stream {
+	return &Stream{
+		datagramStream: str,
+		conn:           conn,
+		buf:            make([]byte, 16),
+		qlogger:        qlogger,
+		parseTrailer:   parseTrailer,
+		frameParser: &frameParser{
+			r:         &tracingReader{Reader: str, trace: trace},
+			streamID:  str.StreamID(),
+			closeConn: conn.CloseWithError,
+		},
+	}
+}
+
+func (s *Stream) Read(b []byte) (int, error) {
+	if s.bytesRemainingInFrame == 0 {
+	parseLoop:
+		for {
+			frame, err := s.frameParser.ParseNext(s.qlogger)
+			if err != nil {
+				return 0, err
+			}
+			switch f := frame.(type) {
+			case *dataFrame:
+				if s.parsedTrailer {
+					return 0, errors.New("DATA frame received after trailers")
+				}
+				s.bytesRemainingInFrame = f.Length
+				break parseLoop
+			case *headersFrame:
+				if s.parsedTrailer {
+					maybeQlogInvalidHeadersFrame(s.qlogger, s.StreamID(), f.Length)
+					return 0, errors.New("additional HEADERS frame received after trailers")
+				}
+				s.parsedTrailer = true
+				return 0, s.parseTrailer(s.datagramStream, f)
+			default:
+				s.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameUnexpected), "")
+				// parseNextFrame skips over unknown frame types
+				// Therefore, this condition is only entered when we parsed another known frame type.
+				return 0, fmt.Errorf("peer sent an unexpected frame: %T", f)
+			}
+		}
+	}
+
+	var n int
+	var err error
+	if s.bytesRemainingInFrame < uint64(len(b)) {
+		n, err = s.datagramStream.Read(b[:s.bytesRemainingInFrame])
+	} else {
+		n, err = s.datagramStream.Read(b)
+	}
+	s.bytesRemainingInFrame -= uint64(n)
+	return n, err
+}
+
+func (s *Stream) hasMoreData() bool {
+	return s.bytesRemainingInFrame > 0
+}
+
+func (s *Stream) Write(b []byte) (int, error) {
+	s.buf = s.buf[:0]
+	s.buf = (&dataFrame{Length: uint64(len(b))}).Append(s.buf)
+	if s.qlogger != nil {
+		s.qlogger.RecordEvent(qlog.FrameCreated{
+			StreamID: s.StreamID(),
+			Raw: qlog.RawInfo{
+				Length:        len(s.buf) + len(b),
+				PayloadLength: len(b),
+			},
+			Frame: qlog.Frame{Frame: qlog.DataFrame{}},
+		})
+	}
+	if _, err := s.datagramStream.Write(s.buf); err != nil {
+		return 0, err
+	}
+	return s.datagramStream.Write(b)
+}
+
+func (s *Stream) writeUnframed(b []byte) (int, error) {
+	return s.datagramStream.Write(b)
+}
+
+func (s *Stream) StreamID() quic.StreamID {
+	return s.datagramStream.StreamID()
+}
+
+func (s *Stream) SendDatagram(b []byte) error {
+	// TODO: reject if datagrams are not negotiated (yet)
+	return s.datagramStream.SendDatagram(b)
+}
+
+func (s *Stream) ReceiveDatagram(ctx context.Context) ([]byte, error) {
+	// TODO: reject if datagrams are not negotiated (yet)
+	return s.datagramStream.ReceiveDatagram(ctx)
+}
+
+// A RequestStream is a low-level abstraction representing an HTTP/3 request stream.
+// It decouples sending of the HTTP request from reading the HTTP response, allowing
+// the application to optimistically use the stream (and, for example, send datagrams)
+// before receiving the response.
+//
+// This is only needed for advanced use case, e.g. WebTransport and the various
+// MASQUE proxying protocols.
+type RequestStream struct {
+	str *Stream
+
+	responseBody io.ReadCloser // set by ReadResponse
+
+	decoder            *qpack.Decoder
+	requestWriter      *requestWriter
+	maxHeaderBytes     int
+	reqDone            chan<- struct{}
+	disableCompression bool
+	response           *http.Response
+
+	sentRequest   bool
+	requestedGzip bool
+	isConnect     bool
+}
+
+func newRequestStream(
+	str *Stream,
+	requestWriter *requestWriter,
+	reqDone chan<- struct{},
+	decoder *qpack.Decoder,
+	disableCompression bool,
+	maxHeaderBytes int,
+	rsp *http.Response,
+) *RequestStream {
+	return &RequestStream{
+		str:                str,
+		requestWriter:      requestWriter,
+		reqDone:            reqDone,
+		decoder:            decoder,
+		disableCompression: disableCompression,
+		maxHeaderBytes:     maxHeaderBytes,
+		response:           rsp,
+	}
+}
+
+// Read reads data from the underlying stream.
+//
+// It can only be used after the request has been sent (using SendRequestHeader)
+// and the response has been consumed (using ReadResponse).
+func (s *RequestStream) Read(b []byte) (int, error) {
+	if s.responseBody == nil {
+		return 0, errors.New("http3: invalid use of RequestStream.Read before ReadResponse")
+	}
+	return s.responseBody.Read(b)
+}
+
+// StreamID returns the QUIC stream ID of the underlying QUIC stream.
+func (s *RequestStream) StreamID() quic.StreamID {
+	return s.str.StreamID()
+}
+
+// Write writes data to the stream.
+//
+// It can only be used after the request has been sent (using SendRequestHeader).
+func (s *RequestStream) Write(b []byte) (int, error) {
+	if !s.sentRequest {
+		return 0, errors.New("http3: invalid use of RequestStream.Write before SendRequestHeader")
+	}
+	return s.str.Write(b)
+}
+
+// Close closes the send-direction of the stream.
+// It does not close the receive-direction of the stream.
+func (s *RequestStream) Close() error {
+	return s.str.Close()
+}
+
+// CancelRead aborts receiving on this stream.
+// See [quic.Stream.CancelRead] for more details.
+func (s *RequestStream) CancelRead(errorCode quic.StreamErrorCode) {
+	s.str.CancelRead(errorCode)
+}
+
+// CancelWrite aborts sending on this stream.
+// See [quic.Stream.CancelWrite] for more details.
+func (s *RequestStream) CancelWrite(errorCode quic.StreamErrorCode) {
+	s.str.CancelWrite(errorCode)
+}
+
+// Context returns a context derived from the underlying QUIC stream's context.
+// See [quic.Stream.Context] for more details.
+func (s *RequestStream) Context() context.Context {
+	return s.str.Context()
+}
+
+// SetReadDeadline sets the deadline for Read calls.
+func (s *RequestStream) SetReadDeadline(t time.Time) error {
+	return s.str.SetReadDeadline(t)
+}
+
+// SetWriteDeadline sets the deadline for Write calls.
+func (s *RequestStream) SetWriteDeadline(t time.Time) error {
+	return s.str.SetWriteDeadline(t)
+}
+
+// SetDeadline sets the read and write deadlines associated with the stream.
+// It is equivalent to calling both SetReadDeadline and SetWriteDeadline.
+func (s *RequestStream) SetDeadline(t time.Time) error {
+	return s.str.SetDeadline(t)
+}
+
+// SendDatagrams send a new HTTP Datagram (RFC 9297).
+//
+// It is only possible to send datagrams if the server enabled support for this extension.
+// It is recommended (though not required) to send the request before calling this method,
+// as the server might drop datagrams which it can't associate with an existing request.
+func (s *RequestStream) SendDatagram(b []byte) error {
+	return s.str.SendDatagram(b)
+}
+
+// ReceiveDatagram receives HTTP Datagrams (RFC 9297).
+//
+// It is only possible if support for HTTP Datagrams was enabled, using the EnableDatagram
+// option on the [Transport].
+func (s *RequestStream) ReceiveDatagram(ctx context.Context) ([]byte, error) {
+	return s.str.ReceiveDatagram(ctx)
+}
+
+// SendRequestHeader sends the HTTP request.
+//
+// It can only used for requests that don't have a request body.
+// It is invalid to call it more than once.
+// It is invalid to call it after Write has been called.
+func (s *RequestStream) SendRequestHeader(req *http.Request) error {
+	if req.Body != nil && req.Body != http.NoBody {
+		return errors.New("http3: invalid use of RequestStream.SendRequestHeader with a request that has a request body")
+	}
+	return s.sendRequestHeader(req)
+}
+
+func (s *RequestStream) sendRequestHeader(req *http.Request) error {
+	if s.sentRequest {
+		return errors.New("http3: invalid duplicate use of RequestStream.SendRequestHeader")
+	}
+	if !s.disableCompression && req.Method != http.MethodHead &&
+		req.Header.Get("Accept-Encoding") == "" && req.Header.Get("Range") == "" {
+		s.requestedGzip = true
+	}
+	s.isConnect = req.Method == http.MethodConnect
+	s.sentRequest = true
+	return s.requestWriter.WriteRequestHeader(s.str.datagramStream, req, s.requestedGzip, s.str.StreamID(), s.str.qlogger)
+}
+
+// sendRequestTrailer sends request trailers to the stream.
+// It should be called after the request body has been fully written.
+func (s *RequestStream) sendRequestTrailer(req *http.Request) error {
+	return s.requestWriter.WriteRequestTrailer(s.str.datagramStream, req, s.str.StreamID(), s.str.qlogger)
+}
+
+// ReadResponse reads the HTTP response from the stream.
+//
+// It must be called after sending the request (using SendRequestHeader).
+// It is invalid to call it more than once.
+// It doesn't set Response.Request and Response.TLS.
+// It is invalid to call it after Read has been called.
+func (s *RequestStream) ReadResponse() (*http.Response, error) {
+	if !s.sentRequest {
+		return nil, errors.New("http3: invalid use of RequestStream.ReadResponse before SendRequestHeader")
+	}
+	frame, err := s.str.frameParser.ParseNext(s.str.qlogger)
+	if err != nil {
+		s.str.CancelRead(quic.StreamErrorCode(ErrCodeFrameError))
+		s.str.CancelWrite(quic.StreamErrorCode(ErrCodeFrameError))
+		return nil, fmt.Errorf("http3: parsing frame failed: %w", err)
+	}
+	hf, ok := frame.(*headersFrame)
+	if !ok {
+		s.str.conn.CloseWithError(quic.ApplicationErrorCode(ErrCodeFrameUnexpected), "expected first frame to be a HEADERS frame")
+		return nil, errors.New("http3: expected first frame to be a HEADERS frame")
+	}
+	if hf.Length > uint64(s.maxHeaderBytes) {
+		maybeQlogInvalidHeadersFrame(s.str.qlogger, s.str.StreamID(), hf.Length)
+		s.str.CancelRead(quic.StreamErrorCode(ErrCodeFrameError))
+		s.str.CancelWrite(quic.StreamErrorCode(ErrCodeFrameError))
+		return nil, fmt.Errorf("http3: HEADERS frame too large: %d bytes (max: %d)", hf.Length, s.maxHeaderBytes)
+	}
+	headerBlock := make([]byte, hf.Length)
+	if _, err := io.ReadFull(s.str.datagramStream, headerBlock); err != nil {
+		maybeQlogInvalidHeadersFrame(s.str.qlogger, s.str.StreamID(), hf.Length)
+		s.str.CancelRead(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		s.str.CancelWrite(quic.StreamErrorCode(ErrCodeRequestIncomplete))
+		return nil, fmt.Errorf("http3: failed to read response headers: %w", err)
+	}
+	decodeFn := s.decoder.Decode(headerBlock)
+	var hfs []qpack.HeaderField
+	if s.str.qlogger != nil {
+		hfs = make([]qpack.HeaderField, 0, 16)
+	}
+	res := s.response
+	err = updateResponseFromHeaders(res, decodeFn, s.maxHeaderBytes, &hfs)
+	if s.str.qlogger != nil {
+		qlogParsedHeadersFrame(s.str.qlogger, s.str.StreamID(), hf, hfs)
+	}
+	if err != nil {
+		errCode := ErrCodeMessageError
+		var qpackErr *qpackError
+		if errors.As(err, &qpackErr) {
+			errCode = ErrCodeQPACKDecompressionFailed
+		}
+		s.str.CancelRead(quic.StreamErrorCode(errCode))
+		s.str.CancelWrite(quic.StreamErrorCode(errCode))
+		return nil, fmt.Errorf("http3: invalid response: %w", err)
+	}
+
+	// Check that the server doesn't send more data in DATA frames than indicated by the Content-Length header (if set).
+	// See section 4.1.2 of RFC 9114.
+	respBody := newResponseBody(s.str, res.ContentLength, s.reqDone)
+
+	// Rules for when to set Content-Length are defined in https://tools.ietf.org/html/rfc7230#section-3.3.2.
+	isInformational := res.StatusCode >= 100 && res.StatusCode < 200
+	isNoContent := res.StatusCode == http.StatusNoContent
+	isSuccessfulConnect := s.isConnect && res.StatusCode >= 200 && res.StatusCode < 300
+	if (isInformational || isNoContent || isSuccessfulConnect) && res.ContentLength == -1 {
+		res.ContentLength = 0
+	}
+	if s.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" {
+		res.Header.Del("Content-Encoding")
+		res.Header.Del("Content-Length")
+		res.ContentLength = -1
+		s.responseBody = newGzipReader(respBody)
+		res.Uncompressed = true
+	} else {
+		s.responseBody = respBody
+	}
+	res.Body = s.responseBody
+	return res, nil
+}
+
+type tracingReader struct {
+	io.Reader
+	readFirst bool
+	trace     *httptrace.ClientTrace
+}
+
+func (r *tracingReader) Read(b []byte) (int, error) {
+	n, err := r.Reader.Read(b)
+	if n > 0 && !r.readFirst {
+		traceGotFirstResponseByte(r.trace)
+		r.readFirst = true
+	}
+	return n, err
+}
diff --git a/backend/vendor/github.com/enetx/http3/trace.go b/backend/vendor/github.com/enetx/http3/trace.go
new file mode 100644
index 00000000..bdabb846
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/trace.go
@@ -0,0 +1,105 @@
+package http3
+
+import (
+	"crypto/tls"
+	"net"
+	"github.com/enetx/http/httptrace"
+	"net/textproto"
+	"time"
+
+	"github.com/quic-go/quic-go"
+)
+
+func traceGetConn(trace *httptrace.ClientTrace, hostPort string) {
+	if trace != nil && trace.GetConn != nil {
+		trace.GetConn(hostPort)
+	}
+}
+
+// fakeConn is a wrapper for quic.EarlyConnection
+// because the quic connection does not implement net.Conn.
+type fakeConn struct {
+	conn *quic.Conn
+}
+
+func (c *fakeConn) Close() error                       { panic("connection operation prohibited") }
+func (c *fakeConn) Read(p []byte) (int, error)         { panic("connection operation prohibited") }
+func (c *fakeConn) Write(p []byte) (int, error)        { panic("connection operation prohibited") }
+func (c *fakeConn) SetDeadline(t time.Time) error      { panic("connection operation prohibited") }
+func (c *fakeConn) SetReadDeadline(t time.Time) error  { panic("connection operation prohibited") }
+func (c *fakeConn) SetWriteDeadline(t time.Time) error { panic("connection operation prohibited") }
+func (c *fakeConn) RemoteAddr() net.Addr               { return c.conn.RemoteAddr() }
+func (c *fakeConn) LocalAddr() net.Addr                { return c.conn.LocalAddr() }
+
+func traceGotConn(trace *httptrace.ClientTrace, conn *quic.Conn, reused bool) {
+	if trace != nil && trace.GotConn != nil {
+		trace.GotConn(httptrace.GotConnInfo{
+			Conn:   &fakeConn{conn: conn},
+			Reused: reused,
+		})
+	}
+}
+
+func traceGotFirstResponseByte(trace *httptrace.ClientTrace) {
+	if trace != nil && trace.GotFirstResponseByte != nil {
+		trace.GotFirstResponseByte()
+	}
+}
+
+func traceGot1xxResponse(trace *httptrace.ClientTrace, code int, header textproto.MIMEHeader) {
+	if trace != nil && trace.Got1xxResponse != nil {
+		trace.Got1xxResponse(code, header)
+	}
+}
+
+func traceGot100Continue(trace *httptrace.ClientTrace) {
+	if trace != nil && trace.Got100Continue != nil {
+		trace.Got100Continue()
+	}
+}
+
+func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool {
+	return trace != nil && trace.WroteHeaderField != nil
+}
+
+func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {
+	if trace != nil && trace.WroteHeaderField != nil {
+		trace.WroteHeaderField(k, []string{v})
+	}
+}
+
+func traceWroteHeaders(trace *httptrace.ClientTrace) {
+	if trace != nil && trace.WroteHeaders != nil {
+		trace.WroteHeaders()
+	}
+}
+
+func traceWroteRequest(trace *httptrace.ClientTrace, err error) {
+	if trace != nil && trace.WroteRequest != nil {
+		trace.WroteRequest(httptrace.WroteRequestInfo{Err: err})
+	}
+}
+
+func traceConnectStart(trace *httptrace.ClientTrace, network, addr string) {
+	if trace != nil && trace.ConnectStart != nil {
+		trace.ConnectStart(network, addr)
+	}
+}
+
+func traceConnectDone(trace *httptrace.ClientTrace, network, addr string, err error) {
+	if trace != nil && trace.ConnectDone != nil {
+		trace.ConnectDone(network, addr, err)
+	}
+}
+
+func traceTLSHandshakeStart(trace *httptrace.ClientTrace) {
+	if trace != nil && trace.TLSHandshakeStart != nil {
+		trace.TLSHandshakeStart()
+	}
+}
+
+func traceTLSHandshakeDone(trace *httptrace.ClientTrace, state tls.ConnectionState, err error) {
+	if trace != nil && trace.TLSHandshakeDone != nil {
+		trace.TLSHandshakeDone(state, err)
+	}
+}
diff --git a/backend/vendor/github.com/enetx/http3/transport.go b/backend/vendor/github.com/enetx/http3/transport.go
new file mode 100644
index 00000000..38ebcdd1
--- /dev/null
+++ b/backend/vendor/github.com/enetx/http3/transport.go
@@ -0,0 +1,545 @@
+package http3
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/url"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/enetx/g"
+	"github.com/enetx/http"
+	"github.com/enetx/http/httptrace"
+
+	"golang.org/x/net/http/httpguts"
+
+	"github.com/enetx/http3/httpcommon"
+	"github.com/quic-go/quic-go"
+)
+
+// Settings are HTTP/3 settings that apply to the underlying connection.
+type Settings struct {
+	// Support for HTTP/3 datagrams (RFC 9297)
+	EnableDatagrams bool
+	// Extended CONNECT, RFC 9220
+	EnableExtendedConnect bool
+	// Other settings, defined by the application
+	Other g.MapOrd[uint64, uint64]
+}
+
+// RoundTripOpt are options for the Transport.RoundTripOpt method.
+type RoundTripOpt struct {
+	// OnlyCachedConn controls whether the Transport may create a new QUIC connection.
+	// If set true and no cached connection is available, RoundTripOpt will return ErrNoCachedConn.
+	OnlyCachedConn bool
+}
+
+type clientConn interface {
+	OpenRequestStream(context.Context) (*RequestStream, error)
+	RoundTrip(*http.Request) (*http.Response, error)
+	handleUnidirectionalStream(*quic.ReceiveStream)
+}
+
+type roundTripperWithCount struct {
+	cancel     context.CancelFunc
+	dialing    chan struct{} // closed as soon as quic.Dial(Early) returned
+	dialErr    error
+	conn       *quic.Conn
+	clientConn clientConn
+
+	useCount atomic.Int64
+}
+
+func (r *roundTripperWithCount) Close() error {
+	r.cancel()
+	<-r.dialing
+	if r.conn != nil {
+		return r.conn.CloseWithError(0, "")
+	}
+	return nil
+}
+
+// Transport implements the http.RoundTripper interface
+type Transport struct {
+	// TLSClientConfig specifies the TLS configuration to use with
+	// tls.Client. If nil, the default configuration is used.
+	TLSClientConfig *tls.Config
+
+	// QUICConfig is the quic.Config used for dialing new connections.
+	// If nil, reasonable default values will be used.
+	QUICConfig *quic.Config
+
+	// Dial specifies an optional dial function for creating QUIC
+	// connections for requests.
+	// If Dial is nil, a UDPConn will be created at the first request
+	// and will be reused for subsequent connections to other servers.
+	Dial func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error)
+
+	// Enable support for HTTP/3 datagrams (RFC 9297).
+	// If a QUICConfig is set, datagram support also needs to be enabled on the QUIC layer by setting EnableDatagrams.
+	EnableDatagrams bool
+
+	// Additional HTTP/3 settings.
+	// It is invalid to specify any settings defined by RFC 9114 (HTTP/3) and RFC 9297 (HTTP Datagrams).
+	AdditionalSettings g.MapOrd[uint64, uint64]
+
+	// MaxResponseHeaderBytes specifies a limit on how many response bytes are
+	// allowed in the server's response header.
+	// Zero means to use a default limit.
+	MaxResponseHeaderBytes int
+
+	// DisableCompression, if true, prevents the Transport from requesting compression with an
+	// "Accept-Encoding: gzip" request header when the Request contains no existing Accept-Encoding value.
+	// If the Transport requests gzip on its own and gets a gzipped response, it's transparently
+	// decoded in the Response.Body.
+	// However, if the user explicitly requested gzip it is not automatically uncompressed.
+	DisableCompression bool
+
+	Logger *slog.Logger
+
+	mutex sync.Mutex
+
+	initOnce sync.Once
+	initErr  error
+
+	newClientConn func(*quic.Conn) clientConn
+
+	clients   map[string]*roundTripperWithCount
+	transport *quic.Transport
+	closed    bool
+}
+
+var (
+	_ http.RoundTripper = &Transport{}
+	_ io.Closer         = &Transport{}
+)
+
+var (
+	// ErrNoCachedConn is returned when Transport.OnlyCachedConn is set
+	ErrNoCachedConn = errors.New("http3: no cached connection was available")
+	// ErrTransportClosed is returned when attempting to use a closed Transport
+	ErrTransportClosed = errors.New("http3: transport is closed")
+)
+
+func (t *Transport) init() error {
+	if t.newClientConn == nil {
+		t.newClientConn = func(conn *quic.Conn) clientConn {
+			return newClientConn(
+				conn,
+				t.EnableDatagrams,
+				t.AdditionalSettings,
+				t.MaxResponseHeaderBytes,
+				t.DisableCompression,
+				t.Logger,
+			)
+		}
+	}
+	if t.QUICConfig == nil {
+		t.QUICConfig = defaultQuicConfig.Clone()
+		t.QUICConfig.EnableDatagrams = t.EnableDatagrams
+	}
+	if t.EnableDatagrams && !t.QUICConfig.EnableDatagrams {
+		return errors.New("HTTP Datagrams enabled, but QUIC Datagrams disabled")
+	}
+	if len(t.QUICConfig.Versions) == 0 {
+		t.QUICConfig = t.QUICConfig.Clone()
+		t.QUICConfig.Versions = []quic.Version{quic.SupportedVersions()[0]}
+	}
+	if len(t.QUICConfig.Versions) != 1 {
+		return errors.New("can only use a single QUIC version for dialing a HTTP/3 connection")
+	}
+	if t.QUICConfig.MaxIncomingStreams == 0 {
+		t.QUICConfig.MaxIncomingStreams = -1 // don't allow any bidirectional streams
+	}
+	if t.Dial == nil {
+		udpConn, err := net.ListenUDP("udp", nil)
+		if err != nil {
+			return err
+		}
+		t.transport = &quic.Transport{Conn: udpConn}
+	}
+	return nil
+}
+
+// RoundTripOpt is like RoundTrip, but takes options.
+func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
+	rsp, err := t.roundTripOpt(req, opt)
+	if err != nil {
+		if req.Body != nil {
+			req.Body.Close()
+		}
+		return nil, err
+	}
+	return rsp, nil
+}
+
+func (t *Transport) roundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
+	t.initOnce.Do(func() { t.initErr = t.init() })
+	if t.initErr != nil {
+		return nil, t.initErr
+	}
+
+	if req.URL == nil {
+		return nil, errors.New("http3: nil Request.URL")
+	}
+	if req.URL.Scheme != "https" {
+		return nil, fmt.Errorf("http3: unsupported protocol scheme: %s", req.URL.Scheme)
+	}
+	if req.URL.Host == "" {
+		return nil, errors.New("http3: no Host in request URL")
+	}
+	if req.Header == nil {
+		return nil, errors.New("http3: nil Request.Header")
+	}
+	if req.Method != "" && !validMethod(req.Method) {
+		return nil, fmt.Errorf("http3: invalid method %q", req.Method)
+	}
+	for k, vv := range req.Header {
+		// Skip validation for special header order keys
+		if k == httpcommon.HeaderOrderKey || k == httpcommon.PHeaderOrderKey {
+			continue
+		}
+		if !httpguts.ValidHeaderFieldName(k) {
+			return nil, fmt.Errorf("http3: invalid http header field name %q", k)
+		}
+		for _, v := range vv {
+			if !httpguts.ValidHeaderFieldValue(v) {
+				return nil, fmt.Errorf("http3: invalid http header field value %q for key %v", v, k)
+			}
+		}
+	}
+
+	return t.doRoundTripOpt(req, opt, false)
+}
+
+func (t *Transport) doRoundTripOpt(req *http.Request, opt RoundTripOpt, isRetried bool) (*http.Response, error) {
+	hostname := authorityAddr(hostnameFromURL(req.URL))
+	trace := httptrace.ContextClientTrace(req.Context())
+	traceGetConn(trace, hostname)
+	cl, isReused, err := t.getClient(req.Context(), hostname, opt.OnlyCachedConn)
+	if err != nil {
+		return nil, err
+	}
+
+	select {
+	case <-cl.dialing:
+	case <-req.Context().Done():
+		return nil, context.Cause(req.Context())
+	}
+
+	if cl.dialErr != nil {
+		t.removeClient(hostname)
+		return nil, cl.dialErr
+	}
+	defer cl.useCount.Add(-1)
+	traceGotConn(trace, cl.conn, isReused)
+	rsp, err := cl.clientConn.RoundTrip(req)
+	if err != nil {
+		// request aborted due to context cancellation
+		select {
+		case <-req.Context().Done():
+			return nil, err
+		default:
+		}
+		if isRetried {
+			return nil, err
+		}
+
+		t.removeClient(hostname)
+		req, err = canRetryRequest(err, req)
+		if err != nil {
+			return nil, err
+		}
+		return t.doRoundTripOpt(req, opt, true)
+	}
+	return rsp, nil
+}
+
+func canRetryRequest(err error, req *http.Request) (*http.Request, error) {
+	// error occurred while opening the stream, we can be sure that the request wasn't sent out
+	var connErr *errConnUnusable
+	if errors.As(err, &connErr) {
+		return req, nil
+	}
+
+	// If the request stream is reset, we can only be sure that the request wasn't processed
+	// if the error code is H3_REQUEST_REJECTED.
+	var e *Error
+	if !errors.As(err, &e) || e.ErrorCode != ErrCodeRequestRejected {
+		return nil, err
+	}
+	// if the body is nil (or http.NoBody), it's safe to reuse this request and its body
+	if req.Body == nil || req.Body == http.NoBody {
+		return req, nil
+	}
+	// if the request body can be reset back to its original state via req.GetBody, do that
+	if req.GetBody != nil {
+		newBody, err := req.GetBody()
+		if err != nil {
+			return nil, err
+		}
+		reqCopy := *req
+		reqCopy.Body = newBody
+		req = &reqCopy
+		return &reqCopy, nil
+	}
+	return nil, fmt.Errorf("http3: Transport: cannot retry err [%w] after Request.Body was written; define Request.GetBody to avoid this error", err)
+}
+
+// RoundTrip does a round trip.
+func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
+	return t.RoundTripOpt(req, RoundTripOpt{})
+}
+
+func (t *Transport) getClient(ctx context.Context, hostname string, onlyCached bool) (rtc *roundTripperWithCount, isReused bool, err error) {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	if t.closed {
+		return nil, false, ErrTransportClosed
+	}
+
+	if t.clients == nil {
+		t.clients = make(map[string]*roundTripperWithCount)
+	}
+
+	cl, ok := t.clients[hostname]
+	if !ok {
+		if onlyCached {
+			return nil, false, ErrNoCachedConn
+		}
+		ctx, cancel := context.WithCancel(ctx)
+		cl = &roundTripperWithCount{
+			dialing: make(chan struct{}),
+			cancel:  cancel,
+		}
+		go func() {
+			defer close(cl.dialing)
+			defer cancel()
+			conn, rt, err := t.dial(ctx, hostname)
+			if err != nil {
+				cl.dialErr = err
+				return
+			}
+			cl.conn = conn
+			cl.clientConn = rt
+		}()
+		t.clients[hostname] = cl
+	}
+	select {
+	case <-cl.dialing:
+		if cl.dialErr != nil {
+			delete(t.clients, hostname)
+			return nil, false, cl.dialErr
+		}
+		select {
+		case <-cl.conn.HandshakeComplete():
+			isReused = true
+		default:
+		}
+	default:
+	}
+	cl.useCount.Add(1)
+	return cl, isReused, nil
+}
+
+func (t *Transport) dial(ctx context.Context, hostname string) (*quic.Conn, clientConn, error) {
+	var tlsConf *tls.Config
+	if t.TLSClientConfig == nil {
+		tlsConf = &tls.Config{}
+	} else {
+		tlsConf = t.TLSClientConfig.Clone()
+	}
+	if tlsConf.ServerName == "" {
+		sni, _, err := net.SplitHostPort(hostname)
+		if err != nil {
+			// It's ok if net.SplitHostPort returns an error - it could be a hostname/IP address without a port.
+			sni = hostname
+		}
+		tlsConf.ServerName = sni
+	}
+	// Replace existing ALPNs by H3
+	tlsConf.NextProtos = []string{NextProtoH3}
+
+	dial := t.Dial
+	if dial == nil {
+		dial = func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) {
+			network := "udp"
+			udpAddr, err := t.resolveUDPAddr(ctx, network, addr)
+			if err != nil {
+				return nil, err
+			}
+			trace := httptrace.ContextClientTrace(ctx)
+			traceConnectStart(trace, network, udpAddr.String())
+			traceTLSHandshakeStart(trace)
+			conn, err := t.transport.DialEarly(ctx, udpAddr, tlsCfg, cfg)
+			var state tls.ConnectionState
+			if conn != nil {
+				state = conn.ConnectionState().TLS
+			}
+			traceTLSHandshakeDone(trace, state, err)
+			traceConnectDone(trace, network, udpAddr.String(), err)
+			return conn, err
+		}
+	}
+	conn, err := dial(ctx, hostname, tlsConf, t.QUICConfig)
+	if err != nil {
+		return nil, nil, err
+	}
+	clientConn := t.newClientConn(conn)
+	go func() {
+		for {
+			str, err := conn.AcceptUniStream(context.Background())
+			if err != nil {
+				return
+			}
+			go clientConn.handleUnidirectionalStream(str)
+		}
+	}()
+	return conn, clientConn, nil
+}
+
+func (t *Transport) resolveUDPAddr(ctx context.Context, network, addr string) (*net.UDPAddr, error) {
+	host, portStr, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+	port, err := net.LookupPort(network, portStr)
+	if err != nil {
+		return nil, err
+	}
+	resolver := net.DefaultResolver
+	ipAddrs, err := resolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return nil, err
+	}
+	addrs := addrList(ipAddrs)
+	ip := addrs.forResolve(network, addr)
+	return &net.UDPAddr{IP: ip.IP, Port: port, Zone: ip.Zone}, nil
+}
+
+func (t *Transport) removeClient(hostname string) {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	if t.clients == nil {
+		return
+	}
+	delete(t.clients, hostname)
+}
+
+// NewClientConn creates a new HTTP/3 client connection on top of a QUIC connection.
+// Most users should use RoundTrip instead of creating a connection directly.
+// Specifically, it is not needed to perform GET, POST, HEAD and CONNECT requests.
+//
+// Obtaining a ClientConn is only needed for more advanced use cases, such as
+// using Extended CONNECT for WebTransport or the various MASQUE protocols.
+func (t *Transport) NewClientConn(conn *quic.Conn) *ClientConn {
+	c := newClientConn(
+		conn,
+		t.EnableDatagrams,
+		t.AdditionalSettings,
+		t.MaxResponseHeaderBytes,
+		t.DisableCompression,
+		t.Logger,
+	)
+	go func() {
+		for {
+			str, err := conn.AcceptUniStream(context.Background())
+			if err != nil {
+				return
+			}
+			go c.handleUnidirectionalStream(str)
+		}
+	}()
+	return c
+}
+
+// NewRawClientConn creates a new low-level HTTP/3 client connection on top of a QUIC connection.
+// Unlike NewClientConn, the returned RawClientConn allows the application to take control
+// of the stream accept loops, by calling HandleUnidirectionalStream for incoming unidirectional
+// streams and HandleBidirectionalStream for incoming bidirectional streams.
+func (t *Transport) NewRawClientConn(conn *quic.Conn) *RawClientConn {
+	return &RawClientConn{
+		ClientConn: newClientConn(
+			conn,
+			t.EnableDatagrams,
+			t.AdditionalSettings,
+			t.MaxResponseHeaderBytes,
+			t.DisableCompression,
+			t.Logger,
+		),
+	}
+}
+
+// Close closes the QUIC connections that this Transport has used.
+// A Transport cannot be used after it has been closed.
+func (t *Transport) Close() error {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	for _, cl := range t.clients {
+		if err := cl.Close(); err != nil {
+			return err
+		}
+	}
+	t.clients = nil
+	if t.transport != nil {
+		if err := t.transport.Close(); err != nil {
+			return err
+		}
+		if err := t.transport.Conn.Close(); err != nil {
+			return err
+		}
+		t.transport = nil
+	}
+	t.closed = true
+	return nil
+}
+
+func hostnameFromURL(url *url.URL) string {
+	if url != nil {
+		return url.Host
+	}
+	return ""
+}
+
+func validMethod(method string) bool {
+	/*
+				     Method         = "OPTIONS"                ; Section 9.2
+		   		                    | "GET"                    ; Section 9.3
+		   		                    | "HEAD"                   ; Section 9.4
+		   		                    | "POST"                   ; Section 9.5
+		   		                    | "PUT"                    ; Section 9.6
+		   		                    | "DELETE"                 ; Section 9.7
+		   		                    | "TRACE"                  ; Section 9.8
+		   		                    | "CONNECT"                ; Section 9.9
+		   		                    | extension-method
+		   		   extension-method = token
+		   		     token          = 1*<any CHAR except CTLs or separators>
+	*/
+	return len(method) > 0 && strings.IndexFunc(method, isNotToken) == -1
+}
+
+// copied from net/http/http.go
+func isNotToken(r rune) bool {
+	return !httpguts.IsTokenRune(r)
+}
+
+// CloseIdleConnections closes any QUIC connections in the transport's pool that are currently idle.
+// An idle connection is one that was previously used for requests but is now sitting unused.
+// This method does not interrupt any connections currently in use.
+// It also does not affect connections obtained via NewClientConn.
+func (t *Transport) CloseIdleConnections() {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	for hostname, cl := range t.clients {
+		if cl.useCount.Load() == 0 {
+			cl.Close()
+			delete(t.clients, hostname)
+		}
+	}
+}
diff --git a/backend/vendor/github.com/enetx/surf/internal/retryafter/retryafter.go b/backend/vendor/github.com/enetx/surf/internal/retryafter/retryafter.go
new file mode 100644
index 00000000..50e1e8f5
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/internal/retryafter/retryafter.go
@@ -0,0 +1,58 @@
+// Package retryafter parses values of the HTTP Retry-After header
+// as defined by RFC 7231 §7.1.3.
+//
+// Two forms are recognised: an integer count of seconds (delay-seconds)
+// and an HTTP-date in any of the three formats accepted by RFC 7231
+// (IMF-fixdate, RFC 850, ANSI C asctime). The HTTP-date branch is
+// handled by github.com/enetx/http.ParseTime, which mirrors the
+// standard library's net/http.ParseTime.
+package retryafter
+
+import (
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/enetx/http"
+)
+
+// Parse interprets value as a Retry-After header field.
+//
+// On success it returns the wait duration and true. A successful parse of "0",
+// a past HTTP-date, or any negative time.Until(parsed) is clamped to zero so
+// that callers using max(retryWait, parsed) preserve their minimum floor.
+//
+// For missing, empty, malformed, fractional, or negative integer values it
+// returns (0, false) so callers fall back to their own wait policy.
+//
+// The now argument is injected to keep HTTP-date arithmetic deterministic in
+// tests; production callers pass time.Now() immediately before scheduling the
+// timer.
+//
+// Multiple Retry-After headers are undefined by the RFC; callers must select
+// a single value via http.Header.Get before calling Parse.
+func Parse(value string, now time.Time) (time.Duration, bool) {
+	v := strings.TrimSpace(value)
+	if v == "" {
+		return 0, false
+	}
+
+	if n, err := strconv.Atoi(v); err == nil {
+		if n < 0 {
+			return 0, false
+		}
+
+		return time.Duration(n) * time.Second, true
+	}
+
+	if t, err := http.ParseTime(v); err == nil {
+		d := t.Sub(now)
+		if d < 0 {
+			return 0, true
+		}
+
+		return d, true
+	}
+
+	return 0, false
+}
diff --git a/backend/vendor/github.com/enetx/surf/multipart.go b/backend/vendor/github.com/enetx/surf/multipart.go
new file mode 100644
index 00000000..2469cd4f
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/multipart.go
@@ -0,0 +1,209 @@
+package surf
+
+import (
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/textproto"
+	"path/filepath"
+
+	"github.com/enetx/g"
+	"github.com/enetx/g/fs"
+)
+
+// Multipart represents multipart form data with fields and files.
+type Multipart struct {
+	fields g.MapOrd[g.String, g.String]
+	files  g.Slice[*MultipartFile]
+	retry  bool
+}
+
+// MultipartFile represents a single file for multipart upload.
+type MultipartFile struct {
+	fieldName   g.String
+	fileName    g.String
+	contentType g.String
+	file        *fs.File
+	reader      io.Reader
+}
+
+// NewMultipart creates a new empty Multipart object.
+func NewMultipart() *Multipart {
+	return &Multipart{
+		fields: g.NewMapOrd[g.String, g.String](),
+		files:  g.NewSlice[*MultipartFile](),
+	}
+}
+
+// Field adds a form field to the multipart.
+func (m *Multipart) Field(name, value g.String) *Multipart {
+	m.fields.Insert(name, value)
+	return m
+}
+
+// File adds a physical file to the multipart.
+func (m *Multipart) File(fieldName g.String, file *fs.File) *Multipart {
+	f := &MultipartFile{
+		fieldName: fieldName,
+		fileName:  file.Name(),
+		file:      file,
+	}
+
+	m.files.Push(f)
+	return m
+}
+
+// FileReader adds a file from io.Reader to the multipart.
+func (m *Multipart) FileReader(fieldName, fileName g.String, reader io.Reader) *Multipart {
+	f := &MultipartFile{
+		fieldName: fieldName,
+		fileName:  fileName,
+		reader:    reader,
+	}
+
+	m.files.Push(f)
+	return m
+}
+
+// FileString adds a file from string content to the multipart.
+func (m *Multipart) FileString(fieldName, fileName, content g.String) *Multipart {
+	f := &MultipartFile{
+		fieldName: fieldName,
+		fileName:  fileName,
+		reader:    content.Reader(),
+	}
+
+	m.files.Push(f)
+	return m
+}
+
+// FileBytes adds a file from byte slice to the multipart.
+func (m *Multipart) FileBytes(fieldName, fileName g.String, data g.Bytes) *Multipart {
+	f := &MultipartFile{
+		fieldName: fieldName,
+		fileName:  fileName,
+		reader:    data.Reader(),
+	}
+
+	m.files.Push(f)
+	return m
+}
+
+// ContentType sets the content type for the last added file.
+// Must be called immediately after File/FileReader/FileString/FileBytes.
+func (m *Multipart) ContentType(ct g.String) *Multipart {
+	if last := m.files.Last(); last.IsSome() {
+		last.Some().contentType = ct
+	}
+
+	return m
+}
+
+// FileName overrides the filename for the last added file.
+// Useful when you want a different name than the physical file.
+func (m *Multipart) FileName(name g.String) *Multipart {
+	if last := m.files.Last(); last.IsSome() {
+		last.Some().fileName = name
+	}
+
+	return m
+}
+
+// Retry controls whether the multipart body should be buffered in memory
+// to support retries on status codes (429, 503, 5xx, etc.).
+//
+// When set, the body is fully read into memory before sending,
+// allowing the client to replay it on retry.
+//
+// Recommended only for small requests (≤ 5–10 MB).
+func (m *Multipart) Retry() *Multipart {
+	m.retry = true
+	return m
+}
+
+// prepareWriter writes the multipart data to a writer and returns the content type and write error.
+func (m *Multipart) prepareWriter(boundary func() g.String) (io.ReadCloser, string, error) {
+	pr, pw := io.Pipe()
+	writer := multipart.NewWriter(pw)
+
+	if boundary != nil {
+		if err := writer.SetBoundary(boundary().Std()); err != nil {
+			_ = pw.CloseWithError(err)
+			_ = pr.Close()
+			return nil, "", err
+		}
+	}
+
+	go func() {
+		err := func() error {
+			for key, val := range m.fields.Iter() {
+				part, err := writer.CreateFormField(key.Std())
+				if err != nil {
+					return err
+				}
+
+				if _, err := io.Copy(part, val.Reader()); err != nil {
+					return err
+				}
+			}
+
+			for file := range m.files.Iter() {
+				var reader io.Reader
+
+				if file.file != nil {
+					res := file.file.Open()
+					if res.IsErr() {
+						return fmt.Errorf("cannot open file %q: %w", file.file.Name(), res.Err())
+					}
+
+					opened := res.Ok()
+					defer opened.Close()
+
+					reader = opened.Std()
+				} else if file.reader != nil {
+					reader = file.reader
+				} else {
+					return fmt.Errorf("multipart file %q has no content source", file.fileName.Std())
+				}
+
+				ct := file.contentType.Std()
+				if ct == "" {
+					ext := filepath.Ext(file.fileName.Std())
+					ct = mime.TypeByExtension(ext)
+					if ct == "" {
+						ct = "application/octet-stream"
+					}
+				}
+
+				disposition := fmt.Sprintf(
+					`form-data; name="%s"; filename="%s"`,
+					escapeQuotes(file.fieldName),
+					escapeQuotes(file.fileName),
+				)
+
+				h := textproto.MIMEHeader{
+					"Content-Disposition": {disposition},
+					"Content-Type":        {ct},
+				}
+
+				part, err := writer.CreatePart(h)
+				if err != nil {
+					return err
+				}
+
+				if _, err := io.Copy(part, reader); err != nil {
+					return err
+				}
+			}
+
+			return writer.Close()
+		}()
+
+		pw.CloseWithError(err)
+	}()
+
+	return pr, writer.FormDataContentType(), nil
+}
+
+func escapeQuotes(s g.String) string { return s.ReplaceMulti(`\`, `\\`, `"`, `\"`).Std() }
diff --git a/backend/vendor/github.com/enetx/surf/pkg/socks4/errors.go b/backend/vendor/github.com/enetx/surf/pkg/socks4/errors.go
new file mode 100644
index 00000000..bcba3a16
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/pkg/socks4/errors.go
@@ -0,0 +1,48 @@
+package socks4
+
+import "fmt"
+
+type (
+	ErrWrongNetwork    struct{}
+	ErrConnRejected    struct{}
+	ErrIdentRequired   struct{}
+	ErrDialFailed      struct{ err error }
+	ErrBuffer          struct{ err error }
+	ErrIO              struct{ err error }
+	ErrInvalidResponse struct{ resp byte }
+
+	ErrWrongAddr struct {
+		msg string
+		err error
+	}
+
+	ErrHostUnknown struct {
+		msg string
+		err error
+	}
+)
+
+func (e *ErrDialFailed) Error() string { return fmt.Sprintf("socks4 dial %v", e.err) }
+func (e *ErrDialFailed) Unwrap() error { return e.err }
+
+func (e *ErrHostUnknown) Error() string {
+	return fmt.Sprintf("unable to find IP address of host %s", e.msg)
+}
+func (e *ErrHostUnknown) Unwrap() error { return e.err }
+
+func (e *ErrBuffer) Error() string { return "unable write into buffer" }
+func (e *ErrBuffer) Unwrap() error { return e.err }
+
+func (e *ErrIO) Error() string { return "io error" }
+func (e *ErrIO) Unwrap() error { return e.err }
+
+func (e *ErrWrongAddr) Error() string { return fmt.Sprintf("wrong addr: %s, error: %v", e.msg, e.err) }
+func (e *ErrWrongAddr) Unwrap() error { return e.err }
+
+func (e *ErrWrongNetwork) Error() string { return "network should be tcp or tcp4" }
+
+func (e *ErrConnRejected) Error() string  { return "connection to remote host was rejected" }
+func (e *ErrIdentRequired) Error() string { return "valid ident required" }
+func (e *ErrInvalidResponse) Error() string {
+	return fmt.Sprintf("unknown socks4 server response 0x%02x", e.resp)
+}
diff --git a/backend/vendor/github.com/enetx/surf/pkg/socks4/socks4.go b/backend/vendor/github.com/enetx/surf/pkg/socks4/socks4.go
new file mode 100644
index 00000000..cf933f96
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/pkg/socks4/socks4.go
@@ -0,0 +1,207 @@
+package socks4
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"io"
+	"net"
+	"net/url"
+	"strconv"
+	"time"
+
+	"golang.org/x/net/proxy"
+)
+
+const (
+	socksVersion = 0x04
+	socksConnect = 0x01
+	socksBind    = 0x02
+
+	accessGranted       = 0x5a
+	accessRejected      = 0x5b
+	accessIdentRequired = 0x5c
+	accessIdentFailed   = 0x5d
+
+	minRequestLen = 8
+)
+
+var Ident = "nobody@0.0.0.0"
+
+func init() {
+	proxy.RegisterDialerType("socks4", func(u *url.URL, d proxy.Dialer) (proxy.Dialer, error) {
+		return socks4{url: u, dialer: d}, nil
+	})
+
+	proxy.RegisterDialerType("socks4a", func(u *url.URL, d proxy.Dialer) (proxy.Dialer, error) {
+		return socks4{url: u, dialer: d}, nil
+	})
+}
+
+type socks4 struct {
+	url    *url.URL
+	dialer proxy.Dialer
+}
+
+// DialContext implements proxy.ContextDialer interface
+func (s socks4) DialContext(ctx context.Context, network, addr string) (c net.Conn, err error) {
+	if network != "tcp" && network != "tcp4" {
+		return nil, new(ErrWrongNetwork)
+	}
+
+	// Use context-aware dialer if available
+	if cd, ok := s.dialer.(proxy.ContextDialer); ok {
+		c, err = cd.DialContext(ctx, network, s.url.Host)
+	} else {
+		c, err = s.dialer.Dial(network, s.url.Host)
+	}
+
+	if err != nil {
+		return nil, &ErrDialFailed{err}
+	}
+
+	// close connection later if we got an error
+	defer func() {
+		if err != nil && c != nil {
+			_ = c.Close()
+		}
+	}()
+
+	// Set deadline from context
+	if deadline, ok := ctx.Deadline(); ok {
+		c.SetDeadline(deadline)
+		defer c.SetDeadline(time.Time{})
+	}
+
+	// Check context before handshake
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
+
+	host, port, err := s.parseAddr(addr)
+	if err != nil {
+		return nil, &ErrWrongAddr{addr, err}
+	}
+
+	ip := net.IPv4(0, 0, 0, 1)
+	if !s.isSocks4a() {
+		if ip, err = s.lookupAddr(ctx, host); err != nil {
+			return nil, &ErrHostUnknown{host, err}
+		}
+	}
+
+	req, err := request{Host: host, Port: port, IP: ip, Is4a: s.isSocks4a()}.Bytes()
+	if err != nil {
+		return nil, &ErrBuffer{err}
+	}
+
+	var i int
+	i, err = c.Write(req)
+	if err != nil {
+		return c, &ErrIO{err}
+	} else if i < minRequestLen {
+		return c, &ErrIO{io.ErrShortWrite}
+	}
+
+	var resp [8]byte
+	i, err = c.Read(resp[:])
+	if err != nil && err != io.EOF {
+		return c, &ErrIO{err}
+	} else if i != 8 {
+		return c, &ErrIO{io.ErrUnexpectedEOF}
+	}
+
+	switch resp[1] {
+	case accessGranted:
+		return c, nil
+	case accessIdentRequired, accessIdentFailed:
+		return c, new(ErrIdentRequired)
+	case accessRejected:
+		return c, new(ErrConnRejected)
+	default:
+		return c, &ErrInvalidResponse{resp[1]}
+	}
+}
+
+// Dial implements proxy.Dialer interface
+func (s socks4) Dial(network, addr string) (net.Conn, error) {
+	return s.DialContext(context.Background(), network, addr)
+}
+
+func (s socks4) lookupAddr(ctx context.Context, host string) (net.IP, error) {
+	resolver := net.DefaultResolver
+	ips, err := resolver.LookupIPAddr(ctx, host)
+	if err != nil {
+		return net.IP{}, err
+	}
+
+	for _, ip := range ips {
+		if v4 := ip.IP.To4(); v4 != nil {
+			return v4, nil
+		}
+	}
+
+	return net.IP{}, &net.DNSError{Err: "no IPv4 address", Name: host}
+}
+
+func (s socks4) isSocks4a() bool {
+	return s.url.Scheme == "socks4a"
+}
+
+func (s socks4) parseAddr(addr string) (host string, iport int, err error) {
+	var port string
+
+	host, port, err = net.SplitHostPort(addr)
+	if err != nil {
+		return "", 0, err
+	}
+
+	iport, err = strconv.Atoi(port)
+	if err != nil {
+		return "", 0, err
+	}
+
+	return host, iport, err
+}
+
+type request struct {
+	Host string
+	Port int
+	IP   net.IP
+	Is4a bool
+
+	err error
+	buf bytes.Buffer
+}
+
+func (r *request) write(b []byte) {
+	if r.err == nil {
+		_, r.err = r.buf.Write(b)
+	}
+}
+
+func (r *request) writeString(s string) {
+	if r.err == nil {
+		_, r.err = r.buf.WriteString(s)
+	}
+}
+
+func (r *request) writeBigEndian(data any) {
+	if r.err == nil {
+		r.err = binary.Write(&r.buf, binary.BigEndian, data)
+	}
+}
+
+func (r request) Bytes() ([]byte, error) {
+	r.write([]byte{socksVersion, socksConnect})
+	r.writeBigEndian(uint16(r.Port))
+	r.writeBigEndian(r.IP.To4())
+	r.writeString(Ident)
+	r.write([]byte{0})
+	if r.Is4a {
+		r.writeString(r.Host)
+		r.write([]byte{0})
+	}
+
+	return r.buf.Bytes(), r.err
+}
diff --git a/backend/vendor/github.com/enetx/surf/pools.go b/backend/vendor/github.com/enetx/surf/pools.go
new file mode 100644
index 00000000..fb0e2f04
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/pools.go
@@ -0,0 +1,134 @@
+package surf
+
+import (
+	"compress/gzip"
+	"errors"
+	"io"
+	"sync"
+
+	"github.com/andybalholm/brotli"
+	"github.com/enetx/g"
+	"github.com/klauspost/compress/zstd"
+)
+
+// decodedReadCloser owns both the decoder and the encoded source it wraps.
+// Closing only the decoder leaks the HTTP response body (and its deadline
+// goroutine); nesting this type also preserves ownership for encoding chains.
+type decodedReadCloser struct {
+	decoder io.ReadCloser
+	source  io.ReadCloser
+}
+
+func (reader *decodedReadCloser) Read(buffer []byte) (int, error) {
+	return reader.decoder.Read(buffer)
+}
+
+func (reader *decodedReadCloser) Close() error {
+	return errors.Join(reader.decoder.Close(), reader.source.Close())
+}
+
+var (
+	// zstdDecoderPool pools zstd.Decoder instances.
+	zstdDecoderPool = sync.Pool{
+		New: func() any {
+			dec, _ := zstd.NewReader(nil)
+			return dec
+		},
+	}
+
+	// gzipReaderPool pools gzip.Reader instances.
+	gzipReaderPool = sync.Pool{
+		New: func() any {
+			return new(gzip.Reader)
+		},
+	}
+
+	// brotliReaderPool pools brotli.Reader instances.
+	brotliReaderPool = sync.Pool{
+		New: func() any {
+			return brotli.NewReader(nil)
+		},
+	}
+)
+
+// zstdReadCloser wraps a zstd decoder and returns it to the pool on Close.
+type zstdReadCloser struct {
+	dec *zstd.Decoder
+}
+
+// Read reads decompressed data from the decoder.
+func (zr *zstdReadCloser) Read(p []byte) (int, error) {
+	return zr.dec.Read(p)
+}
+
+// Close resets the decoder and returns it to the pool.
+func (zr *zstdReadCloser) Close() error {
+	if err := zr.dec.Reset(nil); err != nil {
+		return err
+	}
+
+	zstdDecoderPool.Put(zr.dec)
+	return nil
+}
+
+// gzipReadCloser wraps a gzip reader and returns it to the pool on Close.
+type gzipReadCloser struct {
+	*gzip.Reader
+}
+
+// Close closes the reader and returns it to the pool.
+func (gr *gzipReadCloser) Close() error {
+	if err := gr.Reader.Close(); err != nil {
+		return err
+	}
+
+	gzipReaderPool.Put(gr.Reader)
+	return nil
+}
+
+// brotliReadCloser wraps a brotli reader and returns it to the pool on Close.
+type brotliReadCloser struct {
+	*brotli.Reader
+}
+
+// Close returns the reader to the pool.
+func (br *brotliReadCloser) Close() error {
+	brotliReaderPool.Put(br.Reader)
+	return nil
+}
+
+// acquireGzipReader gets a gzip.Reader from the pool and resets it with the provided reader.
+// Returns the reader wrapped in gzipReadCloser for automatic pool management.
+func acquireGzipReader(r io.Reader) g.Result[io.ReadCloser] {
+	gr := gzipReaderPool.Get().(*gzip.Reader)
+	if err := gr.Reset(r); err != nil {
+		gzipReaderPool.Put(gr)
+		return g.Err[io.ReadCloser](err)
+	}
+
+	return g.Ok[io.ReadCloser](&gzipReadCloser{Reader: gr})
+}
+
+// acquireBrotliReader gets a brotli.Reader from the pool and resets it with the provided reader.
+// Returns the reader wrapped in brotliReadCloser for automatic pool management.
+func acquireBrotliReader(r io.Reader) g.Result[io.ReadCloser] {
+	br := brotliReaderPool.Get().(*brotli.Reader)
+	if err := br.Reset(r); err != nil {
+		brotliReaderPool.Put(br)
+		return g.Err[io.ReadCloser](err)
+	}
+
+	return g.Ok[io.ReadCloser](&brotliReadCloser{Reader: br})
+}
+
+// acquireZstdReader gets a zstd.Decoder from the pool and resets it with the provided reader.
+// Returns the decoder wrapped in zstdReadCloser for automatic pool management.
+func acquireZstdReader(r io.Reader) g.Result[io.ReadCloser] {
+	dec := zstdDecoderPool.Get().(*zstd.Decoder)
+	if err := dec.Reset(r); err != nil {
+		zstdDecoderPool.Put(dec)
+		return g.Err[io.ReadCloser](err)
+	}
+
+	return g.Ok[io.ReadCloser](&zstdReadCloser{dec: dec})
+}
diff --git a/backend/vendor/github.com/enetx/surf/profile_adapter.go b/backend/vendor/github.com/enetx/surf/profile_adapter.go
new file mode 100644
index 00000000..9ecc91f7
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profile_adapter.go
@@ -0,0 +1,109 @@
+package surf
+
+import (
+	"github.com/enetx/http2"
+	"github.com/enetx/surf/profiles"
+)
+
+// h2adapter wraps *HTTP2Settings to satisfy profiles.H2Config (which returns the interface type
+// instead of *HTTP2Settings, so direct method satisfaction is impossible). Each method delegates
+// to the underlying *HTTP2Settings and returns the adapter to keep the chain fluent.
+type h2adapter struct{ s *HTTP2Settings }
+
+func (a h2adapter) HeaderTableSize(v uint32) profiles.H2Config {
+	a.s.HeaderTableSize(v)
+	return a
+}
+
+func (a h2adapter) EnablePush(v uint32) profiles.H2Config {
+	a.s.EnablePush(v)
+	return a
+}
+
+func (a h2adapter) MaxConcurrentStreams(v uint32) profiles.H2Config {
+	a.s.MaxConcurrentStreams(v)
+	return a
+}
+
+func (a h2adapter) InitialWindowSize(v uint32) profiles.H2Config {
+	a.s.InitialWindowSize(v)
+	return a
+}
+
+func (a h2adapter) MaxFrameSize(v uint32) profiles.H2Config {
+	a.s.MaxFrameSize(v)
+	return a
+}
+
+func (a h2adapter) MaxHeaderListSize(v uint32) profiles.H2Config {
+	a.s.MaxHeaderListSize(v)
+	return a
+}
+
+func (a h2adapter) NoRFC7540Priorities(v uint32) profiles.H2Config {
+	a.s.NoRFC7540Priorities(v)
+	return a
+}
+
+func (a h2adapter) ConnectionFlow(v uint32) profiles.H2Config {
+	a.s.ConnectionFlow(v)
+	return a
+}
+
+func (a h2adapter) InitialStreamID(v uint32) profiles.H2Config {
+	a.s.InitialStreamID(v)
+	return a
+}
+
+func (a h2adapter) PriorityParam(v http2.PriorityParam) profiles.H2Config {
+	a.s.PriorityParam(v)
+	return a
+}
+
+func (a h2adapter) PriorityFrames(v []http2.PriorityFrame) profiles.H2Config {
+	a.s.PriorityFrames(v)
+	return a
+}
+
+// h3adapter wraps *HTTP3Settings to satisfy profiles.H3Config.
+type h3adapter struct{ s *HTTP3Settings }
+
+func (a h3adapter) QpackMaxTableCapacity(v uint64) profiles.H3Config {
+	a.s.QpackMaxTableCapacity(v)
+	return a
+}
+
+func (a h3adapter) MaxFieldSectionSize(v uint64) profiles.H3Config {
+	a.s.MaxFieldSectionSize(v)
+	return a
+}
+
+func (a h3adapter) QpackBlockedStreams(v uint64) profiles.H3Config {
+	a.s.QpackBlockedStreams(v)
+	return a
+}
+
+func (a h3adapter) EnableConnectProtocol(v uint64) profiles.H3Config {
+	a.s.EnableConnectProtocol(v)
+	return a
+}
+
+func (a h3adapter) SettingsH3Datagram(v uint64) profiles.H3Config {
+	a.s.SettingsH3Datagram(v)
+	return a
+}
+
+func (a h3adapter) H3Datagram(v uint64) profiles.H3Config {
+	a.s.H3Datagram(v)
+	return a
+}
+
+func (a h3adapter) EnableWebtransport(v uint64) profiles.H3Config {
+	a.s.EnableWebtransport(v)
+	return a
+}
+
+func (a h3adapter) Grease() profiles.H3Config {
+	a.s.Grease()
+	return a
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/boundary.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/boundary.go
new file mode 100644
index 00000000..970afee7
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/boundary.go
@@ -0,0 +1,81 @@
+package chrome
+
+import (
+	"crypto/rand"
+
+	"github.com/enetx/g"
+)
+
+// Blink implementation: https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/network/form_data_encoder.cc;drc=1d694679493c7b2f7b9df00e967b4f8699321093;l=130
+// WebKit implementation: https://github.com/WebKit/WebKit/blob/main/Source/WebCore/platform/network/FormDataBuilder.cpp#L120
+func Boundary() g.String {
+	// C++
+	// Vector<uint8_t> generateUniqueBoundaryString()
+	// {
+	//     Vector<uint8_t> boundary;
+	//
+	//     // The RFC 2046 spec says the alphanumeric characters plus the
+	//     // following characters are legal for boundaries:  '()+_,-./:=?
+	//     // However the following characters, though legal, cause some sites
+	//     // to fail: (),./:=+
+	//     // Note that our algorithm makes it twice as much likely for 'A' or 'B'
+	//     // to appear in the boundary string, because 0x41 and 0x42 are present in
+	//     // the below array twice.
+	//     static constexpr std::array<char, 64> alphaNumericEncodingMap {
+	//         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+	//         0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+	//         0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+	//         0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+	//         0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+	//         0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+	//         0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33,
+	//         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42
+	//     };
+	//
+	//     // Start with an informative prefix.
+	//     append(boundary, "----WebKitFormBoundary");
+	//
+	//     // Append 16 random 7-bit ASCII alphanumeric characters.
+	//     for (unsigned i = 0; i < 4; ++i) {
+	//         unsigned randomness = cryptographicallyRandomNumber<unsigned>();
+	//         boundary.append(alphaNumericEncodingMap[(randomness >> 24) & 0x3F]);
+	//         boundary.append(alphaNumericEncodingMap[(randomness >> 16) & 0x3F]);
+	//         boundary.append(alphaNumericEncodingMap[(randomness >> 8) & 0x3F]);
+	//         boundary.append(alphaNumericEncodingMap[randomness & 0x3F]);
+	//     }
+	//
+	//     return boundary;
+	// }
+
+	prefix := "----WebKitFormBoundary"
+
+	alphaNumericEncodingMap := []byte{
+		0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+		0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+		0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+		0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+		0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
+		0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+		0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33,
+		0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42,
+	}
+
+	boundary := []byte(prefix)
+
+	for range 4 {
+		randomBytes := make([]byte, 4)
+		rand.Read(randomBytes)
+
+		randomness := uint32(randomBytes[0])<<24 |
+			uint32(randomBytes[1])<<16 |
+			uint32(randomBytes[2])<<8 |
+			uint32(randomBytes[3])
+
+		boundary = append(boundary, alphaNumericEncodingMap[(randomness>>24)&0x3F])
+		boundary = append(boundary, alphaNumericEncodingMap[(randomness>>16)&0x3F])
+		boundary = append(boundary, alphaNumericEncodingMap[(randomness>>8)&0x3F])
+		boundary = append(boundary, alphaNumericEncodingMap[randomness&0x3F])
+	}
+
+	return g.String(boundary)
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/headers.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/headers.go
new file mode 100644
index 00000000..50a8f929
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/headers.go
@@ -0,0 +1,324 @@
+package chrome
+
+import (
+	"github.com/enetx/g"
+	"github.com/enetx/http"
+	"github.com/enetx/surf/header"
+	"github.com/enetx/surf/profiles"
+)
+
+// --- Header order maps -------------------------------------------------------
+
+var headerOrderDesktop = g.Map[string, g.Slice[string]]{
+	http.MethodGet: {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.SEC_CH_UA,
+		header.SEC_CH_UA_MOBILE,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_USER,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodGet + "http3": {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.SEC_CH_UA,
+		header.SEC_CH_UA_MOBILE,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_USER,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodPost: {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.CONTENT_LENGTH,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.USER_AGENT,
+		header.SEC_CH_UA,
+		header.CONTENT_TYPE,
+		header.SEC_CH_UA_MOBILE,
+		header.ACCEPT,
+		header.ORIGIN,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodPost + "http3": {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.CONTENT_LENGTH,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.USER_AGENT,
+		header.SEC_CH_UA,
+		header.CONTENT_TYPE,
+		header.SEC_CH_UA_MOBILE,
+		header.ACCEPT,
+		header.ORIGIN,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+}
+
+// headerOrderMobile is a placeholder mobile variant. On the day real Chrome Android header
+// ordering is observed, this map is the single point to substitute it without touching desktop.
+// The literal is a physical copy of headerOrderDesktop so the two maps can diverge independently.
+var headerOrderMobile = g.Map[string, g.Slice[string]]{
+	http.MethodGet: {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.SEC_CH_UA,
+		header.SEC_CH_UA_MOBILE,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_USER,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodGet + "http3": {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.SEC_CH_UA,
+		header.SEC_CH_UA_MOBILE,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_USER,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodPost: {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.CONTENT_LENGTH,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.USER_AGENT,
+		header.SEC_CH_UA,
+		header.CONTENT_TYPE,
+		header.SEC_CH_UA_MOBILE,
+		header.ACCEPT,
+		header.ORIGIN,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+
+	http.MethodPost + "http3": {
+		":method",
+		":authority",
+		":scheme",
+		":path",
+		header.CONTENT_LENGTH,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+		header.SEC_CH_UA_PLATFORM,
+		header.AUTHORIZATION,
+		header.USER_AGENT,
+		header.SEC_CH_UA,
+		header.CONTENT_TYPE,
+		header.SEC_CH_UA_MOBILE,
+		header.ACCEPT,
+		header.ORIGIN,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_DEST,
+		header.REFERER,
+		header.ACCEPT_ENCODING,
+		header.ACCEPT_LANGUAGE,
+		header.COOKIE,
+		header.PRIORITY,
+	},
+}
+
+var headerCache = profiles.NewHeaderCache(headerOrderDesktop, headerOrderMobile)
+
+// --- Static header set (Variant.BuildHeaders) --------------------------------
+
+// buildHeadersDesktop constructs the desktop Chrome 152 request header set.
+func buildHeadersDesktop(os profiles.OSKey) *g.MapOrd[g.String, g.String] {
+	h := g.NewMapOrd[g.String, g.String]()
+	h.Insert(":authority", "")
+	h.Insert(":method", "")
+	h.Insert(":path", "")
+	h.Insert(":scheme", "")
+	h.Insert(header.ACCEPT_ENCODING, "gzip, deflate, br, zstd")
+	h.Insert(header.ACCEPT_LANGUAGE, "en-US,en;q=0.9")
+	h.Insert(header.AUTHORIZATION, "")
+	h.Insert(header.COOKIE, "")
+	h.Insert(header.ORIGIN, "")
+	h.Insert(header.REFERER, "")
+	h.Insert(header.SEC_CH_UA, SecCHUA)
+	h.Insert(header.SEC_CH_UA_MOBILE, os.Mobile())
+	h.Insert(header.SEC_CH_UA_PLATFORM, Platform.Get(os).UnwrapOrDefault())
+	h.Insert(header.USER_AGENT, UserAgent.Get(os).UnwrapOrDefault())
+
+	return &h
+}
+
+// buildHeadersMobile constructs the placeholder mobile Chrome 152 request header set.
+// On the day real Chrome Android header set diverges from desktop (different Accept-Encoding,
+// shorter sec-ch-ua, different ordering / inserts), replace this body — it is the single point
+// of substitution for the entire mobile header set.
+func buildHeadersMobile(os profiles.OSKey) *g.MapOrd[g.String, g.String] {
+	h := g.NewMapOrd[g.String, g.String]()
+	h.Insert(":authority", "")
+	h.Insert(":method", "")
+	h.Insert(":path", "")
+	h.Insert(":scheme", "")
+	h.Insert(header.ACCEPT_ENCODING, "gzip, deflate, br, zstd")
+	h.Insert(header.ACCEPT_LANGUAGE, "en-US,en;q=0.9")
+	h.Insert(header.AUTHORIZATION, "")
+	h.Insert(header.COOKIE, "")
+	h.Insert(header.ORIGIN, "")
+	h.Insert(header.REFERER, "")
+	h.Insert(header.SEC_CH_UA, SecCHUA)
+	h.Insert(header.SEC_CH_UA_MOBILE, os.Mobile())
+	h.Insert(header.SEC_CH_UA_PLATFORM, Platform.Get(os).UnwrapOrDefault())
+	h.Insert(header.USER_AGENT, UserAgent.Get(os).UnwrapOrDefault())
+
+	return &h
+}
+
+// --- Per-request header pipeline (Variant.Headers) ---------------------------
+
+// DesktopApplier applies the desktop Chrome request-header pipeline. Wired into chrome.Desktop.
+var DesktopApplier = profiles.NewApplier(insertDesktopHeaders, insertDesktopHeaders, headerCache, false)
+
+// MobileApplier applies the mobile Chrome request-header pipeline. Wired into chrome.Mobile.
+var MobileApplier = profiles.NewApplier(insertMobileHeaders, insertMobileHeaders, headerCache, true)
+
+func insertDesktopHeaders[T ~string](headers *g.MapOrd[T, T], method string) {
+	switch method {
+	case http.MethodPost:
+		headers.Insert(header.ACCEPT, "*/*")
+		headers.Insert(header.CACHE_CONTROL, "no-cache")
+		headers.Insert(header.CONTENT_TYPE, "")
+		headers.Insert(header.CONTENT_LENGTH, "")
+		headers.Insert(header.PRAGMA, "no-cache")
+		headers.Insert(header.PRIORITY, "u=1, i")
+		headers.Insert(header.SEC_FETCH_DEST, "empty")
+		headers.Insert(header.SEC_FETCH_MODE, "cors")
+		headers.Insert(header.SEC_FETCH_SITE, "same-origin")
+	default:
+		headers.Insert(
+			header.ACCEPT,
+			"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+		)
+		headers.Insert(header.PRIORITY, "u=0, i")
+		headers.Insert(header.SEC_FETCH_DEST, "document")
+		headers.Insert(header.SEC_FETCH_MODE, "navigate")
+		headers.Insert(header.SEC_FETCH_SITE, "none")
+		headers.Insert(header.SEC_FETCH_USER, "?1")
+		headers.Insert(header.UPGRADE_INSECURE_REQUESTS, "1")
+	}
+}
+
+// insertMobileHeaders is a placeholder mobile variant. On the day the real Chrome Android header
+// inserts diverge from desktop, this function is the single point to substitute them.
+func insertMobileHeaders[T ~string](headers *g.MapOrd[T, T], method string) {
+	switch method {
+	case http.MethodPost:
+		headers.Insert(header.ACCEPT, "*/*")
+		headers.Insert(header.CACHE_CONTROL, "no-cache")
+		headers.Insert(header.CONTENT_TYPE, "")
+		headers.Insert(header.CONTENT_LENGTH, "")
+		headers.Insert(header.PRAGMA, "no-cache")
+		headers.Insert(header.PRIORITY, "u=1, i")
+		headers.Insert(header.SEC_FETCH_DEST, "empty")
+		headers.Insert(header.SEC_FETCH_MODE, "cors")
+		headers.Insert(header.SEC_FETCH_SITE, "same-origin")
+	default:
+		headers.Insert(
+			header.ACCEPT,
+			"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+		)
+		headers.Insert(header.PRIORITY, "u=0, i")
+		headers.Insert(header.SEC_FETCH_DEST, "document")
+		headers.Insert(header.SEC_FETCH_MODE, "navigate")
+		headers.Insert(header.SEC_FETCH_SITE, "none")
+		headers.Insert(header.SEC_FETCH_USER, "?1")
+		headers.Insert(header.UPGRADE_INSECURE_REQUESTS, "1")
+	}
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/tls.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/tls.go
new file mode 100644
index 00000000..253ed3b6
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/tls.go
@@ -0,0 +1,180 @@
+package chrome
+
+import utls "github.com/refraction-networking/utls"
+
+// ML-DSA (post-quantum) TLS 1.3 signature schemes that Chrome 152 advertises at the
+// head of its signature_algorithms list. utls does not yet name them, so they are
+// spelled as raw SignatureScheme code points (per the TLS ML-DSA draft). Without
+// them a Chrome-152 UA ships a pre-152 JA4, which some Akamai deployments reject.
+const (
+	MLDSA44 utls.SignatureScheme = 0x0904
+	MLDSA65 utls.SignatureScheme = 0x0905
+	MLDSA87 utls.SignatureScheme = 0x0906
+)
+
+// extensionTrustAnchors is the TLS Trust Anchor Identifiers extension
+// (draft-ietf-tls-trust-anchor-ids, code point 0xca34). Chrome 152 sends it on every
+// ClientHello, so its presence is part of the Chrome 152 JA4 (t13d1517h2_…); a hello
+// without it is a pre-152 fingerprint, which some Akamai deployments reject when the
+// UA claims Chrome 152.
+const extensionTrustAnchors uint16 = 0xca34
+
+// chrome152TrustAnchorIDs is the extension body Chrome 152 sends: a length-prefixed
+// TrustAnchorIdentifierList of the Chrome Root Store trust anchor IDs it advertises,
+// captured verbatim from a Google Chrome 152.0.7977 desktop ClientHello.
+//
+// The order matters and is not randomised. Chromium walks the compiled-in kChromeRootCertList
+// in array order (net/cert/internal/trust_store_chrome.cc), passes the bytes to
+// SSL_set1_requested_trust_anchors untouched, and BoringSSL writes them into the extension
+// verbatim — nothing shuffles the list the way the extension order is shuffled. So the order
+// is a compile-time constant of one Chrome build: stable across connections and hosts, but two
+// builds carrying different root store snapshots emit different orders for the same set of IDs.
+// These bytes must therefore come from a Google Chrome release, matching the branding the
+// profile claims in sec-ch-ua; a Chromium or ungoogled-chromium build of the same major
+// version is not interchangeable here.
+var chrome152TrustAnchorIDs = []byte{
+	0x00, 0xcc,
+	0x04, 0xd6, 0x79, 0x09, 0x06,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x07,
+	0x04, 0xd6, 0x79, 0x09, 0x0c,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x06,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x13,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x0d,
+	0x04, 0xd6, 0x79, 0x09, 0x01,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x0d,
+	0x04, 0xd6, 0x79, 0x09, 0x0d,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x0f,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x08,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x12,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x09,
+	0x04, 0xd6, 0x79, 0x09, 0x02,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x01,
+	0x04, 0xd6, 0x79, 0x09, 0x0e,
+	0x04, 0xd6, 0x79, 0x09, 0x09,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x0a,
+	0x04, 0xd6, 0x79, 0x09, 0x03,
+	0x04, 0xd6, 0x79, 0x09, 0x0f,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x0b,
+	0x04, 0xd6, 0x79, 0x09, 0x04,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x14,
+	0x04, 0xd6, 0x79, 0x09, 0x0a,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x13,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x12,
+	0x04, 0xd6, 0x79, 0x09, 0x07,
+	0x04, 0xd6, 0x79, 0x09, 0x08,
+	0x08, 0x83, 0x9a, 0x64, 0x8c, 0x9b, 0x2d, 0x01, 0x0c,
+	0x04, 0xd6, 0x79, 0x09, 0x05,
+	0x05, 0x82, 0xdf, 0x13, 0x02, 0x0e,
+	0x04, 0xd6, 0x79, 0x09, 0x0b,
+}
+
+// HelloChrome_152 mirrors HelloChrome_150 (ML-DSA signature schemes at the head of
+// signature_algorithms) and adds what Chrome 152 sends on top: a GREASE signature scheme
+// and the trust_anchors extension. Together with the per-connection extension shuffle
+// (Variant.ShuffleExtensions / JA.Chrome152) this reproduces a Chrome 152 desktop
+// ClientHello structurally, not just its JA4.
+//
+// The extension order declared below is Chrome's own order. It is never shuffled in place:
+// the shuffle runs per connection on a private clone at dial time, so this value stays a
+// stable reference point across runs.
+var HelloChrome_152 = utls.ClientHelloSpec{
+	CipherSuites: []uint16{
+		utls.GREASE_PLACEHOLDER,
+		utls.TLS_AES_128_GCM_SHA256,
+		utls.TLS_AES_256_GCM_SHA384,
+		utls.TLS_CHACHA20_POLY1305_SHA256,
+		utls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+		utls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+		utls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+		utls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+		utls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+		utls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+		utls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+		utls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+		utls.TLS_RSA_WITH_AES_128_GCM_SHA256,
+		utls.TLS_RSA_WITH_AES_256_GCM_SHA384,
+		utls.TLS_RSA_WITH_AES_128_CBC_SHA,
+		utls.TLS_RSA_WITH_AES_256_CBC_SHA,
+	},
+	CompressionMethods: []byte{0x00},
+	Extensions: []utls.TLSExtension{
+		&utls.UtlsGREASEExtension{},
+		&utls.SNIExtension{},
+		&utls.ExtendedMasterSecretExtension{},
+		&utls.RenegotiationInfoExtension{
+			Renegotiation: utls.RenegotiateOnceAsClient,
+		},
+		&utls.SupportedCurvesExtension{
+			Curves: []utls.CurveID{
+				utls.GREASE_PLACEHOLDER,
+				utls.X25519MLKEM768,
+				utls.X25519,
+				utls.CurveP256,
+				utls.CurveP384,
+			},
+		},
+		&utls.SupportedPointsExtension{
+			SupportedPoints: []byte{0x00},
+		},
+		&utls.SessionTicketExtension{},
+		&utls.ALPNExtension{
+			AlpnProtocols: []string{"h2", "http/1.1"},
+		},
+		&utls.StatusRequestExtension{},
+		&utls.SignatureAlgorithmsExtension{
+			SupportedSignatureAlgorithms: []utls.SignatureScheme{
+				// Chrome 152 GREASEs signature_algorithms; surf substitutes the
+				// placeholder with a random GREASE value per connection (see JA.getSpec).
+				utls.GREASE_PLACEHOLDER,
+				MLDSA44,
+				MLDSA65,
+				MLDSA87,
+				utls.ECDSAWithP256AndSHA256,
+				utls.PSSWithSHA256,
+				utls.PKCS1WithSHA256,
+				utls.ECDSAWithP384AndSHA384,
+				utls.PSSWithSHA384,
+				utls.PKCS1WithSHA384,
+				utls.PSSWithSHA512,
+				utls.PKCS1WithSHA512,
+			},
+		},
+		&utls.SCTExtension{},
+		&utls.KeyShareExtension{
+			KeyShares: []utls.KeyShare{
+				{Group: utls.GREASE_PLACEHOLDER, Data: []byte{0}},
+				{Group: utls.X25519MLKEM768},
+				{Group: utls.X25519},
+			},
+		},
+		&utls.PSKKeyExchangeModesExtension{
+			Modes: []uint8{
+				utls.PskModeDHE,
+			},
+		},
+		&utls.SupportedVersionsExtension{
+			Versions: []uint16{
+				utls.GREASE_PLACEHOLDER,
+				utls.VersionTLS13,
+				utls.VersionTLS12,
+			},
+		},
+		&utls.UtlsCompressCertExtension{
+			Algorithms: []utls.CertCompressionAlgo{
+				utls.CertCompressionBrotli,
+			},
+		},
+		&utls.ApplicationSettingsExtensionNew{
+			SupportedProtocols: []string{"h2"},
+		},
+		&utls.GenericExtension{Id: extensionTrustAnchors, Data: chrome152TrustAnchorIDs},
+		utls.BoringGREASEECH(),
+		&utls.UtlsGREASEExtension{},
+		&utls.UtlsPreSharedKeyExtension{},
+	},
+}
+
+// HelloChrome_152_Mobile is a placeholder mobile variant. On the day real Chrome Android 152
+// ClientHello bytes are observed, replace this body — it is the single point of substitution
+// for the mobile TLS fingerprint.
+var HelloChrome_152_Mobile = HelloChrome_152
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/transport.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/transport.go
new file mode 100644
index 00000000..58311e23
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/transport.go
@@ -0,0 +1,54 @@
+package chrome
+
+import (
+	"github.com/enetx/http2"
+	"github.com/enetx/surf/profiles"
+)
+
+// configureH2Desktop applies the desktop Chrome 152 HTTP/2 SETTINGS chain.
+func configureH2Desktop(h profiles.H2Config) {
+	h.HeaderTableSize(65536).
+		EnablePush(0).
+		InitialWindowSize(6291456).
+		MaxHeaderListSize(262144).
+		ConnectionFlow(15663105).
+		PriorityParam(http2.PriorityParam{
+			StreamDep: 0,
+			Exclusive: true,
+			Weight:    255,
+		})
+}
+
+// configureH2Mobile applies the placeholder mobile Chrome 152 HTTP/2 SETTINGS chain.
+// On the day real Chrome Android 152 H/2 settings are observed, replace this body.
+func configureH2Mobile(h profiles.H2Config) {
+	h.HeaderTableSize(65536).
+		EnablePush(0).
+		InitialWindowSize(6291456).
+		MaxHeaderListSize(262144).
+		ConnectionFlow(15663105).
+		PriorityParam(http2.PriorityParam{
+			StreamDep: 0,
+			Exclusive: true,
+			Weight:    255,
+		})
+}
+
+// configureH3Desktop applies the desktop Chrome 152 HTTP/3 SETTINGS chain.
+func configureH3Desktop(h profiles.H3Config) {
+	h.QpackMaxTableCapacity(65536).
+		MaxFieldSectionSize(262144).
+		QpackBlockedStreams(100).
+		SettingsH3Datagram(1).
+		Grease()
+}
+
+// configureH3Mobile applies the placeholder mobile Chrome 152 HTTP/3 SETTINGS chain.
+// On the day real Chrome Android 152 H/3 settings are observed, replace this body.
+func configureH3Mobile(h profiles.H3Config) {
+	h.QpackMaxTableCapacity(65536).
+		MaxFieldSectionSize(262144).
+		QpackBlockedStreams(100).
+		SettingsH3Datagram(1).
+		Grease()
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/ua.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/ua.go
new file mode 100644
index 00000000..ce84c644
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/ua.go
@@ -0,0 +1,32 @@
+package chrome
+
+import (
+	"github.com/enetx/g"
+	"github.com/enetx/surf/profiles"
+)
+
+// SecCHUA is the static value of the sec-ch-ua header for Chrome 152 (Chromium brand list).
+// If the mobile sec-ch-ua diverges from desktop, introduce SecCHUAMobile here and wire it into
+// chrome.Mobile in variant.go.
+const SecCHUA = `"Chromium";v="152", "Not?A_Brand";v="24", "Google Chrome";v="152"`
+
+// UserAgent maps every supported impersonated OS to its Chrome 152 User-Agent string.
+// It is shared between Desktop and Mobile variants — UA strings are an OS property, not a
+// form-factor property (Chrome on Android always identifies as mobile, Chrome on Windows
+// always as desktop, regardless of which fingerprint variant is dispatched).
+var UserAgent = g.Map[profiles.OSKey, g.String]{
+	profiles.Windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+	profiles.MacOS:   "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+	profiles.Linux:   "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+	profiles.Android: "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Mobile Safari/537.36",
+	profiles.IOS:     "Mozilla/5.0 (iPad; CPU OS 26_3_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/152.0.7977.53 Mobile/15E148 Safari/604.1",
+}
+
+// Platform maps every supported impersonated OS to its sec-ch-ua-platform header value.
+var Platform = g.Map[profiles.OSKey, g.String]{
+	profiles.Windows: `"Windows"`,
+	profiles.MacOS:   `"macOS"`,
+	profiles.Linux:   `"Linux"`,
+	profiles.Android: `"Android"`,
+	profiles.IOS:     `"iOS"`,
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/chrome/variant.go b/backend/vendor/github.com/enetx/surf/profiles/chrome/variant.go
new file mode 100644
index 00000000..4c38b7a2
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/chrome/variant.go
@@ -0,0 +1,27 @@
+package chrome
+
+import "github.com/enetx/surf/profiles"
+
+// Desktop is the Chrome 152 desktop variant - current production fingerprint.
+var Desktop = profiles.Variant{
+	HelloSpec:         &HelloChrome_152,
+	ShuffleExtensions: true,
+	Boundary:          Boundary,
+	ConfigureH2:       configureH2Desktop,
+	ConfigureH3:       configureH3Desktop,
+	BuildHeaders:      buildHeadersDesktop,
+	Headers:           DesktopApplier,
+}
+
+// Mobile is a placeholder Chrome 152 mobile variant. On the day real Chrome Android 152 bytes
+// are observed, replace HelloChrome_152_Mobile, configureH2Mobile, configureH3Mobile and
+// buildHeadersMobile bodies — the variant fields below stay as-is.
+var Mobile = profiles.Variant{
+	HelloSpec:         &HelloChrome_152_Mobile,
+	ShuffleExtensions: true,
+	Boundary:          Boundary,
+	ConfigureH2:       configureH2Mobile,
+	ConfigureH3:       configureH3Mobile,
+	BuildHeaders:      buildHeadersMobile,
+	Headers:           MobileApplier,
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/boundary.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/boundary.go
new file mode 100644
index 00000000..7bc97ff8
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/boundary.go
@@ -0,0 +1,43 @@
+package firefox
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+
+	"github.com/enetx/g"
+)
+
+// Firefox implementation: https://github.com/mozilla/gecko-dev/blob/master/dom/html/HTMLFormSubmission.cpp#L355
+func Boundary() g.String {
+	// C++
+	// mBoundary.AssignLiteral("----geckoformboundary");
+	// mBoundary.AppendInt(mozilla::RandomUint64OrDie(), 16);
+	// mBoundary.AppendInt(mozilla::RandomUint64OrDie(), 16);
+
+	// prefix := "----geckoformboundary"
+	// var num1, num2 uint64
+	// binary.Read(rand.Reader, binary.BigEndian, &num1)
+	// binary.Read(rand.Reader, binary.BigEndian, &num2)
+	// return g.Sprintf("%s%x%x", prefix, num1, num2)
+
+	////////////////////////////////////////////////////////////////////////////
+
+	// C++
+	// mBoundary.AssignLiteral("---------------------------");
+	// mBoundary.AppendInt(static_cast<uint32_t>(mozilla::RandomUint64OrDie()));
+	// mBoundary.AppendInt(static_cast<uint32_t>(mozilla::RandomUint64OrDie()));
+	// mBoundary.AppendInt(static_cast<uint32_t>(mozilla::RandomUint64OrDie()));
+
+	prefix := g.String("---------------------------")
+
+	var builder g.Builder
+	builder.WriteString(prefix)
+
+	for range 3 {
+		var b [4]byte
+		rand.Read(b[:])
+		builder.WriteString(g.Int(binary.LittleEndian.Uint32(b[:])).String())
+	}
+
+	return builder.String()
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/headers.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/headers.go
new file mode 100644
index 00000000..23305469
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/headers.go
@@ -0,0 +1,290 @@
+package firefox
+
+import (
+	"net/http"
+
+	"github.com/enetx/g"
+	"github.com/enetx/surf/header"
+	"github.com/enetx/surf/profiles"
+)
+
+// --- Header order maps -------------------------------------------------------
+
+var headerOrderDesktop = g.Map[string, g.Slice[string]]{
+	http.MethodGet: {
+		":method",
+		":path",
+		":authority",
+		":scheme",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.AUTHORIZATION,
+		header.COOKIE,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_USER,
+		header.PRIORITY,
+	},
+
+	http.MethodGet + "http3": {
+		":method",
+		":scheme",
+		":authority",
+		":path",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.AUTHORIZATION,
+		header.COOKIE,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_USER,
+		header.PRIORITY,
+	},
+
+	http.MethodPost: {
+		":method",
+		":path",
+		":authority",
+		":scheme",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.CONTENT_TYPE,
+		header.AUTHORIZATION,
+		header.CONTENT_LENGTH,
+		header.ORIGIN,
+		header.COOKIE,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.PRIORITY,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+	},
+
+	http.MethodPost + "http3": {
+		":method",
+		":scheme",
+		":authority",
+		":path",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.CONTENT_TYPE,
+		header.AUTHORIZATION,
+		header.CONTENT_LENGTH,
+		header.ORIGIN,
+		header.COOKIE,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.PRIORITY,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+	},
+}
+
+// headerOrderMobile is a placeholder mobile variant. On the day real Firefox Android header
+// ordering is observed, this map is the single point to substitute it without touching desktop.
+// The literal is a physical copy of headerOrderDesktop so the two maps can diverge independently.
+var headerOrderMobile = g.Map[string, g.Slice[string]]{
+	http.MethodGet: {
+		":method",
+		":path",
+		":authority",
+		":scheme",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.AUTHORIZATION,
+		header.COOKIE,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_USER,
+		header.PRIORITY,
+	},
+
+	http.MethodGet + "http3": {
+		":method",
+		":scheme",
+		":authority",
+		":path",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.AUTHORIZATION,
+		header.COOKIE,
+		header.UPGRADE_INSECURE_REQUESTS,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.SEC_FETCH_USER,
+		header.PRIORITY,
+	},
+
+	http.MethodPost: {
+		":method",
+		":path",
+		":authority",
+		":scheme",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.CONTENT_TYPE,
+		header.AUTHORIZATION,
+		header.CONTENT_LENGTH,
+		header.ORIGIN,
+		header.COOKIE,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.PRIORITY,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+	},
+
+	http.MethodPost + "http3": {
+		":method",
+		":scheme",
+		":authority",
+		":path",
+		header.USER_AGENT,
+		header.ACCEPT,
+		header.ACCEPT_LANGUAGE,
+		header.ACCEPT_ENCODING,
+		header.REFERER,
+		header.CONTENT_TYPE,
+		header.AUTHORIZATION,
+		header.CONTENT_LENGTH,
+		header.ORIGIN,
+		header.COOKIE,
+		header.SEC_FETCH_DEST,
+		header.SEC_FETCH_MODE,
+		header.SEC_FETCH_SITE,
+		header.PRIORITY,
+		header.PRAGMA,
+		header.CACHE_CONTROL,
+	},
+}
+
+var headerCache = profiles.NewHeaderCache(headerOrderDesktop, headerOrderMobile)
+
+// --- Static header set (Variant.BuildHeaders) --------------------------------
+
+// buildHeadersDesktop constructs the desktop Firefox 148 request header set.
+// Firefox does not emit Client Hints UA-CH headers (sec-ch-ua / sec-ch-ua-mobile /
+// sec-ch-ua-platform).
+func buildHeadersDesktop(os profiles.OSKey) *g.MapOrd[g.String, g.String] {
+	h := g.NewMapOrd[g.String, g.String]()
+	h.Insert(":authority", "")
+	h.Insert(":method", "")
+	h.Insert(":path", "")
+	h.Insert(":scheme", "")
+	h.Insert(header.ACCEPT_ENCODING, "gzip, deflate, br, zstd")
+	h.Insert(header.ACCEPT_LANGUAGE, "en-US,en;q=0.5")
+	h.Insert(header.AUTHORIZATION, "")
+	h.Insert(header.COOKIE, "")
+	h.Insert(header.ORIGIN, "")
+	h.Insert(header.REFERER, "")
+	h.Insert(header.USER_AGENT, UserAgent.Get(os).UnwrapOrDefault())
+
+	return &h
+}
+
+// buildHeadersMobile constructs the placeholder mobile Firefox 148 request header set.
+// On the day real Firefox Android header set diverges from desktop, replace this body — it is
+// the single point of substitution for the entire mobile header set.
+func buildHeadersMobile(os profiles.OSKey) *g.MapOrd[g.String, g.String] {
+	h := g.NewMapOrd[g.String, g.String]()
+	h.Insert(":authority", "")
+	h.Insert(":method", "")
+	h.Insert(":path", "")
+	h.Insert(":scheme", "")
+	h.Insert(header.ACCEPT_ENCODING, "gzip, deflate, br, zstd")
+	h.Insert(header.ACCEPT_LANGUAGE, "en-US,en;q=0.5")
+	h.Insert(header.AUTHORIZATION, "")
+	h.Insert(header.COOKIE, "")
+	h.Insert(header.ORIGIN, "")
+	h.Insert(header.REFERER, "")
+	h.Insert(header.USER_AGENT, UserAgent.Get(os).UnwrapOrDefault())
+
+	return &h
+}
+
+// --- Per-request header pipeline (Variant.Headers) ---------------------------
+
+// DesktopApplier applies the desktop Firefox request-header pipeline. Wired into firefox.Desktop.
+var DesktopApplier = profiles.NewApplier(insertDesktopHeaders, insertDesktopHeaders, headerCache, false)
+
+// MobileApplier applies the mobile Firefox request-header pipeline. Wired into firefox.Mobile.
+var MobileApplier = profiles.NewApplier(insertMobileHeaders, insertMobileHeaders, headerCache, true)
+
+func insertDesktopHeaders[T ~string](headers *g.MapOrd[T, T], method string) {
+	switch method {
+	case http.MethodPost:
+		headers.Insert(header.ACCEPT, "*/*")
+		headers.Insert(header.CACHE_CONTROL, "no-cache")
+		headers.Insert(header.CONTENT_TYPE, "")
+		headers.Insert(header.CONTENT_LENGTH, "")
+		headers.Insert(header.PRAGMA, "no-cache")
+		headers.Insert(header.PRIORITY, "u=1, i")
+		headers.Insert(header.SEC_FETCH_DEST, "empty")
+		headers.Insert(header.SEC_FETCH_MODE, "cors")
+		headers.Insert(header.SEC_FETCH_SITE, "same-origin")
+	default:
+		headers.Insert(header.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+		headers.Insert(header.PRIORITY, "u=0, i")
+		headers.Insert(header.SEC_FETCH_DEST, "document")
+		headers.Insert(header.SEC_FETCH_MODE, "navigate")
+		headers.Insert(header.SEC_FETCH_SITE, "none")
+		headers.Insert(header.SEC_FETCH_USER, "?1")
+		headers.Insert(header.UPGRADE_INSECURE_REQUESTS, "1")
+	}
+}
+
+// insertMobileHeaders is a placeholder mobile variant. On the day the real Firefox Android header
+// inserts diverge from desktop, this function is the single point to substitute them.
+func insertMobileHeaders[T ~string](headers *g.MapOrd[T, T], method string) {
+	switch method {
+	case http.MethodPost:
+		headers.Insert(header.ACCEPT, "*/*")
+		headers.Insert(header.CACHE_CONTROL, "no-cache")
+		headers.Insert(header.CONTENT_TYPE, "")
+		headers.Insert(header.CONTENT_LENGTH, "")
+		headers.Insert(header.PRAGMA, "no-cache")
+		headers.Insert(header.PRIORITY, "u=1, i")
+		headers.Insert(header.SEC_FETCH_DEST, "empty")
+		headers.Insert(header.SEC_FETCH_MODE, "cors")
+		headers.Insert(header.SEC_FETCH_SITE, "same-origin")
+	default:
+		headers.Insert(header.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+		headers.Insert(header.PRIORITY, "u=0, i")
+		headers.Insert(header.SEC_FETCH_DEST, "document")
+		headers.Insert(header.SEC_FETCH_MODE, "navigate")
+		headers.Insert(header.SEC_FETCH_SITE, "none")
+		headers.Insert(header.SEC_FETCH_USER, "?1")
+		headers.Insert(header.UPGRADE_INSECURE_REQUESTS, "1")
+	}
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/tls.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/tls.go
new file mode 100644
index 00000000..acb133fc
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/tls.go
@@ -0,0 +1,10 @@
+package firefox
+
+import utls "github.com/refraction-networking/utls"
+
+// HelloFirefox_148 is the desktop ClientHelloID for Firefox 148.
+var HelloFirefox_148 = utls.HelloFirefox_148
+
+// HelloFirefox_148_Mobile is a placeholder mobile variant; functionally identical to the desktop
+// ClientHelloID until real Firefox Android bytes are observed and substituted here.
+var HelloFirefox_148_Mobile = utls.HelloFirefox_148
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/transport.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/transport.go
new file mode 100644
index 00000000..34c030a9
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/transport.go
@@ -0,0 +1,58 @@
+package firefox
+
+import (
+	"github.com/enetx/http2"
+	"github.com/enetx/surf/profiles"
+)
+
+// configureH2Desktop applies the desktop Firefox 148 HTTP/2 SETTINGS chain.
+func configureH2Desktop(h profiles.H2Config) {
+	h.InitialStreamID(3).
+		HeaderTableSize(65536).
+		EnablePush(0).
+		InitialWindowSize(131072).
+		MaxFrameSize(16384).
+		ConnectionFlow(12517377).
+		PriorityParam(http2.PriorityParam{
+			StreamDep: 0,
+			Exclusive: false,
+			Weight:    41,
+		})
+}
+
+// configureH2Mobile applies the placeholder mobile Firefox 148 HTTP/2 SETTINGS chain.
+// On the day real Firefox Android 148 H/2 settings are observed, replace this body.
+func configureH2Mobile(h profiles.H2Config) {
+	h.InitialStreamID(3).
+		HeaderTableSize(65536).
+		EnablePush(0).
+		InitialWindowSize(131072).
+		MaxFrameSize(16384).
+		ConnectionFlow(12517377).
+		PriorityParam(http2.PriorityParam{
+			StreamDep: 0,
+			Exclusive: false,
+			Weight:    41,
+		})
+}
+
+// configureH3Desktop applies the desktop Firefox 148 HTTP/3 SETTINGS chain.
+func configureH3Desktop(h profiles.H3Config) {
+	h.QpackMaxTableCapacity(65536).
+		QpackBlockedStreams(20).
+		EnableWebtransport(0).
+		H3Datagram(1).
+		SettingsH3Datagram(1).
+		EnableConnectProtocol(1)
+}
+
+// configureH3Mobile applies the placeholder mobile Firefox 148 HTTP/3 SETTINGS chain.
+// On the day real Firefox Android 148 H/3 settings are observed, replace this body.
+func configureH3Mobile(h profiles.H3Config) {
+	h.QpackMaxTableCapacity(65536).
+		QpackBlockedStreams(20).
+		EnableWebtransport(0).
+		H3Datagram(1).
+		SettingsH3Datagram(1).
+		EnableConnectProtocol(1)
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/ua.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/ua.go
new file mode 100644
index 00000000..a6b195b8
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/ua.go
@@ -0,0 +1,17 @@
+package firefox
+
+import (
+	"github.com/enetx/g"
+	"github.com/enetx/surf/profiles"
+)
+
+// UserAgent maps every supported impersonated OS to its Firefox 148 User-Agent string.
+// Shared between Desktop and Mobile variants — UA strings are an OS property, not a
+// form-factor property. iOS Firefox uses the FxiOS variant (under the hood it is WebKit).
+var UserAgent = g.Map[profiles.OSKey, g.String]{
+	profiles.Windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0",
+	profiles.MacOS:   "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:148.0) Gecko/20100101 Firefox/148.0",
+	profiles.Linux:   "Mozilla/5.0 (X11; Linux x86_64; rv:148.0) Gecko/20100101 Firefox/148.0",
+	profiles.Android: "Mozilla/5.0 (Android 16; Mobile; rv:148.0) Gecko/148.0 Firefox/148.0",
+	profiles.IOS:     "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/148.0 Mobile/15E148 Safari/605.1.15",
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/firefox/variant.go b/backend/vendor/github.com/enetx/surf/profiles/firefox/variant.go
new file mode 100644
index 00000000..d7a5ba11
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/firefox/variant.go
@@ -0,0 +1,25 @@
+package firefox
+
+import "github.com/enetx/surf/profiles"
+
+// Desktop is the Firefox 148 desktop variant — current production fingerprint.
+var Desktop = profiles.Variant{
+	HelloID:      HelloFirefox_148,
+	Boundary:     Boundary,
+	ConfigureH2:  configureH2Desktop,
+	ConfigureH3:  configureH3Desktop,
+	BuildHeaders: buildHeadersDesktop,
+	Headers:      DesktopApplier,
+}
+
+// Mobile is a placeholder Firefox 148 mobile variant. On the day real Firefox Android 148 bytes
+// are observed, replace HelloFirefox_148_Mobile, configureH2Mobile, configureH3Mobile and
+// buildHeadersMobile bodies — the variant fields below stay as-is.
+var Mobile = profiles.Variant{
+	HelloID:      HelloFirefox_148_Mobile,
+	Boundary:     Boundary,
+	ConfigureH2:  configureH2Mobile,
+	ConfigureH3:  configureH3Mobile,
+	BuildHeaders: buildHeadersMobile,
+	Headers:      MobileApplier,
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/headers.go b/backend/vendor/github.com/enetx/surf/profiles/headers.go
new file mode 100644
index 00000000..1f700d07
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/headers.go
@@ -0,0 +1,100 @@
+package profiles
+
+import (
+	"sync"
+
+	"github.com/enetx/g"
+	"github.com/enetx/g/cmp"
+)
+
+// HeadersApplier applies the browser-specific request-header pipeline (insert defaults +
+// reorder by header-order map) to a request header map. Form-factor (desktop/mobile) is baked
+// into each applier instance — Variant.Desktop and Variant.Mobile carry different appliers.
+type HeadersApplier func(headers any, method string)
+
+// HeadersFn is the type of a generic headers function instantiated for a concrete T ~string.
+type HeadersFn[T ~string] func(*g.MapOrd[T, T], string)
+
+// NewApplier wraps a browser-specific header-insert pair with the standard "insert, then
+// reorder by per-method enum" pipeline shared by every profile. The form factor (desktop/mobile)
+// is baked in via cache.Enums(mobile); the lookup runs on each call so HeaderCache lazy-init is
+// preserved.
+//
+// The constructor takes the two concrete HeadersFn instantiations as separate parameters so
+// callers can pass the same generic function twice and let Go infer T at each site.
+func NewApplier(
+	insertG HeadersFn[g.String],
+	insertS HeadersFn[string],
+	cache *HeaderCache,
+	mobile bool,
+) HeadersApplier {
+	return func(h any, method string) {
+		switch v := h.(type) {
+		case *g.MapOrd[g.String, g.String]:
+			insertG(v, method)
+			SortByOrder(v, method, cache.Enums(mobile))
+		case *g.MapOrd[string, string]:
+			insertS(v, method)
+			SortByOrder(v, method, cache.Enums(mobile))
+		}
+	}
+}
+
+// HeaderCache lazily builds and caches per-method header-position enums for both desktop and
+// mobile header-order maps. Each browser profile constructs one HeaderCache from its own
+// headerOrderDesktop / headerOrderMobile literals. The dispatcher asks for enums via Enums(mobile).
+type HeaderCache struct {
+	desktopOrder g.Map[string, g.Slice[string]]
+	mobileOrder  g.Map[string, g.Slice[string]]
+
+	desktopEnums g.Map[string, g.MapOrd[string, g.Int]]
+	mobileEnums  g.Map[string, g.MapOrd[string, g.Int]]
+
+	onceDesktop sync.Once
+	onceMobile  sync.Once
+}
+
+// NewHeaderCache wires the cache to two header-order maps. Enums are built on first access.
+func NewHeaderCache(desktop, mobile g.Map[string, g.Slice[string]]) *HeaderCache {
+	return &HeaderCache{desktopOrder: desktop, mobileOrder: mobile}
+}
+
+// Enums returns the desktop or mobile enum map (lazy-built on first call).
+func (c *HeaderCache) Enums(mobile bool) g.Map[string, g.MapOrd[string, g.Int]] {
+	if mobile {
+		c.onceMobile.Do(func() { c.mobileEnums = buildHeaderEnums(c.mobileOrder) })
+		return c.mobileEnums
+	}
+
+	c.onceDesktop.Do(func() { c.desktopEnums = buildHeaderEnums(c.desktopOrder) })
+	return c.desktopEnums
+}
+
+func buildHeaderEnums(order g.Map[string, g.Slice[string]]) g.Map[string, g.MapOrd[string, g.Int]] {
+	enums := g.NewMap[string, g.MapOrd[string, g.Int]]()
+
+	for method, headers := range order {
+		h := g.NewMapOrd[string, g.Int]()
+		headers.Iter().Enumerate().
+			ForEach(func(k g.Int, v string) {
+				h.Insert(v, k)
+			})
+
+		enums[method] = h
+	}
+
+	return enums
+}
+
+// SortByOrder reorders headers in-place according to the per-method enum positions returned
+// by HeaderCache.Enums. Profile packages call it from headersDesktop / headersMobile after the
+// browser-specific Insert step. Falls back to the GET enum when method is not present.
+func SortByOrder[T ~string](h *g.MapOrd[T, T], method string, enums g.Map[string, g.MapOrd[string, g.Int]]) {
+	enum := enums.Get(method).UnwrapOr(enums["GET"])
+
+	h.SortByKey(func(a, b T) cmp.Ordering {
+		ida := enum.Get(string(a))
+		idb := enum.Get(string(b))
+		return ida.UnwrapOrDefault().Cmp(idb.UnwrapOrDefault())
+	})
+}
diff --git a/backend/vendor/github.com/enetx/surf/profiles/profile.go b/backend/vendor/github.com/enetx/surf/profiles/profile.go
new file mode 100644
index 00000000..a13df30c
--- /dev/null
+++ b/backend/vendor/github.com/enetx/surf/profiles/profile.go
@@ -0,0 +1,102 @@
+// Package profiles defines the shared variant contract used by browser profile packages
+// (profiles/chrome, profiles/firefox, ...) and consumed by the top-level surf package.
+//
+// A Variant is the self-contained description of one browser and form-factor combination:
+// TLS ClientHello, HTTP/2 + HTTP/3 SETTINGS, header set, User-Agent / sec-ch-ua data per OS.
+// The surf.Impersonate dispatcher reads chrome.Desktop / chrome.Mobile / firefox.Desktop /
+// firefox.Mobile values, applies the static fields, and runs ConfigureH2/ConfigureH3 against
+// adapters that satisfy H2Config / H3Config — without the profile package importing surf.
+package profiles
+
+import (
+	"github.com/enetx/g"
+	"github.com/enetx/http2"
+	utls "github.com/refraction-networking/utls"
+)
+
+// OSKey identifies the impersonated operating system. Surf's Impersonate stores it directly
+// (no separate ImpersonateOS enum). Profile packages use it as a lookup key for UA / Platform.
+type OSKey int
+
+const (
+	Windows OSKey = iota
+	MacOS
+	Linux
+	Android
+	IOS
+)
+
+// IsMobile reports whether the OS is a mobile form factor (Android or iOS).
+func (k OSKey) IsMobile() bool { return k == Android || k == IOS }
+
+// Mobile returns the value of the sec-ch-ua-mobile header: "?1" for mobile OS, "?0" otherwise.
+func (k OSKey) Mobile() g.String {
+	if k.IsMobile() {
+		return "?1"
+	}
+
+	return "?0"
+}
+
+// H2Config is the fluent contract used by profile.ConfigureH2 callbacks. It mirrors the
+// methods on surf.HTTP2Settings, the surf package provides an adapter that satisfies it.
+type H2Config interface {
+	HeaderTableSize(uint32) H2Config
+	EnablePush(uint32) H2Config
+	MaxConcurrentStreams(uint32) H2Config
+	InitialWindowSize(uint32) H2Config
+	MaxFrameSize(uint32) H2Config
+	MaxHeaderListSize(uint32) H2Config
+	NoRFC7540Priorities(uint32) H2Config
+	ConnectionFlow(uint32) H2Config
+	InitialStreamID(uint32) H2Config
+	PriorityParam(http2.PriorityParam) H2Config
+	PriorityFrames([]http2.PriorityFrame) H2Config
+}
+
+// H3Config is the fluent contract used by profile.ConfigureH3 callbacks. It mirrors the
+// methods on surf.HTTP3Settings, the surf package provides an adapter that satisfies it.
+type H3Config interface {
+	QpackMaxTableCapacity(uint64) H3Config
+	MaxFieldSectionSize(uint64) H3Config
+	QpackBlockedStreams(uint64) H3Config
+	EnableConnectProtocol(uint64) H3Config
+	SettingsH3Datagram(uint64) H3Config
+	H3Datagram(uint64) H3Config
+	EnableWebtransport(uint64) H3Config
+	Grease() H3Config
+}
+
+// Variant is a self-contained description of one browser and form-factor combination.
+type Variant struct {
+	// HelloSpec takes precedence over HelloID when non-nil.
+	HelloSpec *utls.ClientHelloSpec
+	HelloID   utls.ClientHelloID
+
+	// ShuffleExtensions re-shuffles HelloSpec's extension order on every connection, as
+	// Chromium does since v110. Firefox keeps a fixed order.
+	ShuffleExtensions bool
+
+	// Boundary is the multipart boundary generator for this browser. Same reference for both
+	// Desktop and Mobile within one profile package (boundary is a per-browser property).
+	Boundary func() g.String
+
+	// ConfigureH2 / ConfigureH3 own the fluent SETTINGS chain as code. The surf dispatcher
+	// invokes them with adapters and calls Set() afterwards.
+	ConfigureH2 func(H2Config)
+	ConfigureH3 func(H3Config)
+
+	// BuildHeaders constructs the full ordered header map for one request — pseudo-headers,
+	// Accept-Encoding, Accept-Language, authorization/cookie/origin/referer placeholders,
+	// sec-ch-ua-* (Chromium only), User-Agent. Profile packages provide one BuildHeaders per
+	// Variant so each browser and form-factor has its own single point of substitution for the
+	// entire header set (set, values, and order are all browser-specific).
+	BuildHeaders func(OSKey) *g.MapOrd[g.String, g.String]
+
+	// Headers applies the per-request header-order pipeline (the same Headers[T ~string]
+	// function profile packages export) for the surf request path. Same value for Desktop and
+	// Mobile within one profile package — header pipeline differs by mobile bool, not by
+	// Variant — but living on Variant lets surf.Builder route through one indirection without
+	// importing concrete profile packages from the request hot path.
+	Headers HeadersApplier
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/.gitignore b/backend/vendor/github.com/quic-go/quic-go/.gitignore
new file mode 100644
index 00000000..60571ed0
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/.gitignore
@@ -0,0 +1,20 @@
+debug
+debug.test
+main
+mockgen_tmp.go
+*.qtr
+*.qlog
+*.sqlog
+*.txt
+race.[0-9]*
+
+fuzzing/*/*.zip
+fuzzing/*/coverprofile
+fuzzing/*/crashers
+fuzzing/*/sonarprofile
+fuzzing/*/suppressions
+fuzzing/*/corpus/
+
+**/testdata/fuzz/
+
+gomock_reflect_*/
diff --git a/backend/vendor/github.com/quic-go/quic-go/.golangci.yml b/backend/vendor/github.com/quic-go/quic-go/.golangci.yml
new file mode 100644
index 00000000..82bf4fc9
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/.golangci.yml
@@ -0,0 +1,99 @@
+version: "2"
+linters:
+  default: none
+  enable:
+    - asciicheck
+    - copyloopvar
+    - depguard
+    - exhaustive
+    - govet
+    - ineffassign
+    - misspell
+    - nolintlint
+    - prealloc
+    - staticcheck
+    - unconvert
+    - unparam
+    - unused
+    - usetesting
+  settings:
+    depguard:
+      rules:
+        random:
+          deny:
+            - pkg: "math/rand$"
+              desc: use math/rand/v2
+            - pkg: "golang.org/x/exp/rand"
+              desc: use math/rand/v2
+        quicvarint:
+          list-mode: strict
+          files:
+            - '**/github.com/quic-go/quic-go/quicvarint/*'
+            - '!$test'
+          allow:
+            - $gostd
+        rsa:
+          list-mode: original
+          deny:
+            - pkg: crypto/rsa
+              desc: "use crypto/ed25519 instead"
+        ginkgo:
+          list-mode: original
+          deny:
+            - pkg: github.com/onsi/ginkgo
+              desc: "use standard Go tests"
+            - pkg: github.com/onsi/ginkgo/v2
+              desc: "use standard Go tests"
+            - pkg: github.com/onsi/gomega
+              desc: "use standard Go tests"
+        http3-internal:
+          list-mode: lax
+          files:
+            - '**/http3/**'
+          deny:
+            - pkg: 'github.com/quic-go/quic-go/internal'
+              desc: 'no dependency on quic-go/internal'
+    misspell:
+      ignore-rules:
+        - ect
+    # see https://github.com/ldez/usetesting/issues/10
+    usetesting:
+      context-background: false
+      context-todo: false
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - depguard
+        path: internal/qtls
+      - linters:
+          - exhaustive
+          - prealloc
+          - unparam
+        path: _test\.go
+      - linters:
+          - staticcheck
+        path: _test\.go
+        text: 'SA1029:' # inappropriate key in call to context.WithValue
+    paths:
+      - internal/handshake/cipher_suite.go
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - internal/handshake/cipher_suite.go
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/backend/vendor/github.com/quic-go/quic-go/FIPS140.md b/backend/vendor/github.com/quic-go/quic-go/FIPS140.md
new file mode 100644
index 00000000..7d7d92e8
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/FIPS140.md
@@ -0,0 +1,37 @@
+# FIPS 140-3
+
+quic-go relies on the Go standard library for cryptography, including the Go Cryptographic Module described in [The FIPS 140-3 Go Cryptographic Module](https://go.dev/blog/fips140). quic-go does not seek separate FIPS 140-3 validation as a cryptographic module. This document explains how quic-go uses Go standard library cryptography for QUIC operations relevant to FIPS 140-3.
+
+Starting with quic-go v0.60, the behavior described here applies when built with Go 1.26 or newer. With older Go versions, quic-go still builds and runs as usual, without any attempt to meet FIPS 140 requirements.
+
+## QUIC operations relevant to FIPS 140-3
+
+quic-go delegates the TLS 1.3 handshake, certificate handling, cipher suite selection, session tickets, and the TLS key schedule to `crypto/tls`. When Go's FIPS 140-3 mode is active, `crypto/tls` restricts the algorithms it negotiates.
+
+### Packet protection AEADs
+
+The main quic-go-specific FIPS-relevant operations are the AEADs protecting Handshake, 0-RTT, and 1-RTT packets.
+
+AES-GCM packet protection AEADs are constructed through the Go standard library's TLS 1.3 AES-GCM implementation. Today this uses `go:linkname` to call the unexported `crypto/tls.aeadAESGCMTLS13`, because the standard library does not yet expose a QUIC-specific constructor; see [golang/go#79219](https://github.com/golang/go/issues/79219).
+
+ChaCha20-Poly1305 is not used in Go's FIPS 140-3 mode. `crypto/tls` avoids that cipher suite during negotiation, and quic-go additionally guards its internal ChaCha20-Poly1305 path when FIPS 140-3 mode is enabled.
+
+### Header protection
+
+For Handshake, 0-RTT, and 1-RTT packets protected with AES cipher suites, header protection keys are derived with `crypto/hkdf` and the AES block operation uses `crypto/aes`. ChaCha20 header protection is tied to the ChaCha20-Poly1305 cipher suite and is not reachable in FIPS 140-3 mode.
+
+### Address validation tokens
+
+quic-go encrypts the address validation tokens it sends in Retry packets and NEW_TOKEN frames. These are not TLS session tickets (those are handled by `crypto/tls`); they carry server-defined state such as the client address, timestamp, RTT information, and Retry connection IDs.
+
+Token-protection keys are derived with `crypto/hkdf`, AES is used via `crypto/aes`, and the token AEAD is constructed with `cipher.NewGCMWithRandomNonce`, keeping token encryption on standard library primitives.
+
+## QUIC operations not relevant to FIPS 140-3
+
+### Initial packet protection
+
+Initial packet protection (including Initial header protection) is not treated as FIPS 140-relevant confidentiality protection: the Initial secrets are derived from constants in RFC 9001 and the packet's destination connection ID, so any observer can derive the same keys. quic-go therefore disables strict FIPS 140 enforcement around Initial packet construction in Go 1.26 FIPS 140-3 mode. See the IETF QUIC mailing list discussion at <https://mailarchive.ietf.org/arch/msg/quic/k2kl2W_n5WDEZBbt3O31Ef2XBbM/>.
+
+### Retry packet integrity tag
+
+RFC 9001 defines the Retry packet integrity tag using fixed keys and nonces. It guards against accidental corruption and casual injection but does not encrypt packet contents. quic-go treats it as outside the FIPS 140 scope and disables strict FIPS 140 enforcement for that AEAD construction in Go 1.26 FIPS 140-3 mode.
diff --git a/backend/vendor/github.com/quic-go/quic-go/FUZZING.md b/backend/vendor/github.com/quic-go/quic-go/FUZZING.md
new file mode 100644
index 00000000..2662a193
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/FUZZING.md
@@ -0,0 +1,59 @@
+# Fuzzing
+
+[![Documentation](https://img.shields.io/badge/OSS--Fuzz-Introspector-red?style=flat)](https://introspector.oss-fuzz.com/project-profile?project=quic-go)
+[![ClusterFuzz coverage](https://img.shields.io/codecov/c/github/quic-go/quic-go/master.svg?flag=clusterfuzz&label=ClusterFuzz%20coverage&logo=codecov&logoColor=white&style=flat)](https://app.codecov.io/gh/quic-go/quic-go?flags%5B0%5D=clusterfuzz)
+[![ClusterFuzz Lite Batch coverage](https://img.shields.io/codecov/c/github/quic-go/quic-go/master.svg?flag=clusterfuzz-lite-batch&label=ClusterFuzz%20Lite%20Batch%20coverage&logo=codecov&logoColor=white&style=flat)](https://app.codecov.io/gh/quic-go/quic-go?flags%5B0%5D=clusterfuzz-lite-batch)
+
+Run the commands below from a local [`google/oss-fuzz`](https://github.com/google/oss-fuzz) checkout.
+Fuzz target names match the binary names listed in `oss-fuzz.sh` (for example, `frame_fuzzer_v2`).
+
+Update the base images:
+```sh
+python3 infra/helper.py pull_images
+```
+
+## Running fuzzers locally
+
+The following steps run a single fuzz target and then open its line-by-line coverage in `go tool cover`.
+
+```sh
+export DOCKER_DEFAULT_PLATFORM=linux/amd64
+export FUZZ_TARGET=<fuzz_target>
+export CORPUS_DIR=corpus/$FUZZ_TARGET
+
+mkdir -p "$CORPUS_DIR"
+
+python3 infra/helper.py build_image --no-pull quic-go
+python3 infra/helper.py build_fuzzers --sanitizer address quic-go
+python3 infra/helper.py run_fuzzer --corpus-dir="$CORPUS_DIR" quic-go "$FUZZ_TARGET"
+```
+
+Leave `run_fuzzer` running for a while to build up a corpus. It unpacks the seed corpus zip into the corpus directory and appends new entries as it discovers them.
+
+```sh
+python3 infra/helper.py build_fuzzers --sanitizer coverage quic-go
+python3 infra/helper.py coverage --no-serve --fuzz-target "$FUZZ_TARGET" --corpus-dir="$CORPUS_DIR" quic-go
+sed "s#^/out/#$(pwd)/build/out/quic-go/#" build/out/quic-go/fuzz.cov > "/tmp/quic-go-$FUZZ_TARGET.coverprofile"
+go tool cover -html="/tmp/quic-go-$FUZZ_TARGET.coverprofile"
+```
+
+The `sed` command rewrites the container paths in `fuzz.cov` so that `go tool cover` can locate the source files in the local checkout.
+
+To produce a coverage report against a modified local source tree, mount the local checkout when building the coverage fuzzers, the same way you would for reproducers:
+
+```sh
+python3 infra/helper.py build_fuzzers --sanitizer coverage --mount_path /root/go/src/github.com/quic-go/quic-go quic-go <local_quic_go_dir>
+```
+
+## Reproducing an OSS-Fuzz testcase
+
+Download the reproducer file from the OSS-Fuzz report. To test a local fix, rebuild the fuzzers with the modified quic-go checkout mounted at the path expected by `oss-fuzz.sh`:
+
+```sh
+export DOCKER_DEFAULT_PLATFORM=linux/amd64
+export FUZZ_TARGET=<fuzz_target>
+
+python3 infra/helper.py build_image --no-pull quic-go
+python3 infra/helper.py build_fuzzers --sanitizer address --mount_path /root/go/src/github.com/quic-go/quic-go quic-go <local_quic_go_dir>
+python3 infra/helper.py reproduce quic-go "$FUZZ_TARGET" <reproducer_file>
+```
diff --git a/backend/vendor/github.com/quic-go/quic-go/LICENSE b/backend/vendor/github.com/quic-go/quic-go/LICENSE
new file mode 100644
index 00000000..51378bef
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 the quic-go authors & Google, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/backend/vendor/github.com/quic-go/quic-go/README.md b/backend/vendor/github.com/quic-go/quic-go/README.md
new file mode 100644
index 00000000..a3089205
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/README.md
@@ -0,0 +1,65 @@
+<div align="center" style="margin-bottom: 15px;">
+  <img src="./assets/quic-go-logo.png" width="700" height="auto">
+</div>
+
+# A QUIC implementation in pure Go
+
+
+[![Documentation](https://img.shields.io/badge/docs-quic--go.net-red?style=flat)](https://quic-go.net/docs/)
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/quic-go/quic-go)](https://pkg.go.dev/github.com/quic-go/quic-go)
+[![Code Coverage](https://img.shields.io/codecov/c/github/quic-go/quic-go/master.svg?style=flat-square)](https://codecov.io/gh/quic-go/quic-go/)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/quic-go.svg)](https://issues.oss-fuzz.com/issues?q=quic-go)
+
+quic-go is an implementation of the QUIC protocol ([RFC 9000](https://datatracker.ietf.org/doc/html/rfc9000), [RFC 9001](https://datatracker.ietf.org/doc/html/rfc9001), [RFC 9002](https://datatracker.ietf.org/doc/html/rfc9002)) in Go. It has support for HTTP/3 ([RFC 9114](https://datatracker.ietf.org/doc/html/rfc9114)), including QPACK ([RFC 9204](https://datatracker.ietf.org/doc/html/rfc9204)) and HTTP Datagrams ([RFC 9297](https://datatracker.ietf.org/doc/html/rfc9297)).
+
+In addition to these base RFCs, it also implements the following RFCs:
+
+* Unreliable Datagram Extension ([RFC 9221](https://datatracker.ietf.org/doc/html/rfc9221))
+* Datagram Packetization Layer Path MTU Discovery (DPLPMTUD, [RFC 8899](https://datatracker.ietf.org/doc/html/rfc8899))
+* QUIC Version 2 ([RFC 9369](https://datatracker.ietf.org/doc/html/rfc9369))
+* QUIC Event Logging using qlog ([draft-ietf-quic-qlog-main-schema](https://datatracker.ietf.org/doc/draft-ietf-quic-qlog-main-schema/) and [draft-ietf-quic-qlog-quic-events](https://datatracker.ietf.org/doc/draft-ietf-quic-qlog-quic-events/))
+* QUIC Stream Resets with Partial Delivery ([draft-ietf-quic-reliable-stream-reset-07](https://datatracker.ietf.org/doc/html/draft-ietf-quic-reliable-stream-reset-07) and [draft-ietf-quic-reliable-stream-reset-09](https://datatracker.ietf.org/doc/html/draft-ietf-quic-reliable-stream-reset-09))
+
+Support for WebTransport over HTTP/3 ([draft-ietf-webtrans-http3](https://datatracker.ietf.org/doc/draft-ietf-webtrans-http3/)) is implemented in [webtransport-go](https://github.com/quic-go/webtransport-go).
+
+Detailed documentation can be found on [quic-go.net](https://quic-go.net/docs/).
+
+## FIPS 140-3
+
+Starting with v0.60, quic-go supports use in FIPS 140-3 environments when built with Go 1.26 or newer, using Go standard library cryptography for the QUIC code paths relevant in FIPS mode; see [FIPS140.md](FIPS140.md) for details.
+
+## Projects using quic-go
+
+| Project                                                   | Description                                                                                                                                                       | Stars                                                                                               |
+| ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| [AdGuardHome](https://github.com/AdguardTeam/AdGuardHome) | Free and open source, powerful network-wide ads & trackers blocking DNS server.                                                                                   | ![GitHub Repo stars](https://img.shields.io/github/stars/AdguardTeam/AdGuardHome?style=flat-square) |
+| [algernon](https://github.com/xyproto/algernon)           | Small self-contained pure-Go web server with Lua, Markdown, HTTP/2, QUIC, Redis and PostgreSQL support                                                            | ![GitHub Repo stars](https://img.shields.io/github/stars/xyproto/algernon?style=flat-square)        |
+| [caddy](https://github.com/caddyserver/caddy/)            | Fast, multi-platform web server with automatic HTTPS                                                                                                              | ![GitHub Repo stars](https://img.shields.io/github/stars/caddyserver/caddy?style=flat-square)       |
+| [cloudflared](https://github.com/cloudflare/cloudflared)  | A tunneling daemon that proxies traffic from the Cloudflare network to your origins                                                                               | ![GitHub Repo stars](https://img.shields.io/github/stars/cloudflare/cloudflared?style=flat-square)  |
+| [frp](https://github.com/fatedier/frp)                    | A fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet                                                                   | ![GitHub Repo stars](https://img.shields.io/github/stars/fatedier/frp?style=flat-square)            |
+| [go-libp2p](https://github.com/libp2p/go-libp2p)          | libp2p implementation in Go, powering [Kubo](https://github.com/ipfs/kubo) (IPFS) and [Lotus](https://github.com/filecoin-project/lotus) (Filecoin), among others | ![GitHub Repo stars](https://img.shields.io/github/stars/libp2p/go-libp2p?style=flat-square)     |
+| [gost](https://github.com/go-gost/gost)                   | A simple security tunnel written in Go                                                                                                                        | ![GitHub Repo stars](https://img.shields.io/github/stars/go-gost/gost?style=flat-square)            |
+| [Hysteria](https://github.com/apernet/hysteria)           | A powerful, lightning fast and censorship resistant proxy                                                                                                         | ![GitHub Repo stars](https://img.shields.io/github/stars/apernet/hysteria?style=flat-square)        |
+| [Mercure](https://github.com/dunglas/mercure)             | An open, easy, fast, reliable and battery-efficient solution for real-time communications                                                                         | ![GitHub Repo stars](https://img.shields.io/github/stars/dunglas/mercure?style=flat-square)         |
+| [nodepass](https://github.com/NodePassProject/nodepass) | A secure, efficient TCP/UDP tunneling solution that delivers fast, reliable access across network restrictions using pre-established TCP/QUIC/WebSocket or HTTP/2 connections. | ![GitHub Repo stars](https://img.shields.io/github/stars/NodePassProject/nodepass?style=flat-square)  |
+| [OONI Probe](https://github.com/ooni/probe-cli)           | Next generation OONI Probe. Library and CLI tool.                                                                                                                 | ![GitHub Repo stars](https://img.shields.io/github/stars/ooni/probe-cli?style=flat-square)          |
+| [reverst](https://github.com/flipt-io/reverst)            | Reverse Tunnels in Go over HTTP/3 and QUIC                                                                                                                        | ![GitHub Repo stars](https://img.shields.io/github/stars/flipt-io/reverst?style=flat-square) |
+| [RoadRunner](https://github.com/roadrunner-server/roadrunner) | High-performance PHP application server, process manager written in Go and powered with plugins | ![GitHub Repo stars](https://img.shields.io/github/stars/roadrunner-server/roadrunner?style=flat-square) |
+| [syncthing](https://github.com/syncthing/syncthing/)      | Open Source Continuous File Synchronization                                                                                                                       | ![GitHub Repo stars](https://img.shields.io/github/stars/syncthing/syncthing?style=flat-square)     |
+| [traefik](https://github.com/traefik/traefik)             | The Cloud Native Application Proxy                                                                                                                                | ![GitHub Repo stars](https://img.shields.io/github/stars/traefik/traefik?style=flat-square)         |
+| [v2ray-core](https://github.com/v2fly/v2ray-core)         | A platform for building proxies to bypass network restrictions                                                                                                    | ![GitHub Repo stars](https://img.shields.io/github/stars/v2fly/v2ray-core?style=flat-square)        |
+| [YoMo](https://github.com/yomorun/yomo)                   | Streaming Serverless Framework for Geo-distributed System                                                                                                         | ![GitHub Repo stars](https://img.shields.io/github/stars/yomorun/yomo?style=flat-square)            |
+
+If you'd like to see your project added to this list, please send us a PR.
+
+## Release Policy
+
+quic-go always aims to support the latest two Go releases.
+
+## Contributing
+
+We are always happy to welcome new contributors! We have a number of self-contained issues that are suitable for first-time contributors, they are tagged with [help wanted](https://github.com/quic-go/quic-go/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22). If you have any questions, please feel free to reach out by opening an issue or leaving a comment.
+
+## License
+
+The code is licensed under the MIT license. The logo and brand assets are excluded from the MIT license. See [assets/LICENSE.md](https://github.com/quic-go/quic-go/tree/master/assets/LICENSE.md) for the full usage policy and details.
diff --git a/backend/vendor/github.com/quic-go/quic-go/SECURITY.md b/backend/vendor/github.com/quic-go/quic-go/SECURITY.md
new file mode 100644
index 00000000..79fe1f56
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/SECURITY.md
@@ -0,0 +1,14 @@
+# Security Policy
+
+quic-go is an implementation of the QUIC protocol and related standards. No software is perfect, and we take reports of potential security issues very seriously.
+
+## Reporting a Vulnerability
+
+If you discover a vulnerability that could affect production deployments (e.g., a remotely exploitable issue), please report it [**privately**](https://github.com/quic-go/quic-go/security/advisories/new).
+Please **DO NOT file a public issue** for exploitable vulnerabilities.
+
+If the issue is theoretical, non-exploitable, or related to an experimental feature, you may discuss it openly by filing a regular issue.
+
+## Reporting a non-security bug
+
+For bugs, feature requests, or other non-security concerns, please open a GitHub [issue](https://github.com/quic-go/quic-go/issues/new).
diff --git a/backend/vendor/github.com/quic-go/quic-go/buffer_pool.go b/backend/vendor/github.com/quic-go/quic-go/buffer_pool.go
new file mode 100644
index 00000000..48589e12
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/buffer_pool.go
@@ -0,0 +1,92 @@
+package quic
+
+import (
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type packetBuffer struct {
+	Data []byte
+
+	// refCount counts how many packets Data is used in.
+	// It doesn't support concurrent use.
+	// It is > 1 when used for coalesced packet.
+	refCount int
+}
+
+// Split increases the refCount.
+// It must be called when a packet buffer is used for more than one packet,
+// e.g. when splitting coalesced packets.
+func (b *packetBuffer) Split() {
+	b.refCount++
+}
+
+// Decrement decrements the reference counter.
+// It doesn't put the buffer back into the pool.
+func (b *packetBuffer) Decrement() {
+	b.refCount--
+	if b.refCount < 0 {
+		panic("negative packetBuffer refCount")
+	}
+}
+
+// MaybeRelease puts the packet buffer back into the pool,
+// if the reference counter already reached 0.
+func (b *packetBuffer) MaybeRelease() {
+	// only put the packetBuffer back if it's not used any more
+	if b.refCount == 0 {
+		b.putBack()
+	}
+}
+
+// Release puts back the packet buffer into the pool.
+// It should be called when processing is definitely finished.
+func (b *packetBuffer) Release() {
+	b.Decrement()
+	if b.refCount != 0 {
+		panic("packetBuffer refCount not zero")
+	}
+	b.putBack()
+}
+
+// Len returns the length of Data
+func (b *packetBuffer) Len() protocol.ByteCount { return protocol.ByteCount(len(b.Data)) }
+func (b *packetBuffer) Cap() protocol.ByteCount { return protocol.ByteCount(cap(b.Data)) }
+
+func (b *packetBuffer) putBack() {
+	if cap(b.Data) == protocol.MaxPacketBufferSize {
+		bufferPool.Put(b)
+		return
+	}
+	if cap(b.Data) == protocol.MaxLargePacketBufferSize {
+		largeBufferPool.Put(b)
+		return
+	}
+	panic("putPacketBuffer called with packet of wrong size!")
+}
+
+var bufferPool, largeBufferPool sync.Pool
+
+func getPacketBuffer() *packetBuffer {
+	buf := bufferPool.Get().(*packetBuffer)
+	buf.refCount = 1
+	buf.Data = buf.Data[:0]
+	return buf
+}
+
+func getLargePacketBuffer() *packetBuffer {
+	buf := largeBufferPool.Get().(*packetBuffer)
+	buf.refCount = 1
+	buf.Data = buf.Data[:0]
+	return buf
+}
+
+func init() {
+	bufferPool.New = func() any {
+		return &packetBuffer{Data: make([]byte, 0, protocol.MaxPacketBufferSize)}
+	}
+	largeBufferPool.New = func() any {
+		return &packetBuffer{Data: make([]byte, 0, protocol.MaxLargePacketBufferSize)}
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/client.go b/backend/vendor/github.com/quic-go/quic-go/client.go
new file mode 100644
index 00000000..63132f2d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/client.go
@@ -0,0 +1,109 @@
+package quic
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// make it possible to mock connection ID for initial generation in the tests
+var generateConnectionIDForInitial = protocol.GenerateConnectionIDForInitial
+
+// DialAddr establishes a new QUIC connection to a server.
+// It resolves the address, and then creates a new UDP connection to dial the QUIC server.
+// When the QUIC connection is closed, this UDP connection is closed.
+// See [Dial] for more details.
+func DialAddr(ctx context.Context, addr string, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	udpConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
+	if err != nil {
+		return nil, err
+	}
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+	tr, err := setupTransport(udpConn, tlsConf, true)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := tr.dial(ctx, udpAddr, addr, tlsConf, conf, false)
+	if err != nil {
+		tr.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+// DialAddrEarly establishes a new 0-RTT QUIC connection to a server.
+// See [DialAddr] for more details.
+func DialAddrEarly(ctx context.Context, addr string, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	udpConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
+	if err != nil {
+		return nil, err
+	}
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+	tr, err := setupTransport(udpConn, tlsConf, true)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := tr.dial(ctx, udpAddr, addr, tlsConf, conf, true)
+	if err != nil {
+		tr.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+// DialEarly establishes a new 0-RTT QUIC connection to a server using a net.PacketConn.
+// See [Dial] for more details.
+func DialEarly(ctx context.Context, c net.PacketConn, addr net.Addr, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	dl, err := setupTransport(c, tlsConf, false)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := dl.DialEarly(ctx, addr, tlsConf, conf)
+	if err != nil {
+		dl.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+// Dial establishes a new QUIC connection to a server using a net.PacketConn.
+// If the PacketConn satisfies the [OOBCapablePacketConn] interface (as a [net.UDPConn] does),
+// ECN and packet info support will be enabled. In this case, ReadMsgUDP and WriteMsgUDP
+// will be used instead of ReadFrom and WriteTo to read/write packets.
+// The [tls.Config] must define an application protocol (using tls.Config.NextProtos).
+//
+// This is a convenience function. More advanced use cases should instantiate a [Transport],
+// which offers configuration options for a more fine-grained control of the connection establishment,
+// including reusing the underlying UDP socket for multiple QUIC connections.
+func Dial(ctx context.Context, c net.PacketConn, addr net.Addr, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	dl, err := setupTransport(c, tlsConf, false)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := dl.Dial(ctx, addr, tlsConf, conf)
+	if err != nil {
+		dl.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+func setupTransport(c net.PacketConn, tlsConf *tls.Config, createdPacketConn bool) (*Transport, error) {
+	if tlsConf == nil {
+		return nil, errors.New("quic: tls.Config not set")
+	}
+	return &Transport{
+		Conn:        c,
+		createdConn: createdPacketConn,
+		isSingleUse: true,
+	}, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/closed_conn.go b/backend/vendor/github.com/quic-go/quic-go/closed_conn.go
new file mode 100644
index 00000000..6486ea65
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/closed_conn.go
@@ -0,0 +1,58 @@
+package quic
+
+import (
+	"math/bits"
+	"net"
+	"sync/atomic"
+
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+// A closedLocalConn is a connection that we closed locally.
+// When receiving packets for such a connection, we need to retransmit the packet containing the CONNECTION_CLOSE frame,
+// with an exponential backoff.
+type closedLocalConn struct {
+	counter atomic.Uint32
+	logger  utils.Logger
+
+	sendPacket func(net.Addr, packetInfo)
+}
+
+var _ packetHandler = &closedLocalConn{}
+
+// newClosedLocalConn creates a new closedLocalConn and runs it.
+func newClosedLocalConn(sendPacket func(net.Addr, packetInfo), logger utils.Logger) packetHandler {
+	return &closedLocalConn{
+		sendPacket: sendPacket,
+		logger:     logger,
+	}
+}
+
+func (c *closedLocalConn) handlePacket(p receivedPacket) {
+	n := c.counter.Add(1)
+	// exponential backoff
+	// only send a CONNECTION_CLOSE for the 1st, 2nd, 4th, 8th, 16th, ... packet arriving
+	if bits.OnesCount32(n) != 1 {
+		return
+	}
+	c.logger.Debugf("Received %d packets after sending CONNECTION_CLOSE. Retransmitting.", n)
+	c.sendPacket(p.remoteAddr, p.info)
+}
+
+func (c *closedLocalConn) destroy(error)                              {}
+func (c *closedLocalConn) closeWithTransportError(TransportErrorCode) {}
+
+// A closedRemoteConn is a connection that was closed remotely.
+// For such a connection, we might receive reordered packets that were sent before the CONNECTION_CLOSE.
+// We can just ignore those packets.
+type closedRemoteConn struct{}
+
+var _ packetHandler = &closedRemoteConn{}
+
+func newClosedRemoteConn() packetHandler {
+	return &closedRemoteConn{}
+}
+
+func (c *closedRemoteConn) handlePacket(receivedPacket)                {}
+func (c *closedRemoteConn) destroy(error)                              {}
+func (c *closedRemoteConn) closeWithTransportError(TransportErrorCode) {}
diff --git a/backend/vendor/github.com/quic-go/quic-go/codecov.yml b/backend/vendor/github.com/quic-go/quic-go/codecov.yml
new file mode 100644
index 00000000..55d8a35e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/codecov.yml
@@ -0,0 +1,23 @@
+coverage:
+  round: nearest
+  ignore:
+    - http3/gzip_reader.go
+    - example/
+    - interop/
+    - internal/handshake/cipher_suite.go
+    - internal/mocks/
+    - internal/utils/linkedlist/linkedlist.go
+    - internal/testdata
+    - testutils/
+    - fuzzing/
+    - metrics/
+  status:
+    project:
+      default:
+        threshold: 0.5
+    patch: false
+flags:
+  clusterfuzz-lite-batch:
+    joined: false
+  clusterfuzz:
+    joined: false
diff --git a/backend/vendor/github.com/quic-go/quic-go/config.go b/backend/vendor/github.com/quic-go/quic-go/config.go
new file mode 100644
index 00000000..74c2054e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/config.go
@@ -0,0 +1,129 @@
+package quic
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// Clone clones a Config.
+func (c *Config) Clone() *Config {
+	copy := *c
+	return &copy
+}
+
+func (c *Config) handshakeTimeout() time.Duration {
+	return 2 * c.HandshakeIdleTimeout
+}
+
+func (c *Config) maxRetryTokenAge() time.Duration {
+	return c.handshakeTimeout()
+}
+
+func validateConfig(config *Config) error {
+	if config == nil {
+		return nil
+	}
+	const maxStreams = 1 << 60
+	if config.MaxIncomingStreams > maxStreams {
+		config.MaxIncomingStreams = maxStreams
+	}
+	if config.MaxIncomingUniStreams > maxStreams {
+		config.MaxIncomingUniStreams = maxStreams
+	}
+	if config.MaxStreamReceiveWindow > quicvarint.Max {
+		config.MaxStreamReceiveWindow = quicvarint.Max
+	}
+	if config.MaxConnectionReceiveWindow > quicvarint.Max {
+		config.MaxConnectionReceiveWindow = quicvarint.Max
+	}
+	if config.InitialPacketSize > 0 && config.InitialPacketSize < protocol.MinInitialPacketSize {
+		config.InitialPacketSize = protocol.MinInitialPacketSize
+	}
+	if config.InitialPacketSize > protocol.MaxPacketBufferSize {
+		config.InitialPacketSize = protocol.MaxPacketBufferSize
+	}
+	// check that all QUIC versions are actually supported
+	for _, v := range config.Versions {
+		if !protocol.IsValidVersion(v) {
+			return fmt.Errorf("invalid QUIC version: %s", v)
+		}
+	}
+	return nil
+}
+
+// populateConfig populates fields in the quic.Config with their default values, if none are set
+// it may be called with nil
+func populateConfig(config *Config) *Config {
+	if config == nil {
+		config = &Config{}
+	}
+	versions := config.Versions
+	if len(versions) == 0 {
+		versions = protocol.SupportedVersions
+	}
+	handshakeIdleTimeout := protocol.DefaultHandshakeIdleTimeout
+	if config.HandshakeIdleTimeout != 0 {
+		handshakeIdleTimeout = config.HandshakeIdleTimeout
+	}
+	idleTimeout := protocol.DefaultIdleTimeout
+	if config.MaxIdleTimeout != 0 {
+		idleTimeout = config.MaxIdleTimeout
+	}
+	initialStreamReceiveWindow := config.InitialStreamReceiveWindow
+	if initialStreamReceiveWindow == 0 {
+		initialStreamReceiveWindow = protocol.DefaultInitialMaxStreamData
+	}
+	maxStreamReceiveWindow := config.MaxStreamReceiveWindow
+	if maxStreamReceiveWindow == 0 {
+		maxStreamReceiveWindow = protocol.DefaultMaxReceiveStreamFlowControlWindow
+	}
+	initialConnectionReceiveWindow := config.InitialConnectionReceiveWindow
+	if initialConnectionReceiveWindow == 0 {
+		initialConnectionReceiveWindow = protocol.DefaultInitialMaxData
+	}
+	maxConnectionReceiveWindow := config.MaxConnectionReceiveWindow
+	if maxConnectionReceiveWindow == 0 {
+		maxConnectionReceiveWindow = protocol.DefaultMaxReceiveConnectionFlowControlWindow
+	}
+	maxIncomingStreams := config.MaxIncomingStreams
+	if maxIncomingStreams == 0 {
+		maxIncomingStreams = protocol.DefaultMaxIncomingStreams
+	} else if maxIncomingStreams < 0 {
+		maxIncomingStreams = 0
+	}
+	maxIncomingUniStreams := config.MaxIncomingUniStreams
+	if maxIncomingUniStreams == 0 {
+		maxIncomingUniStreams = protocol.DefaultMaxIncomingUniStreams
+	} else if maxIncomingUniStreams < 0 {
+		maxIncomingUniStreams = 0
+	}
+	initialPacketSize := config.InitialPacketSize
+	if initialPacketSize == 0 {
+		initialPacketSize = protocol.InitialPacketSize
+	}
+
+	return &Config{
+		GetConfigForClient:               config.GetConfigForClient,
+		Versions:                         versions,
+		HandshakeIdleTimeout:             handshakeIdleTimeout,
+		MaxIdleTimeout:                   idleTimeout,
+		KeepAlivePeriod:                  config.KeepAlivePeriod,
+		InitialStreamReceiveWindow:       initialStreamReceiveWindow,
+		MaxStreamReceiveWindow:           maxStreamReceiveWindow,
+		InitialConnectionReceiveWindow:   initialConnectionReceiveWindow,
+		MaxConnectionReceiveWindow:       maxConnectionReceiveWindow,
+		AllowConnectionWindowIncrease:    config.AllowConnectionWindowIncrease,
+		MaxIncomingStreams:               maxIncomingStreams,
+		MaxIncomingUniStreams:            maxIncomingUniStreams,
+		TokenStore:                       config.TokenStore,
+		EnableDatagrams:                  config.EnableDatagrams,
+		InitialPacketSize:                initialPacketSize,
+		DisablePathMTUDiscovery:          config.DisablePathMTUDiscovery,
+		EnableStreamResetPartialDelivery: config.EnableStreamResetPartialDelivery,
+		Allow0RTT:                        config.Allow0RTT,
+		Tracer:                           config.Tracer,
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/conn_id_generator.go b/backend/vendor/github.com/quic-go/quic-go/conn_id_generator.go
new file mode 100644
index 00000000..133932a6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/conn_id_generator.go
@@ -0,0 +1,212 @@
+package quic
+
+import (
+	"fmt"
+	"slices"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type connRunnerCallbacks struct {
+	AddConnectionID    func(protocol.ConnectionID)
+	RemoveConnectionID func(protocol.ConnectionID)
+	ReplaceWithClosed  func([]protocol.ConnectionID, []byte, time.Duration)
+}
+
+// The memory address of the Transport is used as the key.
+type connRunners map[connRunner]connRunnerCallbacks
+
+func (cr connRunners) AddConnectionID(id protocol.ConnectionID) {
+	for _, c := range cr {
+		c.AddConnectionID(id)
+	}
+}
+
+func (cr connRunners) RemoveConnectionID(id protocol.ConnectionID) {
+	for _, c := range cr {
+		c.RemoveConnectionID(id)
+	}
+}
+
+func (cr connRunners) ReplaceWithClosed(ids []protocol.ConnectionID, b []byte, expiry time.Duration) {
+	for _, c := range cr {
+		c.ReplaceWithClosed(ids, b, expiry)
+	}
+}
+
+type connIDToRetire struct {
+	t      monotime.Time
+	connID protocol.ConnectionID
+}
+
+type connIDGenerator struct {
+	generator   ConnectionIDGenerator
+	highestSeq  uint64
+	connRunners connRunners
+
+	activeSrcConnIDs        map[uint64]protocol.ConnectionID
+	connIDsToRetire         []connIDToRetire       // sorted by t
+	initialClientDestConnID *protocol.ConnectionID // nil for the client
+
+	statelessResetter *statelessResetter
+
+	queueControlFrame func(wire.Frame)
+}
+
+func newConnIDGenerator(
+	runner connRunner,
+	initialConnectionID protocol.ConnectionID,
+	initialClientDestConnID *protocol.ConnectionID, // nil for the client
+	statelessResetter *statelessResetter,
+	callbacks connRunnerCallbacks,
+	queueControlFrame func(wire.Frame),
+	generator ConnectionIDGenerator,
+) *connIDGenerator {
+	m := &connIDGenerator{
+		generator:         generator,
+		activeSrcConnIDs:  make(map[uint64]protocol.ConnectionID),
+		statelessResetter: statelessResetter,
+		connRunners:       map[connRunner]connRunnerCallbacks{runner: callbacks},
+		queueControlFrame: queueControlFrame,
+	}
+	m.activeSrcConnIDs[0] = initialConnectionID
+	m.initialClientDestConnID = initialClientDestConnID
+	return m
+}
+
+func (m *connIDGenerator) SetMaxActiveConnIDs(limit uint64) error {
+	if m.generator.ConnectionIDLen() == 0 {
+		return nil
+	}
+	// The active_connection_id_limit transport parameter is the number of
+	// connection IDs the peer will store. This limit includes the connection ID
+	// used during the handshake, and the one sent in the preferred_address
+	// transport parameter.
+	// We currently don't send the preferred_address transport parameter,
+	// so we can issue (limit - 1) connection IDs.
+	for i := uint64(len(m.activeSrcConnIDs)); i < min(limit, protocol.MaxIssuedConnectionIDs); i++ {
+		if err := m.issueNewConnID(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (m *connIDGenerator) Retire(seq uint64, sentWithDestConnID protocol.ConnectionID, expiry monotime.Time) error {
+	if seq > m.highestSeq {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: fmt.Sprintf("retired connection ID %d (highest issued: %d)", seq, m.highestSeq),
+		}
+	}
+	connID, ok := m.activeSrcConnIDs[seq]
+	// We might already have deleted this connection ID, if this is a duplicate frame.
+	if !ok {
+		return nil
+	}
+	if connID == sentWithDestConnID {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: fmt.Sprintf("retired connection ID %d (%s), which was used as the Destination Connection ID on this packet", seq, connID),
+		}
+	}
+	m.queueConnIDForRetiring(connID, expiry)
+
+	delete(m.activeSrcConnIDs, seq)
+	// Don't issue a replacement for the initial connection ID.
+	if seq == 0 {
+		return nil
+	}
+	return m.issueNewConnID()
+}
+
+func (m *connIDGenerator) queueConnIDForRetiring(connID protocol.ConnectionID, expiry monotime.Time) {
+	idx := slices.IndexFunc(m.connIDsToRetire, func(c connIDToRetire) bool {
+		return c.t.After(expiry)
+	})
+	if idx == -1 {
+		idx = len(m.connIDsToRetire)
+	}
+	m.connIDsToRetire = slices.Insert(m.connIDsToRetire, idx, connIDToRetire{t: expiry, connID: connID})
+}
+
+func (m *connIDGenerator) issueNewConnID() error {
+	connID, err := m.generator.GenerateConnectionID()
+	if err != nil {
+		return err
+	}
+	m.activeSrcConnIDs[m.highestSeq+1] = connID
+	m.connRunners.AddConnectionID(connID)
+	m.queueControlFrame(&wire.NewConnectionIDFrame{
+		SequenceNumber:      m.highestSeq + 1,
+		ConnectionID:        connID,
+		StatelessResetToken: m.statelessResetter.GetStatelessResetToken(connID),
+	})
+	m.highestSeq++
+	return nil
+}
+
+func (m *connIDGenerator) SetHandshakeComplete(connIDExpiry monotime.Time) {
+	if m.initialClientDestConnID != nil {
+		m.queueConnIDForRetiring(*m.initialClientDestConnID, connIDExpiry)
+		m.initialClientDestConnID = nil
+	}
+}
+
+func (m *connIDGenerator) RemoveRetiredConnIDs(now monotime.Time) {
+	if len(m.connIDsToRetire) == 0 {
+		return
+	}
+	for _, c := range m.connIDsToRetire {
+		if c.t.After(now) {
+			break
+		}
+		m.connRunners.RemoveConnectionID(c.connID)
+		m.connIDsToRetire = m.connIDsToRetire[1:]
+	}
+}
+
+func (m *connIDGenerator) RemoveAll() {
+	if m.initialClientDestConnID != nil {
+		m.connRunners.RemoveConnectionID(*m.initialClientDestConnID)
+	}
+	for _, connID := range m.activeSrcConnIDs {
+		m.connRunners.RemoveConnectionID(connID)
+	}
+	for _, c := range m.connIDsToRetire {
+		m.connRunners.RemoveConnectionID(c.connID)
+	}
+}
+
+func (m *connIDGenerator) ReplaceWithClosed(connClose []byte, expiry time.Duration) {
+	connIDs := make([]protocol.ConnectionID, 0, len(m.activeSrcConnIDs)+len(m.connIDsToRetire)+1)
+	if m.initialClientDestConnID != nil {
+		connIDs = append(connIDs, *m.initialClientDestConnID)
+	}
+	for _, connID := range m.activeSrcConnIDs {
+		connIDs = append(connIDs, connID)
+	}
+	for _, c := range m.connIDsToRetire {
+		connIDs = append(connIDs, c.connID)
+	}
+	m.connRunners.ReplaceWithClosed(connIDs, connClose, expiry)
+}
+
+func (m *connIDGenerator) AddConnRunner(runner connRunner, r connRunnerCallbacks) {
+	// The transport might have already been added earlier.
+	// This happens if the application migrates back to and old path.
+	if _, ok := m.connRunners[runner]; ok {
+		return
+	}
+	m.connRunners[runner] = r
+	if m.initialClientDestConnID != nil {
+		r.AddConnectionID(*m.initialClientDestConnID)
+	}
+	for _, connID := range m.activeSrcConnIDs {
+		r.AddConnectionID(connID)
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/conn_id_manager.go b/backend/vendor/github.com/quic-go/quic-go/conn_id_manager.go
new file mode 100644
index 00000000..5513b645
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/conn_id_manager.go
@@ -0,0 +1,321 @@
+package quic
+
+import (
+	"fmt"
+	"slices"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type newConnID struct {
+	SequenceNumber      uint64
+	ConnectionID        protocol.ConnectionID
+	StatelessResetToken protocol.StatelessResetToken
+}
+
+type connIDManager struct {
+	queue []newConnID
+
+	highestProbingID uint64
+	pathProbing      map[pathID]newConnID // initialized lazily
+
+	handshakeComplete         bool
+	activeSequenceNumber      uint64
+	highestRetired            uint64
+	activeConnectionID        protocol.ConnectionID
+	activeStatelessResetToken *protocol.StatelessResetToken
+
+	// We change the connection ID after sending on average
+	// protocol.PacketsPerConnectionID packets. The actual value is randomized
+	// hide the packet loss rate from on-path observers.
+	rand                   utils.Rand
+	packetsSinceLastChange uint32
+	packetsPerConnectionID uint32
+
+	addStatelessResetToken    func(protocol.StatelessResetToken)
+	removeStatelessResetToken func(protocol.StatelessResetToken)
+	queueControlFrame         func(wire.Frame)
+
+	closed bool
+}
+
+func newConnIDManager(
+	initialDestConnID protocol.ConnectionID,
+	addStatelessResetToken func(protocol.StatelessResetToken),
+	removeStatelessResetToken func(protocol.StatelessResetToken),
+	queueControlFrame func(wire.Frame),
+) *connIDManager {
+	return &connIDManager{
+		activeConnectionID:        initialDestConnID,
+		addStatelessResetToken:    addStatelessResetToken,
+		removeStatelessResetToken: removeStatelessResetToken,
+		queueControlFrame:         queueControlFrame,
+		queue:                     make([]newConnID, 0, protocol.MaxActiveConnectionIDs),
+	}
+}
+
+func (h *connIDManager) AddFromPreferredAddress(connID protocol.ConnectionID, resetToken protocol.StatelessResetToken) error {
+	return h.addConnectionID(1, connID, resetToken)
+}
+
+func (h *connIDManager) Add(f *wire.NewConnectionIDFrame) error {
+	if err := h.add(f); err != nil {
+		return err
+	}
+	if len(h.queue) >= protocol.MaxActiveConnectionIDs {
+		return &qerr.TransportError{ErrorCode: qerr.ConnectionIDLimitError}
+	}
+	return nil
+}
+
+func (h *connIDManager) add(f *wire.NewConnectionIDFrame) error {
+	if h.activeConnectionID.Len() == 0 {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "received NEW_CONNECTION_ID frame but zero-length connection IDs are in use",
+		}
+	}
+	// If the NEW_CONNECTION_ID frame is reordered, such that its sequence number is smaller than the currently active
+	// connection ID or if it was already retired, send the RETIRE_CONNECTION_ID frame immediately.
+	if f.SequenceNumber < max(h.activeSequenceNumber, h.highestProbingID) || f.SequenceNumber < h.highestRetired {
+		h.queueControlFrame(&wire.RetireConnectionIDFrame{
+			SequenceNumber: f.SequenceNumber,
+		})
+		return nil
+	}
+
+	if f.RetirePriorTo != 0 && h.pathProbing != nil {
+		for id, entry := range h.pathProbing {
+			if entry.SequenceNumber < f.RetirePriorTo {
+				h.queueControlFrame(&wire.RetireConnectionIDFrame{
+					SequenceNumber: entry.SequenceNumber,
+				})
+				h.removeStatelessResetToken(entry.StatelessResetToken)
+				delete(h.pathProbing, id)
+			}
+		}
+	}
+	// Retire elements in the queue.
+	// Doesn't retire the active connection ID.
+	if f.RetirePriorTo > h.highestRetired {
+		var newQueue []newConnID
+		for _, entry := range h.queue {
+			if entry.SequenceNumber >= f.RetirePriorTo {
+				newQueue = append(newQueue, entry)
+			} else {
+				h.queueControlFrame(&wire.RetireConnectionIDFrame{SequenceNumber: entry.SequenceNumber})
+			}
+		}
+		h.queue = newQueue
+		h.highestRetired = f.RetirePriorTo
+	}
+
+	if f.SequenceNumber == h.activeSequenceNumber {
+		return nil
+	}
+
+	if err := h.addConnectionID(f.SequenceNumber, f.ConnectionID, f.StatelessResetToken); err != nil {
+		return err
+	}
+
+	// Retire the active connection ID, if necessary.
+	if h.activeSequenceNumber < f.RetirePriorTo {
+		// The queue is guaranteed to have at least one element at this point.
+		h.updateConnectionID()
+	}
+	return nil
+}
+
+func (h *connIDManager) addConnectionID(seq uint64, connID protocol.ConnectionID, resetToken protocol.StatelessResetToken) error {
+	// fast path: add to the end of the queue
+	if len(h.queue) == 0 || h.queue[len(h.queue)-1].SequenceNumber < seq {
+		h.queue = append(h.queue, newConnID{
+			SequenceNumber:      seq,
+			ConnectionID:        connID,
+			StatelessResetToken: resetToken,
+		})
+		return nil
+	}
+
+	// slow path: insert in the middle
+	for i, entry := range h.queue {
+		if entry.SequenceNumber == seq {
+			if entry.ConnectionID != connID {
+				return fmt.Errorf("received conflicting connection IDs for sequence number %d", seq)
+			}
+			if entry.StatelessResetToken != resetToken {
+				return fmt.Errorf("received conflicting stateless reset tokens for sequence number %d", seq)
+			}
+			return nil
+		}
+
+		// insert at the correct position to maintain sorted order
+		if entry.SequenceNumber > seq {
+			h.queue = slices.Insert(h.queue, i, newConnID{
+				SequenceNumber:      seq,
+				ConnectionID:        connID,
+				StatelessResetToken: resetToken,
+			})
+			return nil
+		}
+	}
+	return nil // unreachable
+}
+
+func (h *connIDManager) updateConnectionID() {
+	h.assertNotClosed()
+	h.queueControlFrame(&wire.RetireConnectionIDFrame{
+		SequenceNumber: h.activeSequenceNumber,
+	})
+	h.highestRetired = max(h.highestRetired, h.activeSequenceNumber)
+	if h.activeStatelessResetToken != nil {
+		h.removeStatelessResetToken(*h.activeStatelessResetToken)
+	}
+
+	front := h.queue[0]
+	h.queue = h.queue[1:]
+	h.activeSequenceNumber = front.SequenceNumber
+	h.activeConnectionID = front.ConnectionID
+	h.activeStatelessResetToken = &front.StatelessResetToken
+	h.packetsSinceLastChange = 0
+	h.packetsPerConnectionID = protocol.PacketsPerConnectionID/2 + uint32(h.rand.Int31n(protocol.PacketsPerConnectionID))
+	h.addStatelessResetToken(*h.activeStatelessResetToken)
+}
+
+func (h *connIDManager) Close() {
+	h.closed = true
+	if h.activeStatelessResetToken != nil {
+		h.removeStatelessResetToken(*h.activeStatelessResetToken)
+	}
+	if h.pathProbing != nil {
+		for _, entry := range h.pathProbing {
+			h.removeStatelessResetToken(entry.StatelessResetToken)
+		}
+	}
+}
+
+// is called when the server performs a Retry
+// and when the server changes the connection ID in the first Initial sent
+func (h *connIDManager) ChangeInitialConnID(newConnID protocol.ConnectionID) {
+	if h.activeSequenceNumber != 0 {
+		panic("expected first connection ID to have sequence number 0")
+	}
+	h.activeConnectionID = newConnID
+}
+
+// is called when the server provides a stateless reset token in the transport parameters
+func (h *connIDManager) SetStatelessResetToken(token protocol.StatelessResetToken) {
+	h.assertNotClosed()
+	if h.activeSequenceNumber != 0 {
+		panic("expected first connection ID to have sequence number 0")
+	}
+	h.activeStatelessResetToken = &token
+	h.addStatelessResetToken(token)
+}
+
+func (h *connIDManager) SentPacket() {
+	h.packetsSinceLastChange++
+}
+
+func (h *connIDManager) shouldUpdateConnID() bool {
+	if !h.handshakeComplete {
+		return false
+	}
+	// initiate the first change as early as possible (after handshake completion)
+	if len(h.queue) > 0 && h.activeSequenceNumber == 0 {
+		return true
+	}
+	// For later changes, only change if
+	// 1. The queue of connection IDs is filled more than 50%.
+	// 2. We sent at least PacketsPerConnectionID packets
+	return 2*len(h.queue) >= protocol.MaxActiveConnectionIDs &&
+		h.packetsSinceLastChange >= h.packetsPerConnectionID
+}
+
+func (h *connIDManager) Get() protocol.ConnectionID {
+	h.assertNotClosed()
+	if h.shouldUpdateConnID() {
+		h.updateConnectionID()
+	}
+	return h.activeConnectionID
+}
+
+func (h *connIDManager) SetHandshakeComplete() {
+	h.handshakeComplete = true
+}
+
+// GetConnIDForPath retrieves a connection ID for a new path (i.e. not the active one).
+// Once a connection ID is allocated for a path, it cannot be used for a different path.
+// When called with the same pathID, it will return the same connection ID,
+// unless the peer requested that this connection ID be retired.
+func (h *connIDManager) GetConnIDForPath(id pathID) (protocol.ConnectionID, bool) {
+	h.assertNotClosed()
+	// if we're using zero-length connection IDs, we don't need to change the connection ID
+	if h.activeConnectionID.Len() == 0 {
+		return protocol.ConnectionID{}, true
+	}
+
+	if h.pathProbing == nil {
+		h.pathProbing = make(map[pathID]newConnID)
+	}
+	entry, ok := h.pathProbing[id]
+	if ok {
+		return entry.ConnectionID, true
+	}
+	if len(h.queue) == 0 {
+		return protocol.ConnectionID{}, false
+	}
+	front := h.queue[0]
+	h.queue = h.queue[1:]
+	h.pathProbing[id] = front
+	h.highestProbingID = front.SequenceNumber
+	h.addStatelessResetToken(front.StatelessResetToken)
+	return front.ConnectionID, true
+}
+
+func (h *connIDManager) RetireConnIDForPath(pathID pathID) {
+	h.assertNotClosed()
+	// if we're using zero-length connection IDs, we don't need to change the connection ID
+	if h.activeConnectionID.Len() == 0 {
+		return
+	}
+
+	entry, ok := h.pathProbing[pathID]
+	if !ok {
+		return
+	}
+	h.queueControlFrame(&wire.RetireConnectionIDFrame{
+		SequenceNumber: entry.SequenceNumber,
+	})
+	h.removeStatelessResetToken(entry.StatelessResetToken)
+	delete(h.pathProbing, pathID)
+}
+
+func (h *connIDManager) IsActiveStatelessResetToken(token protocol.StatelessResetToken) bool {
+	if h.activeStatelessResetToken != nil {
+		if *h.activeStatelessResetToken == token {
+			return true
+		}
+	}
+	if h.pathProbing != nil {
+		for _, entry := range h.pathProbing {
+			if entry.StatelessResetToken == token {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Using the connIDManager after it has been closed can have disastrous effects:
+// If the connection ID is rotated, a new entry would be inserted into the packet handler map,
+// leading to a memory leak of the connection struct.
+// See https://github.com/quic-go/quic-go/pull/4852 for more details.
+func (h *connIDManager) assertNotClosed() {
+	if h.closed {
+		panic("connection ID manager is closed")
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/connection.go b/backend/vendor/github.com/quic-go/quic-go/connection.go
new file mode 100644
index 00000000..a610abda
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/connection.go
@@ -0,0 +1,3150 @@
+package quic
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"reflect"
+	"slices"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/handshake"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/utils/ringbuffer"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+type unpacker interface {
+	UnpackLongHeader(hdr *wire.Header, data []byte) (*unpackedPacket, error)
+	UnpackShortHeader(rcvTime monotime.Time, data []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error)
+}
+
+type cryptoStreamHandler interface {
+	StartHandshake(context.Context) error
+	ChangeConnectionID(protocol.ConnectionID)
+	SetLargest1RTTAcked(protocol.PacketNumber) error
+	SetHandshakeConfirmed()
+	GetSessionTicket() ([]byte, error)
+	NextEvent() handshake.Event
+	DiscardInitialKeys()
+	HandleMessage([]byte, protocol.EncryptionLevel) error
+	io.Closer
+	ConnectionState() handshake.ConnectionState
+}
+
+type receivedPacket struct {
+	buffer *packetBuffer
+
+	remoteAddr net.Addr
+	rcvTime    monotime.Time
+	data       []byte
+
+	ecn protocol.ECN
+
+	info packetInfo // only valid if the contained IP address is valid
+}
+
+type receivedPacketWithChecksum struct {
+	receivedPacket
+	checksum qlog.DatagramPayloadChecksum
+}
+
+func (p *receivedPacket) Size() protocol.ByteCount { return protocol.ByteCount(len(p.data)) }
+
+func (p *receivedPacket) Clone() *receivedPacket {
+	return &receivedPacket{
+		remoteAddr: p.remoteAddr,
+		rcvTime:    p.rcvTime,
+		data:       p.data,
+		buffer:     p.buffer,
+		ecn:        p.ecn,
+		info:       p.info,
+	}
+}
+
+type connRunner interface {
+	Add(protocol.ConnectionID, packetHandler) bool
+	Remove(protocol.ConnectionID)
+	ReplaceWithClosed([]protocol.ConnectionID, []byte, time.Duration)
+	AddResetToken(protocol.StatelessResetToken, packetHandler)
+	RemoveResetToken(protocol.StatelessResetToken)
+}
+
+type closeError struct {
+	err       error
+	immediate bool
+}
+
+type errCloseForRecreating struct {
+	nextPacketNumber protocol.PacketNumber
+	nextVersion      protocol.Version
+}
+
+func (e *errCloseForRecreating) Error() string {
+	return "closing connection in order to recreate it"
+}
+
+var deadlineSendImmediately = monotime.Time(42 * time.Millisecond) // any value > time.Time{} and before time.Now() is fine
+
+type blockMode uint8
+
+const (
+	// blockModeNone means that the connection is not blocked.
+	blockModeNone blockMode = iota
+	// blockModeCongestionLimited means that the connection is congestion limited.
+	// In that case, we can still send acknowledgments and PTO probe packets.
+	blockModeCongestionLimited
+	// blockModeHardBlocked means that no packet can be sent, under no circumstances. This can happen when:
+	// * the send queue is full
+	// * the SentPacketHandler returns SendNone, e.g. when we are tracking the maximum number of packets
+	// In that case, the timer will be set to the idle timeout.
+	blockModeHardBlocked
+)
+
+// A Conn is a QUIC connection between two peers.
+// Calls to the connection (and to streams) can return the following types of errors:
+//   - [ApplicationError]: for errors triggered by the application running on top of QUIC
+//   - [TransportError]: for errors triggered by the QUIC transport (in many cases a misbehaving peer)
+//   - [IdleTimeoutError]: when the peer goes away unexpectedly (this is a [net.Error] timeout error)
+//   - [HandshakeTimeoutError]: when the cryptographic handshake takes too long (this is a [net.Error] timeout error)
+//   - [StatelessResetError]: when we receive a stateless reset
+//   - [VersionNegotiationError]: returned by the client, when there's no version overlap between the peers
+type Conn struct {
+	// Destination connection ID used during the handshake.
+	// Used to check source connection ID on incoming packets.
+	handshakeDestConnID protocol.ConnectionID
+	// Set for the client. Destination connection ID used on the first Initial sent.
+	origDestConnID protocol.ConnectionID
+	retrySrcConnID *protocol.ConnectionID // only set for the client (and if a Retry was performed)
+
+	srcConnIDLen int
+
+	perspective protocol.Perspective
+	version     protocol.Version
+	config      *Config
+
+	conn      sendConn
+	sendQueue sender
+
+	// lazily initialzed: most connections never migrate
+	pathManager         *pathManager
+	largestRcvdAppData  protocol.PacketNumber
+	pathManagerOutgoing atomic.Pointer[pathManagerOutgoing]
+
+	streamsMap      *streamsMap
+	connIDManager   *connIDManager
+	connIDGenerator *connIDGenerator
+
+	rttStats  *utils.RTTStats
+	connStats utils.ConnectionStats
+
+	cryptoStreamManager   *cryptoStreamManager
+	sentPacketHandler     ackhandler.SentPacketHandler
+	receivedPacketHandler ackhandler.ReceivedPacketHandler
+	retransmissionQueue   *retransmissionQueue
+	framer                *framer
+	connFlowController    *connectionFlowController
+	tokenStoreKey         string                    // only set for the client
+	tokenGenerator        *handshake.TokenGenerator // only set for the server
+
+	unpacker      unpacker
+	frameParser   wire.FrameParser
+	packer        packer
+	mtuDiscoverer mtuDiscoverer // initialized when the transport parameters are received
+
+	maxPayloadSizeEstimate atomic.Uint32
+
+	initialStream       *initialCryptoStream
+	handshakeStream     *cryptoStream
+	oneRTTStream        *cryptoStream // only set for the server
+	cryptoStreamHandler cryptoStreamHandler
+
+	notifyReceivedPacket chan struct{}
+	sendingScheduled     chan struct{}
+	receivedPacketMx     sync.Mutex
+	receivedPackets      ringbuffer.RingBuffer[receivedPacket]
+
+	// closeChan is used to notify the run loop that it should terminate
+	closeChan chan struct{}
+	closeErr  atomic.Pointer[closeError]
+
+	ctx                   context.Context
+	ctxCancel             context.CancelCauseFunc
+	handshakeCompleteChan chan struct{}
+
+	undecryptablePackets          []receivedPacketWithChecksum // undecryptable packets, waiting for a change in encryption level
+	undecryptablePacketsToProcess []receivedPacketWithChecksum
+
+	earlyConnReadyChan chan struct{}
+	sentFirstPacket    bool
+	droppedInitialKeys bool
+	handshakeComplete  bool
+	handshakeConfirmed bool
+
+	receivedRetry       bool
+	versionNegotiated   bool
+	receivedFirstPacket bool
+
+	blocked blockMode
+
+	// the minimum of the max_idle_timeout values advertised by both endpoints
+	idleTimeout  time.Duration
+	creationTime monotime.Time
+	// The idle timeout is set based on the max of the time we received the last packet...
+	lastPacketReceivedTime monotime.Time
+	// ... and the time we sent a new ack-eliciting packet after receiving a packet.
+	firstAckElicitingPacketAfterIdleSentTime monotime.Time
+	// pacingDeadline is the time when the next packet should be sent
+	pacingDeadline monotime.Time
+
+	peerParams *wire.TransportParameters
+
+	timer *time.Timer
+	// keepAlivePingSent stores whether a keep alive PING is in flight.
+	// It is reset as soon as we receive a packet from the peer.
+	keepAlivePingSent bool
+	keepAliveInterval time.Duration
+
+	datagramQueue *datagramQueue
+
+	connStateMutex sync.Mutex
+	connState      ConnectionState
+
+	logID     string
+	qlogTrace qlogwriter.Trace
+	qlogger   qlogwriter.Recorder
+	logger    utils.Logger
+}
+
+var _ streamSender = &Conn{}
+
+type connTestHooks struct {
+	run                     func() error
+	earlyConnReady          func() <-chan struct{}
+	context                 func() context.Context
+	handshakeComplete       func() <-chan struct{}
+	closeWithTransportError func(TransportErrorCode)
+	destroy                 func(error)
+	handlePacket            func(receivedPacket)
+}
+
+type wrappedConn struct {
+	testHooks *connTestHooks
+	*Conn
+}
+
+var newConnection = func(
+	ctx context.Context,
+	ctxCancel context.CancelCauseFunc,
+	conn sendConn,
+	runner connRunner,
+	origDestConnID protocol.ConnectionID,
+	retrySrcConnID *protocol.ConnectionID,
+	clientDestConnID protocol.ConnectionID,
+	destConnID protocol.ConnectionID,
+	srcConnID protocol.ConnectionID,
+	connIDGenerator ConnectionIDGenerator,
+	statelessResetter *statelessResetter,
+	conf *Config,
+	tlsConf *tls.Config,
+	tokenGenerator *handshake.TokenGenerator,
+	clientAddressValidated bool,
+	rtt time.Duration,
+	qlogTrace qlogwriter.Trace,
+	logger utils.Logger,
+	v protocol.Version,
+) *wrappedConn {
+	s := &Conn{
+		ctx:                 ctx,
+		ctxCancel:           ctxCancel,
+		conn:                conn,
+		config:              conf,
+		handshakeDestConnID: destConnID,
+		srcConnIDLen:        srcConnID.Len(),
+		tokenGenerator:      tokenGenerator,
+		oneRTTStream:        newCryptoStream(),
+		perspective:         protocol.PerspectiveServer,
+		qlogTrace:           qlogTrace,
+		logger:              logger,
+		version:             v,
+	}
+	if qlogTrace != nil {
+		s.qlogger = qlogTrace.AddProducer()
+	}
+	if origDestConnID.Len() > 0 {
+		s.logID = origDestConnID.String()
+	} else {
+		s.logID = destConnID.String()
+	}
+	s.connIDManager = newConnIDManager(
+		destConnID,
+		func(token protocol.StatelessResetToken) { runner.AddResetToken(token, s) },
+		runner.RemoveResetToken,
+		s.queueControlFrame,
+	)
+	s.connIDGenerator = newConnIDGenerator(
+		runner,
+		srcConnID,
+		&clientDestConnID,
+		statelessResetter,
+		connRunnerCallbacks{
+			AddConnectionID:    func(connID protocol.ConnectionID) { runner.Add(connID, s) },
+			RemoveConnectionID: runner.Remove,
+			ReplaceWithClosed:  runner.ReplaceWithClosed,
+		},
+		s.queueControlFrame,
+		connIDGenerator,
+	)
+	s.preSetup()
+	s.rttStats.SetInitialRTT(rtt)
+	s.sentPacketHandler = ackhandler.NewSentPacketHandler(
+		0,
+		protocol.ByteCount(s.config.InitialPacketSize),
+		s.rttStats,
+		&s.connStats,
+		clientAddressValidated,
+		s.conn.capabilities().ECN,
+		s.receivedPacketHandler.IgnorePacketsBelow,
+		s.perspective,
+		s.qlogger,
+		s.logger,
+	)
+	s.maxPayloadSizeEstimate.Store(uint32(estimateMaxPayloadSize(protocol.ByteCount(s.config.InitialPacketSize))))
+	statelessResetToken := statelessResetter.GetStatelessResetToken(srcConnID)
+	params := &wire.TransportParameters{
+		InitialMaxStreamDataBidiLocal:   protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxStreamDataBidiRemote:  protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxStreamDataUni:         protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxData:                  protocol.ByteCount(s.config.InitialConnectionReceiveWindow),
+		MaxIdleTimeout:                  s.config.MaxIdleTimeout,
+		MaxBidiStreamNum:                protocol.StreamNum(s.config.MaxIncomingStreams),
+		MaxUniStreamNum:                 protocol.StreamNum(s.config.MaxIncomingUniStreams),
+		MaxAckDelay:                     protocol.MaxAckDelayInclGranularity,
+		AckDelayExponent:                protocol.AckDelayExponent,
+		MaxUDPPayloadSize:               protocol.MaxPacketBufferSize,
+		StatelessResetToken:             &statelessResetToken,
+		OriginalDestinationConnectionID: origDestConnID,
+		// For interoperability with quic-go versions before May 2023, this value must be set to a value
+		// different from protocol.DefaultActiveConnectionIDLimit.
+		// If set to the default value, it will be omitted from the transport parameters, which will make
+		// old quic-go versions interpret it as 0, instead of the default value of 2.
+		// See https://github.com/quic-go/quic-go/pull/3806.
+		ActiveConnectionIDLimit:   protocol.MaxActiveConnectionIDs,
+		InitialSourceConnectionID: srcConnID,
+		RetrySourceConnectionID:   retrySrcConnID,
+		EnableResetStreamAt:       conf.EnableStreamResetPartialDelivery,
+	}
+	if s.config.EnableDatagrams {
+		params.MaxDatagramFrameSize = wire.MaxDatagramSize
+	} else {
+		params.MaxDatagramFrameSize = protocol.InvalidByteCount
+	}
+	if s.qlogger != nil {
+		s.qlogTransportParameters(params, protocol.PerspectiveServer, false)
+	}
+	cs := handshake.NewCryptoSetupServer(
+		clientDestConnID,
+		conn.LocalAddr(),
+		conn.RemoteAddr(),
+		params,
+		tlsConf,
+		conf.Allow0RTT,
+		s.rttStats,
+		s.qlogger,
+		logger,
+		s.version,
+	)
+	s.cryptoStreamHandler = cs
+	s.packer = newPacketPacker(srcConnID, s.connIDManager.Get, s.initialStream, s.handshakeStream, s.sentPacketHandler, s.retransmissionQueue, cs, s.framer, &s.receivedPacketHandler, s.datagramQueue, s.perspective)
+	s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen)
+	s.cryptoStreamManager = newCryptoStreamManager(s.initialStream, s.handshakeStream, s.oneRTTStream)
+	return &wrappedConn{Conn: s}
+}
+
+// declare this as a variable, such that we can it mock it in the tests
+var newClientConnection = func(
+	ctx context.Context,
+	conn sendConn,
+	runner connRunner,
+	destConnID protocol.ConnectionID,
+	srcConnID protocol.ConnectionID,
+	connIDGenerator ConnectionIDGenerator,
+	statelessResetter *statelessResetter,
+	conf *Config,
+	tlsConf *tls.Config,
+	initialPacketNumber protocol.PacketNumber,
+	enable0RTT bool,
+	hasNegotiatedVersion bool,
+	qlogTrace qlogwriter.Trace,
+	logger utils.Logger,
+	v protocol.Version,
+) *wrappedConn {
+	s := &Conn{
+		conn:                conn,
+		config:              conf,
+		origDestConnID:      destConnID,
+		handshakeDestConnID: destConnID,
+		srcConnIDLen:        srcConnID.Len(),
+		perspective:         protocol.PerspectiveClient,
+		logID:               destConnID.String(),
+		logger:              logger,
+		qlogTrace:           qlogTrace,
+		versionNegotiated:   hasNegotiatedVersion,
+		version:             v,
+	}
+	if qlogTrace != nil {
+		s.qlogger = qlogTrace.AddProducer()
+	}
+	if s.qlogger != nil {
+		var srcAddr, destAddr *net.UDPAddr
+		if addr, ok := conn.LocalAddr().(*net.UDPAddr); ok {
+			srcAddr = addr
+		}
+		if addr, ok := conn.RemoteAddr().(*net.UDPAddr); ok {
+			destAddr = addr
+		}
+		s.qlogger.RecordEvent(startedConnectionEvent(srcAddr, destAddr))
+	}
+	s.connIDManager = newConnIDManager(
+		destConnID,
+		func(token protocol.StatelessResetToken) { runner.AddResetToken(token, s) },
+		runner.RemoveResetToken,
+		s.queueControlFrame,
+	)
+	s.connIDGenerator = newConnIDGenerator(
+		runner,
+		srcConnID,
+		nil,
+		statelessResetter,
+		connRunnerCallbacks{
+			AddConnectionID:    func(connID protocol.ConnectionID) { runner.Add(connID, s) },
+			RemoveConnectionID: runner.Remove,
+			ReplaceWithClosed:  runner.ReplaceWithClosed,
+		},
+		s.queueControlFrame,
+		connIDGenerator,
+	)
+	s.ctx, s.ctxCancel = context.WithCancelCause(ctx)
+	s.preSetup()
+	s.sentPacketHandler = ackhandler.NewSentPacketHandler(
+		initialPacketNumber,
+		protocol.ByteCount(s.config.InitialPacketSize),
+		s.rttStats,
+		&s.connStats,
+		false, // has no effect
+		s.conn.capabilities().ECN,
+		s.receivedPacketHandler.IgnorePacketsBelow,
+		s.perspective,
+		s.qlogger,
+		s.logger,
+	)
+	s.maxPayloadSizeEstimate.Store(uint32(estimateMaxPayloadSize(protocol.ByteCount(s.config.InitialPacketSize))))
+	oneRTTStream := newCryptoStream()
+	params := &wire.TransportParameters{
+		InitialMaxStreamDataBidiRemote: protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxStreamDataBidiLocal:  protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxStreamDataUni:        protocol.ByteCount(s.config.InitialStreamReceiveWindow),
+		InitialMaxData:                 protocol.ByteCount(s.config.InitialConnectionReceiveWindow),
+		MaxIdleTimeout:                 s.config.MaxIdleTimeout,
+		MaxBidiStreamNum:               protocol.StreamNum(s.config.MaxIncomingStreams),
+		MaxUniStreamNum:                protocol.StreamNum(s.config.MaxIncomingUniStreams),
+		MaxAckDelay:                    protocol.MaxAckDelayInclGranularity,
+		MaxUDPPayloadSize:              protocol.MaxPacketBufferSize,
+		AckDelayExponent:               protocol.AckDelayExponent,
+		// For interoperability with quic-go versions before May 2023, this value must be set to a value
+		// different from protocol.DefaultActiveConnectionIDLimit.
+		// If set to the default value, it will be omitted from the transport parameters, which will make
+		// old quic-go versions interpret it as 0, instead of the default value of 2.
+		// See https://github.com/quic-go/quic-go/pull/3806.
+		ActiveConnectionIDLimit:   protocol.MaxActiveConnectionIDs,
+		InitialSourceConnectionID: srcConnID,
+		EnableResetStreamAt:       conf.EnableStreamResetPartialDelivery,
+	}
+	if s.config.EnableDatagrams {
+		params.MaxDatagramFrameSize = wire.MaxDatagramSize
+	} else {
+		params.MaxDatagramFrameSize = protocol.InvalidByteCount
+	}
+	if s.qlogger != nil {
+		s.qlogTransportParameters(params, protocol.PerspectiveClient, false)
+	}
+	cs := handshake.NewCryptoSetupClient(
+		destConnID,
+		params,
+		tlsConf,
+		enable0RTT,
+		s.rttStats,
+		s.qlogger,
+		logger,
+		s.version,
+	)
+	s.cryptoStreamHandler = cs
+	s.cryptoStreamManager = newCryptoStreamManager(s.initialStream, s.handshakeStream, oneRTTStream)
+	s.unpacker = newPacketUnpacker(cs, s.srcConnIDLen)
+	s.packer = newPacketPacker(srcConnID, s.connIDManager.Get, s.initialStream, s.handshakeStream, s.sentPacketHandler, s.retransmissionQueue, cs, s.framer, &s.receivedPacketHandler, s.datagramQueue, s.perspective)
+	if len(tlsConf.ServerName) > 0 {
+		s.tokenStoreKey = tlsConf.ServerName
+	} else {
+		s.tokenStoreKey = conn.RemoteAddr().String()
+	}
+	if s.config.TokenStore != nil {
+		if token := s.config.TokenStore.Pop(s.tokenStoreKey); token != nil {
+			s.packer.SetToken(token.data)
+			s.rttStats.SetInitialRTT(token.rtt)
+		}
+	}
+	return &wrappedConn{Conn: s}
+}
+
+func (c *Conn) preSetup() {
+	c.largestRcvdAppData = protocol.InvalidPacketNumber
+	c.initialStream = newInitialCryptoStream(c.perspective == protocol.PerspectiveClient)
+	c.handshakeStream = newCryptoStream()
+	c.sendQueue = newSendQueue(c.conn)
+	c.retransmissionQueue = newRetransmissionQueue()
+	c.frameParser = *wire.NewFrameParser(
+		c.config.EnableDatagrams,
+		c.config.EnableStreamResetPartialDelivery,
+		false, // ACK_FREQUENCY is not supported yet
+	)
+	c.rttStats = utils.NewRTTStats()
+	c.connFlowController = newConnectionFlowController(
+		protocol.ByteCount(c.config.InitialConnectionReceiveWindow),
+		protocol.ByteCount(c.config.MaxConnectionReceiveWindow),
+		func(size protocol.ByteCount) bool {
+			if c.config.AllowConnectionWindowIncrease == nil {
+				return true
+			}
+			return c.config.AllowConnectionWindowIncrease(c, uint64(size))
+		},
+		c.rttStats,
+		c.logger,
+	)
+	c.earlyConnReadyChan = make(chan struct{})
+	c.streamsMap = newStreamsMap(
+		c.ctx,
+		c,
+		c.queueControlFrame,
+		c.newFlowController,
+		uint64(c.config.MaxIncomingStreams),
+		uint64(c.config.MaxIncomingUniStreams),
+		c.perspective,
+	)
+	c.framer = newFramer(c.connFlowController)
+	c.receivedPackets.Init(8)
+	c.notifyReceivedPacket = make(chan struct{}, 1)
+	c.closeChan = make(chan struct{}, 1)
+	c.sendingScheduled = make(chan struct{}, 1)
+	c.handshakeCompleteChan = make(chan struct{})
+
+	now := monotime.Now()
+	c.lastPacketReceivedTime = now
+	c.creationTime = now
+
+	c.receivedPacketHandler = *ackhandler.NewReceivedPacketHandler(c.logger)
+
+	c.datagramQueue = newDatagramQueue(c.scheduleSending, c.logger)
+	c.connState.Version = c.version
+}
+
+// run the connection main loop
+func (c *Conn) run() (err error) {
+	defer func() { c.ctxCancel(err) }()
+
+	defer func() {
+		// drain queued packets that will never be processed
+		c.receivedPacketMx.Lock()
+		defer c.receivedPacketMx.Unlock()
+
+		for !c.receivedPackets.Empty() {
+			p := c.receivedPackets.PopFront()
+			p.buffer.Decrement()
+			p.buffer.MaybeRelease()
+		}
+	}()
+
+	c.timer = time.NewTimer(monotime.Until(c.idleTimeoutStartTime().Add(c.config.HandshakeIdleTimeout)))
+
+	if err := c.cryptoStreamHandler.StartHandshake(c.ctx); err != nil {
+		return err
+	}
+	if err := c.handleHandshakeEvents(monotime.Now()); err != nil {
+		return err
+	}
+	go func() {
+		if err := c.sendQueue.Run(); err != nil {
+			c.destroyImpl(err)
+		}
+	}()
+
+	if c.perspective == protocol.PerspectiveClient {
+		c.scheduleSending() // so the ClientHello actually gets sent
+	}
+
+	var sendQueueAvailable <-chan struct{}
+
+runLoop:
+	for {
+		if c.framer.QueuedTooManyControlFrames() {
+			c.setCloseError(&closeError{err: &qerr.TransportError{ErrorCode: InternalError}})
+			break runLoop
+		}
+		// Close immediately if requested
+		select {
+		case <-c.closeChan:
+			break runLoop
+		default:
+		}
+
+		// no need to set a timer if we can send packets immediately
+		if c.pacingDeadline != deadlineSendImmediately {
+			c.maybeResetTimer()
+		}
+
+		// 1st: handle undecryptable packets, if any.
+		// This can only occur before completion of the handshake.
+		if len(c.undecryptablePacketsToProcess) > 0 {
+			var processedUndecryptablePacket bool
+			queue := c.undecryptablePacketsToProcess
+			c.undecryptablePacketsToProcess = nil
+			for _, p := range queue {
+				processed, err := c.handleOnePacket(p.receivedPacket, p.checksum)
+				if err != nil {
+					c.setCloseError(&closeError{err: err})
+					break runLoop
+				}
+				if processed {
+					processedUndecryptablePacket = true
+				}
+			}
+			if processedUndecryptablePacket {
+				// if we processed any undecryptable packets, jump to the resetting of the timers directly
+				continue
+			}
+		}
+
+		// 2nd: receive packets.
+		processed, err := c.handlePackets() // don't check receivedPackets.Len() in the run loop to avoid locking the mutex
+		if err != nil {
+			c.setCloseError(&closeError{err: err})
+			break runLoop
+		}
+
+		// We don't need to wait for new events if:
+		// * we processed packets: we probably need to send an ACK, and potentially more data
+		// * the pacer allows us to send more packets immediately
+		shouldProceedImmediately := sendQueueAvailable == nil && (processed || c.pacingDeadline.Equal(deadlineSendImmediately))
+		if !shouldProceedImmediately {
+			// 3rd: wait for something to happen:
+			// * closing of the connection
+			// * timer firing
+			// * sending scheduled
+			// * send queue available
+			// * received packets
+			select {
+			case <-c.closeChan:
+				break runLoop
+			case <-c.timer.C:
+			case <-c.sendingScheduled:
+			case <-sendQueueAvailable:
+			case <-c.notifyReceivedPacket:
+				wasProcessed, err := c.handlePackets()
+				if err != nil {
+					c.setCloseError(&closeError{err: err})
+					break runLoop
+				}
+				// if we processed any undecryptable packets, jump to the resetting of the timers directly
+				if !wasProcessed {
+					continue
+				}
+			}
+		}
+
+		// Check for loss detection timeout.
+		// This could cause packets to be declared lost, and retransmissions to be enqueued.
+		now := monotime.Now()
+		if timeout := c.sentPacketHandler.GetLossDetectionTimeout(); !timeout.IsZero() && !timeout.After(now) {
+			if err := c.sentPacketHandler.OnLossDetectionTimeout(now); err != nil {
+				c.setCloseError(&closeError{err: err})
+				break runLoop
+			}
+		}
+
+		if keepAliveTime := c.nextKeepAliveTime(); !keepAliveTime.IsZero() && !now.Before(keepAliveTime) {
+			// send a PING frame since there is no activity in the connection
+			c.logger.Debugf("Sending a keep-alive PING to keep the connection alive.")
+			c.framer.QueueControlFrame(&wire.PingFrame{})
+			c.keepAlivePingSent = true
+		} else if !c.handshakeComplete && now.Sub(c.creationTime) >= c.config.handshakeTimeout() {
+			c.destroyImpl(qerr.ErrHandshakeTimeout)
+			break runLoop
+		} else {
+			idleTimeoutStartTime := c.idleTimeoutStartTime()
+			if (!c.handshakeComplete && now.Sub(idleTimeoutStartTime) >= c.config.HandshakeIdleTimeout) ||
+				(c.handshakeComplete && !now.Before(c.nextIdleTimeoutTime())) {
+				c.destroyImpl(qerr.ErrIdleTimeout)
+				break runLoop
+			}
+		}
+
+		c.connIDGenerator.RemoveRetiredConnIDs(now)
+
+		if c.perspective == protocol.PerspectiveClient {
+			pm := c.pathManagerOutgoing.Load()
+			if pm != nil {
+				tr, ok := pm.ShouldSwitchPath()
+				if ok {
+					c.switchToNewPath(tr, now)
+				}
+			}
+		}
+
+		if c.sendQueue.WouldBlock() {
+			// The send queue is still busy sending out packets. Wait until there's space to enqueue new packets.
+			sendQueueAvailable = c.sendQueue.Available()
+			// Cancel the pacing timer, as we can't send any more packets until the send queue is available again.
+			c.pacingDeadline = 0
+			c.blocked = blockModeHardBlocked
+			continue
+		}
+
+		if c.closeErr.Load() != nil {
+			break runLoop
+		}
+
+		c.blocked = blockModeNone // sending might set it back to true if we're congestion limited
+		if err := c.triggerSending(now); err != nil {
+			c.setCloseError(&closeError{err: err})
+			break runLoop
+		}
+		if c.sendQueue.WouldBlock() {
+			// The send queue is still busy sending out packets. Wait until there's space to enqueue new packets.
+			sendQueueAvailable = c.sendQueue.Available()
+			// Cancel the pacing timer, as we can't send any more packets until the send queue is available again.
+			c.pacingDeadline = 0
+			c.blocked = blockModeHardBlocked
+		} else {
+			sendQueueAvailable = nil
+		}
+	}
+
+	closeErr := c.closeErr.Load()
+	c.cryptoStreamHandler.Close()
+	c.sendQueue.Close() // close the send queue before sending the CONNECTION_CLOSE
+	c.handleCloseError(closeErr)
+	if c.qlogger != nil {
+		if e := (&errCloseForRecreating{}); !errors.As(closeErr.err, &e) {
+			c.qlogger.Close()
+		}
+	}
+	c.logger.Infof("Connection %s closed.", c.logID)
+	c.timer.Stop()
+	return closeErr.err
+}
+
+// blocks until the early connection can be used
+func (c *Conn) earlyConnReady() <-chan struct{} {
+	return c.earlyConnReadyChan
+}
+
+// Context returns a context that is cancelled when the connection is closed.
+// The cancellation cause is set to the error that caused the connection to close.
+func (c *Conn) Context() context.Context {
+	return c.ctx
+}
+
+func (c *Conn) supportsDatagrams() bool {
+	return c.peerParams.MaxDatagramFrameSize > 0
+}
+
+// ConnectionState returns basic details about the QUIC connection.
+func (c *Conn) ConnectionState() ConnectionState {
+	c.connStateMutex.Lock()
+	defer c.connStateMutex.Unlock()
+
+	cs := c.cryptoStreamHandler.ConnectionState()
+	c.connState.TLS = cs.ConnectionState
+	c.connState.Used0RTT = cs.Used0RTT
+	if c.peerParams != nil {
+		c.connState.SupportsDatagrams.Remote = c.supportsDatagrams()
+		c.connState.SupportsStreamResetPartialDelivery.Remote = c.peerParams.EnableResetStreamAt
+	}
+	c.connState.SupportsDatagrams.Local = c.config.EnableDatagrams
+	c.connState.SupportsStreamResetPartialDelivery.Local = c.config.EnableStreamResetPartialDelivery
+	c.connState.GSO = c.conn.capabilities().GSO
+	return c.connState
+}
+
+// ConnectionStats contains statistics about the QUIC connection
+type ConnectionStats struct {
+	// MinRTT is the estimate of the minimum RTT observed on the active network
+	// path.
+	MinRTT time.Duration
+	// LatestRTT is the last RTT sample observed on the active network path.
+	LatestRTT time.Duration
+	// SmoothedRTT is an exponentially weighted moving average of an endpoint's
+	// RTT samples. See https://www.rfc-editor.org/rfc/rfc9002#section-5.3
+	SmoothedRTT time.Duration
+	// MeanDeviation estimates the variation in the RTT samples using a mean
+	// variation. See https://www.rfc-editor.org/rfc/rfc9002#section-5.3
+	MeanDeviation time.Duration
+
+	// BytesSent is the number of bytes sent on the underlying connection,
+	// including retransmissions. Does not include UDP or any other outer
+	// framing.
+	BytesSent uint64
+	// PacketsSent is the number of packets sent on the underlying connection,
+	// including those that are determined to have been lost.
+	PacketsSent uint64
+	// BytesReceived is the number of total bytes received on the underlying
+	// connection, including duplicate data for streams. Does not include UDP or
+	// any other outer framing.
+	BytesReceived uint64
+	// PacketsReceived is the number of total packets received on the underlying
+	// connection, including packets that were not processable.
+	PacketsReceived uint64
+	// BytesLost is the number of bytes lost on the underlying connection (does
+	// not monotonically increase, because packets that are declared lost can
+	// subsequently be received). Does not include UDP or any other outer
+	// framing.
+	BytesLost uint64
+	// PacketsLost is the number of packets lost on the underlying connection
+	// (does not monotonically increase, because packets that are declared lost
+	// can subsequently be received).
+	PacketsLost uint64
+}
+
+func (c *Conn) ConnectionStats() ConnectionStats {
+	return ConnectionStats{
+		MinRTT:        c.rttStats.MinRTT(),
+		LatestRTT:     c.rttStats.LatestRTT(),
+		SmoothedRTT:   c.rttStats.SmoothedRTT(),
+		MeanDeviation: c.rttStats.MeanDeviation(),
+
+		BytesSent:       c.connStats.BytesSent.Load(),
+		PacketsSent:     c.connStats.PacketsSent.Load(),
+		BytesReceived:   c.connStats.BytesReceived.Load(),
+		PacketsReceived: c.connStats.PacketsReceived.Load(),
+		BytesLost:       c.connStats.BytesLost.Load(),
+		PacketsLost:     c.connStats.PacketsLost.Load(),
+	}
+}
+
+// Time when the connection should time out
+func (c *Conn) nextIdleTimeoutTime() monotime.Time {
+	idleTimeout := max(c.idleTimeout, c.rttStats.PTO(true)*3)
+	return c.idleTimeoutStartTime().Add(idleTimeout)
+}
+
+// Time when the next keep-alive packet should be sent.
+// It returns a zero time if no keep-alive should be sent.
+func (c *Conn) nextKeepAliveTime() monotime.Time {
+	if c.config.KeepAlivePeriod == 0 || c.keepAlivePingSent {
+		return 0
+	}
+	keepAliveInterval := max(c.keepAliveInterval, c.rttStats.PTO(true)*3/2)
+	return c.lastPacketReceivedTime.Add(keepAliveInterval)
+}
+
+func (c *Conn) maybeResetTimer() {
+	var deadline monotime.Time
+	if !c.handshakeComplete {
+		deadline = c.creationTime.Add(c.config.handshakeTimeout())
+		if t := c.idleTimeoutStartTime().Add(c.config.HandshakeIdleTimeout); t.Before(deadline) {
+			deadline = t
+		}
+	} else {
+		// A keep-alive packet is ack-eliciting, so it can only be sent if the connection is
+		// neither congestion limited nor hard-blocked.
+		if c.blocked != blockModeNone {
+			deadline = c.nextIdleTimeoutTime()
+		} else {
+			if keepAliveTime := c.nextKeepAliveTime(); !keepAliveTime.IsZero() {
+				deadline = keepAliveTime
+			} else {
+				deadline = c.nextIdleTimeoutTime()
+			}
+		}
+	}
+	// If the connection is hard-blocked, we can't even send acknowledgments,
+	// nor can we send PTO probe packets.
+	if c.blocked == blockModeHardBlocked {
+		c.timer.Reset(monotime.Until(deadline))
+		return
+	}
+
+	if t := c.receivedPacketHandler.GetAlarmTimeout(); !t.IsZero() && t.Before(deadline) {
+		deadline = t
+	}
+	if t := c.sentPacketHandler.GetLossDetectionTimeout(); !t.IsZero() && t.Before(deadline) {
+		deadline = t
+	}
+	if c.blocked == blockModeCongestionLimited {
+		c.timer.Reset(monotime.Until(deadline))
+		return
+	}
+
+	if !c.pacingDeadline.IsZero() && c.pacingDeadline.Before(deadline) {
+		deadline = c.pacingDeadline
+	}
+	c.timer.Reset(monotime.Until(deadline))
+}
+
+func (c *Conn) idleTimeoutStartTime() monotime.Time {
+	startTime := c.lastPacketReceivedTime
+	if t := c.firstAckElicitingPacketAfterIdleSentTime; !t.IsZero() && t.After(startTime) {
+		startTime = t
+	}
+	return startTime
+}
+
+func (c *Conn) switchToNewPath(tr *Transport, now monotime.Time) {
+	initialPacketSize := protocol.ByteCount(c.config.InitialPacketSize)
+	c.sentPacketHandler.MigratedPath(now, initialPacketSize)
+	maxPacketSize := protocol.ByteCount(protocol.MaxPacketBufferSize)
+	if c.peerParams.MaxUDPPayloadSize > 0 && c.peerParams.MaxUDPPayloadSize < maxPacketSize {
+		maxPacketSize = c.peerParams.MaxUDPPayloadSize
+	}
+	c.mtuDiscoverer.Reset(now, initialPacketSize, maxPacketSize)
+	c.conn = newSendConn(tr.conn, c.conn.RemoteAddr(), packetInfo{}, utils.DefaultLogger) // TODO: find a better way
+	c.sendQueue.Close()
+	c.sendQueue = newSendQueue(c.conn)
+	go func() {
+		if err := c.sendQueue.Run(); err != nil {
+			c.destroyImpl(err)
+		}
+	}()
+}
+
+func (c *Conn) handleHandshakeComplete(now monotime.Time) error {
+	defer close(c.handshakeCompleteChan)
+	// Once the handshake completes, we have derived 1-RTT keys.
+	// There's no point in queueing undecryptable packets for later decryption anymore.
+	c.undecryptablePackets = nil
+
+	c.connIDManager.SetHandshakeComplete()
+	c.connIDGenerator.SetHandshakeComplete(now.Add(3 * c.rttStats.PTO(false)))
+
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.ALPNInformation{
+			ChosenALPN: c.cryptoStreamHandler.ConnectionState().NegotiatedProtocol,
+		})
+	}
+
+	// The server applies transport parameters right away, but the client side has to wait for handshake completion.
+	// During a 0-RTT connection, the client is only allowed to use the new transport parameters for 1-RTT packets.
+	if c.perspective == protocol.PerspectiveClient {
+		c.applyTransportParameters()
+		return nil
+	}
+
+	// All these only apply to the server side.
+	if err := c.handleHandshakeConfirmed(now); err != nil {
+		return err
+	}
+
+	ticket, err := c.cryptoStreamHandler.GetSessionTicket()
+	if err != nil {
+		return err
+	}
+	if ticket != nil { // may be nil if session tickets are disabled via tls.Config.SessionTicketsDisabled
+		c.oneRTTStream.Write(ticket)
+		for c.oneRTTStream.HasData() {
+			if cf := c.oneRTTStream.PopCryptoFrame(protocol.MaxPostHandshakeCryptoFrameSize); cf != nil {
+				c.queueControlFrame(cf)
+			}
+		}
+	}
+	token, err := c.tokenGenerator.NewToken(c.conn.RemoteAddr(), c.rttStats.SmoothedRTT())
+	if err != nil {
+		return err
+	}
+	c.queueControlFrame(&wire.NewTokenFrame{Token: token})
+	c.queueControlFrame(&wire.HandshakeDoneFrame{})
+	return nil
+}
+
+func (c *Conn) handleHandshakeConfirmed(now monotime.Time) error {
+	// Drop initial keys.
+	// On the client side, this should have happened when sending the first Handshake packet,
+	// but this is not guaranteed if the server misbehaves.
+	// See CVE-2025-59530 for more details.
+	if err := c.dropEncryptionLevel(protocol.EncryptionInitial, now); err != nil {
+		return err
+	}
+	if err := c.dropEncryptionLevel(protocol.EncryptionHandshake, now); err != nil {
+		return err
+	}
+
+	c.handshakeConfirmed = true
+	c.cryptoStreamHandler.SetHandshakeConfirmed()
+
+	if !c.config.DisablePathMTUDiscovery && c.conn.capabilities().DF {
+		c.mtuDiscoverer.Start(now)
+	}
+	return nil
+}
+
+const maxPacketsToProcess = 32
+
+func (c *Conn) handlePackets() (wasProcessed bool, _ error) {
+	// Process packets from the receivedPackets queue.
+	// Limit the number of packets to process to maxPacketsToProcess,
+	// so we eventually get a chance to send out an ACK when receiving a lot of packets.
+	c.receivedPacketMx.Lock()
+
+	if c.receivedPackets.Empty() {
+		c.receivedPacketMx.Unlock()
+		return false, nil
+	}
+
+	var hasMorePackets bool
+	for range maxPacketsToProcess {
+		p := c.receivedPackets.PopFront()
+		c.receivedPacketMx.Unlock()
+
+		var datagramPayloadChecksum qlog.DatagramPayloadChecksum
+		if c.qlogger != nil && wire.IsLongHeaderPacket(p.data[0]) {
+			datagramPayloadChecksum = qlog.CalculateDatagramPayloadChecksum(p.data)
+		}
+		processed, err := c.handleOnePacket(p, datagramPayloadChecksum)
+		if err != nil {
+			return false, err
+		}
+		if processed {
+			wasProcessed = true
+		}
+		c.receivedPacketMx.Lock()
+		hasMorePackets = !c.receivedPackets.Empty()
+		if !hasMorePackets {
+			break
+		}
+		// Prioritize sending of new CRYPTO data.
+		// This is especially relevant when processing 0-RTT packets.
+		if !c.handshakeComplete && (c.initialStream.HasData() || c.handshakeStream.HasData()) {
+			break
+		}
+	}
+	c.receivedPacketMx.Unlock()
+
+	if hasMorePackets {
+		select {
+		case c.notifyReceivedPacket <- struct{}{}:
+		default:
+		}
+	}
+	return wasProcessed, nil
+}
+
+func (c *Conn) handleOnePacket(rp receivedPacket, datagramPayloadChecksum qlog.DatagramPayloadChecksum) (wasProcessed bool, _ error) {
+	c.sentPacketHandler.ReceivedBytes(rp.Size(), rp.rcvTime)
+
+	if wire.IsVersionNegotiationPacket(rp.data) {
+		return false, c.handleVersionNegotiationPacket(rp)
+	}
+
+	var counter uint8
+	var lastConnID protocol.ConnectionID
+	data := rp.data
+	p := rp
+	for len(data) > 0 {
+		if counter > 0 {
+			p = *(p.Clone())
+			p.data = data
+
+			destConnID, err := wire.ParseConnectionID(p.data, c.srcConnIDLen)
+			if err != nil {
+				if c.qlogger != nil {
+					c.qlogger.RecordEvent(qlog.PacketDropped{
+						Raw:                     qlog.RawInfo{Length: len(data)},
+						DatagramPayloadChecksum: datagramPayloadChecksum,
+						Trigger:                 qlog.PacketDropHeaderParseError,
+					})
+				}
+				c.logger.Debugf("error parsing packet, couldn't parse connection ID: %s", err)
+				break
+			}
+			if destConnID != lastConnID {
+				if c.qlogger != nil {
+					c.qlogger.RecordEvent(qlog.PacketDropped{
+						Header:                  qlog.PacketHeader{DestConnectionID: destConnID},
+						Raw:                     qlog.RawInfo{Length: len(data)},
+						DatagramPayloadChecksum: datagramPayloadChecksum,
+						Trigger:                 qlog.PacketDropUnknownConnectionID,
+					})
+				}
+				c.logger.Debugf("coalesced packet has different destination connection ID: %s, expected %s", destConnID, lastConnID)
+				break
+			}
+		}
+
+		if wire.IsLongHeaderPacket(p.data[0]) {
+			hdr, packetData, rest, err := wire.ParsePacket(p.data)
+			if err != nil {
+				if c.qlogger != nil {
+					if err == wire.ErrUnsupportedVersion {
+						c.qlogger.RecordEvent(qlog.PacketDropped{
+							Header:                  qlog.PacketHeader{Version: hdr.Version},
+							Raw:                     qlog.RawInfo{Length: len(data)},
+							DatagramPayloadChecksum: datagramPayloadChecksum,
+							Trigger:                 qlog.PacketDropUnsupportedVersion,
+						})
+					} else {
+						c.qlogger.RecordEvent(qlog.PacketDropped{
+							Raw:                     qlog.RawInfo{Length: len(data)},
+							DatagramPayloadChecksum: datagramPayloadChecksum,
+							Trigger:                 qlog.PacketDropHeaderParseError,
+						})
+					}
+				}
+				c.logger.Debugf("error parsing packet: %s", err)
+				break
+			}
+			lastConnID = hdr.DestConnectionID
+
+			if hdr.Version != c.version {
+				if c.qlogger != nil {
+					c.qlogger.RecordEvent(qlog.PacketDropped{
+						Raw:                     qlog.RawInfo{Length: len(data)},
+						DatagramPayloadChecksum: datagramPayloadChecksum,
+						Trigger:                 qlog.PacketDropUnexpectedVersion,
+					})
+				}
+				c.logger.Debugf("Dropping packet with version %x. Expected %x.", hdr.Version, c.version)
+				break
+			}
+
+			if counter > 0 {
+				p.buffer.Split()
+			}
+			counter++
+
+			// only log if this actually a coalesced packet
+			if c.logger.Debug() && (counter > 1 || len(rest) > 0) {
+				c.logger.Debugf("Parsed a coalesced packet. Part %d: %d bytes. Remaining: %d bytes.", counter, len(packetData), len(rest))
+			}
+
+			p.data = packetData
+
+			processed, err := c.handleLongHeaderPacket(p, hdr, datagramPayloadChecksum)
+			if err != nil {
+				return false, err
+			}
+			if processed {
+				wasProcessed = true
+			}
+			data = rest
+		} else {
+			if counter > 0 {
+				p.buffer.Split()
+			}
+			processed, err := c.handleShortHeaderPacket(p, counter > 0, datagramPayloadChecksum)
+			if err != nil {
+				return false, err
+			}
+			if processed {
+				wasProcessed = true
+			}
+			break
+		}
+	}
+
+	p.buffer.MaybeRelease()
+	c.blocked = blockModeNone
+	return wasProcessed, nil
+}
+
+func (c *Conn) handleShortHeaderPacket(
+	p receivedPacket,
+	isCoalesced bool,
+	datagramPayloadChecksum qlog.DatagramPayloadChecksum, // only for logging
+) (wasProcessed bool, _ error) {
+	var wasQueued bool
+
+	defer func() {
+		// Put back the packet buffer if the packet wasn't queued for later decryption.
+		if !wasQueued {
+			p.buffer.Decrement()
+		}
+	}()
+
+	destConnID, err := wire.ParseConnectionID(p.data, c.srcConnIDLen)
+	if err != nil {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketType1RTT,
+					PacketNumber: protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: len(p.data)},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropHeaderParseError,
+			})
+		}
+		return false, nil
+	}
+	pn, pnLen, keyPhase, data, err := c.unpacker.UnpackShortHeader(p.rcvTime, p.data)
+	if err != nil {
+		// Stateless reset packets (see RFC 9000, section 10.3):
+		// * fill the entire UDP datagram (i.e. they cannot be part of a coalesced packet)
+		// * are short header packets (first bit is 0)
+		// * have the QUIC bit set (second bit is 1)
+		// * are at least 21 bytes long
+		if !isCoalesced && len(p.data) >= protocol.MinReceivedStatelessResetSize && p.data[0]&0b11000000 == 0b01000000 {
+			token := protocol.StatelessResetToken(p.data[len(p.data)-16:])
+			if c.connIDManager.IsActiveStatelessResetToken(token) {
+				return false, &StatelessResetError{}
+			}
+		}
+		wasQueued, err = c.handleUnpackError(err, p, qlog.PacketType1RTT, datagramPayloadChecksum)
+		return false, err
+	}
+	c.largestRcvdAppData = max(c.largestRcvdAppData, pn)
+
+	if c.logger.Debug() {
+		c.logger.Debugf("<- Reading packet %d (%d bytes) for connection %s, 1-RTT", pn, p.Size(), destConnID)
+		wire.LogShortHeader(c.logger, destConnID, pn, pnLen, keyPhase)
+	}
+
+	if c.receivedPacketHandler.IsPotentiallyDuplicate(pn, protocol.Encryption1RTT) {
+		c.logger.Debugf("Dropping (potentially) duplicate packet.")
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketType1RTT,
+					PacketNumber: pn,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropDuplicate,
+			})
+		}
+		return false, nil
+	}
+
+	var log func([]qlog.Frame)
+	if c.qlogger != nil {
+		log = func(frames []qlog.Frame) {
+			c.qlogger.RecordEvent(qlog.PacketReceived{
+				Header: qlog.PacketHeader{
+					PacketType:       qlog.PacketType1RTT,
+					DestConnectionID: destConnID,
+					PacketNumber:     pn,
+					KeyPhaseBit:      keyPhase,
+				},
+				Raw: qlog.RawInfo{
+					Length:        int(p.Size()),
+					PayloadLength: int(p.Size() - wire.ShortHeaderLen(destConnID, pnLen)),
+				},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Frames:                  frames,
+				ECN:                     toQlogECN(p.ecn),
+			})
+		}
+	}
+	isNonProbing, pathChallenge, err := c.handleUnpackedShortHeaderPacket(destConnID, pn, data, p.ecn, p.rcvTime, log)
+	if err != nil {
+		return false, err
+	}
+
+	// In RFC 9000, only the client can migrate between paths.
+	if c.perspective == protocol.PerspectiveClient {
+		return true, nil
+	}
+	if addrsEqual(p.remoteAddr, c.RemoteAddr()) {
+		return true, nil
+	}
+
+	var shouldSwitchPath bool
+	if c.pathManager == nil {
+		c.pathManager = newPathManager(
+			c.connIDManager.GetConnIDForPath,
+			c.connIDManager.RetireConnIDForPath,
+			c.logger,
+		)
+	}
+	destConnID, frames, shouldSwitchPath := c.pathManager.HandlePacket(p.remoteAddr, p.rcvTime, pathChallenge, isNonProbing)
+	if len(frames) > 0 {
+		probe, buf, err := c.packer.PackPathProbePacket(destConnID, frames, c.version)
+		if err != nil {
+			return true, err
+		}
+		c.logger.Debugf("sending path probe packet to %s", p.remoteAddr)
+		c.logShortHeaderPacketWithDatagramPayloadChecksum(probe, protocol.ECNNon, buf.Len(), false, datagramPayloadChecksum)
+		c.registerPackedShortHeaderPacket(probe, protocol.ECNNon, p.rcvTime)
+		c.sendQueue.SendProbe(buf, p.remoteAddr, p.info)
+	}
+	// We only switch paths in response to the highest-numbered non-probing packet,
+	// see section 9.3 of RFC 9000.
+	if !shouldSwitchPath || pn != c.largestRcvdAppData {
+		return true, nil
+	}
+	c.pathManager.SwitchToPath(p.remoteAddr)
+	c.sentPacketHandler.MigratedPath(p.rcvTime, protocol.ByteCount(c.config.InitialPacketSize))
+	maxPacketSize := protocol.ByteCount(protocol.MaxPacketBufferSize)
+	if c.peerParams.MaxUDPPayloadSize > 0 && c.peerParams.MaxUDPPayloadSize < maxPacketSize {
+		maxPacketSize = c.peerParams.MaxUDPPayloadSize
+	}
+	c.mtuDiscoverer.Reset(
+		p.rcvTime,
+		protocol.ByteCount(c.config.InitialPacketSize),
+		maxPacketSize,
+	)
+	c.conn.ChangeRemoteAddr(p.remoteAddr, p.info)
+	return true, nil
+}
+
+func (c *Conn) handleLongHeaderPacket(p receivedPacket, hdr *wire.Header, datagramPayloadChecksum qlog.DatagramPayloadChecksum) (wasProcessed bool, _ error) {
+	var wasQueued bool
+
+	defer func() {
+		// Put back the packet buffer if the packet wasn't queued for later decryption.
+		if !wasQueued {
+			p.buffer.Decrement()
+		}
+	}()
+
+	if hdr.Type == protocol.PacketTypeRetry {
+		return c.handleRetryPacket(hdr, p.data, p.rcvTime), nil
+	}
+
+	// The server can change the source connection ID with the first Handshake packet.
+	// After this, all packets with a different source connection have to be ignored.
+	if c.receivedFirstPacket && hdr.Type == protocol.PacketTypeInitial && hdr.SrcConnectionID != c.handshakeDestConnID {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketTypeInitial,
+					PacketNumber: protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropUnknownConnectionID,
+			})
+		}
+		c.logger.Debugf("Dropping Initial packet (%d bytes) with unexpected source connection ID: %s (expected %s)", p.Size(), hdr.SrcConnectionID, c.handshakeDestConnID)
+		return false, nil
+	}
+	// drop 0-RTT packets, if we are a client
+	if c.perspective == protocol.PerspectiveClient && hdr.Type == protocol.PacketType0RTT {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketType0RTT,
+					PacketNumber: protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return false, nil
+	}
+
+	packet, err := c.unpacker.UnpackLongHeader(hdr, p.data)
+	if err != nil {
+		wasQueued, err = c.handleUnpackError(err, p, toQlogPacketType(hdr.Type), datagramPayloadChecksum)
+		return false, err
+	}
+
+	if c.logger.Debug() {
+		c.logger.Debugf("<- Reading packet %d (%d bytes) for connection %s, %s", packet.hdr.PacketNumber, p.Size(), hdr.DestConnectionID, packet.encryptionLevel)
+		packet.hdr.Log(c.logger)
+	}
+
+	if pn := packet.hdr.PacketNumber; c.receivedPacketHandler.IsPotentiallyDuplicate(pn, packet.encryptionLevel) {
+		c.logger.Debugf("Dropping (potentially) duplicate packet.")
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       toQlogPacketType(packet.hdr.Type),
+					DestConnectionID: hdr.DestConnectionID,
+					SrcConnectionID:  hdr.SrcConnectionID,
+					PacketNumber:     pn,
+					Version:          packet.hdr.Version,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size()), PayloadLength: int(packet.hdr.Length)},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropDuplicate,
+			})
+		}
+		return false, nil
+	}
+
+	if err := c.handleUnpackedLongHeaderPacket(packet, p.ecn, p.rcvTime, datagramPayloadChecksum, p.Size()); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (c *Conn) handleUnpackError(err error, p receivedPacket, pt qlog.PacketType, datagramPayloadChecksum qlog.DatagramPayloadChecksum) (wasQueued bool, _ error) {
+	switch err {
+	case handshake.ErrKeysDropped:
+		if c.qlogger != nil {
+			connID, _ := wire.ParseConnectionID(p.data, c.srcConnIDLen)
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       pt,
+					DestConnectionID: connID,
+					PacketNumber:     protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropKeyUnavailable,
+			})
+		}
+		c.logger.Debugf("Dropping %s packet (%d bytes) because we already dropped the keys.", pt, p.Size())
+		return false, nil
+	case handshake.ErrKeysNotYetAvailable:
+		// Sealer for this encryption level not yet available.
+		// Try again later.
+		c.tryQueueingUndecryptablePacket(p, pt, datagramPayloadChecksum)
+		return true, nil
+	case wire.ErrInvalidReservedBits:
+		return false, &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: err.Error(),
+		}
+	case handshake.ErrDecryptionFailed:
+		// This might be a packet injected by an attacker. Drop it.
+		if c.qlogger != nil {
+			connID, _ := wire.ParseConnectionID(p.data, c.srcConnIDLen)
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       pt,
+					DestConnectionID: connID,
+					PacketNumber:     protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropPayloadDecryptError,
+			})
+		}
+		c.logger.Debugf("Dropping %s packet (%d bytes) that could not be unpacked. Error: %s", pt, p.Size(), err)
+		return false, nil
+	default:
+		var headerErr *headerParseError
+		if errors.As(err, &headerErr) {
+			// This might be a packet injected by an attacker. Drop it.
+			if c.qlogger != nil {
+				connID, _ := wire.ParseConnectionID(p.data, c.srcConnIDLen)
+				c.qlogger.RecordEvent(qlog.PacketDropped{
+					Header: qlog.PacketHeader{
+						PacketType:       pt,
+						DestConnectionID: connID,
+						PacketNumber:     protocol.InvalidPacketNumber,
+					},
+					Raw:                     qlog.RawInfo{Length: int(p.Size())},
+					DatagramPayloadChecksum: datagramPayloadChecksum,
+					Trigger:                 qlog.PacketDropHeaderParseError,
+				})
+			}
+			c.logger.Debugf("Dropping %s packet (%d bytes) for which we couldn't unpack the header. Error: %s", pt, p.Size(), err)
+			return false, nil
+		}
+		// This is an error returned by the AEAD (other than ErrDecryptionFailed).
+		// For example, a PROTOCOL_VIOLATION due to key updates.
+		return false, err
+	}
+}
+
+func (c *Conn) handleRetryPacket(hdr *wire.Header, data []byte, rcvTime monotime.Time) bool /* was this a valid Retry */ {
+	if c.perspective == protocol.PerspectiveServer {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       qlog.PacketTypeRetry,
+					SrcConnectionID:  hdr.SrcConnectionID,
+					DestConnectionID: hdr.DestConnectionID,
+					Version:          hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: len(data)},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		c.logger.Debugf("Ignoring Retry.")
+		return false
+	}
+	if c.receivedFirstPacket {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       qlog.PacketTypeRetry,
+					SrcConnectionID:  hdr.SrcConnectionID,
+					DestConnectionID: hdr.DestConnectionID,
+					Version:          hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: len(data)},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		c.logger.Debugf("Ignoring Retry, since we already received a packet.")
+		return false
+	}
+	destConnID := c.connIDManager.Get()
+	if hdr.SrcConnectionID == destConnID {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       qlog.PacketTypeRetry,
+					SrcConnectionID:  hdr.SrcConnectionID,
+					DestConnectionID: hdr.DestConnectionID,
+					Version:          hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: len(data)},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		c.logger.Debugf("Ignoring Retry, since the server didn't change the Source Connection ID.")
+		return false
+	}
+	// If a token is already set, this means that we already received a Retry from the server.
+	// Ignore this Retry packet.
+	if c.receivedRetry {
+		c.logger.Debugf("Ignoring Retry, since a Retry was already received.")
+		return false
+	}
+
+	tag := handshake.GetRetryIntegrityTag(data[:len(data)-16], destConnID, hdr.Version)
+	if !bytes.Equal(data[len(data)-16:], tag[:]) {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:       qlog.PacketTypeRetry,
+					SrcConnectionID:  hdr.SrcConnectionID,
+					DestConnectionID: hdr.DestConnectionID,
+					Version:          hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: len(data)},
+				Trigger: qlog.PacketDropPayloadDecryptError,
+			})
+		}
+		c.logger.Debugf("Ignoring spoofed Retry. Integrity Tag doesn't match.")
+		return false
+	}
+
+	newDestConnID := hdr.SrcConnectionID
+	c.receivedRetry = true
+	c.sentPacketHandler.ResetForRetry(rcvTime)
+	c.handshakeDestConnID = newDestConnID
+	c.retrySrcConnID = &newDestConnID
+	c.cryptoStreamHandler.ChangeConnectionID(newDestConnID)
+	c.packer.SetToken(hdr.Token)
+	c.connIDManager.ChangeInitialConnID(newDestConnID)
+
+	if c.logger.Debug() {
+		c.logger.Debugf("<- Received Retry:")
+		(&wire.ExtendedHeader{Header: *hdr}).Log(c.logger)
+		c.logger.Debugf("Switching destination connection ID to: %s", hdr.SrcConnectionID)
+	}
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.PacketReceived{
+			Header: qlog.PacketHeader{
+				PacketType:       qlog.PacketTypeRetry,
+				DestConnectionID: destConnID,
+				SrcConnectionID:  newDestConnID,
+				Version:          hdr.Version,
+				Token:            &qlog.Token{Raw: hdr.Token},
+			},
+			Raw: qlog.RawInfo{Length: len(data)},
+		})
+	}
+
+	c.scheduleSending()
+	return true
+}
+
+func (c *Conn) handleVersionNegotiationPacket(p receivedPacket) error {
+	if c.perspective == protocol.PerspectiveServer || // servers never receive version negotiation packets
+		c.receivedFirstPacket || c.versionNegotiated { // ignore delayed / duplicated version negotiation packets
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header:  qlog.PacketHeader{PacketType: qlog.PacketTypeVersionNegotiation},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return nil
+	}
+
+	src, dest, supportedVersions, err := wire.ParseVersionNegotiationPacket(p.data)
+	if err != nil {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header:  qlog.PacketHeader{PacketType: qlog.PacketTypeVersionNegotiation},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropHeaderParseError,
+			})
+		}
+		c.logger.Debugf("Error parsing Version Negotiation packet: %s", err)
+		return nil
+	}
+
+	if slices.Contains(supportedVersions, c.version) {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header:  qlog.PacketHeader{PacketType: qlog.PacketTypeVersionNegotiation},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedVersion,
+			})
+		}
+		// The Version Negotiation packet contains the version that we offered.
+		// This might be a packet sent by an attacker, or it was corrupted.
+		return nil
+	}
+
+	c.logger.Infof("Received a Version Negotiation packet. Supported Versions: %s", supportedVersions)
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.VersionNegotiationReceived{
+			Header: qlog.PacketHeaderVersionNegotiation{
+				DestConnectionID: dest,
+				SrcConnectionID:  src,
+			},
+			SupportedVersions: supportedVersions,
+		})
+	}
+	newVersion, ok := protocol.ChooseSupportedVersion(c.config.Versions, supportedVersions)
+	if !ok {
+		c.destroyImpl(&VersionNegotiationError{
+			Ours:   c.config.Versions,
+			Theirs: supportedVersions,
+		})
+		c.logger.Infof("No compatible QUIC version found.")
+		return nil
+	}
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.VersionInformation{
+			ChosenVersion:  newVersion,
+			ClientVersions: c.config.Versions,
+			ServerVersions: supportedVersions,
+		})
+	}
+
+	c.logger.Infof("Switching to QUIC version %s.", newVersion)
+	nextPN, _ := c.sentPacketHandler.PeekPacketNumber(protocol.EncryptionInitial)
+	return &errCloseForRecreating{
+		nextPacketNumber: nextPN,
+		nextVersion:      newVersion,
+	}
+}
+
+func (c *Conn) handleUnpackedLongHeaderPacket(
+	packet *unpackedPacket,
+	ecn protocol.ECN,
+	rcvTime monotime.Time,
+	datagramPayloadChecksum qlog.DatagramPayloadChecksum, // only for logging
+	packetSize protocol.ByteCount, // only for logging
+) error {
+	if !c.receivedFirstPacket {
+		c.receivedFirstPacket = true
+		if !c.versionNegotiated && c.qlogger != nil {
+			var clientVersions, serverVersions []Version
+			switch c.perspective {
+			case protocol.PerspectiveClient:
+				clientVersions = c.config.Versions
+			case protocol.PerspectiveServer:
+				serverVersions = c.config.Versions
+			}
+			c.qlogger.RecordEvent(qlog.VersionInformation{
+				ChosenVersion:  c.version,
+				ClientVersions: clientVersions,
+				ServerVersions: serverVersions,
+			})
+		}
+		// The server can change the source connection ID with the first Handshake packet.
+		if c.perspective == protocol.PerspectiveClient && packet.hdr.SrcConnectionID != c.handshakeDestConnID {
+			cid := packet.hdr.SrcConnectionID
+			c.logger.Debugf("Received first packet. Switching destination connection ID to: %s", cid)
+			c.handshakeDestConnID = cid
+			c.connIDManager.ChangeInitialConnID(cid)
+		}
+		// We create the connection as soon as we receive the first packet from the client.
+		// We do that before authenticating the packet.
+		// That means that if the source connection ID was corrupted,
+		// we might have created a connection with an incorrect source connection ID.
+		// Once we authenticate the first packet, we need to update it.
+		if c.perspective == protocol.PerspectiveServer {
+			if packet.hdr.SrcConnectionID != c.handshakeDestConnID {
+				c.handshakeDestConnID = packet.hdr.SrcConnectionID
+				c.connIDManager.ChangeInitialConnID(packet.hdr.SrcConnectionID)
+			}
+			if c.qlogger != nil {
+				var srcAddr, destAddr *net.UDPAddr
+				if addr, ok := c.conn.LocalAddr().(*net.UDPAddr); ok {
+					srcAddr = addr
+				}
+				if addr, ok := c.conn.RemoteAddr().(*net.UDPAddr); ok {
+					destAddr = addr
+				}
+				c.qlogger.RecordEvent(startedConnectionEvent(srcAddr, destAddr))
+			}
+		}
+	}
+
+	if c.perspective == protocol.PerspectiveServer && packet.encryptionLevel == protocol.EncryptionHandshake &&
+		!c.droppedInitialKeys {
+		// On the server side, Initial keys are dropped as soon as the first Handshake packet is received.
+		// See Section 4.9.1 of RFC 9001.
+		if err := c.dropEncryptionLevel(protocol.EncryptionInitial, rcvTime); err != nil {
+			return err
+		}
+	}
+
+	c.lastPacketReceivedTime = rcvTime
+	c.firstAckElicitingPacketAfterIdleSentTime = 0
+	c.keepAlivePingSent = false
+
+	if packet.hdr.Type == protocol.PacketType0RTT {
+		c.largestRcvdAppData = max(c.largestRcvdAppData, packet.hdr.PacketNumber)
+	}
+
+	var log func([]qlog.Frame)
+	if c.qlogger != nil {
+		log = func(frames []qlog.Frame) {
+			var token *qlog.Token
+			if len(packet.hdr.Token) > 0 {
+				token = &qlog.Token{Raw: packet.hdr.Token}
+			}
+			c.qlogger.RecordEvent(qlog.PacketReceived{
+				Header: qlog.PacketHeader{
+					PacketType:       toQlogPacketType(packet.hdr.Type),
+					DestConnectionID: packet.hdr.DestConnectionID,
+					SrcConnectionID:  packet.hdr.SrcConnectionID,
+					PacketNumber:     packet.hdr.PacketNumber,
+					Version:          packet.hdr.Version,
+					Token:            token,
+				},
+				Raw: qlog.RawInfo{
+					Length:        int(packetSize),
+					PayloadLength: int(packet.hdr.Length),
+				},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Frames:                  frames,
+				ECN:                     toQlogECN(ecn),
+			})
+		}
+	}
+	isAckEliciting, _, _, err := c.handleFrames(packet.data, packet.hdr.DestConnectionID, packet.encryptionLevel, log, rcvTime)
+	if err != nil {
+		return err
+	}
+	c.sentPacketHandler.ReceivedPacket(packet.encryptionLevel, rcvTime)
+	return c.receivedPacketHandler.ReceivedPacket(packet.hdr.PacketNumber, ecn, packet.encryptionLevel, rcvTime, isAckEliciting)
+}
+
+func (c *Conn) handleUnpackedShortHeaderPacket(
+	destConnID protocol.ConnectionID,
+	pn protocol.PacketNumber,
+	data []byte,
+	ecn protocol.ECN,
+	rcvTime monotime.Time,
+	log func([]qlog.Frame),
+) (isNonProbing bool, pathChallenge *wire.PathChallengeFrame, _ error) {
+	c.lastPacketReceivedTime = rcvTime
+	c.firstAckElicitingPacketAfterIdleSentTime = 0
+	c.keepAlivePingSent = false
+
+	isAckEliciting, isNonProbing, pathChallenge, err := c.handleFrames(data, destConnID, protocol.Encryption1RTT, log, rcvTime)
+	if err != nil {
+		return false, nil, err
+	}
+	c.sentPacketHandler.ReceivedPacket(protocol.Encryption1RTT, rcvTime)
+	if err := c.receivedPacketHandler.ReceivedPacket(pn, ecn, protocol.Encryption1RTT, rcvTime, isAckEliciting); err != nil {
+		return false, nil, err
+	}
+	return isNonProbing, pathChallenge, nil
+}
+
+// handleFrames parses the frames, one after the other, and handles them.
+// It returns the last PATH_CHALLENGE frame contained in the packet, if any.
+func (c *Conn) handleFrames(
+	data []byte,
+	destConnID protocol.ConnectionID,
+	encLevel protocol.EncryptionLevel,
+	log func([]qlog.Frame),
+	rcvTime monotime.Time,
+) (isAckEliciting, isNonProbing bool, pathChallenge *wire.PathChallengeFrame, _ error) {
+	// Only used for tracing.
+	// If we're not tracing, this slice will always remain empty.
+	var frames []qlog.Frame
+	if log != nil {
+		frames = make([]qlog.Frame, 0, 4)
+	}
+	handshakeWasComplete := c.handshakeComplete
+	var handleErr error
+	var skipHandling bool
+
+	for len(data) > 0 {
+		frameType, l, err := c.frameParser.ParseType(data, encLevel)
+		if err != nil {
+			// The frame parser skips over PADDING frames, and returns an io.EOF if the PADDING
+			// frames were the last frames in this packet.
+			if err == io.EOF {
+				break
+			}
+			return false, false, nil, err
+		}
+		data = data[l:]
+
+		if ackhandler.IsFrameTypeAckEliciting(frameType) {
+			isAckEliciting = true
+		}
+		if !wire.IsProbingFrameType(frameType) {
+			isNonProbing = true
+		}
+
+		// We're inlining common cases, to avoid using interfaces
+		// Fast path: STREAM, DATAGRAM and ACK
+		if frameType.IsStreamFrameType() {
+			streamFrame, l, err := c.frameParser.ParseStreamFrame(frameType, data, c.version)
+			if err != nil {
+				return false, false, nil, err
+			}
+			data = data[l:]
+
+			if log != nil {
+				frames = append(frames, toQlogFrame(streamFrame))
+			}
+			// an error occurred handling a previous frame, don't handle the current frame
+			if skipHandling {
+				continue
+			}
+			wire.LogFrame(c.logger, streamFrame, false)
+			handleErr = c.streamsMap.HandleStreamFrame(streamFrame, rcvTime)
+		} else if frameType.IsAckFrameType() {
+			ackFrame, l, err := c.frameParser.ParseAckFrame(frameType, data, encLevel, c.version)
+			if err != nil {
+				return false, false, nil, err
+			}
+			data = data[l:]
+			if log != nil {
+				frames = append(frames, toQlogFrame(ackFrame))
+			}
+			// an error occurred handling a previous frame, don't handle the current frame
+			if skipHandling {
+				continue
+			}
+			wire.LogFrame(c.logger, ackFrame, false)
+			handleErr = c.handleAckFrame(ackFrame, encLevel, rcvTime)
+		} else if frameType.IsDatagramFrameType() {
+			datagramFrame, l, err := c.frameParser.ParseDatagramFrame(frameType, data, c.version)
+			if err != nil {
+				return false, false, nil, err
+			}
+			data = data[l:]
+
+			if log != nil {
+				frames = append(frames, toQlogFrame(datagramFrame))
+			}
+			// an error occurred handling a previous frame, don't handle the current frame
+			if skipHandling {
+				continue
+			}
+			wire.LogFrame(c.logger, datagramFrame, false)
+			handleErr = c.handleDatagramFrame(datagramFrame)
+		} else {
+			frame, l, err := c.frameParser.ParseLessCommonFrame(frameType, data, c.version)
+			if err != nil {
+				return false, false, nil, err
+			}
+			data = data[l:]
+
+			if log != nil {
+				frames = append(frames, toQlogFrame(frame))
+			}
+			// an error occurred handling a previous frame, don't handle the current frame
+			if skipHandling {
+				continue
+			}
+			pc, err := c.handleFrame(frame, encLevel, destConnID, rcvTime)
+			if pc != nil {
+				pathChallenge = pc
+			}
+			handleErr = err
+		}
+
+		if handleErr != nil {
+			// if we're logging, we need to keep parsing (but not handling) all frames
+			skipHandling = true
+			if log == nil {
+				return false, false, nil, handleErr
+			}
+		}
+	}
+
+	if log != nil {
+		log(frames)
+		if handleErr != nil {
+			return false, false, nil, handleErr
+		}
+	}
+
+	// Handle completion of the handshake after processing all the frames.
+	// This ensures that we correctly handle the following case on the server side:
+	// We receive a Handshake packet that contains the CRYPTO frame that allows us to complete the handshake,
+	// and an ACK serialized after that CRYPTO frame. In this case, we still want to process the ACK frame.
+	if !handshakeWasComplete && c.handshakeComplete {
+		if err := c.handleHandshakeComplete(rcvTime); err != nil {
+			return false, false, nil, err
+		}
+	}
+	return
+}
+
+func (c *Conn) handleFrame(
+	f wire.Frame,
+	encLevel protocol.EncryptionLevel,
+	destConnID protocol.ConnectionID,
+	rcvTime monotime.Time,
+) (pathChallenge *wire.PathChallengeFrame, _ error) {
+	var err error
+	wire.LogFrame(c.logger, f, false)
+	switch frame := f.(type) {
+	case *wire.CryptoFrame:
+		err = c.handleCryptoFrame(frame, encLevel, rcvTime)
+	case *wire.ConnectionCloseFrame:
+		err = c.handleConnectionCloseFrame(frame)
+	case *wire.ResetStreamFrame:
+		err = c.streamsMap.HandleResetStreamFrame(frame, rcvTime)
+	case *wire.MaxDataFrame:
+		c.connFlowController.UpdateSendWindow(frame.MaximumData)
+	case *wire.MaxStreamDataFrame:
+		err = c.streamsMap.HandleMaxStreamDataFrame(frame)
+	case *wire.MaxStreamsFrame:
+		c.streamsMap.HandleMaxStreamsFrame(frame)
+	case *wire.DataBlockedFrame:
+	case *wire.StreamDataBlockedFrame:
+		err = c.streamsMap.HandleStreamDataBlockedFrame(frame)
+	case *wire.StreamsBlockedFrame:
+	case *wire.StopSendingFrame:
+		err = c.streamsMap.HandleStopSendingFrame(frame)
+	case *wire.PingFrame:
+	case *wire.PathChallengeFrame:
+		c.handlePathChallengeFrame(frame)
+		pathChallenge = frame
+	case *wire.PathResponseFrame:
+		err = c.handlePathResponseFrame(frame)
+	case *wire.NewTokenFrame:
+		err = c.handleNewTokenFrame(frame)
+	case *wire.NewConnectionIDFrame:
+		err = c.connIDManager.Add(frame)
+	case *wire.RetireConnectionIDFrame:
+		err = c.connIDGenerator.Retire(frame.SequenceNumber, destConnID, rcvTime.Add(3*c.rttStats.PTO(false)))
+	case *wire.HandshakeDoneFrame:
+		err = c.handleHandshakeDoneFrame(rcvTime)
+	default:
+		err = fmt.Errorf("unexpected frame type: %s", reflect.ValueOf(&frame).Elem().Type().Name())
+	}
+	return pathChallenge, err
+}
+
+// handlePacket is called by the server with a new packet
+func (c *Conn) handlePacket(p receivedPacket) {
+	c.receivedPacketMx.Lock()
+	// Discard packets once the amount of queued packets is larger than
+	// the channel size, protocol.MaxConnUnprocessedPackets
+	if c.receivedPackets.Len() >= protocol.MaxConnUnprocessedPackets {
+		if c.qlogger != nil {
+			var datagramPayloadChecksum qlog.DatagramPayloadChecksum
+			if wire.IsLongHeaderPacket(p.data[0]) {
+				datagramPayloadChecksum = qlog.CalculateDatagramPayloadChecksum(p.data)
+			}
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropDOSPrevention,
+			})
+		}
+		c.receivedPacketMx.Unlock()
+		return
+	}
+	c.receivedPackets.PushBack(p)
+	c.receivedPacketMx.Unlock()
+
+	select {
+	case c.notifyReceivedPacket <- struct{}{}:
+	default:
+	}
+}
+
+func (c *Conn) handleConnectionCloseFrame(frame *wire.ConnectionCloseFrame) error {
+	if frame.IsApplicationError {
+		return &qerr.ApplicationError{
+			Remote:       true,
+			ErrorCode:    qerr.ApplicationErrorCode(frame.ErrorCode),
+			ErrorMessage: frame.ReasonPhrase,
+		}
+	}
+	return &qerr.TransportError{
+		Remote:       true,
+		ErrorCode:    qerr.TransportErrorCode(frame.ErrorCode),
+		FrameType:    frame.FrameType,
+		ErrorMessage: frame.ReasonPhrase,
+	}
+}
+
+func (c *Conn) handleCryptoFrame(frame *wire.CryptoFrame, encLevel protocol.EncryptionLevel, rcvTime monotime.Time) error {
+	if err := c.cryptoStreamManager.HandleCryptoFrame(frame, encLevel); err != nil {
+		return err
+	}
+	for {
+		data := c.cryptoStreamManager.GetCryptoData(encLevel)
+		if data == nil {
+			break
+		}
+		if err := c.cryptoStreamHandler.HandleMessage(data, encLevel); err != nil {
+			return err
+		}
+	}
+	return c.handleHandshakeEvents(rcvTime)
+}
+
+func (c *Conn) handleHandshakeEvents(now monotime.Time) error {
+	for {
+		ev := c.cryptoStreamHandler.NextEvent()
+		var err error
+		switch ev.Kind {
+		case handshake.EventNoEvent:
+			return nil
+		case handshake.EventHandshakeComplete:
+			// Don't call handleHandshakeComplete yet.
+			// It's advantageous to process ACK frames that might be serialized after the CRYPTO frame first.
+			c.handshakeComplete = true
+		case handshake.EventReceivedTransportParameters:
+			err = c.handleTransportParameters(ev.TransportParameters)
+		case handshake.EventRestoredTransportParameters:
+			c.restoreTransportParameters(ev.TransportParameters)
+			close(c.earlyConnReadyChan)
+		case handshake.EventReceivedReadKeys:
+			// queue all previously undecryptable packets
+			c.undecryptablePacketsToProcess = append(c.undecryptablePacketsToProcess, c.undecryptablePackets...)
+			c.undecryptablePackets = nil
+		case handshake.EventDiscard0RTTKeys:
+			err = c.dropEncryptionLevel(protocol.Encryption0RTT, now)
+		case handshake.EventWriteInitialData:
+			_, err = c.initialStream.Write(ev.Data)
+		case handshake.EventWriteHandshakeData:
+			_, err = c.handshakeStream.Write(ev.Data)
+		}
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (c *Conn) handlePathChallengeFrame(f *wire.PathChallengeFrame) {
+	if c.perspective == protocol.PerspectiveClient {
+		c.queueControlFrame(&wire.PathResponseFrame{Data: f.Data})
+	}
+}
+
+func (c *Conn) handlePathResponseFrame(f *wire.PathResponseFrame) error {
+	switch c.perspective {
+	case protocol.PerspectiveClient:
+		return c.handlePathResponseFrameClient(f)
+	case protocol.PerspectiveServer:
+		return c.handlePathResponseFrameServer(f)
+	default:
+		panic("unreachable")
+	}
+}
+
+func (c *Conn) handlePathResponseFrameClient(f *wire.PathResponseFrame) error {
+	pm := c.pathManagerOutgoing.Load()
+	if pm == nil {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "unexpected PATH_RESPONSE frame",
+		}
+	}
+	pm.HandlePathResponseFrame(f)
+	return nil
+}
+
+func (c *Conn) handlePathResponseFrameServer(f *wire.PathResponseFrame) error {
+	if c.pathManager == nil {
+		// since we didn't send PATH_CHALLENGEs yet, we don't expect PATH_RESPONSEs
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "unexpected PATH_RESPONSE frame",
+		}
+	}
+	c.pathManager.HandlePathResponseFrame(f)
+	return nil
+}
+
+func (c *Conn) handleNewTokenFrame(frame *wire.NewTokenFrame) error {
+	if c.perspective == protocol.PerspectiveServer {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "received NEW_TOKEN frame from the client",
+		}
+	}
+	if c.config.TokenStore != nil {
+		c.config.TokenStore.Put(c.tokenStoreKey, &ClientToken{data: frame.Token, rtt: c.rttStats.SmoothedRTT()})
+	}
+	return nil
+}
+
+func (c *Conn) handleHandshakeDoneFrame(rcvTime monotime.Time) error {
+	if c.perspective == protocol.PerspectiveServer {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "received a HANDSHAKE_DONE frame",
+		}
+	}
+	if !c.handshakeConfirmed {
+		return c.handleHandshakeConfirmed(rcvTime)
+	}
+	return nil
+}
+
+func (c *Conn) handleAckFrame(frame *wire.AckFrame, encLevel protocol.EncryptionLevel, rcvTime monotime.Time) error {
+	acked1RTTPacket, err := c.sentPacketHandler.ReceivedAck(frame, encLevel, c.lastPacketReceivedTime)
+	if err != nil {
+		return err
+	}
+	if !acked1RTTPacket {
+		return nil
+	}
+	// On the client side: If the packet acknowledged a 1-RTT packet, this confirms the handshake.
+	// This is only possible if the ACK was sent in a 1-RTT packet.
+	// This is an optimization over simply waiting for a HANDSHAKE_DONE frame, see section 4.1.2 of RFC 9001.
+	if c.perspective == protocol.PerspectiveClient && !c.handshakeConfirmed {
+		if err := c.handleHandshakeConfirmed(rcvTime); err != nil {
+			return err
+		}
+	}
+	// If one of the acknowledged packets was a Path MTU probe packet, this might have increased the Path MTU estimate.
+	if c.mtuDiscoverer != nil {
+		mtu := c.mtuDiscoverer.CurrentSize()
+		maxPayloadSize := estimateMaxPayloadSize(mtu)
+		if maxPayloadSize > protocol.ByteCount(c.maxPayloadSizeEstimate.Load()) {
+			c.maxPayloadSizeEstimate.Store(uint32(maxPayloadSize))
+			c.sentPacketHandler.SetMaxDatagramSize(mtu)
+		}
+	}
+	return c.cryptoStreamHandler.SetLargest1RTTAcked(frame.LargestAcked())
+}
+
+func (c *Conn) handleDatagramFrame(f *wire.DatagramFrame) error {
+	if f.Length(c.version) > wire.MaxDatagramSize {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "DATAGRAM frame too large",
+		}
+	}
+	c.datagramQueue.HandleDatagramFrame(f)
+	return nil
+}
+
+func (c *Conn) setCloseError(e *closeError) {
+	c.closeErr.CompareAndSwap(nil, e)
+	select {
+	case c.closeChan <- struct{}{}:
+	default:
+	}
+}
+
+// closeLocal closes the connection and send a CONNECTION_CLOSE containing the error
+func (c *Conn) closeLocal(e error) {
+	c.setCloseError(&closeError{err: e, immediate: false})
+}
+
+// destroy closes the connection without sending the error on the wire
+func (c *Conn) destroy(e error) {
+	c.destroyImpl(e)
+	<-c.ctx.Done()
+}
+
+func (c *Conn) destroyImpl(e error) {
+	c.setCloseError(&closeError{err: e, immediate: true})
+}
+
+// CloseWithError closes the connection with an error.
+// The error string will be sent to the peer.
+func (c *Conn) CloseWithError(code ApplicationErrorCode, desc string) error {
+	c.closeLocal(&qerr.ApplicationError{
+		ErrorCode:    code,
+		ErrorMessage: desc,
+	})
+	<-c.ctx.Done()
+	return nil
+}
+
+func (c *Conn) closeWithTransportError(code TransportErrorCode) {
+	c.closeLocal(&qerr.TransportError{ErrorCode: code})
+	<-c.ctx.Done()
+}
+
+func (c *Conn) handleCloseError(closeErr *closeError) {
+	if closeErr.immediate {
+		if nerr, ok := closeErr.err.(net.Error); ok && nerr.Timeout() {
+			c.logger.Errorf("Destroying connection: %s", closeErr.err)
+		} else {
+			c.logger.Errorf("Destroying connection with error: %s", closeErr.err)
+		}
+	} else {
+		if closeErr.err == nil {
+			c.logger.Infof("Closing connection.")
+		} else {
+			c.logger.Errorf("Closing connection with error: %s", closeErr.err)
+		}
+	}
+
+	e := closeErr.err
+	if e == nil {
+		e = &qerr.ApplicationError{}
+	} else {
+		defer func() { closeErr.err = e }()
+	}
+
+	var (
+		statelessResetErr     *StatelessResetError
+		versionNegotiationErr *VersionNegotiationError
+		recreateErr           *errCloseForRecreating
+		applicationErr        *ApplicationError
+		transportErr          *TransportError
+	)
+	var isRemoteClose bool
+	var trigger qlog.ConnectionCloseTrigger
+	var reason string
+	var transportErrorCode *qlog.TransportErrorCode
+	var applicationErrorCode *qlog.ApplicationErrorCode
+	switch {
+	case errors.Is(e, qerr.ErrIdleTimeout),
+		errors.Is(e, qerr.ErrHandshakeTimeout):
+		trigger = qlog.ConnectionCloseTriggerIdleTimeout
+	case errors.As(e, &statelessResetErr):
+		trigger = qlog.ConnectionCloseTriggerStatelessReset
+	case errors.As(e, &versionNegotiationErr):
+		trigger = qlog.ConnectionCloseTriggerVersionMismatch
+	case errors.As(e, &recreateErr):
+	case errors.As(e, &applicationErr):
+		isRemoteClose = applicationErr.Remote
+		reason = applicationErr.ErrorMessage
+		applicationErrorCode = &applicationErr.ErrorCode
+	case errors.As(e, &transportErr):
+		isRemoteClose = transportErr.Remote
+		reason = transportErr.ErrorMessage
+		transportErrorCode = &transportErr.ErrorCode
+	case closeErr.immediate:
+		e = closeErr.err
+	default:
+		te := &qerr.TransportError{
+			ErrorCode:    qerr.InternalError,
+			ErrorMessage: e.Error(),
+		}
+		e = te
+		reason = te.ErrorMessage
+		code := te.ErrorCode
+		transportErrorCode = &code
+	}
+
+	c.streamsMap.CloseWithError(e)
+	if c.datagramQueue != nil {
+		c.datagramQueue.CloseWithError(e)
+	}
+
+	// In rare instances, the connection ID manager might switch to a new connection ID
+	// when sending the CONNECTION_CLOSE frame.
+	// The connection ID manager removes the active stateless reset token from the packet
+	// handler map when it is closed, so we need to make sure that this happens last.
+	defer c.connIDManager.Close()
+
+	if c.qlogger != nil && !errors.As(e, &recreateErr) {
+		initiator := qlog.InitiatorLocal
+		if isRemoteClose {
+			initiator = qlog.InitiatorRemote
+		}
+		c.qlogger.RecordEvent(qlog.ConnectionClosed{
+			Initiator:        initiator,
+			ConnectionError:  transportErrorCode,
+			ApplicationError: applicationErrorCode,
+			Trigger:          trigger,
+			Reason:           reason,
+		})
+	}
+
+	// If this is a remote close we're done here
+	if isRemoteClose {
+		c.connIDGenerator.ReplaceWithClosed(nil, 3*c.rttStats.PTO(false))
+		return
+	}
+	if closeErr.immediate {
+		c.connIDGenerator.RemoveAll()
+		return
+	}
+	// Don't send out any CONNECTION_CLOSE if this is an error that occurred
+	// before we even sent out the first packet.
+	if c.perspective == protocol.PerspectiveClient && !c.sentFirstPacket {
+		c.connIDGenerator.RemoveAll()
+		return
+	}
+	connClosePacket, err := c.sendConnectionClose(e)
+	if err != nil {
+		c.logger.Debugf("Error sending CONNECTION_CLOSE: %s", err)
+	}
+	c.connIDGenerator.ReplaceWithClosed(connClosePacket, 3*c.rttStats.PTO(false))
+}
+
+func (c *Conn) dropEncryptionLevel(encLevel protocol.EncryptionLevel, now monotime.Time) error {
+	c.sentPacketHandler.DropPackets(encLevel, now)
+	c.receivedPacketHandler.DropPackets(encLevel)
+	//nolint:exhaustive // only Initial and 0-RTT need special treatment
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		c.droppedInitialKeys = true
+		c.cryptoStreamHandler.DiscardInitialKeys()
+	case protocol.Encryption0RTT:
+		c.streamsMap.ResetFor0RTT()
+		c.framer.Handle0RTTRejection()
+		return c.connFlowController.Reset()
+	}
+	return c.cryptoStreamManager.Drop(encLevel)
+}
+
+// is called for the client, when restoring transport parameters saved for 0-RTT
+func (c *Conn) restoreTransportParameters(params *wire.TransportParameters) {
+	if c.logger.Debug() {
+		c.logger.Debugf("Restoring Transport Parameters: %s", params)
+	}
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.ParametersSet{
+			Restore:                         true,
+			Initiator:                       qlog.InitiatorRemote,
+			SentBy:                          c.perspective,
+			OriginalDestinationConnectionID: params.OriginalDestinationConnectionID,
+			InitialSourceConnectionID:       params.InitialSourceConnectionID,
+			RetrySourceConnectionID:         params.RetrySourceConnectionID,
+			StatelessResetToken:             params.StatelessResetToken,
+			DisableActiveMigration:          params.DisableActiveMigration,
+			MaxIdleTimeout:                  params.MaxIdleTimeout,
+			MaxUDPPayloadSize:               params.MaxUDPPayloadSize,
+			AckDelayExponent:                params.AckDelayExponent,
+			MaxAckDelay:                     params.MaxAckDelay,
+			ActiveConnectionIDLimit:         params.ActiveConnectionIDLimit,
+			InitialMaxData:                  params.InitialMaxData,
+			InitialMaxStreamDataBidiLocal:   params.InitialMaxStreamDataBidiLocal,
+			InitialMaxStreamDataBidiRemote:  params.InitialMaxStreamDataBidiRemote,
+			InitialMaxStreamDataUni:         params.InitialMaxStreamDataUni,
+			InitialMaxStreamsBidi:           int64(params.MaxBidiStreamNum),
+			InitialMaxStreamsUni:            int64(params.MaxUniStreamNum),
+			MaxDatagramFrameSize:            params.MaxDatagramFrameSize,
+			EnableResetStreamAt:             params.EnableResetStreamAt,
+		})
+	}
+
+	c.peerParams = params
+	c.connIDGenerator.SetMaxActiveConnIDs(params.ActiveConnectionIDLimit)
+	c.connFlowController.UpdateSendWindow(params.InitialMaxData)
+	c.streamsMap.HandleTransportParameters(params)
+}
+
+func (c *Conn) handleTransportParameters(params *wire.TransportParameters) error {
+	if c.qlogger != nil {
+		c.qlogTransportParameters(params, c.perspective.Opposite(), false)
+	}
+	if err := c.checkTransportParameters(params); err != nil {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.TransportParameterError,
+			ErrorMessage: err.Error(),
+		}
+	}
+
+	if c.perspective == protocol.PerspectiveClient && c.peerParams != nil && c.ConnectionState().Used0RTT && !params.ValidForUpdate(c.peerParams) {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "server sent reduced limits after accepting 0-RTT data",
+		}
+	}
+
+	c.peerParams = params
+	// On the client side we have to wait for handshake completion.
+	// During a 0-RTT connection, we are only allowed to use the new transport parameters for 1-RTT packets.
+	if c.perspective == protocol.PerspectiveServer {
+		c.applyTransportParameters()
+		// On the server side, the early connection is ready as soon as we processed
+		// the client's transport parameters.
+		close(c.earlyConnReadyChan)
+	}
+	return nil
+}
+
+func (c *Conn) checkTransportParameters(params *wire.TransportParameters) error {
+	if c.logger.Debug() {
+		c.logger.Debugf("Processed Transport Parameters: %s", params)
+	}
+
+	// check the initial_source_connection_id
+	if params.InitialSourceConnectionID != c.handshakeDestConnID {
+		return fmt.Errorf("expected initial_source_connection_id to equal %s, is %s", c.handshakeDestConnID, params.InitialSourceConnectionID)
+	}
+
+	if c.perspective == protocol.PerspectiveServer {
+		return nil
+	}
+	// check the original_destination_connection_id
+	if params.OriginalDestinationConnectionID != c.origDestConnID {
+		return fmt.Errorf("expected original_destination_connection_id to equal %s, is %s", c.origDestConnID, params.OriginalDestinationConnectionID)
+	}
+	if c.retrySrcConnID != nil { // a Retry was performed
+		if params.RetrySourceConnectionID == nil {
+			return errors.New("missing retry_source_connection_id")
+		}
+		if *params.RetrySourceConnectionID != *c.retrySrcConnID {
+			return fmt.Errorf("expected retry_source_connection_id to equal %s, is %s", c.retrySrcConnID, *params.RetrySourceConnectionID)
+		}
+	} else if params.RetrySourceConnectionID != nil {
+		return errors.New("received retry_source_connection_id, although no Retry was performed")
+	}
+	return nil
+}
+
+func (c *Conn) applyTransportParameters() {
+	params := c.peerParams
+	// Our local idle timeout will always be > 0.
+	c.idleTimeout = c.config.MaxIdleTimeout
+	// If the peer advertised an idle timeout, take the minimum of the values.
+	if params.MaxIdleTimeout > 0 {
+		c.idleTimeout = min(c.idleTimeout, params.MaxIdleTimeout)
+	}
+	c.keepAliveInterval = min(c.config.KeepAlivePeriod, c.idleTimeout/2)
+	c.streamsMap.HandleTransportParameters(params)
+	c.frameParser.SetAckDelayExponent(params.AckDelayExponent)
+	c.connFlowController.UpdateSendWindow(params.InitialMaxData)
+	c.rttStats.SetMaxAckDelay(params.MaxAckDelay)
+	c.connIDGenerator.SetMaxActiveConnIDs(params.ActiveConnectionIDLimit)
+	if params.StatelessResetToken != nil {
+		c.connIDManager.SetStatelessResetToken(*params.StatelessResetToken)
+	}
+	// We don't support connection migration yet, so we don't have any use for the preferred_address.
+	if params.PreferredAddress != nil {
+		// Retire the connection ID.
+		c.connIDManager.AddFromPreferredAddress(params.PreferredAddress.ConnectionID, params.PreferredAddress.StatelessResetToken)
+	}
+	maxPacketSize := protocol.ByteCount(protocol.MaxPacketBufferSize)
+	if params.MaxUDPPayloadSize > 0 && params.MaxUDPPayloadSize < maxPacketSize {
+		maxPacketSize = params.MaxUDPPayloadSize
+	}
+	c.mtuDiscoverer = newMTUDiscoverer(
+		c.rttStats,
+		protocol.ByteCount(c.config.InitialPacketSize),
+		maxPacketSize,
+		c.qlogger,
+	)
+}
+
+func (c *Conn) triggerSending(now monotime.Time) error {
+	c.pacingDeadline = 0
+
+	sendMode := c.sentPacketHandler.SendMode(now)
+	switch sendMode {
+	case ackhandler.SendAny:
+		return c.sendPackets(now)
+	case ackhandler.SendNone:
+		c.blocked = blockModeHardBlocked
+		return nil
+	case ackhandler.SendPacingLimited:
+		deadline := c.sentPacketHandler.TimeUntilSend()
+		if deadline.IsZero() {
+			deadline = deadlineSendImmediately
+		}
+		c.pacingDeadline = deadline
+		// Allow sending of an ACK if we're pacing limit.
+		// This makes sure that a peer that is mostly receiving data (and thus has an inaccurate cwnd estimate)
+		// sends enough ACKs to allow its peer to utilize the bandwidth.
+		return c.maybeSendAckOnlyPacket(now)
+	case ackhandler.SendAck:
+		// We can at most send a single ACK only packet.
+		// There will only be a new ACK after receiving new packets.
+		// SendAck is only returned when we're congestion limited, so we don't need to set the pacing timer.
+		c.blocked = blockModeCongestionLimited
+		return c.maybeSendAckOnlyPacket(now)
+	case ackhandler.SendPTOInitial, ackhandler.SendPTOHandshake, ackhandler.SendPTOAppData:
+		if err := c.sendProbePacket(sendMode, now); err != nil {
+			return err
+		}
+		if c.sendQueue.WouldBlock() {
+			c.scheduleSending()
+			return nil
+		}
+		return c.triggerSending(now)
+	default:
+		return fmt.Errorf("BUG: invalid send mode %d", sendMode)
+	}
+}
+
+func (c *Conn) sendPackets(now monotime.Time) error {
+	if c.perspective == protocol.PerspectiveClient && c.handshakeConfirmed {
+		if pm := c.pathManagerOutgoing.Load(); pm != nil {
+			connID, frame, tr, ok := pm.NextPathToProbe()
+			if ok {
+				probe, buf, err := c.packer.PackPathProbePacket(connID, []ackhandler.Frame{frame}, c.version)
+				if err != nil {
+					return err
+				}
+				c.logger.Debugf("sending path probe packet from %s", c.LocalAddr())
+				c.logShortHeaderPacket(probe, protocol.ECNNon, buf.Len())
+				c.registerPackedShortHeaderPacket(probe, protocol.ECNNon, now)
+				tr.WriteTo(buf.Data, c.conn.RemoteAddr())
+				// There's (likely) more data to send. Loop around again.
+				c.scheduleSending()
+				return nil
+			}
+		}
+	}
+
+	// Path MTU Discovery
+	// Can't use GSO, since we need to send a single packet that's larger than our current maximum size.
+	// Performance-wise, this doesn't matter, since we only send a very small (<10) number of
+	// MTU probe packets per connection.
+	if c.handshakeConfirmed && c.mtuDiscoverer != nil && c.mtuDiscoverer.ShouldSendProbe(now) {
+		ping, size := c.mtuDiscoverer.GetPing(now)
+		p, buf, err := c.packer.PackMTUProbePacket(ping, size, c.version)
+		if err != nil {
+			return err
+		}
+		ecn := c.sentPacketHandler.ECNMode(true)
+		c.logShortHeaderPacket(p, ecn, buf.Len())
+		c.registerPackedShortHeaderPacket(p, ecn, now)
+		c.sendQueue.Send(buf, 0, ecn)
+		// There's (likely) more data to send. Loop around again.
+		c.scheduleSending()
+		return nil
+	}
+
+	if offset := c.connFlowController.GetWindowUpdate(now); offset > 0 {
+		c.framer.QueueControlFrame(&wire.MaxDataFrame{MaximumData: offset})
+	}
+	if cf := c.cryptoStreamManager.GetPostHandshakeData(protocol.MaxPostHandshakeCryptoFrameSize); cf != nil {
+		c.queueControlFrame(cf)
+	}
+
+	if !c.handshakeConfirmed {
+		packet, err := c.packer.PackCoalescedPacket(false, c.maxPacketSize(), now, c.version)
+		if err != nil || packet == nil {
+			return err
+		}
+		c.sentFirstPacket = true
+		if err := c.sendPackedCoalescedPacket(packet, c.sentPacketHandler.ECNMode(packet.IsOnlyShortHeaderPacket()), now); err != nil {
+			return err
+		}
+		//nolint:exhaustive // only need to handle pacing-related events here
+		switch c.sentPacketHandler.SendMode(now) {
+		case ackhandler.SendPacingLimited:
+			c.resetPacingDeadline()
+		case ackhandler.SendAny:
+			c.pacingDeadline = deadlineSendImmediately
+		}
+		return nil
+	}
+
+	if c.conn.capabilities().GSO {
+		return c.sendPacketsWithGSO(now)
+	}
+	return c.sendPacketsWithoutGSO(now)
+}
+
+func (c *Conn) sendPacketsWithoutGSO(now monotime.Time) error {
+	for {
+		buf := getPacketBuffer()
+		ecn := c.sentPacketHandler.ECNMode(true)
+		if _, err := c.appendOneShortHeaderPacket(buf, c.maxPacketSize(), ecn, now); err != nil {
+			if err == errNothingToPack {
+				buf.Release()
+				return nil
+			}
+			return err
+		}
+
+		c.sendQueue.Send(buf, 0, ecn)
+
+		if c.sendQueue.WouldBlock() {
+			return nil
+		}
+		sendMode := c.sentPacketHandler.SendMode(now)
+		if sendMode == ackhandler.SendPacingLimited {
+			c.resetPacingDeadline()
+			return nil
+		}
+		if sendMode != ackhandler.SendAny {
+			return nil
+		}
+		// Prioritize receiving of packets over sending out more packets.
+		c.receivedPacketMx.Lock()
+		hasPackets := !c.receivedPackets.Empty()
+		c.receivedPacketMx.Unlock()
+		if hasPackets {
+			c.pacingDeadline = deadlineSendImmediately
+			return nil
+		}
+	}
+}
+
+func (c *Conn) sendPacketsWithGSO(now monotime.Time) error {
+	buf := getLargePacketBuffer()
+	maxSize := c.maxPacketSize()
+
+	ecn := c.sentPacketHandler.ECNMode(true)
+	for {
+		var dontSendMore bool
+		size, err := c.appendOneShortHeaderPacket(buf, maxSize, ecn, now)
+		if err != nil {
+			if err != errNothingToPack {
+				return err
+			}
+			if buf.Len() == 0 {
+				buf.Release()
+				return nil
+			}
+			dontSendMore = true
+		}
+
+		if !dontSendMore {
+			sendMode := c.sentPacketHandler.SendMode(now)
+			if sendMode == ackhandler.SendPacingLimited {
+				c.resetPacingDeadline()
+			}
+			if sendMode != ackhandler.SendAny {
+				dontSendMore = true
+			}
+		}
+
+		// Don't send more packets in this batch if they require a different ECN marking than the previous ones.
+		nextECN := c.sentPacketHandler.ECNMode(true)
+
+		// Append another packet if
+		// 1. The congestion controller and pacer allow sending more
+		// 2. The last packet appended was a full-size packet
+		// 3. The next packet will have the same ECN marking
+		// 4. We still have enough space for another full-size packet in the buffer
+		if !dontSendMore && size == maxSize && nextECN == ecn && buf.Len()+maxSize <= buf.Cap() {
+			continue
+		}
+
+		c.sendQueue.Send(buf, uint16(maxSize), ecn)
+
+		if dontSendMore {
+			return nil
+		}
+		if c.sendQueue.WouldBlock() {
+			return nil
+		}
+
+		// Prioritize receiving of packets over sending out more packets.
+		c.receivedPacketMx.Lock()
+		hasPackets := !c.receivedPackets.Empty()
+		c.receivedPacketMx.Unlock()
+		if hasPackets {
+			c.pacingDeadline = deadlineSendImmediately
+			return nil
+		}
+
+		ecn = nextECN
+		buf = getLargePacketBuffer()
+	}
+}
+
+func (c *Conn) resetPacingDeadline() {
+	deadline := c.sentPacketHandler.TimeUntilSend()
+	if deadline.IsZero() {
+		deadline = deadlineSendImmediately
+	}
+	c.pacingDeadline = deadline
+}
+
+func (c *Conn) maybeSendAckOnlyPacket(now monotime.Time) error {
+	if !c.handshakeConfirmed {
+		ecn := c.sentPacketHandler.ECNMode(false)
+		packet, err := c.packer.PackCoalescedPacket(true, c.maxPacketSize(), now, c.version)
+		if err != nil {
+			return err
+		}
+		if packet == nil {
+			return nil
+		}
+		return c.sendPackedCoalescedPacket(packet, ecn, now)
+	}
+
+	ecn := c.sentPacketHandler.ECNMode(true)
+	p, buf, err := c.packer.PackAckOnlyPacket(c.maxPacketSize(), now, c.version)
+	if err != nil {
+		if err == errNothingToPack {
+			return nil
+		}
+		return err
+	}
+	c.logShortHeaderPacket(p, ecn, buf.Len())
+	c.registerPackedShortHeaderPacket(p, ecn, now)
+	c.sendQueue.Send(buf, 0, ecn)
+	return nil
+}
+
+func (c *Conn) sendProbePacket(sendMode ackhandler.SendMode, now monotime.Time) error {
+	var encLevel protocol.EncryptionLevel
+	//nolint:exhaustive // We only need to handle the PTO send modes here.
+	switch sendMode {
+	case ackhandler.SendPTOInitial:
+		encLevel = protocol.EncryptionInitial
+	case ackhandler.SendPTOHandshake:
+		encLevel = protocol.EncryptionHandshake
+	case ackhandler.SendPTOAppData:
+		encLevel = protocol.Encryption1RTT
+	default:
+		return fmt.Errorf("connection BUG: unexpected send mode: %d", sendMode)
+	}
+	// Queue probe packets until we actually send out a packet,
+	// or until there are no more packets to queue.
+	var packet *coalescedPacket
+	for packet == nil {
+		if wasQueued := c.sentPacketHandler.QueueProbePacket(encLevel); !wasQueued {
+			break
+		}
+		var err error
+		packet, err = c.packer.PackPTOProbePacket(encLevel, c.maxPacketSize(), false, now, c.version)
+		if err != nil {
+			return err
+		}
+	}
+	if packet == nil {
+		var err error
+		packet, err = c.packer.PackPTOProbePacket(encLevel, c.maxPacketSize(), true, now, c.version)
+		if err != nil {
+			return err
+		}
+	}
+	if packet == nil || (len(packet.longHdrPackets) == 0 && packet.shortHdrPacket == nil) {
+		return fmt.Errorf("connection BUG: couldn't pack %s probe packet: %v", encLevel, packet)
+	}
+	return c.sendPackedCoalescedPacket(packet, c.sentPacketHandler.ECNMode(packet.IsOnlyShortHeaderPacket()), now)
+}
+
+// appendOneShortHeaderPacket appends a new packet to the given packetBuffer.
+// If there was nothing to pack, the returned size is 0.
+func (c *Conn) appendOneShortHeaderPacket(buf *packetBuffer, maxSize protocol.ByteCount, ecn protocol.ECN, now monotime.Time) (protocol.ByteCount, error) {
+	startLen := buf.Len()
+	p, err := c.packer.AppendPacket(buf, maxSize, now, c.version)
+	if err != nil {
+		return 0, err
+	}
+	size := buf.Len() - startLen
+	c.logShortHeaderPacket(p, ecn, size)
+	c.registerPackedShortHeaderPacket(p, ecn, now)
+	return size, nil
+}
+
+func (c *Conn) registerPackedShortHeaderPacket(p shortHeaderPacket, ecn protocol.ECN, now monotime.Time) {
+	if p.IsPathProbePacket {
+		c.sentPacketHandler.SentPacket(
+			now,
+			p.PacketNumber,
+			protocol.InvalidPacketNumber,
+			p.StreamFrames,
+			p.Frames,
+			protocol.Encryption1RTT,
+			ecn,
+			p.Length,
+			p.IsPathMTUProbePacket,
+			true,
+		)
+		return
+	}
+	if c.firstAckElicitingPacketAfterIdleSentTime.IsZero() && (len(p.StreamFrames) > 0 || ackhandler.HasAckElicitingFrames(p.Frames)) {
+		c.firstAckElicitingPacketAfterIdleSentTime = now
+	}
+
+	largestAcked := protocol.InvalidPacketNumber
+	if p.Ack != nil {
+		largestAcked = p.Ack.LargestAcked()
+	}
+	c.sentPacketHandler.SentPacket(
+		now,
+		p.PacketNumber,
+		largestAcked,
+		p.StreamFrames,
+		p.Frames,
+		protocol.Encryption1RTT,
+		ecn,
+		p.Length,
+		p.IsPathMTUProbePacket,
+		false,
+	)
+	c.connIDManager.SentPacket()
+}
+
+func (c *Conn) sendPackedCoalescedPacket(packet *coalescedPacket, ecn protocol.ECN, now monotime.Time) error {
+	c.logCoalescedPacket(packet, ecn)
+	for _, p := range packet.longHdrPackets {
+		if c.firstAckElicitingPacketAfterIdleSentTime.IsZero() && p.IsAckEliciting() {
+			c.firstAckElicitingPacketAfterIdleSentTime = now
+		}
+		largestAcked := protocol.InvalidPacketNumber
+		if p.ack != nil {
+			largestAcked = p.ack.LargestAcked()
+		}
+		c.sentPacketHandler.SentPacket(
+			now,
+			p.header.PacketNumber,
+			largestAcked,
+			p.streamFrames,
+			p.frames,
+			p.EncryptionLevel(),
+			ecn,
+			p.length,
+			false,
+			false,
+		)
+		if c.perspective == protocol.PerspectiveClient && p.EncryptionLevel() == protocol.EncryptionHandshake &&
+			!c.droppedInitialKeys {
+			// On the client side, Initial keys are dropped as soon as the first Handshake packet is sent.
+			// See Section 4.9.1 of RFC 9001.
+			if err := c.dropEncryptionLevel(protocol.EncryptionInitial, now); err != nil {
+				return err
+			}
+		}
+	}
+	if p := packet.shortHdrPacket; p != nil {
+		if c.firstAckElicitingPacketAfterIdleSentTime.IsZero() && p.IsAckEliciting() {
+			c.firstAckElicitingPacketAfterIdleSentTime = now
+		}
+		largestAcked := protocol.InvalidPacketNumber
+		if p.Ack != nil {
+			largestAcked = p.Ack.LargestAcked()
+		}
+		c.sentPacketHandler.SentPacket(
+			now,
+			p.PacketNumber,
+			largestAcked,
+			p.StreamFrames,
+			p.Frames,
+			protocol.Encryption1RTT,
+			ecn,
+			p.Length,
+			p.IsPathMTUProbePacket,
+			false,
+		)
+	}
+	c.connIDManager.SentPacket()
+	c.sendQueue.Send(packet.buffer, 0, ecn)
+	return nil
+}
+
+func (c *Conn) sendConnectionClose(e error) ([]byte, error) {
+	var packet *coalescedPacket
+	var err error
+	var transportErr *qerr.TransportError
+	var applicationErr *qerr.ApplicationError
+	if errors.As(e, &transportErr) {
+		packet, err = c.packer.PackConnectionClose(transportErr, c.maxPacketSize(), c.version)
+	} else if errors.As(e, &applicationErr) {
+		packet, err = c.packer.PackApplicationClose(applicationErr, c.maxPacketSize(), c.version)
+	} else {
+		packet, err = c.packer.PackConnectionClose(&qerr.TransportError{
+			ErrorCode:    qerr.InternalError,
+			ErrorMessage: fmt.Sprintf("connection BUG: unspecified error type (msg: %s)", e.Error()),
+		}, c.maxPacketSize(), c.version)
+	}
+	if err != nil {
+		return nil, err
+	}
+	ecn := c.sentPacketHandler.ECNMode(packet.IsOnlyShortHeaderPacket())
+	c.logCoalescedPacket(packet, ecn)
+	return packet.buffer.Data, c.conn.Write(packet.buffer.Data, 0, ecn)
+}
+
+func (c *Conn) maxPacketSize() protocol.ByteCount {
+	if c.mtuDiscoverer == nil {
+		// Use the configured packet size on the client side.
+		// If the server sends a max_udp_payload_size that's smaller than this size, we can ignore this:
+		// Apparently the server still processed the (fully padded) Initial packet anyway.
+		if c.perspective == protocol.PerspectiveClient {
+			return protocol.ByteCount(c.config.InitialPacketSize)
+		}
+		// On the server side, there's no downside to using 1200 bytes until we received the client's transport
+		// parameters:
+		// * If the first packet didn't contain the entire ClientHello, all we can do is ACK that packet. We don't
+		//   need a lot of bytes for that.
+		// * If it did, we will have processed the transport parameters and initialized the MTU discoverer.
+		return protocol.MinInitialPacketSize
+	}
+	return c.mtuDiscoverer.CurrentSize()
+}
+
+// AcceptStream returns the next stream opened by the peer, blocking until one is available.
+func (c *Conn) AcceptStream(ctx context.Context) (*Stream, error) {
+	return c.streamsMap.AcceptStream(ctx)
+}
+
+// AcceptUniStream returns the next unidirectional stream opened by the peer, blocking until one is available.
+func (c *Conn) AcceptUniStream(ctx context.Context) (*ReceiveStream, error) {
+	return c.streamsMap.AcceptUniStream(ctx)
+}
+
+// OpenStream opens a new bidirectional QUIC stream.
+// There is no signaling to the peer about new streams:
+// The peer can only accept the stream after data has been sent on the stream,
+// or the stream has been reset or closed.
+// When reaching the peer's stream limit, it is not possible to open a new stream until the
+// peer raises the stream limit. In that case, a [StreamLimitReachedError] is returned.
+func (c *Conn) OpenStream() (*Stream, error) {
+	return c.streamsMap.OpenStream()
+}
+
+// OpenStreamSync opens a new bidirectional QUIC stream.
+// It blocks until a new stream can be opened.
+// There is no signaling to the peer about new streams:
+// The peer can only accept the stream after data has been sent on the stream,
+// or the stream has been reset or closed.
+func (c *Conn) OpenStreamSync(ctx context.Context) (*Stream, error) {
+	return c.streamsMap.OpenStreamSync(ctx)
+}
+
+// OpenUniStream opens a new outgoing unidirectional QUIC stream.
+// There is no signaling to the peer about new streams:
+// The peer can only accept the stream after data has been sent on the stream,
+// or the stream has been reset or closed.
+// When reaching the peer's stream limit, it is not possible to open a new stream until the
+// peer raises the stream limit. In that case, a [StreamLimitReachedError] is returned.
+func (c *Conn) OpenUniStream() (*SendStream, error) {
+	return c.streamsMap.OpenUniStream()
+}
+
+// OpenUniStreamSync opens a new outgoing unidirectional QUIC stream.
+// It blocks until a new stream can be opened.
+// There is no signaling to the peer about new streams:
+// The peer can only accept the stream after data has been sent on the stream,
+// or the stream has been reset or closed.
+func (c *Conn) OpenUniStreamSync(ctx context.Context) (*SendStream, error) {
+	return c.streamsMap.OpenUniStreamSync(ctx)
+}
+
+func (c *Conn) newFlowController(id protocol.StreamID) *streamFlowController {
+	initialSendWindow := c.peerParams.InitialMaxStreamDataUni
+	if protocol.StreamTypeOf(id) == protocol.StreamTypeBidi {
+		if protocol.StreamInitiator(id) == c.perspective {
+			initialSendWindow = c.peerParams.InitialMaxStreamDataBidiRemote
+		} else {
+			initialSendWindow = c.peerParams.InitialMaxStreamDataBidiLocal
+		}
+	}
+	return newStreamFlowController(
+		id,
+		c.connFlowController,
+		protocol.ByteCount(c.config.InitialStreamReceiveWindow),
+		protocol.ByteCount(c.config.MaxStreamReceiveWindow),
+		initialSendWindow,
+		c.rttStats,
+		c.logger,
+	)
+}
+
+// scheduleSending signals that we have data for sending
+func (c *Conn) scheduleSending() {
+	select {
+	case c.sendingScheduled <- struct{}{}:
+	default:
+	}
+}
+
+// tryQueueingUndecryptablePacket queues a packet for which we're missing the decryption keys.
+// The qlogevents.PacketType is only used for logging purposes.
+func (c *Conn) tryQueueingUndecryptablePacket(p receivedPacket, pt qlog.PacketType, datagramPayloadChecksum qlog.DatagramPayloadChecksum) {
+	if c.handshakeComplete {
+		panic("shouldn't queue undecryptable packets after handshake completion")
+	}
+	if len(c.undecryptablePackets)+1 > protocol.MaxUndecryptablePackets {
+		if c.qlogger != nil {
+			c.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   pt,
+					PacketNumber: protocol.InvalidPacketNumber,
+				},
+				Raw:                     qlog.RawInfo{Length: int(p.Size())},
+				DatagramPayloadChecksum: datagramPayloadChecksum,
+				Trigger:                 qlog.PacketDropDOSPrevention,
+			})
+		}
+		c.logger.Infof("Dropping undecryptable packet (%d bytes). Undecryptable packet queue full.", p.Size())
+		return
+	}
+	c.logger.Infof("Queueing packet (%d bytes) for later decryption", p.Size())
+	if c.qlogger != nil {
+		c.qlogger.RecordEvent(qlog.PacketBuffered{
+			Header: qlog.PacketHeader{
+				PacketType:   pt,
+				PacketNumber: protocol.InvalidPacketNumber,
+			},
+			Raw:                     qlog.RawInfo{Length: int(p.Size())},
+			DatagramPayloadChecksum: datagramPayloadChecksum,
+		})
+	}
+	c.undecryptablePackets = append(c.undecryptablePackets, receivedPacketWithChecksum{receivedPacket: p, checksum: datagramPayloadChecksum})
+}
+
+func (c *Conn) queueControlFrame(f wire.Frame) {
+	c.framer.QueueControlFrame(f)
+	c.scheduleSending()
+}
+
+func (c *Conn) onHasConnectionData() { c.scheduleSending() }
+
+func (c *Conn) onHasStreamData(id protocol.StreamID, str *SendStream) {
+	c.framer.AddActiveStream(id, str)
+	c.scheduleSending()
+}
+
+func (c *Conn) onHasStreamControlFrame(id protocol.StreamID, str streamControlFrameGetter) {
+	c.framer.AddStreamWithControlFrames(id, str)
+	c.scheduleSending()
+}
+
+func (c *Conn) onStreamCompleted(id protocol.StreamID) {
+	if err := c.streamsMap.DeleteStream(id); err != nil {
+		c.closeLocal(err)
+	}
+	c.framer.RemoveActiveStream(id)
+}
+
+// SendDatagram sends a message using a QUIC datagram, as specified in RFC 9221,
+// if the peer enabled datagram support.
+// There is no delivery guarantee for DATAGRAM frames, they are not retransmitted if lost.
+// The payload of the datagram needs to fit into a single QUIC packet.
+// In addition, a datagram may be dropped before being sent out if the available packet size suddenly decreases.
+// If the payload is too large to be sent at the current time, a DatagramTooLargeError is returned.
+func (c *Conn) SendDatagram(p []byte) error {
+	if !c.supportsDatagrams() {
+		return errors.New("datagram support disabled")
+	}
+
+	f := &wire.DatagramFrame{DataLenPresent: true}
+	// The payload size estimate is conservative.
+	// Under many circumstances we could send a few more bytes.
+	maxDataLen := min(
+		f.MaxDataLen(c.peerParams.MaxDatagramFrameSize, c.version),
+		protocol.ByteCount(c.maxPayloadSizeEstimate.Load()),
+	)
+	if protocol.ByteCount(len(p)) > maxDataLen {
+		return &DatagramTooLargeError{MaxDatagramPayloadSize: int64(maxDataLen)}
+	}
+	f.Data = make([]byte, len(p))
+	copy(f.Data, p)
+	return c.datagramQueue.Add(f)
+}
+
+// ReceiveDatagram gets a message received in a QUIC datagram, as specified in RFC 9221.
+func (c *Conn) ReceiveDatagram(ctx context.Context) ([]byte, error) {
+	if !c.config.EnableDatagrams {
+		return nil, errors.New("datagram support disabled")
+	}
+	return c.datagramQueue.Receive(ctx)
+}
+
+// LocalAddr returns the local address of the QUIC connection.
+func (c *Conn) LocalAddr() net.Addr { return c.conn.LocalAddr() }
+
+// RemoteAddr returns the remote address of the QUIC connection.
+func (c *Conn) RemoteAddr() net.Addr { return c.conn.RemoteAddr() }
+
+// getPathManager lazily initializes the Conn's pathManagerOutgoing.
+// May create multiple pathManagerOutgoing objects if called concurrently.
+func (c *Conn) getPathManager() *pathManagerOutgoing {
+	old := c.pathManagerOutgoing.Load()
+	if old != nil {
+		// Path manager is already initialized
+		return old
+	}
+
+	// Initialize the path manager
+	new := newPathManagerOutgoing(
+		c.connIDManager.GetConnIDForPath,
+		c.connIDManager.RetireConnIDForPath,
+		c.scheduleSending,
+	)
+	if c.pathManagerOutgoing.CompareAndSwap(old, new) {
+		return new
+	}
+
+	// Swap failed. A concurrent writer wrote first, use their value.
+	return c.pathManagerOutgoing.Load()
+}
+
+func (c *Conn) AddPath(t *Transport) (*Path, error) {
+	if c.perspective == protocol.PerspectiveServer {
+		return nil, errors.New("server cannot initiate connection migration")
+	}
+	if c.peerParams.DisableActiveMigration {
+		return nil, errors.New("server disabled connection migration")
+	}
+	if err := t.init(false); err != nil {
+		return nil, err
+	}
+	return c.getPathManager().NewPath(
+		t,
+		200*time.Millisecond, // initial RTT estimate
+		func() {
+			runner := (*packetHandlerMap)(t)
+			c.connIDGenerator.AddConnRunner(
+				runner,
+				connRunnerCallbacks{
+					AddConnectionID:    func(connID protocol.ConnectionID) { runner.Add(connID, c) },
+					RemoveConnectionID: runner.Remove,
+					ReplaceWithClosed:  runner.ReplaceWithClosed,
+				},
+			)
+		},
+	), nil
+}
+
+// HandshakeComplete blocks until the handshake completes (or fails).
+// For the client, data sent before completion of the handshake is encrypted with 0-RTT keys.
+// For the server, data sent before completion of the handshake is encrypted with 1-RTT keys,
+// however the client's identity is only verified once the handshake completes.
+func (c *Conn) HandshakeComplete() <-chan struct{} {
+	return c.handshakeCompleteChan
+}
+
+// QlogTrace returns the qlog trace of the QUIC connection.
+// It is nil if qlog is not enabled.
+func (c *Conn) QlogTrace() qlogwriter.Trace {
+	return c.qlogTrace
+}
+
+// NextConnection transitions a connection to be usable after a 0-RTT rejection.
+// It waits for the handshake to complete and then enables the connection for normal use.
+// This should be called when the server rejects 0-RTT and the application receives
+// [Err0RTTRejected] errors.
+//
+// Note that 0-RTT rejection invalidates all data sent in 0-RTT packets. It is the
+// application's responsibility to handle this (for example by resending the data).
+func (c *Conn) NextConnection(ctx context.Context) (*Conn, error) {
+	// The handshake might fail after the server rejected 0-RTT.
+	// This could happen if the Finished message is malformed or never received.
+	select {
+	case <-ctx.Done():
+		return nil, context.Cause(ctx)
+	case <-c.Context().Done():
+	case <-c.HandshakeComplete():
+		c.streamsMap.UseResetMaps()
+	}
+	return c, nil
+}
+
+// estimateMaxPayloadSize estimates the maximum payload size for short header packets.
+// It is not very sophisticated: it just subtracts the size of header (assuming the maximum
+// connection ID length), and the size of the encryption tag.
+func estimateMaxPayloadSize(mtu protocol.ByteCount) protocol.ByteCount {
+	return mtu - 1 /* type byte */ - 20 /* maximum connection ID length */ - 16 /* tag size */
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/connection_logging.go b/backend/vendor/github.com/quic-go/quic-go/connection_logging.go
new file mode 100644
index 00000000..56df4600
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/connection_logging.go
@@ -0,0 +1,315 @@
+package quic
+
+import (
+	"net"
+	"net/netip"
+	"slices"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+)
+
+// ConvertFrame converts a wire.Frame into a logging.Frame.
+// This makes it possible for external packages to access the frames.
+// Furthermore, it removes the data slices from CRYPTO and STREAM frames.
+func toQlogFrame(frame wire.Frame) qlog.Frame {
+	switch f := frame.(type) {
+	case *wire.AckFrame:
+		// We use a pool for ACK frames.
+		// Implementations of the tracer interface may hold on to frames, so we need to make a copy here.
+		return qlog.Frame{Frame: toQlogAckFrame(f)}
+	case *wire.CryptoFrame:
+		return qlog.Frame{
+			Frame: &qlog.CryptoFrame{
+				Offset: int64(f.Offset),
+				Length: int64(len(f.Data)),
+			},
+		}
+	case *wire.StreamFrame:
+		return qlog.Frame{
+			Frame: &qlog.StreamFrame{
+				StreamID: f.StreamID,
+				Offset:   int64(f.Offset),
+				Length:   int64(f.DataLen()),
+				Fin:      f.Fin,
+			},
+		}
+	case *wire.DatagramFrame:
+		return qlog.Frame{
+			Frame: &qlog.DatagramFrame{
+				Length: int64(len(f.Data)),
+			},
+		}
+	default:
+		return qlog.Frame{Frame: frame}
+	}
+}
+
+func toQlogAckFrame(f *wire.AckFrame) *qlog.AckFrame {
+	ack := &qlog.AckFrame{
+		AckRanges: slices.Clone(f.AckRanges),
+		DelayTime: f.DelayTime,
+		ECNCE:     f.ECNCE,
+		ECT0:      f.ECT0,
+		ECT1:      f.ECT1,
+	}
+	return ack
+}
+
+func (c *Conn) logLongHeaderPacket(p *longHeaderPacket, ecn protocol.ECN, datagramPayloadChecksum qlog.DatagramPayloadChecksum) {
+	// quic-go logging
+	if c.logger.Debug() {
+		p.header.Log(c.logger)
+		if p.ack != nil {
+			wire.LogFrame(c.logger, p.ack, true)
+		}
+		for _, frame := range p.frames {
+			wire.LogFrame(c.logger, frame.Frame, true)
+		}
+		for _, frame := range p.streamFrames {
+			wire.LogFrame(c.logger, frame.Frame, true)
+		}
+	}
+
+	// tracing
+	if c.qlogger != nil {
+		numFrames := len(p.frames) + len(p.streamFrames)
+		if p.ack != nil {
+			numFrames++
+		}
+		frames := make([]qlog.Frame, 0, numFrames)
+		if p.ack != nil {
+			frames = append(frames, toQlogFrame(p.ack))
+		}
+		for _, f := range p.frames {
+			frames = append(frames, toQlogFrame(f.Frame))
+		}
+		for _, f := range p.streamFrames {
+			frames = append(frames, toQlogFrame(f.Frame))
+		}
+		c.qlogger.RecordEvent(qlog.PacketSent{
+			Header: qlog.PacketHeader{
+				PacketType:       toQlogPacketType(p.header.Type),
+				KeyPhaseBit:      p.header.KeyPhase,
+				PacketNumber:     p.header.PacketNumber,
+				Version:          p.header.Version,
+				SrcConnectionID:  p.header.SrcConnectionID,
+				DestConnectionID: p.header.DestConnectionID,
+			},
+			Raw: qlog.RawInfo{
+				Length:        int(p.length),
+				PayloadLength: int(p.header.Length),
+			},
+			DatagramPayloadChecksum: datagramPayloadChecksum,
+			Frames:                  frames,
+			ECN:                     toQlogECN(ecn),
+		})
+	}
+}
+
+func (c *Conn) logShortHeaderPacket(p shortHeaderPacket, ecn protocol.ECN, size protocol.ByteCount) {
+	c.logShortHeaderPacketWithDatagramPayloadChecksum(p, ecn, size, false, 0)
+}
+
+func (c *Conn) logShortHeaderPacketWithDatagramPayloadChecksum(p shortHeaderPacket, ecn protocol.ECN, size protocol.ByteCount, isCoalesced bool, datagramPayloadChecksum qlog.DatagramPayloadChecksum) {
+	if c.logger.Debug() && !isCoalesced {
+		c.logger.Debugf("-> Sending packet %d (%d bytes) for connection %s, 1-RTT (ECN: %s)", p.PacketNumber, size, c.logID, ecn)
+	}
+	// quic-go logging
+	if c.logger.Debug() {
+		wire.LogShortHeader(c.logger, p.DestConnID, p.PacketNumber, p.PacketNumberLen, p.KeyPhase)
+		if p.Ack != nil {
+			wire.LogFrame(c.logger, p.Ack, true)
+		}
+		for _, f := range p.Frames {
+			wire.LogFrame(c.logger, f.Frame, true)
+		}
+		for _, f := range p.StreamFrames {
+			wire.LogFrame(c.logger, f.Frame, true)
+		}
+	}
+
+	// tracing
+	if c.qlogger != nil {
+		numFrames := len(p.Frames) + len(p.StreamFrames)
+		if p.Ack != nil {
+			numFrames++
+		}
+		fs := make([]qlog.Frame, 0, numFrames)
+		if p.Ack != nil {
+			fs = append(fs, toQlogFrame(p.Ack))
+		}
+		for _, f := range p.Frames {
+			fs = append(fs, toQlogFrame(f.Frame))
+		}
+		for _, f := range p.StreamFrames {
+			fs = append(fs, toQlogFrame(f.Frame))
+		}
+		c.qlogger.RecordEvent(qlog.PacketSent{
+			Header: qlog.PacketHeader{
+				PacketType:       qlog.PacketType1RTT,
+				KeyPhaseBit:      p.KeyPhase,
+				PacketNumber:     p.PacketNumber,
+				Version:          c.version,
+				DestConnectionID: p.DestConnID,
+			},
+			Raw: qlog.RawInfo{
+				Length:        int(size),
+				PayloadLength: int(size - wire.ShortHeaderLen(p.DestConnID, p.PacketNumberLen)),
+			},
+			DatagramPayloadChecksum: datagramPayloadChecksum,
+			Frames:                  fs,
+			ECN:                     toQlogECN(ecn),
+		})
+	}
+}
+
+func (c *Conn) logCoalescedPacket(packet *coalescedPacket, ecn protocol.ECN) {
+	var datagramPayloadChecksum qlog.DatagramPayloadChecksum
+	if c.qlogger != nil {
+		datagramPayloadChecksum = qlog.CalculateDatagramPayloadChecksum(packet.buffer.Data)
+	}
+	if c.logger.Debug() {
+		// There's a short period between dropping both Initial and Handshake keys and completion of the handshake,
+		// during which we might call PackCoalescedPacket but just pack a short header packet.
+		if len(packet.longHdrPackets) == 0 && packet.shortHdrPacket != nil {
+			c.logShortHeaderPacketWithDatagramPayloadChecksum(
+				*packet.shortHdrPacket,
+				ecn,
+				packet.shortHdrPacket.Length,
+				false,
+				datagramPayloadChecksum,
+			)
+			return
+		}
+		if len(packet.longHdrPackets) > 1 {
+			c.logger.Debugf("-> Sending coalesced packet (%d parts, %d bytes) for connection %s", len(packet.longHdrPackets), packet.buffer.Len(), c.logID)
+		} else {
+			c.logger.Debugf("-> Sending packet %d (%d bytes) for connection %s, %s", packet.longHdrPackets[0].header.PacketNumber, packet.buffer.Len(), c.logID, packet.longHdrPackets[0].EncryptionLevel())
+		}
+	}
+	for _, p := range packet.longHdrPackets {
+		c.logLongHeaderPacket(p, ecn, datagramPayloadChecksum)
+	}
+	if p := packet.shortHdrPacket; p != nil {
+		c.logShortHeaderPacketWithDatagramPayloadChecksum(*p, ecn, p.Length, true, datagramPayloadChecksum)
+	}
+}
+
+func (c *Conn) qlogTransportParameters(tp *wire.TransportParameters, sentBy protocol.Perspective, restore bool) {
+	ev := qlog.ParametersSet{
+		Restore:                         restore,
+		OriginalDestinationConnectionID: tp.OriginalDestinationConnectionID,
+		InitialSourceConnectionID:       tp.InitialSourceConnectionID,
+		RetrySourceConnectionID:         tp.RetrySourceConnectionID,
+		StatelessResetToken:             tp.StatelessResetToken,
+		DisableActiveMigration:          tp.DisableActiveMigration,
+		MaxIdleTimeout:                  tp.MaxIdleTimeout,
+		MaxUDPPayloadSize:               tp.MaxUDPPayloadSize,
+		AckDelayExponent:                tp.AckDelayExponent,
+		MaxAckDelay:                     tp.MaxAckDelay,
+		ActiveConnectionIDLimit:         tp.ActiveConnectionIDLimit,
+		InitialMaxData:                  tp.InitialMaxData,
+		InitialMaxStreamDataBidiLocal:   tp.InitialMaxStreamDataBidiLocal,
+		InitialMaxStreamDataBidiRemote:  tp.InitialMaxStreamDataBidiRemote,
+		InitialMaxStreamDataUni:         tp.InitialMaxStreamDataUni,
+		InitialMaxStreamsBidi:           int64(tp.MaxBidiStreamNum),
+		InitialMaxStreamsUni:            int64(tp.MaxUniStreamNum),
+		MaxDatagramFrameSize:            tp.MaxDatagramFrameSize,
+		EnableResetStreamAt:             tp.EnableResetStreamAt,
+	}
+	if sentBy == c.perspective {
+		ev.Initiator = qlog.InitiatorLocal
+	} else {
+		ev.Initiator = qlog.InitiatorRemote
+	}
+	if tp.PreferredAddress != nil {
+		ev.PreferredAddress = &qlog.PreferredAddress{
+			IPv4:                tp.PreferredAddress.IPv4,
+			IPv6:                tp.PreferredAddress.IPv6,
+			ConnectionID:        tp.PreferredAddress.ConnectionID,
+			StatelessResetToken: tp.PreferredAddress.StatelessResetToken,
+		}
+	}
+	c.qlogger.RecordEvent(ev)
+}
+
+func toQlogECN(ecn protocol.ECN) qlog.ECN {
+	//nolint:exhaustive // only need to handle the 3 valid values
+	switch ecn {
+	case protocol.ECT0:
+		return qlog.ECT0
+	case protocol.ECT1:
+		return qlog.ECT1
+	case protocol.ECNCE:
+		return qlog.ECNCE
+	default:
+		return qlog.ECNUnsupported
+	}
+}
+
+func toQlogPacketType(pt protocol.PacketType) qlog.PacketType {
+	var qpt qlog.PacketType
+	switch pt {
+	case protocol.PacketTypeInitial:
+		qpt = qlog.PacketTypeInitial
+	case protocol.PacketTypeHandshake:
+		qpt = qlog.PacketTypeHandshake
+	case protocol.PacketType0RTT:
+		qpt = qlog.PacketType0RTT
+	case protocol.PacketTypeRetry:
+		qpt = qlog.PacketTypeRetry
+	}
+	return qpt
+}
+
+func toPathEndpointInfo(addr *net.UDPAddr) qlog.PathEndpointInfo {
+	if addr == nil {
+		return qlog.PathEndpointInfo{}
+	}
+
+	var info qlog.PathEndpointInfo
+	if addr.IP == nil || addr.IP.To4() != nil {
+		addrPort := netip.AddrPortFrom(netip.AddrFrom4([4]byte(addr.IP.To4())), uint16(addr.Port))
+		if addrPort.IsValid() {
+			info.IPv4 = addrPort
+		}
+	} else {
+		addrPort := netip.AddrPortFrom(netip.AddrFrom16([16]byte(addr.IP.To16())), uint16(addr.Port))
+		if addrPort.IsValid() {
+			info.IPv6 = addrPort
+		}
+	}
+	return info
+}
+
+// startedConnectionEvent builds a StartedConnection event using consistent logic
+// for both endpoints. If the local address is unspecified (e.g., dual-stack
+// listener), it selects the family based on the remote address and uses the
+// unspecified address of that family with the local port.
+func startedConnectionEvent(local, remote *net.UDPAddr) qlog.StartedConnection {
+	var localInfo, remoteInfo qlog.PathEndpointInfo
+	if remote != nil {
+		remoteInfo = toPathEndpointInfo(remote)
+	}
+	if local != nil {
+		if local.IP == nil || local.IP.IsUnspecified() {
+			// Choose local family based on the remote address family.
+			if remote != nil && remote.IP.To4() != nil {
+				ap := netip.AddrPortFrom(netip.AddrFrom4([4]byte{}), uint16(local.Port))
+				if ap.IsValid() {
+					localInfo.IPv4 = ap
+				}
+			} else if remote != nil && remote.IP.To16() != nil && remote.IP.To4() == nil {
+				ap := netip.AddrPortFrom(netip.AddrFrom16([16]byte{}), uint16(local.Port))
+				if ap.IsValid() {
+					localInfo.IPv6 = ap
+				}
+			}
+		} else {
+			localInfo = toPathEndpointInfo(local)
+		}
+	}
+	return qlog.StartedConnection{Local: localInfo, Remote: remoteInfo}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/crypto_stream.go b/backend/vendor/github.com/quic-go/quic-go/crypto_stream.go
new file mode 100644
index 00000000..6d39aa09
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/crypto_stream.go
@@ -0,0 +1,249 @@
+package quic
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"slices"
+	"strconv"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+const disableClientHelloScramblingEnv = "QUIC_GO_DISABLE_CLIENTHELLO_SCRAMBLING"
+
+// The baseCryptoStream is used by the cryptoStream and the initialCryptoStream.
+// This allows us to implement different logic for PopCryptoFrame for the two streams.
+type baseCryptoStream struct {
+	queue frameSorter
+
+	highestOffset protocol.ByteCount
+	finished      bool
+
+	writeOffset protocol.ByteCount
+	writeBuf    []byte
+}
+
+func newCryptoStream() *cryptoStream {
+	return &cryptoStream{baseCryptoStream{queue: *newFrameSorter()}}
+}
+
+func (s *baseCryptoStream) HandleCryptoFrame(f *wire.CryptoFrame) error {
+	highestOffset := f.Offset + protocol.ByteCount(len(f.Data))
+	if maxOffset := highestOffset; maxOffset > protocol.MaxCryptoStreamOffset {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.CryptoBufferExceeded,
+			ErrorMessage: fmt.Sprintf("received invalid offset %d on crypto stream, maximum allowed %d", maxOffset, protocol.MaxCryptoStreamOffset),
+		}
+	}
+	if s.finished {
+		if highestOffset > s.highestOffset {
+			// reject crypto data received after this stream was already finished
+			return &qerr.TransportError{
+				ErrorCode:    qerr.ProtocolViolation,
+				ErrorMessage: "received crypto data after change of encryption level",
+			}
+		}
+		// ignore data with a smaller offset than the highest received
+		// could e.g. be a retransmission
+		return nil
+	}
+	s.highestOffset = max(s.highestOffset, highestOffset)
+	return s.queue.Push(f.Data, f.Offset, nil)
+}
+
+// GetCryptoData retrieves data that was received in CRYPTO frames
+func (s *baseCryptoStream) GetCryptoData() []byte {
+	_, data, _ := s.queue.Pop()
+	return data
+}
+
+func (s *baseCryptoStream) Finish() error {
+	if s.queue.HasMoreData() {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "encryption level changed, but crypto stream has more data to read",
+		}
+	}
+	s.finished = true
+	return nil
+}
+
+// Writes writes data that should be sent out in CRYPTO frames
+func (s *baseCryptoStream) Write(p []byte) (int, error) {
+	s.writeBuf = append(s.writeBuf, p...)
+	return len(p), nil
+}
+
+func (s *baseCryptoStream) HasData() bool {
+	return len(s.writeBuf) > 0
+}
+
+func (s *baseCryptoStream) PopCryptoFrame(maxLen protocol.ByteCount) *wire.CryptoFrame {
+	f := &wire.CryptoFrame{Offset: s.writeOffset}
+	n := min(f.MaxDataLen(maxLen), protocol.ByteCount(len(s.writeBuf)))
+	if n <= 0 {
+		return nil
+	}
+	f.Data = s.writeBuf[:n]
+	s.writeBuf = s.writeBuf[n:]
+	s.writeOffset += n
+	return f
+}
+
+type cryptoStream struct {
+	baseCryptoStream
+}
+
+type clientHelloCut struct {
+	start protocol.ByteCount
+	end   protocol.ByteCount
+}
+
+type initialCryptoStream struct {
+	baseCryptoStream
+
+	scramble bool
+	end      protocol.ByteCount
+	cuts     [2]clientHelloCut
+}
+
+func newInitialCryptoStream(isClient bool) *initialCryptoStream {
+	var scramble bool
+	if isClient {
+		disabled, err := strconv.ParseBool(os.Getenv(disableClientHelloScramblingEnv))
+		scramble = err != nil || !disabled
+	}
+	s := &initialCryptoStream{
+		baseCryptoStream: baseCryptoStream{queue: *newFrameSorter()},
+		scramble:         scramble,
+	}
+	for i := range len(s.cuts) {
+		s.cuts[i].start = protocol.InvalidByteCount
+		s.cuts[i].end = protocol.InvalidByteCount
+	}
+	return s
+}
+
+func (s *initialCryptoStream) HasData() bool {
+	// The ClientHello might be written in multiple parts.
+	// In order to correctly split the ClientHello, we need the entire ClientHello has been queued.
+	if s.scramble && s.writeOffset == 0 && s.cuts[0].start == protocol.InvalidByteCount {
+		return false
+	}
+	return s.baseCryptoStream.HasData()
+}
+
+func (s *initialCryptoStream) Write(p []byte) (int, error) {
+	s.writeBuf = append(s.writeBuf, p...)
+	if !s.scramble {
+		return len(p), nil
+	}
+	if s.cuts[0].start == protocol.InvalidByteCount {
+		sniPos, sniLen, echPos, err := findSNIAndECH(s.writeBuf)
+		if errors.Is(err, io.ErrUnexpectedEOF) {
+			return len(p), nil
+		}
+		if err != nil {
+			return len(p), err
+		}
+		if sniPos == -1 && echPos == -1 {
+			// Neither SNI nor ECH found.
+			// There's nothing to scramble.
+			s.scramble = false
+			return len(p), nil
+		}
+		s.end = protocol.ByteCount(len(s.writeBuf))
+		s.cuts[0].start = protocol.ByteCount(sniPos + sniLen/2) // right in the middle
+		s.cuts[0].end = protocol.ByteCount(sniPos + sniLen)
+		if echPos > 0 {
+			// ECH extension found, cut the ECH extension type value (a uint16) in half
+			start := protocol.ByteCount(echPos + 1)
+			s.cuts[1].start = start
+			// cut somewhere (16 bytes), most likely in the ECH extension value
+			s.cuts[1].end = min(start+16, s.end)
+		}
+		slices.SortFunc(s.cuts[:], func(a, b clientHelloCut) int {
+			if a.start == protocol.InvalidByteCount {
+				return 1
+			}
+			if a.start > b.start {
+				return 1
+			}
+			return -1
+		})
+	}
+	return len(p), nil
+}
+
+func (s *initialCryptoStream) PopCryptoFrame(maxLen protocol.ByteCount) *wire.CryptoFrame {
+	if !s.scramble {
+		return s.baseCryptoStream.PopCryptoFrame(maxLen)
+	}
+
+	// send out the skipped parts
+	if s.writeOffset == s.end {
+		var foundCuts bool
+		var f *wire.CryptoFrame
+		for i, c := range s.cuts {
+			if c.start == protocol.InvalidByteCount {
+				continue
+			}
+			foundCuts = true
+			if f != nil {
+				break
+			}
+			f = &wire.CryptoFrame{Offset: c.start}
+			n := min(f.MaxDataLen(maxLen), c.end-c.start)
+			if n <= 0 {
+				return nil
+			}
+			f.Data = s.writeBuf[c.start : c.start+n]
+			s.cuts[i].start += n
+			if s.cuts[i].start == c.end {
+				s.cuts[i].start = protocol.InvalidByteCount
+				s.cuts[i].end = protocol.InvalidByteCount
+				foundCuts = false
+			}
+		}
+		if !foundCuts {
+			// no more cuts found, we're done sending out everything up until s.end
+			s.writeBuf = s.writeBuf[s.end:]
+			s.end = protocol.InvalidByteCount
+			s.scramble = false
+		}
+		return f
+	}
+
+	nextCut := clientHelloCut{start: protocol.InvalidByteCount, end: protocol.InvalidByteCount}
+	for _, c := range s.cuts {
+		if c.start == protocol.InvalidByteCount {
+			continue
+		}
+		if c.start > s.writeOffset {
+			nextCut = c
+			break
+		}
+	}
+	f := &wire.CryptoFrame{Offset: s.writeOffset}
+	maxOffset := nextCut.start
+	if maxOffset == protocol.InvalidByteCount {
+		maxOffset = s.end
+	}
+	n := min(f.MaxDataLen(maxLen), maxOffset-s.writeOffset)
+	if n <= 0 {
+		return nil
+	}
+	f.Data = s.writeBuf[s.writeOffset : s.writeOffset+n]
+	// Don't reslice the writeBuf yet.
+	// This is done once all parts have been sent out.
+	s.writeOffset += n
+	if s.writeOffset == nextCut.start {
+		s.writeOffset = nextCut.end
+	}
+
+	return f
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/crypto_stream_manager.go b/backend/vendor/github.com/quic-go/quic-go/crypto_stream_manager.go
new file mode 100644
index 00000000..1e7dbf74
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/crypto_stream_manager.go
@@ -0,0 +1,73 @@
+package quic
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type cryptoStreamManager struct {
+	initialStream   *initialCryptoStream
+	handshakeStream *cryptoStream
+	oneRTTStream    *cryptoStream
+}
+
+func newCryptoStreamManager(
+	initialStream *initialCryptoStream,
+	handshakeStream *cryptoStream,
+	oneRTTStream *cryptoStream,
+) *cryptoStreamManager {
+	return &cryptoStreamManager{
+		initialStream:   initialStream,
+		handshakeStream: handshakeStream,
+		oneRTTStream:    oneRTTStream,
+	}
+}
+
+func (m *cryptoStreamManager) HandleCryptoFrame(frame *wire.CryptoFrame, encLevel protocol.EncryptionLevel) error {
+	//nolint:exhaustive // CRYPTO frames cannot be sent in 0-RTT packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return m.initialStream.HandleCryptoFrame(frame)
+	case protocol.EncryptionHandshake:
+		return m.handshakeStream.HandleCryptoFrame(frame)
+	case protocol.Encryption1RTT:
+		return m.oneRTTStream.HandleCryptoFrame(frame)
+	default:
+		return fmt.Errorf("received CRYPTO frame with unexpected encryption level: %s", encLevel)
+	}
+}
+
+func (m *cryptoStreamManager) GetCryptoData(encLevel protocol.EncryptionLevel) []byte {
+	//nolint:exhaustive // CRYPTO frames cannot be sent in 0-RTT packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return m.initialStream.GetCryptoData()
+	case protocol.EncryptionHandshake:
+		return m.handshakeStream.GetCryptoData()
+	case protocol.Encryption1RTT:
+		return m.oneRTTStream.GetCryptoData()
+	default:
+		panic(fmt.Sprintf("received CRYPTO frame with unexpected encryption level: %s", encLevel))
+	}
+}
+
+func (m *cryptoStreamManager) GetPostHandshakeData(maxSize protocol.ByteCount) *wire.CryptoFrame {
+	if !m.oneRTTStream.HasData() {
+		return nil
+	}
+	return m.oneRTTStream.PopCryptoFrame(maxSize)
+}
+
+func (m *cryptoStreamManager) Drop(encLevel protocol.EncryptionLevel) error {
+	//nolint:exhaustive // 1-RTT keys should never get dropped.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return m.initialStream.Finish()
+	case protocol.EncryptionHandshake:
+		return m.handshakeStream.Finish()
+	default:
+		panic(fmt.Sprintf("dropped unexpected encryption level: %s", encLevel))
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/datagram_queue.go b/backend/vendor/github.com/quic-go/quic-go/datagram_queue.go
new file mode 100644
index 00000000..e26285b2
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/datagram_queue.go
@@ -0,0 +1,137 @@
+package quic
+
+import (
+	"context"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/utils/ringbuffer"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+const (
+	maxDatagramSendQueueLen = 32
+	maxDatagramRcvQueueLen  = 128
+)
+
+type datagramQueue struct {
+	sendMx    sync.Mutex
+	sendQueue ringbuffer.RingBuffer[*wire.DatagramFrame]
+	sent      chan struct{} // used to notify Add that a datagram was dequeued
+
+	rcvMx    sync.Mutex
+	rcvQueue [][]byte
+	rcvd     chan struct{} // used to notify Receive that a new datagram was received
+
+	closeErr error
+	closed   chan struct{}
+
+	hasData func()
+
+	logger utils.Logger
+}
+
+func newDatagramQueue(hasData func(), logger utils.Logger) *datagramQueue {
+	return &datagramQueue{
+		hasData: hasData,
+		rcvd:    make(chan struct{}, 1),
+		sent:    make(chan struct{}, 1),
+		closed:  make(chan struct{}),
+		logger:  logger,
+	}
+}
+
+// Add queues a new DATAGRAM frame for sending.
+// Up to 32 DATAGRAM frames will be queued.
+// Once that limit is reached, Add blocks until the queue size has reduced.
+func (h *datagramQueue) Add(f *wire.DatagramFrame) error {
+	h.sendMx.Lock()
+
+	for {
+		if h.sendQueue.Len() < maxDatagramSendQueueLen {
+			h.sendQueue.PushBack(f)
+			h.sendMx.Unlock()
+			h.hasData()
+			return nil
+		}
+		select {
+		case <-h.sent: // drain the queue so we don't loop immediately
+		default:
+		}
+		h.sendMx.Unlock()
+		select {
+		case <-h.closed:
+			return h.closeErr
+		case <-h.sent:
+		}
+		h.sendMx.Lock()
+	}
+}
+
+// Peek gets the next DATAGRAM frame for sending.
+// If actually sent out, Pop needs to be called before the next call to Peek.
+func (h *datagramQueue) Peek() *wire.DatagramFrame {
+	h.sendMx.Lock()
+	defer h.sendMx.Unlock()
+	if h.sendQueue.Empty() {
+		return nil
+	}
+	return h.sendQueue.PeekFront()
+}
+
+func (h *datagramQueue) Pop() {
+	h.sendMx.Lock()
+	defer h.sendMx.Unlock()
+	_ = h.sendQueue.PopFront()
+	select {
+	case h.sent <- struct{}{}:
+	default:
+	}
+}
+
+// HandleDatagramFrame handles a received DATAGRAM frame.
+func (h *datagramQueue) HandleDatagramFrame(f *wire.DatagramFrame) {
+	data := make([]byte, len(f.Data))
+	copy(data, f.Data)
+	var queued bool
+	h.rcvMx.Lock()
+	if len(h.rcvQueue) < maxDatagramRcvQueueLen {
+		h.rcvQueue = append(h.rcvQueue, data)
+		queued = true
+		select {
+		case h.rcvd <- struct{}{}:
+		default:
+		}
+	}
+	h.rcvMx.Unlock()
+	if !queued && h.logger.Debug() {
+		h.logger.Debugf("Discarding received DATAGRAM frame (%d bytes payload)", len(f.Data))
+	}
+}
+
+// Receive gets a received DATAGRAM frame.
+func (h *datagramQueue) Receive(ctx context.Context) ([]byte, error) {
+	for {
+		h.rcvMx.Lock()
+		if len(h.rcvQueue) > 0 {
+			data := h.rcvQueue[0]
+			h.rcvQueue = h.rcvQueue[1:]
+			h.rcvMx.Unlock()
+			return data, nil
+		}
+		h.rcvMx.Unlock()
+		select {
+		case <-h.rcvd:
+			continue
+		case <-h.closed:
+			return nil, h.closeErr
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		}
+	}
+}
+
+func (h *datagramQueue) CloseWithError(e error) {
+	h.closeErr = e
+	close(h.closed)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/errors.go b/backend/vendor/github.com/quic-go/quic-go/errors.go
new file mode 100644
index 00000000..829730fe
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/errors.go
@@ -0,0 +1,105 @@
+package quic
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/qerr"
+)
+
+type (
+	// TransportError indicates an error that occurred on the QUIC transport layer.
+	// Every transport error other than CONNECTION_REFUSED and APPLICATION_ERROR is
+	// likely a bug in the implementation.
+	TransportError = qerr.TransportError
+	// ApplicationError is an application-defined error.
+	ApplicationError = qerr.ApplicationError
+	// VersionNegotiationError indicates a failure to negotiate a QUIC version.
+	VersionNegotiationError = qerr.VersionNegotiationError
+	// StatelessResetError indicates a stateless reset was received.
+	// This can happen when the peer reboots, or when packets are misrouted.
+	// See section 10.3 of RFC 9000 for details.
+	StatelessResetError = qerr.StatelessResetError
+	// IdleTimeoutError indicates that the connection timed out because it was inactive for too long.
+	IdleTimeoutError = qerr.IdleTimeoutError
+	// HandshakeTimeoutError indicates that the connection timed out before completing the handshake.
+	HandshakeTimeoutError = qerr.HandshakeTimeoutError
+)
+
+type (
+	// TransportErrorCode is a QUIC transport error code, see section 20 of RFC 9000.
+	TransportErrorCode = qerr.TransportErrorCode
+	// ApplicationErrorCode is an QUIC application error code.
+	ApplicationErrorCode = qerr.ApplicationErrorCode
+	// StreamErrorCode is a QUIC stream error code. The meaning of the value is defined by the application.
+	StreamErrorCode = qerr.StreamErrorCode
+)
+
+const (
+	// NoError is the NO_ERROR transport error code.
+	NoError = qerr.NoError
+	// InternalError is the INTERNAL_ERROR transport error code.
+	InternalError = qerr.InternalError
+	// ConnectionRefused is the CONNECTION_REFUSED transport error code.
+	ConnectionRefused = qerr.ConnectionRefused
+	// FlowControlError is the FLOW_CONTROL_ERROR transport error code.
+	FlowControlError = qerr.FlowControlError
+	// StreamLimitError is the STREAM_LIMIT_ERROR transport error code.
+	StreamLimitError = qerr.StreamLimitError
+	// StreamStateError is the STREAM_STATE_ERROR transport error code.
+	StreamStateError = qerr.StreamStateError
+	// FinalSizeError is the FINAL_SIZE_ERROR transport error code.
+	FinalSizeError = qerr.FinalSizeError
+	// FrameEncodingError is the FRAME_ENCODING_ERROR transport error code.
+	FrameEncodingError = qerr.FrameEncodingError
+	// TransportParameterError is the TRANSPORT_PARAMETER_ERROR transport error code.
+	TransportParameterError = qerr.TransportParameterError
+	// ConnectionIDLimitError is the CONNECTION_ID_LIMIT_ERROR transport error code.
+	ConnectionIDLimitError = qerr.ConnectionIDLimitError
+	// ProtocolViolation is the PROTOCOL_VIOLATION transport error code.
+	ProtocolViolation = qerr.ProtocolViolation
+	// InvalidToken is the INVALID_TOKEN transport error code.
+	InvalidToken = qerr.InvalidToken
+	// ApplicationErrorErrorCode is the APPLICATION_ERROR transport error code.
+	ApplicationErrorErrorCode = qerr.ApplicationErrorErrorCode
+	// CryptoBufferExceeded is the CRYPTO_BUFFER_EXCEEDED transport error code.
+	CryptoBufferExceeded = qerr.CryptoBufferExceeded
+	// KeyUpdateError is the KEY_UPDATE_ERROR transport error code.
+	KeyUpdateError = qerr.KeyUpdateError
+	// AEADLimitReached is the AEAD_LIMIT_REACHED transport error code.
+	AEADLimitReached = qerr.AEADLimitReached
+	// NoViablePathError is the NO_VIABLE_PATH_ERROR transport error code.
+	NoViablePathError = qerr.NoViablePathError
+)
+
+// A StreamError is used to signal stream cancellations.
+// It is returned from the Read and Write methods of the [ReceiveStream], [SendStream] and [Stream].
+type StreamError struct {
+	StreamID  StreamID
+	ErrorCode StreamErrorCode
+	Remote    bool
+}
+
+func (e *StreamError) Is(target error) bool {
+	t, ok := target.(*StreamError)
+	return ok && e.StreamID == t.StreamID && e.ErrorCode == t.ErrorCode && e.Remote == t.Remote
+}
+
+func (e *StreamError) Error() string {
+	pers := "local"
+	if e.Remote {
+		pers = "remote"
+	}
+	return fmt.Sprintf("stream %d canceled by %s with error code %d", e.StreamID, pers, e.ErrorCode)
+}
+
+// DatagramTooLargeError is returned from Conn.SendDatagram if the payload is too large to be sent.
+type DatagramTooLargeError struct {
+	MaxDatagramPayloadSize int64
+}
+
+func (e *DatagramTooLargeError) Is(target error) bool {
+	t, ok := target.(*DatagramTooLargeError)
+	return ok && e.MaxDatagramPayloadSize == t.MaxDatagramPayloadSize
+}
+
+func (e *DatagramTooLargeError) Error() string { return "DATAGRAM frame too large" }
diff --git a/backend/vendor/github.com/quic-go/quic-go/flow_controller_base.go b/backend/vendor/github.com/quic-go/quic-go/flow_controller_base.go
new file mode 100644
index 00000000..769336cd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/flow_controller_base.go
@@ -0,0 +1,84 @@
+package quic
+
+import (
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+type receiveFlowController struct {
+	//nolint:structcheck // The mutex is used both by the stream and the connection flow controller
+	mutex                sync.Mutex
+	bytesRead            protocol.ByteCount
+	highestReceived      protocol.ByteCount
+	receiveWindow        protocol.ByteCount
+	receiveWindowSize    protocol.ByteCount
+	maxReceiveWindowSize protocol.ByteCount
+
+	allowWindowIncrease func(size protocol.ByteCount) bool
+
+	epochStartTime   monotime.Time
+	epochStartOffset protocol.ByteCount
+	rttStats         *utils.RTTStats
+
+	logger utils.Logger
+}
+
+// needs to be called with locked mutex
+func (c *receiveFlowController) addBytesRead(n protocol.ByteCount) {
+	c.bytesRead += n
+}
+
+func (c *receiveFlowController) hasWindowUpdate() bool {
+	bytesRemaining := c.receiveWindow - c.bytesRead
+	// update the window when more than the threshold was consumed
+	return bytesRemaining <= protocol.ByteCount(float64(c.receiveWindowSize)*(1-protocol.WindowUpdateThreshold))
+}
+
+// getWindowUpdate updates the receive window, if necessary
+// it returns the new offset
+func (c *receiveFlowController) getWindowUpdate(now monotime.Time) protocol.ByteCount {
+	if !c.hasWindowUpdate() {
+		return 0
+	}
+
+	c.maybeAdjustWindowSize(now)
+	c.receiveWindow = c.bytesRead + c.receiveWindowSize
+	return c.receiveWindow
+}
+
+// maybeAdjustWindowSize increases the receiveWindowSize if we're sending updates too often.
+// For details about auto-tuning, see https://docs.google.com/document/d/1SExkMmGiz8VYzV3s9E35JQlJ73vhzCekKkDi85F1qCE/edit?usp=sharing.
+func (c *receiveFlowController) maybeAdjustWindowSize(now monotime.Time) {
+	bytesReadInEpoch := c.bytesRead - c.epochStartOffset
+	// don't do anything if less than half the window has been consumed
+	if bytesReadInEpoch <= c.receiveWindowSize/2 {
+		return
+	}
+	rtt := c.rttStats.SmoothedRTT()
+	if rtt == 0 {
+		return
+	}
+
+	fraction := float64(bytesReadInEpoch) / float64(c.receiveWindowSize)
+	if now.Sub(c.epochStartTime) < time.Duration(4*fraction*float64(rtt)) {
+		// window is consumed too fast, try to increase the window size
+		newSize := min(2*c.receiveWindowSize, c.maxReceiveWindowSize)
+		if newSize > c.receiveWindowSize && (c.allowWindowIncrease == nil || c.allowWindowIncrease(newSize-c.receiveWindowSize)) {
+			c.receiveWindowSize = newSize
+		}
+	}
+	c.startNewAutoTuningEpoch(now)
+}
+
+func (c *receiveFlowController) startNewAutoTuningEpoch(now monotime.Time) {
+	c.epochStartTime = now
+	c.epochStartOffset = c.bytesRead
+}
+
+func (c *receiveFlowController) checkFlowControlViolation() bool {
+	return c.highestReceived > c.receiveWindow
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/flow_controller_connection.go b/backend/vendor/github.com/quic-go/quic-go/flow_controller_connection.go
new file mode 100644
index 00000000..5d709de5
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/flow_controller_connection.go
@@ -0,0 +1,186 @@
+package quic
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+type connectionFlowController struct {
+	receiveFlowController
+
+	// Protects send-side state, which TryWriteAll can access from application goroutines.
+	sendMutex     sync.Mutex
+	bytesSent     protocol.ByteCount
+	sendWindow    protocol.ByteCount
+	lastBlockedAt protocol.ByteCount
+}
+
+// newConnectionFlowController gets a new flow controller for the connection.
+// It is created before we receive the peer's transport parameters, thus it starts with a sendWindow of 0.
+func newConnectionFlowController(
+	receiveWindow protocol.ByteCount,
+	maxReceiveWindow protocol.ByteCount,
+	allowWindowIncrease func(size protocol.ByteCount) bool,
+	rttStats *utils.RTTStats,
+	logger utils.Logger,
+) *connectionFlowController {
+	return &connectionFlowController{
+		receiveFlowController: receiveFlowController{
+			rttStats:             rttStats,
+			receiveWindow:        receiveWindow,
+			receiveWindowSize:    receiveWindow,
+			maxReceiveWindowSize: maxReceiveWindow,
+			allowWindowIncrease:  allowWindowIncrease,
+			logger:               logger,
+		},
+	}
+}
+
+// IncrementHighestReceived adds an increment to the highestReceived value
+func (c *connectionFlowController) IncrementHighestReceived(increment protocol.ByteCount, now monotime.Time) error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// If this is the first frame received on this connection, start flow-control auto-tuning.
+	if c.highestReceived == 0 {
+		c.startNewAutoTuningEpoch(now)
+	}
+	c.highestReceived += increment
+
+	if c.checkFlowControlViolation() {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.FlowControlError,
+			ErrorMessage: fmt.Sprintf("received %d bytes for the connection, allowed %d bytes", c.highestReceived, c.receiveWindow),
+		}
+	}
+	return nil
+}
+
+func (c *connectionFlowController) AddBytesRead(n protocol.ByteCount) (hasWindowUpdate bool) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	c.addBytesRead(n)
+	return c.hasWindowUpdate()
+}
+
+// TryAddBytesSent adds n bytes if sufficient connection-level send credit is available.
+func (c *connectionFlowController) TryAddBytesSent(n protocol.ByteCount) bool {
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	if c.bytesSent > c.sendWindow || n > c.sendWindow-c.bytesSent {
+		return false
+	}
+	c.bytesSent += n
+	return true
+}
+
+// AddBytesSentWithLimiter adds the limiter-approved portion of the available connection-level send credit.
+func (c *connectionFlowController) AddBytesSentWithLimiter(
+	n protocol.ByteCount,
+	limiter func(int) int,
+) (protocol.ByteCount, bool) {
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	if c.bytesSent >= c.sendWindow {
+		return 0, false
+	}
+	n = min(n, c.sendWindow-c.bytesSent)
+	added := min(
+		max(protocol.ByteCount(limiter(int(n))), 0),
+		n,
+	)
+	c.bytesSent += added
+	return added, added < n
+}
+
+// UpdateSendWindow is called after receiving a MAX_DATA frame.
+func (c *connectionFlowController) UpdateSendWindow(offset protocol.ByteCount) (updated bool) {
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	if offset > c.sendWindow {
+		c.sendWindow = offset
+		return true
+	}
+	return false
+}
+
+func (c *connectionFlowController) SendWindowSize() protocol.ByteCount {
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	return c.sendWindow - c.bytesSent
+}
+
+// IsNewlyBlocked says if it is newly blocked by connection flow control.
+// For every offset, it only returns true once.
+// If it is blocked, the offset is returned.
+func (c *connectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) {
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	if c.bytesSent < c.sendWindow || c.sendWindow == c.lastBlockedAt {
+		return false, 0
+	}
+	c.lastBlockedAt = c.sendWindow
+	return true, c.sendWindow
+}
+
+func (c *connectionFlowController) GetWindowUpdate(now monotime.Time) protocol.ByteCount {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	oldWindowSize := c.receiveWindowSize
+	offset := c.getWindowUpdate(now)
+	if c.logger.Debug() && oldWindowSize < c.receiveWindowSize {
+		c.logger.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowSize/(1<<10))
+	}
+	return offset
+}
+
+// EnsureMinimumWindowSize sets a minimum window size
+// it should make sure that the connection-level window is increased when a stream-level window grows
+func (c *connectionFlowController) EnsureMinimumWindowSize(inc protocol.ByteCount, now monotime.Time) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if inc <= c.receiveWindowSize {
+		return
+	}
+	newSize := min(inc, c.maxReceiveWindowSize)
+	if delta := newSize - c.receiveWindowSize; delta > 0 && c.allowWindowIncrease(delta) {
+		c.receiveWindowSize = newSize
+		if c.logger.Debug() {
+			c.logger.Debugf("Increasing receive flow control window for the connection to %d, in response to stream flow control window increase", newSize)
+		}
+	}
+	c.startNewAutoTuningEpoch(now)
+}
+
+// Reset rests the flow controller. This happens when 0-RTT is rejected.
+// All stream data is invalidated, it's as if we had never opened a stream and never sent any data.
+// At that point, we only have sent stream data, but we didn't have the keys to open 1-RTT keys yet.
+func (c *connectionFlowController) Reset() error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if c.bytesRead > 0 || c.highestReceived > 0 || !c.epochStartTime.IsZero() {
+		return errors.New("flow controller reset after reading data")
+	}
+	c.sendMutex.Lock()
+	defer c.sendMutex.Unlock()
+
+	c.bytesSent = 0
+	c.lastBlockedAt = 0
+	c.sendWindow = 0
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/flow_controller_stream.go b/backend/vendor/github.com/quic-go/quic-go/flow_controller_stream.go
new file mode 100644
index 00000000..4375b5f1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/flow_controller_stream.go
@@ -0,0 +1,196 @@
+package quic
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+type streamFlowController struct {
+	receiveFlowController
+
+	bytesSent     protocol.ByteCount
+	sendWindow    protocol.ByteCount
+	lastBlockedAt protocol.ByteCount
+
+	streamID protocol.StreamID
+
+	connection *connectionFlowController
+
+	receivedFinalOffset bool
+}
+
+// newStreamFlowController gets a new flow controller for a stream.
+func newStreamFlowController(
+	streamID protocol.StreamID,
+	cfc *connectionFlowController,
+	receiveWindow protocol.ByteCount,
+	maxReceiveWindow protocol.ByteCount,
+	initialSendWindow protocol.ByteCount,
+	rttStats *utils.RTTStats,
+	logger utils.Logger,
+) *streamFlowController {
+	return &streamFlowController{
+		streamID:   streamID,
+		connection: cfc,
+		sendWindow: initialSendWindow,
+		receiveFlowController: receiveFlowController{
+			rttStats:             rttStats,
+			receiveWindow:        receiveWindow,
+			receiveWindowSize:    receiveWindow,
+			maxReceiveWindowSize: maxReceiveWindow,
+			logger:               logger,
+		},
+	}
+}
+
+// UpdateHighestReceived updates the highestReceived value, if the offset is higher.
+func (c *streamFlowController) UpdateHighestReceived(offset protocol.ByteCount, final bool, now monotime.Time) error {
+	// If the final offset for this stream is already known, check for consistency.
+	if c.receivedFinalOffset {
+		// If we receive another final offset, check that it's the same.
+		if final && offset != c.highestReceived {
+			return &qerr.TransportError{
+				ErrorCode:    qerr.FinalSizeError,
+				ErrorMessage: fmt.Sprintf("received inconsistent final offset for stream %d (old: %d, new: %d bytes)", c.streamID, c.highestReceived, offset),
+			}
+		}
+		// Check that the offset is below the final offset.
+		if offset > c.highestReceived {
+			return &qerr.TransportError{
+				ErrorCode:    qerr.FinalSizeError,
+				ErrorMessage: fmt.Sprintf("received offset %d for stream %d, but final offset was already received at %d", offset, c.streamID, c.highestReceived),
+			}
+		}
+	}
+
+	if final {
+		c.receivedFinalOffset = true
+	}
+	if offset == c.highestReceived {
+		return nil
+	}
+	// A higher offset was received before. This can happen due to reordering.
+	if offset < c.highestReceived {
+		if final {
+			return &qerr.TransportError{
+				ErrorCode:    qerr.FinalSizeError,
+				ErrorMessage: fmt.Sprintf("received final offset %d for stream %d, but already received offset %d before", offset, c.streamID, c.highestReceived),
+			}
+		}
+		return nil
+	}
+
+	// If this is the first frame received for this stream, start flow-control auto-tuning.
+	if c.highestReceived == 0 {
+		c.startNewAutoTuningEpoch(now)
+	}
+	increment := offset - c.highestReceived
+	c.highestReceived = offset
+
+	if c.checkFlowControlViolation() {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.FlowControlError,
+			ErrorMessage: fmt.Sprintf("received %d bytes on stream %d, allowed %d bytes", offset, c.streamID, c.receiveWindow),
+		}
+	}
+	return c.connection.IncrementHighestReceived(increment, now)
+}
+
+func (c *streamFlowController) AddBytesRead(n protocol.ByteCount) (hasStreamWindowUpdate, hasConnWindowUpdate bool) {
+	c.mutex.Lock()
+	c.addBytesRead(n)
+	hasStreamWindowUpdate = c.shouldQueueWindowUpdate()
+	c.mutex.Unlock()
+	hasConnWindowUpdate = c.connection.AddBytesRead(n)
+	return
+}
+
+func (c *streamFlowController) Abandon() {
+	c.mutex.Lock()
+	unread := c.highestReceived - c.bytesRead
+	c.bytesRead = c.highestReceived
+	c.mutex.Unlock()
+	if unread > 0 {
+		c.connection.AddBytesRead(unread)
+	}
+}
+
+func (c *streamFlowController) UpdateSendWindow(offset protocol.ByteCount) (updated bool) {
+	if offset > c.sendWindow {
+		c.sendWindow = offset
+		return true
+	}
+	return false
+}
+
+// TryAddBytesSent adds n bytes if sufficient stream- and connection-level send credit is available.
+func (c *streamFlowController) TryAddBytesSent(n protocol.ByteCount) bool {
+	if c.bytesSent > c.sendWindow || n > c.sendWindow-c.bytesSent {
+		return false
+	}
+	if !c.connection.TryAddBytesSent(n) {
+		return false
+	}
+	c.bytesSent += n
+	return true
+}
+
+// AddBytesSentWithLimiter adds the limiter-approved portion of the available stream- and connection-level send credit.
+func (c *streamFlowController) AddBytesSentWithLimiter(
+	n protocol.ByteCount,
+	limiter func(int) int,
+) (protocol.ByteCount, bool) {
+	if c.bytesSent >= c.sendWindow {
+		return 0, false
+	}
+	n = min(n, c.sendWindow-c.bytesSent)
+	added, limited := c.connection.AddBytesSentWithLimiter(n, limiter)
+	c.bytesSent += added
+	return added, limited
+}
+
+func (c *streamFlowController) SendWindowSize() protocol.ByteCount {
+	return min(c.sendWindow-c.bytesSent, c.connection.SendWindowSize())
+}
+
+func (c *streamFlowController) IsNewlyBlocked() bool {
+	blocked, _ := c.isNewlyBlocked()
+	return blocked
+}
+
+func (c *streamFlowController) isNewlyBlocked() (bool, protocol.ByteCount) {
+	if c.bytesSent < c.sendWindow || c.sendWindow == c.lastBlockedAt {
+		return false, 0
+	}
+	c.lastBlockedAt = c.sendWindow
+	return true, c.sendWindow
+}
+
+func (c *streamFlowController) shouldQueueWindowUpdate() bool {
+	return !c.receivedFinalOffset && c.hasWindowUpdate()
+}
+
+func (c *streamFlowController) GetWindowUpdate(now monotime.Time) protocol.ByteCount {
+	// If we already received the final offset for this stream, the peer won't need any additional flow control credit.
+	if c.receivedFinalOffset {
+		return 0
+	}
+
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	oldWindowSize := c.receiveWindowSize
+	offset := c.getWindowUpdate(now)
+	if c.receiveWindowSize > oldWindowSize { // auto-tuning enlarged the window size
+		c.logger.Debugf("Increasing receive flow control window for stream %d to %d", c.streamID, c.receiveWindowSize)
+		c.connection.EnsureMinimumWindowSize(
+			protocol.ByteCount(float64(c.receiveWindowSize)*protocol.ConnectionFlowControlMultiplier),
+			now,
+		)
+	}
+	return offset
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/frame_sorter.go b/backend/vendor/github.com/quic-go/quic-go/frame_sorter.go
new file mode 100644
index 00000000..20c6d9cc
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/frame_sorter.go
@@ -0,0 +1,274 @@
+package quic
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	list "github.com/quic-go/quic-go/internal/utils/linkedlist"
+)
+
+// byteInterval is an interval from one ByteCount to the other
+type byteInterval struct {
+	Start protocol.ByteCount
+	End   protocol.ByteCount
+}
+
+var byteIntervalElementPool sync.Pool
+
+func init() {
+	byteIntervalElementPool = *list.NewPool[byteInterval]()
+}
+
+type frameSorterEntry struct {
+	Data   []byte
+	DoneCb func()
+}
+
+type frameSorter struct {
+	queue   map[protocol.ByteCount]frameSorterEntry
+	readPos protocol.ByteCount
+	gaps    *list.List[byteInterval]
+}
+
+var errDuplicateStreamData = errors.New("duplicate stream data")
+
+func newFrameSorter() *frameSorter {
+	s := frameSorter{
+		gaps:  list.NewWithPool[byteInterval](&byteIntervalElementPool),
+		queue: make(map[protocol.ByteCount]frameSorterEntry),
+	}
+	s.gaps.PushFront(byteInterval{Start: 0, End: protocol.MaxByteCount})
+	return &s
+}
+
+func (s *frameSorter) Push(data []byte, offset protocol.ByteCount, doneCb func()) error {
+	err := s.push(data, offset, doneCb)
+	if err == errDuplicateStreamData {
+		if doneCb != nil {
+			doneCb()
+		}
+		return nil
+	}
+	return err
+}
+
+func (s *frameSorter) push(data []byte, offset protocol.ByteCount, doneCb func()) error {
+	if len(data) == 0 {
+		return errDuplicateStreamData
+	}
+
+	start := offset
+	end := offset + protocol.ByteCount(len(data))
+
+	if end <= s.gaps.Front().Value.Start {
+		return errDuplicateStreamData
+	}
+
+	startGap, startsInGap := s.findStartGap(start)
+	endGap, endsInGap := s.findEndGap(startGap, end)
+
+	startGapEqualsEndGap := startGap == endGap
+
+	if (startGapEqualsEndGap && end <= startGap.Value.Start) ||
+		(!startGapEqualsEndGap && startGap.Value.End >= endGap.Value.Start && end <= startGap.Value.Start) {
+		return errDuplicateStreamData
+	}
+
+	startGapNext := startGap.Next()
+	startGapEnd := startGap.Value.End // save it, in case startGap is modified
+	endGapStart := endGap.Value.Start // save it, in case endGap is modified
+	endGapEnd := endGap.Value.End     // save it, in case endGap is modified
+	var adjustedStartGapEnd bool
+	var wasCut bool
+
+	pos := start
+	var hasReplacedAtLeastOne bool
+	for {
+		oldEntry, ok := s.queue[pos]
+		if !ok {
+			break
+		}
+		oldEntryLen := protocol.ByteCount(len(oldEntry.Data))
+		if end-pos > oldEntryLen || (hasReplacedAtLeastOne && end-pos == oldEntryLen) {
+			// The existing frame is shorter than the new frame. Replace it.
+			delete(s.queue, pos)
+			pos += oldEntryLen
+			hasReplacedAtLeastOne = true
+			if oldEntry.DoneCb != nil {
+				oldEntry.DoneCb()
+			}
+		} else {
+			if !hasReplacedAtLeastOne {
+				return errDuplicateStreamData
+			}
+			// The existing frame is longer than the new frame.
+			// Cut the new frame such that the end aligns with the start of the existing frame.
+			data = data[:pos-start]
+			end = pos
+			wasCut = true
+			break
+		}
+	}
+
+	if !startsInGap && !hasReplacedAtLeastOne {
+		// cut the frame, such that it starts at the start of the gap
+		data = data[startGap.Value.Start-start:]
+		start = startGap.Value.Start
+		wasCut = true
+	}
+	if start <= startGap.Value.Start {
+		if end >= startGap.Value.End {
+			// The frame covers the whole startGap. Delete the gap.
+			s.gaps.Remove(startGap)
+		} else {
+			startGap.Value.Start = end
+		}
+	} else if !hasReplacedAtLeastOne {
+		startGap.Value.End = start
+		adjustedStartGapEnd = true
+	}
+
+	if !startGapEqualsEndGap {
+		s.deleteConsecutive(startGapEnd)
+		var nextGap *list.Element[byteInterval]
+		for gap := startGapNext; gap.Value.End < endGapStart; gap = nextGap {
+			nextGap = gap.Next()
+			s.deleteConsecutive(gap.Value.End)
+			s.gaps.Remove(gap)
+		}
+	}
+
+	if !endsInGap && start != endGapEnd && end > endGapEnd {
+		// cut the frame, such that it ends at the end of the gap
+		data = data[:endGapEnd-start]
+		end = endGapEnd
+		wasCut = true
+	}
+	if end == endGapEnd {
+		if !startGapEqualsEndGap {
+			// The frame covers the whole endGap. Delete the gap.
+			s.gaps.Remove(endGap)
+		}
+	} else {
+		if startGapEqualsEndGap && adjustedStartGapEnd {
+			// The frame split the existing gap into two.
+			s.gaps.InsertAfter(byteInterval{Start: end, End: startGapEnd}, startGap)
+		} else if !startGapEqualsEndGap {
+			endGap.Value.Start = end
+		}
+	}
+
+	if wasCut && len(data) < protocol.MinStreamFrameBufferSize {
+		newData := make([]byte, len(data))
+		copy(newData, data)
+		data = newData
+		if doneCb != nil {
+			doneCb()
+			doneCb = nil
+		}
+	}
+
+	if s.gaps.Len() > protocol.MaxStreamFrameSorterGaps {
+		return errors.New("too many gaps in received data")
+	}
+
+	s.queue[start] = frameSorterEntry{Data: data, DoneCb: doneCb}
+	return nil
+}
+
+func (s *frameSorter) findStartGap(offset protocol.ByteCount) (*list.Element[byteInterval], bool) {
+	for gap := s.gaps.Front(); gap != nil; gap = gap.Next() {
+		if offset >= gap.Value.Start && offset <= gap.Value.End {
+			return gap, true
+		}
+		if offset < gap.Value.Start {
+			return gap, false
+		}
+	}
+	panic("no gap found")
+}
+
+func (s *frameSorter) findEndGap(startGap *list.Element[byteInterval], offset protocol.ByteCount) (*list.Element[byteInterval], bool) {
+	for gap := startGap; gap != nil; gap = gap.Next() {
+		if offset >= gap.Value.Start && offset < gap.Value.End {
+			return gap, true
+		}
+		if offset < gap.Value.Start {
+			return gap.Prev(), false
+		}
+	}
+	panic("no gap found")
+}
+
+// deleteConsecutive deletes consecutive frames from the queue, starting at pos
+func (s *frameSorter) deleteConsecutive(pos protocol.ByteCount) {
+	for {
+		oldEntry, ok := s.queue[pos]
+		if !ok {
+			break
+		}
+		oldEntryLen := protocol.ByteCount(len(oldEntry.Data))
+		delete(s.queue, pos)
+		if oldEntry.DoneCb != nil {
+			oldEntry.DoneCb()
+		}
+		pos += oldEntryLen
+	}
+}
+
+func (s *frameSorter) Pop() (protocol.ByteCount, []byte, func()) {
+	entry, ok := s.queue[s.readPos]
+	if !ok {
+		return s.readPos, nil, nil
+	}
+	delete(s.queue, s.readPos)
+	offset := s.readPos
+	s.readPos += protocol.ByteCount(len(entry.Data))
+	if s.gaps.Front().Value.End <= s.readPos {
+		panic("frame sorter BUG: read position higher than a gap")
+	}
+	return offset, entry.Data, entry.DoneCb
+}
+
+// HasMoreData says if there is any more data queued at *any* offset.
+func (s *frameSorter) HasMoreData() bool {
+	return len(s.queue) > 0
+}
+
+var errTooLittleData = errors.New("too little data")
+
+// Peek copies len(p) consecutive bytes starting at offset into p, without removing them.
+// It is only possible to peek from an offset where a frame starts.
+//
+// If there isn't enough consecutive data available, errTooLittleData is returned.
+func (s *frameSorter) Peek(offset protocol.ByteCount, p []byte) error {
+	if len(p) == 0 {
+		return nil
+	}
+
+	// first, check if we have enough consecutive data available
+	pos := offset
+	remaining := len(p)
+	for remaining > 0 {
+		entry, ok := s.queue[pos]
+		if !ok {
+			return errTooLittleData
+		}
+		entryLen := len(entry.Data)
+		if remaining <= entryLen {
+			break // enough data available
+		}
+		remaining -= entryLen
+		pos += protocol.ByteCount(entryLen)
+	}
+
+	pos = offset
+	var copied int
+	for copied < len(p) {
+		entry := s.queue[pos] // the entry is guaranteed to exist from the check above
+		copied += copy(p[copied:], entry.Data)
+		pos += protocol.ByteCount(len(entry.Data))
+	}
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/framer.go b/backend/vendor/github.com/quic-go/quic-go/framer.go
new file mode 100644
index 00000000..29be9765
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/framer.go
@@ -0,0 +1,295 @@
+package quic
+
+import (
+	"slices"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils/ringbuffer"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+const (
+	maxPathResponses = 256
+	maxControlFrames = 16 << 10
+)
+
+// This is the largest possible size of a stream-related control frame
+// (which is the RESET_STREAM frame).
+const maxStreamControlFrameSize = 25
+
+type streamFrameGetter interface {
+	popStreamFrame(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, *wire.StreamDataBlockedFrame, bool)
+}
+
+type streamControlFrameGetter interface {
+	getControlFrame(monotime.Time) (_ ackhandler.Frame, ok, hasMore bool)
+}
+
+type framer struct {
+	mutex sync.Mutex
+
+	activeStreams            map[protocol.StreamID]streamFrameGetter
+	streamQueue              ringbuffer.RingBuffer[protocol.StreamID]
+	streamsWithControlFrames map[protocol.StreamID]streamControlFrameGetter
+
+	controlFrameMutex          sync.Mutex
+	controlFrames              []wire.Frame
+	pathResponses              []*wire.PathResponseFrame
+	connFlowController         *connectionFlowController
+	queuedTooManyControlFrames bool
+}
+
+func newFramer(connFlowController *connectionFlowController) *framer {
+	return &framer{
+		activeStreams:            make(map[protocol.StreamID]streamFrameGetter),
+		streamsWithControlFrames: make(map[protocol.StreamID]streamControlFrameGetter),
+		connFlowController:       connFlowController,
+	}
+}
+
+func (f *framer) HasData() bool {
+	f.mutex.Lock()
+	hasData := !f.streamQueue.Empty()
+	f.mutex.Unlock()
+	if hasData {
+		return true
+	}
+	f.controlFrameMutex.Lock()
+	defer f.controlFrameMutex.Unlock()
+	return len(f.streamsWithControlFrames) > 0 || len(f.controlFrames) > 0 || len(f.pathResponses) > 0
+}
+
+func (f *framer) QueueControlFrame(frame wire.Frame) {
+	f.controlFrameMutex.Lock()
+	defer f.controlFrameMutex.Unlock()
+
+	if pr, ok := frame.(*wire.PathResponseFrame); ok {
+		// Only queue up to maxPathResponses PATH_RESPONSE frames.
+		// This limit should be high enough to never be hit in practice,
+		// unless the peer is doing something malicious.
+		if len(f.pathResponses) >= maxPathResponses {
+			return
+		}
+		f.pathResponses = append(f.pathResponses, pr)
+		return
+	}
+	// This is a hack.
+	if len(f.controlFrames) >= maxControlFrames {
+		f.queuedTooManyControlFrames = true
+		return
+	}
+	f.controlFrames = append(f.controlFrames, frame)
+}
+
+func (f *framer) Append(
+	frames []ackhandler.Frame,
+	streamFrames []ackhandler.StreamFrame,
+	maxLen protocol.ByteCount,
+	now monotime.Time,
+	v protocol.Version,
+) ([]ackhandler.Frame, []ackhandler.StreamFrame, protocol.ByteCount) {
+	f.controlFrameMutex.Lock()
+	frames, controlFrameLen := f.appendControlFrames(frames, maxLen, now, v)
+	maxLen -= controlFrameLen
+
+	var lastFrame ackhandler.StreamFrame
+	var streamFrameLen protocol.ByteCount
+	f.mutex.Lock()
+	// pop STREAM frames, until less than 128 bytes are left in the packet
+	numActiveStreams := f.streamQueue.Len()
+	for range numActiveStreams {
+		if protocol.MinStreamFrameSize > maxLen {
+			break
+		}
+		sf, blocked := f.getNextStreamFrame(maxLen, v)
+		if sf.Frame != nil {
+			streamFrames = append(streamFrames, sf)
+			maxLen -= sf.Frame.Length(v)
+			lastFrame = sf
+			streamFrameLen += sf.Frame.Length(v)
+		}
+		// If the stream just became blocked on stream flow control, attempt to pack the
+		// STREAM_DATA_BLOCKED into the same packet.
+		if blocked != nil {
+			l := blocked.Length(v)
+			// In case it doesn't fit, queue it for the next packet.
+			if maxLen < l {
+				f.controlFrames = append(f.controlFrames, blocked)
+				break
+			}
+			frames = append(frames, ackhandler.Frame{Frame: blocked})
+			maxLen -= l
+			controlFrameLen += l
+		}
+	}
+
+	// The only way to become blocked on connection-level flow control is by sending STREAM frames.
+	if isBlocked, offset := f.connFlowController.IsNewlyBlocked(); isBlocked {
+		blocked := &wire.DataBlockedFrame{MaximumData: offset}
+		l := blocked.Length(v)
+		// In case it doesn't fit, queue it for the next packet.
+		if maxLen >= l {
+			frames = append(frames, ackhandler.Frame{Frame: blocked})
+			controlFrameLen += l
+		} else {
+			f.controlFrames = append(f.controlFrames, blocked)
+		}
+	}
+
+	f.mutex.Unlock()
+	f.controlFrameMutex.Unlock()
+
+	if lastFrame.Frame != nil {
+		// account for the smaller size of the last STREAM frame
+		streamFrameLen -= lastFrame.Frame.Length(v)
+		lastFrame.Frame.DataLenPresent = false
+		streamFrameLen += lastFrame.Frame.Length(v)
+	}
+
+	return frames, streamFrames, controlFrameLen + streamFrameLen
+}
+
+func (f *framer) appendControlFrames(
+	frames []ackhandler.Frame,
+	maxLen protocol.ByteCount,
+	now monotime.Time,
+	v protocol.Version,
+) ([]ackhandler.Frame, protocol.ByteCount) {
+	var length protocol.ByteCount
+	// add a PATH_RESPONSE first, but only pack a single PATH_RESPONSE per packet
+	if len(f.pathResponses) > 0 {
+		frame := f.pathResponses[0]
+		frameLen := frame.Length(v)
+		if frameLen <= maxLen {
+			frames = append(frames, ackhandler.Frame{Frame: frame})
+			length += frameLen
+			f.pathResponses = f.pathResponses[1:]
+		}
+	}
+
+	// add stream-related control frames
+	for id, str := range f.streamsWithControlFrames {
+	start:
+		remainingLen := maxLen - length
+		if remainingLen <= maxStreamControlFrameSize {
+			break
+		}
+		fr, ok, hasMore := str.getControlFrame(now)
+		if !hasMore {
+			delete(f.streamsWithControlFrames, id)
+		}
+		if !ok {
+			continue
+		}
+		frames = append(frames, fr)
+		length += fr.Frame.Length(v)
+		if hasMore {
+			// It is rare that a stream has more than one control frame to queue.
+			// We don't want to spawn another loop for just to cover that case.
+			goto start
+		}
+	}
+
+	for len(f.controlFrames) > 0 {
+		frame := f.controlFrames[len(f.controlFrames)-1]
+		frameLen := frame.Length(v)
+		if length+frameLen > maxLen {
+			break
+		}
+		frames = append(frames, ackhandler.Frame{Frame: frame})
+		length += frameLen
+		f.controlFrames = f.controlFrames[:len(f.controlFrames)-1]
+	}
+
+	return frames, length
+}
+
+// QueuedTooManyControlFrames says if the control frame queue exceeded its maximum queue length.
+// This is a hack.
+// It is easier to implement than propagating an error return value in QueueControlFrame.
+// The correct solution would be to queue frames with their respective structs.
+// See https://github.com/quic-go/quic-go/issues/4271 for the queueing of stream-related control frames.
+func (f *framer) QueuedTooManyControlFrames() bool {
+	return f.queuedTooManyControlFrames
+}
+
+func (f *framer) AddActiveStream(id protocol.StreamID, str streamFrameGetter) {
+	f.mutex.Lock()
+	if _, ok := f.activeStreams[id]; !ok {
+		f.streamQueue.PushBack(id)
+		f.activeStreams[id] = str
+	}
+	f.mutex.Unlock()
+}
+
+func (f *framer) AddStreamWithControlFrames(id protocol.StreamID, str streamControlFrameGetter) {
+	f.controlFrameMutex.Lock()
+	if _, ok := f.streamsWithControlFrames[id]; !ok {
+		f.streamsWithControlFrames[id] = str
+	}
+	f.controlFrameMutex.Unlock()
+}
+
+// RemoveActiveStream is called when a stream completes.
+func (f *framer) RemoveActiveStream(id protocol.StreamID) {
+	f.mutex.Lock()
+	delete(f.activeStreams, id)
+	// We don't delete the stream from the streamQueue,
+	// since we'd have to iterate over the ringbuffer.
+	// Instead, we check if the stream is still in activeStreams when appending STREAM frames.
+	f.mutex.Unlock()
+}
+
+func (f *framer) getNextStreamFrame(maxLen protocol.ByteCount, v protocol.Version) (ackhandler.StreamFrame, *wire.StreamDataBlockedFrame) {
+	id := f.streamQueue.PopFront()
+	// This should never return an error. Better check it anyway.
+	// The stream will only be in the streamQueue, if it enqueued itself there.
+	str, ok := f.activeStreams[id]
+	// The stream might have been removed after being enqueued.
+	if !ok {
+		return ackhandler.StreamFrame{}, nil
+	}
+	// For the last STREAM frame, we'll remove the DataLen field later.
+	// Therefore, we can pretend to have more bytes available when popping
+	// the STREAM frame (which will always have the DataLen set).
+	maxLen += protocol.ByteCount(quicvarint.Len(uint64(maxLen)))
+	frame, blocked, hasMoreData := str.popStreamFrame(maxLen, v)
+	if hasMoreData { // put the stream back in the queue (at the end)
+		f.streamQueue.PushBack(id)
+	} else { // no more data to send. Stream is not active
+		delete(f.activeStreams, id)
+	}
+	// Note that the frame.Frame can be nil:
+	// * if the stream was canceled after it said it had data
+	// * the remaining size doesn't allow us to add another STREAM frame
+	return frame, blocked
+}
+
+func (f *framer) Handle0RTTRejection() {
+	f.mutex.Lock()
+	defer f.mutex.Unlock()
+	f.controlFrameMutex.Lock()
+	defer f.controlFrameMutex.Unlock()
+
+	f.streamQueue.Clear()
+	for id := range f.activeStreams {
+		delete(f.activeStreams, id)
+	}
+	clear(f.streamsWithControlFrames)
+	var j int
+	for i, frame := range f.controlFrames {
+		switch frame.(type) {
+		case *wire.MaxDataFrame, *wire.MaxStreamDataFrame, *wire.MaxStreamsFrame,
+			*wire.DataBlockedFrame, *wire.StreamDataBlockedFrame, *wire.StreamsBlockedFrame:
+			continue
+		default:
+			f.controlFrames[j] = f.controlFrames[i]
+			j++
+		}
+	}
+	f.controlFrames = slices.Delete(f.controlFrames, j, len(f.controlFrames))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/http3/qlog/event.go b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/event.go
new file mode 100644
index 00000000..b5bbe112
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/event.go
@@ -0,0 +1,138 @@
+package qlog
+
+import (
+	"time"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+type encoderHelper struct {
+	enc *jsontext.Encoder
+	err error
+}
+
+func (h *encoderHelper) WriteToken(t jsontext.Token) {
+	if h.err != nil {
+		return
+	}
+	h.err = h.enc.WriteToken(t)
+}
+
+type RawInfo struct {
+	Length        int // full packet length, including header and AEAD authentication tag
+	PayloadLength int // length of the packet payload, excluding AEAD tag
+}
+
+func (i RawInfo) HasValues() bool {
+	return i.Length != 0 || i.PayloadLength != 0
+}
+
+func (i RawInfo) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if i.Length != 0 {
+		h.WriteToken(jsontext.String("length"))
+		h.WriteToken(jsontext.Uint(uint64(i.Length)))
+	}
+	if i.PayloadLength != 0 {
+		h.WriteToken(jsontext.String("payload_length"))
+		h.WriteToken(jsontext.Uint(uint64(i.PayloadLength)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type FrameParsed struct {
+	StreamID quic.StreamID
+	Raw      RawInfo
+	Frame    Frame
+}
+
+func (e FrameParsed) Name() string { return "http3:frame_parsed" }
+
+func (e FrameParsed) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Uint(uint64(e.StreamID)))
+	if e.Raw.HasValues() {
+		h.WriteToken(jsontext.String("raw"))
+		if err := e.Raw.encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.String("frame"))
+	if err := e.Frame.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type FrameCreated struct {
+	StreamID quic.StreamID
+	Raw      RawInfo
+	Frame    Frame
+}
+
+func (e FrameCreated) Name() string { return "http3:frame_created" }
+
+func (e FrameCreated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Uint(uint64(e.StreamID)))
+	if e.Raw.HasValues() {
+		h.WriteToken(jsontext.String("raw"))
+		if err := e.Raw.encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.String("frame"))
+	if err := e.Frame.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type DatagramCreated struct {
+	QuarterStreamID uint64
+	Raw             RawInfo
+}
+
+func (e DatagramCreated) Name() string { return "http3:datagram_created" }
+
+func (e DatagramCreated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("quarter_stream_id"))
+	h.WriteToken(jsontext.Uint(e.QuarterStreamID))
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type DatagramParsed struct {
+	QuarterStreamID uint64
+	Raw             RawInfo
+}
+
+func (e DatagramParsed) Name() string { return "http3:datagram_parsed" }
+
+func (e DatagramParsed) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("quarter_stream_id"))
+	h.WriteToken(jsontext.Uint(e.QuarterStreamID))
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/http3/qlog/frame.go b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/frame.go
new file mode 100644
index 00000000..b404453d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/frame.go
@@ -0,0 +1,220 @@
+package qlog
+
+import (
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+// Frame represents an HTTP/3 frame.
+type Frame struct {
+	Frame any
+}
+
+func (f Frame) encode(enc *jsontext.Encoder) error {
+	switch frame := f.Frame.(type) {
+	case DataFrame:
+		return frame.encode(enc)
+	case HeadersFrame:
+		return frame.encode(enc)
+	case GoAwayFrame:
+		return frame.encode(enc)
+	case SettingsFrame:
+		return frame.encode(enc)
+	case PushPromiseFrame:
+		return frame.encode(enc)
+	case CancelPushFrame:
+		return frame.encode(enc)
+	case MaxPushIDFrame:
+		return frame.encode(enc)
+	case ReservedFrame:
+		return frame.encode(enc)
+	case UnknownFrame:
+		return frame.encode(enc)
+	}
+	// This shouldn't happen if the code is correctly logging frames.
+	// Write a null token to produce valid JSON.
+	return enc.WriteToken(jsontext.Null)
+}
+
+// A DataFrame is a DATA frame
+type DataFrame struct{}
+
+func (f *DataFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("data"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type HeaderField struct {
+	Name  string
+	Value string
+}
+
+// A HeadersFrame is a HEADERS frame
+type HeadersFrame struct {
+	HeaderFields []HeaderField
+}
+
+func (f *HeadersFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("headers"))
+	if len(f.HeaderFields) > 0 {
+		h.WriteToken(jsontext.String("header_fields"))
+		h.WriteToken(jsontext.BeginArray)
+		for _, f := range f.HeaderFields {
+			h.WriteToken(jsontext.BeginObject)
+			h.WriteToken(jsontext.String("name"))
+			h.WriteToken(jsontext.String(f.Name))
+			h.WriteToken(jsontext.String("value"))
+			h.WriteToken(jsontext.String(f.Value))
+			h.WriteToken(jsontext.EndObject)
+		}
+		h.WriteToken(jsontext.EndArray)
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A GoAwayFrame is a GOAWAY frame
+type GoAwayFrame struct {
+	StreamID quic.StreamID
+}
+
+func (f *GoAwayFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("goaway"))
+	h.WriteToken(jsontext.String("id"))
+	h.WriteToken(jsontext.Uint(uint64(f.StreamID)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type SettingsFrame struct {
+	MaxFieldSectionSize int64
+	Datagram            *bool
+	ExtendedConnect     *bool
+	Other               map[uint64]uint64
+}
+
+func (f *SettingsFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("settings"))
+	h.WriteToken(jsontext.String("settings"))
+	h.WriteToken(jsontext.BeginArray)
+	if f.MaxFieldSectionSize >= 0 {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_max_field_section_size"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Uint(uint64(f.MaxFieldSectionSize)))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if f.Datagram != nil {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_h3_datagram"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Bool(*f.Datagram))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if f.ExtendedConnect != nil {
+		h.WriteToken(jsontext.BeginObject)
+		h.WriteToken(jsontext.String("name"))
+		h.WriteToken(jsontext.String("settings_enable_connect_protocol"))
+		h.WriteToken(jsontext.String("value"))
+		h.WriteToken(jsontext.Bool(*f.ExtendedConnect))
+		h.WriteToken(jsontext.EndObject)
+	}
+	if len(f.Other) > 0 {
+		for k, v := range f.Other {
+			h.WriteToken(jsontext.BeginObject)
+			h.WriteToken(jsontext.String("name"))
+			h.WriteToken(jsontext.String("unknown"))
+			h.WriteToken(jsontext.String("name_bytes"))
+			h.WriteToken(jsontext.Uint(k))
+			h.WriteToken(jsontext.String("value"))
+			h.WriteToken(jsontext.Uint(v))
+			h.WriteToken(jsontext.EndObject)
+		}
+	}
+	h.WriteToken(jsontext.EndArray)
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A PushPromiseFrame is a PUSH_PROMISE frame
+type PushPromiseFrame struct{}
+
+func (f *PushPromiseFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("push_promise"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A CancelPushFrame is a CANCEL_PUSH frame
+type CancelPushFrame struct{}
+
+func (f *CancelPushFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("cancel_push"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A MaxPushIDFrame is a MAX_PUSH_ID frame
+type MaxPushIDFrame struct{}
+
+func (f *MaxPushIDFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("max_push_id"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// A ReservedFrame is one of the reserved frame types
+type ReservedFrame struct {
+	Type uint64
+}
+
+func (f *ReservedFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("reserved"))
+	h.WriteToken(jsontext.String("frame_type_bytes"))
+	h.WriteToken(jsontext.Uint(f.Type))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// An UnknownFrame is an unknown frame type
+type UnknownFrame struct {
+	Type uint64
+}
+
+func (f *UnknownFrame) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("unknown"))
+	h.WriteToken(jsontext.String("frame_type_bytes"))
+	h.WriteToken(jsontext.Uint(f.Type))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/http3/qlog/qlog_dir.go b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/qlog_dir.go
new file mode 100644
index 00000000..898d17c6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/http3/qlog/qlog_dir.go
@@ -0,0 +1,15 @@
+package qlog
+
+import (
+	"context"
+
+	"github.com/quic-go/quic-go"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+const EventSchema = "urn:ietf:params:qlog:events:http3-12"
+
+func DefaultConnectionTracer(ctx context.Context, isClient bool, connID quic.ConnectionID) qlogwriter.Trace {
+	return qlog.DefaultConnectionTracerWithSchemas(ctx, isClient, connID, []string{qlog.EventSchema, EventSchema})
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/interface.go b/backend/vendor/github.com/quic-go/quic-go/interface.go
new file mode 100644
index 00000000..d04091b4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/interface.go
@@ -0,0 +1,221 @@
+package quic
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+	"slices"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/handshake"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// The StreamID is the ID of a QUIC stream.
+type StreamID = protocol.StreamID
+
+// A Version is a QUIC version number.
+type Version = protocol.Version
+
+const (
+	// Version1 is RFC 9000
+	Version1 = protocol.Version1
+	// Version2 is RFC 9369
+	Version2 = protocol.Version2
+)
+
+// SupportedVersions returns the support versions, sorted in descending order of preference.
+func SupportedVersions() []Version {
+	// clone the slice to prevent the caller from modifying the slice
+	return slices.Clone(protocol.SupportedVersions)
+}
+
+// A ClientToken is a token received by the client.
+// It can be used to skip address validation on future connection attempts.
+type ClientToken struct {
+	data []byte
+	rtt  time.Duration
+}
+
+type TokenStore interface {
+	// Pop searches for a ClientToken associated with the given key.
+	// Since tokens are not supposed to be reused, it must remove the token from the cache.
+	// It returns nil when no token is found.
+	Pop(key string) (token *ClientToken)
+
+	// Put adds a token to the cache with the given key. It might get called
+	// multiple times in a connection.
+	Put(key string, token *ClientToken)
+}
+
+// Err0RTTRejected is the returned from:
+//   - Open{Uni}Stream{Sync}
+//   - Accept{Uni}Stream
+//   - Stream.Read and Stream.Write
+//
+// when the server rejects a 0-RTT connection attempt.
+var Err0RTTRejected = errors.New("0-RTT rejected")
+
+// ErrWouldBlock is returned by [SendStream.TryWriteAll] if the entire slice can't be queued immediately.
+var ErrWouldBlock = errors.New("operation would block")
+
+// ErrWriteLimitReached is returned by [SendStream.WriteWithLimit] when its limiter prevents accepting the entire slice.
+var ErrWriteLimitReached = errors.New("write limit reached")
+
+// QUICVersionContextKey can be used to find out the QUIC version of a TLS handshake from the
+// context returned by tls.Config.ClientInfo.Context.
+var QUICVersionContextKey = handshake.QUICVersionContextKey
+
+// StatelessResetKey is a key used to derive stateless reset tokens.
+type StatelessResetKey [32]byte
+
+// TokenGeneratorKey is a key used to encrypt session resumption tokens.
+type TokenGeneratorKey = handshake.TokenProtectorKey
+
+// A ConnectionID is a QUIC Connection ID, as defined in RFC 9000.
+// It is not able to handle QUIC Connection IDs longer than 20 bytes,
+// as they are allowed by RFC 8999.
+type ConnectionID = protocol.ConnectionID
+
+// ConnectionIDFromBytes interprets b as a [ConnectionID]. It panics if b is
+// longer than 20 bytes.
+func ConnectionIDFromBytes(b []byte) ConnectionID {
+	return protocol.ParseConnectionID(b)
+}
+
+// A ConnectionIDGenerator allows the application to take control over the generation of Connection IDs.
+// Connection IDs generated by an implementation must be of constant length.
+type ConnectionIDGenerator interface {
+	// GenerateConnectionID generates a new Connection ID.
+	// Generated Connection IDs must be unique and observers should not be able to correlate two Connection IDs.
+	GenerateConnectionID() (ConnectionID, error)
+
+	// ConnectionIDLen returns the length of Connection IDs generated by this implementation.
+	// Implementations must return constant-length Connection IDs with lengths between 0 and 20 bytes.
+	// A length of 0 can only be used when an endpoint doesn't need to multiplex connections during migration.
+	ConnectionIDLen() int
+}
+
+// Config contains all configuration data needed for a QUIC server or client.
+type Config struct {
+	// GetConfigForClient is called for incoming connections.
+	// If the error is not nil, the connection attempt is refused.
+	GetConfigForClient func(info *ClientInfo) (*Config, error)
+	// The QUIC versions that can be negotiated.
+	// If not set, it uses all versions available.
+	Versions []Version
+	// HandshakeIdleTimeout is the idle timeout before completion of the handshake.
+	// If we don't receive any packet from the peer within this time, the connection attempt is aborted.
+	// Additionally, if the handshake doesn't complete in twice this time, the connection attempt is also aborted.
+	// If this value is zero, the timeout is set to 5 seconds.
+	HandshakeIdleTimeout time.Duration
+	// MaxIdleTimeout is the maximum duration that may pass without any incoming network activity.
+	// The actual value for the idle timeout is the minimum of this value and the peer's.
+	// This value only applies after the handshake has completed.
+	// If the timeout is exceeded, the connection is closed.
+	// If this value is zero, the timeout is set to 30 seconds.
+	MaxIdleTimeout time.Duration
+	// The TokenStore stores tokens received from the server.
+	// Tokens are used to skip address validation on future connection attempts.
+	// The key used to store tokens is the ServerName from the tls.Config, if set
+	// otherwise the token is associated with the server's IP address.
+	TokenStore TokenStore
+	// InitialStreamReceiveWindow is the initial size of the stream-level flow control window for receiving data.
+	// If the application is consuming data quickly enough, the flow control auto-tuning algorithm
+	// will increase the window up to MaxStreamReceiveWindow.
+	// If this value is zero, it will default to 512 KB.
+	// Values larger than the maximum varint (quicvarint.Max) will be clipped to that value.
+	InitialStreamReceiveWindow uint64
+	// MaxStreamReceiveWindow is the maximum stream-level flow control window for receiving data.
+	// If this value is zero, it will default to 6 MB.
+	// Values larger than the maximum varint (quicvarint.Max) will be clipped to that value.
+	MaxStreamReceiveWindow uint64
+	// InitialConnectionReceiveWindow is the initial size of the stream-level flow control window for receiving data.
+	// If the application is consuming data quickly enough, the flow control auto-tuning algorithm
+	// will increase the window up to MaxConnectionReceiveWindow.
+	// If this value is zero, it will default to 512 KB.
+	// Values larger than the maximum varint (quicvarint.Max) will be clipped to that value.
+	InitialConnectionReceiveWindow uint64
+	// MaxConnectionReceiveWindow is the connection-level flow control window for receiving data.
+	// If this value is zero, it will default to 15 MB.
+	// Values larger than the maximum varint (quicvarint.Max) will be clipped to that value.
+	MaxConnectionReceiveWindow uint64
+	// AllowConnectionWindowIncrease is called every time the connection flow controller attempts
+	// to increase the connection flow control window.
+	// If set, the caller can prevent an increase of the window. Typically, it would do so to
+	// limit the memory usage.
+	// To avoid deadlocks, it is not valid to call other functions on the connection or on streams
+	// in this callback.
+	AllowConnectionWindowIncrease func(conn *Conn, delta uint64) bool
+	// MaxIncomingStreams is the maximum number of concurrent bidirectional streams that a peer is allowed to open.
+	// If not set, it will default to 100.
+	// If set to a negative value, it doesn't allow any bidirectional streams.
+	// Values larger than 2^60 will be clipped to that value.
+	MaxIncomingStreams int64
+	// MaxIncomingUniStreams is the maximum number of concurrent unidirectional streams that a peer is allowed to open.
+	// If not set, it will default to 100.
+	// If set to a negative value, it doesn't allow any unidirectional streams.
+	// Values larger than 2^60 will be clipped to that value.
+	MaxIncomingUniStreams int64
+	// KeepAlivePeriod defines whether this peer will periodically send a packet to keep the connection alive.
+	// If set to 0, then no keep alive is sent. Otherwise, the keep alive is sent on that period (or at most
+	// every half of MaxIdleTimeout, whichever is smaller).
+	KeepAlivePeriod time.Duration
+	// InitialPacketSize is the initial size (and the lower limit) for packets sent.
+	// Under most circumstances, it is not necessary to manually set this value,
+	// since path MTU discovery quickly finds the path's MTU.
+	// If set too high, the path might not support packets of that size, leading to a timeout of the QUIC handshake.
+	// Values below 1200 are invalid.
+	InitialPacketSize uint16
+	// DisablePathMTUDiscovery disables Path MTU Discovery (RFC 8899).
+	// This allows the sending of QUIC packets that fully utilize the available MTU of the path.
+	// Path MTU discovery is only available on systems that allow setting of the Don't Fragment (DF) bit.
+	DisablePathMTUDiscovery bool
+	// Allow0RTT allows the application to decide if a 0-RTT connection attempt should be accepted.
+	// Only valid for the server.
+	Allow0RTT bool
+	// Enable QUIC datagram support (RFC 9221).
+	EnableDatagrams bool
+	// Enable QUIC Stream Resets with Partial Delivery.
+	// See https://datatracker.ietf.org/doc/html/draft-ietf-quic-reliable-stream-reset-09.
+	EnableStreamResetPartialDelivery bool
+
+	Tracer func(ctx context.Context, isClient bool, connID ConnectionID) qlogwriter.Trace
+}
+
+// ClientInfo contains information about an incoming connection attempt.
+type ClientInfo struct {
+	// RemoteAddr is the remote address on the Initial packet.
+	// Unless AddrVerified is set, the address is not yet verified, and could be a spoofed IP address.
+	RemoteAddr net.Addr
+	// AddrVerified says if the remote address was verified using QUIC's Retry mechanism.
+	// Note that the Retry mechanism costs one network roundtrip,
+	// and is not performed unless Transport.MaxUnvalidatedHandshakes is surpassed.
+	AddrVerified bool
+}
+
+// ConnectionState records basic details about a QUIC connection.
+type ConnectionState struct {
+	// TLS contains information about the TLS connection state, incl. the tls.ConnectionState.
+	TLS tls.ConnectionState
+	// SupportsDatagrams indicates support for QUIC datagrams (RFC 9221).
+	SupportsDatagrams struct {
+		// Remote is true if the peer advertised datagram support.
+		// Local is true if datagram support was enabled via Config.EnableDatagrams.
+		Remote, Local bool
+	}
+	// SupportsStreamResetPartialDelivery indicates support for QUIC Stream Resets with Partial Delivery.
+	SupportsStreamResetPartialDelivery struct {
+		// Remote is true if the peer advertised support.
+		// Local is true if support was enabled via Config.EnableStreamResetPartialDelivery.
+		Remote, Local bool
+	}
+	// Used0RTT says if 0-RTT resumption was used.
+	Used0RTT bool
+	// Version is the QUIC version of the QUIC connection.
+	Version Version
+	// GSO says if generic segmentation offload is used.
+	GSO bool
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ack_eliciting.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ack_eliciting.go
new file mode 100644
index 00000000..8d843612
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ack_eliciting.go
@@ -0,0 +1,33 @@
+package ackhandler
+
+import "github.com/quic-go/quic-go/internal/wire"
+
+// IsFrameTypeAckEliciting returns true if the frame is ack-eliciting.
+func IsFrameTypeAckEliciting(t wire.FrameType) bool {
+	//nolint:exhaustive // The default case catches the rest.
+	switch t {
+	case wire.FrameTypeAck, wire.FrameTypeAckECN:
+		return false
+	case wire.FrameTypeConnectionClose, wire.FrameTypeApplicationClose:
+		return false
+	default:
+		return true
+	}
+}
+
+// IsFrameAckEliciting returns true if the frame is ack-eliciting.
+func IsFrameAckEliciting(f wire.Frame) bool {
+	_, isAck := f.(*wire.AckFrame)
+	_, isConnectionClose := f.(*wire.ConnectionCloseFrame)
+	return !isAck && !isConnectionClose
+}
+
+// HasAckElicitingFrames returns true if at least one frame is ack-eliciting.
+func HasAckElicitingFrames(fs []Frame) bool {
+	for _, f := range fs {
+		if IsFrameAckEliciting(f.Frame) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ecn.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ecn.go
new file mode 100644
index 00000000..123d3a34
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/ecn.go
@@ -0,0 +1,340 @@
+package ackhandler
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+type ecnState uint8
+
+const (
+	ecnStateInitial ecnState = iota
+	ecnStateTesting
+	ecnStateUnknown
+	ecnStateCapable
+	ecnStateFailed
+)
+
+const (
+	// ecnFailedNoECNCounts is emitted when an ACK acknowledges ECN-marked packets,
+	// but doesn't contain any ECN counts
+	ecnFailedNoECNCounts = "ACK doesn't contain ECN marks"
+	// ecnFailedDecreasedECNCounts is emitted when an ACK frame decreases ECN counts
+	ecnFailedDecreasedECNCounts = "ACK decreases ECN counts"
+	// ecnFailedLostAllTestingPackets is emitted when all ECN testing packets are declared lost
+	ecnFailedLostAllTestingPackets = "all ECN testing packets declared lost"
+	// ecnFailedMoreECNCountsThanSent is emitted when an ACK contains more ECN counts than ECN-marked packets were sent
+	ecnFailedMoreECNCountsThanSent = "ACK contains more ECN counts than ECN-marked packets sent"
+	// ecnFailedTooFewECNCounts is emitted when an ACK contains fewer ECN counts than it acknowledges packets
+	ecnFailedTooFewECNCounts = "ACK contains fewer new ECN counts than acknowledged ECN-marked packets"
+	// ecnFailedManglingDetected is emitted when the path marks all ECN-marked packets as CE
+	ecnFailedManglingDetected = "ECN mangling detected"
+)
+
+// must fit into an uint8, otherwise numSentTesting and numLostTesting must have a larger type
+const numECNTestingPackets = 10
+
+type ecnHandler interface {
+	SentPacket(protocol.PacketNumber, protocol.ECN)
+	Mode() protocol.ECN
+	HandleNewlyAcked(packets []packetWithPacketNumber, ect0, ect1, ecnce int64) (congested bool)
+	LostPacket(protocol.PacketNumber)
+}
+
+// The ecnTracker performs ECN validation of a path.
+// Once failed, it doesn't do any re-validation of the path.
+// It is designed only work for 1-RTT packets, it doesn't handle multiple packet number spaces.
+// In order to avoid revealing any internal state to on-path observers,
+// callers should make sure to start using ECN (i.e. calling Mode) for the very first 1-RTT packet sent.
+// The validation logic implemented here strictly follows the algorithm described in RFC 9000 section 13.4.2 and A.4.
+type ecnTracker struct {
+	state                          ecnState
+	numSentTesting, numLostTesting uint8
+
+	firstTestingPacket protocol.PacketNumber
+	lastTestingPacket  protocol.PacketNumber
+	firstCapablePacket protocol.PacketNumber
+
+	numSentECT0, numSentECT1                  int64
+	numAckedECT0, numAckedECT1, numAckedECNCE int64
+
+	qlogger qlogwriter.Recorder
+	logger  utils.Logger
+}
+
+var _ ecnHandler = &ecnTracker{}
+
+func newECNTracker(logger utils.Logger, qlogger qlogwriter.Recorder) *ecnTracker {
+	return &ecnTracker{
+		firstTestingPacket: protocol.InvalidPacketNumber,
+		lastTestingPacket:  protocol.InvalidPacketNumber,
+		firstCapablePacket: protocol.InvalidPacketNumber,
+		state:              ecnStateInitial,
+		logger:             logger,
+		qlogger:            qlogger,
+	}
+}
+
+func (e *ecnTracker) SentPacket(pn protocol.PacketNumber, ecn protocol.ECN) {
+	//nolint:exhaustive // These are the only ones we need to take care of.
+	switch ecn {
+	case protocol.ECNNon:
+		return
+	case protocol.ECT0:
+		e.numSentECT0++
+	case protocol.ECT1:
+		e.numSentECT1++
+	case protocol.ECNUnsupported:
+		if e.state != ecnStateFailed {
+			panic("didn't expect ECN to be unsupported")
+		}
+	default:
+		panic(fmt.Sprintf("sent packet with unexpected ECN marking: %s", ecn))
+	}
+
+	if e.state == ecnStateCapable && e.firstCapablePacket == protocol.InvalidPacketNumber {
+		e.firstCapablePacket = pn
+	}
+
+	if e.state != ecnStateTesting {
+		return
+	}
+
+	e.numSentTesting++
+	if e.firstTestingPacket == protocol.InvalidPacketNumber {
+		e.firstTestingPacket = pn
+	}
+	if e.numSentECT0+e.numSentECT1 >= numECNTestingPackets {
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State: qlog.ECNStateUnknown,
+			})
+		}
+		e.state = ecnStateUnknown
+		e.lastTestingPacket = pn
+	}
+}
+
+func (e *ecnTracker) Mode() protocol.ECN {
+	switch e.state {
+	case ecnStateInitial:
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State: qlog.ECNStateTesting,
+			})
+		}
+		e.state = ecnStateTesting
+		return e.Mode()
+	case ecnStateTesting, ecnStateCapable:
+		return protocol.ECT0
+	case ecnStateUnknown, ecnStateFailed:
+		return protocol.ECNNon
+	default:
+		panic(fmt.Sprintf("unknown ECN state: %d", e.state))
+	}
+}
+
+func (e *ecnTracker) LostPacket(pn protocol.PacketNumber) {
+	if e.state != ecnStateTesting && e.state != ecnStateUnknown {
+		return
+	}
+	if !e.isTestingPacket(pn) {
+		return
+	}
+	e.numLostTesting++
+	// Only proceed if we have sent all 10 testing packets.
+	if e.state != ecnStateUnknown {
+		return
+	}
+	if e.numLostTesting >= e.numSentTesting {
+		e.logger.Debugf("Disabling ECN. All testing packets were lost.")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedLostAllTestingPackets,
+			})
+		}
+		e.state = ecnStateFailed
+		return
+	}
+	// Path validation also fails if some testing packets are lost, and all other testing packets where CE-marked
+	e.failIfMangled()
+}
+
+// HandleNewlyAcked handles the ECN counts on an ACK frame.
+// It must only be called for ACK frames that increase the largest acknowledged packet number,
+// see section 13.4.2.1 of RFC 9000.
+func (e *ecnTracker) HandleNewlyAcked(packets []packetWithPacketNumber, ect0, ect1, ecnce int64) (congested bool) {
+	if e.state == ecnStateFailed {
+		return false
+	}
+
+	// ECN validation can fail if the received total count for either ECT(0) or ECT(1) exceeds
+	// the total number of packets sent with each corresponding ECT codepoint.
+	if ect0 > e.numSentECT0 || ect1 > e.numSentECT1 {
+		e.logger.Debugf("Disabling ECN. Received more ECT(0) / ECT(1) acknowledgements than packets sent.")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedMoreECNCountsThanSent,
+			})
+		}
+		e.state = ecnStateFailed
+		return false
+	}
+
+	// Count ECT0 and ECT1 marks that we used when sending the packets that are now being acknowledged.
+	var ackedECT0, ackedECT1 int64
+	for _, p := range packets {
+		//nolint:exhaustive // We only ever send ECT(0) and ECT(1).
+		switch e.ecnMarking(p.PacketNumber) {
+		case protocol.ECT0:
+			ackedECT0++
+		case protocol.ECT1:
+			ackedECT1++
+		}
+	}
+
+	// If an ACK frame newly acknowledges a packet that the endpoint sent with either the ECT(0) or ECT(1)
+	// codepoint set, ECN validation fails if the corresponding ECN counts are not present in the ACK frame.
+	// This check detects:
+	// * paths that bleach all ECN marks, and
+	// * peers that don't report any ECN counts
+	if (ackedECT0 > 0 || ackedECT1 > 0) && ect0 == 0 && ect1 == 0 && ecnce == 0 {
+		e.logger.Debugf("Disabling ECN. ECN-marked packet acknowledged, but no ECN counts on ACK frame.")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedNoECNCounts,
+			})
+		}
+		e.state = ecnStateFailed
+		return false
+	}
+
+	// Determine the increase in ECT0, ECT1 and ECNCE marks
+	newECT0 := ect0 - e.numAckedECT0
+	newECT1 := ect1 - e.numAckedECT1
+	newECNCE := ecnce - e.numAckedECNCE
+
+	// We're only processing ACKs that increase the Largest Acked.
+	// Therefore, the ECN counters should only ever increase.
+	// Any decrease means that the peer's counting logic is broken.
+	if newECT0 < 0 || newECT1 < 0 || newECNCE < 0 {
+		e.logger.Debugf("Disabling ECN. ECN counts decreased unexpectedly.")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedDecreasedECNCounts,
+			})
+		}
+		e.state = ecnStateFailed
+		return false
+	}
+
+	// ECN validation also fails if the sum of the increase in ECT(0) and ECN-CE counts is less than the number
+	// of newly acknowledged packets that were originally sent with an ECT(0) marking.
+	// This could be the result of (partial) bleaching.
+	if newECT0+newECNCE < ackedECT0 {
+		e.logger.Debugf("Disabling ECN. Received less ECT(0) + ECN-CE than packets sent with ECT(0).")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedTooFewECNCounts,
+			})
+		}
+		e.state = ecnStateFailed
+		return false
+	}
+	// Similarly, ECN validation fails if the sum of the increases to ECT(1) and ECN-CE counts is less than
+	// the number of newly acknowledged packets sent with an ECT(1) marking.
+	if newECT1+newECNCE < ackedECT1 {
+		e.logger.Debugf("Disabling ECN. Received less ECT(1) + ECN-CE than packets sent with ECT(1).")
+		if e.qlogger != nil {
+			e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+				State:   qlog.ECNStateFailed,
+				Trigger: ecnFailedTooFewECNCounts,
+			})
+		}
+		e.state = ecnStateFailed
+		return false
+	}
+
+	// update our counters
+	e.numAckedECT0 = ect0
+	e.numAckedECT1 = ect1
+	e.numAckedECNCE = ecnce
+
+	// Detect mangling (a path remarking all ECN-marked testing packets as CE),
+	// once all 10 testing packets have been sent out.
+	if e.state == ecnStateUnknown {
+		e.failIfMangled()
+		if e.state == ecnStateFailed {
+			return false
+		}
+	}
+	if e.state == ecnStateTesting || e.state == ecnStateUnknown {
+		var ackedTestingPacket bool
+		for _, p := range packets {
+			if e.isTestingPacket(p.PacketNumber) {
+				ackedTestingPacket = true
+				break
+			}
+		}
+		// This check won't succeed if the path is mangling ECN-marks (i.e. rewrites all ECN-marked packets to CE).
+		if ackedTestingPacket && (newECT0 > 0 || newECT1 > 0) {
+			e.logger.Debugf("ECN capability confirmed.")
+			if e.qlogger != nil {
+				e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+					State: qlog.ECNStateCapable,
+				})
+			}
+			e.state = ecnStateCapable
+		}
+	}
+
+	// Don't trust CE marks before having confirmed ECN capability of the path.
+	// Otherwise, mangling would be misinterpreted as actual congestion.
+	return e.state == ecnStateCapable && newECNCE > 0
+}
+
+// failIfMangled fails ECN validation if all testing packets are lost or CE-marked.
+func (e *ecnTracker) failIfMangled() {
+	numAckedECNCE := e.numAckedECNCE + int64(e.numLostTesting)
+	if e.numSentECT0+e.numSentECT1 > numAckedECNCE {
+		return
+	}
+	if e.qlogger != nil {
+		e.qlogger.RecordEvent(qlog.ECNStateUpdated{
+			State:   qlog.ECNStateFailed,
+			Trigger: ecnFailedManglingDetected,
+		})
+	}
+	e.state = ecnStateFailed
+}
+
+func (e *ecnTracker) ecnMarking(pn protocol.PacketNumber) protocol.ECN {
+	if pn < e.firstTestingPacket || e.firstTestingPacket == protocol.InvalidPacketNumber {
+		return protocol.ECNNon
+	}
+	if pn < e.lastTestingPacket || e.lastTestingPacket == protocol.InvalidPacketNumber {
+		return protocol.ECT0
+	}
+	if pn < e.firstCapablePacket || e.firstCapablePacket == protocol.InvalidPacketNumber {
+		return protocol.ECNNon
+	}
+	// We don't need to deal with the case when ECN validation fails,
+	// since we're ignoring any ECN counts reported in ACK frames in that case.
+	return protocol.ECT0
+}
+
+func (e *ecnTracker) isTestingPacket(pn protocol.PacketNumber) bool {
+	if e.firstTestingPacket == protocol.InvalidPacketNumber {
+		return false
+	}
+	return pn >= e.firstTestingPacket && (pn <= e.lastTestingPacket || e.lastTestingPacket == protocol.InvalidPacketNumber)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/frame.go
new file mode 100644
index 00000000..e03a8080
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/frame.go
@@ -0,0 +1,21 @@
+package ackhandler
+
+import (
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+// FrameHandler handles the acknowledgement and the loss of a frame.
+type FrameHandler interface {
+	OnAcked(wire.Frame)
+	OnLost(wire.Frame)
+}
+
+type Frame struct {
+	Frame   wire.Frame // nil if the frame has already been acknowledged in another packet
+	Handler FrameHandler
+}
+
+type StreamFrame struct {
+	Frame   *wire.StreamFrame
+	Handler FrameHandler
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/interfaces.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/interfaces.go
new file mode 100644
index 00000000..620a5e11
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/interfaces.go
@@ -0,0 +1,39 @@
+package ackhandler
+
+import (
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+// SentPacketHandler handles ACKs received for outgoing packets
+type SentPacketHandler interface {
+	// SentPacket may modify the packet
+	SentPacket(t monotime.Time, pn, largestAcked protocol.PacketNumber, streamFrames []StreamFrame, frames []Frame, encLevel protocol.EncryptionLevel, ecn protocol.ECN, size protocol.ByteCount, isPathMTUProbePacket, isPathProbePacket bool)
+	// ReceivedAck processes an ACK frame.
+	// It does not store a copy of the frame.
+	ReceivedAck(f *wire.AckFrame, encLevel protocol.EncryptionLevel, rcvTime monotime.Time) (bool /* 1-RTT packet acked */, error)
+	ReceivedPacket(protocol.EncryptionLevel, monotime.Time)
+	ReceivedBytes(_ protocol.ByteCount, rcvTime monotime.Time)
+	DropPackets(_ protocol.EncryptionLevel, rcvTime monotime.Time)
+	ResetForRetry(rcvTime monotime.Time)
+
+	// The SendMode determines if and what kind of packets can be sent.
+	SendMode(now monotime.Time) SendMode
+	// TimeUntilSend is the time when the next packet should be sent.
+	// It is used for pacing packets.
+	TimeUntilSend() monotime.Time
+	SetMaxDatagramSize(count protocol.ByteCount)
+
+	// only to be called once the handshake is complete
+	QueueProbePacket(protocol.EncryptionLevel) bool /* was a packet queued */
+
+	ECNMode(isShortHeaderPacket bool) protocol.ECN // isShortHeaderPacket should only be true for non-coalesced 1-RTT packets
+	PeekPacketNumber(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)
+	PopPacketNumber(protocol.EncryptionLevel) protocol.PacketNumber
+
+	GetLossDetectionTimeout() monotime.Time
+	OnLossDetectionTimeout(now monotime.Time) error
+
+	MigratedPath(now monotime.Time, initialMaxPacketSize protocol.ByteCount)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/lost_packet_tracker.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/lost_packet_tracker.go
new file mode 100644
index 00000000..40665734
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/lost_packet_tracker.go
@@ -0,0 +1,73 @@
+package ackhandler
+
+import (
+	"iter"
+	"slices"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type lostPacket struct {
+	PacketNumber protocol.PacketNumber
+	SendTime     monotime.Time
+}
+
+type lostPacketTracker struct {
+	maxLength   int
+	lostPackets []lostPacket
+}
+
+func newLostPacketTracker(maxLength int) *lostPacketTracker {
+	return &lostPacketTracker{
+		maxLength: maxLength,
+		// Preallocate a small slice only.
+		// Hopefully we won't lose many packets.
+		lostPackets: make([]lostPacket, 0, 4),
+	}
+}
+
+func (t *lostPacketTracker) Add(p protocol.PacketNumber, sendTime monotime.Time) {
+	if len(t.lostPackets) == t.maxLength {
+		t.lostPackets = t.lostPackets[1:]
+	}
+	t.lostPackets = append(t.lostPackets, lostPacket{
+		PacketNumber: p,
+		SendTime:     sendTime,
+	})
+}
+
+// Delete deletes a packet from the lost packet tracker.
+// This function is not optimized for performance if many packets are lost,
+// but it is only used when a spurious loss is detected, which is rare.
+func (t *lostPacketTracker) Delete(pn protocol.PacketNumber) {
+	t.lostPackets = slices.DeleteFunc(t.lostPackets, func(p lostPacket) bool {
+		return p.PacketNumber == pn
+	})
+}
+
+func (t *lostPacketTracker) All() iter.Seq2[protocol.PacketNumber, monotime.Time] {
+	return func(yield func(protocol.PacketNumber, monotime.Time) bool) {
+		for _, p := range t.lostPackets {
+			if !yield(p.PacketNumber, p.SendTime) {
+				return
+			}
+		}
+	}
+}
+
+func (t *lostPacketTracker) DeleteBefore(ti monotime.Time) {
+	if len(t.lostPackets) == 0 {
+		return
+	}
+	if !t.lostPackets[0].SendTime.Before(ti) {
+		return
+	}
+	var idx int
+	for ; idx < len(t.lostPackets); idx++ {
+		if !t.lostPackets[idx].SendTime.Before(ti) {
+			break
+		}
+	}
+	t.lostPackets = slices.Delete(t.lostPackets, 0, idx)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/mockgen.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/mockgen.go
new file mode 100644
index 00000000..3add80d1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/mockgen.go
@@ -0,0 +1,6 @@
+//go:build gomock || generate
+
+package ackhandler
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\"  -package ackhandler -destination mock_ecn_handler_test.go github.com/quic-go/quic-go/internal/ackhandler ECNHandler"
+type ECNHandler = ecnHandler
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet.go
new file mode 100644
index 00000000..7d986300
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet.go
@@ -0,0 +1,60 @@
+package ackhandler
+
+import (
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type packetWithPacketNumber struct {
+	PacketNumber protocol.PacketNumber
+	*packet
+}
+
+// A Packet is a packet
+type packet struct {
+	SendTime        monotime.Time
+	StreamFrames    []StreamFrame
+	Frames          []Frame
+	LargestAcked    protocol.PacketNumber // InvalidPacketNumber if the packet doesn't contain an ACK
+	Length          protocol.ByteCount
+	EncryptionLevel protocol.EncryptionLevel
+
+	IsPathMTUProbePacket bool // We don't report the loss of Path MTU probe packets to the congestion controller.
+
+	includedInBytesInFlight bool
+	isPathProbePacket       bool
+}
+
+func (p *packet) Outstanding() bool {
+	return !p.IsPathMTUProbePacket && !p.isPathProbePacket && p.IsAckEliciting()
+}
+
+func (p *packet) IsAckEliciting() bool {
+	return len(p.StreamFrames) > 0 || len(p.Frames) > 0
+}
+
+var packetPool = sync.Pool{New: func() any { return &packet{} }}
+
+func getPacket() *packet {
+	p := packetPool.Get().(*packet)
+	p.StreamFrames = nil
+	p.Frames = nil
+	p.LargestAcked = 0
+	p.Length = 0
+	p.EncryptionLevel = protocol.EncryptionLevel(0)
+	p.SendTime = 0
+	p.IsPathMTUProbePacket = false
+	p.includedInBytesInFlight = false
+	p.isPathProbePacket = false
+	return p
+}
+
+// We currently only return Packets back into the pool when they're acknowledged (not when they're lost).
+// This simplifies the code, and gives the vast majority of the performance benefit we can gain from using the pool.
+func putPacket(p *packet) {
+	p.Frames = nil
+	p.StreamFrames = nil
+	packetPool.Put(p)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet_number_generator.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet_number_generator.go
new file mode 100644
index 00000000..4a9db863
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/packet_number_generator.go
@@ -0,0 +1,84 @@
+package ackhandler
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+type packetNumberGenerator interface {
+	Peek() protocol.PacketNumber
+	// Pop pops the packet number.
+	// It reports if the packet number (before the one just popped) was skipped.
+	// It never skips more than one packet number in a row.
+	Pop() (skipped bool, _ protocol.PacketNumber)
+}
+
+type sequentialPacketNumberGenerator struct {
+	next protocol.PacketNumber
+}
+
+var _ packetNumberGenerator = &sequentialPacketNumberGenerator{}
+
+func newSequentialPacketNumberGenerator(initial protocol.PacketNumber) packetNumberGenerator {
+	return &sequentialPacketNumberGenerator{next: initial}
+}
+
+func (p *sequentialPacketNumberGenerator) Peek() protocol.PacketNumber {
+	return p.next
+}
+
+func (p *sequentialPacketNumberGenerator) Pop() (bool, protocol.PacketNumber) {
+	next := p.next
+	p.next++
+	return false, next
+}
+
+// The skippingPacketNumberGenerator generates the packet number for the next packet
+// it randomly skips a packet number every averagePeriod packets (on average).
+// It is guaranteed to never skip two consecutive packet numbers.
+type skippingPacketNumberGenerator struct {
+	period    protocol.PacketNumber
+	maxPeriod protocol.PacketNumber
+
+	next       protocol.PacketNumber
+	nextToSkip protocol.PacketNumber
+
+	rng utils.Rand
+}
+
+var _ packetNumberGenerator = &skippingPacketNumberGenerator{}
+
+func newSkippingPacketNumberGenerator(initial, initialPeriod, maxPeriod protocol.PacketNumber) packetNumberGenerator {
+	g := &skippingPacketNumberGenerator{
+		next:      initial,
+		period:    initialPeriod,
+		maxPeriod: maxPeriod,
+	}
+	g.generateNewSkip()
+	return g
+}
+
+func (p *skippingPacketNumberGenerator) Peek() protocol.PacketNumber {
+	if p.next == p.nextToSkip {
+		return p.next + 1
+	}
+	return p.next
+}
+
+func (p *skippingPacketNumberGenerator) Pop() (bool, protocol.PacketNumber) {
+	next := p.next
+	if p.next == p.nextToSkip {
+		next++
+		p.next += 2
+		p.generateNewSkip()
+		return true, next
+	}
+	p.next++ // generate a new packet number for the next packet
+	return false, next
+}
+
+func (p *skippingPacketNumberGenerator) generateNewSkip() {
+	// make sure that there are never two consecutive packet numbers that are skipped
+	p.nextToSkip = p.next + 3 + protocol.PacketNumber(p.rng.Int31n(int32(2*p.period)))
+	p.period = min(2*p.period, p.maxPeriod)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_handler.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_handler.go
new file mode 100644
index 00000000..d0d24bf3
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_handler.go
@@ -0,0 +1,119 @@
+package ackhandler
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type ReceivedPacketHandler struct {
+	initialPackets   *receivedPacketTracker
+	handshakePackets *receivedPacketTracker
+	appDataPackets   appDataReceivedPacketTracker
+
+	lowest1RTTPacket protocol.PacketNumber
+}
+
+func NewReceivedPacketHandler(logger utils.Logger) *ReceivedPacketHandler {
+	return &ReceivedPacketHandler{
+		initialPackets:   newReceivedPacketTracker(),
+		handshakePackets: newReceivedPacketTracker(),
+		appDataPackets:   *newAppDataReceivedPacketTracker(logger),
+		lowest1RTTPacket: protocol.InvalidPacketNumber,
+	}
+}
+
+func (h *ReceivedPacketHandler) ReceivedPacket(
+	pn protocol.PacketNumber,
+	ecn protocol.ECN,
+	encLevel protocol.EncryptionLevel,
+	rcvTime monotime.Time,
+	ackEliciting bool,
+) error {
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return h.initialPackets.ReceivedPacket(pn, ecn, ackEliciting)
+	case protocol.EncryptionHandshake:
+		// The Handshake packet number space might already have been dropped as a result
+		// of processing the CRYPTO frame that was contained in this packet.
+		if h.handshakePackets == nil {
+			return nil
+		}
+		return h.handshakePackets.ReceivedPacket(pn, ecn, ackEliciting)
+	case protocol.Encryption0RTT:
+		if h.lowest1RTTPacket != protocol.InvalidPacketNumber && pn > h.lowest1RTTPacket {
+			return fmt.Errorf("received packet number %d on a 0-RTT packet after receiving %d on a 1-RTT packet", pn, h.lowest1RTTPacket)
+		}
+		return h.appDataPackets.ReceivedPacket(pn, ecn, rcvTime, ackEliciting)
+	case protocol.Encryption1RTT:
+		if h.lowest1RTTPacket == protocol.InvalidPacketNumber || pn < h.lowest1RTTPacket {
+			h.lowest1RTTPacket = pn
+		}
+		return h.appDataPackets.ReceivedPacket(pn, ecn, rcvTime, ackEliciting)
+	default:
+		panic(fmt.Sprintf("received packet with unknown encryption level: %s", encLevel))
+	}
+}
+
+func (h *ReceivedPacketHandler) IgnorePacketsBelow(pn protocol.PacketNumber) {
+	h.appDataPackets.IgnoreBelow(pn)
+}
+
+func (h *ReceivedPacketHandler) DropPackets(encLevel protocol.EncryptionLevel) {
+	//nolint:exhaustive // 1-RTT packet number space is never dropped.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		h.initialPackets = nil
+	case protocol.EncryptionHandshake:
+		h.handshakePackets = nil
+	case protocol.Encryption0RTT:
+		// Nothing to do here.
+		// If we are rejecting 0-RTT, no 0-RTT packets will have been decrypted.
+	default:
+		panic(fmt.Sprintf("Cannot drop keys for encryption level %s", encLevel))
+	}
+}
+
+func (h *ReceivedPacketHandler) GetAlarmTimeout() monotime.Time {
+	return h.appDataPackets.GetAlarmTimeout()
+}
+
+func (h *ReceivedPacketHandler) GetAckFrame(encLevel protocol.EncryptionLevel, now monotime.Time, onlyIfQueued bool) *wire.AckFrame {
+	//nolint:exhaustive // 0-RTT packets can't contain ACK frames.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		if h.initialPackets != nil {
+			return h.initialPackets.GetAckFrame()
+		}
+		return nil
+	case protocol.EncryptionHandshake:
+		if h.handshakePackets != nil {
+			return h.handshakePackets.GetAckFrame()
+		}
+		return nil
+	case protocol.Encryption1RTT:
+		return h.appDataPackets.GetAckFrame(now, onlyIfQueued)
+	default:
+		// 0-RTT packets can't contain ACK frames
+		return nil
+	}
+}
+
+func (h *ReceivedPacketHandler) IsPotentiallyDuplicate(pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) bool {
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		if h.initialPackets != nil {
+			return h.initialPackets.IsPotentiallyDuplicate(pn)
+		}
+	case protocol.EncryptionHandshake:
+		if h.handshakePackets != nil {
+			return h.handshakePackets.IsPotentiallyDuplicate(pn)
+		}
+	case protocol.Encryption0RTT, protocol.Encryption1RTT:
+		return h.appDataPackets.IsPotentiallyDuplicate(pn)
+	}
+	panic("unexpected encryption level")
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_history.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_history.go
new file mode 100644
index 00000000..d065b6e6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_history.go
@@ -0,0 +1,159 @@
+package ackhandler
+
+import (
+	"iter"
+	"slices"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// interval is an interval from one PacketNumber to the other
+type interval struct {
+	Start protocol.PacketNumber
+	End   protocol.PacketNumber
+}
+
+// The receivedPacketHistory stores if a packet number has already been received.
+// It generates ACK ranges which can be used to assemble an ACK frame.
+// It does not store packet contents.
+type receivedPacketHistory struct {
+	ranges []interval // maximum length: protocol.MaxNumAckRanges
+
+	deletedBelow protocol.PacketNumber
+}
+
+func newReceivedPacketHistory() *receivedPacketHistory {
+	return &receivedPacketHistory{
+		deletedBelow: protocol.InvalidPacketNumber,
+	}
+}
+
+// ReceivedPacket registers a packet with PacketNumber p and updates the ranges
+func (h *receivedPacketHistory) ReceivedPacket(p protocol.PacketNumber) bool /* is a new packet (and not a duplicate / delayed packet) */ {
+	// ignore delayed packets, if we already deleted the range
+	if p < h.deletedBelow {
+		return false
+	}
+
+	isNew := h.addToRanges(p)
+	// Delete old ranges, if we're tracking too many of them.
+	// This is a DoS defense against a peer that sends us too many gaps.
+	if len(h.ranges) > protocol.MaxNumAckRanges {
+		h.ranges = slices.Delete(h.ranges, 0, len(h.ranges)-protocol.MaxNumAckRanges)
+	}
+	return isNew
+}
+
+func (h *receivedPacketHistory) addToRanges(p protocol.PacketNumber) bool /* is a new packet (and not a duplicate / delayed packet) */ {
+	if len(h.ranges) == 0 {
+		h.ranges = append(h.ranges, interval{Start: p, End: p})
+		return true
+	}
+
+	for i := len(h.ranges) - 1; i >= 0; i-- {
+		// p already included in an existing range. Nothing to do here
+		if p >= h.ranges[i].Start && p <= h.ranges[i].End {
+			return false
+		}
+
+		if h.ranges[i].End == p-1 { // extend a range at the end
+			h.ranges[i].End = p
+			return true
+		}
+		if h.ranges[i].Start == p+1 { // extend a range at the beginning
+			h.ranges[i].Start = p
+
+			if i > 0 && h.ranges[i-1].End+1 == h.ranges[i].Start { // merge two ranges
+				h.ranges[i-1].End = h.ranges[i].End
+				h.ranges = slices.Delete(h.ranges, i, i+1)
+			}
+			return true
+		}
+
+		// create a new range after the current one
+		if p > h.ranges[i].End {
+			h.ranges = slices.Insert(h.ranges, i+1, interval{Start: p, End: p})
+			return true
+		}
+	}
+
+	// create a new range at the beginning
+	h.ranges = slices.Insert(h.ranges, 0, interval{Start: p, End: p})
+	return true
+}
+
+// DeleteBelow deletes all entries below (but not including) p
+func (h *receivedPacketHistory) DeleteBelow(p protocol.PacketNumber) {
+	if p < h.deletedBelow {
+		return
+	}
+	h.deletedBelow = p
+
+	if len(h.ranges) == 0 {
+		return
+	}
+
+	idx := -1
+	for i := 0; i < len(h.ranges); i++ {
+		if h.ranges[i].End < p { // delete a whole range
+			idx = i
+		} else if p > h.ranges[i].Start && p <= h.ranges[i].End {
+			h.ranges[i].Start = p
+			break
+		} else { // no ranges affected. Nothing to do
+			break
+		}
+	}
+	if idx >= 0 {
+		h.ranges = slices.Delete(h.ranges, 0, idx+1)
+	}
+}
+
+// Backward returns an iterator over the ranges in reverse order
+func (h *receivedPacketHistory) Backward() iter.Seq[interval] {
+	return func(yield func(interval) bool) {
+		for i := len(h.ranges) - 1; i >= 0; i-- {
+			if !yield(h.ranges[i]) {
+				return
+			}
+		}
+	}
+}
+
+func (h *receivedPacketHistory) HighestMissingUpTo(p protocol.PacketNumber) protocol.PacketNumber {
+	if len(h.ranges) == 0 || (h.deletedBelow != protocol.InvalidPacketNumber && p < h.deletedBelow) {
+		return protocol.InvalidPacketNumber
+	}
+	p = min(h.ranges[len(h.ranges)-1].End, p)
+	for i := len(h.ranges) - 1; i >= 0; i-- {
+		r := h.ranges[i]
+		if p >= r.Start && p <= r.End { // p is contained in this range
+			highest := r.Start - 1 // highest packet in the gap before this range
+			if h.deletedBelow != protocol.InvalidPacketNumber && highest < h.deletedBelow {
+				return protocol.InvalidPacketNumber
+			}
+			return highest
+		}
+		if i >= 1 && p > h.ranges[i-1].End && p <= r.Start {
+			// p is in the gap between the previous range and this range
+			return p
+		}
+	}
+	return p
+}
+
+func (h *receivedPacketHistory) IsPotentiallyDuplicate(p protocol.PacketNumber) bool {
+	if p < h.deletedBelow {
+		return true
+	}
+	// Iterating over the slices is faster than using a binary search (using slices.BinarySearchFunc).
+	for i := len(h.ranges) - 1; i >= 0; i-- {
+		if p > h.ranges[i].End {
+			return false
+		}
+		if p <= h.ranges[i].End && p >= h.ranges[i].Start {
+			return true
+		}
+	}
+	return false
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_tracker.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_tracker.go
new file mode 100644
index 00000000..64092ccc
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/received_packet_tracker.go
@@ -0,0 +1,228 @@
+package ackhandler
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+const reorderingThreshold = 1
+
+// The receivedPacketTracker tracks packets for the Initial and Handshake packet number space.
+// Every received packet is acknowledged immediately.
+type receivedPacketTracker struct {
+	ect0, ect1, ecnce uint64
+
+	packetHistory receivedPacketHistory
+
+	lastAck   *wire.AckFrame
+	hasNewAck bool // true as soon as we received an ack-eliciting new packet
+}
+
+func newReceivedPacketTracker() *receivedPacketTracker {
+	return &receivedPacketTracker{packetHistory: *newReceivedPacketHistory()}
+}
+
+func (h *receivedPacketTracker) ReceivedPacket(pn protocol.PacketNumber, ecn protocol.ECN, ackEliciting bool) error {
+	if isNew := h.packetHistory.ReceivedPacket(pn); !isNew {
+		return fmt.Errorf("receivedPacketTracker BUG: ReceivedPacket called for old / duplicate packet %d", pn)
+	}
+
+	//nolint:exhaustive // Only need to count ECT(0), ECT(1) and ECN-CE.
+	switch ecn {
+	case protocol.ECT0:
+		h.ect0++
+	case protocol.ECT1:
+		h.ect1++
+	case protocol.ECNCE:
+		h.ecnce++
+	}
+	if !ackEliciting {
+		return nil
+	}
+	h.hasNewAck = true
+	return nil
+}
+
+func (h *receivedPacketTracker) GetAckFrame() *wire.AckFrame {
+	if !h.hasNewAck {
+		return nil
+	}
+
+	// This function always returns the same ACK frame struct, filled with the most recent values.
+	ack := h.lastAck
+	if ack == nil {
+		ack = &wire.AckFrame{}
+	}
+	ack.Reset()
+	ack.ECT0 = h.ect0
+	ack.ECT1 = h.ect1
+	ack.ECNCE = h.ecnce
+	for r := range h.packetHistory.Backward() {
+		ack.AckRanges = append(ack.AckRanges, wire.AckRange{Smallest: r.Start, Largest: r.End})
+	}
+
+	h.lastAck = ack
+	h.hasNewAck = false
+	return ack
+}
+
+func (h *receivedPacketTracker) IsPotentiallyDuplicate(pn protocol.PacketNumber) bool {
+	return h.packetHistory.IsPotentiallyDuplicate(pn)
+}
+
+// number of ack-eliciting packets received before sending an ACK
+const packetsBeforeAck = 2
+
+// The appDataReceivedPacketTracker tracks packets received in the Application Data packet number space.
+// It waits until at least 2 packets were received before queueing an ACK, or until the max_ack_delay was reached.
+type appDataReceivedPacketTracker struct {
+	receivedPacketTracker
+
+	largestObservedRcvdTime monotime.Time
+
+	largestObserved protocol.PacketNumber
+	ignoreBelow     protocol.PacketNumber
+
+	maxAckDelay time.Duration
+	ackQueued   bool // true if we need send a new ACK
+
+	ackElicitingPacketsReceivedSinceLastAck int
+	ackAlarm                                monotime.Time
+
+	logger utils.Logger
+}
+
+func newAppDataReceivedPacketTracker(logger utils.Logger) *appDataReceivedPacketTracker {
+	h := &appDataReceivedPacketTracker{
+		receivedPacketTracker: *newReceivedPacketTracker(),
+		maxAckDelay:           protocol.MaxAckDelay,
+		logger:                logger,
+	}
+	return h
+}
+
+func (h *appDataReceivedPacketTracker) ReceivedPacket(pn protocol.PacketNumber, ecn protocol.ECN, rcvTime monotime.Time, ackEliciting bool) error {
+	if err := h.receivedPacketTracker.ReceivedPacket(pn, ecn, ackEliciting); err != nil {
+		return err
+	}
+	if pn >= h.largestObserved {
+		h.largestObserved = pn
+		h.largestObservedRcvdTime = rcvTime
+	}
+	if !ackEliciting {
+		return nil
+	}
+	h.ackElicitingPacketsReceivedSinceLastAck++
+	isMissing := h.isMissing(pn)
+	if !h.ackQueued && h.shouldQueueACK(pn, ecn, isMissing) {
+		h.ackQueued = true
+		h.ackAlarm = 0 // cancel the ack alarm
+	}
+	if !h.ackQueued {
+		// No ACK queued, but we'll need to acknowledge the packet after max_ack_delay.
+		h.ackAlarm = rcvTime.Add(h.maxAckDelay)
+		if h.logger.Debug() {
+			h.logger.Debugf("\tSetting ACK timer to max ack delay: %s", h.maxAckDelay)
+		}
+	}
+	return nil
+}
+
+// IgnoreBelow sets a lower limit for acknowledging packets.
+// Packets with packet numbers smaller than p will not be acked.
+func (h *appDataReceivedPacketTracker) IgnoreBelow(pn protocol.PacketNumber) {
+	if pn <= h.ignoreBelow {
+		return
+	}
+	h.ignoreBelow = pn
+	h.packetHistory.DeleteBelow(pn)
+	if h.logger.Debug() {
+		h.logger.Debugf("\tIgnoring all packets below %d.", pn)
+	}
+}
+
+// isMissing says if a packet was reported missing in the last ACK.
+func (h *appDataReceivedPacketTracker) isMissing(p protocol.PacketNumber) bool {
+	if h.lastAck == nil || p < h.ignoreBelow {
+		return false
+	}
+	return p < h.lastAck.LargestAcked() && !h.lastAck.AcksPacket(p)
+}
+
+func (h *appDataReceivedPacketTracker) hasNewMissingPackets() bool {
+	if h.lastAck == nil {
+		return false
+	}
+	if h.largestObserved < reorderingThreshold {
+		return false
+	}
+	highestMissing := h.packetHistory.HighestMissingUpTo(h.largestObserved - reorderingThreshold)
+	if highestMissing == protocol.InvalidPacketNumber {
+		return false
+	}
+	if highestMissing < h.lastAck.LargestAcked() {
+		// the packet was already reported missing in the last ACK
+		return false
+	}
+	return highestMissing > h.lastAck.LargestAcked()-reorderingThreshold
+}
+
+func (h *appDataReceivedPacketTracker) shouldQueueACK(pn protocol.PacketNumber, ecn protocol.ECN, wasMissing bool) bool {
+	// Send an ACK if this packet was reported missing in an ACK sent before.
+	// Ack decimation with reordering relies on the timer to send an ACK, but if
+	// missing packets we reported in the previous ACK, send an ACK immediately.
+	if wasMissing {
+		if h.logger.Debug() {
+			h.logger.Debugf("\tQueueing ACK because packet %d was missing before.", pn)
+		}
+		return true
+	}
+
+	// send an ACK every 2 ack-eliciting packets
+	if h.ackElicitingPacketsReceivedSinceLastAck >= packetsBeforeAck {
+		if h.logger.Debug() {
+			h.logger.Debugf("\tQueueing ACK because packet %d packets were received after the last ACK (using initial threshold: %d).", h.ackElicitingPacketsReceivedSinceLastAck, packetsBeforeAck)
+		}
+		return true
+	}
+
+	// queue an ACK if there are new missing packets to report
+	if h.hasNewMissingPackets() {
+		h.logger.Debugf("\tQueuing ACK because there's a new missing packet to report.")
+		return true
+	}
+
+	// queue an ACK if the packet was ECN-CE marked
+	if ecn == protocol.ECNCE {
+		h.logger.Debugf("\tQueuing ACK because the packet was ECN-CE marked.")
+		return true
+	}
+	return false
+}
+
+func (h *appDataReceivedPacketTracker) GetAckFrame(now monotime.Time, onlyIfQueued bool) *wire.AckFrame {
+	if onlyIfQueued && !h.ackQueued {
+		if h.ackAlarm.IsZero() || h.ackAlarm.After(now) {
+			return nil
+		}
+		if h.logger.Debug() && !h.ackAlarm.IsZero() {
+			h.logger.Debugf("Sending ACK because the ACK timer expired.")
+		}
+	}
+	ack := h.receivedPacketTracker.GetAckFrame()
+	if ack == nil {
+		return nil
+	}
+	ack.DelayTime = max(0, now.Sub(h.largestObservedRcvdTime))
+	h.ackQueued = false
+	h.ackAlarm = 0
+	h.ackElicitingPacketsReceivedSinceLastAck = 0
+	return ack
+}
+
+func (h *appDataReceivedPacketTracker) GetAlarmTimeout() monotime.Time { return h.ackAlarm }
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/send_mode.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/send_mode.go
new file mode 100644
index 00000000..c03f3a6f
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/send_mode.go
@@ -0,0 +1,46 @@
+package ackhandler
+
+import "fmt"
+
+// The SendMode says what kind of packets can be sent.
+type SendMode uint8
+
+const (
+	// SendNone means that no packets should be sent
+	SendNone SendMode = iota
+	// SendAck means an ACK-only packet should be sent
+	SendAck
+	// SendPTOInitial means that an Initial probe packet should be sent
+	SendPTOInitial
+	// SendPTOHandshake means that a Handshake probe packet should be sent
+	SendPTOHandshake
+	// SendPTOAppData means that an Application data probe packet should be sent
+	SendPTOAppData
+	// SendPacingLimited means that the pacer doesn't allow sending of a packet right now,
+	// but will do in a little while.
+	// The timestamp when sending is allowed again can be obtained via the SentPacketHandler.TimeUntilSend.
+	SendPacingLimited
+	// SendAny means that any packet should be sent
+	SendAny
+)
+
+func (s SendMode) String() string {
+	switch s {
+	case SendNone:
+		return "none"
+	case SendAck:
+		return "ack"
+	case SendPTOInitial:
+		return "pto (Initial)"
+	case SendPTOHandshake:
+		return "pto (Handshake)"
+	case SendPTOAppData:
+		return "pto (Application Data)"
+	case SendAny:
+		return "any"
+	case SendPacingLimited:
+		return "pacing limited"
+	default:
+		return fmt.Sprintf("invalid send mode: %d", s)
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_handler.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_handler.go
new file mode 100644
index 00000000..9b539ead
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_handler.go
@@ -0,0 +1,1143 @@
+package ackhandler
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/congestion"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+const (
+	// Maximum reordering in time space before time based loss detection considers a packet lost.
+	// Specified as an RTT multiplier.
+	timeThreshold = 9.0 / 8
+	// Maximum reordering in packets before packet threshold loss detection considers a packet lost.
+	packetThreshold = 3
+	// Before validating the client's address, the server won't send more than 3x bytes than it received.
+	amplificationFactor = 3
+	// We use Retry packets to derive an RTT estimate. Make sure we don't set the RTT to a super low value yet.
+	minRTTAfterRetry = 5 * time.Millisecond
+	// The PTO duration uses exponential backoff, but is truncated to a maximum value, as allowed by RFC 8961, section 4.4.
+	maxPTODuration = 60 * time.Second
+)
+
+// Path probe packets are declared lost after this time.
+const pathProbePacketLossTimeout = time.Second
+
+type packetNumberSpace struct {
+	history sentPacketHistory
+	pns     packetNumberGenerator
+
+	lossTime                   monotime.Time
+	lastAckElicitingPacketTime monotime.Time
+
+	largestAcked protocol.PacketNumber
+	largestSent  protocol.PacketNumber
+}
+
+func newPacketNumberSpace(initialPN protocol.PacketNumber, isAppData bool) *packetNumberSpace {
+	var pns packetNumberGenerator
+	if isAppData {
+		pns = newSkippingPacketNumberGenerator(initialPN, protocol.SkipPacketInitialPeriod, protocol.SkipPacketMaxPeriod)
+	} else {
+		pns = newSequentialPacketNumberGenerator(initialPN)
+	}
+	return &packetNumberSpace{
+		history:      *newSentPacketHistory(isAppData),
+		pns:          pns,
+		largestSent:  protocol.InvalidPacketNumber,
+		largestAcked: protocol.InvalidPacketNumber,
+	}
+}
+
+type alarmTimer struct {
+	Time            monotime.Time
+	TimerType       qlog.TimerType
+	EncryptionLevel protocol.EncryptionLevel
+}
+
+type sentPacketHandler struct {
+	initialPackets   *packetNumberSpace
+	handshakePackets *packetNumberSpace
+	appDataPackets   *packetNumberSpace
+	lostPackets      lostPacketTracker // only for application-data packet number space
+	// send time of the largest acknowledged packet, across all packet number spaces
+	largestAckedTime monotime.Time
+
+	// Do we know that the peer completed address validation yet?
+	// Always true for the server.
+	peerCompletedAddressValidation bool
+	bytesReceived                  protocol.ByteCount
+	bytesSent                      protocol.ByteCount
+	// Have we validated the peer's address yet?
+	// Always true for the client.
+	peerAddressValidated bool
+
+	handshakeConfirmed bool
+
+	ignorePacketsBelow func(protocol.PacketNumber)
+
+	ackedPackets []packetWithPacketNumber // to avoid allocations in detectAndRemoveAckedPackets
+
+	bytesInFlight protocol.ByteCount
+
+	congestion congestion.SendAlgorithmWithDebugInfos
+	rttStats   *utils.RTTStats
+	connStats  *utils.ConnectionStats
+
+	// The number of times a PTO has been sent without receiving an ack.
+	ptoCount uint32
+	ptoMode  SendMode
+	// The number of PTO probe packets that should be sent.
+	// Only applies to the application-data packet number space.
+	numProbesToSend int
+
+	// The alarm timeout
+	alarm alarmTimer
+
+	enableECN  bool
+	ecnTracker ecnHandler
+
+	perspective protocol.Perspective
+
+	qlogger     qlogwriter.Recorder
+	lastMetrics qlog.MetricsUpdated
+	logger      utils.Logger
+}
+
+var _ SentPacketHandler = &sentPacketHandler{}
+
+// clientAddressValidated indicates whether the address was validated beforehand by an address validation token.
+// If the address was validated, the amplification limit doesn't apply. It has no effect for a client.
+func NewSentPacketHandler(
+	initialPN protocol.PacketNumber,
+	initialMaxDatagramSize protocol.ByteCount,
+	rttStats *utils.RTTStats,
+	connStats *utils.ConnectionStats,
+	clientAddressValidated bool,
+	enableECN bool,
+	ignorePacketsBelow func(protocol.PacketNumber),
+	pers protocol.Perspective,
+	qlogger qlogwriter.Recorder,
+	logger utils.Logger,
+) SentPacketHandler {
+	congestion := congestion.NewCubicSender(
+		congestion.DefaultClock{},
+		rttStats,
+		connStats,
+		initialMaxDatagramSize,
+		true, // use Reno
+		qlogger,
+	)
+
+	h := &sentPacketHandler{
+		peerCompletedAddressValidation: pers == protocol.PerspectiveServer,
+		peerAddressValidated:           pers == protocol.PerspectiveClient || clientAddressValidated,
+		initialPackets:                 newPacketNumberSpace(initialPN, false),
+		handshakePackets:               newPacketNumberSpace(0, false),
+		appDataPackets:                 newPacketNumberSpace(0, true),
+		lostPackets:                    *newLostPacketTracker(64),
+		rttStats:                       rttStats,
+		connStats:                      connStats,
+		congestion:                     congestion,
+		ignorePacketsBelow:             ignorePacketsBelow,
+		perspective:                    pers,
+		qlogger:                        qlogger,
+		logger:                         logger,
+	}
+	if enableECN {
+		h.enableECN = true
+		h.ecnTracker = newECNTracker(logger, qlogger)
+	}
+	return h
+}
+
+func (h *sentPacketHandler) removeFromBytesInFlight(p *packet) {
+	if p.includedInBytesInFlight {
+		if p.Length > h.bytesInFlight {
+			panic("negative bytes_in_flight")
+		}
+		h.bytesInFlight -= p.Length
+		p.includedInBytesInFlight = false
+	}
+}
+
+func (h *sentPacketHandler) DropPackets(encLevel protocol.EncryptionLevel, now monotime.Time) {
+	// The server won't await address validation after the handshake is confirmed.
+	// This applies even if we didn't receive an ACK for a Handshake packet.
+	if h.perspective == protocol.PerspectiveClient && encLevel == protocol.EncryptionHandshake {
+		h.peerCompletedAddressValidation = true
+	}
+	// remove outstanding packets from bytes_in_flight
+	if encLevel == protocol.EncryptionInitial || encLevel == protocol.EncryptionHandshake {
+		pnSpace := h.getPacketNumberSpace(encLevel)
+		// We might already have dropped this packet number space.
+		if pnSpace == nil {
+			return
+		}
+		for _, p := range pnSpace.history.Packets() {
+			h.removeFromBytesInFlight(p)
+		}
+	}
+	// drop the packet history
+	//nolint:exhaustive // Not every packet number space can be dropped.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		h.initialPackets = nil
+	case protocol.EncryptionHandshake:
+		// Dropping the handshake packet number space means that the handshake is confirmed,
+		// see section 4.9.2 of RFC 9001.
+		h.handshakeConfirmed = true
+		h.handshakePackets = nil
+	case protocol.Encryption0RTT:
+		// This function is only called when 0-RTT is rejected,
+		// and not when the client drops 0-RTT keys when the handshake completes.
+		// When 0-RTT is rejected, all application data sent so far becomes invalid.
+		// Delete the packets from the history and remove them from bytes_in_flight.
+		for pn, p := range h.appDataPackets.history.Packets() {
+			if p.EncryptionLevel != protocol.Encryption0RTT {
+				break
+			}
+			h.removeFromBytesInFlight(p)
+			h.appDataPackets.history.Remove(pn)
+		}
+	default:
+		panic(fmt.Sprintf("Cannot drop keys for encryption level %s", encLevel))
+	}
+	if h.qlogger != nil && h.ptoCount != 0 {
+		h.qlogger.RecordEvent(qlog.PTOCountUpdated{PTOCount: 0})
+	}
+	h.ptoCount = 0
+	h.numProbesToSend = 0
+	h.ptoMode = SendNone
+	h.setLossDetectionTimer(now)
+}
+
+func (h *sentPacketHandler) ReceivedBytes(n protocol.ByteCount, t monotime.Time) {
+	h.connStats.BytesReceived.Add(uint64(n))
+	wasAmplificationLimit := h.isAmplificationLimited()
+	h.bytesReceived += n
+	if wasAmplificationLimit && !h.isAmplificationLimited() {
+		h.setLossDetectionTimer(t)
+	}
+}
+
+func (h *sentPacketHandler) ReceivedPacket(l protocol.EncryptionLevel, t monotime.Time) {
+	h.connStats.PacketsReceived.Add(1)
+	if h.perspective == protocol.PerspectiveServer && l == protocol.EncryptionHandshake && !h.peerAddressValidated {
+		h.peerAddressValidated = true
+		h.setLossDetectionTimer(t)
+	}
+}
+
+func (h *sentPacketHandler) packetsInFlight() int {
+	packetsInFlight := h.appDataPackets.history.NumOutstanding()
+	if h.handshakePackets != nil {
+		packetsInFlight += h.handshakePackets.history.NumOutstanding()
+	}
+	if h.initialPackets != nil {
+		packetsInFlight += h.initialPackets.history.NumOutstanding()
+	}
+	return packetsInFlight
+}
+
+func (h *sentPacketHandler) SentPacket(
+	t monotime.Time,
+	pn, largestAcked protocol.PacketNumber,
+	streamFrames []StreamFrame,
+	frames []Frame,
+	encLevel protocol.EncryptionLevel,
+	ecn protocol.ECN,
+	size protocol.ByteCount,
+	isPathMTUProbePacket bool,
+	isPathProbePacket bool,
+) {
+	h.bytesSent += size
+	h.connStats.BytesSent.Add(uint64(size))
+	h.connStats.PacketsSent.Add(1)
+
+	pnSpace := h.getPacketNumberSpace(encLevel)
+	if h.logger.Debug() && (pnSpace.history.HasOutstandingPackets() || pnSpace.history.HasOutstandingPathProbes()) {
+		for p := max(0, pnSpace.largestSent+1); p < pn; p++ {
+			h.logger.Debugf("Skipping packet number %d", p)
+		}
+	}
+
+	pnSpace.largestSent = pn
+
+	p := getPacket()
+	p.SendTime = t
+	p.EncryptionLevel = encLevel
+	p.Length = size
+	p.Frames = frames
+	p.LargestAcked = largestAcked
+	p.StreamFrames = streamFrames
+	p.IsPathMTUProbePacket = isPathMTUProbePacket
+	p.isPathProbePacket = isPathProbePacket
+	isAckEliciting := p.IsAckEliciting()
+
+	if isPathProbePacket {
+		pnSpace.history.SentPathProbePacket(pn, p)
+		h.setLossDetectionTimer(t)
+		return
+	}
+	if isAckEliciting {
+		pnSpace.lastAckElicitingPacketTime = t
+		h.bytesInFlight += size
+		p.includedInBytesInFlight = true
+		if h.numProbesToSend > 0 {
+			h.numProbesToSend--
+		}
+	}
+	h.congestion.OnPacketSent(t, h.bytesInFlight, pn, size, isAckEliciting)
+
+	if encLevel == protocol.Encryption1RTT && h.ecnTracker != nil {
+		h.ecnTracker.SentPacket(pn, ecn)
+	}
+
+	pnSpace.history.SentPacket(pn, p)
+	if !isAckEliciting {
+		if !h.peerCompletedAddressValidation {
+			h.setLossDetectionTimer(t)
+		}
+		return
+	}
+	if h.qlogger != nil {
+		h.qlogMetricsUpdated()
+	}
+	h.setLossDetectionTimer(t)
+}
+
+func (h *sentPacketHandler) qlogMetricsUpdated() {
+	var metricsUpdatedEvent qlog.MetricsUpdated
+	var updated bool
+	if h.rttStats.HasMeasurement() {
+		if h.lastMetrics.MinRTT != h.rttStats.MinRTT() {
+			metricsUpdatedEvent.MinRTT = h.rttStats.MinRTT()
+			h.lastMetrics.MinRTT = metricsUpdatedEvent.MinRTT
+			updated = true
+		}
+		if h.lastMetrics.SmoothedRTT != h.rttStats.SmoothedRTT() {
+			metricsUpdatedEvent.SmoothedRTT = h.rttStats.SmoothedRTT()
+			h.lastMetrics.SmoothedRTT = metricsUpdatedEvent.SmoothedRTT
+			updated = true
+		}
+		if h.lastMetrics.LatestRTT != h.rttStats.LatestRTT() {
+			metricsUpdatedEvent.LatestRTT = h.rttStats.LatestRTT()
+			h.lastMetrics.LatestRTT = metricsUpdatedEvent.LatestRTT
+			updated = true
+		}
+		if h.lastMetrics.RTTVariance != h.rttStats.MeanDeviation() {
+			metricsUpdatedEvent.RTTVariance = h.rttStats.MeanDeviation()
+			h.lastMetrics.RTTVariance = metricsUpdatedEvent.RTTVariance
+			updated = true
+		}
+	}
+	if cwnd := h.congestion.GetCongestionWindow(); h.lastMetrics.CongestionWindow != int(cwnd) {
+		metricsUpdatedEvent.CongestionWindow = int(cwnd)
+		h.lastMetrics.CongestionWindow = metricsUpdatedEvent.CongestionWindow
+		updated = true
+	}
+	if h.lastMetrics.BytesInFlight != int(h.bytesInFlight) {
+		metricsUpdatedEvent.BytesInFlight = int(h.bytesInFlight)
+		h.lastMetrics.BytesInFlight = metricsUpdatedEvent.BytesInFlight
+		updated = true
+	}
+	packetsInFlight := h.packetsInFlight()
+	if h.lastMetrics.PacketsInFlight != packetsInFlight {
+		metricsUpdatedEvent.PacketsInFlight = packetsInFlight
+		h.lastMetrics.PacketsInFlight = metricsUpdatedEvent.PacketsInFlight
+		updated = true
+	}
+	if updated {
+		h.qlogger.RecordEvent(metricsUpdatedEvent)
+	}
+}
+
+func (h *sentPacketHandler) getPacketNumberSpace(encLevel protocol.EncryptionLevel) *packetNumberSpace {
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return h.initialPackets
+	case protocol.EncryptionHandshake:
+		return h.handshakePackets
+	case protocol.Encryption0RTT, protocol.Encryption1RTT:
+		return h.appDataPackets
+	default:
+		panic("invalid packet number space")
+	}
+}
+
+func (h *sentPacketHandler) ReceivedAck(ack *wire.AckFrame, encLevel protocol.EncryptionLevel, rcvTime monotime.Time) (bool /* contained 1-RTT packet */, error) {
+	pnSpace := h.getPacketNumberSpace(encLevel)
+
+	largestAcked := ack.LargestAcked()
+	if largestAcked > pnSpace.largestSent {
+		return false, &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "received ACK for an unsent packet",
+		}
+	}
+
+	// Servers complete address validation when a protected packet is received.
+	if h.perspective == protocol.PerspectiveClient && !h.peerCompletedAddressValidation &&
+		(encLevel == protocol.EncryptionHandshake || encLevel == protocol.Encryption1RTT) {
+		h.peerCompletedAddressValidation = true
+		h.logger.Debugf("Peer doesn't await address validation any longer.")
+		// Make sure that the timer is reset, even if this ACK doesn't acknowledge any (ack-eliciting) packets.
+		h.setLossDetectionTimer(rcvTime)
+	}
+
+	priorInFlight := h.bytesInFlight
+	ackedPackets, hasAckEliciting, err := h.detectAndRemoveAckedPackets(ack, encLevel)
+	if err != nil || len(ackedPackets) == 0 {
+		return false, err
+	}
+	// update the RTT, if:
+	// * the largest acked is newly acknowledged, AND
+	// * at least one new ack-eliciting packet was acknowledged
+	if len(ackedPackets) > 0 {
+		if p := ackedPackets[len(ackedPackets)-1]; p.PacketNumber == ack.LargestAcked() && !p.isPathProbePacket && hasAckEliciting {
+			// don't use the ack delay for Initial and Handshake packets
+			var ackDelay time.Duration
+			if encLevel == protocol.Encryption1RTT {
+				ackDelay = min(ack.DelayTime, h.rttStats.MaxAckDelay())
+			}
+			if h.largestAckedTime.IsZero() || !p.SendTime.Before(h.largestAckedTime) {
+				h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackDelay)
+				if h.logger.Debug() {
+					h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation())
+				}
+				h.largestAckedTime = p.SendTime
+			}
+			h.congestion.MaybeExitSlowStart()
+		}
+	}
+
+	// Only inform the ECN tracker about new 1-RTT ACKs if the ACK increases the largest acked.
+	if encLevel == protocol.Encryption1RTT && h.ecnTracker != nil && largestAcked > pnSpace.largestAcked {
+		congested := h.ecnTracker.HandleNewlyAcked(ackedPackets, int64(ack.ECT0), int64(ack.ECT1), int64(ack.ECNCE))
+		if congested {
+			h.congestion.OnCongestionEvent(largestAcked, 0, priorInFlight)
+		}
+	}
+
+	pnSpace.largestAcked = max(pnSpace.largestAcked, largestAcked)
+
+	h.detectLostPackets(rcvTime, encLevel)
+	if encLevel == protocol.Encryption1RTT {
+		h.detectLostPathProbes(rcvTime)
+	}
+	var acked1RTTPacket bool
+	for _, p := range ackedPackets {
+		if p.includedInBytesInFlight {
+			h.congestion.OnPacketAcked(p.PacketNumber, p.Length, priorInFlight, rcvTime)
+		}
+		if p.EncryptionLevel == protocol.Encryption1RTT {
+			acked1RTTPacket = true
+		}
+		h.removeFromBytesInFlight(p.packet)
+		if !p.isPathProbePacket {
+			putPacket(p.packet)
+		}
+	}
+
+	// detect spurious losses for application data packets, if the ACK was not reordered
+	if encLevel == protocol.Encryption1RTT && largestAcked == pnSpace.largestAcked {
+		h.detectSpuriousLosses(
+			ack,
+			rcvTime.Add(-min(ack.DelayTime, h.rttStats.MaxAckDelay())),
+		)
+		// clean up lost packet history
+		h.lostPackets.DeleteBefore(rcvTime.Add(-3 * h.rttStats.PTO(false)))
+	}
+
+	// After this point, we must not use ackedPackets any longer!
+	// We've already returned the buffers.
+	ackedPackets = nil    //nolint:ineffassign // This is just to be on the safe side.
+	clear(h.ackedPackets) // make sure the memory is released
+	h.ackedPackets = h.ackedPackets[:0]
+
+	// Reset the pto_count unless the client is unsure if the server has validated the client's address.
+	if h.peerCompletedAddressValidation {
+		if h.qlogger != nil && h.ptoCount != 0 {
+			h.qlogger.RecordEvent(qlog.PTOCountUpdated{PTOCount: 0})
+		}
+		h.ptoCount = 0
+	}
+	h.numProbesToSend = 0
+
+	if h.qlogger != nil {
+		h.qlogMetricsUpdated()
+	}
+
+	h.setLossDetectionTimer(rcvTime)
+	return acked1RTTPacket, nil
+}
+
+func (h *sentPacketHandler) detectSpuriousLosses(ack *wire.AckFrame, ackTime monotime.Time) {
+	var maxPacketReordering protocol.PacketNumber
+	var maxTimeReordering time.Duration
+	ackRangeIdx := len(ack.AckRanges) - 1
+	var spuriousLosses []protocol.PacketNumber
+	for pn, sendTime := range h.lostPackets.All() {
+		ackRange := ack.AckRanges[ackRangeIdx]
+		for pn > ackRange.Largest {
+			// this should never happen, since detectSpuriousLosses is only called for ACKs that increase the largest acked
+			if ackRangeIdx == 0 {
+				break
+			}
+			ackRangeIdx--
+			ackRange = ack.AckRanges[ackRangeIdx]
+		}
+		if pn < ackRange.Smallest {
+			continue
+		}
+		if pn <= ackRange.Largest {
+			packetReordering := h.appDataPackets.history.Difference(ack.LargestAcked(), pn)
+			timeReordering := ackTime.Sub(sendTime)
+			maxPacketReordering = max(maxPacketReordering, packetReordering)
+			maxTimeReordering = max(maxTimeReordering, timeReordering)
+
+			if h.qlogger != nil {
+				h.qlogger.RecordEvent(qlog.SpuriousLoss{
+					EncryptionLevel:  protocol.Encryption1RTT,
+					PacketNumber:     pn,
+					PacketReordering: uint64(packetReordering),
+					TimeReordering:   timeReordering,
+				})
+			}
+			spuriousLosses = append(spuriousLosses, pn)
+		}
+	}
+	for _, pn := range spuriousLosses {
+		h.lostPackets.Delete(pn)
+	}
+}
+
+// Packets are returned in ascending packet number order.
+func (h *sentPacketHandler) detectAndRemoveAckedPackets(
+	ack *wire.AckFrame,
+	encLevel protocol.EncryptionLevel,
+) (_ []packetWithPacketNumber, hasAckEliciting bool, _ error) {
+	if len(h.ackedPackets) > 0 {
+		return nil, false, errors.New("ackhandler BUG: ackedPackets slice not empty")
+	}
+
+	pnSpace := h.getPacketNumberSpace(encLevel)
+
+	if encLevel == protocol.Encryption1RTT {
+		for p := range pnSpace.history.SkippedPackets() {
+			if ack.AcksPacket(p) {
+				return nil, false, &qerr.TransportError{
+					ErrorCode:    qerr.ProtocolViolation,
+					ErrorMessage: fmt.Sprintf("received an ACK for skipped packet number: %d (%s)", p, encLevel),
+				}
+			}
+		}
+	}
+
+	var ackRangeIndex int
+	lowestAcked := ack.LowestAcked()
+	largestAcked := ack.LargestAcked()
+	for pn, p := range pnSpace.history.Packets() {
+		// ignore packets below the lowest acked
+		if pn < lowestAcked {
+			continue
+		}
+		if pn > largestAcked {
+			break
+		}
+
+		if ack.HasMissingRanges() {
+			ackRange := ack.AckRanges[len(ack.AckRanges)-1-ackRangeIndex]
+
+			for pn > ackRange.Largest && ackRangeIndex < len(ack.AckRanges)-1 {
+				ackRangeIndex++
+				ackRange = ack.AckRanges[len(ack.AckRanges)-1-ackRangeIndex]
+			}
+
+			if pn < ackRange.Smallest { // packet not contained in ACK range
+				continue
+			}
+			if pn > ackRange.Largest {
+				return nil, false, fmt.Errorf("BUG: ackhandler would have acked wrong packet %d, while evaluating range %d -> %d", pn, ackRange.Smallest, ackRange.Largest)
+			}
+		}
+		if p.isPathProbePacket {
+			probePacket := pnSpace.history.RemovePathProbe(pn)
+			// the probe packet might already have been declared lost
+			if probePacket != nil {
+				h.ackedPackets = append(h.ackedPackets, packetWithPacketNumber{PacketNumber: pn, packet: probePacket})
+			}
+			continue
+		}
+		if p.IsAckEliciting() {
+			hasAckEliciting = true
+		}
+		h.ackedPackets = append(h.ackedPackets, packetWithPacketNumber{PacketNumber: pn, packet: p})
+	}
+	if h.logger.Debug() && len(h.ackedPackets) > 0 {
+		pns := make([]protocol.PacketNumber, len(h.ackedPackets))
+		for i, p := range h.ackedPackets {
+			pns[i] = p.PacketNumber
+		}
+		h.logger.Debugf("\tnewly acked packets (%d): %d", len(pns), pns)
+	}
+
+	for _, p := range h.ackedPackets {
+		if p.LargestAcked != protocol.InvalidPacketNumber && encLevel == protocol.Encryption1RTT && h.ignorePacketsBelow != nil {
+			h.ignorePacketsBelow(p.LargestAcked + 1)
+		}
+
+		for _, f := range p.Frames {
+			if f.Handler != nil {
+				f.Handler.OnAcked(f.Frame)
+			}
+		}
+		for _, f := range p.StreamFrames {
+			if f.Handler != nil {
+				f.Handler.OnAcked(f.Frame)
+			}
+		}
+		if err := pnSpace.history.Remove(p.PacketNumber); err != nil {
+			return nil, false, err
+		}
+	}
+	// TODO: add support for the transport:packets_acked qlog event
+	return h.ackedPackets, hasAckEliciting, nil
+}
+
+func (h *sentPacketHandler) getLossTimeAndSpace() (monotime.Time, protocol.EncryptionLevel) {
+	var encLevel protocol.EncryptionLevel
+	var lossTime monotime.Time
+
+	if h.initialPackets != nil {
+		lossTime = h.initialPackets.lossTime
+		encLevel = protocol.EncryptionInitial
+	}
+	if h.handshakePackets != nil && (lossTime.IsZero() || (!h.handshakePackets.lossTime.IsZero() && h.handshakePackets.lossTime.Before(lossTime))) {
+		lossTime = h.handshakePackets.lossTime
+		encLevel = protocol.EncryptionHandshake
+	}
+	if lossTime.IsZero() || (!h.appDataPackets.lossTime.IsZero() && h.appDataPackets.lossTime.Before(lossTime)) {
+		lossTime = h.appDataPackets.lossTime
+		encLevel = protocol.Encryption1RTT
+	}
+	return lossTime, encLevel
+}
+
+func (h *sentPacketHandler) getScaledPTO(includeMaxAckDelay bool) time.Duration {
+	pto := h.rttStats.PTO(includeMaxAckDelay) << h.ptoCount
+	if pto > maxPTODuration || pto <= 0 {
+		return maxPTODuration
+	}
+	return pto
+}
+
+// same logic as getLossTimeAndSpace, but for lastAckElicitingPacketTime instead of lossTime
+func (h *sentPacketHandler) getPTOTimeAndSpace(now monotime.Time) (pto monotime.Time, encLevel protocol.EncryptionLevel) {
+	// We only send application data probe packets once the handshake is confirmed,
+	// because before that, we don't have the keys to decrypt ACKs sent in 1-RTT packets.
+	if !h.handshakeConfirmed && !h.hasOutstandingCryptoPackets() {
+		if h.peerCompletedAddressValidation {
+			return
+		}
+		t := now.Add(h.getScaledPTO(false))
+		if h.initialPackets != nil {
+			return t, protocol.EncryptionInitial
+		}
+		return t, protocol.EncryptionHandshake
+	}
+
+	if h.initialPackets != nil && h.initialPackets.history.HasOutstandingPackets() &&
+		!h.initialPackets.lastAckElicitingPacketTime.IsZero() {
+		encLevel = protocol.EncryptionInitial
+		if t := h.initialPackets.lastAckElicitingPacketTime; !t.IsZero() {
+			pto = t.Add(h.getScaledPTO(false))
+		}
+	}
+	if h.handshakePackets != nil && h.handshakePackets.history.HasOutstandingPackets() &&
+		!h.handshakePackets.lastAckElicitingPacketTime.IsZero() {
+		t := h.handshakePackets.lastAckElicitingPacketTime.Add(h.getScaledPTO(false))
+		if pto.IsZero() || (!t.IsZero() && t.Before(pto)) {
+			pto = t
+			encLevel = protocol.EncryptionHandshake
+		}
+	}
+	if h.handshakeConfirmed && h.appDataPackets.history.HasOutstandingPackets() &&
+		!h.appDataPackets.lastAckElicitingPacketTime.IsZero() {
+		t := h.appDataPackets.lastAckElicitingPacketTime.Add(h.getScaledPTO(true))
+		if pto.IsZero() || (!t.IsZero() && t.Before(pto)) {
+			pto = t
+			encLevel = protocol.Encryption1RTT
+		}
+	}
+	return pto, encLevel
+}
+
+func (h *sentPacketHandler) hasOutstandingCryptoPackets() bool {
+	if h.initialPackets != nil && h.initialPackets.history.HasOutstandingPackets() {
+		return true
+	}
+	if h.handshakePackets != nil && h.handshakePackets.history.HasOutstandingPackets() {
+		return true
+	}
+	return false
+}
+
+func (h *sentPacketHandler) setLossDetectionTimer(now monotime.Time) {
+	oldAlarm := h.alarm // only needed in case tracing is enabled
+	newAlarm := h.lossDetectionTime(now)
+	h.alarm = newAlarm
+
+	hasAlarm := !newAlarm.Time.IsZero()
+	if !hasAlarm && !oldAlarm.Time.IsZero() {
+		h.logger.Debugf("Canceling loss detection timer.")
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.LossTimerUpdated{
+				Type: qlog.LossTimerUpdateTypeCancelled,
+			})
+		}
+	}
+
+	if h.qlogger != nil && hasAlarm && newAlarm != oldAlarm {
+		h.qlogger.RecordEvent(qlog.LossTimerUpdated{
+			Type:      qlog.LossTimerUpdateTypeSet,
+			TimerType: newAlarm.TimerType,
+			EncLevel:  newAlarm.EncryptionLevel,
+			Time:      newAlarm.Time.ToTime(),
+		})
+	}
+}
+
+func (h *sentPacketHandler) lossDetectionTime(now monotime.Time) alarmTimer {
+	// cancel the alarm if no packets are outstanding
+	if h.peerCompletedAddressValidation && !h.hasOutstandingCryptoPackets() &&
+		!h.appDataPackets.history.HasOutstandingPackets() && !h.appDataPackets.history.HasOutstandingPathProbes() {
+		return alarmTimer{}
+	}
+
+	// cancel the alarm if amplification limited
+	if h.isAmplificationLimited() {
+		return alarmTimer{}
+	}
+
+	var pathProbeLossTime monotime.Time
+	if h.appDataPackets.history.HasOutstandingPathProbes() {
+		if _, p := h.appDataPackets.history.FirstOutstandingPathProbe(); p != nil {
+			pathProbeLossTime = p.SendTime.Add(pathProbePacketLossTimeout)
+		}
+	}
+
+	// early retransmit timer or time loss detection
+	lossTime, encLevel := h.getLossTimeAndSpace()
+	if !lossTime.IsZero() && (pathProbeLossTime.IsZero() || lossTime.Before(pathProbeLossTime)) {
+		return alarmTimer{
+			Time:            lossTime,
+			TimerType:       qlog.TimerTypeACK,
+			EncryptionLevel: encLevel,
+		}
+	}
+	ptoTime, encLevel := h.getPTOTimeAndSpace(now)
+	if !ptoTime.IsZero() && (pathProbeLossTime.IsZero() || ptoTime.Before(pathProbeLossTime)) {
+		return alarmTimer{
+			Time:            ptoTime,
+			TimerType:       qlog.TimerTypePTO,
+			EncryptionLevel: encLevel,
+		}
+	}
+	if !pathProbeLossTime.IsZero() {
+		return alarmTimer{
+			Time:            pathProbeLossTime,
+			TimerType:       qlog.TimerTypePathProbe,
+			EncryptionLevel: protocol.Encryption1RTT,
+		}
+	}
+	return alarmTimer{}
+}
+
+func (h *sentPacketHandler) detectLostPathProbes(now monotime.Time) {
+	if !h.appDataPackets.history.HasOutstandingPathProbes() {
+		return
+	}
+	lossTime := now.Add(-pathProbePacketLossTimeout)
+	// RemovePathProbe cannot be called while iterating.
+	var lostPathProbes []packetWithPacketNumber
+	for pn, p := range h.appDataPackets.history.PathProbes() {
+		if !p.SendTime.After(lossTime) {
+			lostPathProbes = append(lostPathProbes, packetWithPacketNumber{PacketNumber: pn, packet: p})
+		}
+	}
+	for _, p := range lostPathProbes {
+		for _, f := range p.Frames {
+			f.Handler.OnLost(f.Frame)
+		}
+		h.appDataPackets.history.RemovePathProbe(p.PacketNumber)
+	}
+}
+
+func (h *sentPacketHandler) detectLostPackets(now monotime.Time, encLevel protocol.EncryptionLevel) {
+	pnSpace := h.getPacketNumberSpace(encLevel)
+	pnSpace.lossTime = 0
+
+	maxRTT := float64(max(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
+	lossDelay := time.Duration(timeThreshold * maxRTT)
+
+	// Minimum time of granularity before packets are deemed lost.
+	lossDelay = max(lossDelay, protocol.TimerGranularity)
+
+	// Packets sent before this time are deemed lost.
+	lostSendTime := now.Add(-lossDelay)
+
+	priorInFlight := h.bytesInFlight
+	for pn, p := range pnSpace.history.Packets() {
+		if pn > pnSpace.largestAcked {
+			break
+		}
+
+		var packetLost bool
+		if !p.SendTime.After(lostSendTime) {
+			packetLost = true
+			if !p.isPathProbePacket && p.IsAckEliciting() {
+				if h.logger.Debug() {
+					h.logger.Debugf("\tlost packet %d (time threshold)", pn)
+				}
+				if h.qlogger != nil {
+					h.qlogger.RecordEvent(qlog.PacketLost{
+						Header: qlog.PacketHeader{
+							PacketType:   qlog.EncryptionLevelToPacketType(p.EncryptionLevel),
+							PacketNumber: pn,
+						},
+						Trigger: qlog.PacketLossTimeThreshold,
+					})
+				}
+			}
+		} else if pnSpace.history.Difference(pnSpace.largestAcked, pn) >= packetThreshold {
+			packetLost = true
+			if !p.isPathProbePacket && p.IsAckEliciting() {
+				if h.logger.Debug() {
+					h.logger.Debugf("\tlost packet %d (reordering threshold)", pn)
+				}
+				if h.qlogger != nil {
+					h.qlogger.RecordEvent(qlog.PacketLost{
+						Header: qlog.PacketHeader{
+							PacketType:   qlog.EncryptionLevelToPacketType(p.EncryptionLevel),
+							PacketNumber: pn,
+						},
+						Trigger: qlog.PacketLossReorderingThreshold,
+					})
+				}
+			}
+		} else if pnSpace.lossTime.IsZero() {
+			// Note: This conditional is only entered once per call
+			lossTime := p.SendTime.Add(lossDelay)
+			if h.logger.Debug() {
+				h.logger.Debugf("\tsetting loss timer for packet %d (%s) to %s (in %s)", pn, encLevel, lossDelay, lossTime)
+			}
+			pnSpace.lossTime = lossTime
+		}
+		if packetLost {
+			if encLevel == protocol.Encryption0RTT || encLevel == protocol.Encryption1RTT {
+				h.lostPackets.Add(pn, p.SendTime)
+			}
+			pnSpace.history.DeclareLost(pn)
+			if !p.isPathProbePacket && p.IsAckEliciting() {
+				// the bytes in flight need to be reduced no matter if the frames in this packet will be retransmitted
+				h.removeFromBytesInFlight(p)
+				h.queueFramesForRetransmission(p)
+				if !p.IsPathMTUProbePacket {
+					h.congestion.OnCongestionEvent(pn, p.Length, priorInFlight)
+				}
+				if encLevel == protocol.Encryption1RTT && h.ecnTracker != nil {
+					h.ecnTracker.LostPacket(pn)
+				}
+			}
+		}
+	}
+}
+
+func (h *sentPacketHandler) OnLossDetectionTimeout(now monotime.Time) error {
+	defer h.setLossDetectionTimer(now)
+
+	if h.handshakeConfirmed {
+		h.detectLostPathProbes(now)
+	}
+
+	earliestLossTime, encLevel := h.getLossTimeAndSpace()
+	if !earliestLossTime.IsZero() {
+		if h.logger.Debug() {
+			h.logger.Debugf("Loss detection alarm fired in loss timer mode. Loss time: %s", earliestLossTime)
+		}
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.LossTimerUpdated{
+				Type:      qlog.LossTimerUpdateTypeExpired,
+				TimerType: qlog.TimerTypeACK,
+				EncLevel:  encLevel,
+			})
+		}
+		// Early retransmit or time loss detection
+		h.detectLostPackets(now, encLevel)
+		return nil
+	}
+
+	// PTO
+	// When all outstanding are acknowledged, the alarm is canceled in setLossDetectionTimer.
+	// However, there's no way to reset the timer in the connection.
+	// When OnLossDetectionTimeout is called, we therefore need to make sure that there are
+	// actually packets outstanding.
+	if h.bytesInFlight == 0 && !h.peerCompletedAddressValidation {
+		h.ptoCount++
+		h.numProbesToSend++
+		if h.initialPackets != nil {
+			h.ptoMode = SendPTOInitial
+		} else if h.handshakePackets != nil {
+			h.ptoMode = SendPTOHandshake
+		} else {
+			return errors.New("sentPacketHandler BUG: PTO fired, but bytes_in_flight is 0 and Initial and Handshake already dropped")
+		}
+		return nil
+	}
+
+	ptoTime, encLevel := h.getPTOTimeAndSpace(now)
+	if ptoTime.IsZero() {
+		return nil
+	}
+	ps := h.getPacketNumberSpace(encLevel)
+	if !ps.history.HasOutstandingPackets() && !ps.history.HasOutstandingPathProbes() && !h.peerCompletedAddressValidation {
+		return nil
+	}
+	h.ptoCount++
+	if h.logger.Debug() {
+		h.logger.Debugf("Loss detection alarm for %s fired in PTO mode. PTO count: %d", encLevel, h.ptoCount)
+	}
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.LossTimerUpdated{
+			Type:      qlog.LossTimerUpdateTypeExpired,
+			TimerType: qlog.TimerTypePTO,
+			EncLevel:  encLevel,
+		})
+		h.qlogger.RecordEvent(qlog.PTOCountUpdated{PTOCount: h.ptoCount})
+	}
+	h.numProbesToSend += 2
+	//nolint:exhaustive // We never arm a PTO timer for 0-RTT packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		h.ptoMode = SendPTOInitial
+	case protocol.EncryptionHandshake:
+		h.ptoMode = SendPTOHandshake
+	case protocol.Encryption1RTT:
+		// skip a packet number in order to elicit an immediate ACK
+		pn := h.PopPacketNumber(protocol.Encryption1RTT)
+		h.getPacketNumberSpace(protocol.Encryption1RTT).history.SkippedPacket(pn)
+		h.ptoMode = SendPTOAppData
+	default:
+		return fmt.Errorf("PTO timer in unexpected encryption level: %s", encLevel)
+	}
+	return nil
+}
+
+func (h *sentPacketHandler) GetLossDetectionTimeout() monotime.Time {
+	return h.alarm.Time
+}
+
+func (h *sentPacketHandler) ECNMode(isShortHeaderPacket bool) protocol.ECN {
+	if !h.enableECN {
+		return protocol.ECNUnsupported
+	}
+	if !isShortHeaderPacket {
+		return protocol.ECNNon
+	}
+	return h.ecnTracker.Mode()
+}
+
+func (h *sentPacketHandler) PeekPacketNumber(encLevel protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) {
+	pnSpace := h.getPacketNumberSpace(encLevel)
+	pn := pnSpace.pns.Peek()
+	// See section 17.1 of RFC 9000.
+	return pn, protocol.PacketNumberLengthForHeader(pn, pnSpace.largestAcked)
+}
+
+func (h *sentPacketHandler) PopPacketNumber(encLevel protocol.EncryptionLevel) protocol.PacketNumber {
+	pnSpace := h.getPacketNumberSpace(encLevel)
+	skipped, pn := pnSpace.pns.Pop()
+	if skipped {
+		skippedPN := pn - 1
+		pnSpace.history.SkippedPacket(skippedPN)
+		if h.logger.Debug() {
+			h.logger.Debugf("Skipping packet number %d", skippedPN)
+		}
+	}
+	return pn
+}
+
+func (h *sentPacketHandler) SendMode(now monotime.Time) SendMode {
+	numTrackedPackets := h.appDataPackets.history.Len()
+	if h.initialPackets != nil {
+		numTrackedPackets += h.initialPackets.history.Len()
+	}
+	if h.handshakePackets != nil {
+		numTrackedPackets += h.handshakePackets.history.Len()
+	}
+
+	if h.isAmplificationLimited() {
+		h.logger.Debugf("Amplification window limited. Received %d bytes, already sent out %d bytes", h.bytesReceived, h.bytesSent)
+		return SendNone
+	}
+	// Don't send any packets if we're keeping track of the maximum number of packets.
+	// Note that since MaxOutstandingSentPackets is smaller than MaxTrackedSentPackets,
+	// we will stop sending out new data when reaching MaxOutstandingSentPackets,
+	// but still allow sending of retransmissions and ACKs.
+	if numTrackedPackets >= protocol.MaxTrackedSentPackets {
+		if h.logger.Debug() {
+			h.logger.Debugf("Limited by the number of tracked packets: tracking %d packets, maximum %d", numTrackedPackets, protocol.MaxTrackedSentPackets)
+		}
+		return SendNone
+	}
+	if h.numProbesToSend > 0 {
+		return h.ptoMode
+	}
+	// Only send ACKs if we're congestion limited.
+	if !h.congestion.CanSend(h.bytesInFlight) {
+		if h.logger.Debug() {
+			h.logger.Debugf("Congestion limited: bytes in flight %d, window %d", h.bytesInFlight, h.congestion.GetCongestionWindow())
+		}
+		return SendAck
+	}
+	if numTrackedPackets >= protocol.MaxOutstandingSentPackets {
+		if h.logger.Debug() {
+			h.logger.Debugf("Max outstanding limited: tracking %d packets, maximum: %d", numTrackedPackets, protocol.MaxOutstandingSentPackets)
+		}
+		return SendAck
+	}
+	if !h.congestion.HasPacingBudget(now) {
+		return SendPacingLimited
+	}
+	return SendAny
+}
+
+func (h *sentPacketHandler) TimeUntilSend() monotime.Time {
+	return h.congestion.TimeUntilSend(h.bytesInFlight)
+}
+
+func (h *sentPacketHandler) SetMaxDatagramSize(s protocol.ByteCount) {
+	h.congestion.SetMaxDatagramSize(s)
+}
+
+func (h *sentPacketHandler) isAmplificationLimited() bool {
+	if h.peerAddressValidated {
+		return false
+	}
+	return h.bytesSent >= amplificationFactor*h.bytesReceived
+}
+
+func (h *sentPacketHandler) QueueProbePacket(encLevel protocol.EncryptionLevel) bool {
+	pnSpace := h.getPacketNumberSpace(encLevel)
+	pn, p := pnSpace.history.FirstOutstanding()
+	if p == nil {
+		return false
+	}
+	// TODO: don't declare the packet lost here.
+	// Keep track of acknowledged frames instead.
+	// Call DeclareLost before queueFramesForRetransmission, which clears the packet's frames.
+	pnSpace.history.DeclareLost(pn)
+	h.removeFromBytesInFlight(p)
+	h.queueFramesForRetransmission(p)
+	return true
+}
+
+func (h *sentPacketHandler) queueFramesForRetransmission(p *packet) {
+	if len(p.Frames) == 0 && len(p.StreamFrames) == 0 {
+		panic("no frames")
+	}
+	for _, f := range p.Frames {
+		if f.Handler != nil {
+			f.Handler.OnLost(f.Frame)
+		}
+	}
+	for _, f := range p.StreamFrames {
+		if f.Handler != nil {
+			f.Handler.OnLost(f.Frame)
+		}
+	}
+	p.StreamFrames = nil
+	p.Frames = nil
+}
+
+func (h *sentPacketHandler) ResetForRetry(now monotime.Time) {
+	h.bytesInFlight = 0
+	var firstPacketSendTime monotime.Time
+	for _, p := range h.initialPackets.history.Packets() {
+		if firstPacketSendTime.IsZero() {
+			firstPacketSendTime = p.SendTime
+		}
+		if p.IsAckEliciting() {
+			h.queueFramesForRetransmission(p)
+		}
+	}
+	// All application data packets sent at this point are 0-RTT packets.
+	// In the case of a Retry, we can assume that the server dropped all of them.
+	for _, p := range h.appDataPackets.history.Packets() {
+		if p.IsAckEliciting() {
+			h.queueFramesForRetransmission(p)
+		}
+	}
+
+	// Only use the Retry to estimate the RTT if we didn't send any retransmission for the Initial.
+	// Otherwise, we don't know which Initial the Retry was sent in response to.
+	if h.ptoCount == 0 {
+		// Don't set the RTT to a value lower than 5ms here.
+		h.rttStats.UpdateRTT(max(minRTTAfterRetry, now.Sub(firstPacketSendTime)), 0)
+		if h.logger.Debug() {
+			h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation())
+		}
+		if h.qlogger != nil {
+			h.qlogMetricsUpdated()
+		}
+	}
+	h.initialPackets = newPacketNumberSpace(h.initialPackets.pns.Peek(), false)
+	h.appDataPackets = newPacketNumberSpace(h.appDataPackets.pns.Peek(), true)
+	oldAlarm := h.alarm
+	h.alarm = alarmTimer{}
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.PTOCountUpdated{PTOCount: 0})
+		if !oldAlarm.Time.IsZero() {
+			h.qlogger.RecordEvent(qlog.LossTimerUpdated{
+				Type: qlog.LossTimerUpdateTypeCancelled,
+			})
+		}
+	}
+	h.ptoCount = 0
+}
+
+func (h *sentPacketHandler) MigratedPath(now monotime.Time, initialMaxDatagramSize protocol.ByteCount) {
+	h.rttStats.ResetForPathMigration()
+	for pn, p := range h.appDataPackets.history.Packets() {
+		h.appDataPackets.history.DeclareLost(pn)
+		if !p.isPathProbePacket {
+			h.removeFromBytesInFlight(p)
+			if p.IsAckEliciting() {
+				h.queueFramesForRetransmission(p)
+			}
+		}
+	}
+	for pn := range h.appDataPackets.history.PathProbes() {
+		h.appDataPackets.history.RemovePathProbe(pn)
+	}
+	h.congestion = congestion.NewCubicSender(
+		congestion.DefaultClock{},
+		h.rttStats,
+		h.connStats,
+		initialMaxDatagramSize,
+		true, // use Reno
+		h.qlogger,
+	)
+	h.setLossDetectionTimer(now)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_history.go b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_history.go
new file mode 100644
index 00000000..1500e1cd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/ackhandler/sent_packet_history.go
@@ -0,0 +1,274 @@
+package ackhandler
+
+import (
+	"fmt"
+	"iter"
+	"slices"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+const maxSkippedPackets = 4
+
+type sentPacketHistory struct {
+	packets          []*packet
+	pathProbePackets []packetWithPacketNumber
+	skippedPackets   []protocol.PacketNumber
+
+	numOutstanding int
+
+	firstPacketNumber   protocol.PacketNumber
+	highestPacketNumber protocol.PacketNumber
+}
+
+func newSentPacketHistory(isAppData bool) *sentPacketHistory {
+	h := &sentPacketHistory{
+		highestPacketNumber: protocol.InvalidPacketNumber,
+		firstPacketNumber:   protocol.InvalidPacketNumber,
+	}
+	if isAppData {
+		h.packets = make([]*packet, 0, 32)
+		h.skippedPackets = make([]protocol.PacketNumber, 0, maxSkippedPackets)
+	} else {
+		h.packets = make([]*packet, 0, 6)
+	}
+	return h
+}
+
+func (h *sentPacketHistory) checkSequentialPacketNumberUse(pn protocol.PacketNumber) {
+	if h.highestPacketNumber != protocol.InvalidPacketNumber {
+		if pn != h.highestPacketNumber+1 {
+			panic("non-sequential packet number use")
+		}
+	}
+	h.highestPacketNumber = pn
+	if len(h.packets) == 0 {
+		h.firstPacketNumber = pn
+	}
+}
+
+func (h *sentPacketHistory) SkippedPacket(pn protocol.PacketNumber) {
+	h.checkSequentialPacketNumberUse(pn)
+	if len(h.packets) > 0 {
+		h.packets = append(h.packets, nil)
+	}
+	if len(h.skippedPackets) == maxSkippedPackets {
+		h.skippedPackets = slices.Delete(h.skippedPackets, 0, 1)
+	}
+	h.skippedPackets = append(h.skippedPackets, pn)
+}
+
+func (h *sentPacketHistory) SentPacket(pn protocol.PacketNumber, p *packet) {
+	h.checkSequentialPacketNumberUse(pn)
+	h.packets = append(h.packets, p)
+	if p.Outstanding() {
+		h.numOutstanding++
+	}
+}
+
+func (h *sentPacketHistory) SentPathProbePacket(pn protocol.PacketNumber, p *packet) {
+	h.checkSequentialPacketNumberUse(pn)
+	h.packets = append(h.packets, &packet{isPathProbePacket: true})
+	h.pathProbePackets = append(h.pathProbePackets, packetWithPacketNumber{PacketNumber: pn, packet: p})
+}
+
+func (h *sentPacketHistory) Packets() iter.Seq2[protocol.PacketNumber, *packet] {
+	return func(yield func(protocol.PacketNumber, *packet) bool) {
+		// h.firstPacketNumber might be updated in the yield function,
+		// so we need to save it here.
+		firstPacketNumber := h.firstPacketNumber
+		for i, p := range h.packets {
+			if p == nil {
+				continue
+			}
+			if !yield(firstPacketNumber+protocol.PacketNumber(i), p) {
+				return
+			}
+		}
+	}
+}
+
+func (h *sentPacketHistory) PathProbes() iter.Seq2[protocol.PacketNumber, *packet] {
+	return func(yield func(protocol.PacketNumber, *packet) bool) {
+		for _, p := range h.pathProbePackets {
+			if !yield(p.PacketNumber, p.packet) {
+				return
+			}
+		}
+	}
+}
+
+// FirstOutstanding returns the first outstanding packet.
+func (h *sentPacketHistory) FirstOutstanding() (protocol.PacketNumber, *packet) {
+	if !h.HasOutstandingPackets() {
+		return protocol.InvalidPacketNumber, nil
+	}
+	for i, p := range h.packets {
+		if p != nil && p.Outstanding() {
+			return h.firstPacketNumber + protocol.PacketNumber(i), p
+		}
+	}
+	return protocol.InvalidPacketNumber, nil
+}
+
+// FirstOutstandingPathProbe returns the first outstanding path probe packet
+func (h *sentPacketHistory) FirstOutstandingPathProbe() (protocol.PacketNumber, *packet) {
+	if len(h.pathProbePackets) == 0 {
+		return protocol.InvalidPacketNumber, nil
+	}
+	return h.pathProbePackets[0].PacketNumber, h.pathProbePackets[0].packet
+}
+
+func (h *sentPacketHistory) SkippedPackets() iter.Seq[protocol.PacketNumber] {
+	return func(yield func(protocol.PacketNumber) bool) {
+		for _, p := range h.skippedPackets {
+			if !yield(p) {
+				return
+			}
+		}
+	}
+}
+
+func (h *sentPacketHistory) Len() int {
+	return len(h.packets)
+}
+
+func (h *sentPacketHistory) NumOutstanding() int {
+	return h.numOutstanding
+}
+
+// Remove removes a packet from the sent packet history.
+// It must not be used for skipped packet numbers.
+func (h *sentPacketHistory) Remove(pn protocol.PacketNumber) error {
+	idx, ok := h.getIndex(pn)
+	if !ok {
+		return fmt.Errorf("packet %d not found in sent packet history", pn)
+	}
+	p := h.packets[idx]
+	if p.Outstanding() {
+		h.numOutstanding--
+		if h.numOutstanding < 0 {
+			panic("negative number of outstanding packets")
+		}
+	}
+	h.packets[idx] = nil
+	// clean up all skipped packets directly before this packet number
+	var hasPacketBefore bool
+	for idx > 0 {
+		idx--
+		if h.packets[idx] != nil {
+			hasPacketBefore = true
+			break
+		}
+	}
+	if !hasPacketBefore {
+		h.cleanupStart()
+	}
+	if len(h.packets) > 0 && h.packets[0] == nil {
+		panic("cleanup failed")
+	}
+	return nil
+}
+
+// RemovePathProbe removes a path probe packet.
+// It scales O(N), but that's ok, since we don't expect to send many path probe packets.
+// It is not valid to call this function in IteratePathProbes.
+func (h *sentPacketHistory) RemovePathProbe(pn protocol.PacketNumber) *packet {
+	var packetToDelete *packet
+	idx := -1
+	for i, p := range h.pathProbePackets {
+		if p.PacketNumber == pn {
+			packetToDelete = p.packet
+			idx = i
+			break
+		}
+	}
+	if idx != -1 {
+		// don't use slices.Delete, because it zeros the deleted element
+		copy(h.pathProbePackets[idx:], h.pathProbePackets[idx+1:])
+		h.pathProbePackets = h.pathProbePackets[:len(h.pathProbePackets)-1]
+	}
+	return packetToDelete
+}
+
+// getIndex gets the index of packet p in the packets slice.
+func (h *sentPacketHistory) getIndex(p protocol.PacketNumber) (int, bool) {
+	if len(h.packets) == 0 {
+		return 0, false
+	}
+	if p < h.firstPacketNumber {
+		return 0, false
+	}
+	index := int(p - h.firstPacketNumber)
+	if index > len(h.packets)-1 {
+		return 0, false
+	}
+	return index, true
+}
+
+func (h *sentPacketHistory) HasOutstandingPackets() bool {
+	return h.numOutstanding > 0
+}
+
+func (h *sentPacketHistory) HasOutstandingPathProbes() bool {
+	return len(h.pathProbePackets) > 0
+}
+
+// delete all nil entries at the beginning of the packets slice
+func (h *sentPacketHistory) cleanupStart() {
+	for i, p := range h.packets {
+		if p != nil {
+			h.packets = h.packets[i:]
+			h.firstPacketNumber += protocol.PacketNumber(i)
+			return
+		}
+	}
+	h.packets = h.packets[:0]
+	h.firstPacketNumber = protocol.InvalidPacketNumber
+}
+
+func (h *sentPacketHistory) LowestPacketNumber() protocol.PacketNumber {
+	if len(h.packets) == 0 {
+		return protocol.InvalidPacketNumber
+	}
+	return h.firstPacketNumber
+}
+
+func (h *sentPacketHistory) DeclareLost(pn protocol.PacketNumber) {
+	idx, ok := h.getIndex(pn)
+	if !ok {
+		return
+	}
+	p := h.packets[idx]
+	if p.Outstanding() {
+		h.numOutstanding--
+		if h.numOutstanding < 0 {
+			panic("negative number of outstanding packets")
+		}
+	}
+	h.packets[idx] = nil
+	if idx == 0 {
+		h.cleanupStart()
+	}
+}
+
+// Difference returns the difference between two packet numbers a and b (a - b),
+// taking into account any skipped packet numbers between them.
+//
+// Note that old skipped packets are garbage collected at some point,
+// so this function is not guaranteed to return the correct result after a while.
+func (h *sentPacketHistory) Difference(a, b protocol.PacketNumber) protocol.PacketNumber {
+	diff := a - b
+	if len(h.skippedPackets) == 0 {
+		return diff
+	}
+	if a < h.skippedPackets[0] || b > h.skippedPackets[len(h.skippedPackets)-1] {
+		return diff
+	}
+	for _, p := range h.skippedPackets {
+		if p > b && p < a {
+			diff--
+		}
+	}
+	return diff
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/bandwidth.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/bandwidth.go
new file mode 100644
index 00000000..3ad827d2
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/bandwidth.go
@@ -0,0 +1,22 @@
+package congestion
+
+import (
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// Bandwidth of a connection
+type Bandwidth uint64
+
+const (
+	// BitsPerSecond is 1 bit per second
+	BitsPerSecond Bandwidth = 1
+	// BytesPerSecond is 1 byte per second
+	BytesPerSecond = 8 * BitsPerSecond
+)
+
+// BandwidthFromDelta calculates the bandwidth from a number of bytes and a time delta
+func BandwidthFromDelta(bytes protocol.ByteCount, delta time.Duration) Bandwidth {
+	return Bandwidth(bytes) * Bandwidth(time.Second) / Bandwidth(delta) * BytesPerSecond
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/clock.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/clock.go
new file mode 100644
index 00000000..8315026f
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/clock.go
@@ -0,0 +1,20 @@
+package congestion
+
+import (
+	"github.com/quic-go/quic-go/internal/monotime"
+)
+
+// A Clock returns the current time
+type Clock interface {
+	Now() monotime.Time
+}
+
+// DefaultClock implements the Clock interface using the Go stdlib clock.
+type DefaultClock struct{}
+
+var _ Clock = DefaultClock{}
+
+// Now gets the current time
+func (DefaultClock) Now() monotime.Time {
+	return monotime.Now()
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic.go
new file mode 100644
index 00000000..40655de6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic.go
@@ -0,0 +1,214 @@
+package congestion
+
+import (
+	"math"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// This cubic implementation is based on the one found in Chromiums's QUIC
+// implementation, in the files net/quic/congestion_control/cubic.{hh,cc}.
+
+// Constants based on TCP defaults.
+// The following constants are in 2^10 fractions of a second instead of ms to
+// allow a 10 shift right to divide.
+
+// 1024*1024^3 (first 1024 is from 0.100^3)
+// where 0.100 is 100 ms which is the scaling round trip time.
+const (
+	cubeScale                 = 40
+	cubeCongestionWindowScale = 410
+	cubeFactor                = 1 << cubeScale / cubeCongestionWindowScale / maxDatagramSize
+	// TODO: when re-enabling cubic, make sure to use the actual packet size here
+	maxDatagramSize = protocol.ByteCount(protocol.InitialPacketSize)
+)
+
+const defaultNumConnections = 1
+
+// Default Cubic backoff factor
+const beta float32 = 0.7
+
+// Additional backoff factor when loss occurs in the concave part of the Cubic
+// curve. This additional backoff factor is expected to give up bandwidth to
+// new concurrent flows and speed up convergence.
+const betaLastMax float32 = 0.85
+
+// Cubic implements the cubic algorithm from TCP
+type Cubic struct {
+	clock Clock
+
+	// Number of connections to simulate.
+	numConnections int
+
+	// Time when this cycle started, after last loss event.
+	epoch monotime.Time
+
+	// Max congestion window used just before last loss event.
+	// Note: to improve fairness to other streams an additional back off is
+	// applied to this value if the new value is below our latest value.
+	lastMaxCongestionWindow protocol.ByteCount
+
+	// Number of acked bytes since the cycle started (epoch).
+	ackedBytesCount protocol.ByteCount
+
+	// TCP Reno equivalent congestion window in packets.
+	estimatedTCPcongestionWindow protocol.ByteCount
+
+	// Origin point of cubic function.
+	originPointCongestionWindow protocol.ByteCount
+
+	// Time to origin point of cubic function in 2^10 fractions of a second.
+	timeToOriginPoint uint32
+
+	// Last congestion window in packets computed by cubic function.
+	lastTargetCongestionWindow protocol.ByteCount
+}
+
+// NewCubic returns a new Cubic instance
+func NewCubic(clock Clock) *Cubic {
+	c := &Cubic{
+		clock:          clock,
+		numConnections: defaultNumConnections,
+	}
+	c.Reset()
+	return c
+}
+
+// Reset is called after a timeout to reset the cubic state
+func (c *Cubic) Reset() {
+	c.epoch = 0
+	c.lastMaxCongestionWindow = 0
+	c.ackedBytesCount = 0
+	c.estimatedTCPcongestionWindow = 0
+	c.originPointCongestionWindow = 0
+	c.timeToOriginPoint = 0
+	c.lastTargetCongestionWindow = 0
+}
+
+func (c *Cubic) alpha() float32 {
+	// TCPFriendly alpha is described in Section 3.3 of the CUBIC paper. Note that
+	// beta here is a cwnd multiplier, and is equal to 1-beta from the paper.
+	// We derive the equivalent alpha for an N-connection emulation as:
+	b := c.beta()
+	return 3 * float32(c.numConnections) * float32(c.numConnections) * (1 - b) / (1 + b)
+}
+
+func (c *Cubic) beta() float32 {
+	// kNConnectionBeta is the backoff factor after loss for our N-connection
+	// emulation, which emulates the effective backoff of an ensemble of N
+	// TCP-Reno connections on a single loss event. The effective multiplier is
+	// computed as:
+	return (float32(c.numConnections) - 1 + beta) / float32(c.numConnections)
+}
+
+func (c *Cubic) betaLastMax() float32 {
+	// betaLastMax is the additional backoff factor after loss for our
+	// N-connection emulation, which emulates the additional backoff of
+	// an ensemble of N TCP-Reno connections on a single loss event. The
+	// effective multiplier is computed as:
+	return (float32(c.numConnections) - 1 + betaLastMax) / float32(c.numConnections)
+}
+
+// OnApplicationLimited is called on ack arrival when sender is unable to use
+// the available congestion window. Resets Cubic state during quiescence.
+func (c *Cubic) OnApplicationLimited() {
+	// When sender is not using the available congestion window, the window does
+	// not grow. But to be RTT-independent, Cubic assumes that the sender has been
+	// using the entire window during the time since the beginning of the current
+	// "epoch" (the end of the last loss recovery period). Since
+	// application-limited periods break this assumption, we reset the epoch when
+	// in such a period. This reset effectively freezes congestion window growth
+	// through application-limited periods and allows Cubic growth to continue
+	// when the entire window is being used.
+	c.epoch = 0
+}
+
+// CongestionWindowAfterPacketLoss computes a new congestion window to use after
+// a loss event. Returns the new congestion window in packets. The new
+// congestion window is a multiplicative decrease of our current window.
+func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount {
+	if currentCongestionWindow+maxDatagramSize < c.lastMaxCongestionWindow {
+		// We never reached the old max, so assume we are competing with another
+		// flow. Use our extra back off factor to allow the other flow to go up.
+		c.lastMaxCongestionWindow = protocol.ByteCount(c.betaLastMax() * float32(currentCongestionWindow))
+	} else {
+		c.lastMaxCongestionWindow = currentCongestionWindow
+	}
+	c.epoch = 0 // Reset time.
+	return protocol.ByteCount(float32(currentCongestionWindow) * c.beta())
+}
+
+// CongestionWindowAfterAck computes a new congestion window to use after a received ACK.
+// Returns the new congestion window in packets. The new congestion window
+// follows a cubic function that depends on the time passed since last
+// packet loss.
+func (c *Cubic) CongestionWindowAfterAck(
+	ackedBytes protocol.ByteCount,
+	currentCongestionWindow protocol.ByteCount,
+	delayMin time.Duration,
+	eventTime monotime.Time,
+) protocol.ByteCount {
+	c.ackedBytesCount += ackedBytes
+
+	if c.epoch.IsZero() {
+		// First ACK after a loss event.
+		c.epoch = eventTime            // Start of epoch.
+		c.ackedBytesCount = ackedBytes // Reset count.
+		// Reset estimated_tcp_congestion_window_ to be in sync with cubic.
+		c.estimatedTCPcongestionWindow = currentCongestionWindow
+		if c.lastMaxCongestionWindow <= currentCongestionWindow {
+			c.timeToOriginPoint = 0
+			c.originPointCongestionWindow = currentCongestionWindow
+		} else {
+			c.timeToOriginPoint = uint32(math.Cbrt(float64(cubeFactor * (c.lastMaxCongestionWindow - currentCongestionWindow))))
+			c.originPointCongestionWindow = c.lastMaxCongestionWindow
+		}
+	}
+
+	// Change the time unit from microseconds to 2^10 fractions per second. Take
+	// the round trip time in account. This is done to allow us to use shift as a
+	// divide operator.
+	elapsedTime := int64(eventTime.Add(delayMin).Sub(c.epoch)/time.Microsecond) << 10 / (1000 * 1000)
+
+	// Right-shifts of negative, signed numbers have implementation-dependent
+	// behavior, so force the offset to be positive, as is done in the kernel.
+	offset := int64(c.timeToOriginPoint) - elapsedTime
+	if offset < 0 {
+		offset = -offset
+	}
+
+	deltaCongestionWindow := protocol.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * maxDatagramSize >> cubeScale
+	var targetCongestionWindow protocol.ByteCount
+	if elapsedTime > int64(c.timeToOriginPoint) {
+		targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow
+	} else {
+		targetCongestionWindow = c.originPointCongestionWindow - deltaCongestionWindow
+	}
+	// Limit the CWND increase to half the acked bytes.
+	targetCongestionWindow = min(targetCongestionWindow, currentCongestionWindow+c.ackedBytesCount/2)
+
+	// Increase the window by approximately Alpha * 1 MSS of bytes every
+	// time we ack an estimated tcp window of bytes.  For small
+	// congestion windows (less than 25), the formula below will
+	// increase slightly slower than linearly per estimated tcp window
+	// of bytes.
+	c.estimatedTCPcongestionWindow += protocol.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(maxDatagramSize) / float32(c.estimatedTCPcongestionWindow))
+	c.ackedBytesCount = 0
+
+	// We have a new cubic congestion window.
+	c.lastTargetCongestionWindow = targetCongestionWindow
+
+	// Compute target congestion_window based on cubic target and estimated TCP
+	// congestion_window, use highest (fastest).
+	if targetCongestionWindow < c.estimatedTCPcongestionWindow {
+		targetCongestionWindow = c.estimatedTCPcongestionWindow
+	}
+	return targetCongestionWindow
+}
+
+// SetNumConnections sets the number of emulated connections
+func (c *Cubic) SetNumConnections(n int) {
+	c.numConnections = n
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic_sender.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic_sender.go
new file mode 100644
index 00000000..e5457ddb
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/cubic_sender.go
@@ -0,0 +1,330 @@
+package congestion
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+const (
+	// maxDatagramSize is the default maximum packet size used in the Linux TCP implementation.
+	// Used in QUIC for congestion window computations in bytes.
+	initialMaxDatagramSize     = protocol.ByteCount(protocol.InitialPacketSize)
+	maxBurstPackets            = 3
+	renoBeta                   = 0.7 // Reno backoff factor.
+	minCongestionWindowPackets = 2
+	initialCongestionWindow    = 32
+)
+
+type cubicSender struct {
+	hybridSlowStart HybridSlowStart
+	rttStats        *utils.RTTStats
+	connStats       *utils.ConnectionStats
+	cubic           *Cubic
+	pacer           *pacer
+	clock           Clock
+
+	reno bool
+
+	// Track the largest packet that has been sent.
+	largestSentPacketNumber protocol.PacketNumber
+
+	// Track the largest packet that has been acked.
+	largestAckedPacketNumber protocol.PacketNumber
+
+	// Track the largest packet number outstanding when a CWND cutback occurs.
+	largestSentAtLastCutback protocol.PacketNumber
+
+	// Whether the last loss event caused us to exit slowstart.
+	// Used for stats collection of slowstartPacketsLost
+	lastCutbackExitedSlowstart bool
+
+	// Congestion window in bytes.
+	congestionWindow protocol.ByteCount
+
+	// Slow start congestion window in bytes, aka ssthresh.
+	slowStartThreshold protocol.ByteCount
+
+	// ACK counter for the Reno implementation.
+	numAckedPackets uint64
+
+	initialCongestionWindow    protocol.ByteCount
+	initialMaxCongestionWindow protocol.ByteCount
+
+	maxDatagramSize protocol.ByteCount
+
+	lastState qlog.CongestionState
+	qlogger   qlogwriter.Recorder
+}
+
+var (
+	_ SendAlgorithm               = &cubicSender{}
+	_ SendAlgorithmWithDebugInfos = &cubicSender{}
+)
+
+// NewCubicSender makes a new cubic sender
+func NewCubicSender(
+	clock Clock,
+	rttStats *utils.RTTStats,
+	connStats *utils.ConnectionStats,
+	initialMaxDatagramSize protocol.ByteCount,
+	reno bool,
+	qlogger qlogwriter.Recorder,
+) *cubicSender {
+	return newCubicSender(
+		clock,
+		rttStats,
+		connStats,
+		reno,
+		initialMaxDatagramSize,
+		initialCongestionWindow*initialMaxDatagramSize,
+		protocol.MaxCongestionWindowPackets*initialMaxDatagramSize,
+		qlogger,
+	)
+}
+
+func newCubicSender(
+	clock Clock,
+	rttStats *utils.RTTStats,
+	connStats *utils.ConnectionStats,
+	reno bool,
+	initialMaxDatagramSize,
+	initialCongestionWindow,
+	initialMaxCongestionWindow protocol.ByteCount,
+	qlogger qlogwriter.Recorder,
+) *cubicSender {
+	c := &cubicSender{
+		rttStats:                   rttStats,
+		connStats:                  connStats,
+		largestSentPacketNumber:    protocol.InvalidPacketNumber,
+		largestAckedPacketNumber:   protocol.InvalidPacketNumber,
+		largestSentAtLastCutback:   protocol.InvalidPacketNumber,
+		initialCongestionWindow:    initialCongestionWindow,
+		initialMaxCongestionWindow: initialMaxCongestionWindow,
+		congestionWindow:           initialCongestionWindow,
+		slowStartThreshold:         protocol.MaxByteCount,
+		cubic:                      NewCubic(clock),
+		clock:                      clock,
+		reno:                       reno,
+		qlogger:                    qlogger,
+		maxDatagramSize:            initialMaxDatagramSize,
+	}
+	c.pacer = newPacer(c.BandwidthEstimate)
+	if c.qlogger != nil {
+		c.lastState = qlog.CongestionStateSlowStart
+		c.qlogger.RecordEvent(qlog.CongestionStateUpdated{
+			State: qlog.CongestionStateSlowStart,
+		})
+	}
+	return c
+}
+
+// TimeUntilSend returns when the next packet should be sent.
+func (c *cubicSender) TimeUntilSend(_ protocol.ByteCount) monotime.Time {
+	return c.pacer.TimeUntilSend()
+}
+
+func (c *cubicSender) HasPacingBudget(now monotime.Time) bool {
+	return c.pacer.Budget(now) >= c.maxDatagramSize
+}
+
+func (c *cubicSender) maxCongestionWindow() protocol.ByteCount {
+	return c.maxDatagramSize * protocol.MaxCongestionWindowPackets
+}
+
+func (c *cubicSender) minCongestionWindow() protocol.ByteCount {
+	return c.maxDatagramSize * minCongestionWindowPackets
+}
+
+func (c *cubicSender) OnPacketSent(
+	sentTime monotime.Time,
+	_ protocol.ByteCount,
+	packetNumber protocol.PacketNumber,
+	bytes protocol.ByteCount,
+	isRetransmittable bool,
+) {
+	c.pacer.SentPacket(sentTime, bytes)
+	if !isRetransmittable {
+		return
+	}
+	c.largestSentPacketNumber = packetNumber
+	c.hybridSlowStart.OnPacketSent(packetNumber)
+}
+
+func (c *cubicSender) CanSend(bytesInFlight protocol.ByteCount) bool {
+	return bytesInFlight < c.GetCongestionWindow()
+}
+
+func (c *cubicSender) InRecovery() bool {
+	return c.largestAckedPacketNumber != protocol.InvalidPacketNumber && c.largestAckedPacketNumber <= c.largestSentAtLastCutback
+}
+
+func (c *cubicSender) InSlowStart() bool {
+	return c.GetCongestionWindow() < c.slowStartThreshold
+}
+
+func (c *cubicSender) GetCongestionWindow() protocol.ByteCount {
+	return c.congestionWindow
+}
+
+func (c *cubicSender) MaybeExitSlowStart() {
+	if c.InSlowStart() &&
+		c.hybridSlowStart.ShouldExitSlowStart(c.rttStats.LatestRTT(), c.rttStats.MinRTT(), c.GetCongestionWindow()/c.maxDatagramSize) {
+		// exit slow start
+		c.slowStartThreshold = c.congestionWindow
+		c.maybeQlogStateChange(qlog.CongestionStateCongestionAvoidance)
+	}
+}
+
+func (c *cubicSender) OnPacketAcked(
+	ackedPacketNumber protocol.PacketNumber,
+	ackedBytes protocol.ByteCount,
+	priorInFlight protocol.ByteCount,
+	eventTime monotime.Time,
+) {
+	c.largestAckedPacketNumber = max(ackedPacketNumber, c.largestAckedPacketNumber)
+	if c.InRecovery() {
+		return
+	}
+	c.maybeIncreaseCwnd(ackedPacketNumber, ackedBytes, priorInFlight, eventTime)
+	if c.InSlowStart() {
+		c.hybridSlowStart.OnPacketAcked(ackedPacketNumber)
+	}
+}
+
+func (c *cubicSender) OnCongestionEvent(packetNumber protocol.PacketNumber, lostBytes, priorInFlight protocol.ByteCount) {
+	c.connStats.PacketsLost.Add(1)
+	c.connStats.BytesLost.Add(uint64(lostBytes))
+
+	// TCP NewReno (RFC6582) says that once a loss occurs, any losses in packets
+	// already sent should be treated as a single loss event, since it's expected.
+	if packetNumber <= c.largestSentAtLastCutback {
+		return
+	}
+	c.lastCutbackExitedSlowstart = c.InSlowStart()
+	c.maybeQlogStateChange(qlog.CongestionStateRecovery)
+
+	if c.reno {
+		c.congestionWindow = protocol.ByteCount(float64(c.congestionWindow) * renoBeta)
+	} else {
+		c.congestionWindow = c.cubic.CongestionWindowAfterPacketLoss(c.congestionWindow)
+	}
+	if minCwnd := c.minCongestionWindow(); c.congestionWindow < minCwnd {
+		c.congestionWindow = minCwnd
+	}
+	c.slowStartThreshold = c.congestionWindow
+	c.largestSentAtLastCutback = c.largestSentPacketNumber
+	// reset packet count from congestion avoidance mode. We start
+	// counting again when we're out of recovery.
+	c.numAckedPackets = 0
+}
+
+// Called when we receive an ack. Normal TCP tracks how many packets one ack
+// represents, but quic has a separate ack for each packet.
+func (c *cubicSender) maybeIncreaseCwnd(
+	_ protocol.PacketNumber,
+	ackedBytes protocol.ByteCount,
+	priorInFlight protocol.ByteCount,
+	eventTime monotime.Time,
+) {
+	// Do not increase the congestion window unless the sender is close to using
+	// the current window.
+	if !c.isCwndLimited(priorInFlight) {
+		c.cubic.OnApplicationLimited()
+		c.maybeQlogStateChange(qlog.CongestionStateApplicationLimited)
+		return
+	}
+	if c.congestionWindow >= c.maxCongestionWindow() {
+		return
+	}
+	if c.InSlowStart() {
+		// TCP slow start, exponential growth, increase by one for each ACK.
+		c.congestionWindow += c.maxDatagramSize
+		c.maybeQlogStateChange(qlog.CongestionStateSlowStart)
+		return
+	}
+	// Congestion avoidance
+	c.maybeQlogStateChange(qlog.CongestionStateCongestionAvoidance)
+	if c.reno {
+		// Classic Reno congestion avoidance.
+		c.numAckedPackets++
+		if c.numAckedPackets >= uint64(c.congestionWindow/c.maxDatagramSize) {
+			c.congestionWindow += c.maxDatagramSize
+			c.numAckedPackets = 0
+		}
+	} else {
+		c.congestionWindow = min(
+			c.maxCongestionWindow(),
+			c.cubic.CongestionWindowAfterAck(ackedBytes, c.congestionWindow, c.rttStats.MinRTT(), eventTime),
+		)
+	}
+}
+
+func (c *cubicSender) isCwndLimited(bytesInFlight protocol.ByteCount) bool {
+	congestionWindow := c.GetCongestionWindow()
+	if bytesInFlight >= congestionWindow {
+		return true
+	}
+	availableBytes := congestionWindow - bytesInFlight
+	slowStartLimited := c.InSlowStart() && bytesInFlight > congestionWindow/2
+	return slowStartLimited || availableBytes <= maxBurstPackets*c.maxDatagramSize
+}
+
+// BandwidthEstimate returns the current bandwidth estimate
+func (c *cubicSender) BandwidthEstimate() Bandwidth {
+	srtt := c.rttStats.SmoothedRTT()
+	if srtt == 0 {
+		// This should never happen, but if it does, avoid division by zero.
+		srtt = protocol.TimerGranularity
+	}
+	return BandwidthFromDelta(c.GetCongestionWindow(), srtt)
+}
+
+// OnRetransmissionTimeout is called on an retransmission timeout
+func (c *cubicSender) OnRetransmissionTimeout(packetsRetransmitted bool) {
+	c.largestSentAtLastCutback = protocol.InvalidPacketNumber
+	if !packetsRetransmitted {
+		return
+	}
+	c.hybridSlowStart.Restart()
+	c.cubic.Reset()
+	c.slowStartThreshold = c.congestionWindow / 2
+	c.congestionWindow = c.minCongestionWindow()
+}
+
+// OnConnectionMigration is called when the connection is migrated (?)
+func (c *cubicSender) OnConnectionMigration() {
+	c.hybridSlowStart.Restart()
+	c.largestSentPacketNumber = protocol.InvalidPacketNumber
+	c.largestAckedPacketNumber = protocol.InvalidPacketNumber
+	c.largestSentAtLastCutback = protocol.InvalidPacketNumber
+	c.lastCutbackExitedSlowstart = false
+	c.cubic.Reset()
+	c.numAckedPackets = 0
+	c.congestionWindow = c.initialCongestionWindow
+	c.slowStartThreshold = c.initialMaxCongestionWindow
+}
+
+func (c *cubicSender) maybeQlogStateChange(new qlog.CongestionState) {
+	if c.qlogger == nil || new == c.lastState {
+		return
+	}
+	c.qlogger.RecordEvent(qlog.CongestionStateUpdated{State: new})
+	c.lastState = new
+}
+
+func (c *cubicSender) SetMaxDatagramSize(s protocol.ByteCount) {
+	if s < c.maxDatagramSize {
+		panic(fmt.Sprintf("congestion BUG: decreased max datagram size from %d to %d", c.maxDatagramSize, s))
+	}
+	cwndIsMinCwnd := c.congestionWindow == c.minCongestionWindow()
+	c.maxDatagramSize = s
+	if cwndIsMinCwnd {
+		c.congestionWindow = c.minCongestionWindow()
+	}
+	c.pacer.SetMaxDatagramSize(s)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/hybrid_slow_start.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/hybrid_slow_start.go
new file mode 100644
index 00000000..9679d9e4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/hybrid_slow_start.go
@@ -0,0 +1,112 @@
+package congestion
+
+import (
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// Note(pwestin): the magic clamping numbers come from the original code in
+// tcp_cubic.c.
+const hybridStartLowWindow = protocol.ByteCount(16)
+
+// Number of delay samples for detecting the increase of delay.
+const hybridStartMinSamples = uint32(8)
+
+// Exit slow start if the min rtt has increased by more than 1/8th.
+const hybridStartDelayFactorExp = 3 // 2^3 = 8
+// The original paper specifies 2 and 8ms, but those have changed over time.
+const (
+	hybridStartDelayMinThresholdUs = int64(4000)
+	hybridStartDelayMaxThresholdUs = int64(16000)
+)
+
+// HybridSlowStart implements the TCP hybrid slow start algorithm
+type HybridSlowStart struct {
+	endPacketNumber      protocol.PacketNumber
+	lastSentPacketNumber protocol.PacketNumber
+	started              bool
+	currentMinRTT        time.Duration
+	rttSampleCount       uint32
+	hystartFound         bool
+}
+
+// StartReceiveRound is called for the start of each receive round (burst) in the slow start phase.
+func (s *HybridSlowStart) StartReceiveRound(lastSent protocol.PacketNumber) {
+	s.endPacketNumber = lastSent
+	s.currentMinRTT = 0
+	s.rttSampleCount = 0
+	s.started = true
+}
+
+// IsEndOfRound returns true if this ack is the last packet number of our current slow start round.
+func (s *HybridSlowStart) IsEndOfRound(ack protocol.PacketNumber) bool {
+	return s.endPacketNumber < ack
+}
+
+// ShouldExitSlowStart should be called on every new ack frame, since a new
+// RTT measurement can be made then.
+// rtt: the RTT for this ack packet.
+// minRTT: is the lowest delay (RTT) we have seen during the session.
+// congestionWindow: the congestion window in packets.
+func (s *HybridSlowStart) ShouldExitSlowStart(latestRTT time.Duration, minRTT time.Duration, congestionWindow protocol.ByteCount) bool {
+	if !s.started {
+		// Time to start the hybrid slow start.
+		s.StartReceiveRound(s.lastSentPacketNumber)
+	}
+	if s.hystartFound {
+		return true
+	}
+	// Second detection parameter - delay increase detection.
+	// Compare the minimum delay (s.currentMinRTT) of the current
+	// burst of packets relative to the minimum delay during the session.
+	// Note: we only look at the first few(8) packets in each burst, since we
+	// only want to compare the lowest RTT of the burst relative to previous
+	// bursts.
+	s.rttSampleCount++
+	if s.rttSampleCount <= hybridStartMinSamples {
+		if s.currentMinRTT == 0 || s.currentMinRTT > latestRTT {
+			s.currentMinRTT = latestRTT
+		}
+	}
+	// We only need to check this once per round.
+	if s.rttSampleCount == hybridStartMinSamples {
+		// Divide minRTT by 8 to get a rtt increase threshold for exiting.
+		minRTTincreaseThresholdUs := int64(minRTT / time.Microsecond >> hybridStartDelayFactorExp)
+		// Ensure the rtt threshold is never less than 2ms or more than 16ms.
+		minRTTincreaseThresholdUs = min(minRTTincreaseThresholdUs, hybridStartDelayMaxThresholdUs)
+		minRTTincreaseThreshold := time.Duration(max(minRTTincreaseThresholdUs, hybridStartDelayMinThresholdUs)) * time.Microsecond
+
+		if s.currentMinRTT > (minRTT + minRTTincreaseThreshold) {
+			s.hystartFound = true
+		}
+	}
+	// Exit from slow start if the cwnd is greater than 16 and
+	// increasing delay is found.
+	return congestionWindow >= hybridStartLowWindow && s.hystartFound
+}
+
+// OnPacketSent is called when a packet was sent
+func (s *HybridSlowStart) OnPacketSent(packetNumber protocol.PacketNumber) {
+	s.lastSentPacketNumber = packetNumber
+}
+
+// OnPacketAcked gets invoked after ShouldExitSlowStart, so it's best to end
+// the round when the final packet of the burst is received and start it on
+// the next incoming ack.
+func (s *HybridSlowStart) OnPacketAcked(ackedPacketNumber protocol.PacketNumber) {
+	if s.IsEndOfRound(ackedPacketNumber) {
+		s.started = false
+	}
+}
+
+// Started returns true if started
+func (s *HybridSlowStart) Started() bool {
+	return s.started
+}
+
+// Restart the slow start phase
+func (s *HybridSlowStart) Restart() {
+	s.started = false
+	s.hystartFound = false
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/interface.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/interface.go
new file mode 100644
index 00000000..996907c6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/interface.go
@@ -0,0 +1,27 @@
+package congestion
+
+import (
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A SendAlgorithm performs congestion control
+type SendAlgorithm interface {
+	TimeUntilSend(bytesInFlight protocol.ByteCount) monotime.Time
+	HasPacingBudget(now monotime.Time) bool
+	OnPacketSent(sentTime monotime.Time, bytesInFlight protocol.ByteCount, packetNumber protocol.PacketNumber, bytes protocol.ByteCount, isRetransmittable bool)
+	CanSend(bytesInFlight protocol.ByteCount) bool
+	MaybeExitSlowStart()
+	OnPacketAcked(number protocol.PacketNumber, ackedBytes protocol.ByteCount, priorInFlight protocol.ByteCount, eventTime monotime.Time)
+	OnCongestionEvent(number protocol.PacketNumber, lostBytes protocol.ByteCount, priorInFlight protocol.ByteCount)
+	OnRetransmissionTimeout(packetsRetransmitted bool)
+	SetMaxDatagramSize(protocol.ByteCount)
+}
+
+// A SendAlgorithmWithDebugInfos is a SendAlgorithm that exposes some debug infos
+type SendAlgorithmWithDebugInfos interface {
+	SendAlgorithm
+	InSlowStart() bool
+	InRecovery() bool
+	GetCongestionWindow() protocol.ByteCount
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/congestion/pacer.go b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/pacer.go
new file mode 100644
index 00000000..7656f529
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/congestion/pacer.go
@@ -0,0 +1,110 @@
+package congestion
+
+import (
+	"math"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+const maxBurstSizePackets = 10
+
+// The pacer implements a token bucket pacing algorithm.
+type pacer struct {
+	budgetAtLastSent  protocol.ByteCount
+	maxDatagramSize   protocol.ByteCount
+	lastSentTime      monotime.Time
+	adjustedBandwidth func() uint64 // in bytes/s
+}
+
+func newPacer(getBandwidth func() Bandwidth) *pacer {
+	p := &pacer{
+		maxDatagramSize: initialMaxDatagramSize,
+		adjustedBandwidth: func() uint64 {
+			// Bandwidth is in bits/s. We need the value in bytes/s.
+			bw := uint64(getBandwidth() / BytesPerSecond)
+			// Use a slightly higher value than the actual measured bandwidth.
+			// RTT variations then won't result in under-utilization of the congestion window.
+			// Ultimately, this will result in sending packets as acknowledgments are received rather than when timers fire,
+			// provided the congestion window is fully utilized and acknowledgments arrive at regular intervals.
+			return bw * 5 / 4
+		},
+	}
+	p.budgetAtLastSent = p.maxBurstSize()
+	return p
+}
+
+func (p *pacer) SentPacket(sendTime monotime.Time, size protocol.ByteCount) {
+	budget := p.Budget(sendTime)
+	if size >= budget {
+		p.budgetAtLastSent = 0
+	} else {
+		p.budgetAtLastSent = budget - size
+	}
+	p.lastSentTime = sendTime
+}
+
+func (p *pacer) Budget(now monotime.Time) protocol.ByteCount {
+	if p.lastSentTime.IsZero() {
+		return p.maxBurstSize()
+	}
+	delta := now.Sub(p.lastSentTime)
+	var added protocol.ByteCount
+	if delta > 0 {
+		added = p.timeScaledBandwidth(uint64(delta.Nanoseconds()))
+	}
+	budget := p.budgetAtLastSent + added
+	if added > 0 && budget < p.budgetAtLastSent {
+		budget = protocol.MaxByteCount
+	}
+	return min(p.maxBurstSize(), budget)
+}
+
+func (p *pacer) maxBurstSize() protocol.ByteCount {
+	return max(
+		p.timeScaledBandwidth(uint64((protocol.MinPacingDelay + protocol.TimerGranularity).Nanoseconds())),
+		maxBurstSizePackets*p.maxDatagramSize,
+	)
+}
+
+// timeScaledBandwidth calculates the number of bytes that may be sent within
+// a given time interval (ns nanoseconds), based on the current bandwidth estimate.
+// It caps the scaled value to the maximum allowed burst and handles overflows.
+func (p *pacer) timeScaledBandwidth(ns uint64) protocol.ByteCount {
+	bw := p.adjustedBandwidth()
+	if bw == 0 {
+		return 0
+	}
+	const nsPerSecond = 1e9
+	maxBurst := maxBurstSizePackets * p.maxDatagramSize
+	var scaled protocol.ByteCount
+	if ns > math.MaxUint64/bw {
+		scaled = maxBurst
+	} else {
+		scaled = protocol.ByteCount(bw * ns / nsPerSecond)
+	}
+	return scaled
+}
+
+// TimeUntilSend returns when the next packet should be sent.
+// It returns zero if a packet can be sent immediately.
+func (p *pacer) TimeUntilSend() monotime.Time {
+	if p.budgetAtLastSent >= p.maxDatagramSize {
+		return 0
+	}
+	diff := 1e9 * uint64(p.maxDatagramSize-p.budgetAtLastSent)
+	bw := p.adjustedBandwidth()
+	// We might need to round up this value.
+	// Otherwise, we might have a budget (slightly) smaller than the datagram size when the timer expires.
+	d := diff / bw
+	// this is effectively a math.Ceil, but using only integer math
+	if diff%bw > 0 {
+		d++
+	}
+	return p.lastSentTime.Add(max(protocol.MinPacingDelay, time.Duration(d)*time.Nanosecond))
+}
+
+func (p *pacer) SetMaxDatagramSize(s protocol.ByteCount) {
+	p.maxDatagramSize = s
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/aead.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/aead.go
new file mode 100644
index 00000000..f12c932a
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/aead.go
@@ -0,0 +1,91 @@
+package handshake
+
+import (
+	"crypto/cipher"
+	"encoding/binary"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+func createAEAD(suite cipherSuite, trafficSecret []byte, v protocol.Version) cipher.AEAD {
+	keyLabel := hkdfLabelKeyV1
+	ivLabel := hkdfLabelIVV1
+	if v == protocol.Version2 {
+		keyLabel = hkdfLabelKeyV2
+		ivLabel = hkdfLabelIVV2
+	}
+	key := hkdfExpandLabel(suite.Hash, trafficSecret, []byte{}, keyLabel, suite.KeyLen)
+	iv := hkdfExpandLabel(suite.Hash, trafficSecret, []byte{}, ivLabel, suite.IVLen())
+	return suite.AEAD(key, iv)
+}
+
+type longHeaderSealer struct {
+	aead            cipher.AEAD
+	headerProtector headerProtector
+	nonceBuf        [8]byte
+}
+
+var _ LongHeaderSealer = &longHeaderSealer{}
+
+func newLongHeaderSealer(aead cipher.AEAD, headerProtector headerProtector) LongHeaderSealer {
+	if aead.NonceSize() != 8 {
+		panic("unexpected nonce size")
+	}
+	return &longHeaderSealer{
+		aead:            aead,
+		headerProtector: headerProtector,
+	}
+}
+
+func (s *longHeaderSealer) Seal(dst, src []byte, pn protocol.PacketNumber, ad []byte) []byte {
+	binary.BigEndian.PutUint64(s.nonceBuf[:], uint64(pn))
+	return s.aead.Seal(dst, s.nonceBuf[:], src, ad)
+}
+
+func (s *longHeaderSealer) EncryptHeader(sample []byte, firstByte *byte, pnBytes []byte) {
+	s.headerProtector.EncryptHeader(sample, firstByte, pnBytes)
+}
+
+func (s *longHeaderSealer) Overhead() int {
+	return s.aead.Overhead()
+}
+
+type longHeaderOpener struct {
+	aead            cipher.AEAD
+	headerProtector headerProtector
+	highestRcvdPN   protocol.PacketNumber // highest packet number received (which could be successfully unprotected)
+
+	// use a single array to avoid allocations
+	nonceBuf [8]byte
+}
+
+var _ LongHeaderOpener = &longHeaderOpener{}
+
+func newLongHeaderOpener(aead cipher.AEAD, headerProtector headerProtector) LongHeaderOpener {
+	if aead.NonceSize() != 8 {
+		panic("unexpected nonce size")
+	}
+	return &longHeaderOpener{
+		aead:            aead,
+		headerProtector: headerProtector,
+	}
+}
+
+func (o *longHeaderOpener) DecodePacketNumber(wirePN protocol.PacketNumber, wirePNLen protocol.PacketNumberLen) protocol.PacketNumber {
+	return protocol.DecodePacketNumber(wirePNLen, o.highestRcvdPN, wirePN)
+}
+
+func (o *longHeaderOpener) Open(dst, src []byte, pn protocol.PacketNumber, ad []byte) ([]byte, error) {
+	binary.BigEndian.PutUint64(o.nonceBuf[:], uint64(pn))
+	dec, err := o.aead.Open(dst, o.nonceBuf[:], src, ad)
+	if err == nil {
+		o.highestRcvdPN = max(o.highestRcvdPN, pn)
+	} else {
+		err = ErrDecryptionFailed
+	}
+	return dec, err
+}
+
+func (o *longHeaderOpener) DecryptHeader(sample []byte, firstByte *byte, pnBytes []byte) {
+	o.headerProtector.DecryptHeader(sample, firstByte, pnBytes)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite.go
new file mode 100644
index 00000000..98112a81
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite.go
@@ -0,0 +1,114 @@
+package handshake
+
+import (
+	"crypto"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/fips140"
+	"crypto/tls"
+	"fmt"
+
+	"golang.org/x/crypto/chacha20poly1305"
+)
+
+// These cipher suite implementations are copied from the standard library crypto/tls package.
+
+const aeadNonceLength = 12
+
+type cipherSuite struct {
+	ID     uint16
+	Hash   crypto.Hash
+	KeyLen int
+	AEAD   func(key, nonceMask []byte) cipher.AEAD
+}
+
+func (s cipherSuite) IVLen() int { return aeadNonceLength }
+
+func getCipherSuite(id uint16) cipherSuite {
+	switch id {
+	case tls.TLS_AES_128_GCM_SHA256:
+		return cipherSuite{ID: tls.TLS_AES_128_GCM_SHA256, Hash: crypto.SHA256, KeyLen: 16, AEAD: aeadAESGCMTLS13}
+	case tls.TLS_CHACHA20_POLY1305_SHA256:
+		// The usual convention is to only panic on fips140.Enforced (and not on fips140.Enabled),
+		// but this function panics in the default case anyway, so we might as well panic here.
+		if fips140.Enabled() {
+			panic("tls: TLS_CHACHA20_POLY1305_SHA256 is not allowed in FIPS 140-3 mode")
+		}
+		return cipherSuite{ID: tls.TLS_CHACHA20_POLY1305_SHA256, Hash: crypto.SHA256, KeyLen: 32, AEAD: aeadChaCha20Poly1305}
+	case tls.TLS_AES_256_GCM_SHA384:
+		return cipherSuite{ID: tls.TLS_AES_256_GCM_SHA384, Hash: crypto.SHA384, KeyLen: 32, AEAD: aeadAESGCMTLS13}
+	default:
+		panic(fmt.Sprintf("unknown cypher suite: %d", id))
+	}
+}
+
+func aeadAESGCMTLS13(key, nonceMask []byte) cipher.AEAD {
+	if fips140.Enabled() {
+		return aeadAESGCMTLS13FIPS140(key, nonceMask)
+	}
+
+	if len(nonceMask) != aeadNonceLength {
+		panic("tls: internal error: wrong nonce length")
+	}
+	aes, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	aead, err := cipher.NewGCM(aes)
+	if err != nil {
+		panic(err)
+	}
+
+	ret := &xorNonceAEAD{aead: aead}
+	copy(ret.nonceMask[:], nonceMask)
+	return ret
+}
+
+func aeadChaCha20Poly1305(key, nonceMask []byte) cipher.AEAD {
+	if len(nonceMask) != aeadNonceLength {
+		panic("tls: internal error: wrong nonce length")
+	}
+	aead, err := chacha20poly1305.New(key)
+	if err != nil {
+		panic(err)
+	}
+
+	ret := &xorNonceAEAD{aead: aead}
+	copy(ret.nonceMask[:], nonceMask)
+	return ret
+}
+
+// xorNonceAEAD wraps an AEAD by XORing in a fixed pattern to the nonce
+// before each call.
+type xorNonceAEAD struct {
+	nonceMask [aeadNonceLength]byte
+	aead      cipher.AEAD
+}
+
+func (f *xorNonceAEAD) NonceSize() int        { return 8 } // 64-bit sequence number
+func (f *xorNonceAEAD) Overhead() int         { return f.aead.Overhead() }
+func (f *xorNonceAEAD) explicitNonceLen() int { return 0 }
+
+func (f *xorNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte {
+	for i, b := range nonce {
+		f.nonceMask[4+i] ^= b
+	}
+	result := f.aead.Seal(out, f.nonceMask[:], plaintext, additionalData)
+	for i, b := range nonce {
+		f.nonceMask[4+i] ^= b
+	}
+
+	return result
+}
+
+func (f *xorNonceAEAD) Open(out, nonce, ciphertext, additionalData []byte) ([]byte, error) {
+	for i, b := range nonce {
+		f.nonceMask[4+i] ^= b
+	}
+	result, err := f.aead.Open(out, f.nonceMask[:], ciphertext, additionalData)
+	for i, b := range nonce {
+		f.nonceMask[4+i] ^= b
+	}
+
+	return result, err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite_fips140.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite_fips140.go
new file mode 100644
index 00000000..2248cbad
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/cipher_suite_fips140.go
@@ -0,0 +1,48 @@
+package handshake
+
+import (
+	"crypto/cipher"
+	_ "unsafe" // for go:linkname
+)
+
+// Reaching into crypto/tls is a bit of a hack, but it's the only way to get the FIPS 140
+// compliant AEAD, because the standard library doesn't yet expose the NewGCMForQUIC constructor
+// added in https://go-review.googlesource.com/c/go/+/723760.
+// See https://github.com/golang/go/issues/79219 for details.
+//
+// Once the standard library exposes the necessary constructors, we can use a shared code path
+// for both FIPS 140 and non-FIPS 140 modes.
+//
+//go:linkname cryptoTLSAEAD_AESGCMTLS13 crypto/tls.aeadAESGCMTLS13
+func cryptoTLSAEAD_AESGCMTLS13(key, nonceMask []byte) cipher.AEAD
+
+func aeadAESGCMTLS13FIPS140(key, nonceMask []byte) cipher.AEAD {
+	return &tls13AESGCMAEADFIPS140{aead: cryptoTLSAEAD_AESGCMTLS13(key, nonceMask)}
+}
+
+type tls13AESGCMAEADFIPS140 struct {
+	aead       cipher.AEAD
+	primedSeal bool
+}
+
+func (f *tls13AESGCMAEADFIPS140) NonceSize() int { return f.aead.NonceSize() }
+func (f *tls13AESGCMAEADFIPS140) Overhead() int  { return f.aead.Overhead() }
+
+func (f *tls13AESGCMAEADFIPS140) Seal(out, nonce, plaintext, additionalData []byte) []byte {
+	if !f.primedSeal {
+		f.primedSeal = true
+		if nonce[0]|nonce[1]|nonce[2]|nonce[3]|nonce[4]|nonce[5]|nonce[6]|nonce[7] != 0 {
+			// Go's TLS 1.3 AES-GCM AEAD learns the XOR mask from the first Seal
+			// call and enforces monotonically increasing packet numbers after that.
+			// QUIC packet numbers don't reset on key updates, so prime it with
+			// packet number 0 before the first real, non-zero packet number.
+			var zeroNonce [8]byte
+			f.aead.Seal(nil, zeroNonce[:], nil, nil)
+		}
+	}
+	return f.aead.Seal(out, nonce, plaintext, additionalData)
+}
+
+func (f *tls13AESGCMAEADFIPS140) Open(out, nonce, ciphertext, additionalData []byte) ([]byte, error) {
+	return f.aead.Open(out, nonce, ciphertext, additionalData)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/crypto_setup.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/crypto_setup.go
new file mode 100644
index 00000000..9c61fe67
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/crypto_setup.go
@@ -0,0 +1,718 @@
+package handshake
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+type quicVersionContextKey struct{}
+
+var QUICVersionContextKey = &quicVersionContextKey{}
+
+const clientSessionStateRevision = 5
+
+type cryptoSetup struct {
+	tlsConf *tls.Config
+	conn    *tls.QUICConn
+
+	events []Event
+
+	version protocol.Version
+
+	ourParams  *wire.TransportParameters
+	peerParams *wire.TransportParameters
+
+	zeroRTTParameters *wire.TransportParameters
+	allow0RTT         bool
+
+	rttStats *utils.RTTStats
+
+	qlogger qlogwriter.Recorder
+	logger  utils.Logger
+
+	perspective protocol.Perspective
+
+	handshakeCompleteTime time.Time
+
+	zeroRTTOpener LongHeaderOpener // only set for the server
+	zeroRTTSealer LongHeaderSealer // only set for the client
+
+	initialOpener LongHeaderOpener
+	initialSealer LongHeaderSealer
+
+	handshakeOpener LongHeaderOpener
+	handshakeSealer LongHeaderSealer
+
+	used0RTT atomic.Bool
+
+	aead          *updatableAEAD
+	has1RTTSealer bool
+	has1RTTOpener bool
+}
+
+var _ CryptoSetup = &cryptoSetup{}
+
+// NewCryptoSetupClient creates a new crypto setup for the client
+func NewCryptoSetupClient(
+	connID protocol.ConnectionID,
+	tp *wire.TransportParameters,
+	tlsConf *tls.Config,
+	enable0RTT bool,
+	rttStats *utils.RTTStats,
+	qlogger qlogwriter.Recorder,
+	logger utils.Logger,
+	version protocol.Version,
+) CryptoSetup {
+	cs := newCryptoSetup(
+		connID,
+		tp,
+		rttStats,
+		qlogger,
+		logger,
+		protocol.PerspectiveClient,
+		version,
+	)
+
+	tlsConf = setupConfigForClient(tlsConf)
+	cs.tlsConf = tlsConf
+	cs.allow0RTT = enable0RTT
+
+	cs.conn = tls.QUICClient(&tls.QUICConfig{
+		TLSConfig:           tlsConf,
+		EnableSessionEvents: true,
+	})
+	cs.conn.SetTransportParameters(cs.ourParams.Marshal(protocol.PerspectiveClient))
+
+	return cs
+}
+
+// NewCryptoSetupServer creates a new crypto setup for the server
+func NewCryptoSetupServer(
+	connID protocol.ConnectionID,
+	localAddr, remoteAddr net.Addr,
+	tp *wire.TransportParameters,
+	tlsConf *tls.Config,
+	allow0RTT bool,
+	rttStats *utils.RTTStats,
+	qlogger qlogwriter.Recorder,
+	logger utils.Logger,
+	version protocol.Version,
+) CryptoSetup {
+	cs := newCryptoSetup(
+		connID,
+		tp,
+		rttStats,
+		qlogger,
+		logger,
+		protocol.PerspectiveServer,
+		version,
+	)
+	cs.allow0RTT = allow0RTT
+
+	tlsConf = setupConfigForServer(tlsConf, localAddr, remoteAddr)
+
+	cs.tlsConf = tlsConf
+	cs.conn = tls.QUICServer(getQUICConfig(tlsConf, localAddr, remoteAddr))
+	return cs
+}
+
+func newCryptoSetup(
+	connID protocol.ConnectionID,
+	tp *wire.TransportParameters,
+	rttStats *utils.RTTStats,
+	qlogger qlogwriter.Recorder,
+	logger utils.Logger,
+	perspective protocol.Perspective,
+	version protocol.Version,
+) *cryptoSetup {
+	initialSealer, initialOpener := NewInitialAEAD(connID, perspective, version)
+	if qlogger != nil {
+		qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.EncryptionInitial, protocol.PerspectiveClient),
+		})
+		qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.EncryptionInitial, protocol.PerspectiveServer),
+		})
+	}
+	return &cryptoSetup{
+		initialSealer: initialSealer,
+		initialOpener: initialOpener,
+		aead:          newUpdatableAEAD(rttStats, qlogger, logger, version),
+		events:        make([]Event, 0, 16),
+		ourParams:     tp,
+		rttStats:      rttStats,
+		qlogger:       qlogger,
+		logger:        logger,
+		perspective:   perspective,
+		version:       version,
+	}
+}
+
+func (h *cryptoSetup) ChangeConnectionID(id protocol.ConnectionID) {
+	initialSealer, initialOpener := NewInitialAEAD(id, h.perspective, h.version)
+	h.initialSealer = initialSealer
+	h.initialOpener = initialOpener
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.EncryptionInitial, protocol.PerspectiveClient),
+		})
+		h.qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.EncryptionInitial, protocol.PerspectiveServer),
+		})
+	}
+}
+
+func (h *cryptoSetup) SetLargest1RTTAcked(pn protocol.PacketNumber) error {
+	return h.aead.SetLargestAcked(pn)
+}
+
+func (h *cryptoSetup) StartHandshake(ctx context.Context) error {
+	err := h.conn.Start(context.WithValue(ctx, QUICVersionContextKey, h.version))
+	if err != nil {
+		return wrapError(err)
+	}
+	for {
+		ev := h.conn.NextEvent()
+		if err := h.handleEvent(ev); err != nil {
+			return wrapError(err)
+		}
+		if ev.Kind == tls.QUICNoEvent {
+			break
+		}
+	}
+	if h.perspective == protocol.PerspectiveClient {
+		if h.zeroRTTSealer != nil && h.zeroRTTParameters != nil {
+			h.logger.Debugf("Doing 0-RTT.")
+			h.events = append(h.events, Event{Kind: EventRestoredTransportParameters, TransportParameters: h.zeroRTTParameters})
+		} else {
+			h.logger.Debugf("Not doing 0-RTT. Has sealer: %t, has params: %t", h.zeroRTTSealer != nil, h.zeroRTTParameters != nil)
+		}
+	}
+	return nil
+}
+
+// Close closes the crypto setup.
+// It aborts the handshake, if it is still running.
+func (h *cryptoSetup) Close() error {
+	return h.conn.Close()
+}
+
+// HandleMessage handles a TLS handshake message.
+// It is called by the crypto streams when a new message is available.
+func (h *cryptoSetup) HandleMessage(data []byte, encLevel protocol.EncryptionLevel) error {
+	if err := h.handleMessage(data, encLevel); err != nil {
+		return wrapError(err)
+	}
+	return nil
+}
+
+func (h *cryptoSetup) handleMessage(data []byte, encLevel protocol.EncryptionLevel) error {
+	if err := h.conn.HandleData(encLevel.ToTLSEncryptionLevel(), data); err != nil {
+		return err
+	}
+	for {
+		ev := h.conn.NextEvent()
+		if err := h.handleEvent(ev); err != nil {
+			return err
+		}
+		if ev.Kind == tls.QUICNoEvent {
+			return nil
+		}
+	}
+}
+
+func (h *cryptoSetup) handleEvent(ev tls.QUICEvent) (err error) {
+	switch ev.Kind {
+	case tls.QUICNoEvent:
+		return nil
+	case tls.QUICSetReadSecret:
+		h.setReadKey(ev.Level, ev.Suite, ev.Data)
+		return nil
+	case tls.QUICSetWriteSecret:
+		h.setWriteKey(ev.Level, ev.Suite, ev.Data)
+		return nil
+	case tls.QUICTransportParameters:
+		return h.handleTransportParameters(ev.Data)
+	case tls.QUICTransportParametersRequired:
+		h.conn.SetTransportParameters(h.ourParams.Marshal(h.perspective))
+		return nil
+	case tls.QUICRejectedEarlyData:
+		h.rejected0RTT()
+		return nil
+	case tls.QUICWriteData:
+		h.writeRecord(ev.Level, ev.Data)
+		return nil
+	case tls.QUICHandshakeDone:
+		h.handshakeComplete()
+		return nil
+	case tls.QUICStoreSession:
+		if h.perspective == protocol.PerspectiveServer {
+			panic("cryptoSetup BUG: unexpected QUICStoreSession event for the server")
+		}
+		ev.SessionState.Extra = append(
+			ev.SessionState.Extra,
+			addSessionStateExtraPrefix(h.marshalDataForSessionState(ev.SessionState.EarlyData)),
+		)
+		return h.conn.StoreSession(ev.SessionState)
+	case tls.QUICResumeSession:
+		var allowEarlyData bool
+		switch h.perspective {
+		case protocol.PerspectiveClient:
+			// for clients, this event occurs when a session ticket is selected
+			allowEarlyData = h.handleDataFromSessionState(
+				findSessionStateExtraData(ev.SessionState.Extra),
+				ev.SessionState.EarlyData,
+			)
+		case protocol.PerspectiveServer:
+			// for servers, this event occurs when receiving the client's session ticket
+			allowEarlyData = h.handleSessionTicket(
+				findSessionStateExtraData(ev.SessionState.Extra),
+				ev.SessionState.EarlyData,
+			)
+		}
+		if ev.SessionState.EarlyData {
+			ev.SessionState.EarlyData = allowEarlyData
+		}
+		return nil
+	case quicErrorEvent:
+		return extractQUICEventError(ev)
+	default:
+		// Unknown events should be ignored.
+		// crypto/tls will ensure that this is safe to do.
+		// See the discussion following https://github.com/golang/go/issues/68124#issuecomment-2187042510 for details.
+		return nil
+	}
+}
+
+func (h *cryptoSetup) NextEvent() Event {
+	if len(h.events) == 0 {
+		return Event{Kind: EventNoEvent}
+	}
+	ev := h.events[0]
+	h.events = h.events[1:]
+	return ev
+}
+
+func (h *cryptoSetup) handleTransportParameters(data []byte) error {
+	var tp wire.TransportParameters
+	if err := tp.Unmarshal(data, h.perspective.Opposite()); err != nil {
+		return err
+	}
+	h.peerParams = &tp
+	h.events = append(h.events, Event{Kind: EventReceivedTransportParameters, TransportParameters: h.peerParams})
+	return nil
+}
+
+// must be called after receiving the transport parameters
+func (h *cryptoSetup) marshalDataForSessionState(earlyData bool) []byte {
+	b := make([]byte, 0, 256)
+	b = quicvarint.Append(b, clientSessionStateRevision)
+	if earlyData {
+		// only save the transport parameters for 0-RTT enabled session tickets
+		return h.peerParams.MarshalForSessionTicket(b)
+	}
+	return b
+}
+
+func (h *cryptoSetup) handleDataFromSessionState(data []byte, earlyData bool) (allowEarlyData bool) {
+	tp, err := decodeDataFromSessionState(data, earlyData)
+	if err != nil {
+		h.logger.Debugf("Restoring of transport parameters from session ticket failed: %s", err.Error())
+		return
+	}
+	// The session ticket might have been saved from a connection that allowed 0-RTT,
+	// and therefore contain transport parameters.
+	// Only use them if 0-RTT is actually used on the new connection.
+	if tp != nil && h.allow0RTT {
+		h.zeroRTTParameters = tp
+		return true
+	}
+	return false
+}
+
+func decodeDataFromSessionState(b []byte, earlyData bool) (*wire.TransportParameters, error) {
+	ver, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, err
+	}
+	b = b[l:]
+	if ver != clientSessionStateRevision {
+		return nil, fmt.Errorf("mismatching version. Got %d, expected %d", ver, clientSessionStateRevision)
+	}
+	if !earlyData {
+		return nil, nil
+	}
+	var tp wire.TransportParameters
+	if err := tp.UnmarshalFromSessionTicket(b); err != nil {
+		return nil, err
+	}
+	return &tp, nil
+}
+
+func (h *cryptoSetup) getDataForSessionTicket() []byte {
+	return (&sessionTicket{
+		Parameters: h.ourParams,
+	}).Marshal()
+}
+
+// GetSessionTicket generates a new session ticket.
+// Due to limitations in crypto/tls, it's only possible to generate a single session ticket per connection.
+// It is only valid for the server.
+func (h *cryptoSetup) GetSessionTicket() ([]byte, error) {
+	if err := h.conn.SendSessionTicket(tls.QUICSessionTicketOptions{
+		EarlyData: h.allow0RTT,
+		Extra:     [][]byte{addSessionStateExtraPrefix(h.getDataForSessionTicket())},
+	}); err != nil {
+		// Session tickets might be disabled by tls.Config.SessionTicketsDisabled.
+		// We can't check h.tlsConfig here, since the actual config might have been obtained from
+		// the GetConfigForClient callback.
+		// See https://github.com/golang/go/issues/62032.
+		// This error assertion can be removed once we drop support for Go 1.25.
+		if strings.Contains(err.Error(), "session ticket keys unavailable") {
+			return nil, nil
+		}
+		return nil, err
+	}
+	// If session tickets are disabled, NextEvent will immediately return QUICNoEvent,
+	// and we will return a nil ticket.
+	var ticket []byte
+	for {
+		ev := h.conn.NextEvent()
+		if ev.Kind == tls.QUICNoEvent {
+			break
+		}
+		if ev.Kind == tls.QUICWriteData && ev.Level == tls.QUICEncryptionLevelApplication {
+			if ticket != nil {
+				h.logger.Errorf("unexpected multiple session tickets")
+				continue
+			}
+			ticket = ev.Data
+		} else {
+			h.logger.Errorf("unexpected event: %v", ev.Kind)
+		}
+	}
+	return ticket, nil
+}
+
+// handleSessionTicket is called for the server when receiving the client's session ticket.
+// It reads parameters from the session ticket and checks whether to accept 0-RTT if the session ticket enabled 0-RTT.
+// Note that the fact that the session ticket allows 0-RTT doesn't mean that the actual TLS handshake enables 0-RTT:
+// A client may use a 0-RTT enabled session to resume a TLS session without using 0-RTT.
+func (h *cryptoSetup) handleSessionTicket(data []byte, using0RTT bool) (allowEarlyData bool) {
+	var t sessionTicket
+	if err := t.Unmarshal(data); err != nil {
+		h.logger.Debugf("Unmarshalling session ticket failed: %s", err.Error())
+		return false
+	}
+	if !using0RTT {
+		return false
+	}
+	valid := h.ourParams.ValidFor0RTT(t.Parameters)
+	if !valid {
+		h.logger.Debugf("Transport parameters changed. Rejecting 0-RTT.")
+		return false
+	}
+	if !h.allow0RTT {
+		h.logger.Debugf("0-RTT not allowed. Rejecting 0-RTT.")
+		return false
+	}
+	return true
+}
+
+// rejected0RTT is called for the client when the server rejects 0-RTT.
+func (h *cryptoSetup) rejected0RTT() {
+	h.logger.Debugf("0-RTT was rejected. Dropping 0-RTT keys.")
+
+	had0RTTKeys := h.zeroRTTSealer != nil
+	h.zeroRTTSealer = nil
+
+	if had0RTTKeys {
+		h.events = append(h.events, Event{Kind: EventDiscard0RTTKeys})
+	}
+}
+
+func (h *cryptoSetup) setReadKey(el tls.QUICEncryptionLevel, suiteID uint16, trafficSecret []byte) {
+	suite := getCipherSuite(suiteID)
+	//nolint:exhaustive // The TLS stack doesn't export Initial keys.
+	switch el {
+	case tls.QUICEncryptionLevelEarly:
+		if h.perspective == protocol.PerspectiveClient {
+			panic("Received 0-RTT read key for the client")
+		}
+		h.zeroRTTOpener = newLongHeaderOpener(
+			createAEAD(suite, trafficSecret, h.version),
+			newHeaderProtector(suite, trafficSecret, true, h.version),
+		)
+		h.used0RTT.Store(true)
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed 0-RTT Read keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+	case tls.QUICEncryptionLevelHandshake:
+		h.handshakeOpener = newLongHeaderOpener(
+			createAEAD(suite, trafficSecret, h.version),
+			newHeaderProtector(suite, trafficSecret, true, h.version),
+		)
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed Handshake Read keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+	case tls.QUICEncryptionLevelApplication:
+		h.aead.SetReadKey(suite, trafficSecret)
+		h.has1RTTOpener = true
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed 1-RTT Read keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+	default:
+		panic("unexpected read encryption level")
+	}
+	h.events = append(h.events, Event{Kind: EventReceivedReadKeys})
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.FromTLSEncryptionLevel(el), h.perspective.Opposite()),
+		})
+	}
+}
+
+func (h *cryptoSetup) setWriteKey(el tls.QUICEncryptionLevel, suiteID uint16, trafficSecret []byte) {
+	suite := getCipherSuite(suiteID)
+	//nolint:exhaustive // The TLS stack doesn't export Initial keys.
+	switch el {
+	case tls.QUICEncryptionLevelEarly:
+		if h.perspective == protocol.PerspectiveServer {
+			panic("Received 0-RTT write key for the server")
+		}
+		h.zeroRTTSealer = newLongHeaderSealer(
+			createAEAD(suite, trafficSecret, h.version),
+			newHeaderProtector(suite, trafficSecret, true, h.version),
+		)
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed 0-RTT Write keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.KeyUpdated{
+				Trigger: qlog.KeyUpdateTLS,
+				KeyType: encLevelToKeyType(protocol.Encryption0RTT, h.perspective),
+			})
+		}
+		// don't set used0RTT here. 0-RTT might still get rejected.
+		return
+	case tls.QUICEncryptionLevelHandshake:
+		h.handshakeSealer = newLongHeaderSealer(
+			createAEAD(suite, trafficSecret, h.version),
+			newHeaderProtector(suite, trafficSecret, true, h.version),
+		)
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed Handshake Write keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+	case tls.QUICEncryptionLevelApplication:
+		h.aead.SetWriteKey(suite, trafficSecret)
+		h.has1RTTSealer = true
+		if h.logger.Debug() {
+			h.logger.Debugf("Installed 1-RTT Write keys (using %s)", tls.CipherSuiteName(suite.ID))
+		}
+		if h.zeroRTTSealer != nil {
+			// Once we receive handshake keys, we know that 0-RTT was not rejected.
+			h.used0RTT.Store(true)
+			h.zeroRTTSealer = nil
+			h.logger.Debugf("Dropping 0-RTT keys.")
+			if h.qlogger != nil {
+				h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeClient0RTT})
+			}
+		}
+	default:
+		panic("unexpected write encryption level")
+	}
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.KeyUpdated{
+			Trigger: qlog.KeyUpdateTLS,
+			KeyType: encLevelToKeyType(protocol.FromTLSEncryptionLevel(el), h.perspective),
+		})
+	}
+}
+
+// writeRecord is called when TLS writes data
+func (h *cryptoSetup) writeRecord(encLevel tls.QUICEncryptionLevel, p []byte) {
+	//nolint:exhaustive // handshake records can only be written for Initial and Handshake.
+	switch encLevel {
+	case tls.QUICEncryptionLevelInitial:
+		h.events = append(h.events, Event{Kind: EventWriteInitialData, Data: p})
+	case tls.QUICEncryptionLevelHandshake:
+		h.events = append(h.events, Event{Kind: EventWriteHandshakeData, Data: p})
+	case tls.QUICEncryptionLevelApplication:
+		panic("unexpected write")
+	default:
+		panic(fmt.Sprintf("unexpected write encryption level: %s", encLevel))
+	}
+}
+
+func (h *cryptoSetup) DiscardInitialKeys() {
+	dropped := h.initialOpener != nil
+	h.initialOpener = nil
+	h.initialSealer = nil
+	if dropped {
+		h.logger.Debugf("Dropping Initial keys.")
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeClientInitial})
+			h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeServerInitial})
+		}
+	}
+}
+
+func (h *cryptoSetup) handshakeComplete() {
+	h.handshakeCompleteTime = time.Now()
+	h.events = append(h.events, Event{Kind: EventHandshakeComplete})
+}
+
+func (h *cryptoSetup) SetHandshakeConfirmed() {
+	h.aead.SetHandshakeConfirmed()
+	// drop Handshake keys
+	var dropped bool
+	if h.handshakeOpener != nil {
+		h.handshakeOpener = nil
+		h.handshakeSealer = nil
+		dropped = true
+	}
+	if dropped {
+		h.logger.Debugf("Dropping Handshake keys.")
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeClientHandshake})
+			h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeServerHandshake})
+		}
+	}
+}
+
+func (h *cryptoSetup) GetInitialSealer() (LongHeaderSealer, error) {
+	if h.initialSealer == nil {
+		return nil, ErrKeysDropped
+	}
+	return h.initialSealer, nil
+}
+
+func (h *cryptoSetup) Get0RTTSealer() (LongHeaderSealer, error) {
+	if h.zeroRTTSealer == nil {
+		return nil, ErrKeysDropped
+	}
+	return h.zeroRTTSealer, nil
+}
+
+func (h *cryptoSetup) GetHandshakeSealer() (LongHeaderSealer, error) {
+	if h.handshakeSealer == nil {
+		if h.initialSealer == nil {
+			return nil, ErrKeysDropped
+		}
+		return nil, ErrKeysNotYetAvailable
+	}
+	return h.handshakeSealer, nil
+}
+
+func (h *cryptoSetup) Get1RTTSealer() (ShortHeaderSealer, error) {
+	if !h.has1RTTSealer {
+		return nil, ErrKeysNotYetAvailable
+	}
+	return h.aead, nil
+}
+
+func (h *cryptoSetup) GetInitialOpener() (LongHeaderOpener, error) {
+	if h.initialOpener == nil {
+		return nil, ErrKeysDropped
+	}
+	return h.initialOpener, nil
+}
+
+func (h *cryptoSetup) Get0RTTOpener() (LongHeaderOpener, error) {
+	if h.zeroRTTOpener == nil {
+		if h.initialOpener != nil {
+			return nil, ErrKeysNotYetAvailable
+		}
+		// if the initial opener is also not available, the keys were already dropped
+		return nil, ErrKeysDropped
+	}
+	return h.zeroRTTOpener, nil
+}
+
+func (h *cryptoSetup) GetHandshakeOpener() (LongHeaderOpener, error) {
+	if h.handshakeOpener == nil {
+		if h.initialOpener != nil {
+			return nil, ErrKeysNotYetAvailable
+		}
+		// if the initial opener is also not available, the keys were already dropped
+		return nil, ErrKeysDropped
+	}
+	return h.handshakeOpener, nil
+}
+
+func (h *cryptoSetup) Get1RTTOpener() (ShortHeaderOpener, error) {
+	if h.zeroRTTOpener != nil && time.Since(h.handshakeCompleteTime) > 3*h.rttStats.PTO(true) {
+		h.zeroRTTOpener = nil
+		h.logger.Debugf("Dropping 0-RTT keys.")
+		if h.qlogger != nil {
+			h.qlogger.RecordEvent(qlog.KeyDiscarded{KeyType: qlog.KeyTypeClient0RTT})
+		}
+	}
+
+	if !h.has1RTTOpener {
+		return nil, ErrKeysNotYetAvailable
+	}
+	return h.aead, nil
+}
+
+func (h *cryptoSetup) ConnectionState() ConnectionState {
+	return ConnectionState{
+		ConnectionState: h.conn.ConnectionState(),
+		Used0RTT:        h.used0RTT.Load(),
+	}
+}
+
+func wrapError(err error) error {
+	if alertErr := tls.AlertError(0); errors.As(err, &alertErr) {
+		return qerr.NewLocalCryptoError(uint8(alertErr), err)
+	}
+	return &qerr.TransportError{ErrorCode: qerr.InternalError, ErrorMessage: err.Error()}
+}
+
+func encLevelToKeyType(encLevel protocol.EncryptionLevel, pers protocol.Perspective) qlog.KeyType {
+	if pers == protocol.PerspectiveServer {
+		switch encLevel {
+		case protocol.EncryptionInitial:
+			return qlog.KeyTypeServerInitial
+		case protocol.EncryptionHandshake:
+			return qlog.KeyTypeServerHandshake
+		case protocol.Encryption0RTT:
+			return qlog.KeyTypeServer0RTT
+		case protocol.Encryption1RTT:
+			return qlog.KeyTypeServer1RTT
+		default:
+			return ""
+		}
+	}
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return qlog.KeyTypeClientInitial
+	case protocol.EncryptionHandshake:
+		return qlog.KeyTypeClientHandshake
+	case protocol.Encryption0RTT:
+		return qlog.KeyTypeClient0RTT
+	case protocol.Encryption1RTT:
+		return qlog.KeyTypeClient1RTT
+	default:
+		return ""
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fake_conn.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fake_conn.go
new file mode 100644
index 00000000..54af823b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fake_conn.go
@@ -0,0 +1,21 @@
+package handshake
+
+import (
+	"net"
+	"time"
+)
+
+type conn struct {
+	localAddr, remoteAddr net.Addr
+}
+
+var _ net.Conn = &conn{}
+
+func (c *conn) Read([]byte) (int, error)         { return 0, nil }
+func (c *conn) Write([]byte) (int, error)        { return 0, nil }
+func (c *conn) Close() error                     { return nil }
+func (c *conn) RemoteAddr() net.Addr             { return c.remoteAddr }
+func (c *conn) LocalAddr() net.Addr              { return c.localAddr }
+func (c *conn) SetReadDeadline(time.Time) error  { return nil }
+func (c *conn) SetWriteDeadline(time.Time) error { return nil }
+func (c *conn) SetDeadline(time.Time) error      { return nil }
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_go126.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_go126.go
new file mode 100644
index 00000000..4241794c
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_go126.go
@@ -0,0 +1,9 @@
+//go:build go1.26
+
+package handshake
+
+import "crypto/fips140"
+
+func withoutFIPSEnforcement(f func()) {
+	fips140.WithoutEnforcement(f)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_legacy.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_legacy.go
new file mode 100644
index 00000000..bc8e639a
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/fips140_legacy.go
@@ -0,0 +1,7 @@
+//go:build !go1.26
+
+package handshake
+
+func withoutFIPSEnforcement(f func()) {
+	f()
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/header_protector.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/header_protector.go
new file mode 100644
index 00000000..3ea7caf1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/header_protector.go
@@ -0,0 +1,134 @@
+package handshake
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/tls"
+	"encoding/binary"
+	"fmt"
+
+	"golang.org/x/crypto/chacha20"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type headerProtector interface {
+	EncryptHeader(sample []byte, firstByte *byte, hdrBytes []byte)
+	DecryptHeader(sample []byte, firstByte *byte, hdrBytes []byte)
+}
+
+func hkdfHeaderProtectionLabel(v protocol.Version) string {
+	if v == protocol.Version2 {
+		return "quicv2 hp"
+	}
+	return "quic hp"
+}
+
+func newHeaderProtector(suite cipherSuite, trafficSecret []byte, isLongHeader bool, v protocol.Version) headerProtector {
+	hkdfLabel := hkdfHeaderProtectionLabel(v)
+	switch suite.ID {
+	case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384:
+		return newAESHeaderProtector(suite, trafficSecret, isLongHeader, hkdfLabel)
+	case tls.TLS_CHACHA20_POLY1305_SHA256:
+		return newChaChaHeaderProtector(suite, trafficSecret, isLongHeader, hkdfLabel)
+	default:
+		panic(fmt.Sprintf("Invalid cipher suite id: %d", suite.ID))
+	}
+}
+
+type aesHeaderProtector struct {
+	mask         [16]byte // AES always has a 16 byte block size
+	block        cipher.Block
+	isLongHeader bool
+}
+
+var _ headerProtector = &aesHeaderProtector{}
+
+func newAESHeaderProtector(suite cipherSuite, trafficSecret []byte, isLongHeader bool, hkdfLabel string) headerProtector {
+	hpKey := hkdfExpandLabel(suite.Hash, trafficSecret, []byte{}, hkdfLabel, suite.KeyLen)
+	block, err := aes.NewCipher(hpKey)
+	if err != nil {
+		panic(fmt.Sprintf("error creating new AES cipher: %s", err))
+	}
+	return &aesHeaderProtector{
+		block:        block,
+		isLongHeader: isLongHeader,
+	}
+}
+
+func (p *aesHeaderProtector) DecryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	p.apply(sample, firstByte, hdrBytes)
+}
+
+func (p *aesHeaderProtector) EncryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	p.apply(sample, firstByte, hdrBytes)
+}
+
+func (p *aesHeaderProtector) apply(sample []byte, firstByte *byte, hdrBytes []byte) {
+	if len(sample) != len(p.mask) {
+		panic("invalid sample size")
+	}
+	p.block.Encrypt(p.mask[:], sample)
+	if p.isLongHeader {
+		*firstByte ^= p.mask[0] & 0xf
+	} else {
+		*firstByte ^= p.mask[0] & 0x1f
+	}
+	for i := range hdrBytes {
+		hdrBytes[i] ^= p.mask[i+1]
+	}
+}
+
+type chachaHeaderProtector struct {
+	mask [5]byte
+
+	key          [32]byte
+	isLongHeader bool
+}
+
+var _ headerProtector = &chachaHeaderProtector{}
+
+func newChaChaHeaderProtector(suite cipherSuite, trafficSecret []byte, isLongHeader bool, hkdfLabel string) headerProtector {
+	hpKey := hkdfExpandLabel(suite.Hash, trafficSecret, []byte{}, hkdfLabel, suite.KeyLen)
+
+	p := &chachaHeaderProtector{
+		isLongHeader: isLongHeader,
+	}
+	copy(p.key[:], hpKey)
+	return p
+}
+
+func (p *chachaHeaderProtector) DecryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	p.apply(sample, firstByte, hdrBytes)
+}
+
+func (p *chachaHeaderProtector) EncryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	p.apply(sample, firstByte, hdrBytes)
+}
+
+func (p *chachaHeaderProtector) apply(sample []byte, firstByte *byte, hdrBytes []byte) {
+	if len(sample) != 16 {
+		panic("invalid sample size")
+	}
+	for i := range 5 {
+		p.mask[i] = 0
+	}
+	cipher, err := chacha20.NewUnauthenticatedCipher(p.key[:], sample[4:])
+	if err != nil {
+		panic(err)
+	}
+	cipher.SetCounter(binary.LittleEndian.Uint32(sample[:4]))
+	cipher.XORKeyStream(p.mask[:], p.mask[:])
+	p.applyMask(firstByte, hdrBytes)
+}
+
+func (p *chachaHeaderProtector) applyMask(firstByte *byte, hdrBytes []byte) {
+	if p.isLongHeader {
+		*firstByte ^= p.mask[0] & 0xf
+	} else {
+		*firstByte ^= p.mask[0] & 0x1f
+	}
+	for i := range hdrBytes {
+		hdrBytes[i] ^= p.mask[i+1]
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/hkdf.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/hkdf.go
new file mode 100644
index 00000000..b28c1f1d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/hkdf.go
@@ -0,0 +1,26 @@
+package handshake
+
+import (
+	"crypto"
+	"crypto/hkdf"
+	"encoding/binary"
+	"fmt"
+)
+
+// hkdfExpandLabel HKDF expands a label as defined in RFC 8446, section 7.1.
+func hkdfExpandLabel(hash crypto.Hash, secret, context []byte, label string, length int) []byte {
+	b := make([]byte, 3, 3+6+len(label)+1+len(context))
+	binary.BigEndian.PutUint16(b, uint16(length))
+	b[2] = uint8(6 + len(label))
+	b = append(b, []byte("tls13 ")...)
+	b = append(b, []byte(label)...)
+	b = b[:3+6+len(label)+1]
+	b[3+6+len(label)] = uint8(len(context))
+	b = append(b, context...)
+
+	expanded, err := hkdf.Expand(hash.New, secret, string(b), length)
+	if err != nil {
+		panic(fmt.Errorf("quic: HKDF-Expand-Label invocation failed unexpectedly: %v", err))
+	}
+	return expanded
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/initial_aead.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/initial_aead.go
new file mode 100644
index 00000000..ff8e377a
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/initial_aead.go
@@ -0,0 +1,80 @@
+package handshake
+
+import (
+	"crypto"
+	"crypto/hkdf"
+	"crypto/tls"
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+var (
+	quicSaltV1 = []byte{0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34, 0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a}
+	quicSaltV2 = []byte{0x0d, 0xed, 0xe3, 0xde, 0xf7, 0x00, 0xa6, 0xdb, 0x81, 0x93, 0x81, 0xbe, 0x6e, 0x26, 0x9d, 0xcb, 0xf9, 0xbd, 0x2e, 0xd9}
+)
+
+const (
+	hkdfLabelKeyV1 = "quic key"
+	hkdfLabelKeyV2 = "quicv2 key"
+	hkdfLabelIVV1  = "quic iv"
+	hkdfLabelIVV2  = "quicv2 iv"
+)
+
+var initialSuite = getCipherSuite(tls.TLS_AES_128_GCM_SHA256)
+
+// NewInitialAEAD creates a new AEAD for Initial encryption / decryption.
+func NewInitialAEAD(connID protocol.ConnectionID, pers protocol.Perspective, v protocol.Version) (LongHeaderSealer, LongHeaderOpener) {
+	var sealer LongHeaderSealer
+	var opener LongHeaderOpener
+	// The keys for the Initial AEAD are derived from the connection ID and constants defined in RFC 9001, Section 5.2.
+	// By design, the Initial encryption level provides no confidentiality against any attacker who has read the RFC.
+	// Its sole purpose is integrity protection. The Initial encryption level is therefore out of scope for FIPS 140.
+	// See also this thread on the IETF QUIC mailing list: https://mailarchive.ietf.org/arch/msg/quic/k2kl2W_n5WDEZBbt3O31Ef2XBbM.
+	withoutFIPSEnforcement(func() {
+		clientSecret, serverSecret := computeSecrets(connID, v)
+		var mySecret, otherSecret []byte
+		if pers == protocol.PerspectiveClient {
+			mySecret = clientSecret
+			otherSecret = serverSecret
+		} else {
+			mySecret = serverSecret
+			otherSecret = clientSecret
+		}
+		myKey, myIV := computeInitialKeyAndIV(mySecret, v)
+		otherKey, otherIV := computeInitialKeyAndIV(otherSecret, v)
+
+		encrypter := initialSuite.AEAD(myKey, myIV)
+		decrypter := initialSuite.AEAD(otherKey, otherIV)
+
+		sealer = newLongHeaderSealer(encrypter, newHeaderProtector(initialSuite, mySecret, true, v))
+		opener = newLongHeaderOpener(decrypter, newHeaderProtector(initialSuite, otherSecret, true, v))
+	})
+	return sealer, opener
+}
+
+func computeSecrets(connID protocol.ConnectionID, v protocol.Version) (clientSecret, serverSecret []byte) {
+	salt := quicSaltV1
+	if v == protocol.Version2 {
+		salt = quicSaltV2
+	}
+	initialSecret, err := hkdf.Extract(crypto.SHA256.New, connID.Bytes(), salt)
+	if err != nil {
+		panic(fmt.Errorf("quic: HKDF-Extract invocation failed unexpectedly: %v", err))
+	}
+	clientSecret = hkdfExpandLabel(crypto.SHA256, initialSecret, []byte{}, "client in", crypto.SHA256.Size())
+	serverSecret = hkdfExpandLabel(crypto.SHA256, initialSecret, []byte{}, "server in", crypto.SHA256.Size())
+	return
+}
+
+func computeInitialKeyAndIV(secret []byte, v protocol.Version) (key, iv []byte) {
+	keyLabel := hkdfLabelKeyV1
+	ivLabel := hkdfLabelIVV1
+	if v == protocol.Version2 {
+		keyLabel = hkdfLabelKeyV2
+		ivLabel = hkdfLabelIVV2
+	}
+	key = hkdfExpandLabel(crypto.SHA256, secret, []byte{}, keyLabel, 16)
+	iv = hkdfExpandLabel(crypto.SHA256, secret, []byte{}, ivLabel, 12)
+	return
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/interface.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/interface.go
new file mode 100644
index 00000000..d9227339
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/interface.go
@@ -0,0 +1,140 @@
+package handshake
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+var (
+	// ErrKeysNotYetAvailable is returned when an opener or a sealer is requested for an encryption level,
+	// but the corresponding opener has not yet been initialized
+	// This can happen when packets arrive out of order.
+	ErrKeysNotYetAvailable = errors.New("CryptoSetup: keys at this encryption level not yet available")
+	// ErrKeysDropped is returned when an opener or a sealer is requested for an encryption level,
+	// but the corresponding keys have already been dropped.
+	ErrKeysDropped = errors.New("CryptoSetup: keys were already dropped")
+	// ErrDecryptionFailed is returned when the AEAD fails to open the packet.
+	ErrDecryptionFailed = errors.New("decryption failed")
+)
+
+type headerDecryptor interface {
+	DecryptHeader(sample []byte, firstByte *byte, pnBytes []byte)
+}
+
+// LongHeaderOpener opens a long header packet
+type LongHeaderOpener interface {
+	headerDecryptor
+	DecodePacketNumber(wirePN protocol.PacketNumber, wirePNLen protocol.PacketNumberLen) protocol.PacketNumber
+	Open(dst, src []byte, pn protocol.PacketNumber, associatedData []byte) ([]byte, error)
+}
+
+// ShortHeaderOpener opens a short header packet
+type ShortHeaderOpener interface {
+	headerDecryptor
+	DecodePacketNumber(wirePN protocol.PacketNumber, wirePNLen protocol.PacketNumberLen) protocol.PacketNumber
+	Open(dst, src []byte, rcvTime monotime.Time, pn protocol.PacketNumber, kp protocol.KeyPhaseBit, associatedData []byte) ([]byte, error)
+}
+
+// LongHeaderSealer seals a long header packet
+type LongHeaderSealer interface {
+	Seal(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte
+	EncryptHeader(sample []byte, firstByte *byte, pnBytes []byte)
+	Overhead() int
+}
+
+// ShortHeaderSealer seals a short header packet
+type ShortHeaderSealer interface {
+	LongHeaderSealer
+	KeyPhase() protocol.KeyPhaseBit
+}
+
+type ConnectionState struct {
+	tls.ConnectionState
+	Used0RTT bool
+}
+
+// EventKind is the kind of handshake event.
+type EventKind uint8
+
+const (
+	// EventNoEvent signals that there are no new handshake events
+	EventNoEvent EventKind = iota + 1
+	// EventWriteInitialData contains new CRYPTO data to send at the Initial encryption level
+	EventWriteInitialData
+	// EventWriteHandshakeData contains new CRYPTO data to send at the Handshake encryption level
+	EventWriteHandshakeData
+	// EventReceivedReadKeys signals that new decryption keys are available.
+	// It doesn't say which encryption level those keys are for.
+	EventReceivedReadKeys
+	// EventDiscard0RTTKeys signals that the Handshake keys were discarded.
+	EventDiscard0RTTKeys
+	// EventReceivedTransportParameters contains the transport parameters sent by the peer.
+	EventReceivedTransportParameters
+	// EventRestoredTransportParameters contains the transport parameters restored from the session ticket.
+	// It is only used for the client.
+	EventRestoredTransportParameters
+	// EventHandshakeComplete signals that the TLS handshake was completed.
+	EventHandshakeComplete
+)
+
+func (k EventKind) String() string {
+	switch k {
+	case EventNoEvent:
+		return "EventNoEvent"
+	case EventWriteInitialData:
+		return "EventWriteInitialData"
+	case EventWriteHandshakeData:
+		return "EventWriteHandshakeData"
+	case EventReceivedReadKeys:
+		return "EventReceivedReadKeys"
+	case EventDiscard0RTTKeys:
+		return "EventDiscard0RTTKeys"
+	case EventReceivedTransportParameters:
+		return "EventReceivedTransportParameters"
+	case EventRestoredTransportParameters:
+		return "EventRestoredTransportParameters"
+	case EventHandshakeComplete:
+		return "EventHandshakeComplete"
+	default:
+		return "Unknown EventKind"
+	}
+}
+
+// Event is a handshake event.
+type Event struct {
+	Kind                EventKind
+	Data                []byte
+	TransportParameters *wire.TransportParameters
+}
+
+// CryptoSetup handles the handshake and protecting / unprotecting packets
+type CryptoSetup interface {
+	StartHandshake(context.Context) error
+	io.Closer
+	ChangeConnectionID(protocol.ConnectionID)
+	GetSessionTicket() ([]byte, error)
+
+	HandleMessage([]byte, protocol.EncryptionLevel) error
+	NextEvent() Event
+
+	SetLargest1RTTAcked(protocol.PacketNumber) error
+	DiscardInitialKeys()
+	SetHandshakeConfirmed()
+	ConnectionState() ConnectionState
+
+	GetInitialOpener() (LongHeaderOpener, error)
+	GetHandshakeOpener() (LongHeaderOpener, error)
+	Get0RTTOpener() (LongHeaderOpener, error)
+	Get1RTTOpener() (ShortHeaderOpener, error)
+
+	GetInitialSealer() (LongHeaderSealer, error)
+	GetHandshakeSealer() (LongHeaderSealer, error)
+	Get0RTTSealer() (LongHeaderSealer, error)
+	Get1RTTSealer() (ShortHeaderSealer, error)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go125.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go125.go
new file mode 100644
index 00000000..e9553972
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go125.go
@@ -0,0 +1,11 @@
+//go:build go1.25 && !go1.26
+
+package handshake
+
+import "crypto/tls"
+
+const quicErrorEvent tls.QUICEventKind = -1
+
+func extractQUICEventError(tls.QUICEvent) error {
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go126.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go126.go
new file mode 100644
index 00000000..734778e0
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/quic_event_go126.go
@@ -0,0 +1,11 @@
+//go:build go1.26
+
+package handshake
+
+import "crypto/tls"
+
+const quicErrorEvent tls.QUICEventKind = tls.QUICErrorEvent
+
+func extractQUICEventError(ev tls.QUICEvent) error {
+	return ev.Err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go125.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go125.go
new file mode 100644
index 00000000..8c525625
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go125.go
@@ -0,0 +1,68 @@
+//go:build !go1.26
+
+package handshake
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"fmt"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// Instead of using an init function, the AEADs are created lazily.
+// For more details see https://github.com/quic-go/quic-go/issues/4894.
+var (
+	retryAEADv1 cipher.AEAD // used for QUIC v1 (RFC 9000)
+	retryAEADv2 cipher.AEAD // used for QUIC v2 (RFC 9369)
+)
+
+func initAEAD(key [16]byte) cipher.AEAD {
+	aes, err := aes.NewCipher(key[:])
+	if err != nil {
+		panic(err)
+	}
+	aead, err := cipher.NewGCM(aes)
+	if err != nil {
+		panic(err)
+	}
+	return aead
+}
+
+var (
+	retryBuf     bytes.Buffer
+	retryMutex   sync.Mutex
+	retryNonceV1 = [12]byte{0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb}
+	retryNonceV2 = [12]byte{0xd8, 0x69, 0x69, 0xbc, 0x2d, 0x7c, 0x6d, 0x99, 0x90, 0xef, 0xb0, 0x4a}
+)
+
+// GetRetryIntegrityTag calculates the integrity tag on a Retry packet
+func GetRetryIntegrityTag(retry []byte, origDestConnID protocol.ConnectionID, version protocol.Version) *[16]byte {
+	retryMutex.Lock()
+	defer retryMutex.Unlock()
+
+	retryBuf.WriteByte(uint8(origDestConnID.Len()))
+	retryBuf.Write(origDestConnID.Bytes())
+	retryBuf.Write(retry)
+	defer retryBuf.Reset()
+
+	var tag [16]byte
+	var sealed []byte
+	if version == protocol.Version2 {
+		if retryAEADv2 == nil {
+			retryAEADv2 = initAEAD([16]byte{0x8f, 0xb4, 0xb0, 0x1b, 0x56, 0xac, 0x48, 0xe2, 0x60, 0xfb, 0xcb, 0xce, 0xad, 0x7c, 0xcc, 0x92})
+		}
+		sealed = retryAEADv2.Seal(tag[:0], retryNonceV2[:], nil, retryBuf.Bytes())
+	} else {
+		if retryAEADv1 == nil {
+			retryAEADv1 = initAEAD([16]byte{0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e})
+		}
+		sealed = retryAEADv1.Seal(tag[:0], retryNonceV1[:], nil, retryBuf.Bytes())
+	}
+	if len(sealed) != 16 {
+		panic(fmt.Sprintf("unexpected Retry integrity tag length: %d", len(sealed)))
+	}
+	return &tag
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go126.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go126.go
new file mode 100644
index 00000000..bf95697e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/retry_go126.go
@@ -0,0 +1,70 @@
+//go:build go1.26
+
+package handshake
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/fips140"
+	"fmt"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// used for QUIC v1 (RFC 9000)
+var retryAEADv1 = initAEAD([16]byte{0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e})
+
+// used for QUIC v2 (RFC 9369)
+var retryAEADv2 = initAEAD([16]byte{0x8f, 0xb4, 0xb0, 0x1b, 0x56, 0xac, 0x48, 0xe2, 0x60, 0xfb, 0xcb, 0xce, 0xad, 0x7c, 0xcc, 0x92})
+
+func initAEAD(key [16]byte) cipher.AEAD {
+	aes, err := aes.NewCipher(key[:])
+	if err != nil {
+		panic(err)
+	}
+	var aead cipher.AEAD
+	// Retry packet authentication uses the fixed key and nonce specified by RFC 9000.
+	// It acts as an integrity tag for the Retry packet itself, protecting against
+	// accidental modification and making injection harder. It is not used to encrypt
+	// packet contents and therefore outside the scope of FIPS 140 enforcement.
+	fips140.WithoutEnforcement(func() {
+		var err error
+		aead, err = cipher.NewGCM(aes)
+		if err != nil {
+			panic(err)
+		}
+	})
+	return aead
+}
+
+var (
+	retryBuf     bytes.Buffer
+	retryMutex   sync.Mutex
+	retryNonceV1 = [12]byte{0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb}
+	retryNonceV2 = [12]byte{0xd8, 0x69, 0x69, 0xbc, 0x2d, 0x7c, 0x6d, 0x99, 0x90, 0xef, 0xb0, 0x4a}
+)
+
+// GetRetryIntegrityTag calculates the integrity tag on a Retry packet
+func GetRetryIntegrityTag(retry []byte, origDestConnID protocol.ConnectionID, version protocol.Version) *[16]byte {
+	retryMutex.Lock()
+	defer retryMutex.Unlock()
+
+	retryBuf.WriteByte(uint8(origDestConnID.Len()))
+	retryBuf.Write(origDestConnID.Bytes())
+	retryBuf.Write(retry)
+	defer retryBuf.Reset()
+
+	var tag [16]byte
+	var sealed []byte
+	if version == protocol.Version2 {
+		sealed = retryAEADv2.Seal(tag[:0], retryNonceV2[:], nil, retryBuf.Bytes())
+	} else {
+		sealed = retryAEADv1.Seal(tag[:0], retryNonceV1[:], nil, retryBuf.Bytes())
+	}
+	if len(sealed) != 16 {
+		panic(fmt.Sprintf("unexpected Retry integrity tag length: %d", len(sealed)))
+	}
+	return &tag
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/session_ticket.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/session_ticket.go
new file mode 100644
index 00000000..eee09d35
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/session_ticket.go
@@ -0,0 +1,55 @@
+package handshake
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+const sessionTicketRevision = 5
+
+type sessionTicket struct {
+	Parameters *wire.TransportParameters
+}
+
+func (t *sessionTicket) Marshal() []byte {
+	b := make([]byte, 0, 256)
+	b = quicvarint.Append(b, sessionTicketRevision)
+	return t.Parameters.MarshalForSessionTicket(b)
+}
+
+func (t *sessionTicket) Unmarshal(b []byte) error {
+	rev, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return errors.New("failed to read session ticket revision")
+	}
+	b = b[l:]
+	if rev != sessionTicketRevision {
+		return fmt.Errorf("unknown session ticket revision: %d", rev)
+	}
+	var tp wire.TransportParameters
+	if err := tp.UnmarshalFromSessionTicket(b); err != nil {
+		return fmt.Errorf("unmarshaling transport parameters from session ticket failed: %s", err.Error())
+	}
+	t.Parameters = &tp
+	return nil
+}
+
+const extraPrefix = "quic-go1"
+
+func addSessionStateExtraPrefix(b []byte) []byte {
+	return append([]byte(extraPrefix), b...)
+}
+
+func findSessionStateExtraData(extras [][]byte) []byte {
+	prefix := []byte(extraPrefix)
+	for _, extra := range extras {
+		if data, ok := bytes.CutPrefix(extra, prefix); ok {
+			return data
+		}
+	}
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go126.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go126.go
new file mode 100644
index 00000000..693a08db
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go126.go
@@ -0,0 +1,54 @@
+//go:build !go1.27
+
+package handshake
+
+import (
+	"crypto/tls"
+	"net"
+)
+
+func setupConfigForClient(conf *tls.Config) *tls.Config {
+	conf = conf.Clone()
+	conf.MinVersion = tls.VersionTLS13
+	return conf
+}
+
+func setupConfigForServer(conf *tls.Config, localAddr, remoteAddr net.Addr) *tls.Config {
+	// Workaround for https://github.com/golang/go/issues/60506.
+	// This initializes the session tickets _before_ cloning the config.
+	_, _ = conf.DecryptTicket(nil, tls.ConnectionState{})
+
+	conf = conf.Clone()
+	conf.MinVersion = tls.VersionTLS13
+
+	// The tls.Config contains two callbacks that pass in a tls.ClientHelloInfo.
+	// Since crypto/tls doesn't do it, we need to make sure to set the Conn field with a fake net.Conn
+	// that allows the caller to get the local and the remote address.
+	if conf.GetConfigForClient != nil {
+		gcfc := conf.GetConfigForClient
+		conf.GetConfigForClient = func(info *tls.ClientHelloInfo) (*tls.Config, error) {
+			info.Conn = &conn{localAddr: localAddr, remoteAddr: remoteAddr}
+			c, err := gcfc(info)
+			if c != nil {
+				// we're returning a tls.Config here, so we need to apply this recursively
+				c = setupConfigForServer(c, localAddr, remoteAddr)
+			}
+			return c, err
+		}
+	}
+	if conf.GetCertificate != nil {
+		gc := conf.GetCertificate
+		conf.GetCertificate = func(info *tls.ClientHelloInfo) (*tls.Certificate, error) {
+			info.Conn = &conn{localAddr: localAddr, remoteAddr: remoteAddr}
+			return gc(info)
+		}
+	}
+	return conf
+}
+
+func getQUICConfig(tlsConf *tls.Config, _, _ net.Addr) *tls.QUICConfig {
+	return &tls.QUICConfig{
+		TLSConfig:           tlsConf,
+		EnableSessionEvents: true,
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go127.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go127.go
new file mode 100644
index 00000000..7b9d4816
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/tls_config_go127.go
@@ -0,0 +1,24 @@
+//go:build go1.27
+
+package handshake
+
+import (
+	"crypto/tls"
+	"net"
+)
+
+func setupConfigForClient(conf *tls.Config) *tls.Config {
+	return conf
+}
+
+func setupConfigForServer(conf *tls.Config, _, _ net.Addr) *tls.Config {
+	return conf
+}
+
+func getQUICConfig(tlsConf *tls.Config, localAddr, remoteAddr net.Addr) *tls.QUICConfig {
+	return &tls.QUICConfig{
+		TLSConfig:           tlsConf,
+		EnableSessionEvents: true,
+		ClientHelloInfoConn: &conn{localAddr: localAddr, remoteAddr: remoteAddr},
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_generator.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_generator.go
new file mode 100644
index 00000000..933670dd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_generator.go
@@ -0,0 +1,126 @@
+package handshake
+
+import (
+	"bytes"
+	"encoding/asn1"
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+const (
+	tokenPrefixIP byte = iota
+	tokenPrefixString
+)
+
+// A Token is derived from the client address and can be used to verify the ownership of this address.
+type Token struct {
+	IsRetryToken      bool
+	SentTime          time.Time
+	encodedRemoteAddr []byte
+	// only set for tokens sent in NEW_TOKEN frames
+	RTT time.Duration
+	// only set for retry tokens
+	OriginalDestConnectionID protocol.ConnectionID
+	RetrySrcConnectionID     protocol.ConnectionID
+}
+
+// ValidateRemoteAddr validates the address, but does not check expiration
+func (t *Token) ValidateRemoteAddr(addr net.Addr) bool {
+	return bytes.Equal(encodeRemoteAddr(addr), t.encodedRemoteAddr)
+}
+
+// token is the struct that is used for ASN1 serialization and deserialization
+type token struct {
+	IsRetryToken             bool
+	RemoteAddr               []byte
+	Timestamp                int64
+	RTT                      int64 // in mus
+	OriginalDestConnectionID []byte
+	RetrySrcConnectionID     []byte
+}
+
+// A TokenGenerator generates tokens
+type TokenGenerator struct {
+	tokenProtector tokenProtector
+}
+
+// NewTokenGenerator initializes a new TokenGenerator
+func NewTokenGenerator(key TokenProtectorKey) *TokenGenerator {
+	return &TokenGenerator{tokenProtector: *newTokenProtector(key)}
+}
+
+// NewRetryToken generates a new token for a Retry for a given source address
+func (g *TokenGenerator) NewRetryToken(
+	raddr net.Addr,
+	origDestConnID protocol.ConnectionID,
+	retrySrcConnID protocol.ConnectionID,
+) ([]byte, error) {
+	data, err := asn1.Marshal(token{
+		IsRetryToken:             true,
+		RemoteAddr:               encodeRemoteAddr(raddr),
+		OriginalDestConnectionID: origDestConnID.Bytes(),
+		RetrySrcConnectionID:     retrySrcConnID.Bytes(),
+		Timestamp:                time.Now().UnixNano(),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return g.tokenProtector.NewToken(data)
+}
+
+// NewToken generates a new token to be sent in a NEW_TOKEN frame
+func (g *TokenGenerator) NewToken(raddr net.Addr, rtt time.Duration) ([]byte, error) {
+	data, err := asn1.Marshal(token{
+		RemoteAddr: encodeRemoteAddr(raddr),
+		Timestamp:  time.Now().UnixNano(),
+		RTT:        rtt.Microseconds(),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return g.tokenProtector.NewToken(data)
+}
+
+// DecodeToken decodes a token
+func (g *TokenGenerator) DecodeToken(encrypted []byte) (*Token, error) {
+	// if the client didn't send any token, DecodeToken will be called with a nil-slice
+	if len(encrypted) == 0 {
+		return nil, nil
+	}
+
+	data, err := g.tokenProtector.DecodeToken(encrypted)
+	if err != nil {
+		return nil, err
+	}
+	t := &token{}
+	rest, err := asn1.Unmarshal(data, t)
+	if err != nil {
+		return nil, err
+	}
+	if len(rest) != 0 {
+		return nil, fmt.Errorf("rest when unpacking token: %d", len(rest))
+	}
+	token := &Token{
+		IsRetryToken:      t.IsRetryToken,
+		SentTime:          time.Unix(0, t.Timestamp),
+		encodedRemoteAddr: t.RemoteAddr,
+	}
+	if t.IsRetryToken {
+		token.OriginalDestConnectionID = protocol.ParseConnectionID(t.OriginalDestConnectionID)
+		token.RetrySrcConnectionID = protocol.ParseConnectionID(t.RetrySrcConnectionID)
+	} else {
+		token.RTT = time.Duration(t.RTT) * time.Microsecond
+	}
+	return token, nil
+}
+
+// encodeRemoteAddr encodes a remote address such that it can be saved in the token
+func encodeRemoteAddr(remoteAddr net.Addr) []byte {
+	if udpAddr, ok := remoteAddr.(*net.UDPAddr); ok {
+		return append([]byte{tokenPrefixIP}, udpAddr.IP...)
+	}
+	return append([]byte{tokenPrefixString}, []byte(remoteAddr.String())...)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_protector.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_protector.go
new file mode 100644
index 00000000..74cd7d7b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/token_protector.go
@@ -0,0 +1,78 @@
+package handshake
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/hkdf"
+	"crypto/rand"
+	"crypto/sha256"
+	"fmt"
+)
+
+// TokenProtectorKey is the key used to encrypt both Retry and session resumption tokens.
+type TokenProtectorKey [32]byte
+
+const tokenSaltSize = 32
+
+// tokenProtector is used to create and verify a token
+type tokenProtector struct {
+	key TokenProtectorKey
+}
+
+// newTokenProtector creates a source for source address tokens
+func newTokenProtector(key TokenProtectorKey) *tokenProtector {
+	return &tokenProtector{key: key}
+}
+
+// NewToken encodes data into a new token.
+func (s *tokenProtector) NewToken(data []byte) ([]byte, error) {
+	var salt [tokenSaltSize]byte
+	if _, err := rand.Read(salt[:]); err != nil {
+		return nil, err
+	}
+	aead, err := s.createAEAD(salt[:])
+	if err != nil {
+		return nil, err
+	}
+	return append(salt[:], aead.Seal(nil, nil, data, nil)...), nil
+}
+
+// DecodeToken decodes a token.
+func (s *tokenProtector) DecodeToken(p []byte) ([]byte, error) {
+	if len(p) < tokenSaltSize {
+		return nil, fmt.Errorf("token too short: %d", len(p))
+	}
+	salt := p[:tokenSaltSize]
+	aead, err := s.createAEAD(salt)
+	if err != nil {
+		return nil, err
+	}
+	if len(p[tokenSaltSize:]) < aead.Overhead() {
+		return nil, fmt.Errorf("token too short: %d", len(p))
+	}
+	return aead.Open(nil, nil, p[tokenSaltSize:], nil)
+}
+
+const tokenProtectorHKDFInfo = "quic-go token source"
+
+func (s *tokenProtector) createAEAD(salt []byte) (cipher.AEAD, error) {
+	prk, err := hkdf.Extract(sha256.New, s.key[:], salt)
+	if err != nil {
+		return nil, err
+	}
+
+	key, err := hkdf.Expand(sha256.New, prk, tokenProtectorHKDFInfo, 32)
+	if err != nil {
+		return nil, err
+	}
+
+	c, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	aead, err := cipher.NewGCMWithRandomNonce(c)
+	if err != nil {
+		return nil, err
+	}
+	return aead, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/handshake/updatable_aead.go b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/updatable_aead.go
new file mode 100644
index 00000000..f88f76ad
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/handshake/updatable_aead.go
@@ -0,0 +1,372 @@
+package handshake
+
+import (
+	"crypto"
+	"crypto/cipher"
+	"crypto/tls"
+	"encoding/binary"
+	"fmt"
+	"sync/atomic"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+var keyUpdateInterval atomic.Uint64
+
+func init() {
+	keyUpdateInterval.Store(protocol.KeyUpdateInterval)
+}
+
+func SetKeyUpdateInterval(v uint64) (reset func()) {
+	old := keyUpdateInterval.Swap(v)
+	return func() { keyUpdateInterval.Store(old) }
+}
+
+// FirstKeyUpdateInterval is the maximum number of packets we send or receive before initiating the first key update.
+// It's a package-level variable to allow modifying it for testing purposes.
+var FirstKeyUpdateInterval uint64 = 100
+
+type updatableAEAD struct {
+	suite cipherSuite
+
+	keyPhase           protocol.KeyPhase
+	largestAcked       protocol.PacketNumber
+	firstPacketNumber  protocol.PacketNumber
+	handshakeConfirmed bool
+
+	invalidPacketLimit uint64
+	invalidPacketCount uint64
+
+	// Time when the keys should be dropped. Keys are dropped on the next call to Open().
+	prevRcvAEADExpiry monotime.Time
+	prevRcvAEAD       cipher.AEAD
+
+	firstRcvdWithCurrentKey protocol.PacketNumber
+	firstSentWithCurrentKey protocol.PacketNumber
+	highestRcvdPN           protocol.PacketNumber // highest packet number received (which could be successfully unprotected)
+	numRcvdWithCurrentKey   uint64
+	numSentWithCurrentKey   uint64
+	rcvAEAD                 cipher.AEAD
+	sendAEAD                cipher.AEAD
+	// caches cipher.AEAD.Overhead(). This speeds up calls to Overhead().
+	aeadOverhead int
+
+	nextRcvAEAD           cipher.AEAD
+	nextSendAEAD          cipher.AEAD
+	nextRcvTrafficSecret  []byte
+	nextSendTrafficSecret []byte
+
+	headerDecrypter headerProtector
+	headerEncrypter headerProtector
+
+	rttStats *utils.RTTStats
+
+	qlogger qlogwriter.Recorder
+	logger  utils.Logger
+	version protocol.Version
+
+	// use a single slice to avoid allocations
+	nonceBuf []byte
+}
+
+var (
+	_ ShortHeaderOpener = &updatableAEAD{}
+	_ ShortHeaderSealer = &updatableAEAD{}
+)
+
+func newUpdatableAEAD(rttStats *utils.RTTStats, qlogger qlogwriter.Recorder, logger utils.Logger, version protocol.Version) *updatableAEAD {
+	return &updatableAEAD{
+		firstPacketNumber:       protocol.InvalidPacketNumber,
+		largestAcked:            protocol.InvalidPacketNumber,
+		firstRcvdWithCurrentKey: protocol.InvalidPacketNumber,
+		firstSentWithCurrentKey: protocol.InvalidPacketNumber,
+		rttStats:                rttStats,
+		qlogger:                 qlogger,
+		logger:                  logger,
+		version:                 version,
+	}
+}
+
+func (a *updatableAEAD) rollKeys() {
+	if a.prevRcvAEAD != nil {
+		a.logger.Debugf("Dropping key phase %d ahead of scheduled time. Drop time was: %s", a.keyPhase-1, a.prevRcvAEADExpiry)
+		if a.qlogger != nil {
+			a.qlogger.RecordEvent(qlog.KeyDiscarded{
+				KeyType:  qlog.KeyTypeClient1RTT,
+				KeyPhase: a.keyPhase - 1,
+			})
+			a.qlogger.RecordEvent(qlog.KeyDiscarded{
+				KeyType:  qlog.KeyTypeServer1RTT,
+				KeyPhase: a.keyPhase - 1,
+			})
+		}
+		a.prevRcvAEADExpiry = 0
+	}
+
+	a.keyPhase++
+	a.firstRcvdWithCurrentKey = protocol.InvalidPacketNumber
+	a.firstSentWithCurrentKey = protocol.InvalidPacketNumber
+	a.numRcvdWithCurrentKey = 0
+	a.numSentWithCurrentKey = 0
+	a.prevRcvAEAD = a.rcvAEAD
+	a.rcvAEAD = a.nextRcvAEAD
+	a.sendAEAD = a.nextSendAEAD
+
+	a.nextRcvTrafficSecret = a.getNextTrafficSecret(a.suite.Hash, a.nextRcvTrafficSecret)
+	a.nextSendTrafficSecret = a.getNextTrafficSecret(a.suite.Hash, a.nextSendTrafficSecret)
+	a.nextRcvAEAD = createAEAD(a.suite, a.nextRcvTrafficSecret, a.version)
+	a.nextSendAEAD = createAEAD(a.suite, a.nextSendTrafficSecret, a.version)
+}
+
+func (a *updatableAEAD) startKeyDropTimer(now monotime.Time) {
+	d := 3 * a.rttStats.PTO(true)
+	a.logger.Debugf("Starting key drop timer to drop key phase %d (in %s)", a.keyPhase-1, d)
+	a.prevRcvAEADExpiry = now.Add(d)
+}
+
+func (a *updatableAEAD) getNextTrafficSecret(hash crypto.Hash, ts []byte) []byte {
+	return hkdfExpandLabel(hash, ts, []byte{}, "quic ku", hash.Size())
+}
+
+// SetReadKey sets the read key.
+// For the client, this function is called before SetWriteKey.
+// For the server, this function is called after SetWriteKey.
+func (a *updatableAEAD) SetReadKey(suite cipherSuite, trafficSecret []byte) {
+	a.rcvAEAD = createAEAD(suite, trafficSecret, a.version)
+	a.headerDecrypter = newHeaderProtector(suite, trafficSecret, false, a.version)
+	if a.suite.ID == 0 { // suite is not set yet
+		a.setAEADParameters(a.rcvAEAD, suite)
+	}
+
+	a.nextRcvTrafficSecret = a.getNextTrafficSecret(suite.Hash, trafficSecret)
+	a.nextRcvAEAD = createAEAD(suite, a.nextRcvTrafficSecret, a.version)
+}
+
+// SetWriteKey sets the write key.
+// For the client, this function is called after SetReadKey.
+// For the server, this function is called before SetReadKey.
+func (a *updatableAEAD) SetWriteKey(suite cipherSuite, trafficSecret []byte) {
+	a.sendAEAD = createAEAD(suite, trafficSecret, a.version)
+	a.headerEncrypter = newHeaderProtector(suite, trafficSecret, false, a.version)
+	if a.suite.ID == 0 { // suite is not set yet
+		a.setAEADParameters(a.sendAEAD, suite)
+	}
+
+	a.nextSendTrafficSecret = a.getNextTrafficSecret(suite.Hash, trafficSecret)
+	a.nextSendAEAD = createAEAD(suite, a.nextSendTrafficSecret, a.version)
+}
+
+func (a *updatableAEAD) setAEADParameters(aead cipher.AEAD, suite cipherSuite) {
+	a.nonceBuf = make([]byte, aead.NonceSize())
+	a.aeadOverhead = aead.Overhead()
+	a.suite = suite
+	switch suite.ID {
+	case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384:
+		a.invalidPacketLimit = protocol.InvalidPacketLimitAES
+	case tls.TLS_CHACHA20_POLY1305_SHA256:
+		a.invalidPacketLimit = protocol.InvalidPacketLimitChaCha
+	default:
+		panic(fmt.Sprintf("unknown cipher suite %d", suite.ID))
+	}
+}
+
+func (a *updatableAEAD) DecodePacketNumber(wirePN protocol.PacketNumber, wirePNLen protocol.PacketNumberLen) protocol.PacketNumber {
+	return protocol.DecodePacketNumber(wirePNLen, a.highestRcvdPN, wirePN)
+}
+
+func (a *updatableAEAD) Open(dst, src []byte, rcvTime monotime.Time, pn protocol.PacketNumber, kp protocol.KeyPhaseBit, ad []byte) ([]byte, error) {
+	dec, err := a.open(dst, src, rcvTime, pn, kp, ad)
+	if err == ErrDecryptionFailed {
+		a.invalidPacketCount++
+		if a.invalidPacketCount >= a.invalidPacketLimit {
+			return nil, &qerr.TransportError{ErrorCode: qerr.AEADLimitReached}
+		}
+	}
+	if err == nil {
+		a.highestRcvdPN = max(a.highestRcvdPN, pn)
+	}
+	return dec, err
+}
+
+func (a *updatableAEAD) open(dst, src []byte, rcvTime monotime.Time, pn protocol.PacketNumber, kp protocol.KeyPhaseBit, ad []byte) ([]byte, error) {
+	if a.prevRcvAEAD != nil && !a.prevRcvAEADExpiry.IsZero() && rcvTime.After(a.prevRcvAEADExpiry) {
+		a.prevRcvAEAD = nil
+		a.logger.Debugf("Dropping key phase %d", a.keyPhase-1)
+		a.prevRcvAEADExpiry = 0
+		if a.qlogger != nil {
+			a.qlogger.RecordEvent(qlog.KeyDiscarded{
+				KeyType:  qlog.KeyTypeClient1RTT,
+				KeyPhase: a.keyPhase - 1,
+			})
+			a.qlogger.RecordEvent(qlog.KeyDiscarded{
+				KeyType:  qlog.KeyTypeServer1RTT,
+				KeyPhase: a.keyPhase - 1,
+			})
+		}
+	}
+	binary.BigEndian.PutUint64(a.nonceBuf[len(a.nonceBuf)-8:], uint64(pn))
+	if kp != a.keyPhase.Bit() {
+		if a.keyPhase > 0 && a.firstRcvdWithCurrentKey == protocol.InvalidPacketNumber || pn < a.firstRcvdWithCurrentKey {
+			if a.prevRcvAEAD == nil {
+				return nil, ErrKeysDropped
+			}
+			// we updated the key, but the peer hasn't updated yet
+			dec, err := a.prevRcvAEAD.Open(dst, a.nonceBuf, src, ad)
+			if err != nil {
+				err = ErrDecryptionFailed
+			}
+			return dec, err
+		}
+		// try opening the packet with the next key phase
+		dec, err := a.nextRcvAEAD.Open(dst, a.nonceBuf, src, ad)
+		if err != nil {
+			return nil, ErrDecryptionFailed
+		}
+		// Opening succeeded. Check if the peer was allowed to update.
+		if a.keyPhase > 0 && a.firstSentWithCurrentKey == protocol.InvalidPacketNumber {
+			return nil, &qerr.TransportError{
+				ErrorCode:    qerr.KeyUpdateError,
+				ErrorMessage: "keys updated too quickly",
+			}
+		}
+		a.rollKeys()
+		a.logger.Debugf("Peer updated keys to %d", a.keyPhase)
+		// The peer initiated this key update. It's safe to drop the keys for the previous generation now.
+		// Start a timer to drop the previous key generation.
+		a.startKeyDropTimer(rcvTime)
+		if a.qlogger != nil {
+			a.qlogger.RecordEvent(qlog.KeyUpdated{
+				Trigger:  qlog.KeyUpdateRemote,
+				KeyType:  qlog.KeyTypeClient1RTT,
+				KeyPhase: a.keyPhase,
+			})
+			a.qlogger.RecordEvent(qlog.KeyUpdated{
+				Trigger:  qlog.KeyUpdateRemote,
+				KeyType:  qlog.KeyTypeServer1RTT,
+				KeyPhase: a.keyPhase,
+			})
+		}
+		a.firstRcvdWithCurrentKey = pn
+		return dec, err
+	}
+	// The AEAD we're using here will be the qtls.aeadAESGCM13.
+	// It uses the nonce provided here and XOR it with the IV.
+	dec, err := a.rcvAEAD.Open(dst, a.nonceBuf, src, ad)
+	if err != nil {
+		return dec, ErrDecryptionFailed
+	}
+	a.numRcvdWithCurrentKey++
+	if a.firstRcvdWithCurrentKey == protocol.InvalidPacketNumber {
+		// We initiated the key updated, and now we received the first packet protected with the new key phase.
+		// Therefore, we are certain that the peer rolled its keys as well. Start a timer to drop the old keys.
+		if a.keyPhase > 0 {
+			a.logger.Debugf("Peer confirmed key update to phase %d", a.keyPhase)
+			a.startKeyDropTimer(rcvTime)
+		}
+		a.firstRcvdWithCurrentKey = pn
+	}
+	return dec, err
+}
+
+func (a *updatableAEAD) Seal(dst, src []byte, pn protocol.PacketNumber, ad []byte) []byte {
+	if a.firstSentWithCurrentKey == protocol.InvalidPacketNumber {
+		a.firstSentWithCurrentKey = pn
+	}
+	if a.firstPacketNumber == protocol.InvalidPacketNumber {
+		a.firstPacketNumber = pn
+	}
+	a.numSentWithCurrentKey++
+	binary.BigEndian.PutUint64(a.nonceBuf[len(a.nonceBuf)-8:], uint64(pn))
+	// The AEAD we're using here will be the qtls.aeadAESGCM13.
+	// It uses the nonce provided here and XOR it with the IV.
+	return a.sendAEAD.Seal(dst, a.nonceBuf, src, ad)
+}
+
+func (a *updatableAEAD) SetLargestAcked(pn protocol.PacketNumber) error {
+	if a.firstSentWithCurrentKey != protocol.InvalidPacketNumber &&
+		pn >= a.firstSentWithCurrentKey && a.numRcvdWithCurrentKey == 0 {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.KeyUpdateError,
+			ErrorMessage: fmt.Sprintf("received ACK for key phase %d, but peer didn't update keys", a.keyPhase),
+		}
+	}
+	a.largestAcked = pn
+	return nil
+}
+
+func (a *updatableAEAD) SetHandshakeConfirmed() {
+	a.handshakeConfirmed = true
+}
+
+func (a *updatableAEAD) updateAllowed() bool {
+	if !a.handshakeConfirmed {
+		return false
+	}
+	// the first key update is allowed as soon as the handshake is confirmed
+	return a.keyPhase == 0 ||
+		// subsequent key updates as soon as a packet sent with that key phase has been acknowledged
+		(a.firstSentWithCurrentKey != protocol.InvalidPacketNumber &&
+			a.largestAcked != protocol.InvalidPacketNumber &&
+			a.largestAcked >= a.firstSentWithCurrentKey)
+}
+
+func (a *updatableAEAD) shouldInitiateKeyUpdate() bool {
+	if !a.updateAllowed() {
+		return false
+	}
+	// Initiate the first key update shortly after the handshake, in order to exercise the key update mechanism.
+	if a.keyPhase == 0 {
+		if a.numRcvdWithCurrentKey >= FirstKeyUpdateInterval || a.numSentWithCurrentKey >= FirstKeyUpdateInterval {
+			return true
+		}
+	}
+	if a.numRcvdWithCurrentKey >= keyUpdateInterval.Load() {
+		a.logger.Debugf("Received %d packets with current key phase. Initiating key update to the next key phase: %d", a.numRcvdWithCurrentKey, a.keyPhase+1)
+		return true
+	}
+	if a.numSentWithCurrentKey >= keyUpdateInterval.Load() {
+		a.logger.Debugf("Sent %d packets with current key phase. Initiating key update to the next key phase: %d", a.numSentWithCurrentKey, a.keyPhase+1)
+		return true
+	}
+	return false
+}
+
+func (a *updatableAEAD) KeyPhase() protocol.KeyPhaseBit {
+	if a.shouldInitiateKeyUpdate() {
+		a.rollKeys()
+		if a.qlogger != nil {
+			a.qlogger.RecordEvent(qlog.KeyUpdated{
+				Trigger:  qlog.KeyUpdateLocal,
+				KeyType:  qlog.KeyTypeClient1RTT,
+				KeyPhase: a.keyPhase,
+			})
+			a.qlogger.RecordEvent(qlog.KeyUpdated{
+				Trigger:  qlog.KeyUpdateLocal,
+				KeyType:  qlog.KeyTypeServer1RTT,
+				KeyPhase: a.keyPhase,
+			})
+		}
+	}
+	return a.keyPhase.Bit()
+}
+
+func (a *updatableAEAD) Overhead() int {
+	return a.aeadOverhead
+}
+
+func (a *updatableAEAD) EncryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	a.headerEncrypter.EncryptHeader(sample, firstByte, hdrBytes)
+}
+
+func (a *updatableAEAD) DecryptHeader(sample []byte, firstByte *byte, hdrBytes []byte) {
+	a.headerDecrypter.DecryptHeader(sample, firstByte, hdrBytes)
+}
+
+func (a *updatableAEAD) FirstPacketNumber() protocol.PacketNumber {
+	return a.firstPacketNumber
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/monotime/time.go b/backend/vendor/github.com/quic-go/quic-go/internal/monotime/time.go
new file mode 100644
index 00000000..eda61dc6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/monotime/time.go
@@ -0,0 +1,90 @@
+// Package monotime provides a monotonic time representation that is useful for
+// measuring elapsed time.
+// It is designed as a memory optimized drop-in replacement for time.Time, with
+// a monotime.Time consuming just 8 bytes instead of 24 bytes.
+package monotime
+
+import (
+	"time"
+)
+
+// The absolute value doesn't matter, but it should be in the past,
+// so that every timestamp obtained with Now() is non-zero,
+// even on systems with low timer resolutions (e.g. Windows).
+var start = time.Now().Add(-time.Hour)
+
+// A Time represents an instant in monotonic time.
+// Times can be compared using the comparison operators, but the specific
+// value is implementation-dependent and should not be relied upon.
+// The zero value of Time doesn't have any specific meaning.
+type Time int64
+
+// Now returns the current monotonic time.
+func Now() Time {
+	return Time(time.Since(start).Nanoseconds())
+}
+
+// Sub returns the duration t-t2. If the result exceeds the maximum (or minimum)
+// value that can be stored in a Duration, the maximum (or minimum) duration
+// will be returned.
+// To compute t-d for a duration d, use t.Add(-d).
+func (t Time) Sub(t2 Time) time.Duration {
+	return time.Duration(t - t2)
+}
+
+// Add returns the time t+d.
+func (t Time) Add(d time.Duration) Time {
+	return Time(int64(t) + d.Nanoseconds())
+}
+
+// After reports whether the time instant t is after t2.
+func (t Time) After(t2 Time) bool {
+	return t > t2
+}
+
+// Before reports whether the time instant t is before t2.
+func (t Time) Before(t2 Time) bool {
+	return t < t2
+}
+
+// IsZero reports whether t represents the zero time instant.
+func (t Time) IsZero() bool {
+	return t == 0
+}
+
+// Equal reports whether t and t2 represent the same time instant.
+func (t Time) Equal(t2 Time) bool {
+	return t == t2
+}
+
+// ToTime converts the monotonic time to a time.Time value.
+// The returned time.Time will have the same instant as the monotonic time,
+// but may be subject to clock adjustments.
+func (t Time) ToTime() time.Time {
+	if t.IsZero() {
+		return time.Time{}
+	}
+	return start.Add(time.Duration(t))
+}
+
+// Since returns the time elapsed since t. It is shorthand for Now().Sub(t).
+func Since(t Time) time.Duration {
+	return Now().Sub(t)
+}
+
+// Until returns the duration until t.
+// It is shorthand for t.Sub(Now()).
+// If t is in the past, the returned duration will be negative.
+func Until(t Time) time.Duration {
+	return time.Duration(t - Now())
+}
+
+// FromTime converts a time.Time to a monotonic Time.
+// The conversion is relative to the package's start time and may lose
+// precision if the time.Time is far from the start time.
+func FromTime(t time.Time) Time {
+	if t.IsZero() {
+		return 0
+	}
+	return Time(t.Sub(start).Nanoseconds())
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/connection_id.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/connection_id.go
new file mode 100644
index 00000000..ce3171fc
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/connection_id.go
@@ -0,0 +1,116 @@
+package protocol
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"io"
+)
+
+var ErrInvalidConnectionIDLen = errors.New("invalid Connection ID length")
+
+// An ArbitraryLenConnectionID is a QUIC Connection ID able to represent Connection IDs according to RFC 8999.
+// Future QUIC versions might allow connection ID lengths up to 255 bytes, while QUIC v1
+// restricts the length to 20 bytes.
+type ArbitraryLenConnectionID []byte
+
+func (c ArbitraryLenConnectionID) Len() int {
+	return len(c)
+}
+
+func (c ArbitraryLenConnectionID) Bytes() []byte {
+	return c
+}
+
+func (c ArbitraryLenConnectionID) String() string {
+	if c.Len() == 0 {
+		return "(empty)"
+	}
+	return hex.EncodeToString(c.Bytes())
+}
+
+const maxConnectionIDLen = 20
+
+// A ConnectionID in QUIC
+type ConnectionID struct {
+	b [20]byte
+	l uint8
+}
+
+// GenerateConnectionID generates a connection ID using cryptographic random
+func GenerateConnectionID(l int) (ConnectionID, error) {
+	var c ConnectionID
+	c.l = uint8(l)
+	_, err := rand.Read(c.b[:l])
+	return c, err
+}
+
+// ParseConnectionID interprets b as a Connection ID.
+// It panics if b is longer than 20 bytes.
+func ParseConnectionID(b []byte) ConnectionID {
+	if len(b) > maxConnectionIDLen {
+		panic("invalid conn id length")
+	}
+	var c ConnectionID
+	c.l = uint8(len(b))
+	copy(c.b[:c.l], b)
+	return c
+}
+
+// GenerateConnectionIDForInitial generates a connection ID for the Initial packet.
+// It uses a length randomly chosen between 8 and 20 bytes.
+func GenerateConnectionIDForInitial() (ConnectionID, error) {
+	r := make([]byte, 1)
+	if _, err := rand.Read(r); err != nil {
+		return ConnectionID{}, err
+	}
+	l := MinConnectionIDLenInitial + int(r[0])%(maxConnectionIDLen-MinConnectionIDLenInitial+1)
+	return GenerateConnectionID(l)
+}
+
+// ReadConnectionID reads a connection ID of length len from the given io.Reader.
+// It returns io.EOF if there are not enough bytes to read.
+func ReadConnectionID(r io.Reader, l int) (ConnectionID, error) {
+	var c ConnectionID
+	if l == 0 {
+		return c, nil
+	}
+	if l > maxConnectionIDLen {
+		return c, ErrInvalidConnectionIDLen
+	}
+	c.l = uint8(l)
+	_, err := io.ReadFull(r, c.b[:l])
+	if err == io.ErrUnexpectedEOF {
+		return c, io.EOF
+	}
+	return c, err
+}
+
+// Len returns the length of the connection ID in bytes
+func (c ConnectionID) Len() int {
+	return int(c.l)
+}
+
+// Bytes returns the byte representation
+func (c ConnectionID) Bytes() []byte {
+	return c.b[:c.l]
+}
+
+func (c ConnectionID) String() string {
+	if c.Len() == 0 {
+		return "(empty)"
+	}
+	return hex.EncodeToString(c.Bytes())
+}
+
+type DefaultConnectionIDGenerator struct {
+	ConnLen int
+}
+
+func (d *DefaultConnectionIDGenerator) GenerateConnectionID() (ConnectionID, error) {
+	return GenerateConnectionID(d.ConnLen)
+}
+
+func (d *DefaultConnectionIDGenerator) ConnectionIDLen() int {
+	return d.ConnLen
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/encryption_level.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/encryption_level.go
new file mode 100644
index 00000000..40aa331a
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/encryption_level.go
@@ -0,0 +1,65 @@
+package protocol
+
+import (
+	"crypto/tls"
+	"fmt"
+)
+
+// EncryptionLevel is the encryption level
+// Default value is Unencrypted
+type EncryptionLevel uint8
+
+const (
+	// EncryptionInitial is the Initial encryption level
+	EncryptionInitial EncryptionLevel = 1 + iota
+	// EncryptionHandshake is the Handshake encryption level
+	EncryptionHandshake
+	// Encryption0RTT is the 0-RTT encryption level
+	Encryption0RTT
+	// Encryption1RTT is the 1-RTT encryption level
+	Encryption1RTT
+)
+
+func (e EncryptionLevel) String() string {
+	switch e {
+	case EncryptionInitial:
+		return "Initial"
+	case EncryptionHandshake:
+		return "Handshake"
+	case Encryption0RTT:
+		return "0-RTT"
+	case Encryption1RTT:
+		return "1-RTT"
+	}
+	return "unknown"
+}
+
+func (e EncryptionLevel) ToTLSEncryptionLevel() tls.QUICEncryptionLevel {
+	switch e {
+	case EncryptionInitial:
+		return tls.QUICEncryptionLevelInitial
+	case EncryptionHandshake:
+		return tls.QUICEncryptionLevelHandshake
+	case Encryption1RTT:
+		return tls.QUICEncryptionLevelApplication
+	case Encryption0RTT:
+		return tls.QUICEncryptionLevelEarly
+	default:
+		panic(fmt.Sprintf("unexpected encryption level: %s", e))
+	}
+}
+
+func FromTLSEncryptionLevel(e tls.QUICEncryptionLevel) EncryptionLevel {
+	switch e {
+	case tls.QUICEncryptionLevelInitial:
+		return EncryptionInitial
+	case tls.QUICEncryptionLevelHandshake:
+		return EncryptionHandshake
+	case tls.QUICEncryptionLevelApplication:
+		return Encryption1RTT
+	case tls.QUICEncryptionLevelEarly:
+		return Encryption0RTT
+	default:
+		panic(fmt.Sprintf("unexpect encryption level: %s", e))
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/key_phase.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/key_phase.go
new file mode 100644
index 00000000..edd740cf
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/key_phase.go
@@ -0,0 +1,36 @@
+package protocol
+
+// KeyPhase is the key phase
+type KeyPhase uint64
+
+// Bit determines the key phase bit
+func (p KeyPhase) Bit() KeyPhaseBit {
+	if p%2 == 0 {
+		return KeyPhaseZero
+	}
+	return KeyPhaseOne
+}
+
+// KeyPhaseBit is the key phase bit
+type KeyPhaseBit uint8
+
+const (
+	// KeyPhaseUndefined is an undefined key phase
+	KeyPhaseUndefined KeyPhaseBit = iota
+	// KeyPhaseZero is key phase 0
+	KeyPhaseZero
+	// KeyPhaseOne is key phase 1
+	KeyPhaseOne
+)
+
+func (p KeyPhaseBit) String() string {
+	//nolint:exhaustive
+	switch p {
+	case KeyPhaseZero:
+		return "0"
+	case KeyPhaseOne:
+		return "1"
+	default:
+		return "undefined"
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/packet_number.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/packet_number.go
new file mode 100644
index 00000000..9422db92
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/packet_number.go
@@ -0,0 +1,57 @@
+package protocol
+
+// A PacketNumber in QUIC
+type PacketNumber int64
+
+// InvalidPacketNumber is a packet number that is never sent.
+// In QUIC, 0 is a valid packet number.
+const InvalidPacketNumber PacketNumber = -1
+
+// PacketNumberLen is the length of the packet number in bytes
+type PacketNumberLen uint8
+
+const (
+	// PacketNumberLen1 is a packet number length of 1 byte
+	PacketNumberLen1 PacketNumberLen = 1
+	// PacketNumberLen2 is a packet number length of 2 bytes
+	PacketNumberLen2 PacketNumberLen = 2
+	// PacketNumberLen3 is a packet number length of 3 bytes
+	PacketNumberLen3 PacketNumberLen = 3
+	// PacketNumberLen4 is a packet number length of 4 bytes
+	PacketNumberLen4 PacketNumberLen = 4
+)
+
+// DecodePacketNumber calculates the packet number based its length and the last seen packet number
+// This function is taken from https://www.rfc-editor.org/rfc/rfc9000.html#section-a.3.
+func DecodePacketNumber(length PacketNumberLen, largest PacketNumber, truncated PacketNumber) PacketNumber {
+	expected := largest + 1
+	win := PacketNumber(1 << (length * 8))
+	hwin := win / 2
+	mask := win - 1
+	candidate := (expected & ^mask) | truncated
+	if candidate <= expected-hwin && candidate < 1<<62-win {
+		return candidate + win
+	}
+	if candidate > expected+hwin && candidate >= win {
+		return candidate - win
+	}
+	return candidate
+}
+
+// PacketNumberLengthForHeader gets the length of the packet number for the public header
+// it never chooses a PacketNumberLen of 1 byte, since this is too short under certain circumstances
+func PacketNumberLengthForHeader(pn, largestAcked PacketNumber) PacketNumberLen {
+	var numUnacked PacketNumber
+	if largestAcked == InvalidPacketNumber {
+		numUnacked = pn + 1
+	} else {
+		numUnacked = pn - largestAcked
+	}
+	if numUnacked < 1<<(16-1) {
+		return PacketNumberLen2
+	}
+	if numUnacked < 1<<(24-1) {
+		return PacketNumberLen3
+	}
+	return PacketNumberLen4
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/params.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/params.go
new file mode 100644
index 00000000..0861d57f
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/params.go
@@ -0,0 +1,169 @@
+package protocol
+
+import "time"
+
+// DesiredReceiveBufferSize is the kernel UDP receive buffer size that we'd like to use.
+const DesiredReceiveBufferSize = (1 << 20) * 7 // 7 MB
+
+// DesiredSendBufferSize is the kernel UDP send buffer size that we'd like to use.
+const DesiredSendBufferSize = (1 << 20) * 7 // 7 MB
+
+// InitialPacketSize is the initial (before Path MTU discovery) maximum packet size used.
+const InitialPacketSize = 1280
+
+// MaxCongestionWindowPackets is the maximum congestion window in packet.
+const MaxCongestionWindowPackets = 10000
+
+// MaxUndecryptablePackets limits the number of undecryptable packets that are queued in the connection.
+const MaxUndecryptablePackets = 32
+
+// ConnectionFlowControlMultiplier determines how much larger the connection flow control windows needs to be relative to any stream's flow control window
+// This is the value that Chromium is using
+const ConnectionFlowControlMultiplier = 1.5
+
+// DefaultInitialMaxStreamData is the default initial stream-level flow control window for receiving data
+const DefaultInitialMaxStreamData = (1 << 10) * 512 // 512 kb
+
+// DefaultInitialMaxData is the connection-level flow control window for receiving data
+const DefaultInitialMaxData = ConnectionFlowControlMultiplier * DefaultInitialMaxStreamData
+
+// DefaultMaxReceiveStreamFlowControlWindow is the default maximum stream-level flow control window for receiving data
+const DefaultMaxReceiveStreamFlowControlWindow = 6 * (1 << 20) // 6 MB
+
+// DefaultMaxReceiveConnectionFlowControlWindow is the default connection-level flow control window for receiving data
+const DefaultMaxReceiveConnectionFlowControlWindow = 15 * (1 << 20) // 15 MB
+
+// WindowUpdateThreshold is the fraction of the receive window that has to be consumed before an higher offset is advertised to the client
+const WindowUpdateThreshold = 0.25
+
+// DefaultMaxIncomingStreams is the maximum number of streams that a peer may open
+const DefaultMaxIncomingStreams = 100
+
+// DefaultMaxIncomingUniStreams is the maximum number of unidirectional streams that a peer may open
+const DefaultMaxIncomingUniStreams = 100
+
+// MaxServerUnprocessedPackets is the max number of packets stored in the server that are not yet processed.
+const MaxServerUnprocessedPackets = 1024
+
+// MaxConnUnprocessedPackets is the max number of packets stored in each connection that are not yet processed.
+const MaxConnUnprocessedPackets = 256
+
+// SkipPacketInitialPeriod is the initial period length used for packet number skipping to prevent an Optimistic ACK attack.
+// Every time a packet number is skipped, the period is doubled, up to SkipPacketMaxPeriod.
+const SkipPacketInitialPeriod PacketNumber = 256
+
+// SkipPacketMaxPeriod is the maximum period length used for packet number skipping.
+const SkipPacketMaxPeriod PacketNumber = 128 * 1024
+
+// MaxAcceptQueueSize is the maximum number of connections that the server queues for accepting.
+// If the queue is full, new connection attempts will be rejected.
+const MaxAcceptQueueSize = 32
+
+// TokenValidity is the duration that a (non-retry) token is considered valid
+const TokenValidity = 24 * time.Hour
+
+// MaxOutstandingSentPackets is maximum number of packets saved for retransmission.
+// When reached, it imposes a soft limit on sending new packets:
+// Sending ACKs and retransmission is still allowed, but now new regular packets can be sent.
+const MaxOutstandingSentPackets = 2 * MaxCongestionWindowPackets
+
+// MaxTrackedSentPackets is maximum number of sent packets saved for retransmission.
+// When reached, no more packets will be sent.
+// This value *must* be larger than MaxOutstandingSentPackets.
+const MaxTrackedSentPackets = MaxOutstandingSentPackets * 5 / 4
+
+// MaxNonAckElicitingAcks is the maximum number of packets containing an ACK,
+// but no ack-eliciting frames, that we send in a row
+const MaxNonAckElicitingAcks = 19
+
+// MaxStreamFrameSorterGaps is the maximum number of gaps between received StreamFrames
+// prevents DoS attacks against the streamFrameSorter
+const MaxStreamFrameSorterGaps = 1000
+
+// MinStreamFrameBufferSize is the minimum data length of a received STREAM frame
+// that we use the buffer for. This protects against a DoS where an attacker would send us
+// very small STREAM frames to consume a lot of memory.
+const MinStreamFrameBufferSize = 128
+
+// MinCoalescedPacketSize is the minimum size of a coalesced packet that we pack.
+// If a packet has less than this number of bytes, we won't coalesce any more packets onto it.
+const MinCoalescedPacketSize = 128
+
+// MaxCryptoStreamOffset is the maximum offset allowed on any of the crypto streams.
+// This limits the size of the ClientHello and Certificates that can be received.
+const MaxCryptoStreamOffset = 16 * (1 << 10)
+
+// MinRemoteIdleTimeout is the minimum value that we accept for the remote idle timeout
+const MinRemoteIdleTimeout = 5 * time.Second
+
+// DefaultIdleTimeout is the default idle timeout
+const DefaultIdleTimeout = 30 * time.Second
+
+// DefaultHandshakeIdleTimeout is the default idle timeout used before handshake completion.
+const DefaultHandshakeIdleTimeout = 5 * time.Second
+
+// MinStreamFrameSize is the minimum size that has to be left in a packet, so that we add another STREAM frame.
+// This avoids splitting up STREAM frames into small pieces, which has 2 advantages:
+// 1. it reduces the framing overhead
+// 2. it reduces the head-of-line blocking, when a packet is lost
+const MinStreamFrameSize ByteCount = 128
+
+// MaxPostHandshakeCryptoFrameSize is the maximum size of CRYPTO frames
+// we send after the handshake completes.
+const MaxPostHandshakeCryptoFrameSize = 1000
+
+// MaxNumAckRanges is the maximum number of ACK ranges that we send in an ACK frame.
+// It also serves as a limit for the packet history.
+// If at any point we keep track of more ranges, old ranges are discarded.
+//
+// This value also guarantees that ACK Range Count value in the ACK frame can be encoded
+// in a single byte varint.
+const MaxNumAckRanges = 64
+
+// MinPacingDelay is the minimum duration that is used for packet pacing
+// If the packet packing frequency is higher, multiple packets might be sent at once.
+// Example: For a packet pacing delay of 200μs, we would send 5 packets at once, wait for 1ms, and so forth.
+const MinPacingDelay = time.Millisecond
+
+// DefaultConnectionIDLength is the connection ID length that is used for multiplexed connections
+// if no other value is configured.
+const DefaultConnectionIDLength = 4
+
+// MaxActiveConnectionIDs is the number of connection IDs that we're storing.
+const MaxActiveConnectionIDs = 4
+
+// MaxIssuedConnectionIDs is the maximum number of connection IDs that we're issuing at the same time.
+const MaxIssuedConnectionIDs = 6
+
+// PacketsPerConnectionID is the number of packets we send using one connection ID.
+// If the peer provices us with enough new connection IDs, we switch to a new connection ID.
+const PacketsPerConnectionID = 10000
+
+// AckDelayExponent is the ack delay exponent used when sending ACKs.
+const AckDelayExponent = 3
+
+// Estimated timer granularity.
+// The loss detection timer will not be set to a value smaller than granularity.
+const TimerGranularity = time.Millisecond
+
+// MaxAckDelay is the maximum time by which we delay sending ACKs.
+const MaxAckDelay = 25 * time.Millisecond
+
+// MaxAckDelayInclGranularity is the max_ack_delay including the timer granularity.
+// This is the value that should be advertised to the peer.
+const MaxAckDelayInclGranularity = MaxAckDelay + TimerGranularity
+
+// KeyUpdateInterval is the maximum number of packets we send or receive before initiating a key update.
+const KeyUpdateInterval = 100 * 1000
+
+// Max0RTTQueueingDuration is the maximum time that we store 0-RTT packets in order to wait for the corresponding Initial to be received.
+const Max0RTTQueueingDuration = 100 * time.Millisecond
+
+// Max0RTTQueues is the maximum number of connections that we buffer 0-RTT packets for.
+const Max0RTTQueues = 32
+
+// Max0RTTQueueLen is the maximum number of 0-RTT packets that we buffer for each connection.
+// When a new connection is created, all buffered packets are passed to the connection immediately.
+// To avoid blocking, this value has to be smaller than MaxConnUnprocessedPackets.
+// To avoid packets being dropped as undecryptable by the connection, this value has to be smaller than MaxUndecryptablePackets.
+const Max0RTTQueueLen = 31
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/perspective.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/perspective.go
new file mode 100644
index 00000000..5a29d3ce
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/perspective.go
@@ -0,0 +1,26 @@
+package protocol
+
+// Perspective determines if we're acting as a server or a client
+type Perspective int
+
+// the perspectives
+const (
+	PerspectiveServer Perspective = 1
+	PerspectiveClient Perspective = 2
+)
+
+// Opposite returns the perspective of the peer
+func (p Perspective) Opposite() Perspective {
+	return 3 - p
+}
+
+func (p Perspective) String() string {
+	switch p {
+	case PerspectiveServer:
+		return "server"
+	case PerspectiveClient:
+		return "client"
+	default:
+		return "invalid perspective"
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/protocol.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/protocol.go
new file mode 100644
index 00000000..b1109ff4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/protocol.go
@@ -0,0 +1,156 @@
+package protocol
+
+import (
+	"fmt"
+	"time"
+)
+
+// The PacketType is the Long Header Type
+type PacketType uint8
+
+const (
+	// PacketTypeInitial is the packet type of an Initial packet
+	PacketTypeInitial PacketType = 1 + iota
+	// PacketTypeRetry is the packet type of a Retry packet
+	PacketTypeRetry
+	// PacketTypeHandshake is the packet type of a Handshake packet
+	PacketTypeHandshake
+	// PacketType0RTT is the packet type of a 0-RTT packet
+	PacketType0RTT
+)
+
+func (t PacketType) String() string {
+	switch t {
+	case PacketTypeInitial:
+		return "Initial"
+	case PacketTypeRetry:
+		return "Retry"
+	case PacketTypeHandshake:
+		return "Handshake"
+	case PacketType0RTT:
+		return "0-RTT Protected"
+	default:
+		return fmt.Sprintf("unknown packet type: %d", t)
+	}
+}
+
+type ECN uint8
+
+const (
+	ECNUnsupported ECN = iota
+	ECNNon             // 00
+	ECT1               // 01
+	ECT0               // 10
+	ECNCE              // 11
+)
+
+func ParseECNHeaderBits(bits byte) ECN {
+	switch bits {
+	case 0:
+		return ECNNon
+	case 0b00000010:
+		return ECT0
+	case 0b00000001:
+		return ECT1
+	case 0b00000011:
+		return ECNCE
+	default:
+		panic("invalid ECN bits")
+	}
+}
+
+func (e ECN) ToHeaderBits() byte {
+	//nolint:exhaustive // There are only 4 values.
+	switch e {
+	case ECNNon:
+		return 0
+	case ECT0:
+		return 0b00000010
+	case ECT1:
+		return 0b00000001
+	case ECNCE:
+		return 0b00000011
+	default:
+		panic("ECN unsupported")
+	}
+}
+
+func (e ECN) String() string {
+	switch e {
+	case ECNUnsupported:
+		return "ECN unsupported"
+	case ECNNon:
+		return "Not-ECT"
+	case ECT1:
+		return "ECT(1)"
+	case ECT0:
+		return "ECT(0)"
+	case ECNCE:
+		return "CE"
+	default:
+		return fmt.Sprintf("invalid ECN value: %d", e)
+	}
+}
+
+// A ByteCount in QUIC
+type ByteCount int64
+
+// MaxByteCount is the maximum value of a ByteCount
+const MaxByteCount = ByteCount(1<<62 - 1)
+
+// InvalidByteCount is an invalid byte count
+const InvalidByteCount ByteCount = -1
+
+// A StatelessResetToken is a stateless reset token.
+type StatelessResetToken [16]byte
+
+// MaxPacketBufferSize maximum packet size of any QUIC packet, based on
+// ethernet's max size, minus the IP and UDP headers. IPv6 has a 40 byte header,
+// UDP adds an additional 8 bytes.  This is a total overhead of 48 bytes.
+// Ethernet's max packet size is 1500 bytes,  1500 - 48 = 1452.
+const MaxPacketBufferSize = 1452
+
+// MaxLargePacketBufferSize is used when using GSO
+const MaxLargePacketBufferSize = 20 * 1024
+
+// MinInitialPacketSize is the minimum size an Initial packet is required to have.
+const MinInitialPacketSize = 1200
+
+// MinUnknownVersionPacketSize is the minimum size a packet with an unknown version
+// needs to have in order to trigger a Version Negotiation packet.
+const MinUnknownVersionPacketSize = MinInitialPacketSize
+
+// MinStatelessResetSize is the minimum size of a stateless reset packet that we send
+const MinStatelessResetSize = 1 /* first byte */ + 20 /* max. conn ID length */ + 4 /* max. packet number length */ + 1 /* min. payload length */ + 16 /* token */
+
+// MinReceivedStatelessResetSize is the minimum size of a received stateless reset,
+// as specified in section 10.3 of RFC 9000.
+const MinReceivedStatelessResetSize = 5 + 16
+
+// MinConnectionIDLenInitial is the minimum length of the destination connection ID on an Initial packet.
+const MinConnectionIDLenInitial = 8
+
+// DefaultAckDelayExponent is the default ack delay exponent
+const DefaultAckDelayExponent = 3
+
+// DefaultActiveConnectionIDLimit is the default active connection ID limit
+const DefaultActiveConnectionIDLimit = 2
+
+// MaxAckDelayExponent is the maximum ack delay exponent
+const MaxAckDelayExponent = 20
+
+// DefaultMaxAckDelay is the default max_ack_delay
+const DefaultMaxAckDelay = 25 * time.Millisecond
+
+// MaxMaxAckDelay is the maximum max_ack_delay
+const MaxMaxAckDelay = (1<<14 - 1) * time.Millisecond
+
+// MaxConnIDLen is the maximum length of the connection ID
+const MaxConnIDLen = 20
+
+// InvalidPacketLimitAES is the maximum number of packets that we can fail to decrypt when using
+// AEAD_AES_128_GCM or AEAD_AES_265_GCM.
+const InvalidPacketLimitAES = 1 << 52
+
+// InvalidPacketLimitChaCha is the maximum number of packets that we can fail to decrypt when using AEAD_CHACHA20_POLY1305.
+const InvalidPacketLimitChaCha = 1 << 36
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/stream.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/stream.go
new file mode 100644
index 00000000..a71be52f
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/stream.go
@@ -0,0 +1,102 @@
+package protocol
+
+import "github.com/quic-go/quic-go/quicvarint"
+
+// StreamType encodes if this is a unidirectional or bidirectional stream
+type StreamType uint8
+
+const (
+	// StreamTypeUni is a unidirectional stream
+	StreamTypeUni StreamType = iota
+	// StreamTypeBidi is a bidirectional stream
+	StreamTypeBidi
+)
+
+// InvalidPacketNumber is a stream ID that is invalid.
+// The first valid stream ID in QUIC is 0.
+const InvalidStreamID StreamID = -1
+
+// StreamNum is the stream number
+type StreamNum int64
+
+const (
+	// InvalidStreamNum is an invalid stream number.
+	InvalidStreamNum = -1
+	// MaxStreamCount is the maximum stream count value that can be sent in MAX_STREAMS frames
+	// and as the stream count in the transport parameters
+	MaxStreamCount StreamNum = 1 << 60
+	// MaxStreamID is the maximum stream ID
+	MaxStreamID StreamID = quicvarint.Max
+)
+
+const (
+	// FirstOutgoingBidiStreamClient is the first bidirectional stream opened by the client
+	FirstOutgoingBidiStreamClient StreamID = 0
+	// FirstOutgoingUniStreamClient is the first unidirectional stream opened by the client
+	FirstOutgoingUniStreamClient StreamID = 2
+	// FirstOutgoingBidiStreamServer is the first bidirectional stream opened by the server
+	FirstOutgoingBidiStreamServer StreamID = 1
+	// FirstOutgoingUniStreamServer is the first unidirectional stream opened by the server
+	FirstOutgoingUniStreamServer StreamID = 3
+)
+
+const (
+	// FirstIncomingBidiStreamServer is the first bidirectional stream accepted by the server
+	FirstIncomingBidiStreamServer = FirstOutgoingBidiStreamClient
+	// FirstIncomingUniStreamServer is the first unidirectional stream accepted by the server
+	FirstIncomingUniStreamServer = FirstOutgoingUniStreamClient
+	// FirstIncomingBidiStreamClient is the first bidirectional stream accepted by the client
+	FirstIncomingBidiStreamClient = FirstOutgoingBidiStreamServer
+	// FirstIncomingUniStreamClient is the first unidirectional stream accepted by the client
+	FirstIncomingUniStreamClient = FirstOutgoingUniStreamServer
+)
+
+// StreamID calculates the stream ID.
+func (s StreamNum) StreamID(stype StreamType, pers Perspective) StreamID {
+	if s == 0 {
+		return InvalidStreamID
+	}
+	var first StreamID
+	switch stype {
+	case StreamTypeBidi:
+		switch pers {
+		case PerspectiveClient:
+			first = 0
+		case PerspectiveServer:
+			first = 1
+		}
+	case StreamTypeUni:
+		switch pers {
+		case PerspectiveClient:
+			first = 2
+		case PerspectiveServer:
+			first = 3
+		}
+	}
+	return first + 4*StreamID(s-1)
+}
+
+// A StreamID in QUIC
+type StreamID int64
+
+// StreamInitiator says if the stream was initiated by the client or by the server.
+func StreamInitiator(id StreamID) Perspective {
+	if id%2 == 0 {
+		return PerspectiveClient
+	}
+	return PerspectiveServer
+}
+
+// StreamTypeOf says if this is a unidirectional or bidirectional stream.
+func StreamTypeOf(id StreamID) StreamType {
+	if id%4 >= 2 {
+		return StreamTypeUni
+	}
+	return StreamTypeBidi
+}
+
+// StreamNum returns how many streams in total are below this
+// Example: for stream 9 it returns 3 (i.e. streams 1, 5 and 9)
+func (s StreamID) StreamNum() StreamNum {
+	return StreamNum(s/4) + 1
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/protocol/version.go b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/version.go
new file mode 100644
index 00000000..8abca506
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/protocol/version.go
@@ -0,0 +1,115 @@
+package protocol
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"math"
+	mrand "math/rand/v2"
+	"slices"
+	"sync"
+)
+
+// Version is a version number as int
+type Version uint32
+
+// gQUIC version range as defined in the wiki: https://github.com/quicwg/base-drafts/wiki/QUIC-Versions
+const (
+	gquicVersion0   = 0x51303030
+	maxGquicVersion = 0x51303439
+)
+
+// The version numbers, making grepping easier
+const (
+	VersionUnknown Version = math.MaxUint32
+	versionDraft29 Version = 0xff00001d // draft-29 used to be a widely deployed version
+	Version1       Version = 0x1
+	Version2       Version = 0x6b3343cf
+)
+
+// SupportedVersions lists the versions that the server supports
+// must be in sorted descending order
+var SupportedVersions = []Version{Version1, Version2}
+
+// IsValidVersion says if the version is known to quic-go
+func IsValidVersion(v Version) bool {
+	return v == Version1 || IsSupportedVersion(SupportedVersions, v)
+}
+
+func (vn Version) String() string {
+	switch vn {
+	case VersionUnknown:
+		return "unknown"
+	case versionDraft29:
+		return "draft-29"
+	case Version1:
+		return "v1"
+	case Version2:
+		return "v2"
+	default:
+		if vn.isGQUIC() {
+			return fmt.Sprintf("gQUIC %d", vn.toGQUICVersion())
+		}
+		return fmt.Sprintf("%#x", uint32(vn))
+	}
+}
+
+func (vn Version) isGQUIC() bool {
+	return vn > gquicVersion0 && vn <= maxGquicVersion
+}
+
+func (vn Version) toGQUICVersion() int {
+	return int(10*(vn-gquicVersion0)/0x100) + int(vn%0x10)
+}
+
+// IsSupportedVersion returns true if the server supports this version
+func IsSupportedVersion(supported []Version, v Version) bool {
+	return slices.Contains(supported, v)
+}
+
+// ChooseSupportedVersion finds the best version in the overlap of ours and theirs
+// ours is a slice of versions that we support, sorted by our preference (descending)
+// theirs is a slice of versions offered by the peer. The order does not matter.
+// The bool returned indicates if a matching version was found.
+func ChooseSupportedVersion(ours, theirs []Version) (Version, bool) {
+	for _, ourVer := range ours {
+		if slices.Contains(theirs, ourVer) {
+			return ourVer, true
+		}
+	}
+	return 0, false
+}
+
+var (
+	versionNegotiationMx   sync.Mutex
+	versionNegotiationRand mrand.Rand
+)
+
+func init() {
+	var seed [16]byte
+	rand.Read(seed[:])
+	versionNegotiationRand = *mrand.New(mrand.NewPCG(
+		binary.BigEndian.Uint64(seed[:8]),
+		binary.BigEndian.Uint64(seed[8:]),
+	))
+}
+
+// generateReservedVersion generates a reserved version (v & 0x0f0f0f0f == 0x0a0a0a0a)
+func generateReservedVersion() Version {
+	var b [4]byte
+	binary.BigEndian.PutUint32(b[:], versionNegotiationRand.Uint32())
+	return Version((binary.BigEndian.Uint32(b[:]) | 0x0a0a0a0a) & 0xfafafafa)
+}
+
+// GetGreasedVersions adds one reserved version number to a slice of version numbers, at a random position.
+// It doesn't modify the supported slice.
+func GetGreasedVersions(supported []Version) []Version {
+	versionNegotiationMx.Lock()
+	defer versionNegotiationMx.Unlock()
+	randPos := versionNegotiationRand.IntN(len(supported) + 1)
+	greased := make([]Version, len(supported)+1)
+	copy(greased, supported[:randPos])
+	greased[randPos] = generateReservedVersion()
+	copy(greased[randPos+1:], supported[randPos:])
+	return greased
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/qerr/error_codes.go b/backend/vendor/github.com/quic-go/quic-go/internal/qerr/error_codes.go
new file mode 100644
index 00000000..00361308
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/qerr/error_codes.go
@@ -0,0 +1,87 @@
+package qerr
+
+import (
+	"crypto/tls"
+	"fmt"
+)
+
+// TransportErrorCode is a QUIC transport error.
+type TransportErrorCode uint64
+
+// The error codes defined by QUIC
+const (
+	NoError                   TransportErrorCode = 0x0
+	InternalError             TransportErrorCode = 0x1
+	ConnectionRefused         TransportErrorCode = 0x2
+	FlowControlError          TransportErrorCode = 0x3
+	StreamLimitError          TransportErrorCode = 0x4
+	StreamStateError          TransportErrorCode = 0x5
+	FinalSizeError            TransportErrorCode = 0x6
+	FrameEncodingError        TransportErrorCode = 0x7
+	TransportParameterError   TransportErrorCode = 0x8
+	ConnectionIDLimitError    TransportErrorCode = 0x9
+	ProtocolViolation         TransportErrorCode = 0xa
+	InvalidToken              TransportErrorCode = 0xb
+	ApplicationErrorErrorCode TransportErrorCode = 0xc
+	CryptoBufferExceeded      TransportErrorCode = 0xd
+	KeyUpdateError            TransportErrorCode = 0xe
+	AEADLimitReached          TransportErrorCode = 0xf
+	NoViablePathError         TransportErrorCode = 0x10
+)
+
+func (e TransportErrorCode) IsCryptoError() bool {
+	return e >= 0x100 && e < 0x200
+}
+
+// Message is a description of the error.
+// It only returns a non-empty string for crypto errors.
+func (e TransportErrorCode) Message() string {
+	if !e.IsCryptoError() {
+		return ""
+	}
+	return tls.AlertError(e - 0x100).Error()
+}
+
+func (e TransportErrorCode) String() string {
+	switch e {
+	case NoError:
+		return "NO_ERROR"
+	case InternalError:
+		return "INTERNAL_ERROR"
+	case ConnectionRefused:
+		return "CONNECTION_REFUSED"
+	case FlowControlError:
+		return "FLOW_CONTROL_ERROR"
+	case StreamLimitError:
+		return "STREAM_LIMIT_ERROR"
+	case StreamStateError:
+		return "STREAM_STATE_ERROR"
+	case FinalSizeError:
+		return "FINAL_SIZE_ERROR"
+	case FrameEncodingError:
+		return "FRAME_ENCODING_ERROR"
+	case TransportParameterError:
+		return "TRANSPORT_PARAMETER_ERROR"
+	case ConnectionIDLimitError:
+		return "CONNECTION_ID_LIMIT_ERROR"
+	case ProtocolViolation:
+		return "PROTOCOL_VIOLATION"
+	case InvalidToken:
+		return "INVALID_TOKEN"
+	case ApplicationErrorErrorCode:
+		return "APPLICATION_ERROR"
+	case CryptoBufferExceeded:
+		return "CRYPTO_BUFFER_EXCEEDED"
+	case KeyUpdateError:
+		return "KEY_UPDATE_ERROR"
+	case AEADLimitReached:
+		return "AEAD_LIMIT_REACHED"
+	case NoViablePathError:
+		return "NO_VIABLE_PATH"
+	default:
+		if e.IsCryptoError() {
+			return fmt.Sprintf("CRYPTO_ERROR %#x", uint16(e))
+		}
+		return fmt.Sprintf("unknown error code: %#x", uint16(e))
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/qerr/errors.go b/backend/vendor/github.com/quic-go/quic-go/internal/qerr/errors.go
new file mode 100644
index 00000000..7fe1c293
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/qerr/errors.go
@@ -0,0 +1,134 @@
+package qerr
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+var (
+	ErrHandshakeTimeout = &HandshakeTimeoutError{}
+	ErrIdleTimeout      = &IdleTimeoutError{}
+)
+
+type TransportError struct {
+	Remote       bool
+	FrameType    uint64
+	ErrorCode    TransportErrorCode
+	ErrorMessage string
+	error        error // only set for local errors, sometimes
+}
+
+var _ error = &TransportError{}
+
+// NewLocalCryptoError create a new TransportError instance for a crypto error
+func NewLocalCryptoError(tlsAlert uint8, err error) *TransportError {
+	return &TransportError{
+		ErrorCode: 0x100 + TransportErrorCode(tlsAlert),
+		error:     err,
+	}
+}
+
+func (e *TransportError) Error() string {
+	str := fmt.Sprintf("%s (%s)", e.ErrorCode.String(), getRole(e.Remote))
+	if e.FrameType != 0 {
+		str += fmt.Sprintf(" (frame type: %#x)", e.FrameType)
+	}
+	msg := e.ErrorMessage
+	if len(msg) == 0 && e.error != nil {
+		msg = e.error.Error()
+	}
+	if len(msg) == 0 {
+		msg = e.ErrorCode.Message()
+	}
+	if len(msg) == 0 {
+		return str
+	}
+	return str + ": " + msg
+}
+
+func (e *TransportError) Unwrap() []error { return []error{net.ErrClosed, e.error} }
+
+func (e *TransportError) Is(target error) bool {
+	t, ok := target.(*TransportError)
+	return ok && e.ErrorCode == t.ErrorCode && e.FrameType == t.FrameType && e.Remote == t.Remote
+}
+
+// An ApplicationErrorCode is an application-defined error code.
+type ApplicationErrorCode uint64
+
+// A StreamErrorCode is an error code used to cancel streams.
+type StreamErrorCode uint64
+
+type ApplicationError struct {
+	Remote       bool
+	ErrorCode    ApplicationErrorCode
+	ErrorMessage string
+}
+
+var _ error = &ApplicationError{}
+
+func (e *ApplicationError) Error() string {
+	if len(e.ErrorMessage) == 0 {
+		return fmt.Sprintf("Application error %#x (%s)", e.ErrorCode, getRole(e.Remote))
+	}
+	return fmt.Sprintf("Application error %#x (%s): %s", e.ErrorCode, getRole(e.Remote), e.ErrorMessage)
+}
+
+func (e *ApplicationError) Unwrap() error { return net.ErrClosed }
+
+func (e *ApplicationError) Is(target error) bool {
+	t, ok := target.(*ApplicationError)
+	return ok && e.ErrorCode == t.ErrorCode && e.Remote == t.Remote
+}
+
+type IdleTimeoutError struct{}
+
+var _ error = &IdleTimeoutError{}
+
+func (e *IdleTimeoutError) Timeout() bool   { return true }
+func (e *IdleTimeoutError) Temporary() bool { return false }
+func (e *IdleTimeoutError) Error() string   { return "timeout: no recent network activity" }
+func (e *IdleTimeoutError) Unwrap() error   { return net.ErrClosed }
+
+type HandshakeTimeoutError struct{}
+
+var _ error = &HandshakeTimeoutError{}
+
+func (e *HandshakeTimeoutError) Timeout() bool   { return true }
+func (e *HandshakeTimeoutError) Temporary() bool { return false }
+func (e *HandshakeTimeoutError) Error() string   { return "timeout: handshake did not complete in time" }
+func (e *HandshakeTimeoutError) Unwrap() error   { return net.ErrClosed }
+
+// A VersionNegotiationError occurs when the client and the server can't agree on a QUIC version.
+type VersionNegotiationError struct {
+	Ours   []protocol.Version
+	Theirs []protocol.Version
+}
+
+func (e *VersionNegotiationError) Error() string {
+	return fmt.Sprintf("no compatible QUIC version found (we support %s, server offered %s)", e.Ours, e.Theirs)
+}
+
+func (e *VersionNegotiationError) Unwrap() error { return net.ErrClosed }
+
+// A StatelessResetError occurs when we receive a stateless reset.
+type StatelessResetError struct{}
+
+var _ net.Error = &StatelessResetError{}
+
+func (e *StatelessResetError) Error() string {
+	return "received a stateless reset"
+}
+
+func (e *StatelessResetError) Unwrap() error   { return net.ErrClosed }
+func (e *StatelessResetError) Timeout() bool   { return false }
+func (e *StatelessResetError) Temporary() bool { return true }
+
+func getRole(remote bool) string {
+	if remote {
+		return "remote"
+	}
+	return "local"
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/buffered_write_closer.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/buffered_write_closer.go
new file mode 100644
index 00000000..80ebfecb
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/buffered_write_closer.go
@@ -0,0 +1,26 @@
+package utils
+
+import (
+	"bufio"
+	"io"
+)
+
+type bufferedWriteCloser struct {
+	*bufio.Writer
+	io.Closer
+}
+
+// NewBufferedWriteCloser creates an io.WriteCloser from a bufio.Writer and an io.Closer
+func NewBufferedWriteCloser(writer *bufio.Writer, closer io.Closer) io.WriteCloser {
+	return &bufferedWriteCloser{
+		Writer: writer,
+		Closer: closer,
+	}
+}
+
+func (h bufferedWriteCloser) Close() error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	return h.Closer.Close()
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/connstats.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/connstats.go
new file mode 100644
index 00000000..19d88312
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/connstats.go
@@ -0,0 +1,14 @@
+package utils
+
+import "sync/atomic"
+
+// ConnectionStats stores stats for the connection. See the public
+// ConnectionStats struct in connection.go for more information
+type ConnectionStats struct {
+	BytesSent       atomic.Uint64
+	PacketsSent     atomic.Uint64
+	BytesReceived   atomic.Uint64
+	PacketsReceived atomic.Uint64
+	BytesLost       atomic.Uint64
+	PacketsLost     atomic.Uint64
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/README.md b/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/README.md
new file mode 100644
index 00000000..66482f4f
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/README.md
@@ -0,0 +1,6 @@
+# Usage
+
+This is the Go standard library implementation of a linked list 
+(https://golang.org/src/container/list/list.go), with the following modifications:
+* it uses Go generics
+* it allows passing in a `sync.Pool` (via the `NewWithPool` constructor) to reduce allocations of `Element` structs
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/linkedlist.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/linkedlist.go
new file mode 100644
index 00000000..804a3444
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/linkedlist/linkedlist.go
@@ -0,0 +1,264 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package list implements a doubly linked list.
+//
+// To iterate over a list (where l is a *List[T]):
+//
+//	for e := l.Front(); e != nil; e = e.Next() {
+//		// do something with e.Value
+//	}
+package list
+
+import "sync"
+
+func NewPool[T any]() *sync.Pool {
+	return &sync.Pool{New: func() any { return &Element[T]{} }}
+}
+
+// Element is an element of a linked list.
+type Element[T any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *Element[T]
+
+	// The list to which this element belongs.
+	list *List[T]
+
+	// The value stored with this element.
+	Value T
+}
+
+// Next returns the next list element or nil.
+func (e *Element[T]) Next() *Element[T] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *Element[T]) Prev() *Element[T] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+func (e *Element[T]) List() *List[T] {
+	return e.list
+}
+
+// List represents a doubly linked list.
+// The zero value for List is an empty list ready to use.
+type List[T any] struct {
+	root Element[T] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int        // current list length excluding (this) sentinel element
+
+	pool *sync.Pool
+}
+
+// Init initializes or clears list l.
+func (l *List[T]) Init() *List[T] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// New returns an initialized list.
+func New[T any]() *List[T] { return new(List[T]).Init() }
+
+// NewWithPool returns an initialized list, using a sync.Pool for list elements.
+func NewWithPool[T any](pool *sync.Pool) *List[T] {
+	l := &List[T]{pool: pool}
+	return l.Init()
+}
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *List[T]) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *List[T]) Front() *Element[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *List[T]) Back() *Element[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *List[T]) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *List[T]) insert(e, at *Element[T]) *Element[T] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *List[T]) insertValue(v T, at *Element[T]) *Element[T] {
+	var e *Element[T]
+	if l.pool != nil {
+		e = l.pool.Get().(*Element[T])
+	} else {
+		e = &Element[T]{}
+	}
+	e.Value = v
+	return l.insert(e, at)
+}
+
+// remove removes e from its list, decrements l.len
+func (l *List[T]) remove(e *Element[T]) {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	if l.pool != nil {
+		l.pool.Put(e)
+	}
+	l.len--
+}
+
+// move moves e to next to at.
+func (l *List[T]) move(e, at *Element[T]) {
+	if e == at {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *List[T]) Remove(e *Element[T]) T {
+	v := e.Value
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero Element) and l.remove will crash
+		l.remove(e)
+	}
+	return v
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *List[T]) PushFront(v T) *Element[T] {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *List[T]) PushBack(v T) *Element[T] {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[T]) InsertBefore(v T, mark *Element[T]) *Element[T] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *List[T]) InsertAfter(v T, mark *Element[T]) *Element[T] {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[T]) MoveToFront(e *Element[T]) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *List[T]) MoveToBack(e *Element[T]) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[T]) MoveBefore(e, mark *Element[T]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *List[T]) MoveAfter(e, mark *Element[T]) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.move(e, mark)
+}
+
+// PushBackList inserts a copy of another list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[T]) PushBackList(other *List[T]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of another list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *List[T]) PushFrontList(other *List[T]) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/log.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/log.go
new file mode 100644
index 00000000..558803ef
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/log.go
@@ -0,0 +1,131 @@
+package utils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+// LogLevel of quic-go
+type LogLevel uint8
+
+const (
+	// LogLevelNothing disables
+	LogLevelNothing LogLevel = iota
+	// LogLevelError enables err logs
+	LogLevelError
+	// LogLevelInfo enables info logs (e.g. packets)
+	LogLevelInfo
+	// LogLevelDebug enables debug logs (e.g. packet contents)
+	LogLevelDebug
+)
+
+const logEnv = "QUIC_GO_LOG_LEVEL"
+
+// A Logger logs.
+type Logger interface {
+	SetLogLevel(LogLevel)
+	SetLogTimeFormat(format string)
+	WithPrefix(prefix string) Logger
+	Debug() bool
+
+	Errorf(format string, args ...any)
+	Infof(format string, args ...any)
+	Debugf(format string, args ...any)
+}
+
+// DefaultLogger is used by quic-go for logging.
+var DefaultLogger Logger
+
+type defaultLogger struct {
+	prefix string
+
+	logLevel   LogLevel
+	timeFormat string
+}
+
+var _ Logger = &defaultLogger{}
+
+// SetLogLevel sets the log level
+func (l *defaultLogger) SetLogLevel(level LogLevel) {
+	l.logLevel = level
+}
+
+// SetLogTimeFormat sets the format of the timestamp
+// an empty string disables the logging of timestamps
+func (l *defaultLogger) SetLogTimeFormat(format string) {
+	log.SetFlags(0) // disable timestamp logging done by the log package
+	l.timeFormat = format
+}
+
+// Debugf logs something
+func (l *defaultLogger) Debugf(format string, args ...any) {
+	if l.logLevel == LogLevelDebug {
+		l.logMessage(format, args...)
+	}
+}
+
+// Infof logs something
+func (l *defaultLogger) Infof(format string, args ...any) {
+	if l.logLevel >= LogLevelInfo {
+		l.logMessage(format, args...)
+	}
+}
+
+// Errorf logs something
+func (l *defaultLogger) Errorf(format string, args ...any) {
+	if l.logLevel >= LogLevelError {
+		l.logMessage(format, args...)
+	}
+}
+
+func (l *defaultLogger) logMessage(format string, args ...any) {
+	var pre string
+
+	if len(l.timeFormat) > 0 {
+		pre = time.Now().Format(l.timeFormat) + " "
+	}
+	if len(l.prefix) > 0 {
+		pre += l.prefix + " "
+	}
+	log.Printf(pre+format, args...)
+}
+
+func (l *defaultLogger) WithPrefix(prefix string) Logger {
+	if len(l.prefix) > 0 {
+		prefix = l.prefix + " " + prefix
+	}
+	return &defaultLogger{
+		logLevel:   l.logLevel,
+		timeFormat: l.timeFormat,
+		prefix:     prefix,
+	}
+}
+
+// Debug returns true if the log level is LogLevelDebug
+func (l *defaultLogger) Debug() bool {
+	return l.logLevel == LogLevelDebug
+}
+
+func init() {
+	DefaultLogger = &defaultLogger{}
+	DefaultLogger.SetLogLevel(readLoggingEnv())
+}
+
+func readLoggingEnv() LogLevel {
+	switch strings.ToLower(os.Getenv(logEnv)) {
+	case "":
+		return LogLevelNothing
+	case "debug":
+		return LogLevelDebug
+	case "info":
+		return LogLevelInfo
+	case "error":
+		return LogLevelError
+	default:
+		fmt.Fprintln(os.Stderr, "invalid quic-go log level, see https://github.com/quic-go/quic-go/wiki/Logging")
+		return LogLevelNothing
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/rand.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/rand.go
new file mode 100644
index 00000000..30069144
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/rand.go
@@ -0,0 +1,29 @@
+package utils
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+)
+
+// Rand is a wrapper around crypto/rand that adds some convenience functions known from math/rand.
+type Rand struct {
+	buf [4]byte
+}
+
+func (r *Rand) Int31() int32 {
+	rand.Read(r.buf[:])
+	return int32(binary.BigEndian.Uint32(r.buf[:]) & ^uint32(1<<31))
+}
+
+// copied from the standard library math/rand implementation of Int63n
+func (r *Rand) Int31n(n int32) int32 {
+	if n&(n-1) == 0 { // n is power of two, can mask
+		return r.Int31() & (n - 1)
+	}
+	max := int32((1 << 31) - 1 - (1<<31)%uint32(n))
+	v := r.Int31()
+	for v > max {
+		v = r.Int31()
+	}
+	return v % n
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/ringbuffer/ringbuffer.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/ringbuffer/ringbuffer.go
new file mode 100644
index 00000000..f9b2c797
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/ringbuffer/ringbuffer.go
@@ -0,0 +1,96 @@
+package ringbuffer
+
+// A RingBuffer is a ring buffer.
+// It acts as a heap that doesn't cause any allocations.
+type RingBuffer[T any] struct {
+	ring             []T
+	headPos, tailPos int
+	full             bool
+}
+
+// Init preallocates a buffer with a certain size.
+func (r *RingBuffer[T]) Init(size int) {
+	r.ring = make([]T, size)
+}
+
+// Len returns the number of elements in the ring buffer.
+func (r *RingBuffer[T]) Len() int {
+	if r.full {
+		return len(r.ring)
+	}
+	if r.tailPos >= r.headPos {
+		return r.tailPos - r.headPos
+	}
+	return r.tailPos - r.headPos + len(r.ring)
+}
+
+// Empty says if the ring buffer is empty.
+func (r *RingBuffer[T]) Empty() bool {
+	return !r.full && r.headPos == r.tailPos
+}
+
+// PushBack adds a new element.
+// If the ring buffer is full, its capacity is increased first.
+func (r *RingBuffer[T]) PushBack(t T) {
+	if r.full || len(r.ring) == 0 {
+		r.grow()
+	}
+	r.ring[r.tailPos] = t
+	r.tailPos++
+	if r.tailPos == len(r.ring) {
+		r.tailPos = 0
+	}
+	if r.tailPos == r.headPos {
+		r.full = true
+	}
+}
+
+// PopFront returns the next element.
+// It must not be called when the buffer is empty, that means that
+// callers might need to check if there are elements in the buffer first.
+func (r *RingBuffer[T]) PopFront() T {
+	if r.Empty() {
+		panic("github.com/quic-go/quic-go/internal/utils/ringbuffer: pop from an empty queue")
+	}
+	r.full = false
+	t := r.ring[r.headPos]
+	r.ring[r.headPos] = *new(T)
+	r.headPos++
+	if r.headPos == len(r.ring) {
+		r.headPos = 0
+	}
+	return t
+}
+
+// PeekFront returns the next element.
+// It must not be called when the buffer is empty, that means that
+// callers might need to check if there are elements in the buffer first.
+func (r *RingBuffer[T]) PeekFront() T {
+	if r.Empty() {
+		panic("github.com/quic-go/quic-go/internal/utils/ringbuffer: peek from an empty queue")
+	}
+	return r.ring[r.headPos]
+}
+
+// Grow the maximum size of the queue.
+// This method assume the queue is full.
+func (r *RingBuffer[T]) grow() {
+	oldRing := r.ring
+	newSize := len(oldRing) * 2
+	if newSize == 0 {
+		newSize = 1
+	}
+	r.ring = make([]T, newSize)
+	headLen := copy(r.ring, oldRing[r.headPos:])
+	copy(r.ring[headLen:], oldRing[:r.headPos])
+	r.headPos, r.tailPos, r.full = 0, len(oldRing), false
+}
+
+// Clear removes all elements.
+func (r *RingBuffer[T]) Clear() {
+	var zeroValue T
+	for i := range r.ring {
+		r.ring[i] = zeroValue
+	}
+	r.headPos, r.tailPos, r.full = 0, 0, false
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/utils/rtt_stats.go b/backend/vendor/github.com/quic-go/quic-go/internal/utils/rtt_stats.go
new file mode 100644
index 00000000..27531307
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/utils/rtt_stats.go
@@ -0,0 +1,159 @@
+package utils
+
+import (
+	"sync/atomic"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+const (
+	rttAlpha      = 0.125
+	oneMinusAlpha = 1 - rttAlpha
+	rttBeta       = 0.25
+	oneMinusBeta  = 1 - rttBeta
+)
+
+// The default RTT used before an RTT sample is taken
+const DefaultInitialRTT = 100 * time.Millisecond
+
+// RTTStats provides round-trip statistics
+type RTTStats struct {
+	hasMeasurement bool
+
+	minRTT        atomic.Int64 // nanoseconds
+	latestRTT     atomic.Int64 // nanoseconds
+	smoothedRTT   atomic.Int64 // nanoseconds
+	meanDeviation atomic.Int64 // nanoseconds
+
+	maxAckDelay atomic.Int64 // nanoseconds
+}
+
+func NewRTTStats() *RTTStats {
+	var rttStats RTTStats
+	rttStats.minRTT.Store(DefaultInitialRTT.Nanoseconds())
+	rttStats.latestRTT.Store(DefaultInitialRTT.Nanoseconds())
+	rttStats.smoothedRTT.Store(DefaultInitialRTT.Nanoseconds())
+	return &rttStats
+}
+
+// MinRTT Returns the minRTT for the entire connection.
+// May return Zero if no valid updates have occurred.
+func (r *RTTStats) MinRTT() time.Duration {
+	return time.Duration(r.minRTT.Load())
+}
+
+// LatestRTT returns the most recent rtt measurement.
+// May return Zero if no valid updates have occurred.
+func (r *RTTStats) LatestRTT() time.Duration {
+	return time.Duration(r.latestRTT.Load())
+}
+
+// SmoothedRTT returns the smoothed RTT for the connection.
+// May return Zero if no valid updates have occurred.
+func (r *RTTStats) SmoothedRTT() time.Duration {
+	return time.Duration(r.smoothedRTT.Load())
+}
+
+// MeanDeviation gets the mean deviation
+func (r *RTTStats) MeanDeviation() time.Duration {
+	return time.Duration(r.meanDeviation.Load())
+}
+
+// MaxAckDelay gets the max_ack_delay advertised by the peer
+func (r *RTTStats) MaxAckDelay() time.Duration {
+	return time.Duration(r.maxAckDelay.Load())
+}
+
+// PTO gets the probe timeout duration.
+func (r *RTTStats) PTO(includeMaxAckDelay bool) time.Duration {
+	if !r.hasMeasurement {
+		return 2 * DefaultInitialRTT
+	}
+	pto := r.SmoothedRTT() + max(4*r.MeanDeviation(), protocol.TimerGranularity)
+	if includeMaxAckDelay {
+		pto += r.MaxAckDelay()
+	}
+	return pto
+}
+
+// UpdateRTT updates the RTT based on a new sample.
+func (r *RTTStats) UpdateRTT(sendDelta, ackDelay time.Duration) {
+	if sendDelta <= 0 {
+		return
+	}
+
+	// Update r.minRTT first. r.minRTT does not use an rttSample corrected for
+	// ackDelay but the raw observed sendDelta, since poor clock granularity at
+	// the client may cause a high ackDelay to result in underestimation of the
+	// r.minRTT.
+	minRTT := time.Duration(r.minRTT.Load())
+	if !r.hasMeasurement || minRTT > sendDelta {
+		minRTT = sendDelta
+		r.minRTT.Store(sendDelta.Nanoseconds())
+	}
+
+	// Correct for ackDelay if information received from the peer results in a
+	// an RTT sample at least as large as minRTT. Otherwise, only use the
+	// sendDelta.
+	sample := sendDelta
+	if sample-minRTT >= ackDelay {
+		sample -= ackDelay
+	}
+	r.latestRTT.Store(sample.Nanoseconds())
+	// First time call.
+	if !r.hasMeasurement {
+		r.hasMeasurement = true
+		r.smoothedRTT.Store(sample.Nanoseconds())
+		r.meanDeviation.Store(sample.Nanoseconds() / 2)
+	} else {
+		smoothedRTT := r.SmoothedRTT()
+		meanDev := time.Duration(oneMinusBeta*float32(r.MeanDeviation()/time.Microsecond)+rttBeta*float32((smoothedRTT-sample).Abs()/time.Microsecond)) * time.Microsecond
+		newSmoothedRTT := time.Duration((float32(smoothedRTT/time.Microsecond)*oneMinusAlpha)+(float32(sample/time.Microsecond)*rttAlpha)) * time.Microsecond
+		r.meanDeviation.Store(meanDev.Nanoseconds())
+		r.smoothedRTT.Store(newSmoothedRTT.Nanoseconds())
+	}
+}
+
+func (r *RTTStats) HasMeasurement() bool {
+	return r.hasMeasurement
+}
+
+// SetMaxAckDelay sets the max_ack_delay
+func (r *RTTStats) SetMaxAckDelay(mad time.Duration) {
+	r.maxAckDelay.Store(int64(mad))
+}
+
+// SetInitialRTT sets the initial RTT.
+// It is used during handshake when restoring the RTT stats from the token.
+func (r *RTTStats) SetInitialRTT(t time.Duration) {
+	// On the server side, by the time we get to process the session ticket,
+	// we might already have obtained an RTT measurement.
+	// This can happen if we received the ClientHello in multiple pieces, and one of those pieces was lost.
+	// Discard the restored value. A fresh measurement is always better.
+	if r.hasMeasurement {
+		return
+	}
+	r.smoothedRTT.Store(int64(t))
+	r.latestRTT.Store(int64(t))
+}
+
+func (r *RTTStats) ResetForPathMigration() {
+	r.hasMeasurement = false
+	r.minRTT.Store(DefaultInitialRTT.Nanoseconds())
+	r.latestRTT.Store(DefaultInitialRTT.Nanoseconds())
+	r.smoothedRTT.Store(DefaultInitialRTT.Nanoseconds())
+	r.meanDeviation.Store(0)
+	// max_ack_delay remains valid
+}
+
+func (r *RTTStats) Clone() *RTTStats {
+	out := &RTTStats{}
+	out.hasMeasurement = r.hasMeasurement
+	out.minRTT.Store(r.minRTT.Load())
+	out.latestRTT.Store(r.latestRTT.Load())
+	out.smoothedRTT.Store(r.smoothedRTT.Load())
+	out.meanDeviation.Store(r.meanDeviation.Load())
+	out.maxAckDelay.Store(r.maxAckDelay.Load())
+	return out
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frame.go
new file mode 100644
index 00000000..191e1530
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frame.go
@@ -0,0 +1,298 @@
+package wire
+
+import (
+	"errors"
+	"math"
+	"sort"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+var errInvalidAckRanges = errors.New("AckFrame: ACK frame contains invalid ACK ranges")
+
+// An AckFrame is an ACK frame
+type AckFrame struct {
+	AckRanges []AckRange // has to be ordered. The highest ACK range goes first, the lowest ACK range goes last
+	DelayTime time.Duration
+
+	ECT0, ECT1, ECNCE uint64
+}
+
+// parseAckFrame reads an ACK frame
+func parseAckFrame(frame *AckFrame, b []byte, typ FrameType, ackDelayExponent uint8, _ protocol.Version) (int, error) {
+	startLen := len(b)
+	ecn := typ == FrameTypeAckECN
+
+	la, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	largestAcked := protocol.PacketNumber(la)
+	delay, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	delayTime := time.Duration(delay*1<<ackDelayExponent) * time.Microsecond
+	if delayTime < 0 {
+		// If the delay time overflows, set it to the maximum encode-able value.
+		delayTime = time.Duration(math.MaxInt64)
+	}
+	frame.DelayTime = delayTime
+
+	numBlocks, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	// read the first ACK range
+	ab, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	ackBlock := protocol.PacketNumber(ab)
+	if ackBlock > largestAcked {
+		return 0, errors.New("invalid first ACK range")
+	}
+	smallest := largestAcked - ackBlock
+	frame.AckRanges = append(frame.AckRanges, AckRange{Smallest: smallest, Largest: largestAcked})
+
+	// read all the other ACK ranges
+	for range numBlocks {
+		g, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		gap := protocol.PacketNumber(g)
+		if smallest < gap+2 {
+			return 0, errInvalidAckRanges
+		}
+		largest := smallest - gap - 2
+
+		ab, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		ackBlock := protocol.PacketNumber(ab)
+
+		if ackBlock > largest {
+			return 0, errInvalidAckRanges
+		}
+		smallest = largest - ackBlock
+		frame.AckRanges = append(frame.AckRanges, AckRange{Smallest: smallest, Largest: largest})
+	}
+
+	if !frame.validateAckRanges() {
+		return 0, errInvalidAckRanges
+	}
+
+	if ecn {
+		ect0, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECT0 = ect0
+		ect1, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECT1 = ect1
+		ecnce, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECNCE = ecnce
+	}
+
+	return startLen - len(b), nil
+}
+
+// Append appends an ACK frame.
+func (f *AckFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	hasECN := f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0
+	if hasECN {
+		b = append(b, byte(FrameTypeAckECN))
+	} else {
+		b = append(b, byte(FrameTypeAck))
+	}
+	b = quicvarint.Append(b, uint64(f.LargestAcked()))
+	b = quicvarint.Append(b, encodeAckDelay(f.DelayTime))
+
+	numRanges := min(len(f.AckRanges), protocol.MaxNumAckRanges)
+	b = quicvarint.Append(b, uint64(numRanges-1))
+
+	// write the first range
+	_, firstRange := f.encodeAckRange(0)
+	b = quicvarint.Append(b, firstRange)
+
+	// write all the other range
+	for i := 1; i < numRanges; i++ {
+		gap, len := f.encodeAckRange(i)
+		b = quicvarint.Append(b, gap)
+		b = quicvarint.Append(b, len)
+	}
+
+	if hasECN {
+		b = quicvarint.Append(b, f.ECT0)
+		b = quicvarint.Append(b, f.ECT1)
+		b = quicvarint.Append(b, f.ECNCE)
+	}
+	return b, nil
+}
+
+// Length of a written frame
+func (f *AckFrame) Length(_ protocol.Version) protocol.ByteCount {
+	largestAcked := f.AckRanges[0].Largest
+
+	// The number of ACK ranges is limited to 64, which guarantees that the
+	// ACK Range Count value can be encoded in a single byte varint.
+	length := 1 + quicvarint.Len(uint64(largestAcked)) + quicvarint.Len(encodeAckDelay(f.DelayTime)) + 1
+
+	lowestInFirstRange := f.AckRanges[0].Smallest
+	length += quicvarint.Len(uint64(largestAcked - lowestInFirstRange))
+
+	for i := 1; i < min(len(f.AckRanges), protocol.MaxNumAckRanges); i++ {
+		gap, len := f.encodeAckRange(i)
+		length += quicvarint.Len(gap)
+		length += quicvarint.Len(len)
+	}
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += quicvarint.Len(f.ECT0) + quicvarint.Len(f.ECT1) + quicvarint.Len(f.ECNCE)
+	}
+	return protocol.ByteCount(length)
+}
+
+// Truncate truncates the ACK frame to fit into maxSize,
+// and to at most 64 ACK ranges.
+// maxSize must be large enough to fit at least one ACK range.
+func (f *AckFrame) Truncate(maxSize protocol.ByteCount, _ protocol.Version) {
+	f.AckRanges = f.AckRanges[:f.numEncodableAckRanges(maxSize)]
+}
+
+// gets the number of ACK ranges that can be encoded
+// such that the resulting frame is smaller than maxSize
+func (f *AckFrame) numEncodableAckRanges(maxSize protocol.ByteCount) int {
+	// Fast path: Most ACK frames are relatively small, and we don't need to calculate the exact length.
+	// We just assume the worst case scenario: every varint is encoded to 8 bytes.
+	// If the result is still smaller than the maximum ACK frame size, the actual ACK frame will definitely fit.
+	length := 1 + 8 /* largest acked */ + 8 /* delay */ + 1 /* ack range count */ + 8 /* first range */
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += 8 + 8 + 8
+	}
+	numRanges := min(len(f.AckRanges), protocol.MaxNumAckRanges)
+	length += 2 * 8 * (numRanges - 1)
+	if protocol.ByteCount(length) <= maxSize {
+		return numRanges
+	}
+
+	// Slow path: Calculate the exact length of the ACK frame.
+	length = 1 + quicvarint.Len(uint64(f.LargestAcked())) + quicvarint.Len(encodeAckDelay(f.DelayTime)) + 1
+	_, firstRange := f.encodeAckRange(0)
+	length += quicvarint.Len(firstRange)
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += quicvarint.Len(f.ECT0) + quicvarint.Len(f.ECT1) + quicvarint.Len(f.ECNCE)
+	}
+	for i := 1; i < numRanges; i++ {
+		gap, l := f.encodeAckRange(i)
+		rangeLen := quicvarint.Len(gap) + quicvarint.Len(l)
+		if protocol.ByteCount(length+rangeLen) > maxSize {
+			// Writing range i would exceed the maximum size,
+			// so encode one range less than that.
+			return i
+		}
+		length += rangeLen
+	}
+	return numRanges
+}
+
+func (f *AckFrame) encodeAckRange(i int) (gap, length uint64) {
+	if i == 0 {
+		return 0, uint64(f.AckRanges[0].Largest - f.AckRanges[0].Smallest)
+	}
+	return uint64(f.AckRanges[i-1].Smallest - f.AckRanges[i].Largest - 2),
+		uint64(f.AckRanges[i].Largest - f.AckRanges[i].Smallest)
+}
+
+// HasMissingRanges returns if this frame reports any missing packets
+func (f *AckFrame) HasMissingRanges() bool {
+	return len(f.AckRanges) > 1
+}
+
+func (f *AckFrame) validateAckRanges() bool {
+	if len(f.AckRanges) == 0 {
+		return false
+	}
+
+	// check the validity of every single ACK range
+	for _, ackRange := range f.AckRanges {
+		if ackRange.Smallest > ackRange.Largest {
+			return false
+		}
+	}
+
+	// check the consistency for ACK with multiple ACK ranges
+	for i, ackRange := range f.AckRanges {
+		if i == 0 {
+			continue
+		}
+		lastAckRange := f.AckRanges[i-1]
+		if lastAckRange.Smallest <= ackRange.Smallest {
+			return false
+		}
+		if lastAckRange.Smallest <= ackRange.Largest+1 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// LargestAcked is the largest acked packet number
+func (f *AckFrame) LargestAcked() protocol.PacketNumber {
+	return f.AckRanges[0].Largest
+}
+
+// LowestAcked is the lowest acked packet number
+func (f *AckFrame) LowestAcked() protocol.PacketNumber {
+	return f.AckRanges[len(f.AckRanges)-1].Smallest
+}
+
+// AcksPacket determines if this ACK frame acks a certain packet number
+func (f *AckFrame) AcksPacket(p protocol.PacketNumber) bool {
+	if p < f.LowestAcked() || p > f.LargestAcked() {
+		return false
+	}
+
+	i := sort.Search(len(f.AckRanges), func(i int) bool {
+		return p >= f.AckRanges[i].Smallest
+	})
+	// i will always be < len(f.AckRanges), since we checked above that p is not bigger than the largest acked
+	return p <= f.AckRanges[i].Largest
+}
+
+func (f *AckFrame) Reset() {
+	f.DelayTime = 0
+	f.ECT0 = 0
+	f.ECT1 = 0
+	f.ECNCE = 0
+	for _, r := range f.AckRanges {
+		r.Largest = 0
+		r.Smallest = 0
+	}
+	f.AckRanges = f.AckRanges[:0]
+}
+
+func encodeAckDelay(delay time.Duration) uint64 {
+	return uint64(delay.Nanoseconds() / (1000 * (1 << protocol.AckDelayExponent)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frequency_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frequency_frame.go
new file mode 100644
index 00000000..0735d70b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_frequency_frame.go
@@ -0,0 +1,65 @@
+package wire
+
+import (
+	"math"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+type AckFrequencyFrame struct {
+	SequenceNumber        uint64
+	AckElicitingThreshold uint64
+	RequestMaxAckDelay    time.Duration
+	ReorderingThreshold   protocol.PacketNumber
+}
+
+func parseAckFrequencyFrame(b []byte, _ protocol.Version) (*AckFrequencyFrame, int, error) {
+	startLen := len(b)
+	seq, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	aeth, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	mad, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	// prevents overflows if the peer sends a very large value
+	maxAckDelay := time.Duration(mad) * time.Microsecond
+	if maxAckDelay < 0 {
+		maxAckDelay = math.MaxInt64
+	}
+	b = b[l:]
+	rth, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	return &AckFrequencyFrame{
+		SequenceNumber:        seq,
+		AckElicitingThreshold: aeth,
+		RequestMaxAckDelay:    maxAckDelay,
+		ReorderingThreshold:   protocol.PacketNumber(rth),
+	}, startLen - len(b), nil
+}
+
+func (f *AckFrequencyFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = quicvarint.Append(b, uint64(FrameTypeAckFrequency))
+	b = quicvarint.Append(b, f.SequenceNumber)
+	b = quicvarint.Append(b, f.AckElicitingThreshold)
+	b = quicvarint.Append(b, uint64(f.RequestMaxAckDelay/time.Microsecond))
+	return quicvarint.Append(b, uint64(f.ReorderingThreshold)), nil
+}
+
+func (f *AckFrequencyFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return protocol.ByteCount(2 + quicvarint.Len(f.SequenceNumber) + quicvarint.Len(f.AckElicitingThreshold) +
+		quicvarint.Len(uint64(f.RequestMaxAckDelay/time.Microsecond)) + quicvarint.Len(uint64(f.ReorderingThreshold)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_range.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_range.go
new file mode 100644
index 00000000..03a1235e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ack_range.go
@@ -0,0 +1,14 @@
+package wire
+
+import "github.com/quic-go/quic-go/internal/protocol"
+
+// AckRange is an ACK range
+type AckRange struct {
+	Smallest protocol.PacketNumber
+	Largest  protocol.PacketNumber
+}
+
+// Len returns the number of packets contained in this ACK range
+func (r AckRange) Len() protocol.PacketNumber {
+	return r.Largest - r.Smallest + 1
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/connection_close_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/connection_close_frame.go
new file mode 100644
index 00000000..6c71aab6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/connection_close_frame.go
@@ -0,0 +1,75 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A ConnectionCloseFrame is a CONNECTION_CLOSE frame
+type ConnectionCloseFrame struct {
+	IsApplicationError bool
+	ErrorCode          uint64
+	FrameType          uint64
+	ReasonPhrase       string
+}
+
+func parseConnectionCloseFrame(b []byte, typ FrameType, _ protocol.Version) (*ConnectionCloseFrame, int, error) {
+	startLen := len(b)
+	f := &ConnectionCloseFrame{IsApplicationError: typ == FrameTypeApplicationClose}
+	ec, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	f.ErrorCode = ec
+	// read the Frame Type, if this is not an application error
+	if !f.IsApplicationError {
+		ft, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		f.FrameType = ft
+	}
+	var reasonPhraseLen uint64
+	reasonPhraseLen, l, err = quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	if int(reasonPhraseLen) > len(b) {
+		return nil, 0, io.EOF
+	}
+
+	reasonPhrase := make([]byte, reasonPhraseLen)
+	copy(reasonPhrase, b)
+	f.ReasonPhrase = string(reasonPhrase)
+	return f, startLen - len(b) + int(reasonPhraseLen), nil
+}
+
+// Length of a written frame
+func (f *ConnectionCloseFrame) Length(protocol.Version) protocol.ByteCount {
+	length := 1 + protocol.ByteCount(quicvarint.Len(f.ErrorCode)+quicvarint.Len(uint64(len(f.ReasonPhrase)))) + protocol.ByteCount(len(f.ReasonPhrase))
+	if !f.IsApplicationError {
+		length += protocol.ByteCount(quicvarint.Len(f.FrameType)) // for the frame type
+	}
+	return length
+}
+
+func (f *ConnectionCloseFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if f.IsApplicationError {
+		b = append(b, byte(FrameTypeApplicationClose))
+	} else {
+		b = append(b, byte(FrameTypeConnectionClose))
+	}
+
+	b = quicvarint.Append(b, f.ErrorCode)
+	if !f.IsApplicationError {
+		b = quicvarint.Append(b, f.FrameType)
+	}
+	b = quicvarint.Append(b, uint64(len(f.ReasonPhrase)))
+	b = append(b, []byte(f.ReasonPhrase)...)
+	return b, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/crypto_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/crypto_frame.go
new file mode 100644
index 00000000..60a713f7
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/crypto_frame.go
@@ -0,0 +1,97 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A CryptoFrame is a CRYPTO frame
+type CryptoFrame struct {
+	Offset protocol.ByteCount
+	Data   []byte
+}
+
+func parseCryptoFrame(b []byte, _ protocol.Version) (*CryptoFrame, int, error) {
+	startLen := len(b)
+	frame := &CryptoFrame{}
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	frame.Offset = protocol.ByteCount(offset)
+	dataLen, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	if dataLen > uint64(len(b)) {
+		return nil, 0, io.EOF
+	}
+	if dataLen != 0 {
+		frame.Data = make([]byte, dataLen)
+		copy(frame.Data, b)
+	}
+	return frame, startLen - len(b) + int(dataLen), nil
+}
+
+func (f *CryptoFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeCrypto))
+	b = quicvarint.Append(b, uint64(f.Offset))
+	b = quicvarint.Append(b, uint64(len(f.Data)))
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *CryptoFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return protocol.ByteCount(1 + quicvarint.Len(uint64(f.Offset)) + quicvarint.Len(uint64(len(f.Data))) + len(f.Data))
+}
+
+// MaxDataLen returns the maximum data length
+func (f *CryptoFrame) MaxDataLen(maxSize protocol.ByteCount) protocol.ByteCount {
+	// pretend that the data size will be 1 bytes
+	// if it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterwards
+	headerLen := protocol.ByteCount(1 + quicvarint.Len(uint64(f.Offset)) + 1)
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if quicvarint.Len(uint64(maxDataLen)) != 1 {
+		maxDataLen--
+	}
+	return maxDataLen
+}
+
+// MaybeSplitOffFrame splits a frame such that it is not bigger than n bytes.
+// It returns if the frame was actually split.
+// The frame might not be split if:
+// * the size is large enough to fit the whole frame
+// * the size is too small to fit even a 1-byte frame. In that case, the frame returned is nil.
+func (f *CryptoFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.Version) (*CryptoFrame, bool /* was splitting required */) {
+	if f.Length(version) <= maxSize {
+		return nil, false
+	}
+
+	n := f.MaxDataLen(maxSize)
+	if n == 0 {
+		return nil, true
+	}
+
+	newLen := protocol.ByteCount(len(f.Data)) - n
+
+	new := &CryptoFrame{}
+	new.Offset = f.Offset
+	new.Data = make([]byte, newLen)
+
+	// swap the data slices
+	new.Data, f.Data = f.Data, new.Data
+
+	copy(f.Data, new.Data[n:])
+	new.Data = new.Data[:n]
+	f.Offset += n
+
+	return new, true
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/data_blocked_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/data_blocked_frame.go
new file mode 100644
index 00000000..11c72ea3
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/data_blocked_frame.go
@@ -0,0 +1,29 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A DataBlockedFrame is a DATA_BLOCKED frame
+type DataBlockedFrame struct {
+	MaximumData protocol.ByteCount
+}
+
+func parseDataBlockedFrame(b []byte, _ protocol.Version) (*DataBlockedFrame, int, error) {
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	return &DataBlockedFrame{MaximumData: protocol.ByteCount(offset)}, l, nil
+}
+
+func (f *DataBlockedFrame) Append(b []byte, version protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeDataBlocked))
+	return quicvarint.Append(b, uint64(f.MaximumData)), nil
+}
+
+// Length of a written frame
+func (f *DataBlockedFrame) Length(version protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.MaximumData)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/datagram_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/datagram_frame.go
new file mode 100644
index 00000000..a6034867
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/datagram_frame.go
@@ -0,0 +1,85 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// MaxDatagramSize is the maximum size of a DATAGRAM frame (RFC 9221).
+// By setting it to a large value, we allow all datagrams that fit into a QUIC packet.
+// The value is chosen such that it can still be encoded as a 2 byte varint.
+// This is a var and not a const so it can be set in tests.
+var MaxDatagramSize protocol.ByteCount = 16383
+
+// A DatagramFrame is a DATAGRAM frame
+type DatagramFrame struct {
+	DataLenPresent bool
+	Data           []byte
+}
+
+func parseDatagramFrame(b []byte, typ FrameType, _ protocol.Version) (*DatagramFrame, int, error) {
+	startLen := len(b)
+	f := &DatagramFrame{}
+	f.DataLenPresent = uint64(typ)&0x1 > 0
+
+	var length uint64
+	if f.DataLenPresent {
+		var err error
+		var l int
+		length, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		if length > uint64(len(b)) {
+			return nil, 0, io.EOF
+		}
+	} else {
+		length = uint64(len(b))
+	}
+	f.Data = make([]byte, length)
+	copy(f.Data, b)
+	return f, startLen - len(b) + int(length), nil
+}
+
+func (f *DatagramFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	typ := uint8(0x30)
+	if f.DataLenPresent {
+		typ ^= 0b1
+	}
+	b = append(b, typ)
+	if f.DataLenPresent {
+		b = quicvarint.Append(b, uint64(len(f.Data)))
+	}
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// MaxDataLen returns the maximum data length
+func (f *DatagramFrame) MaxDataLen(maxSize protocol.ByteCount, version protocol.Version) protocol.ByteCount {
+	headerLen := protocol.ByteCount(1)
+	if f.DataLenPresent {
+		// pretend that the data size will be 1 bytes
+		// if it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterwards
+		headerLen++
+	}
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if f.DataLenPresent && quicvarint.Len(uint64(maxDataLen)) != 1 {
+		maxDataLen--
+	}
+	return maxDataLen
+}
+
+// Length of a written frame
+func (f *DatagramFrame) Length(_ protocol.Version) protocol.ByteCount {
+	length := 1 + protocol.ByteCount(len(f.Data))
+	if f.DataLenPresent {
+		length += protocol.ByteCount(quicvarint.Len(uint64(len(f.Data))))
+	}
+	return length
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/extended_header.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/extended_header.go
new file mode 100644
index 00000000..6ab9fb98
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/extended_header.go
@@ -0,0 +1,164 @@
+package wire
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// ErrInvalidReservedBits is returned when the reserved bits are incorrect.
+// When this error is returned, parsing continues, and an ExtendedHeader is returned.
+// This is necessary because we need to decrypt the packet in that case,
+// in order to avoid a timing side-channel.
+var ErrInvalidReservedBits = errors.New("invalid reserved bits")
+
+// ExtendedHeader is the header of a QUIC packet.
+type ExtendedHeader struct {
+	Header
+
+	typeByte byte
+
+	KeyPhase protocol.KeyPhaseBit
+
+	PacketNumberLen protocol.PacketNumberLen
+	PacketNumber    protocol.PacketNumber
+
+	parsedLen protocol.ByteCount
+}
+
+func (h *ExtendedHeader) parse(data []byte) (bool /* reserved bits valid */, error) {
+	// read the (now unencrypted) first byte
+	h.typeByte = data[0]
+	h.PacketNumberLen = protocol.PacketNumberLen(h.typeByte&0x3) + 1
+	if protocol.ByteCount(len(data)) < h.Header.ParsedLen()+protocol.ByteCount(h.PacketNumberLen) {
+		return false, io.EOF
+	}
+
+	pn, err := readPacketNumber(data[h.Header.ParsedLen():], h.PacketNumberLen)
+	if err != nil {
+		return true, nil
+	}
+	h.PacketNumber = pn
+	reservedBitsValid := h.typeByte&0xc == 0
+
+	h.parsedLen = h.Header.ParsedLen() + protocol.ByteCount(h.PacketNumberLen)
+	return reservedBitsValid, err
+}
+
+// Append appends the Header.
+func (h *ExtendedHeader) Append(b []byte, v protocol.Version) ([]byte, error) {
+	if h.DestConnectionID.Len() > protocol.MaxConnIDLen {
+		return nil, fmt.Errorf("invalid connection ID length: %d bytes", h.DestConnectionID.Len())
+	}
+	if h.SrcConnectionID.Len() > protocol.MaxConnIDLen {
+		return nil, fmt.Errorf("invalid connection ID length: %d bytes", h.SrcConnectionID.Len())
+	}
+
+	var packetType uint8
+	if v == protocol.Version2 {
+		switch h.Type {
+		case protocol.PacketTypeInitial:
+			packetType = 0b01
+		case protocol.PacketType0RTT:
+			packetType = 0b10
+		case protocol.PacketTypeHandshake:
+			packetType = 0b11
+		case protocol.PacketTypeRetry:
+			packetType = 0b00
+		}
+	} else {
+		switch h.Type {
+		case protocol.PacketTypeInitial:
+			packetType = 0b00
+		case protocol.PacketType0RTT:
+			packetType = 0b01
+		case protocol.PacketTypeHandshake:
+			packetType = 0b10
+		case protocol.PacketTypeRetry:
+			packetType = 0b11
+		}
+	}
+	firstByte := 0xc0 | packetType<<4
+	if h.Type != protocol.PacketTypeRetry {
+		// Retry packets don't have a packet number
+		firstByte |= uint8(h.PacketNumberLen - 1)
+	}
+
+	b = append(b, firstByte)
+	b = append(b, make([]byte, 4)...)
+	binary.BigEndian.PutUint32(b[len(b)-4:], uint32(h.Version))
+	b = append(b, uint8(h.DestConnectionID.Len()))
+	b = append(b, h.DestConnectionID.Bytes()...)
+	b = append(b, uint8(h.SrcConnectionID.Len()))
+	b = append(b, h.SrcConnectionID.Bytes()...)
+
+	//nolint:exhaustive
+	switch h.Type {
+	case protocol.PacketTypeRetry:
+		b = append(b, h.Token...)
+		return b, nil
+	case protocol.PacketTypeInitial:
+		b = quicvarint.Append(b, uint64(len(h.Token)))
+		b = append(b, h.Token...)
+	}
+	b = quicvarint.AppendWithLen(b, uint64(h.Length), 2)
+	return appendPacketNumber(b, h.PacketNumber, h.PacketNumberLen)
+}
+
+// ParsedLen returns the number of bytes that were consumed when parsing the header
+func (h *ExtendedHeader) ParsedLen() protocol.ByteCount {
+	return h.parsedLen
+}
+
+// GetLength determines the length of the Header.
+func (h *ExtendedHeader) GetLength(_ protocol.Version) protocol.ByteCount {
+	length := 1 /* type byte */ + 4 /* version */ + 1 /* dest conn ID len */ + protocol.ByteCount(h.DestConnectionID.Len()) + 1 /* src conn ID len */ + protocol.ByteCount(h.SrcConnectionID.Len()) + protocol.ByteCount(h.PacketNumberLen) + 2 /* length */
+	if h.Type == protocol.PacketTypeInitial {
+		length += protocol.ByteCount(quicvarint.Len(uint64(len(h.Token))) + len(h.Token))
+	}
+	return length
+}
+
+// Log logs the Header
+func (h *ExtendedHeader) Log(logger utils.Logger) {
+	var token string
+	if h.Type == protocol.PacketTypeInitial || h.Type == protocol.PacketTypeRetry {
+		if len(h.Token) == 0 {
+			token = "Token: (empty), "
+		} else {
+			token = fmt.Sprintf("Token: %#x, ", h.Token)
+		}
+		if h.Type == protocol.PacketTypeRetry {
+			logger.Debugf("\tLong Header{Type: %s, DestConnectionID: %s, SrcConnectionID: %s, %sVersion: %s}", h.Type, h.DestConnectionID, h.SrcConnectionID, token, h.Version)
+			return
+		}
+	}
+	logger.Debugf("\tLong Header{Type: %s, DestConnectionID: %s, SrcConnectionID: %s, %sPacketNumber: %d, PacketNumberLen: %d, Length: %d, Version: %s}", h.Type, h.DestConnectionID, h.SrcConnectionID, token, h.PacketNumber, h.PacketNumberLen, h.Length, h.Version)
+}
+
+func appendPacketNumber(b []byte, pn protocol.PacketNumber, pnLen protocol.PacketNumberLen) ([]byte, error) {
+	switch pnLen {
+	case protocol.PacketNumberLen1:
+		b = append(b, uint8(pn))
+	case protocol.PacketNumberLen2:
+		buf := make([]byte, 2)
+		binary.BigEndian.PutUint16(buf, uint16(pn))
+		b = append(b, buf...)
+	case protocol.PacketNumberLen3:
+		buf := make([]byte, 4)
+		binary.BigEndian.PutUint32(buf, uint32(pn))
+		b = append(b, buf[1:]...)
+	case protocol.PacketNumberLen4:
+		buf := make([]byte, 4)
+		binary.BigEndian.PutUint32(buf, uint32(pn))
+		b = append(b, buf...)
+	default:
+		return nil, fmt.Errorf("invalid packet number length: %d", pnLen)
+	}
+	return b, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame.go
new file mode 100644
index 00000000..09ea92f7
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame.go
@@ -0,0 +1,33 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A Frame in QUIC
+type Frame interface {
+	Append(b []byte, version protocol.Version) ([]byte, error)
+	Length(version protocol.Version) protocol.ByteCount
+}
+
+// IsProbingFrame returns true if the frame is a probing frame.
+// See section 9.1 of RFC 9000.
+func IsProbingFrame(f Frame) bool {
+	switch f.(type) {
+	case *PathChallengeFrame, *PathResponseFrame, *NewConnectionIDFrame:
+		return true
+	}
+	return false
+}
+
+// IsProbingFrameType returns true if the FrameType is a probing frame.
+// See section 9.1 of RFC 9000.
+func IsProbingFrameType(f FrameType) bool {
+	//nolint:exhaustive // PATH_CHALLENGE, PATH_RESPONSE and NEW_CONNECTION_ID are the only probing frames
+	switch f {
+	case FrameTypePathChallenge, FrameTypePathResponse, FrameTypeNewConnectionID:
+		return true
+	default:
+		return false
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_parser.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_parser.go
new file mode 100644
index 00000000..afc3bedb
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_parser.go
@@ -0,0 +1,192 @@
+package wire
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+var errUnknownFrameType = errors.New("unknown frame type")
+
+// The FrameParser parses QUIC frames, one by one.
+type FrameParser struct {
+	ackDelayExponent      uint8
+	supportsDatagrams     bool
+	supportsResetStreamAt bool
+	supportsAckFrequency  bool
+
+	// To avoid allocating when parsing, keep a single ACK frame struct.
+	// It is used over and over again.
+	ackFrame *AckFrame
+}
+
+// NewFrameParser creates a new frame parser.
+func NewFrameParser(supportsDatagrams, supportsResetStreamAt, supportsAckFrequency bool) *FrameParser {
+	return &FrameParser{
+		supportsDatagrams:     supportsDatagrams,
+		supportsResetStreamAt: supportsResetStreamAt,
+		supportsAckFrequency:  supportsAckFrequency,
+		ackFrame:              &AckFrame{},
+	}
+}
+
+// ParseType parses the frame type of the next frame.
+// It skips over PADDING frames.
+func (p *FrameParser) ParseType(b []byte, encLevel protocol.EncryptionLevel) (FrameType, int, error) {
+	var parsed int
+	for len(b) != 0 {
+		typ, l, err := quicvarint.Parse(b)
+		parsed += l
+		if err != nil {
+			return 0, parsed, &qerr.TransportError{
+				ErrorCode:    qerr.FrameEncodingError,
+				ErrorMessage: err.Error(),
+			}
+		}
+		b = b[l:]
+		if typ == 0x0 { // skip PADDING frames
+			continue
+		}
+		ft := FrameType(typ)
+		valid := ft.isValidRFC9000() ||
+			(p.supportsDatagrams && ft.IsDatagramFrameType()) ||
+			(p.supportsResetStreamAt && ft == FrameTypeResetStreamAt) ||
+			(p.supportsAckFrequency && (ft == FrameTypeAckFrequency || ft == FrameTypeImmediateAck))
+		if !valid {
+			return 0, parsed, &qerr.TransportError{
+				ErrorCode:    qerr.FrameEncodingError,
+				FrameType:    typ,
+				ErrorMessage: errUnknownFrameType.Error(),
+			}
+		}
+		if !ft.isAllowedAtEncLevel(encLevel) {
+			return 0, parsed, &qerr.TransportError{
+				ErrorCode:    qerr.FrameEncodingError,
+				FrameType:    typ,
+				ErrorMessage: fmt.Sprintf("%d not allowed at encryption level %s", ft, encLevel),
+			}
+		}
+		return ft, parsed, nil
+	}
+	return 0, parsed, io.EOF
+}
+
+func (p *FrameParser) ParseStreamFrame(frameType FrameType, data []byte, v protocol.Version) (*StreamFrame, int, error) {
+	frame, n, err := ParseStreamFrame(data, frameType, v)
+	if err != nil {
+		return nil, n, &qerr.TransportError{
+			ErrorCode:    qerr.FrameEncodingError,
+			FrameType:    uint64(frameType),
+			ErrorMessage: err.Error(),
+		}
+	}
+	return frame, n, nil
+}
+
+func (p *FrameParser) ParseAckFrame(frameType FrameType, data []byte, encLevel protocol.EncryptionLevel, v protocol.Version) (*AckFrame, int, error) {
+	ackDelayExponent := p.ackDelayExponent
+	if encLevel != protocol.Encryption1RTT {
+		ackDelayExponent = protocol.DefaultAckDelayExponent
+	}
+	p.ackFrame.Reset()
+	l, err := parseAckFrame(p.ackFrame, data, frameType, ackDelayExponent, v)
+	if err != nil {
+		return nil, l, &qerr.TransportError{
+			ErrorCode:    qerr.FrameEncodingError,
+			FrameType:    uint64(frameType),
+			ErrorMessage: err.Error(),
+		}
+	}
+
+	return p.ackFrame, l, nil
+}
+
+func (p *FrameParser) ParseDatagramFrame(frameType FrameType, data []byte, v protocol.Version) (*DatagramFrame, int, error) {
+	f, l, err := parseDatagramFrame(data, frameType, v)
+	if err != nil {
+		return nil, 0, &qerr.TransportError{
+			ErrorCode:    qerr.FrameEncodingError,
+			FrameType:    uint64(frameType),
+			ErrorMessage: err.Error(),
+		}
+	}
+	return f, l, nil
+}
+
+// ParseLessCommonFrame parses everything except STREAM, ACK or DATAGRAM.
+// These cases should be handled separately for performance reasons.
+func (p *FrameParser) ParseLessCommonFrame(frameType FrameType, data []byte, v protocol.Version) (Frame, int, error) {
+	var frame Frame
+	var l int
+	var err error
+	//nolint:exhaustive // Common frames should already be handled.
+	switch frameType {
+	case FrameTypePing:
+		frame = &PingFrame{}
+	case FrameTypeResetStream:
+		frame, l, err = parseResetStreamFrame(data, false, v)
+	case FrameTypeStopSending:
+		frame, l, err = parseStopSendingFrame(data, v)
+	case FrameTypeCrypto:
+		frame, l, err = parseCryptoFrame(data, v)
+	case FrameTypeNewToken:
+		frame, l, err = parseNewTokenFrame(data, v)
+	case FrameTypeMaxData:
+		frame, l, err = parseMaxDataFrame(data, v)
+	case FrameTypeMaxStreamData:
+		frame, l, err = parseMaxStreamDataFrame(data, v)
+	case FrameTypeBidiMaxStreams, FrameTypeUniMaxStreams:
+		frame, l, err = parseMaxStreamsFrame(data, frameType, v)
+	case FrameTypeDataBlocked:
+		frame, l, err = parseDataBlockedFrame(data, v)
+	case FrameTypeStreamDataBlocked:
+		frame, l, err = parseStreamDataBlockedFrame(data, v)
+	case FrameTypeBidiStreamBlocked, FrameTypeUniStreamBlocked:
+		frame, l, err = parseStreamsBlockedFrame(data, frameType, v)
+	case FrameTypeNewConnectionID:
+		frame, l, err = parseNewConnectionIDFrame(data, v)
+	case FrameTypeRetireConnectionID:
+		frame, l, err = parseRetireConnectionIDFrame(data, v)
+	case FrameTypePathChallenge:
+		frame, l, err = parsePathChallengeFrame(data, v)
+	case FrameTypePathResponse:
+		frame, l, err = parsePathResponseFrame(data, v)
+	case FrameTypeConnectionClose, FrameTypeApplicationClose:
+		frame, l, err = parseConnectionCloseFrame(data, frameType, v)
+	case FrameTypeHandshakeDone:
+		frame = &HandshakeDoneFrame{}
+	case FrameTypeResetStreamAt:
+		frame, l, err = parseResetStreamFrame(data, true, v)
+	case FrameTypeAckFrequency:
+		frame, l, err = parseAckFrequencyFrame(data, v)
+	case FrameTypeImmediateAck:
+		frame = &ImmediateAckFrame{}
+	default:
+		err = errUnknownFrameType
+	}
+	if err != nil {
+		return frame, l, &qerr.TransportError{
+			ErrorCode:    qerr.FrameEncodingError,
+			FrameType:    uint64(frameType),
+			ErrorMessage: err.Error(),
+		}
+	}
+	return frame, l, err
+}
+
+// SetAckDelayExponent sets the acknowledgment delay exponent (sent in the transport parameters).
+// This value is used to scale the ACK Delay field in the ACK frame.
+func (p *FrameParser) SetAckDelayExponent(exp uint8) {
+	p.ackDelayExponent = exp
+}
+
+func replaceUnexpectedEOF(e error) error {
+	if e == io.ErrUnexpectedEOF {
+		return io.EOF
+	}
+	return e
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_type.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_type.go
new file mode 100644
index 00000000..597523f6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/frame_type.go
@@ -0,0 +1,81 @@
+package wire
+
+import "github.com/quic-go/quic-go/internal/protocol"
+
+type FrameType uint64
+
+// These constants correspond to those defined in RFC 9000.
+// Stream frame types are not listed explicitly here; use FrameType.IsStreamFrameType() to identify them.
+const (
+	FrameTypePing        FrameType = 0x1
+	FrameTypeAck         FrameType = 0x2
+	FrameTypeAckECN      FrameType = 0x3
+	FrameTypeResetStream FrameType = 0x4
+	FrameTypeStopSending FrameType = 0x5
+	FrameTypeCrypto      FrameType = 0x6
+	FrameTypeNewToken    FrameType = 0x7
+
+	FrameTypeMaxData            FrameType = 0x10
+	FrameTypeMaxStreamData      FrameType = 0x11
+	FrameTypeBidiMaxStreams     FrameType = 0x12
+	FrameTypeUniMaxStreams      FrameType = 0x13
+	FrameTypeDataBlocked        FrameType = 0x14
+	FrameTypeStreamDataBlocked  FrameType = 0x15
+	FrameTypeBidiStreamBlocked  FrameType = 0x16
+	FrameTypeUniStreamBlocked   FrameType = 0x17
+	FrameTypeNewConnectionID    FrameType = 0x18
+	FrameTypeRetireConnectionID FrameType = 0x19
+	FrameTypePathChallenge      FrameType = 0x1a
+	FrameTypePathResponse       FrameType = 0x1b
+	FrameTypeConnectionClose    FrameType = 0x1c
+	FrameTypeApplicationClose   FrameType = 0x1d
+	FrameTypeHandshakeDone      FrameType = 0x1e
+	// https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/09/
+	FrameTypeResetStreamAt FrameType = 0x24
+	// https://datatracker.ietf.org/doc/draft-ietf-quic-ack-frequency/11/
+	FrameTypeAckFrequency FrameType = 0xaf
+	FrameTypeImmediateAck FrameType = 0x1f
+
+	FrameTypeDatagramNoLength   FrameType = 0x30
+	FrameTypeDatagramWithLength FrameType = 0x31
+)
+
+func (t FrameType) IsStreamFrameType() bool {
+	return t >= 0x8 && t <= 0xf
+}
+
+func (t FrameType) isValidRFC9000() bool {
+	return t <= 0x1e
+}
+
+func (t FrameType) IsAckFrameType() bool {
+	return t == FrameTypeAck || t == FrameTypeAckECN
+}
+
+func (t FrameType) IsDatagramFrameType() bool {
+	return t == FrameTypeDatagramNoLength || t == FrameTypeDatagramWithLength
+}
+
+func (t FrameType) isAllowedAtEncLevel(encLevel protocol.EncryptionLevel) bool {
+	//nolint:exhaustive
+	switch encLevel {
+	case protocol.EncryptionInitial, protocol.EncryptionHandshake:
+		switch t {
+		case FrameTypeCrypto, FrameTypeAck, FrameTypeAckECN, FrameTypeConnectionClose, FrameTypePing:
+			return true
+		default:
+			return false
+		}
+	case protocol.Encryption0RTT:
+		switch t {
+		case FrameTypeCrypto, FrameTypeAck, FrameTypeAckECN, FrameTypeConnectionClose, FrameTypeNewToken, FrameTypePathResponse, FrameTypeRetireConnectionID:
+			return false
+		default:
+			return true
+		}
+	case protocol.Encryption1RTT:
+		return true
+	default:
+		panic("unknown encryption level")
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/handshake_done_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/handshake_done_frame.go
new file mode 100644
index 00000000..bf95f525
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/handshake_done_frame.go
@@ -0,0 +1,17 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A HandshakeDoneFrame is a HANDSHAKE_DONE frame
+type HandshakeDoneFrame struct{}
+
+func (f *HandshakeDoneFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	return append(b, byte(FrameTypeHandshakeDone)), nil
+}
+
+// Length of a written frame
+func (f *HandshakeDoneFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/header.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/header.go
new file mode 100644
index 00000000..678a04a2
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/header.go
@@ -0,0 +1,302 @@
+package wire
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// ParseConnectionID parses the destination connection ID of a packet.
+func ParseConnectionID(data []byte, shortHeaderConnIDLen int) (protocol.ConnectionID, error) {
+	if len(data) == 0 {
+		return protocol.ConnectionID{}, io.EOF
+	}
+	if !IsLongHeaderPacket(data[0]) {
+		if len(data) < shortHeaderConnIDLen+1 {
+			return protocol.ConnectionID{}, io.EOF
+		}
+		return protocol.ParseConnectionID(data[1 : 1+shortHeaderConnIDLen]), nil
+	}
+	if len(data) < 6 {
+		return protocol.ConnectionID{}, io.EOF
+	}
+	destConnIDLen := int(data[5])
+	if destConnIDLen > protocol.MaxConnIDLen {
+		return protocol.ConnectionID{}, protocol.ErrInvalidConnectionIDLen
+	}
+	if len(data) < 6+destConnIDLen {
+		return protocol.ConnectionID{}, io.EOF
+	}
+	return protocol.ParseConnectionID(data[6 : 6+destConnIDLen]), nil
+}
+
+// ParseArbitraryLenConnectionIDs parses the most general form of a Long Header packet,
+// using only the version-independent packet format as described in Section 5.1 of RFC 8999:
+// https://datatracker.ietf.org/doc/html/rfc8999#section-5.1.
+// This function should only be called on Long Header packets for which we don't support the version.
+func ParseArbitraryLenConnectionIDs(data []byte) (bytesParsed int, dest, src protocol.ArbitraryLenConnectionID, _ error) {
+	startLen := len(data)
+	if len(data) < 6 {
+		return 0, nil, nil, io.EOF
+	}
+	data = data[5:] // skip first byte and version field
+	destConnIDLen := data[0]
+	data = data[1:]
+	destConnID := make(protocol.ArbitraryLenConnectionID, destConnIDLen)
+	if len(data) < int(destConnIDLen)+1 {
+		return 0, nil, nil, io.EOF
+	}
+	copy(destConnID, data)
+	data = data[destConnIDLen:]
+	srcConnIDLen := data[0]
+	data = data[1:]
+	if len(data) < int(srcConnIDLen) {
+		return 0, nil, nil, io.EOF
+	}
+	srcConnID := make(protocol.ArbitraryLenConnectionID, srcConnIDLen)
+	copy(srcConnID, data)
+	return startLen - len(data) + int(srcConnIDLen), destConnID, srcConnID, nil
+}
+
+func IsPotentialQUICPacket(firstByte byte) bool {
+	return firstByte&0x40 > 0
+}
+
+// IsLongHeaderPacket says if this is a Long Header packet
+func IsLongHeaderPacket(firstByte byte) bool {
+	return firstByte&0x80 > 0
+}
+
+// ParseVersion parses the QUIC version.
+// It should only be called for Long Header packets (Short Header packets don't contain a version number).
+func ParseVersion(data []byte) (protocol.Version, error) {
+	if len(data) < 5 {
+		return 0, io.EOF
+	}
+	return protocol.Version(binary.BigEndian.Uint32(data[1:5])), nil
+}
+
+// IsVersionNegotiationPacket says if this is a version negotiation packet
+func IsVersionNegotiationPacket(b []byte) bool {
+	if len(b) < 5 {
+		return false
+	}
+	return IsLongHeaderPacket(b[0]) && b[1] == 0 && b[2] == 0 && b[3] == 0 && b[4] == 0
+}
+
+// Is0RTTPacket says if this is a 0-RTT packet.
+// A packet sent with a version we don't understand can never be a 0-RTT packet.
+func Is0RTTPacket(b []byte) bool {
+	if len(b) < 5 {
+		return false
+	}
+	if !IsLongHeaderPacket(b[0]) {
+		return false
+	}
+	version := protocol.Version(binary.BigEndian.Uint32(b[1:5]))
+	//nolint:exhaustive // We only need to test QUIC versions that we support.
+	switch version {
+	case protocol.Version1:
+		return b[0]>>4&0b11 == 0b01
+	case protocol.Version2:
+		return b[0]>>4&0b11 == 0b10
+	default:
+		return false
+	}
+}
+
+var ErrUnsupportedVersion = errors.New("unsupported version")
+
+// The Header is the version independent part of the header
+type Header struct {
+	typeByte byte
+	Type     protocol.PacketType
+
+	Version          protocol.Version
+	SrcConnectionID  protocol.ConnectionID
+	DestConnectionID protocol.ConnectionID
+
+	Length protocol.ByteCount
+
+	Token []byte
+
+	parsedLen protocol.ByteCount // how many bytes were read while parsing this header
+}
+
+// ParsePacket parses a long header packet.
+// The packet is cut according to the length field.
+// If we understand the version, the packet is parsed up unto the packet number.
+// Otherwise, only the invariant part of the header is parsed.
+func ParsePacket(data []byte) (*Header, []byte, []byte, error) {
+	if len(data) == 0 || !IsLongHeaderPacket(data[0]) {
+		return nil, nil, nil, errors.New("not a long header packet")
+	}
+	hdr, err := parseHeader(data)
+	if err != nil {
+		if errors.Is(err, ErrUnsupportedVersion) {
+			return hdr, nil, nil, err
+		}
+		return nil, nil, nil, err
+	}
+	if protocol.ByteCount(len(data)) < hdr.ParsedLen()+hdr.Length {
+		return nil, nil, nil, fmt.Errorf("packet length (%d bytes) is smaller than the expected length (%d bytes)", len(data)-int(hdr.ParsedLen()), hdr.Length)
+	}
+	packetLen := int(hdr.ParsedLen() + hdr.Length)
+	return hdr, data[:packetLen], data[packetLen:], nil
+}
+
+// ParseHeader parses the header:
+// * if we understand the version: up to the packet number
+// * if not, only the invariant part of the header
+func parseHeader(b []byte) (*Header, error) {
+	if len(b) == 0 {
+		return nil, io.EOF
+	}
+	typeByte := b[0]
+
+	h := &Header{typeByte: typeByte}
+	l, err := h.parseLongHeader(b[1:])
+	h.parsedLen = protocol.ByteCount(l) + 1
+	return h, err
+}
+
+func (h *Header) parseLongHeader(b []byte) (int, error) {
+	startLen := len(b)
+	if len(b) < 5 {
+		return 0, io.EOF
+	}
+	h.Version = protocol.Version(binary.BigEndian.Uint32(b[:4]))
+	if h.Version != 0 && h.typeByte&0x40 == 0 {
+		return startLen - len(b), errors.New("not a QUIC packet")
+	}
+	destConnIDLen := int(b[4])
+	if destConnIDLen > protocol.MaxConnIDLen {
+		return startLen - len(b), protocol.ErrInvalidConnectionIDLen
+	}
+	b = b[5:]
+	if len(b) < destConnIDLen+1 {
+		return startLen - len(b), io.EOF
+	}
+	h.DestConnectionID = protocol.ParseConnectionID(b[:destConnIDLen])
+	srcConnIDLen := int(b[destConnIDLen])
+	if srcConnIDLen > protocol.MaxConnIDLen {
+		return startLen - len(b), protocol.ErrInvalidConnectionIDLen
+	}
+	b = b[destConnIDLen+1:]
+	if len(b) < srcConnIDLen {
+		return startLen - len(b), io.EOF
+	}
+	h.SrcConnectionID = protocol.ParseConnectionID(b[:srcConnIDLen])
+	b = b[srcConnIDLen:]
+	if h.Version == 0 { // version negotiation packet
+		return startLen - len(b), nil
+	}
+	// If we don't understand the version, we have no idea how to interpret the rest of the bytes
+	if !protocol.IsSupportedVersion(protocol.SupportedVersions, h.Version) {
+		return startLen - len(b), ErrUnsupportedVersion
+	}
+
+	if h.Version == protocol.Version2 {
+		switch h.typeByte >> 4 & 0b11 {
+		case 0b00:
+			h.Type = protocol.PacketTypeRetry
+		case 0b01:
+			h.Type = protocol.PacketTypeInitial
+		case 0b10:
+			h.Type = protocol.PacketType0RTT
+		case 0b11:
+			h.Type = protocol.PacketTypeHandshake
+		}
+	} else {
+		switch h.typeByte >> 4 & 0b11 {
+		case 0b00:
+			h.Type = protocol.PacketTypeInitial
+		case 0b01:
+			h.Type = protocol.PacketType0RTT
+		case 0b10:
+			h.Type = protocol.PacketTypeHandshake
+		case 0b11:
+			h.Type = protocol.PacketTypeRetry
+		}
+	}
+
+	if h.Type == protocol.PacketTypeRetry {
+		tokenLen := len(b) - 16
+		if tokenLen <= 0 {
+			return startLen - len(b), io.EOF
+		}
+		h.Token = make([]byte, tokenLen)
+		copy(h.Token, b[:tokenLen])
+		return startLen - len(b) + tokenLen + 16, nil
+	}
+
+	if h.Type == protocol.PacketTypeInitial {
+		tokenLen, n, err := quicvarint.Parse(b)
+		if err != nil {
+			return startLen - len(b), err
+		}
+		b = b[n:]
+		if tokenLen > uint64(len(b)) {
+			return startLen - len(b), io.EOF
+		}
+		h.Token = make([]byte, tokenLen)
+		copy(h.Token, b[:tokenLen])
+		b = b[tokenLen:]
+	}
+
+	pl, n, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, err
+	}
+	h.Length = protocol.ByteCount(pl)
+	return startLen - len(b) + n, nil
+}
+
+// ParsedLen returns the number of bytes that were consumed when parsing the header
+func (h *Header) ParsedLen() protocol.ByteCount {
+	return h.parsedLen
+}
+
+// ParseExtended parses the version dependent part of the header.
+// The Reader has to be set such that it points to the first byte of the header.
+func (h *Header) ParseExtended(data []byte) (*ExtendedHeader, error) {
+	extHdr := h.toExtendedHeader()
+	reservedBitsValid, err := extHdr.parse(data)
+	if err != nil {
+		return nil, err
+	}
+	if !reservedBitsValid {
+		return extHdr, ErrInvalidReservedBits
+	}
+	return extHdr, nil
+}
+
+func (h *Header) toExtendedHeader() *ExtendedHeader {
+	return &ExtendedHeader{Header: *h}
+}
+
+// PacketType is the type of the packet, for logging purposes
+func (h *Header) PacketType() string {
+	return h.Type.String()
+}
+
+func readPacketNumber(data []byte, pnLen protocol.PacketNumberLen) (protocol.PacketNumber, error) {
+	var pn protocol.PacketNumber
+	switch pnLen {
+	case protocol.PacketNumberLen1:
+		pn = protocol.PacketNumber(data[0])
+	case protocol.PacketNumberLen2:
+		pn = protocol.PacketNumber(binary.BigEndian.Uint16(data[:2]))
+	case protocol.PacketNumberLen3:
+		pn = protocol.PacketNumber(uint32(data[2]) + uint32(data[1])<<8 + uint32(data[0])<<16)
+	case protocol.PacketNumberLen4:
+		pn = protocol.PacketNumber(binary.BigEndian.Uint32(data[:4]))
+	default:
+		return 0, fmt.Errorf("invalid packet number length: %d", pnLen)
+	}
+	return pn, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/immediate_ack_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/immediate_ack_frame.go
new file mode 100644
index 00000000..aeff71b4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/immediate_ack_frame.go
@@ -0,0 +1,18 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// An ImmediateAckFrame is an IMMEDIATE_ACK frame
+type ImmediateAckFrame struct{}
+
+func (f *ImmediateAckFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	return quicvarint.Append(b, uint64(FrameTypeImmediateAck)), nil
+}
+
+// Length of a written frame
+func (f *ImmediateAckFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return protocol.ByteCount(quicvarint.Len(uint64(FrameTypeImmediateAck)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/log.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/log.go
new file mode 100644
index 00000000..c8b28d92
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/log.go
@@ -0,0 +1,74 @@
+package wire
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+// LogFrame logs a frame, either sent or received
+func LogFrame(logger utils.Logger, frame Frame, sent bool) {
+	if !logger.Debug() {
+		return
+	}
+	dir := "<-"
+	if sent {
+		dir = "->"
+	}
+	switch f := frame.(type) {
+	case *CryptoFrame:
+		dataLen := protocol.ByteCount(len(f.Data))
+		logger.Debugf("\t%s &wire.CryptoFrame{Offset: %d, Data length: %d, Offset + Data length: %d}", dir, f.Offset, dataLen, f.Offset+dataLen)
+	case *StreamFrame:
+		logger.Debugf("\t%s &wire.StreamFrame{StreamID: %d, Fin: %t, Offset: %d, Data length: %d, Offset + Data length: %d}", dir, f.StreamID, f.Fin, f.Offset, f.DataLen(), f.Offset+f.DataLen())
+	case *ResetStreamFrame:
+		logger.Debugf("\t%s &wire.ResetStreamFrame{StreamID: %d, ErrorCode: %#x, FinalSize: %d}", dir, f.StreamID, f.ErrorCode, f.FinalSize)
+	case *AckFrame:
+		hasECN := f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0
+		var ecn string
+		if hasECN {
+			ecn = fmt.Sprintf(", ECT0: %d, ECT1: %d, CE: %d", f.ECT0, f.ECT1, f.ECNCE)
+		}
+		if len(f.AckRanges) > 1 {
+			ackRanges := make([]string, len(f.AckRanges))
+			for i, r := range f.AckRanges {
+				ackRanges[i] = fmt.Sprintf("{Largest: %d, Smallest: %d}", r.Largest, r.Smallest)
+			}
+			logger.Debugf("\t%s &wire.AckFrame{LargestAcked: %d, LowestAcked: %d, AckRanges: {%s}, DelayTime: %s%s}", dir, f.LargestAcked(), f.LowestAcked(), strings.Join(ackRanges, ", "), f.DelayTime.String(), ecn)
+		} else {
+			logger.Debugf("\t%s &wire.AckFrame{LargestAcked: %d, LowestAcked: %d, DelayTime: %s%s}", dir, f.LargestAcked(), f.LowestAcked(), f.DelayTime.String(), ecn)
+		}
+	case *MaxDataFrame:
+		logger.Debugf("\t%s &wire.MaxDataFrame{MaximumData: %d}", dir, f.MaximumData)
+	case *MaxStreamDataFrame:
+		logger.Debugf("\t%s &wire.MaxStreamDataFrame{StreamID: %d, MaximumStreamData: %d}", dir, f.StreamID, f.MaximumStreamData)
+	case *DataBlockedFrame:
+		logger.Debugf("\t%s &wire.DataBlockedFrame{MaximumData: %d}", dir, f.MaximumData)
+	case *StreamDataBlockedFrame:
+		logger.Debugf("\t%s &wire.StreamDataBlockedFrame{StreamID: %d, MaximumStreamData: %d}", dir, f.StreamID, f.MaximumStreamData)
+	case *MaxStreamsFrame:
+		switch f.Type {
+		case protocol.StreamTypeUni:
+			logger.Debugf("\t%s &wire.MaxStreamsFrame{Type: uni, MaxStreamNum: %d}", dir, f.MaxStreamNum)
+		case protocol.StreamTypeBidi:
+			logger.Debugf("\t%s &wire.MaxStreamsFrame{Type: bidi, MaxStreamNum: %d}", dir, f.MaxStreamNum)
+		}
+	case *StreamsBlockedFrame:
+		switch f.Type {
+		case protocol.StreamTypeUni:
+			logger.Debugf("\t%s &wire.StreamsBlockedFrame{Type: uni, MaxStreams: %d}", dir, f.StreamLimit)
+		case protocol.StreamTypeBidi:
+			logger.Debugf("\t%s &wire.StreamsBlockedFrame{Type: bidi, MaxStreams: %d}", dir, f.StreamLimit)
+		}
+	case *NewConnectionIDFrame:
+		logger.Debugf("\t%s &wire.NewConnectionIDFrame{SequenceNumber: %d, RetirePriorTo: %d, ConnectionID: %s, StatelessResetToken: %#x}", dir, f.SequenceNumber, f.RetirePriorTo, f.ConnectionID, f.StatelessResetToken)
+	case *RetireConnectionIDFrame:
+		logger.Debugf("\t%s &wire.RetireConnectionIDFrame{SequenceNumber: %d}", dir, f.SequenceNumber)
+	case *NewTokenFrame:
+		logger.Debugf("\t%s &wire.NewTokenFrame{Token: %#x}", dir, f.Token)
+	default:
+		logger.Debugf("\t%s %#v", dir, frame)
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_data_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_data_frame.go
new file mode 100644
index 00000000..bfbdcba6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_data_frame.go
@@ -0,0 +1,33 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A MaxDataFrame carries flow control information for the connection
+type MaxDataFrame struct {
+	MaximumData protocol.ByteCount
+}
+
+// parseMaxDataFrame parses a MAX_DATA frame
+func parseMaxDataFrame(b []byte, _ protocol.Version) (*MaxDataFrame, int, error) {
+	frame := &MaxDataFrame{}
+	byteOffset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	frame.MaximumData = protocol.ByteCount(byteOffset)
+	return frame, l, nil
+}
+
+func (f *MaxDataFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeMaxData))
+	b = quicvarint.Append(b, uint64(f.MaximumData))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *MaxDataFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.MaximumData)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_stream_data_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_stream_data_frame.go
new file mode 100644
index 00000000..0966ea46
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_stream_data_frame.go
@@ -0,0 +1,43 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A MaxStreamDataFrame is a MAX_STREAM_DATA frame
+type MaxStreamDataFrame struct {
+	StreamID          protocol.StreamID
+	MaximumStreamData protocol.ByteCount
+}
+
+func parseMaxStreamDataFrame(b []byte, _ protocol.Version) (*MaxStreamDataFrame, int, error) {
+	startLen := len(b)
+	sid, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	return &MaxStreamDataFrame{
+		StreamID:          protocol.StreamID(sid),
+		MaximumStreamData: protocol.ByteCount(offset),
+	}, startLen - len(b), nil
+}
+
+func (f *MaxStreamDataFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeMaxStreamData))
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.MaximumStreamData))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *MaxStreamDataFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID))+quicvarint.Len(uint64(f.MaximumStreamData)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_streams_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_streams_frame.go
new file mode 100644
index 00000000..30612e23
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/max_streams_frame.go
@@ -0,0 +1,50 @@
+package wire
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A MaxStreamsFrame is a MAX_STREAMS frame
+type MaxStreamsFrame struct {
+	Type         protocol.StreamType
+	MaxStreamNum protocol.StreamNum
+}
+
+func parseMaxStreamsFrame(b []byte, typ FrameType, _ protocol.Version) (*MaxStreamsFrame, int, error) {
+	f := &MaxStreamsFrame{}
+	//nolint:exhaustive // Function will only be called with BidiMaxStreamsFrameType or UniMaxStreamsFrameType
+	switch typ {
+	case FrameTypeBidiMaxStreams:
+		f.Type = protocol.StreamTypeBidi
+	case FrameTypeUniMaxStreams:
+		f.Type = protocol.StreamTypeUni
+	}
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	f.MaxStreamNum = protocol.StreamNum(streamID)
+	if f.MaxStreamNum > protocol.MaxStreamCount {
+		return nil, 0, fmt.Errorf("%d exceeds the maximum stream count", f.MaxStreamNum)
+	}
+	return f, l, nil
+}
+
+func (f *MaxStreamsFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	switch f.Type {
+	case protocol.StreamTypeBidi:
+		b = append(b, byte(FrameTypeBidiMaxStreams))
+	case protocol.StreamTypeUni:
+		b = append(b, byte(FrameTypeUniMaxStreams))
+	}
+	b = quicvarint.Append(b, uint64(f.MaxStreamNum))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *MaxStreamsFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.MaxStreamNum)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_connection_id_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_connection_id_frame.go
new file mode 100644
index 00000000..05831926
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_connection_id_frame.go
@@ -0,0 +1,80 @@
+package wire
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A NewConnectionIDFrame is a NEW_CONNECTION_ID frame
+type NewConnectionIDFrame struct {
+	SequenceNumber      uint64
+	RetirePriorTo       uint64
+	ConnectionID        protocol.ConnectionID
+	StatelessResetToken protocol.StatelessResetToken
+}
+
+func parseNewConnectionIDFrame(b []byte, _ protocol.Version) (*NewConnectionIDFrame, int, error) {
+	startLen := len(b)
+	seq, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	ret, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	if ret > seq {
+		//nolint:staticcheck // SA1021: Retire Prior To is the name of the field
+		return nil, 0, fmt.Errorf("Retire Prior To value (%d) larger than Sequence Number (%d)", ret, seq)
+	}
+	if len(b) == 0 {
+		return nil, 0, io.EOF
+	}
+	connIDLen := int(b[0])
+	b = b[1:]
+	if connIDLen == 0 {
+		return nil, 0, errors.New("invalid zero-length connection ID")
+	}
+	if connIDLen > protocol.MaxConnIDLen {
+		return nil, 0, protocol.ErrInvalidConnectionIDLen
+	}
+	if len(b) < connIDLen {
+		return nil, 0, io.EOF
+	}
+	frame := &NewConnectionIDFrame{
+		SequenceNumber: seq,
+		RetirePriorTo:  ret,
+		ConnectionID:   protocol.ParseConnectionID(b[:connIDLen]),
+	}
+	b = b[connIDLen:]
+	if len(b) < len(frame.StatelessResetToken) {
+		return nil, 0, io.EOF
+	}
+	copy(frame.StatelessResetToken[:], b)
+	return frame, startLen - len(b) + len(frame.StatelessResetToken), nil
+}
+
+func (f *NewConnectionIDFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeNewConnectionID))
+	b = quicvarint.Append(b, f.SequenceNumber)
+	b = quicvarint.Append(b, f.RetirePriorTo)
+	connIDLen := f.ConnectionID.Len()
+	if connIDLen > protocol.MaxConnIDLen {
+		return nil, fmt.Errorf("invalid connection ID length: %d", connIDLen)
+	}
+	b = append(b, uint8(connIDLen))
+	b = append(b, f.ConnectionID.Bytes()...)
+	b = append(b, f.StatelessResetToken[:]...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *NewConnectionIDFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(f.SequenceNumber)+quicvarint.Len(f.RetirePriorTo)+1 /* connection ID length */ +f.ConnectionID.Len()) + 16
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_token_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_token_frame.go
new file mode 100644
index 00000000..73d356b1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/new_token_frame.go
@@ -0,0 +1,43 @@
+package wire
+
+import (
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A NewTokenFrame is a NEW_TOKEN frame
+type NewTokenFrame struct {
+	Token []byte
+}
+
+func parseNewTokenFrame(b []byte, _ protocol.Version) (*NewTokenFrame, int, error) {
+	tokenLen, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	if tokenLen == 0 {
+		return nil, 0, errors.New("token must not be empty")
+	}
+	if uint64(len(b)) < tokenLen {
+		return nil, 0, io.EOF
+	}
+	token := make([]byte, int(tokenLen))
+	copy(token, b)
+	return &NewTokenFrame{Token: token}, l + int(tokenLen), nil
+}
+
+func (f *NewTokenFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeNewToken))
+	b = quicvarint.Append(b, uint64(len(f.Token)))
+	b = append(b, f.Token...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *NewTokenFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(len(f.Token)))+len(f.Token))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_challenge_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_challenge_frame.go
new file mode 100644
index 00000000..7a4a767e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_challenge_frame.go
@@ -0,0 +1,32 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A PathChallengeFrame is a PATH_CHALLENGE frame
+type PathChallengeFrame struct {
+	Data [8]byte
+}
+
+func parsePathChallengeFrame(b []byte, _ protocol.Version) (*PathChallengeFrame, int, error) {
+	f := &PathChallengeFrame{}
+	if len(b) < 8 {
+		return nil, 0, io.EOF
+	}
+	copy(f.Data[:], b)
+	return f, 8, nil
+}
+
+func (f *PathChallengeFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypePathChallenge))
+	b = append(b, f.Data[:]...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *PathChallengeFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + 8
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_response_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_response_frame.go
new file mode 100644
index 00000000..e76d037b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/path_response_frame.go
@@ -0,0 +1,32 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A PathResponseFrame is a PATH_RESPONSE frame
+type PathResponseFrame struct {
+	Data [8]byte
+}
+
+func parsePathResponseFrame(b []byte, _ protocol.Version) (*PathResponseFrame, int, error) {
+	f := &PathResponseFrame{}
+	if len(b) < 8 {
+		return nil, 0, io.EOF
+	}
+	copy(f.Data[:], b)
+	return f, 8, nil
+}
+
+func (f *PathResponseFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypePathResponse))
+	b = append(b, f.Data[:]...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *PathResponseFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + 8
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/ping_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ping_frame.go
new file mode 100644
index 00000000..5d344d44
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/ping_frame.go
@@ -0,0 +1,17 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A PingFrame is a PING frame
+type PingFrame struct{}
+
+func (f *PingFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	return append(b, byte(FrameTypePing)), nil
+}
+
+// Length of a written frame
+func (f *PingFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/pool.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/pool.go
new file mode 100644
index 00000000..d656fad4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/pool.go
@@ -0,0 +1,33 @@
+package wire
+
+import (
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+var pool sync.Pool
+
+func init() {
+	pool.New = func() any {
+		return &StreamFrame{
+			Data:     make([]byte, 0, protocol.MaxPacketBufferSize),
+			fromPool: true,
+		}
+	}
+}
+
+func GetStreamFrame() *StreamFrame {
+	f := pool.Get().(*StreamFrame)
+	return f
+}
+
+func putStreamFrame(f *StreamFrame) {
+	if !f.fromPool {
+		return
+	}
+	if protocol.ByteCount(cap(f.Data)) != protocol.MaxPacketBufferSize {
+		panic("wire.PutStreamFrame called with packet of wrong size!")
+	}
+	pool.Put(f)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/reset_stream_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/reset_stream_frame.go
new file mode 100644
index 00000000..4101b76b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/reset_stream_frame.go
@@ -0,0 +1,79 @@
+package wire
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A ResetStreamFrame is a RESET_STREAM or RESET_STREAM_AT frame in QUIC
+type ResetStreamFrame struct {
+	StreamID     protocol.StreamID
+	ErrorCode    qerr.StreamErrorCode
+	FinalSize    protocol.ByteCount
+	ReliableSize protocol.ByteCount
+}
+
+func parseResetStreamFrame(b []byte, isResetStreamAt bool, _ protocol.Version) (*ResetStreamFrame, int, error) {
+	startLen := len(b)
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	errorCode, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	finalSize, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	var reliableSize uint64
+	if isResetStreamAt {
+		reliableSize, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+	}
+	if reliableSize > finalSize {
+		return nil, 0, fmt.Errorf("RESET_STREAM_AT: reliable size can't be larger than final size (%d vs %d)", reliableSize, finalSize)
+	}
+
+	return &ResetStreamFrame{
+		StreamID:     protocol.StreamID(streamID),
+		ErrorCode:    qerr.StreamErrorCode(errorCode),
+		FinalSize:    protocol.ByteCount(finalSize),
+		ReliableSize: protocol.ByteCount(reliableSize),
+	}, startLen - len(b), nil
+}
+
+func (f *ResetStreamFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if f.ReliableSize == 0 {
+		b = quicvarint.Append(b, uint64(FrameTypeResetStream))
+	} else {
+		b = quicvarint.Append(b, uint64(FrameTypeResetStreamAt))
+	}
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.ErrorCode))
+	b = quicvarint.Append(b, uint64(f.FinalSize))
+	if f.ReliableSize > 0 {
+		b = quicvarint.Append(b, uint64(f.ReliableSize))
+	}
+	return b, nil
+}
+
+// Length of a written frame
+func (f *ResetStreamFrame) Length(protocol.Version) protocol.ByteCount {
+	size := 1 // the frame type for both RESET_STREAM and RESET_STREAM_AT fits into 1 byte
+	if f.ReliableSize > 0 {
+		size += quicvarint.Len(uint64(f.ReliableSize))
+	}
+	return protocol.ByteCount(size + quicvarint.Len(uint64(f.StreamID)) + quicvarint.Len(uint64(f.ErrorCode)) + quicvarint.Len(uint64(f.FinalSize)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/retire_connection_id_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/retire_connection_id_frame.go
new file mode 100644
index 00000000..1927f9dc
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/retire_connection_id_frame.go
@@ -0,0 +1,30 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame
+type RetireConnectionIDFrame struct {
+	SequenceNumber uint64
+}
+
+func parseRetireConnectionIDFrame(b []byte, _ protocol.Version) (*RetireConnectionIDFrame, int, error) {
+	seq, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	return &RetireConnectionIDFrame{SequenceNumber: seq}, l, nil
+}
+
+func (f *RetireConnectionIDFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeRetireConnectionID))
+	b = quicvarint.Append(b, f.SequenceNumber)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *RetireConnectionIDFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(f.SequenceNumber))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/short_header.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/short_header.go
new file mode 100644
index 00000000..cf2889c5
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/short_header.go
@@ -0,0 +1,62 @@
+package wire
+
+import (
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+// ParseShortHeader parses a short header packet.
+// It must be called after header protection was removed.
+// Otherwise, the check for the reserved bits will (most likely) fail.
+func ParseShortHeader(data []byte, connIDLen int) (length int, _ protocol.PacketNumber, _ protocol.PacketNumberLen, _ protocol.KeyPhaseBit, _ error) {
+	if len(data) == 0 {
+		return 0, 0, 0, 0, io.EOF
+	}
+	if data[0]&0x80 > 0 {
+		return 0, 0, 0, 0, errors.New("not a short header packet")
+	}
+	if data[0]&0x40 == 0 {
+		return 0, 0, 0, 0, errors.New("not a QUIC packet")
+	}
+	pnLen := protocol.PacketNumberLen(data[0]&0b11) + 1
+	if len(data) < 1+int(pnLen)+connIDLen {
+		return 0, 0, 0, 0, io.EOF
+	}
+
+	pos := 1 + connIDLen
+	pn, err := readPacketNumber(data[pos:], pnLen)
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+	kp := protocol.KeyPhaseZero
+	if data[0]&0b100 > 0 {
+		kp = protocol.KeyPhaseOne
+	}
+
+	if data[0]&0x18 != 0 {
+		err = ErrInvalidReservedBits
+	}
+	return 1 + connIDLen + int(pnLen), pn, pnLen, kp, err
+}
+
+// AppendShortHeader writes a short header.
+func AppendShortHeader(b []byte, connID protocol.ConnectionID, pn protocol.PacketNumber, pnLen protocol.PacketNumberLen, kp protocol.KeyPhaseBit) ([]byte, error) {
+	typeByte := 0x40 | uint8(pnLen-1)
+	if kp == protocol.KeyPhaseOne {
+		typeByte |= byte(1 << 2)
+	}
+	b = append(b, typeByte)
+	b = append(b, connID.Bytes()...)
+	return appendPacketNumber(b, pn, pnLen)
+}
+
+func ShortHeaderLen(dest protocol.ConnectionID, pnLen protocol.PacketNumberLen) protocol.ByteCount {
+	return 1 + protocol.ByteCount(dest.Len()) + protocol.ByteCount(pnLen)
+}
+
+func LogShortHeader(logger utils.Logger, dest protocol.ConnectionID, pn protocol.PacketNumber, pnLen protocol.PacketNumberLen, kp protocol.KeyPhaseBit) {
+	logger.Debugf("\tShort Header{DestConnectionID: %s, PacketNumber: %d, PacketNumberLen: %d, KeyPhase: %s}", dest, pn, pnLen, kp)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/stop_sending_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stop_sending_frame.go
new file mode 100644
index 00000000..2b15c710
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stop_sending_frame.go
@@ -0,0 +1,45 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StopSendingFrame is a STOP_SENDING frame
+type StopSendingFrame struct {
+	StreamID  protocol.StreamID
+	ErrorCode qerr.StreamErrorCode
+}
+
+// parseStopSendingFrame parses a STOP_SENDING frame
+func parseStopSendingFrame(b []byte, _ protocol.Version) (*StopSendingFrame, int, error) {
+	startLen := len(b)
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	errorCode, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	return &StopSendingFrame{
+		StreamID:  protocol.StreamID(streamID),
+		ErrorCode: qerr.StreamErrorCode(errorCode),
+	}, startLen - len(b), nil
+}
+
+// Length of a written frame
+func (f *StopSendingFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID))+quicvarint.Len(uint64(f.ErrorCode)))
+}
+
+func (f *StopSendingFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeStopSending))
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.ErrorCode))
+	return b, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_data_blocked_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_data_blocked_frame.go
new file mode 100644
index 00000000..3762ec76
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_data_blocked_frame.go
@@ -0,0 +1,42 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamDataBlockedFrame is a STREAM_DATA_BLOCKED frame
+type StreamDataBlockedFrame struct {
+	StreamID          protocol.StreamID
+	MaximumStreamData protocol.ByteCount
+}
+
+func parseStreamDataBlockedFrame(b []byte, _ protocol.Version) (*StreamDataBlockedFrame, int, error) {
+	startLen := len(b)
+	sid, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+
+	return &StreamDataBlockedFrame{
+		StreamID:          protocol.StreamID(sid),
+		MaximumStreamData: protocol.ByteCount(offset),
+	}, startLen - len(b) + l, nil
+}
+
+func (f *StreamDataBlockedFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, 0x15)
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.MaximumStreamData))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *StreamDataBlockedFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID))+quicvarint.Len(uint64(f.MaximumStreamData)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_frame.go
new file mode 100644
index 00000000..e53962b1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/stream_frame.go
@@ -0,0 +1,191 @@
+package wire
+
+import (
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamFrame of QUIC
+type StreamFrame struct {
+	StreamID       protocol.StreamID
+	Offset         protocol.ByteCount
+	Data           []byte
+	Fin            bool
+	DataLenPresent bool
+
+	fromPool bool
+}
+
+func ParseStreamFrame(b []byte, typ FrameType, _ protocol.Version) (*StreamFrame, int, error) {
+	startLen := len(b)
+	hasOffset := typ&0b100 > 0
+	fin := typ&0b1 > 0
+	hasDataLen := typ&0b10 > 0
+
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	var offset uint64
+	if hasOffset {
+		offset, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+	}
+
+	var dataLen uint64
+	if hasDataLen {
+		var err error
+		var l int
+		dataLen, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		if dataLen > uint64(len(b)) {
+			return nil, 0, io.EOF
+		}
+	} else {
+		// The rest of the packet is data
+		dataLen = uint64(len(b))
+	}
+
+	var frame *StreamFrame
+	if dataLen < protocol.MinStreamFrameBufferSize {
+		frame = &StreamFrame{}
+		if dataLen > 0 {
+			frame.Data = make([]byte, dataLen)
+		}
+	} else {
+		frame = GetStreamFrame()
+		// The STREAM frame can't be larger than the StreamFrame we obtained from the buffer,
+		// since those StreamFrames have a buffer length of the maximum packet size.
+		if dataLen > uint64(cap(frame.Data)) {
+			return nil, 0, io.EOF
+		}
+		frame.Data = frame.Data[:dataLen]
+	}
+
+	frame.StreamID = protocol.StreamID(streamID)
+	frame.Offset = protocol.ByteCount(offset)
+	frame.Fin = fin
+	frame.DataLenPresent = hasDataLen
+
+	if dataLen > 0 {
+		copy(frame.Data, b)
+	}
+	if frame.Offset+frame.DataLen() > protocol.MaxByteCount {
+		return nil, 0, errors.New("stream data overflows maximum offset")
+	}
+	return frame, startLen - len(b) + int(dataLen), nil
+}
+
+func (f *StreamFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if len(f.Data) == 0 && !f.Fin {
+		return nil, errors.New("StreamFrame: attempting to write empty frame without FIN")
+	}
+
+	typ := byte(0x8)
+	if f.Fin {
+		typ ^= 0b1
+	}
+	hasOffset := f.Offset != 0
+	if f.DataLenPresent {
+		typ ^= 0b10
+	}
+	if hasOffset {
+		typ ^= 0b100
+	}
+	b = append(b, typ)
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	if hasOffset {
+		b = quicvarint.Append(b, uint64(f.Offset))
+	}
+	if f.DataLenPresent {
+		b = quicvarint.Append(b, uint64(f.DataLen()))
+	}
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// Length returns the total length of the STREAM frame
+func (f *StreamFrame) Length(protocol.Version) protocol.ByteCount {
+	length := 1 + quicvarint.Len(uint64(f.StreamID))
+	if f.Offset != 0 {
+		length += quicvarint.Len(uint64(f.Offset))
+	}
+	if f.DataLenPresent {
+		length += quicvarint.Len(uint64(f.DataLen()))
+	}
+	return protocol.ByteCount(length) + f.DataLen()
+}
+
+// DataLen gives the length of data in bytes
+func (f *StreamFrame) DataLen() protocol.ByteCount {
+	return protocol.ByteCount(len(f.Data))
+}
+
+// MaxDataLen returns the maximum data length
+// If 0 is returned, writing will fail (a STREAM frame must contain at least 1 byte of data).
+func (f *StreamFrame) MaxDataLen(maxSize protocol.ByteCount, _ protocol.Version) protocol.ByteCount {
+	headerLen := 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID)))
+	if f.Offset != 0 {
+		headerLen += protocol.ByteCount(quicvarint.Len(uint64(f.Offset)))
+	}
+	if f.DataLenPresent {
+		// Pretend that the data size will be 1 byte.
+		// If it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterward
+		headerLen++
+	}
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if f.DataLenPresent && quicvarint.Len(uint64(maxDataLen)) != 1 {
+		maxDataLen--
+	}
+	return maxDataLen
+}
+
+// MaybeSplitOffFrame splits a frame such that it is not bigger than n bytes.
+// It returns if the frame was actually split.
+// The frame might not be split if:
+// * the size is large enough to fit the whole frame
+// * the size is too small to fit even a 1-byte frame. In that case, the frame returned is nil.
+func (f *StreamFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.Version) (*StreamFrame, bool /* was splitting required */) {
+	if maxSize >= f.Length(version) {
+		return nil, false
+	}
+
+	n := f.MaxDataLen(maxSize, version)
+	if n == 0 {
+		return nil, true
+	}
+
+	new := GetStreamFrame()
+	new.StreamID = f.StreamID
+	new.Offset = f.Offset
+	new.Fin = false
+	new.DataLenPresent = f.DataLenPresent
+
+	// swap the data slices
+	new.Data, f.Data = f.Data, new.Data
+	new.fromPool, f.fromPool = f.fromPool, new.fromPool
+
+	f.Data = f.Data[:protocol.ByteCount(len(new.Data))-n]
+	copy(f.Data, new.Data[n:])
+	new.Data = new.Data[:n]
+	f.Offset += n
+
+	return new, true
+}
+
+func (f *StreamFrame) PutBack() {
+	putStreamFrame(f)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/streams_blocked_frame.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/streams_blocked_frame.go
new file mode 100644
index 00000000..d98fde46
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/streams_blocked_frame.go
@@ -0,0 +1,50 @@
+package wire
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamsBlockedFrame is a STREAMS_BLOCKED frame
+type StreamsBlockedFrame struct {
+	Type        protocol.StreamType
+	StreamLimit protocol.StreamNum
+}
+
+func parseStreamsBlockedFrame(b []byte, typ FrameType, _ protocol.Version) (*StreamsBlockedFrame, int, error) {
+	f := &StreamsBlockedFrame{}
+	//nolint:exhaustive // This will only be called with a BidiStreamBlockedFrameType or a UniStreamBlockedFrameType.
+	switch typ {
+	case FrameTypeBidiStreamBlocked:
+		f.Type = protocol.StreamTypeBidi
+	case FrameTypeUniStreamBlocked:
+		f.Type = protocol.StreamTypeUni
+	}
+	streamLimit, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	f.StreamLimit = protocol.StreamNum(streamLimit)
+	if f.StreamLimit > protocol.MaxStreamCount {
+		return nil, 0, fmt.Errorf("%d exceeds the maximum stream count", f.StreamLimit)
+	}
+	return f, l, nil
+}
+
+func (f *StreamsBlockedFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	switch f.Type {
+	case protocol.StreamTypeBidi:
+		b = append(b, byte(FrameTypeBidiStreamBlocked))
+	case protocol.StreamTypeUni:
+		b = append(b, byte(FrameTypeUniStreamBlocked))
+	}
+	b = quicvarint.Append(b, uint64(f.StreamLimit))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *StreamsBlockedFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamLimit)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/transport_parameters.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/transport_parameters.go
new file mode 100644
index 00000000..3e4203bd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/transport_parameters.go
@@ -0,0 +1,593 @@
+package wire
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"net/netip"
+	"slices"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// AdditionalTransportParametersClient are additional transport parameters that will be added
+// to the client's transport parameters.
+// This is not intended for production use, but _only_ to increase the size of the ClientHello beyond
+// the usual size of less than 1 MTU.
+var AdditionalTransportParametersClient map[uint64][]byte
+
+const transportParameterMarshalingVersion = 1
+
+type transportParameterID uint64
+
+const (
+	originalDestinationConnectionIDParameterID transportParameterID = 0x0
+	maxIdleTimeoutParameterID                  transportParameterID = 0x1
+	statelessResetTokenParameterID             transportParameterID = 0x2
+	maxUDPPayloadSizeParameterID               transportParameterID = 0x3
+	initialMaxDataParameterID                  transportParameterID = 0x4
+	initialMaxStreamDataBidiLocalParameterID   transportParameterID = 0x5
+	initialMaxStreamDataBidiRemoteParameterID  transportParameterID = 0x6
+	initialMaxStreamDataUniParameterID         transportParameterID = 0x7
+	initialMaxStreamsBidiParameterID           transportParameterID = 0x8
+	initialMaxStreamsUniParameterID            transportParameterID = 0x9
+	ackDelayExponentParameterID                transportParameterID = 0xa
+	maxAckDelayParameterID                     transportParameterID = 0xb
+	disableActiveMigrationParameterID          transportParameterID = 0xc
+	preferredAddressParameterID                transportParameterID = 0xd
+	activeConnectionIDLimitParameterID         transportParameterID = 0xe
+	initialSourceConnectionIDParameterID       transportParameterID = 0xf
+	retrySourceConnectionIDParameterID         transportParameterID = 0x10
+	// RFC 9221
+	maxDatagramFrameSizeParameterID transportParameterID = 0x20
+	// https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/09/
+	resetStreamAtParameterID transportParameterID = 0x1d
+	// https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/07/
+	// When removing support for this codepoint, increment transportParameterMarshalingVersion
+	// to prevent 0-RTT resumption with tickets that remember it.
+	legacyResetStreamAtParameterID transportParameterID = 0x17f7586d2cb571
+	// https://datatracker.ietf.org/doc/draft-ietf-quic-ack-frequency/11/
+	minAckDelayParameterID transportParameterID = 0xff04de1b
+)
+
+// PreferredAddress is the value encoding in the preferred_address transport parameter
+type PreferredAddress struct {
+	IPv4, IPv6          netip.AddrPort
+	ConnectionID        protocol.ConnectionID
+	StatelessResetToken protocol.StatelessResetToken
+}
+
+// TransportParameters are parameters sent to the peer during the handshake
+type TransportParameters struct {
+	InitialMaxStreamDataBidiLocal  protocol.ByteCount
+	InitialMaxStreamDataBidiRemote protocol.ByteCount
+	InitialMaxStreamDataUni        protocol.ByteCount
+	InitialMaxData                 protocol.ByteCount
+
+	MaxAckDelay      time.Duration
+	AckDelayExponent uint8
+
+	DisableActiveMigration bool
+
+	MaxUDPPayloadSize protocol.ByteCount
+
+	MaxUniStreamNum  protocol.StreamNum
+	MaxBidiStreamNum protocol.StreamNum
+
+	MaxIdleTimeout time.Duration
+
+	PreferredAddress *PreferredAddress
+
+	OriginalDestinationConnectionID protocol.ConnectionID
+	InitialSourceConnectionID       protocol.ConnectionID
+	RetrySourceConnectionID         *protocol.ConnectionID // use a pointer here to distinguish zero-length connection IDs from missing transport parameters
+
+	StatelessResetToken     *protocol.StatelessResetToken
+	ActiveConnectionIDLimit uint64
+
+	MaxDatagramFrameSize protocol.ByteCount // RFC 9221
+	EnableResetStreamAt  bool               // https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/09/
+	MinAckDelay          *time.Duration
+}
+
+// Unmarshal the transport parameters
+func (p *TransportParameters) Unmarshal(data []byte, sentBy protocol.Perspective) error {
+	if err := p.unmarshal(data, sentBy, false); err != nil {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.TransportParameterError,
+			ErrorMessage: err.Error(),
+		}
+	}
+	return nil
+}
+
+func (p *TransportParameters) unmarshal(b []byte, sentBy protocol.Perspective, fromSessionTicket bool) error {
+	// needed to check that every parameter is only sent at most once
+	parameterIDs := make([]transportParameterID, 0, 32)
+
+	var (
+		readOriginalDestinationConnectionID bool
+		readInitialSourceConnectionID       bool
+	)
+
+	p.AckDelayExponent = protocol.DefaultAckDelayExponent
+	p.MaxAckDelay = protocol.DefaultMaxAckDelay
+	p.MaxDatagramFrameSize = protocol.InvalidByteCount
+	p.ActiveConnectionIDLimit = protocol.DefaultActiveConnectionIDLimit
+
+	for len(b) > 0 {
+		paramIDInt, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return err
+		}
+		paramID := transportParameterID(paramIDInt)
+		b = b[l:]
+		paramLen, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return err
+		}
+		b = b[l:]
+		if uint64(len(b)) < paramLen {
+			return fmt.Errorf("remaining length (%d) smaller than parameter length (%d)", len(b), paramLen)
+		}
+		parameterIDs = append(parameterIDs, paramID)
+		switch paramID {
+		case maxIdleTimeoutParameterID,
+			maxUDPPayloadSizeParameterID,
+			initialMaxDataParameterID,
+			initialMaxStreamDataBidiLocalParameterID,
+			initialMaxStreamDataBidiRemoteParameterID,
+			initialMaxStreamDataUniParameterID,
+			initialMaxStreamsBidiParameterID,
+			initialMaxStreamsUniParameterID,
+			maxAckDelayParameterID,
+			maxDatagramFrameSizeParameterID,
+			ackDelayExponentParameterID,
+			activeConnectionIDLimitParameterID,
+			minAckDelayParameterID:
+			if err := p.readNumericTransportParameter(b, paramID, int(paramLen)); err != nil {
+				return err
+			}
+			b = b[paramLen:]
+		case preferredAddressParameterID:
+			if sentBy == protocol.PerspectiveClient {
+				return errors.New("client sent a preferred_address")
+			}
+			if err := p.readPreferredAddress(b, int(paramLen)); err != nil {
+				return err
+			}
+			b = b[paramLen:]
+		case disableActiveMigrationParameterID:
+			if paramLen != 0 {
+				return fmt.Errorf("wrong length for disable_active_migration: %d (expected empty)", paramLen)
+			}
+			p.DisableActiveMigration = true
+		case statelessResetTokenParameterID:
+			if sentBy == protocol.PerspectiveClient {
+				return errors.New("client sent a stateless_reset_token")
+			}
+			if paramLen != 16 {
+				return fmt.Errorf("wrong length for stateless_reset_token: %d (expected 16)", paramLen)
+			}
+			var token protocol.StatelessResetToken
+			if len(b) < len(token) {
+				return io.EOF
+			}
+			copy(token[:], b)
+			b = b[len(token):]
+			p.StatelessResetToken = &token
+		case originalDestinationConnectionIDParameterID:
+			if sentBy == protocol.PerspectiveClient {
+				return errors.New("client sent an original_destination_connection_id")
+			}
+			if paramLen > protocol.MaxConnIDLen {
+				return protocol.ErrInvalidConnectionIDLen
+			}
+			p.OriginalDestinationConnectionID = protocol.ParseConnectionID(b[:paramLen])
+			b = b[paramLen:]
+			readOriginalDestinationConnectionID = true
+		case initialSourceConnectionIDParameterID:
+			if paramLen > protocol.MaxConnIDLen {
+				return protocol.ErrInvalidConnectionIDLen
+			}
+			p.InitialSourceConnectionID = protocol.ParseConnectionID(b[:paramLen])
+			b = b[paramLen:]
+			readInitialSourceConnectionID = true
+		case retrySourceConnectionIDParameterID:
+			if sentBy == protocol.PerspectiveClient {
+				return errors.New("client sent a retry_source_connection_id")
+			}
+			if paramLen > protocol.MaxConnIDLen {
+				return protocol.ErrInvalidConnectionIDLen
+			}
+			connID := protocol.ParseConnectionID(b[:paramLen])
+			b = b[paramLen:]
+			p.RetrySourceConnectionID = &connID
+		case resetStreamAtParameterID, legacyResetStreamAtParameterID:
+			if paramLen != 0 {
+				return fmt.Errorf("wrong length for reset_stream_at: %d (expected empty)", paramLen)
+			}
+			p.EnableResetStreamAt = true
+		default:
+			if fromSessionTicket {
+				// A ticket might contain a parameter for an extension supported by an older
+				// version of this endpoint. If we can't parse it, don't resume with it.
+				return fmt.Errorf("unknown transport parameter %#x in session ticket", paramID)
+			}
+			b = b[paramLen:]
+		}
+	}
+
+	// min_ack_delay must be less or equal to max_ack_delay
+	if p.MinAckDelay != nil && *p.MinAckDelay > p.MaxAckDelay {
+		return fmt.Errorf("min_ack_delay (%s) is greater than max_ack_delay (%s)", *p.MinAckDelay, p.MaxAckDelay)
+	}
+	if !fromSessionTicket {
+		if sentBy == protocol.PerspectiveServer && !readOriginalDestinationConnectionID {
+			return errors.New("missing original_destination_connection_id")
+		}
+		if p.MaxUDPPayloadSize == 0 {
+			p.MaxUDPPayloadSize = protocol.MaxByteCount
+		}
+		if !readInitialSourceConnectionID {
+			return errors.New("missing initial_source_connection_id")
+		}
+	}
+
+	// check that every transport parameter was sent at most once
+	slices.Sort(parameterIDs)
+	for i := range len(parameterIDs) - 1 {
+		if parameterIDs[i] == parameterIDs[i+1] {
+			return fmt.Errorf("received duplicate transport parameter %#x", parameterIDs[i])
+		}
+	}
+
+	return nil
+}
+
+func (p *TransportParameters) readPreferredAddress(b []byte, expectedLen int) error {
+	remainingLen := len(b)
+	pa := &PreferredAddress{}
+	if len(b) < 4+2+16+2+1 {
+		return io.EOF
+	}
+	var ipv4 [4]byte
+	copy(ipv4[:], b[:4])
+	port4 := binary.BigEndian.Uint16(b[4:])
+	b = b[4+2:]
+	if port4 != 0 && ipv4 != [4]byte{} {
+		pa.IPv4 = netip.AddrPortFrom(netip.AddrFrom4(ipv4), port4)
+	}
+	var ipv6 [16]byte
+	copy(ipv6[:], b[:16])
+	port6 := binary.BigEndian.Uint16(b[16:])
+	if port6 != 0 && ipv6 != [16]byte{} {
+		pa.IPv6 = netip.AddrPortFrom(netip.AddrFrom16(ipv6), port6)
+	}
+	b = b[16+2:]
+	connIDLen := int(b[0])
+	b = b[1:]
+	if connIDLen == 0 || connIDLen > protocol.MaxConnIDLen {
+		return fmt.Errorf("invalid connection ID length: %d", connIDLen)
+	}
+	if len(b) < connIDLen+len(pa.StatelessResetToken) {
+		return io.EOF
+	}
+	pa.ConnectionID = protocol.ParseConnectionID(b[:connIDLen])
+	b = b[connIDLen:]
+	copy(pa.StatelessResetToken[:], b)
+	b = b[len(pa.StatelessResetToken):]
+	if bytesRead := remainingLen - len(b); bytesRead != expectedLen {
+		return fmt.Errorf("expected preferred_address to be %d long, read %d bytes", expectedLen, bytesRead)
+	}
+	p.PreferredAddress = pa
+	return nil
+}
+
+func (p *TransportParameters) readNumericTransportParameter(b []byte, paramID transportParameterID, expectedLen int) error {
+	val, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return fmt.Errorf("error while reading transport parameter %d: %s", paramID, err)
+	}
+	if l != expectedLen {
+		return fmt.Errorf("inconsistent transport parameter length for transport parameter %#x", paramID)
+	}
+	//nolint:exhaustive // This only covers the numeric transport parameters.
+	switch paramID {
+	case initialMaxStreamDataBidiLocalParameterID:
+		p.InitialMaxStreamDataBidiLocal = protocol.ByteCount(val)
+	case initialMaxStreamDataBidiRemoteParameterID:
+		p.InitialMaxStreamDataBidiRemote = protocol.ByteCount(val)
+	case initialMaxStreamDataUniParameterID:
+		p.InitialMaxStreamDataUni = protocol.ByteCount(val)
+	case initialMaxDataParameterID:
+		p.InitialMaxData = protocol.ByteCount(val)
+	case initialMaxStreamsBidiParameterID:
+		p.MaxBidiStreamNum = protocol.StreamNum(val)
+		if p.MaxBidiStreamNum > protocol.MaxStreamCount {
+			return fmt.Errorf("initial_max_streams_bidi too large: %d (maximum %d)", p.MaxBidiStreamNum, protocol.MaxStreamCount)
+		}
+	case initialMaxStreamsUniParameterID:
+		p.MaxUniStreamNum = protocol.StreamNum(val)
+		if p.MaxUniStreamNum > protocol.MaxStreamCount {
+			return fmt.Errorf("initial_max_streams_uni too large: %d (maximum %d)", p.MaxUniStreamNum, protocol.MaxStreamCount)
+		}
+	case maxIdleTimeoutParameterID:
+		p.MaxIdleTimeout = max(protocol.MinRemoteIdleTimeout, time.Duration(val)*time.Millisecond)
+	case maxUDPPayloadSizeParameterID:
+		if val < 1200 {
+			return fmt.Errorf("invalid value for max_udp_payload_size: %d (minimum 1200)", val)
+		}
+		p.MaxUDPPayloadSize = protocol.ByteCount(val)
+	case ackDelayExponentParameterID:
+		if val > protocol.MaxAckDelayExponent {
+			return fmt.Errorf("invalid value for ack_delay_exponent: %d (maximum %d)", val, protocol.MaxAckDelayExponent)
+		}
+		p.AckDelayExponent = uint8(val)
+	case maxAckDelayParameterID:
+		if val > uint64(protocol.MaxMaxAckDelay/time.Millisecond) {
+			return fmt.Errorf("invalid value for max_ack_delay: %dms (maximum %dms)", val, protocol.MaxMaxAckDelay/time.Millisecond)
+		}
+		p.MaxAckDelay = time.Duration(val) * time.Millisecond
+	case activeConnectionIDLimitParameterID:
+		if val < 2 {
+			return fmt.Errorf("invalid value for active_connection_id_limit: %d (minimum 2)", val)
+		}
+		p.ActiveConnectionIDLimit = val
+	case maxDatagramFrameSizeParameterID:
+		p.MaxDatagramFrameSize = protocol.ByteCount(val)
+	case minAckDelayParameterID:
+		mad := time.Duration(val) * time.Microsecond
+		if mad < 0 {
+			mad = math.MaxInt64
+		}
+		p.MinAckDelay = &mad
+	default:
+		return fmt.Errorf("TransportParameter BUG: transport parameter %d not found", paramID)
+	}
+	return nil
+}
+
+// Marshal the transport parameters
+func (p *TransportParameters) Marshal(pers protocol.Perspective) []byte {
+	// Typical Transport Parameters consume around 110 bytes, depending on the exact values,
+	// especially the lengths of the Connection IDs.
+	// Allocate 256 bytes, so we won't have to grow the slice in any case.
+	b := make([]byte, 0, 256)
+
+	// add a greased value
+	random := make([]byte, 18)
+	rand.Read(random)
+	b = quicvarint.Append(b, 27+31*uint64(random[0]))
+	length := random[1] % 16
+	b = quicvarint.Append(b, uint64(length))
+	b = append(b, random[2:2+length]...)
+
+	// initial_max_stream_data_bidi_local
+	b = p.marshalVarintParam(b, initialMaxStreamDataBidiLocalParameterID, uint64(p.InitialMaxStreamDataBidiLocal))
+	// initial_max_stream_data_bidi_remote
+	b = p.marshalVarintParam(b, initialMaxStreamDataBidiRemoteParameterID, uint64(p.InitialMaxStreamDataBidiRemote))
+	// initial_max_stream_data_uni
+	b = p.marshalVarintParam(b, initialMaxStreamDataUniParameterID, uint64(p.InitialMaxStreamDataUni))
+	// initial_max_data
+	b = p.marshalVarintParam(b, initialMaxDataParameterID, uint64(p.InitialMaxData))
+	// initial_max_bidi_streams
+	b = p.marshalVarintParam(b, initialMaxStreamsBidiParameterID, uint64(p.MaxBidiStreamNum))
+	// initial_max_uni_streams
+	b = p.marshalVarintParam(b, initialMaxStreamsUniParameterID, uint64(p.MaxUniStreamNum))
+	// idle_timeout
+	b = p.marshalVarintParam(b, maxIdleTimeoutParameterID, uint64(p.MaxIdleTimeout/time.Millisecond))
+	// max_udp_payload_size
+	if p.MaxUDPPayloadSize > 0 {
+		b = p.marshalVarintParam(b, maxUDPPayloadSizeParameterID, uint64(p.MaxUDPPayloadSize))
+	}
+	// max_ack_delay
+	// Only send it if is different from the default value.
+	if p.MaxAckDelay != protocol.DefaultMaxAckDelay {
+		b = p.marshalVarintParam(b, maxAckDelayParameterID, uint64(p.MaxAckDelay/time.Millisecond))
+	}
+	// ack_delay_exponent
+	// Only send it if is different from the default value.
+	if p.AckDelayExponent != protocol.DefaultAckDelayExponent {
+		b = p.marshalVarintParam(b, ackDelayExponentParameterID, uint64(p.AckDelayExponent))
+	}
+	// disable_active_migration
+	if p.DisableActiveMigration {
+		b = quicvarint.Append(b, uint64(disableActiveMigrationParameterID))
+		b = quicvarint.Append(b, 0)
+	}
+	if pers == protocol.PerspectiveServer {
+		// stateless_reset_token
+		if p.StatelessResetToken != nil {
+			b = quicvarint.Append(b, uint64(statelessResetTokenParameterID))
+			b = quicvarint.Append(b, 16)
+			b = append(b, p.StatelessResetToken[:]...)
+		}
+		// original_destination_connection_id
+		b = quicvarint.Append(b, uint64(originalDestinationConnectionIDParameterID))
+		b = quicvarint.Append(b, uint64(p.OriginalDestinationConnectionID.Len()))
+		b = append(b, p.OriginalDestinationConnectionID.Bytes()...)
+		// preferred_address
+		if p.PreferredAddress != nil {
+			b = quicvarint.Append(b, uint64(preferredAddressParameterID))
+			b = quicvarint.Append(b, 4+2+16+2+1+uint64(p.PreferredAddress.ConnectionID.Len())+16)
+			if p.PreferredAddress.IPv4.IsValid() {
+				ipv4 := p.PreferredAddress.IPv4.Addr().As4()
+				b = append(b, ipv4[:]...)
+				b = binary.BigEndian.AppendUint16(b, p.PreferredAddress.IPv4.Port())
+			} else {
+				b = append(b, make([]byte, 6)...)
+			}
+			if p.PreferredAddress.IPv6.IsValid() {
+				ipv6 := p.PreferredAddress.IPv6.Addr().As16()
+				b = append(b, ipv6[:]...)
+				b = binary.BigEndian.AppendUint16(b, p.PreferredAddress.IPv6.Port())
+			} else {
+				b = append(b, make([]byte, 18)...)
+			}
+			b = append(b, uint8(p.PreferredAddress.ConnectionID.Len()))
+			b = append(b, p.PreferredAddress.ConnectionID.Bytes()...)
+			b = append(b, p.PreferredAddress.StatelessResetToken[:]...)
+		}
+	}
+	// active_connection_id_limit
+	if p.ActiveConnectionIDLimit != protocol.DefaultActiveConnectionIDLimit {
+		b = p.marshalVarintParam(b, activeConnectionIDLimitParameterID, p.ActiveConnectionIDLimit)
+	}
+	// initial_source_connection_id
+	b = quicvarint.Append(b, uint64(initialSourceConnectionIDParameterID))
+	b = quicvarint.Append(b, uint64(p.InitialSourceConnectionID.Len()))
+	b = append(b, p.InitialSourceConnectionID.Bytes()...)
+	// retry_source_connection_id
+	if pers == protocol.PerspectiveServer && p.RetrySourceConnectionID != nil {
+		b = quicvarint.Append(b, uint64(retrySourceConnectionIDParameterID))
+		b = quicvarint.Append(b, uint64(p.RetrySourceConnectionID.Len()))
+		b = append(b, p.RetrySourceConnectionID.Bytes()...)
+	}
+	// QUIC datagrams
+	if p.MaxDatagramFrameSize != protocol.InvalidByteCount {
+		b = p.marshalVarintParam(b, maxDatagramFrameSizeParameterID, uint64(p.MaxDatagramFrameSize))
+	}
+	// QUIC Stream Resets with Partial Delivery
+	if p.EnableResetStreamAt {
+		b = quicvarint.Append(b, uint64(resetStreamAtParameterID))
+		b = quicvarint.Append(b, 0)
+	}
+	if p.MinAckDelay != nil {
+		b = p.marshalVarintParam(b, minAckDelayParameterID, uint64(*p.MinAckDelay/time.Microsecond))
+	}
+
+	if pers == protocol.PerspectiveClient && len(AdditionalTransportParametersClient) > 0 {
+		for k, v := range AdditionalTransportParametersClient {
+			b = quicvarint.Append(b, k)
+			b = quicvarint.Append(b, uint64(len(v)))
+			b = append(b, v...)
+		}
+	}
+
+	return b
+}
+
+func (p *TransportParameters) marshalVarintParam(b []byte, id transportParameterID, val uint64) []byte {
+	b = quicvarint.Append(b, uint64(id))
+	b = quicvarint.Append(b, uint64(quicvarint.Len(val)))
+	return quicvarint.Append(b, val)
+}
+
+// MarshalForSessionTicket marshals the transport parameters we save in the session ticket.
+// When sending a 0-RTT enabled TLS session tickets, we need to save the transport parameters.
+// The client will remember the transport parameters used in the last session,
+// and apply those to the 0-RTT data it sends.
+// Saving the transport parameters in the ticket gives the server the option to reject 0-RTT
+// if the transport parameters changed.
+// Since the session ticket is encrypted, the serialization format is defined by the server.
+// For convenience, we use the same format that we also use for sending the transport parameters.
+func (p *TransportParameters) MarshalForSessionTicket(b []byte) []byte {
+	b = quicvarint.Append(b, transportParameterMarshalingVersion)
+
+	// initial_max_stream_data_bidi_local
+	b = p.marshalVarintParam(b, initialMaxStreamDataBidiLocalParameterID, uint64(p.InitialMaxStreamDataBidiLocal))
+	// initial_max_stream_data_bidi_remote
+	b = p.marshalVarintParam(b, initialMaxStreamDataBidiRemoteParameterID, uint64(p.InitialMaxStreamDataBidiRemote))
+	// initial_max_stream_data_uni
+	b = p.marshalVarintParam(b, initialMaxStreamDataUniParameterID, uint64(p.InitialMaxStreamDataUni))
+	// initial_max_data
+	b = p.marshalVarintParam(b, initialMaxDataParameterID, uint64(p.InitialMaxData))
+	// initial_max_bidi_streams
+	b = p.marshalVarintParam(b, initialMaxStreamsBidiParameterID, uint64(p.MaxBidiStreamNum))
+	// initial_max_uni_streams
+	b = p.marshalVarintParam(b, initialMaxStreamsUniParameterID, uint64(p.MaxUniStreamNum))
+	// active_connection_id_limit
+	b = p.marshalVarintParam(b, activeConnectionIDLimitParameterID, p.ActiveConnectionIDLimit)
+	// max_datagram_frame_size
+	if p.MaxDatagramFrameSize != protocol.InvalidByteCount {
+		b = p.marshalVarintParam(b, maxDatagramFrameSizeParameterID, uint64(p.MaxDatagramFrameSize))
+	}
+	// reset_stream_at
+	if p.EnableResetStreamAt {
+		b = quicvarint.Append(b, uint64(resetStreamAtParameterID))
+		b = quicvarint.Append(b, 0)
+	}
+	return b
+}
+
+// UnmarshalFromSessionTicket unmarshals transport parameters from a session ticket.
+func (p *TransportParameters) UnmarshalFromSessionTicket(b []byte) error {
+	version, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return err
+	}
+	if version != transportParameterMarshalingVersion {
+		return fmt.Errorf("unknown transport parameter marshaling version: %d", version)
+	}
+	return p.unmarshal(b[l:], protocol.PerspectiveServer, true)
+}
+
+// ValidFor0RTT checks if the transport parameters match those saved in the session ticket.
+func (p *TransportParameters) ValidFor0RTT(saved *TransportParameters) bool {
+	if saved.MaxDatagramFrameSize != protocol.InvalidByteCount && (p.MaxDatagramFrameSize == protocol.InvalidByteCount || p.MaxDatagramFrameSize < saved.MaxDatagramFrameSize) {
+		return false
+	}
+	if saved.EnableResetStreamAt && !p.EnableResetStreamAt {
+		return false
+	}
+	return p.InitialMaxStreamDataBidiLocal >= saved.InitialMaxStreamDataBidiLocal &&
+		p.InitialMaxStreamDataBidiRemote >= saved.InitialMaxStreamDataBidiRemote &&
+		p.InitialMaxStreamDataUni >= saved.InitialMaxStreamDataUni &&
+		p.InitialMaxData >= saved.InitialMaxData &&
+		p.MaxBidiStreamNum >= saved.MaxBidiStreamNum &&
+		p.MaxUniStreamNum >= saved.MaxUniStreamNum &&
+		p.ActiveConnectionIDLimit == saved.ActiveConnectionIDLimit
+}
+
+// ValidForUpdate checks that the new transport parameters don't reduce limits after resuming a 0-RTT connection.
+// It is only used on the client side.
+func (p *TransportParameters) ValidForUpdate(saved *TransportParameters) bool {
+	if saved.MaxDatagramFrameSize != protocol.InvalidByteCount && (p.MaxDatagramFrameSize == protocol.InvalidByteCount || p.MaxDatagramFrameSize < saved.MaxDatagramFrameSize) {
+		return false
+	}
+	if saved.EnableResetStreamAt && !p.EnableResetStreamAt {
+		return false
+	}
+	return p.ActiveConnectionIDLimit >= saved.ActiveConnectionIDLimit &&
+		p.InitialMaxData >= saved.InitialMaxData &&
+		p.InitialMaxStreamDataBidiLocal >= saved.InitialMaxStreamDataBidiLocal &&
+		p.InitialMaxStreamDataBidiRemote >= saved.InitialMaxStreamDataBidiRemote &&
+		p.InitialMaxStreamDataUni >= saved.InitialMaxStreamDataUni &&
+		p.MaxBidiStreamNum >= saved.MaxBidiStreamNum &&
+		p.MaxUniStreamNum >= saved.MaxUniStreamNum
+}
+
+// String returns a string representation, intended for logging.
+func (p *TransportParameters) String() string {
+	logString := "&wire.TransportParameters{OriginalDestinationConnectionID: %s, InitialSourceConnectionID: %s, "
+	logParams := []any{p.OriginalDestinationConnectionID, p.InitialSourceConnectionID}
+	if p.RetrySourceConnectionID != nil {
+		logString += "RetrySourceConnectionID: %s, "
+		logParams = append(logParams, p.RetrySourceConnectionID)
+	}
+	logString += "InitialMaxStreamDataBidiLocal: %d, InitialMaxStreamDataBidiRemote: %d, InitialMaxStreamDataUni: %d, InitialMaxData: %d, MaxBidiStreamNum: %d, MaxUniStreamNum: %d, MaxIdleTimeout: %s, AckDelayExponent: %d, MaxAckDelay: %s, ActiveConnectionIDLimit: %d"
+	logParams = append(logParams, []any{p.InitialMaxStreamDataBidiLocal, p.InitialMaxStreamDataBidiRemote, p.InitialMaxStreamDataUni, p.InitialMaxData, p.MaxBidiStreamNum, p.MaxUniStreamNum, p.MaxIdleTimeout, p.AckDelayExponent, p.MaxAckDelay, p.ActiveConnectionIDLimit}...)
+	if p.StatelessResetToken != nil { // the client never sends a stateless reset token
+		logString += ", StatelessResetToken: %#x"
+		logParams = append(logParams, *p.StatelessResetToken)
+	}
+	if p.MaxDatagramFrameSize != protocol.InvalidByteCount {
+		logString += ", MaxDatagramFrameSize: %d"
+		logParams = append(logParams, p.MaxDatagramFrameSize)
+	}
+	logString += ", EnableResetStreamAt: %t"
+	logParams = append(logParams, p.EnableResetStreamAt)
+	if p.MinAckDelay != nil {
+		logString += ", MinAckDelay: %s"
+		logParams = append(logParams, *p.MinAckDelay)
+	}
+	logString += "}"
+	return fmt.Sprintf(logString, logParams...)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/internal/wire/version_negotiation.go b/backend/vendor/github.com/quic-go/quic-go/internal/wire/version_negotiation.go
new file mode 100644
index 00000000..407cb629
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/internal/wire/version_negotiation.go
@@ -0,0 +1,53 @@
+package wire
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// ParseVersionNegotiationPacket parses a Version Negotiation packet.
+func ParseVersionNegotiationPacket(b []byte) (dest, src protocol.ArbitraryLenConnectionID, _ []protocol.Version, _ error) {
+	n, dest, src, err := ParseArbitraryLenConnectionIDs(b)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	b = b[n:]
+	if len(b) == 0 {
+		//nolint:staticcheck // SA1021: the packet is called Version Negotiation packet
+		return nil, nil, nil, errors.New("Version Negotiation packet has empty version list")
+	}
+	if len(b)%4 != 0 {
+		//nolint:staticcheck // SA1021: the packet is called Version Negotiation packet
+		return nil, nil, nil, errors.New("Version Negotiation packet has a version list with an invalid length")
+	}
+	versions := make([]protocol.Version, len(b)/4)
+	for i := 0; len(b) > 0; i++ {
+		versions[i] = protocol.Version(binary.BigEndian.Uint32(b[:4]))
+		b = b[4:]
+	}
+	return dest, src, versions, nil
+}
+
+// ComposeVersionNegotiation composes a Version Negotiation
+func ComposeVersionNegotiation(destConnID, srcConnID protocol.ArbitraryLenConnectionID, versions []protocol.Version) []byte {
+	greasedVersions := protocol.GetGreasedVersions(versions)
+	expectedLen := 1 /* type byte */ + 4 /* version field */ + 1 /* dest connection ID length field */ + destConnID.Len() + 1 /* src connection ID length field */ + srcConnID.Len() + len(greasedVersions)*4
+	buf := make([]byte, 1+4 /* type byte and version field */, expectedLen)
+	_, _ = rand.Read(buf[:1]) // ignore the error here. It is not critical to have perfect random here.
+	// Setting the "QUIC bit" (0x40) is not required by the RFC,
+	// but it allows clients to demultiplex QUIC with a long list of other protocols.
+	// See RFC 9443 and https://mailarchive.ietf.org/arch/msg/quic/oR4kxGKY6mjtPC1CZegY1ED4beg/ for details.
+	buf[0] |= 0xc0
+	// The next 4 bytes are left at 0 (version number).
+	buf = append(buf, uint8(destConnID.Len()))
+	buf = append(buf, destConnID.Bytes()...)
+	buf = append(buf, uint8(srcConnID.Len()))
+	buf = append(buf, srcConnID.Bytes()...)
+	for _, v := range greasedVersions {
+		buf = binary.BigEndian.AppendUint32(buf, uint32(v))
+	}
+	return buf
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/mockgen.go b/backend/vendor/github.com/quic-go/quic-go/mockgen.go
new file mode 100644
index 00000000..65160d0d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/mockgen.go
@@ -0,0 +1,47 @@
+//go:build gomock || generate
+
+package quic
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_send_conn_test.go github.com/quic-go/quic-go SendConn"
+type SendConn = sendConn
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_raw_conn_test.go github.com/quic-go/quic-go RawConn"
+type RawConn = rawConn
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_sender_test.go github.com/quic-go/quic-go Sender"
+type Sender = sender
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_sender_test.go github.com/quic-go/quic-go StreamSender"
+type StreamSender = streamSender
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_control_frame_getter_test.go github.com/quic-go/quic-go StreamControlFrameGetter"
+type StreamControlFrameGetter = streamControlFrameGetter
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_frame_getter_test.go github.com/quic-go/quic-go StreamFrameGetter"
+type StreamFrameGetter = streamFrameGetter
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_frame_source_test.go github.com/quic-go/quic-go FrameSource"
+type FrameSource = frameSource
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_ack_frame_source_test.go github.com/quic-go/quic-go AckFrameSource"
+type AckFrameSource = ackFrameSource
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_sealing_manager_test.go github.com/quic-go/quic-go SealingManager"
+type SealingManager = sealingManager
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_unpacker_test.go github.com/quic-go/quic-go Unpacker"
+type Unpacker = unpacker
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_packer_test.go github.com/quic-go/quic-go Packer"
+type Packer = packer
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_mtu_discoverer_test.go github.com/quic-go/quic-go MTUDiscoverer"
+type MTUDiscoverer = mtuDiscoverer
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_conn_runner_test.go github.com/quic-go/quic-go ConnRunner"
+type ConnRunner = connRunner
+
+//go:generate sh -c "go tool mockgen -typed -build_flags=\"-tags=gomock\" -package quic -self_package github.com/quic-go/quic-go -destination mock_packet_handler_test.go github.com/quic-go/quic-go PacketHandler"
+type PacketHandler = packetHandler
+
+//go:generate sh -c "go tool mockgen -typed -package quic -self_package github.com/quic-go/quic-go -self_package github.com/quic-go/quic-go -destination mock_packetconn_test.go net PacketConn"
diff --git a/backend/vendor/github.com/quic-go/quic-go/mtu_discoverer.go b/backend/vendor/github.com/quic-go/quic-go/mtu_discoverer.go
new file mode 100644
index 00000000..b2a75ae4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/mtu_discoverer.go
@@ -0,0 +1,253 @@
+package quic
+
+import (
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+type mtuDiscoverer interface {
+	// Start starts the MTU discovery process.
+	// It's unnecessary to call ShouldSendProbe before that.
+	Start(now monotime.Time)
+	ShouldSendProbe(now monotime.Time) bool
+	CurrentSize() protocol.ByteCount
+	GetPing(now monotime.Time) (ping ackhandler.Frame, datagramSize protocol.ByteCount)
+	Reset(now monotime.Time, start, max protocol.ByteCount)
+}
+
+const (
+	// At some point, we have to stop searching for a higher MTU.
+	// We're happy to send a packet that's 10 bytes smaller than the actual MTU.
+	maxMTUDiff protocol.ByteCount = 20
+	// send a probe packet every mtuProbeDelay RTTs
+	mtuProbeDelay = 5
+	// Once maxLostMTUProbes MTU probe packets larger than a certain size are lost,
+	// MTU discovery won't probe for larger MTUs than this size.
+	// The algorithm used here is resilient to packet loss of (maxLostMTUProbes - 1) packets.
+	maxLostMTUProbes = 3
+)
+
+// The Path MTU is found by sending a larger packet every now and then.
+// If the packet is acknowledged, we conclude that the path supports this larger packet size.
+// If the packet is lost, this can mean one of two things:
+//   1. The path doesn't support this larger packet size, or
+//   2. The packet was lost due to packet loss, independent of its size.
+// The algorithm used here is resilient to packet loss of (maxLostMTUProbes - 1) packets.
+// For simplicty, the following example use maxLostMTUProbes = 2.
+//
+// Initialization:
+//    |------------------------------------------------------------------------------|
+//   min                                                                            max
+//
+// The first MTU probe packet will have size (min+max)/2.
+// Assume that this packet is acknowledged. We can now move the min marker,
+// and continue the search in the resulting interval.
+//
+// If 1st probe packet acknowledged:
+//    |---------------------------------------|--------------------------------------|
+//                                           min                                    max
+//
+// If 1st probe packet lost:
+//    |---------------------------------------|--------------------------------------|
+//   min                                    lost[0]                                 max
+//
+// We can't conclude that the path doesn't support this packet size, since the loss of the probe
+// packet could have been unrelated to the packet size.  A larger probe packet will be sent later on.
+// After a loss, the next probe packet has size (min+lost[0])/2.
+// Now assume this probe packet is acknowledged:
+//
+// 2nd probe packet acknowledged:
+//    |------------------|--------------------|--------------------------------------|
+//                      min                lost[0]                                  max
+//
+// First of all, we conclude that the path supports at least this MTU. That's progress!
+// Second, we probe a bit more aggressively with the next probe packet:
+// After an acknowledgement, the next probe packet has size (min+max)/2.
+// This means we'll send a packet larger than the first probe packet (which was lost).
+//
+// If 3rd probe packet acknowledged:
+//    |-------------------------------------------------|----------------------------|
+//                                                     min                          max
+//
+// We can conclude that the loss of the 1st probe packet was not due to its size, and
+// continue searching in a much smaller interval now.
+//
+// If 3rd probe packet lost:
+//    |------------------|--------------------|---------|----------------------------|
+//                      min                lost[0]     max
+//
+// Since in our example numPTOProbes = 2, and we lost 2 packets smaller than max, we
+// conclude that this packet size is not supported on the path, and reduce the maximum
+// value of the search interval.
+//
+// MTU discovery concludes once the interval min and max has been narrowed down to maxMTUDiff.
+
+type mtuFinder struct {
+	lastProbeTime monotime.Time
+
+	rttStats *utils.RTTStats
+
+	inFlight protocol.ByteCount // the size of the probe packet currently in flight. InvalidByteCount if none is in flight
+	min      protocol.ByteCount
+
+	// on initialization, we treat the maximum size as the first "lost" packet
+	lost             [maxLostMTUProbes]protocol.ByteCount
+	lastProbeWasLost bool
+
+	// The generation is used to ignore ACKs / losses for probe packets sent before a reset.
+	// Resets happen when the connection is migrated to a new path.
+	// We're therefore not concerned about overflows of this counter.
+	generation uint8
+
+	qlogger qlogwriter.Recorder
+}
+
+var _ mtuDiscoverer = &mtuFinder{}
+
+func newMTUDiscoverer(
+	rttStats *utils.RTTStats,
+	start, max protocol.ByteCount,
+	qlogger qlogwriter.Recorder,
+) *mtuFinder {
+	f := &mtuFinder{
+		inFlight: protocol.InvalidByteCount,
+		rttStats: rttStats,
+		qlogger:  qlogger,
+	}
+	f.init(start, max)
+	return f
+}
+
+func (f *mtuFinder) init(start, max protocol.ByteCount) {
+	f.min = start
+	for i := range f.lost {
+		if i == 0 {
+			f.lost[i] = max
+			continue
+		}
+		f.lost[i] = protocol.InvalidByteCount
+	}
+}
+
+func (f *mtuFinder) done() bool {
+	return f.max()-f.min <= maxMTUDiff+1
+}
+
+func (f *mtuFinder) max() protocol.ByteCount {
+	for i, v := range f.lost {
+		if v == protocol.InvalidByteCount {
+			return f.lost[i-1]
+		}
+	}
+	return f.lost[len(f.lost)-1]
+}
+
+func (f *mtuFinder) Start(now monotime.Time) {
+	f.lastProbeTime = now // makes sure the first probe packet is not sent immediately
+}
+
+func (f *mtuFinder) ShouldSendProbe(now monotime.Time) bool {
+	if f.lastProbeTime.IsZero() {
+		return false
+	}
+	if f.inFlight != protocol.InvalidByteCount || f.done() {
+		return false
+	}
+	return !now.Before(f.lastProbeTime.Add(mtuProbeDelay * f.rttStats.SmoothedRTT()))
+}
+
+func (f *mtuFinder) GetPing(now monotime.Time) (ackhandler.Frame, protocol.ByteCount) {
+	var size protocol.ByteCount
+	if f.lastProbeWasLost {
+		size = (f.min + f.lost[0]) / 2
+	} else {
+		size = (f.min + f.max()) / 2
+	}
+	f.lastProbeTime = now
+	f.inFlight = size
+	return ackhandler.Frame{
+		Frame:   &wire.PingFrame{},
+		Handler: &mtuFinderAckHandler{mtuFinder: f, generation: f.generation},
+	}, size
+}
+
+func (f *mtuFinder) CurrentSize() protocol.ByteCount {
+	return f.min
+}
+
+func (f *mtuFinder) Reset(now monotime.Time, start, max protocol.ByteCount) {
+	f.generation++
+	f.lastProbeTime = now
+	f.lastProbeWasLost = false
+	f.inFlight = protocol.InvalidByteCount
+	f.init(start, max)
+}
+
+type mtuFinderAckHandler struct {
+	*mtuFinder
+	generation uint8
+}
+
+var _ ackhandler.FrameHandler = &mtuFinderAckHandler{}
+
+func (h *mtuFinderAckHandler) OnAcked(wire.Frame) {
+	if h.generation != h.mtuFinder.generation {
+		// ACK for probe sent before reset
+		return
+	}
+	size := h.inFlight
+	if size == protocol.InvalidByteCount {
+		panic("OnAcked callback called although there's no MTU probe packet in flight")
+	}
+	h.inFlight = protocol.InvalidByteCount
+	h.min = size
+	h.lastProbeWasLost = false
+	// remove all values smaller than size from the lost array
+	var j int
+	for i, v := range h.lost {
+		if size < v {
+			j = i
+			break
+		}
+	}
+	if j > 0 {
+		for i := range len(h.lost) {
+			if i+j < len(h.lost) {
+				h.lost[i] = h.lost[i+j]
+			} else {
+				h.lost[i] = protocol.InvalidByteCount
+			}
+		}
+	}
+	if h.qlogger != nil {
+		h.qlogger.RecordEvent(qlog.MTUUpdated{
+			Value: int(size),
+			Done:  h.done(),
+		})
+	}
+}
+
+func (h *mtuFinderAckHandler) OnLost(wire.Frame) {
+	if h.generation != h.mtuFinder.generation {
+		// probe sent before reset received
+		return
+	}
+	size := h.inFlight
+	if size == protocol.InvalidByteCount {
+		panic("OnLost callback called although there's no MTU probe packet in flight")
+	}
+	h.lastProbeWasLost = true
+	h.inFlight = protocol.InvalidByteCount
+	for i, v := range h.lost {
+		if size < v {
+			copy(h.lost[i+1:], h.lost[i:])
+			h.lost[i] = size
+			break
+		}
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/oss-fuzz.sh b/backend/vendor/github.com/quic-go/quic-go/oss-fuzz.sh
new file mode 100644
index 00000000..45df1569
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/oss-fuzz.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+set -euo pipefail
+
+echo "Build date (UTC): $(date -u '+%Y-%m-%dT%H:%M:%SZ')"
+
+go version
+go env
+
+# fuzz qpack
+cd $GOPATH/src/github.com/quic-go/qpack
+git log -1 --format='qpack revision: %H (%cI) %s'
+compile_native_go_fuzzer_v2 github.com/quic-go/qpack FuzzDecode qpack_decode_fuzzer
+
+# fuzz quic-go
+cd $GOPATH/src/github.com/quic-go/quic-go/
+git log -1 --format='quic-go revision: %H (%cI) %s'
+
+build_native_go_fuzzer() {
+	local pkg=$1
+	local fuzz=$2
+	local name=$3
+	local corpus_dir="${WORK:-/tmp}/quic-go-seed-corpus/$name"
+	local corpus_zip="$OUT/${name}_seed_corpus.zip"
+
+	# FUZZ_CORPUS_DIR makes go-ossfuzz-seeds write each f.Add seed as a raw
+	# libFuzzer corpus file. OSS-Fuzz picks up <fuzzer>_seed_corpus.zip from
+	# $OUT and unpacks it next to the fuzzer binary.
+	rm -rf "$corpus_dir"
+	mkdir -p "$corpus_dir"
+	FUZZ_CORPUS_DIR="$corpus_dir" go test "$pkg" -run "^${fuzz}$" -count=1 -v
+
+	rm -f "$corpus_zip"
+	corpus_files=$(find "$corpus_dir" -type f | wc -l)
+	echo "$name: generated $corpus_files corpus files"
+	if [[ "$corpus_files" -gt 0 ]]; then
+		(cd "$corpus_dir" && zip -q -r "$corpus_zip" .)
+	fi
+
+	compile_native_go_fuzzer_v2 "$pkg" "$fuzz" "$name"
+}
+
+build_native_go_fuzzer github.com/quic-go/quic-go/internal/wire FuzzFrames frame_fuzzer_v2
+build_native_go_fuzzer github.com/quic-go/quic-go/internal/wire FuzzTransportParameters transportparameter_fuzzer_v2
+build_native_go_fuzzer github.com/quic-go/quic-go/http3 FuzzFrameParser http3_frame_fuzzer
+build_native_go_fuzzer github.com/quic-go/quic-go/internal/wire FuzzHeaderParser header_fuzzer_v2
+build_native_go_fuzzer github.com/quic-go/quic-go/internal/handshake FuzzHandshake handshake_fuzzer_v2
+build_native_go_fuzzer github.com/quic-go/quic-go FuzzFrameSorter frame_sorter_fuzzer
+build_native_go_fuzzer github.com/quic-go/quic-go/http3 FuzzHeaderParsing http3_header_parsing_fuzzer
+
+# for debugging
+ls -al $OUT
diff --git a/backend/vendor/github.com/quic-go/quic-go/packet_packer.go b/backend/vendor/github.com/quic-go/quic-go/packet_packer.go
new file mode 100644
index 00000000..175d3c86
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/packet_packer.go
@@ -0,0 +1,1009 @@
+package quic
+
+import (
+	crand "crypto/rand"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math/rand/v2"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/handshake"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+var errNothingToPack = errors.New("nothing to pack")
+
+type packer interface {
+	PackCoalescedPacket(onlyAck bool, maxPacketSize protocol.ByteCount, now monotime.Time, v protocol.Version) (*coalescedPacket, error)
+	PackAckOnlyPacket(maxPacketSize protocol.ByteCount, now monotime.Time, v protocol.Version) (shortHeaderPacket, *packetBuffer, error)
+	AppendPacket(_ *packetBuffer, maxPacketSize protocol.ByteCount, now monotime.Time, v protocol.Version) (shortHeaderPacket, error)
+	PackPTOProbePacket(_ protocol.EncryptionLevel, _ protocol.ByteCount, addPingIfEmpty bool, now monotime.Time, v protocol.Version) (*coalescedPacket, error)
+	PackConnectionClose(*qerr.TransportError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)
+	PackApplicationClose(*qerr.ApplicationError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)
+	PackPathProbePacket(protocol.ConnectionID, []ackhandler.Frame, protocol.Version) (shortHeaderPacket, *packetBuffer, error)
+	PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, v protocol.Version) (shortHeaderPacket, *packetBuffer, error)
+
+	SetToken([]byte)
+}
+
+type sealer interface {
+	handshake.LongHeaderSealer
+}
+
+type payload struct {
+	streamFrames []ackhandler.StreamFrame
+	frames       []ackhandler.Frame
+	ack          *wire.AckFrame
+	length       protocol.ByteCount
+}
+
+type longHeaderPacket struct {
+	header       *wire.ExtendedHeader
+	ack          *wire.AckFrame
+	frames       []ackhandler.Frame
+	streamFrames []ackhandler.StreamFrame // only used for 0-RTT packets
+
+	length protocol.ByteCount
+}
+
+type shortHeaderPacket struct {
+	PacketNumber         protocol.PacketNumber
+	Frames               []ackhandler.Frame
+	StreamFrames         []ackhandler.StreamFrame
+	Ack                  *wire.AckFrame
+	Length               protocol.ByteCount
+	IsPathMTUProbePacket bool
+	IsPathProbePacket    bool
+
+	// used for logging
+	DestConnID      protocol.ConnectionID
+	PacketNumberLen protocol.PacketNumberLen
+	KeyPhase        protocol.KeyPhaseBit
+}
+
+func (p *shortHeaderPacket) IsAckEliciting() bool { return ackhandler.HasAckElicitingFrames(p.Frames) }
+
+type coalescedPacket struct {
+	buffer         *packetBuffer
+	longHdrPackets []*longHeaderPacket
+	shortHdrPacket *shortHeaderPacket
+}
+
+// IsOnlyShortHeaderPacket says if this packet only contains a short header packet (and no long header packets).
+func (p *coalescedPacket) IsOnlyShortHeaderPacket() bool {
+	return len(p.longHdrPackets) == 0 && p.shortHdrPacket != nil
+}
+
+func (p *longHeaderPacket) EncryptionLevel() protocol.EncryptionLevel {
+	//nolint:exhaustive // Will never be called for Retry packets (and they don't have encrypted data).
+	switch p.header.Type {
+	case protocol.PacketTypeInitial:
+		return protocol.EncryptionInitial
+	case protocol.PacketTypeHandshake:
+		return protocol.EncryptionHandshake
+	case protocol.PacketType0RTT:
+		return protocol.Encryption0RTT
+	default:
+		panic("can't determine encryption level")
+	}
+}
+
+func (p *longHeaderPacket) IsAckEliciting() bool { return ackhandler.HasAckElicitingFrames(p.frames) }
+
+type packetNumberManager interface {
+	PeekPacketNumber(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)
+	PopPacketNumber(protocol.EncryptionLevel) protocol.PacketNumber
+}
+
+type sealingManager interface {
+	GetInitialSealer() (handshake.LongHeaderSealer, error)
+	GetHandshakeSealer() (handshake.LongHeaderSealer, error)
+	Get0RTTSealer() (handshake.LongHeaderSealer, error)
+	Get1RTTSealer() (handshake.ShortHeaderSealer, error)
+}
+
+type frameSource interface {
+	HasData() bool
+	Append([]ackhandler.Frame, []ackhandler.StreamFrame, protocol.ByteCount, monotime.Time, protocol.Version) ([]ackhandler.Frame, []ackhandler.StreamFrame, protocol.ByteCount)
+}
+
+type ackFrameSource interface {
+	GetAckFrame(_ protocol.EncryptionLevel, now monotime.Time, onlyIfQueued bool) *wire.AckFrame
+}
+
+type packetPacker struct {
+	srcConnID     protocol.ConnectionID
+	getDestConnID func() protocol.ConnectionID
+
+	perspective protocol.Perspective
+	cryptoSetup sealingManager
+
+	initialStream   *initialCryptoStream
+	handshakeStream *cryptoStream
+
+	token []byte
+
+	pnManager           packetNumberManager
+	framer              frameSource
+	acks                ackFrameSource
+	datagramQueue       *datagramQueue
+	retransmissionQueue *retransmissionQueue
+	rand                rand.Rand
+
+	numNonAckElicitingAcks int
+}
+
+var _ packer = &packetPacker{}
+
+func newPacketPacker(
+	srcConnID protocol.ConnectionID,
+	getDestConnID func() protocol.ConnectionID,
+	initialStream *initialCryptoStream,
+	handshakeStream *cryptoStream,
+	packetNumberManager packetNumberManager,
+	retransmissionQueue *retransmissionQueue,
+	cryptoSetup sealingManager,
+	framer frameSource,
+	acks ackFrameSource,
+	datagramQueue *datagramQueue,
+	perspective protocol.Perspective,
+) *packetPacker {
+	var b [16]byte
+	_, _ = crand.Read(b[:])
+
+	return &packetPacker{
+		cryptoSetup:         cryptoSetup,
+		getDestConnID:       getDestConnID,
+		srcConnID:           srcConnID,
+		initialStream:       initialStream,
+		handshakeStream:     handshakeStream,
+		retransmissionQueue: retransmissionQueue,
+		datagramQueue:       datagramQueue,
+		perspective:         perspective,
+		framer:              framer,
+		acks:                acks,
+		rand:                *rand.New(rand.NewPCG(binary.BigEndian.Uint64(b[:8]), binary.BigEndian.Uint64(b[8:]))),
+		pnManager:           packetNumberManager,
+	}
+}
+
+// PackConnectionClose packs a packet that closes the connection with a transport error.
+func (p *packetPacker) PackConnectionClose(e *qerr.TransportError, maxPacketSize protocol.ByteCount, v protocol.Version) (*coalescedPacket, error) {
+	var reason string
+	// don't send details of crypto errors
+	if !e.ErrorCode.IsCryptoError() {
+		reason = e.ErrorMessage
+	}
+	return p.packConnectionClose(false, uint64(e.ErrorCode), e.FrameType, reason, maxPacketSize, v)
+}
+
+// PackApplicationClose packs a packet that closes the connection with an application error.
+func (p *packetPacker) PackApplicationClose(e *qerr.ApplicationError, maxPacketSize protocol.ByteCount, v protocol.Version) (*coalescedPacket, error) {
+	return p.packConnectionClose(true, uint64(e.ErrorCode), 0, e.ErrorMessage, maxPacketSize, v)
+}
+
+func (p *packetPacker) packConnectionClose(
+	isApplicationError bool,
+	errorCode uint64,
+	frameType uint64,
+	reason string,
+	maxPacketSize protocol.ByteCount,
+	v protocol.Version,
+) (*coalescedPacket, error) {
+	var sealers [4]sealer
+	var hdrs [3]*wire.ExtendedHeader
+	var payloads [4]payload
+	var size protocol.ByteCount
+	var connID protocol.ConnectionID
+	var oneRTTPacketNumber protocol.PacketNumber
+	var oneRTTPacketNumberLen protocol.PacketNumberLen
+	var keyPhase protocol.KeyPhaseBit // only set for 1-RTT
+	var numLongHdrPackets uint8
+	encLevels := [4]protocol.EncryptionLevel{protocol.EncryptionInitial, protocol.EncryptionHandshake, protocol.Encryption0RTT, protocol.Encryption1RTT}
+	for i, encLevel := range encLevels {
+		if p.perspective == protocol.PerspectiveServer && encLevel == protocol.Encryption0RTT {
+			continue
+		}
+		ccf := &wire.ConnectionCloseFrame{
+			IsApplicationError: isApplicationError,
+			ErrorCode:          errorCode,
+			FrameType:          frameType,
+			ReasonPhrase:       reason,
+		}
+		// don't send application errors in Initial or Handshake packets
+		if isApplicationError && (encLevel == protocol.EncryptionInitial || encLevel == protocol.EncryptionHandshake) {
+			ccf.IsApplicationError = false
+			ccf.ErrorCode = uint64(qerr.ApplicationErrorErrorCode)
+			ccf.ReasonPhrase = ""
+		}
+		pl := payload{
+			frames: []ackhandler.Frame{{Frame: ccf}},
+			length: ccf.Length(v),
+		}
+
+		var sealer sealer
+		var err error
+		switch encLevel {
+		case protocol.EncryptionInitial:
+			sealer, err = p.cryptoSetup.GetInitialSealer()
+		case protocol.EncryptionHandshake:
+			sealer, err = p.cryptoSetup.GetHandshakeSealer()
+		case protocol.Encryption0RTT:
+			sealer, err = p.cryptoSetup.Get0RTTSealer()
+		case protocol.Encryption1RTT:
+			var s handshake.ShortHeaderSealer
+			s, err = p.cryptoSetup.Get1RTTSealer()
+			if err == nil {
+				keyPhase = s.KeyPhase()
+			}
+			sealer = s
+		}
+		if err == handshake.ErrKeysNotYetAvailable || err == handshake.ErrKeysDropped {
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+		sealers[i] = sealer
+		var hdr *wire.ExtendedHeader
+		if encLevel == protocol.Encryption1RTT {
+			connID = p.getDestConnID()
+			oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+			size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, pl)
+		} else {
+			hdr = p.getLongHeader(encLevel, v)
+			hdrs[i] = hdr
+			size += p.longHeaderPacketLength(hdr, pl, v) + protocol.ByteCount(sealer.Overhead())
+			numLongHdrPackets++
+		}
+		payloads[i] = pl
+	}
+	buffer := getPacketBuffer()
+	packet := &coalescedPacket{
+		buffer:         buffer,
+		longHdrPackets: make([]*longHeaderPacket, 0, numLongHdrPackets),
+	}
+	for i, encLevel := range encLevels {
+		if sealers[i] == nil {
+			continue
+		}
+		if encLevel == protocol.Encryption1RTT {
+			shp, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, keyPhase, payloads[i], 0, maxPacketSize, sealers[i], false, v)
+			if err != nil {
+				return nil, err
+			}
+			packet.shortHdrPacket = &shp
+		} else {
+			var paddingLen protocol.ByteCount
+			if encLevel == protocol.EncryptionInitial {
+				paddingLen = p.initialPaddingLen(payloads[i].frames, size, maxPacketSize)
+			}
+			longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdrs[i], payloads[i], paddingLen, encLevel, sealers[i], v)
+			if err != nil {
+				return nil, err
+			}
+			packet.longHdrPackets = append(packet.longHdrPackets, longHdrPacket)
+		}
+	}
+	return packet, nil
+}
+
+// longHeaderPacketLength calculates the length of a serialized long header packet.
+// It takes into account that packets that have a tiny payload need to be padded,
+// such that len(payload) + packet number len >= 4 + AEAD overhead
+func (p *packetPacker) longHeaderPacketLength(hdr *wire.ExtendedHeader, pl payload, v protocol.Version) protocol.ByteCount {
+	var paddingLen protocol.ByteCount
+	pnLen := protocol.ByteCount(hdr.PacketNumberLen)
+	if pl.length < 4-pnLen {
+		paddingLen = 4 - pnLen - pl.length
+	}
+	return hdr.GetLength(v) + pl.length + paddingLen
+}
+
+// shortHeaderPacketLength calculates the length of a serialized short header packet.
+// It takes into account that packets that have a tiny payload need to be padded,
+// such that len(payload) + packet number len >= 4 + AEAD overhead
+func (p *packetPacker) shortHeaderPacketLength(connID protocol.ConnectionID, pnLen protocol.PacketNumberLen, pl payload) protocol.ByteCount {
+	var paddingLen protocol.ByteCount
+	if pl.length < 4-protocol.ByteCount(pnLen) {
+		paddingLen = 4 - protocol.ByteCount(pnLen) - pl.length
+	}
+	return wire.ShortHeaderLen(connID, pnLen) + pl.length + paddingLen
+}
+
+// size is the expected size of the packet, if no padding was applied.
+func (p *packetPacker) initialPaddingLen(frames []ackhandler.Frame, currentSize, maxPacketSize protocol.ByteCount) protocol.ByteCount {
+	// For the server, only ack-eliciting Initial packets need to be padded.
+	if p.perspective == protocol.PerspectiveServer && !ackhandler.HasAckElicitingFrames(frames) {
+		return 0
+	}
+	if currentSize >= maxPacketSize {
+		return 0
+	}
+	return maxPacketSize - currentSize
+}
+
+// PackCoalescedPacket packs a new packet.
+// It packs an Initial / Handshake if there is data to send in these packet number spaces.
+// It should only be called before the handshake is confirmed.
+func (p *packetPacker) PackCoalescedPacket(onlyAck bool, maxSize protocol.ByteCount, now monotime.Time, v protocol.Version) (*coalescedPacket, error) {
+	var (
+		initialHdr, handshakeHdr, zeroRTTHdr                            *wire.ExtendedHeader
+		initialPayload, handshakePayload, zeroRTTPayload, oneRTTPayload payload
+		oneRTTPacketNumber                                              protocol.PacketNumber
+		oneRTTPacketNumberLen                                           protocol.PacketNumberLen
+	)
+	// Try packing an Initial packet.
+	initialSealer, err := p.cryptoSetup.GetInitialSealer()
+	if err != nil && err != handshake.ErrKeysDropped {
+		return nil, err
+	}
+	var size protocol.ByteCount
+	if initialSealer != nil {
+		initialHdr, initialPayload = p.maybeGetCryptoPacket(
+			maxSize-protocol.ByteCount(initialSealer.Overhead()),
+			protocol.EncryptionInitial,
+			now,
+			false,
+			onlyAck,
+			v,
+		)
+		if initialPayload.length > 0 {
+			size += p.longHeaderPacketLength(initialHdr, initialPayload, v) + protocol.ByteCount(initialSealer.Overhead())
+		}
+	}
+
+	// Add a Handshake packet.
+	var handshakeSealer sealer
+	if (onlyAck && size == 0) || (!onlyAck && size < maxSize-protocol.MinCoalescedPacketSize) {
+		var err error
+		handshakeSealer, err = p.cryptoSetup.GetHandshakeSealer()
+		if err != nil && err != handshake.ErrKeysDropped && err != handshake.ErrKeysNotYetAvailable {
+			return nil, err
+		}
+		if handshakeSealer != nil {
+			handshakeHdr, handshakePayload = p.maybeGetCryptoPacket(
+				maxSize-size-protocol.ByteCount(handshakeSealer.Overhead()),
+				protocol.EncryptionHandshake,
+				now,
+				false,
+				onlyAck,
+				v,
+			)
+			if handshakePayload.length > 0 {
+				s := p.longHeaderPacketLength(handshakeHdr, handshakePayload, v) + protocol.ByteCount(handshakeSealer.Overhead())
+				size += s
+			}
+		}
+	}
+
+	// Add a 0-RTT / 1-RTT packet.
+	var zeroRTTSealer sealer
+	var oneRTTSealer handshake.ShortHeaderSealer
+	var connID protocol.ConnectionID
+	var kp protocol.KeyPhaseBit
+	if (onlyAck && size == 0) || (!onlyAck && size < maxSize-protocol.MinCoalescedPacketSize) {
+		var err error
+		oneRTTSealer, err = p.cryptoSetup.Get1RTTSealer()
+		if err != nil && err != handshake.ErrKeysDropped && err != handshake.ErrKeysNotYetAvailable {
+			return nil, err
+		}
+		if err == nil { // 1-RTT
+			kp = oneRTTSealer.KeyPhase()
+			connID = p.getDestConnID()
+			oneRTTPacketNumber, oneRTTPacketNumberLen = p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+			hdrLen := wire.ShortHeaderLen(connID, oneRTTPacketNumberLen)
+			oneRTTPayload = p.maybeGetShortHeaderPacket(oneRTTSealer, hdrLen, maxSize-size, onlyAck, now, v)
+			if oneRTTPayload.length > 0 {
+				size += p.shortHeaderPacketLength(connID, oneRTTPacketNumberLen, oneRTTPayload) + protocol.ByteCount(oneRTTSealer.Overhead())
+			}
+		} else if p.perspective == protocol.PerspectiveClient && !onlyAck { // 0-RTT packets can't contain ACK frames
+			var err error
+			zeroRTTSealer, err = p.cryptoSetup.Get0RTTSealer()
+			if err != nil && err != handshake.ErrKeysDropped && err != handshake.ErrKeysNotYetAvailable {
+				return nil, err
+			}
+			if zeroRTTSealer != nil {
+				zeroRTTHdr, zeroRTTPayload = p.maybeGetAppDataPacketFor0RTT(zeroRTTSealer, maxSize-size, now, v)
+				if zeroRTTPayload.length > 0 {
+					size += p.longHeaderPacketLength(zeroRTTHdr, zeroRTTPayload, v) + protocol.ByteCount(zeroRTTSealer.Overhead())
+				}
+			}
+		}
+	}
+
+	if initialPayload.length == 0 && handshakePayload.length == 0 && zeroRTTPayload.length == 0 && oneRTTPayload.length == 0 {
+		return nil, nil
+	}
+
+	buffer := getPacketBuffer()
+	packet := &coalescedPacket{
+		buffer:         buffer,
+		longHdrPackets: make([]*longHeaderPacket, 0, 3),
+	}
+	if initialPayload.length > 0 {
+		padding := p.initialPaddingLen(initialPayload.frames, size, maxSize)
+		cont, err := p.appendLongHeaderPacket(buffer, initialHdr, initialPayload, padding, protocol.EncryptionInitial, initialSealer, v)
+		if err != nil {
+			return nil, err
+		}
+		packet.longHdrPackets = append(packet.longHdrPackets, cont)
+	}
+	if handshakePayload.length > 0 {
+		cont, err := p.appendLongHeaderPacket(buffer, handshakeHdr, handshakePayload, 0, protocol.EncryptionHandshake, handshakeSealer, v)
+		if err != nil {
+			return nil, err
+		}
+		packet.longHdrPackets = append(packet.longHdrPackets, cont)
+	}
+	if zeroRTTPayload.length > 0 {
+		longHdrPacket, err := p.appendLongHeaderPacket(buffer, zeroRTTHdr, zeroRTTPayload, 0, protocol.Encryption0RTT, zeroRTTSealer, v)
+		if err != nil {
+			return nil, err
+		}
+		packet.longHdrPackets = append(packet.longHdrPackets, longHdrPacket)
+	} else if oneRTTPayload.length > 0 {
+		shp, err := p.appendShortHeaderPacket(buffer, connID, oneRTTPacketNumber, oneRTTPacketNumberLen, kp, oneRTTPayload, 0, maxSize, oneRTTSealer, false, v)
+		if err != nil {
+			return nil, err
+		}
+		packet.shortHdrPacket = &shp
+	}
+	return packet, nil
+}
+
+// PackAckOnlyPacket packs a packet containing only an ACK in the application data packet number space.
+// It should be called after the handshake is confirmed.
+func (p *packetPacker) PackAckOnlyPacket(maxSize protocol.ByteCount, now monotime.Time, v protocol.Version) (shortHeaderPacket, *packetBuffer, error) {
+	buf := getPacketBuffer()
+	packet, err := p.appendPacket(buf, true, maxSize, now, v)
+	return packet, buf, err
+}
+
+// AppendPacket packs a packet in the application data packet number space.
+// It should be called after the handshake is confirmed.
+func (p *packetPacker) AppendPacket(buf *packetBuffer, maxSize protocol.ByteCount, now monotime.Time, v protocol.Version) (shortHeaderPacket, error) {
+	return p.appendPacket(buf, false, maxSize, now, v)
+}
+
+func (p *packetPacker) appendPacket(
+	buf *packetBuffer,
+	onlyAck bool,
+	maxPacketSize protocol.ByteCount,
+	now monotime.Time,
+	v protocol.Version,
+) (shortHeaderPacket, error) {
+	sealer, err := p.cryptoSetup.Get1RTTSealer()
+	if err != nil {
+		return shortHeaderPacket{}, err
+	}
+	pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+	connID := p.getDestConnID()
+	hdrLen := wire.ShortHeaderLen(connID, pnLen)
+	pl := p.maybeGetShortHeaderPacket(sealer, hdrLen, maxPacketSize, onlyAck, now, v)
+	if pl.length == 0 {
+		return shortHeaderPacket{}, errNothingToPack
+	}
+	kp := sealer.KeyPhase()
+
+	return p.appendShortHeaderPacket(buf, connID, pn, pnLen, kp, pl, 0, maxPacketSize, sealer, false, v)
+}
+
+func (p *packetPacker) maybeGetCryptoPacket(
+	maxPacketSize protocol.ByteCount,
+	encLevel protocol.EncryptionLevel,
+	now monotime.Time,
+	addPingIfEmpty bool,
+	onlyAck bool,
+	v protocol.Version,
+) (*wire.ExtendedHeader, payload) {
+	if onlyAck {
+		if ack := p.acks.GetAckFrame(encLevel, now, true); ack != nil {
+			hdr := p.getLongHeader(encLevel, v)
+			maxPacketSize -= hdr.GetLength(v)
+			ack.Truncate(maxPacketSize, v)
+			return hdr, payload{ack: ack, length: ack.Length(v)}
+		}
+		return nil, payload{length: 0}
+	}
+
+	var hasCryptoData func() bool
+	var popCryptoFrame func(maxLen protocol.ByteCount) *wire.CryptoFrame
+	//nolint:exhaustive // Initial and Handshake are the only two encryption levels here.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		hasCryptoData = p.initialStream.HasData
+		popCryptoFrame = p.initialStream.PopCryptoFrame
+	case protocol.EncryptionHandshake:
+		hasCryptoData = p.handshakeStream.HasData
+		popCryptoFrame = p.handshakeStream.PopCryptoFrame
+	}
+	handler := p.retransmissionQueue.AckHandler(encLevel)
+	hasRetransmission := p.retransmissionQueue.HasData(encLevel)
+
+	ack := p.acks.GetAckFrame(encLevel, now, !hasRetransmission && !hasCryptoData())
+	var pl payload
+	if !hasCryptoData() && !hasRetransmission && ack == nil {
+		if !addPingIfEmpty {
+			// nothing to send
+			return nil, payload{}
+		}
+		ping := &wire.PingFrame{}
+		pl.frames = append(pl.frames, ackhandler.Frame{Frame: ping, Handler: emptyHandler{}})
+		pl.length += ping.Length(v)
+	}
+
+	hdr := p.getLongHeader(encLevel, v)
+	maxPacketSize -= hdr.GetLength(v)
+
+	if ack != nil {
+		ack.Truncate(maxPacketSize, v)
+		pl.ack = ack
+		pl.length = ack.Length(v)
+		maxPacketSize -= pl.length
+	}
+	if hasRetransmission {
+		for {
+			frame := p.retransmissionQueue.GetFrame(encLevel, maxPacketSize, v)
+			if frame == nil {
+				break
+			}
+			pl.frames = append(pl.frames, ackhandler.Frame{
+				Frame:   frame,
+				Handler: p.retransmissionQueue.AckHandler(encLevel),
+			})
+			frameLen := frame.Length(v)
+			pl.length += frameLen
+			maxPacketSize -= frameLen
+		}
+		return hdr, pl
+	} else {
+		for hasCryptoData() {
+			cf := popCryptoFrame(maxPacketSize)
+			if cf == nil {
+				break
+			}
+			pl.frames = append(pl.frames, ackhandler.Frame{Frame: cf, Handler: handler})
+			pl.length += cf.Length(v)
+			maxPacketSize -= cf.Length(v)
+		}
+	}
+	return hdr, pl
+}
+
+func (p *packetPacker) maybeGetAppDataPacketFor0RTT(sealer sealer, maxSize protocol.ByteCount, now monotime.Time, v protocol.Version) (*wire.ExtendedHeader, payload) {
+	if p.perspective != protocol.PerspectiveClient {
+		return nil, payload{}
+	}
+
+	hdr := p.getLongHeader(protocol.Encryption0RTT, v)
+	maxPayloadSize := maxSize - hdr.GetLength(v) - protocol.ByteCount(sealer.Overhead())
+	return hdr, p.maybeGetAppDataPacket(maxPayloadSize, false, false, now, v)
+}
+
+func (p *packetPacker) maybeGetShortHeaderPacket(
+	sealer handshake.ShortHeaderSealer,
+	hdrLen, maxPacketSize protocol.ByteCount,
+	onlyAck bool,
+	now monotime.Time,
+	v protocol.Version,
+) payload {
+	maxPayloadSize := maxPacketSize - hdrLen - protocol.ByteCount(sealer.Overhead())
+	return p.maybeGetAppDataPacket(maxPayloadSize, onlyAck, true, now, v)
+}
+
+func (p *packetPacker) maybeGetAppDataPacket(
+	maxPayloadSize protocol.ByteCount,
+	onlyAck, ackAllowed bool,
+	now monotime.Time,
+	v protocol.Version,
+) payload {
+	pl := p.composeNextPacket(maxPayloadSize, onlyAck, ackAllowed, now, v)
+
+	// check if we have anything to send
+	if len(pl.frames) == 0 && len(pl.streamFrames) == 0 {
+		if pl.ack == nil {
+			return payload{}
+		}
+		// the packet only contains an ACK
+		if p.numNonAckElicitingAcks >= protocol.MaxNonAckElicitingAcks {
+			ping := &wire.PingFrame{}
+			pl.frames = append(pl.frames, ackhandler.Frame{Frame: ping})
+			pl.length += ping.Length(v)
+			p.numNonAckElicitingAcks = 0
+		} else {
+			p.numNonAckElicitingAcks++
+		}
+	} else {
+		p.numNonAckElicitingAcks = 0
+	}
+	return pl
+}
+
+func (p *packetPacker) composeNextPacket(
+	maxPayloadSize protocol.ByteCount,
+	onlyAck, ackAllowed bool,
+	now monotime.Time,
+	v protocol.Version,
+) payload {
+	if onlyAck {
+		if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, now, true); ack != nil {
+			ack.Truncate(maxPayloadSize, v)
+			return payload{ack: ack, length: ack.Length(v)}
+		}
+		return payload{}
+	}
+
+	hasData := p.framer.HasData()
+	hasRetransmission := p.retransmissionQueue.HasData(protocol.Encryption1RTT)
+
+	var pl payload
+	if ackAllowed {
+		if ack := p.acks.GetAckFrame(protocol.Encryption1RTT, now, !hasRetransmission && !hasData); ack != nil {
+			ack.Truncate(maxPayloadSize, v)
+			pl.ack = ack
+			pl.length += ack.Length(v)
+		}
+	}
+
+	if p.datagramQueue != nil {
+		if f := p.datagramQueue.Peek(); f != nil {
+			size := f.Length(v)
+			if size <= maxPayloadSize-pl.length { // DATAGRAM frame fits
+				pl.frames = append(pl.frames, ackhandler.Frame{Frame: f})
+				pl.length += size
+				p.datagramQueue.Pop()
+			} else if pl.ack == nil {
+				// The DATAGRAM frame doesn't fit, and the packet doesn't contain an ACK.
+				// Discard this frame. There's no point in retrying this in the next packet,
+				// as it's unlikely that the available packet size will increase.
+				p.datagramQueue.Pop()
+			}
+			// If the DATAGRAM frame was too large and the packet contained an ACK, we'll try to send it out later.
+		}
+	}
+
+	if pl.ack != nil && !hasData && !hasRetransmission {
+		return pl
+	}
+
+	if hasRetransmission {
+		for {
+			remainingLen := maxPayloadSize - pl.length
+			if remainingLen < protocol.MinStreamFrameSize {
+				break
+			}
+			f := p.retransmissionQueue.GetFrame(protocol.Encryption1RTT, remainingLen, v)
+			if f == nil {
+				break
+			}
+			pl.frames = append(pl.frames, ackhandler.Frame{Frame: f, Handler: p.retransmissionQueue.AckHandler(protocol.Encryption1RTT)})
+			pl.length += f.Length(v)
+		}
+	}
+
+	if hasData {
+		var lengthAdded protocol.ByteCount
+		startLen := len(pl.frames)
+		pl.frames, pl.streamFrames, lengthAdded = p.framer.Append(pl.frames, pl.streamFrames, maxPayloadSize-pl.length, now, v)
+		pl.length += lengthAdded
+		// add handlers for the control frames that were added
+		for i := startLen; i < len(pl.frames); i++ {
+			if pl.frames[i].Handler != nil {
+				continue
+			}
+			switch pl.frames[i].Frame.(type) {
+			case *wire.PathChallengeFrame, *wire.PathResponseFrame:
+				// Path probing is currently not supported, therefore we don't need to set the OnAcked callback yet.
+				// PATH_CHALLENGE and PATH_RESPONSE are never retransmitted.
+			default:
+				// we might be packing a 0-RTT packet, but we need to use the 1-RTT ack handler anyway
+				pl.frames[i].Handler = p.retransmissionQueue.AckHandler(protocol.Encryption1RTT)
+			}
+		}
+	}
+	return pl
+}
+
+func (p *packetPacker) PackPTOProbePacket(
+	encLevel protocol.EncryptionLevel,
+	maxPacketSize protocol.ByteCount,
+	addPingIfEmpty bool,
+	now monotime.Time,
+	v protocol.Version,
+) (*coalescedPacket, error) {
+	if encLevel == protocol.Encryption1RTT {
+		return p.packPTOProbePacket1RTT(maxPacketSize, addPingIfEmpty, now, v)
+	}
+
+	var sealer handshake.LongHeaderSealer
+	//nolint:exhaustive // Probe packets are never sent for 0-RTT.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		var err error
+		sealer, err = p.cryptoSetup.GetInitialSealer()
+		if err != nil {
+			return nil, err
+		}
+	case protocol.EncryptionHandshake:
+		var err error
+		sealer, err = p.cryptoSetup.GetHandshakeSealer()
+		if err != nil {
+			return nil, err
+		}
+	default:
+		panic("unknown encryption level")
+	}
+	hdr, pl := p.maybeGetCryptoPacket(
+		maxPacketSize-protocol.ByteCount(sealer.Overhead()),
+		encLevel,
+		now,
+		addPingIfEmpty,
+		false,
+		v,
+	)
+	if pl.length == 0 {
+		return nil, nil
+	}
+	buffer := getPacketBuffer()
+	packet := &coalescedPacket{buffer: buffer}
+	size := p.longHeaderPacketLength(hdr, pl, v) + protocol.ByteCount(sealer.Overhead())
+	var padding protocol.ByteCount
+	if encLevel == protocol.EncryptionInitial {
+		padding = p.initialPaddingLen(pl.frames, size, maxPacketSize)
+	}
+
+	longHdrPacket, err := p.appendLongHeaderPacket(buffer, hdr, pl, padding, encLevel, sealer, v)
+	if err != nil {
+		return nil, err
+	}
+	packet.longHdrPackets = []*longHeaderPacket{longHdrPacket}
+	return packet, nil
+}
+
+func (p *packetPacker) packPTOProbePacket1RTT(maxPacketSize protocol.ByteCount, addPingIfEmpty bool, now monotime.Time, v protocol.Version) (*coalescedPacket, error) {
+	s, err := p.cryptoSetup.Get1RTTSealer()
+	if err != nil {
+		return nil, err
+	}
+	kp := s.KeyPhase()
+	connID := p.getDestConnID()
+	pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+	hdrLen := wire.ShortHeaderLen(connID, pnLen)
+	pl := p.maybeGetAppDataPacket(maxPacketSize-protocol.ByteCount(s.Overhead())-hdrLen, false, true, now, v)
+	if pl.length == 0 {
+		if !addPingIfEmpty {
+			return nil, nil
+		}
+		ping := &wire.PingFrame{}
+		pl.frames = append(pl.frames, ackhandler.Frame{Frame: ping, Handler: emptyHandler{}})
+		pl.length += ping.Length(v)
+	}
+	buffer := getPacketBuffer()
+	packet := &coalescedPacket{buffer: buffer}
+	shp, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, 0, maxPacketSize, s, false, v)
+	if err != nil {
+		return nil, err
+	}
+	packet.shortHdrPacket = &shp
+	return packet, nil
+}
+
+func (p *packetPacker) PackMTUProbePacket(ping ackhandler.Frame, size protocol.ByteCount, v protocol.Version) (shortHeaderPacket, *packetBuffer, error) {
+	pl := payload{
+		frames: []ackhandler.Frame{ping},
+		length: ping.Frame.Length(v),
+	}
+	buffer := getPacketBuffer()
+	s, err := p.cryptoSetup.Get1RTTSealer()
+	if err != nil {
+		return shortHeaderPacket{}, nil, err
+	}
+	connID := p.getDestConnID()
+	pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+	padding := size - p.shortHeaderPacketLength(connID, pnLen, pl) - protocol.ByteCount(s.Overhead())
+	kp := s.KeyPhase()
+	packet, err := p.appendShortHeaderPacket(buffer, connID, pn, pnLen, kp, pl, padding, size, s, true, v)
+	return packet, buffer, err
+}
+
+func (p *packetPacker) PackPathProbePacket(connID protocol.ConnectionID, frames []ackhandler.Frame, v protocol.Version) (shortHeaderPacket, *packetBuffer, error) {
+	pn, pnLen := p.pnManager.PeekPacketNumber(protocol.Encryption1RTT)
+	buf := getPacketBuffer()
+	s, err := p.cryptoSetup.Get1RTTSealer()
+	if err != nil {
+		return shortHeaderPacket{}, nil, err
+	}
+	var l protocol.ByteCount
+	for _, f := range frames {
+		l += f.Frame.Length(v)
+	}
+	payload := payload{
+		frames: frames,
+		length: l,
+	}
+	padding := protocol.MinInitialPacketSize - p.shortHeaderPacketLength(connID, pnLen, payload) - protocol.ByteCount(s.Overhead())
+	packet, err := p.appendShortHeaderPacket(buf, connID, pn, pnLen, s.KeyPhase(), payload, padding, protocol.MinInitialPacketSize, s, false, v)
+	if err != nil {
+		return shortHeaderPacket{}, nil, err
+	}
+	packet.IsPathProbePacket = true
+	return packet, buf, err
+}
+
+func (p *packetPacker) getLongHeader(encLevel protocol.EncryptionLevel, v protocol.Version) *wire.ExtendedHeader {
+	pn, pnLen := p.pnManager.PeekPacketNumber(encLevel)
+	hdr := &wire.ExtendedHeader{
+		PacketNumber:    pn,
+		PacketNumberLen: pnLen,
+	}
+	hdr.Version = v
+	hdr.SrcConnectionID = p.srcConnID
+	hdr.DestConnectionID = p.getDestConnID()
+
+	//nolint:exhaustive // 1-RTT packets are not long header packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		hdr.Type = protocol.PacketTypeInitial
+		hdr.Token = p.token
+	case protocol.EncryptionHandshake:
+		hdr.Type = protocol.PacketTypeHandshake
+	case protocol.Encryption0RTT:
+		hdr.Type = protocol.PacketType0RTT
+	}
+	return hdr
+}
+
+func (p *packetPacker) appendLongHeaderPacket(buffer *packetBuffer, header *wire.ExtendedHeader, pl payload, padding protocol.ByteCount, encLevel protocol.EncryptionLevel, sealer sealer, v protocol.Version) (*longHeaderPacket, error) {
+	var paddingLen protocol.ByteCount
+	pnLen := protocol.ByteCount(header.PacketNumberLen)
+	if pl.length < 4-pnLen {
+		paddingLen = 4 - pnLen - pl.length
+	}
+	paddingLen += padding
+	header.Length = pnLen + protocol.ByteCount(sealer.Overhead()) + pl.length + paddingLen
+
+	startLen := len(buffer.Data)
+	raw := buffer.Data[startLen:]
+	raw, err := header.Append(raw, v)
+	if err != nil {
+		return nil, err
+	}
+	payloadOffset := protocol.ByteCount(len(raw))
+
+	raw, err = p.appendPacketPayload(raw, pl, paddingLen, v)
+	if err != nil {
+		return nil, err
+	}
+	raw = p.encryptPacket(raw, sealer, header.PacketNumber, payloadOffset, pnLen)
+	buffer.Data = buffer.Data[:len(buffer.Data)+len(raw)]
+
+	if pn := p.pnManager.PopPacketNumber(encLevel); pn != header.PacketNumber {
+		return nil, fmt.Errorf("packetPacker BUG: Peeked and Popped packet numbers do not match: expected %d, got %d", pn, header.PacketNumber)
+	}
+	return &longHeaderPacket{
+		header:       header,
+		ack:          pl.ack,
+		frames:       pl.frames,
+		streamFrames: pl.streamFrames,
+		length:       protocol.ByteCount(len(raw)),
+	}, nil
+}
+
+func (p *packetPacker) appendShortHeaderPacket(
+	buffer *packetBuffer,
+	connID protocol.ConnectionID,
+	pn protocol.PacketNumber,
+	pnLen protocol.PacketNumberLen,
+	kp protocol.KeyPhaseBit,
+	pl payload,
+	padding, maxPacketSize protocol.ByteCount,
+	sealer sealer,
+	isMTUProbePacket bool,
+	v protocol.Version,
+) (shortHeaderPacket, error) {
+	var paddingLen protocol.ByteCount
+	if pl.length < 4-protocol.ByteCount(pnLen) {
+		paddingLen = 4 - protocol.ByteCount(pnLen) - pl.length
+	}
+	paddingLen += padding
+
+	startLen := len(buffer.Data)
+	raw := buffer.Data[startLen:]
+	raw, err := wire.AppendShortHeader(raw, connID, pn, pnLen, kp)
+	if err != nil {
+		return shortHeaderPacket{}, err
+	}
+	payloadOffset := protocol.ByteCount(len(raw))
+
+	raw, err = p.appendPacketPayload(raw, pl, paddingLen, v)
+	if err != nil {
+		return shortHeaderPacket{}, err
+	}
+	if !isMTUProbePacket {
+		if size := protocol.ByteCount(len(raw) + sealer.Overhead()); size > maxPacketSize {
+			return shortHeaderPacket{}, fmt.Errorf("PacketPacker BUG: packet too large (%d bytes, allowed %d bytes)", size, maxPacketSize)
+		}
+	}
+	raw = p.encryptPacket(raw, sealer, pn, payloadOffset, protocol.ByteCount(pnLen))
+	buffer.Data = buffer.Data[:len(buffer.Data)+len(raw)]
+
+	if newPN := p.pnManager.PopPacketNumber(protocol.Encryption1RTT); newPN != pn {
+		return shortHeaderPacket{}, fmt.Errorf("packetPacker BUG: Peeked and Popped packet numbers do not match: expected %d, got %d", pn, newPN)
+	}
+	return shortHeaderPacket{
+		PacketNumber:         pn,
+		PacketNumberLen:      pnLen,
+		KeyPhase:             kp,
+		StreamFrames:         pl.streamFrames,
+		Frames:               pl.frames,
+		Ack:                  pl.ack,
+		Length:               protocol.ByteCount(len(raw)),
+		DestConnID:           connID,
+		IsPathMTUProbePacket: isMTUProbePacket,
+	}, nil
+}
+
+// appendPacketPayload serializes the payload of a packet into the raw byte slice.
+// It modifies the order of payload.frames.
+func (p *packetPacker) appendPacketPayload(raw []byte, pl payload, paddingLen protocol.ByteCount, v protocol.Version) ([]byte, error) {
+	payloadOffset := len(raw)
+	if pl.ack != nil {
+		var err error
+		raw, err = pl.ack.Append(raw, v)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if paddingLen > 0 {
+		raw = append(raw, make([]byte, paddingLen)...)
+	}
+	// Randomize the order of the control frames.
+	// This makes sure that the receiver doesn't rely on the order in which frames are packed.
+	if len(pl.frames) > 1 {
+		p.rand.Shuffle(len(pl.frames), func(i, j int) { pl.frames[i], pl.frames[j] = pl.frames[j], pl.frames[i] })
+	}
+	for _, f := range pl.frames {
+		var err error
+		raw, err = f.Frame.Append(raw, v)
+		if err != nil {
+			return nil, err
+		}
+	}
+	for _, f := range pl.streamFrames {
+		var err error
+		raw, err = f.Frame.Append(raw, v)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if payloadSize := protocol.ByteCount(len(raw)-payloadOffset) - paddingLen; payloadSize != pl.length {
+		return nil, fmt.Errorf("PacketPacker BUG: payload size inconsistent (expected %d, got %d bytes)", pl.length, payloadSize)
+	}
+	return raw, nil
+}
+
+func (p *packetPacker) encryptPacket(raw []byte, sealer sealer, pn protocol.PacketNumber, payloadOffset, pnLen protocol.ByteCount) []byte {
+	_ = sealer.Seal(raw[payloadOffset:payloadOffset], raw[payloadOffset:], pn, raw[:payloadOffset])
+	raw = raw[:len(raw)+sealer.Overhead()]
+	// apply header protection
+	pnOffset := payloadOffset - pnLen
+	sealer.EncryptHeader(raw[pnOffset+4:pnOffset+4+16], &raw[0], raw[pnOffset:payloadOffset])
+	return raw
+}
+
+func (p *packetPacker) SetToken(token []byte) {
+	p.token = token
+}
+
+type emptyHandler struct{}
+
+var _ ackhandler.FrameHandler = emptyHandler{}
+
+func (emptyHandler) OnAcked(wire.Frame) {}
+func (emptyHandler) OnLost(wire.Frame)  {}
diff --git a/backend/vendor/github.com/quic-go/quic-go/packet_unpacker.go b/backend/vendor/github.com/quic-go/quic-go/packet_unpacker.go
new file mode 100644
index 00000000..0729636e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/packet_unpacker.go
@@ -0,0 +1,222 @@
+package quic
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/handshake"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type headerDecryptor interface {
+	DecryptHeader(sample []byte, firstByte *byte, pnBytes []byte)
+}
+
+type headerParseError struct {
+	err error
+}
+
+func (e *headerParseError) Unwrap() error {
+	return e.err
+}
+
+func (e *headerParseError) Error() string {
+	return e.err.Error()
+}
+
+type unpackedPacket struct {
+	hdr             *wire.ExtendedHeader
+	encryptionLevel protocol.EncryptionLevel
+	data            []byte
+}
+
+// The packetUnpacker unpacks QUIC packets.
+type packetUnpacker struct {
+	cs handshake.CryptoSetup
+
+	shortHdrConnIDLen int
+}
+
+var _ unpacker = &packetUnpacker{}
+
+func newPacketUnpacker(cs handshake.CryptoSetup, shortHdrConnIDLen int) *packetUnpacker {
+	return &packetUnpacker{
+		cs:                cs,
+		shortHdrConnIDLen: shortHdrConnIDLen,
+	}
+}
+
+// UnpackLongHeader unpacks a Long Header packet.
+// If the reserved bits are invalid, the error is wire.ErrInvalidReservedBits.
+// If any other error occurred when parsing the header, the error is of type headerParseError.
+// If decrypting the payload fails for any reason, the error is the error returned by the AEAD.
+func (u *packetUnpacker) UnpackLongHeader(hdr *wire.Header, data []byte) (*unpackedPacket, error) {
+	var encLevel protocol.EncryptionLevel
+	var extHdr *wire.ExtendedHeader
+	var decrypted []byte
+	//nolint:exhaustive // Retry packets can't be unpacked.
+	switch hdr.Type {
+	case protocol.PacketTypeInitial:
+		encLevel = protocol.EncryptionInitial
+		opener, err := u.cs.GetInitialOpener()
+		if err != nil {
+			return nil, err
+		}
+		extHdr, decrypted, err = u.unpackLongHeaderPacket(opener, hdr, data)
+		if err != nil {
+			return nil, err
+		}
+	case protocol.PacketTypeHandshake:
+		encLevel = protocol.EncryptionHandshake
+		opener, err := u.cs.GetHandshakeOpener()
+		if err != nil {
+			return nil, err
+		}
+		extHdr, decrypted, err = u.unpackLongHeaderPacket(opener, hdr, data)
+		if err != nil {
+			return nil, err
+		}
+	case protocol.PacketType0RTT:
+		encLevel = protocol.Encryption0RTT
+		opener, err := u.cs.Get0RTTOpener()
+		if err != nil {
+			return nil, err
+		}
+		extHdr, decrypted, err = u.unpackLongHeaderPacket(opener, hdr, data)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("unknown packet type: %s", hdr.Type)
+	}
+
+	if len(decrypted) == 0 {
+		return nil, &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "empty packet",
+		}
+	}
+
+	return &unpackedPacket{
+		hdr:             extHdr,
+		encryptionLevel: encLevel,
+		data:            decrypted,
+	}, nil
+}
+
+func (u *packetUnpacker) UnpackShortHeader(rcvTime monotime.Time, data []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error) {
+	opener, err := u.cs.Get1RTTOpener()
+	if err != nil {
+		return 0, 0, 0, nil, err
+	}
+	pn, pnLen, kp, decrypted, err := u.unpackShortHeaderPacket(opener, rcvTime, data)
+	if err != nil {
+		return 0, 0, 0, nil, err
+	}
+	if len(decrypted) == 0 {
+		return 0, 0, 0, nil, &qerr.TransportError{
+			ErrorCode:    qerr.ProtocolViolation,
+			ErrorMessage: "empty packet",
+		}
+	}
+	return pn, pnLen, kp, decrypted, nil
+}
+
+func (u *packetUnpacker) unpackLongHeaderPacket(opener handshake.LongHeaderOpener, hdr *wire.Header, data []byte) (*wire.ExtendedHeader, []byte, error) {
+	extHdr, parseErr := u.unpackLongHeader(opener, hdr, data)
+	// If the reserved bits are set incorrectly, we still need to continue unpacking.
+	// This avoids a timing side-channel, which otherwise might allow an attacker
+	// to gain information about the header encryption.
+	if parseErr != nil && parseErr != wire.ErrInvalidReservedBits {
+		return nil, nil, parseErr
+	}
+	extHdrLen := extHdr.ParsedLen()
+	extHdr.PacketNumber = opener.DecodePacketNumber(extHdr.PacketNumber, extHdr.PacketNumberLen)
+	decrypted, err := opener.Open(data[extHdrLen:extHdrLen], data[extHdrLen:], extHdr.PacketNumber, data[:extHdrLen])
+	if err != nil {
+		return nil, nil, err
+	}
+	if parseErr != nil {
+		return nil, nil, parseErr
+	}
+	return extHdr, decrypted, nil
+}
+
+func (u *packetUnpacker) unpackShortHeaderPacket(opener handshake.ShortHeaderOpener, rcvTime monotime.Time, data []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error) {
+	l, pn, pnLen, kp, parseErr := u.unpackShortHeader(opener, data)
+	// If the reserved bits are set incorrectly, we still need to continue unpacking.
+	// This avoids a timing side-channel, which otherwise might allow an attacker
+	// to gain information about the header encryption.
+	if parseErr != nil && parseErr != wire.ErrInvalidReservedBits {
+		return 0, 0, 0, nil, &headerParseError{parseErr}
+	}
+	pn = opener.DecodePacketNumber(pn, pnLen)
+	decrypted, err := opener.Open(data[l:l], data[l:], rcvTime, pn, kp, data[:l])
+	if err != nil {
+		return 0, 0, 0, nil, err
+	}
+	return pn, pnLen, kp, decrypted, parseErr
+}
+
+func (u *packetUnpacker) unpackShortHeader(hd headerDecryptor, data []byte) (int, protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, error) {
+	hdrLen := 1 /* first header byte */ + u.shortHdrConnIDLen
+	if len(data) < hdrLen+4+16 {
+		return 0, 0, 0, 0, fmt.Errorf("packet too small, expected at least 20 bytes after the header, got %d", len(data)-hdrLen)
+	}
+	origPNBytes := make([]byte, 4)
+	copy(origPNBytes, data[hdrLen:hdrLen+4])
+	// 2. decrypt the header, assuming a 4 byte packet number
+	hd.DecryptHeader(
+		data[hdrLen+4:hdrLen+4+16],
+		&data[0],
+		data[hdrLen:hdrLen+4],
+	)
+	// 3. parse the header (and learn the actual length of the packet number)
+	l, pn, pnLen, kp, parseErr := wire.ParseShortHeader(data, u.shortHdrConnIDLen)
+	if parseErr != nil && parseErr != wire.ErrInvalidReservedBits {
+		return l, pn, pnLen, kp, parseErr
+	}
+	// 4. if the packet number is shorter than 4 bytes, replace the remaining bytes with the copy we saved earlier
+	if pnLen != protocol.PacketNumberLen4 {
+		copy(data[hdrLen+int(pnLen):hdrLen+4], origPNBytes[int(pnLen):])
+	}
+	return l, pn, pnLen, kp, parseErr
+}
+
+// The error is either nil, a wire.ErrInvalidReservedBits or of type headerParseError.
+func (u *packetUnpacker) unpackLongHeader(hd headerDecryptor, hdr *wire.Header, data []byte) (*wire.ExtendedHeader, error) {
+	extHdr, err := unpackLongHeader(hd, hdr, data)
+	if err != nil && err != wire.ErrInvalidReservedBits {
+		return nil, &headerParseError{err: err}
+	}
+	return extHdr, err
+}
+
+func unpackLongHeader(hd headerDecryptor, hdr *wire.Header, data []byte) (*wire.ExtendedHeader, error) {
+	hdrLen := hdr.ParsedLen()
+	if protocol.ByteCount(len(data)) < hdrLen+4+16 {
+		return nil, fmt.Errorf("packet too small, expected at least 20 bytes after the header, got %d", protocol.ByteCount(len(data))-hdrLen)
+	}
+	// The packet number can be up to 4 bytes long, but we won't know the length until we decrypt it.
+	// 1. save a copy of the 4 bytes
+	origPNBytes := make([]byte, 4)
+	copy(origPNBytes, data[hdrLen:hdrLen+4])
+	// 2. decrypt the header, assuming a 4 byte packet number
+	hd.DecryptHeader(
+		data[hdrLen+4:hdrLen+4+16],
+		&data[0],
+		data[hdrLen:hdrLen+4],
+	)
+	// 3. parse the header (and learn the actual length of the packet number)
+	extHdr, parseErr := hdr.ParseExtended(data)
+	if parseErr != nil && parseErr != wire.ErrInvalidReservedBits {
+		return nil, parseErr
+	}
+	// 4. if the packet number is shorter than 4 bytes, replace the remaining bytes with the copy we saved earlier
+	if extHdr.PacketNumberLen != protocol.PacketNumberLen4 {
+		copy(data[extHdr.ParsedLen():hdrLen+4], origPNBytes[int(extHdr.PacketNumberLen):])
+	}
+	return extHdr, parseErr
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/path_manager.go b/backend/vendor/github.com/quic-go/quic-go/path_manager.go
new file mode 100644
index 00000000..dd188ea1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/path_manager.go
@@ -0,0 +1,206 @@
+package quic
+
+import (
+	"crypto/rand"
+	"net"
+	"slices"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type pathID int64
+
+const invalidPathID pathID = -1
+
+// Maximum number of paths to keep track of.
+// If the peer probes another path (before the pathTimeout of an existing path expires),
+// this probing attempt is ignored.
+const maxPaths = 3
+
+// If no packet is received for a path for pathTimeout,
+// the path can be evicted when the peer probes another path.
+// This prevents an attacker from churning through paths by duplicating packets and
+// sending them with spoofed source addresses.
+const pathTimeout = 5 * time.Second
+
+type path struct {
+	id             pathID
+	addr           net.Addr
+	lastPacketTime monotime.Time
+	pathChallenge  [8]byte
+	validated      bool
+	rcvdNonProbing bool
+}
+
+type pathManager struct {
+	nextPathID pathID
+	// ordered by lastPacketTime, with the most recently used path at the end
+	paths []*path
+
+	getConnID    func(pathID) (_ protocol.ConnectionID, ok bool)
+	retireConnID func(pathID)
+
+	logger utils.Logger
+}
+
+func newPathManager(
+	getConnID func(pathID) (_ protocol.ConnectionID, ok bool),
+	retireConnID func(pathID),
+	logger utils.Logger,
+) *pathManager {
+	return &pathManager{
+		paths:        make([]*path, 0, maxPaths+1),
+		getConnID:    getConnID,
+		retireConnID: retireConnID,
+		logger:       logger,
+	}
+}
+
+// Returns a path challenge frame if one should be sent.
+// May return nil.
+func (pm *pathManager) HandlePacket(
+	remoteAddr net.Addr,
+	t monotime.Time,
+	pathChallenge *wire.PathChallengeFrame, // may be nil if the packet didn't contain a PATH_CHALLENGE
+	isNonProbing bool,
+) (_ protocol.ConnectionID, _ []ackhandler.Frame, shouldSwitch bool) {
+	var p *path
+	for i, path := range pm.paths {
+		if addrsEqual(path.addr, remoteAddr) {
+			p = path
+			p.lastPacketTime = t
+			// already sent a PATH_CHALLENGE for this path
+			if isNonProbing {
+				path.rcvdNonProbing = true
+			}
+			if pm.logger.Debug() {
+				pm.logger.Debugf("received packet for path %s that was already probed, validated: %t", remoteAddr, path.validated)
+			}
+			shouldSwitch = path.validated && path.rcvdNonProbing
+			if i != len(pm.paths)-1 {
+				// move the path to the end of the list
+				pm.paths = slices.Delete(pm.paths, i, i+1)
+				pm.paths = append(pm.paths, p)
+			}
+			if pathChallenge == nil {
+				return protocol.ConnectionID{}, nil, shouldSwitch
+			}
+		}
+	}
+
+	if len(pm.paths) >= maxPaths {
+		if pm.paths[0].lastPacketTime.Add(pathTimeout).After(t) {
+			if pm.logger.Debug() {
+				pm.logger.Debugf("received packet for previously unseen path %s, but already have %d paths", remoteAddr, len(pm.paths))
+			}
+			return protocol.ConnectionID{}, nil, shouldSwitch
+		}
+		// evict the oldest path, if the last packet was received more than pathTimeout ago
+		pm.retireConnID(pm.paths[0].id)
+		pm.paths = pm.paths[1:]
+	}
+
+	var pathID pathID
+	if p != nil {
+		pathID = p.id
+	} else {
+		pathID = pm.nextPathID
+	}
+
+	// previously unseen path, initiate path validation by sending a PATH_CHALLENGE
+	connID, ok := pm.getConnID(pathID)
+	if !ok {
+		pm.logger.Debugf("skipping validation of new path %s since no connection ID is available", remoteAddr)
+		return protocol.ConnectionID{}, nil, shouldSwitch
+	}
+
+	frames := make([]ackhandler.Frame, 0, 2)
+	if p == nil {
+		var pathChallengeData [8]byte
+		rand.Read(pathChallengeData[:])
+		p = &path{
+			id:             pm.nextPathID,
+			addr:           remoteAddr,
+			lastPacketTime: t,
+			rcvdNonProbing: isNonProbing,
+			pathChallenge:  pathChallengeData,
+		}
+		pm.nextPathID++
+		pm.paths = append(pm.paths, p)
+		frames = append(frames, ackhandler.Frame{
+			Frame:   &wire.PathChallengeFrame{Data: p.pathChallenge},
+			Handler: (*pathManagerAckHandler)(pm),
+		})
+		pm.logger.Debugf("enqueueing PATH_CHALLENGE for new path %s", remoteAddr)
+	}
+	if pathChallenge != nil {
+		frames = append(frames, ackhandler.Frame{
+			Frame:   &wire.PathResponseFrame{Data: pathChallenge.Data},
+			Handler: (*pathManagerAckHandler)(pm),
+		})
+	}
+	return connID, frames, shouldSwitch
+}
+
+func (pm *pathManager) HandlePathResponseFrame(f *wire.PathResponseFrame) {
+	for _, p := range pm.paths {
+		if f.Data == p.pathChallenge {
+			// path validated
+			p.validated = true
+			pm.logger.Debugf("path %s validated", p.addr)
+			break
+		}
+	}
+}
+
+// SwitchToPath is called when the connection switches to a new path
+func (pm *pathManager) SwitchToPath(addr net.Addr) {
+	// retire all other paths
+	for _, path := range pm.paths {
+		if addrsEqual(path.addr, addr) {
+			pm.logger.Debugf("switching to path %d (%s)", path.id, addr)
+			continue
+		}
+		pm.retireConnID(path.id)
+	}
+	clear(pm.paths)
+	pm.paths = pm.paths[:0]
+}
+
+type pathManagerAckHandler pathManager
+
+var _ ackhandler.FrameHandler = &pathManagerAckHandler{}
+
+// Acknowledging the frame doesn't validate the path, only receiving the PATH_RESPONSE does.
+func (pm *pathManagerAckHandler) OnAcked(f wire.Frame) {}
+
+func (pm *pathManagerAckHandler) OnLost(f wire.Frame) {
+	pc, ok := f.(*wire.PathChallengeFrame)
+	if !ok {
+		return
+	}
+	for i, path := range pm.paths {
+		if path.pathChallenge == pc.Data {
+			pm.paths = slices.Delete(pm.paths, i, i+1)
+			pm.retireConnID(path.id)
+			break
+		}
+	}
+}
+
+func addrsEqual(addr1, addr2 net.Addr) bool {
+	if addr1 == nil || addr2 == nil {
+		return false
+	}
+	a1, ok1 := addr1.(*net.UDPAddr)
+	a2, ok2 := addr2.(*net.UDPAddr)
+	if ok1 && ok2 {
+		return a1.IP.Equal(a2.IP) && a1.Port == a2.Port
+	}
+	return addr1.String() == addr2.String()
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/path_manager_outgoing.go b/backend/vendor/github.com/quic-go/quic-go/path_manager_outgoing.go
new file mode 100644
index 00000000..78f68eea
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/path_manager_outgoing.go
@@ -0,0 +1,314 @@
+package quic
+
+import (
+	"context"
+	"crypto/rand"
+	"errors"
+	"slices"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+var (
+	// ErrPathClosed is returned when trying to switch to a path that has been closed.
+	ErrPathClosed = errors.New("path closed")
+	// ErrPathNotValidated is returned when trying to use a path before path probing has completed.
+	ErrPathNotValidated = errors.New("path not yet validated")
+)
+
+var errPathDoesNotExist = errors.New("path does not exist")
+
+// Path is a network path.
+type Path struct {
+	id          pathID
+	pathManager *pathManagerOutgoing
+	tr          *Transport
+	initialRTT  time.Duration
+
+	enablePath func()
+	validated  atomic.Bool
+	abandon    chan struct{}
+}
+
+func (p *Path) Probe(ctx context.Context) error {
+	path := p.pathManager.addPath(p, p.enablePath)
+
+	p.pathManager.enqueueProbe(p)
+	nextProbeDur := p.initialRTT
+	var timer *time.Timer
+	var timerChan <-chan time.Time
+	for {
+		select {
+		case <-ctx.Done():
+			return context.Cause(ctx)
+		case <-path.Validated():
+			p.validated.Store(true)
+			return nil
+		case <-timerChan:
+			nextProbeDur *= 2 // exponential backoff
+			p.pathManager.enqueueProbe(p)
+		case <-path.ProbeSent():
+		case <-p.abandon:
+			return ErrPathClosed
+		}
+
+		if timer != nil {
+			timer.Stop()
+		}
+		timer = time.NewTimer(nextProbeDur)
+		timerChan = timer.C
+	}
+}
+
+// Switch switches the QUIC connection to this path.
+// It immediately stops sending on the old path, and sends on this new path.
+func (p *Path) Switch() error {
+	if err := p.pathManager.switchToPath(p.id); err != nil {
+		switch {
+		case errors.Is(err, ErrPathNotValidated):
+			return err
+		case errors.Is(err, errPathDoesNotExist) && !p.validated.Load():
+			select {
+			case <-p.abandon:
+				return ErrPathClosed
+			default:
+				return ErrPathNotValidated
+			}
+		default:
+			return ErrPathClosed
+		}
+	}
+	return nil
+}
+
+// Close abandons a path.
+// It is not possible to close the path that’s currently active.
+// After closing, it is not possible to probe this path again.
+func (p *Path) Close() error {
+	select {
+	case <-p.abandon:
+		return nil
+	default:
+	}
+
+	if err := p.pathManager.removePath(p.id); err != nil {
+		return err
+	}
+	close(p.abandon)
+	return nil
+}
+
+type pathOutgoing struct {
+	pathChallenges [][8]byte // length is implicitly limited by exponential backoff
+	tr             *Transport
+	isValidated    bool
+	probeSent      chan struct{} // receives when a PATH_CHALLENGE is sent
+	validated      chan struct{} // closed when the path the corresponding PATH_RESPONSE is received
+	enablePath     func()
+}
+
+func (p *pathOutgoing) ProbeSent() <-chan struct{} { return p.probeSent }
+func (p *pathOutgoing) Validated() <-chan struct{} { return p.validated }
+
+type pathManagerOutgoing struct {
+	getConnID       func(pathID) (_ protocol.ConnectionID, ok bool)
+	retireConnID    func(pathID)
+	scheduleSending func()
+
+	mx             sync.Mutex
+	activePath     pathID
+	pathsToProbe   []pathID
+	paths          map[pathID]*pathOutgoing
+	nextPathID     pathID
+	pathToSwitchTo *pathOutgoing
+}
+
+// newPathManagerOutgoing creates a new pathManagerOutgoing object. This
+// function must be side-effect free as it may be called multiple times for a
+// single connection.
+func newPathManagerOutgoing(
+	getConnID func(pathID) (_ protocol.ConnectionID, ok bool),
+	retireConnID func(pathID),
+	scheduleSending func(),
+) *pathManagerOutgoing {
+	return &pathManagerOutgoing{
+		activePath:      0, // at initialization time, we're guaranteed to be using the handshake path
+		nextPathID:      1,
+		getConnID:       getConnID,
+		retireConnID:    retireConnID,
+		scheduleSending: scheduleSending,
+		paths:           make(map[pathID]*pathOutgoing, 4),
+	}
+}
+
+func (pm *pathManagerOutgoing) addPath(p *Path, enablePath func()) *pathOutgoing {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	// path might already exist, and just being re-probed
+	if existingPath, ok := pm.paths[p.id]; ok {
+		existingPath.validated = make(chan struct{})
+		return existingPath
+	}
+
+	path := &pathOutgoing{
+		tr:         p.tr,
+		probeSent:  make(chan struct{}, 1),
+		validated:  make(chan struct{}),
+		enablePath: enablePath,
+	}
+	pm.paths[p.id] = path
+	return path
+}
+
+func (pm *pathManagerOutgoing) enqueueProbe(p *Path) {
+	pm.mx.Lock()
+	pm.pathsToProbe = append(pm.pathsToProbe, p.id)
+	pm.mx.Unlock()
+	pm.scheduleSending()
+}
+
+func (pm *pathManagerOutgoing) removePath(id pathID) error {
+	if err := pm.removePathImpl(id); err != nil {
+		return err
+	}
+	pm.scheduleSending()
+	return nil
+}
+
+func (pm *pathManagerOutgoing) removePathImpl(id pathID) error {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	if id == pm.activePath {
+		return errors.New("cannot close active path")
+	}
+	p, ok := pm.paths[id]
+	if !ok {
+		return nil
+	}
+	if len(p.pathChallenges) > 0 {
+		pm.retireConnID(id)
+	}
+	delete(pm.paths, id)
+	return nil
+}
+
+func (pm *pathManagerOutgoing) switchToPath(id pathID) error {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	p, ok := pm.paths[id]
+	if !ok {
+		return errPathDoesNotExist
+	}
+	if !p.isValidated {
+		return ErrPathNotValidated
+	}
+	pm.pathToSwitchTo = p
+	pm.activePath = id
+	return nil
+}
+
+func (pm *pathManagerOutgoing) NewPath(t *Transport, initialRTT time.Duration, enablePath func()) *Path {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	id := pm.nextPathID
+	pm.nextPathID++
+	return &Path{
+		pathManager: pm,
+		id:          id,
+		tr:          t,
+		enablePath:  enablePath,
+		initialRTT:  initialRTT,
+		abandon:     make(chan struct{}),
+	}
+}
+
+func (pm *pathManagerOutgoing) NextPathToProbe() (_ protocol.ConnectionID, _ ackhandler.Frame, _ *Transport, hasPath bool) {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	var p *pathOutgoing
+	id := invalidPathID
+	for _, pID := range pm.pathsToProbe {
+		var ok bool
+		p, ok = pm.paths[pID]
+		if ok {
+			id = pID
+			break
+		}
+		// if the path doesn't exist in the map, it might have been abandoned
+		pm.pathsToProbe = pm.pathsToProbe[1:]
+	}
+	if id == invalidPathID {
+		return protocol.ConnectionID{}, ackhandler.Frame{}, nil, false
+	}
+
+	connID, ok := pm.getConnID(id)
+	if !ok {
+		return protocol.ConnectionID{}, ackhandler.Frame{}, nil, false
+	}
+
+	var b [8]byte
+	_, _ = rand.Read(b[:])
+	p.pathChallenges = append(p.pathChallenges, b)
+
+	pm.pathsToProbe = pm.pathsToProbe[1:]
+	p.enablePath()
+	select {
+	case p.probeSent <- struct{}{}:
+	default:
+	}
+	frame := ackhandler.Frame{
+		Frame:   &wire.PathChallengeFrame{Data: b},
+		Handler: (*pathManagerOutgoingAckHandler)(pm),
+	}
+	return connID, frame, p.tr, true
+}
+
+func (pm *pathManagerOutgoing) HandlePathResponseFrame(f *wire.PathResponseFrame) {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	for _, p := range pm.paths {
+		if slices.Contains(p.pathChallenges, f.Data) {
+			// path validated
+			if !p.isValidated {
+				// make sure that duplicate PATH_RESPONSE frames are ignored
+				p.isValidated = true
+				p.pathChallenges = nil
+				close(p.validated)
+			}
+			break
+		}
+	}
+}
+
+func (pm *pathManagerOutgoing) ShouldSwitchPath() (*Transport, bool) {
+	pm.mx.Lock()
+	defer pm.mx.Unlock()
+
+	if pm.pathToSwitchTo == nil {
+		return nil, false
+	}
+	p := pm.pathToSwitchTo
+	pm.pathToSwitchTo = nil
+	return p.tr, true
+}
+
+type pathManagerOutgoingAckHandler pathManagerOutgoing
+
+var _ ackhandler.FrameHandler = &pathManagerOutgoingAckHandler{}
+
+// OnAcked is called when the PATH_CHALLENGE is acked.
+// This doesn't validate the path, only receiving the PATH_RESPONSE does.
+func (pm *pathManagerOutgoingAckHandler) OnAcked(wire.Frame) {}
+
+func (pm *pathManagerOutgoingAckHandler) OnLost(wire.Frame) {}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlog/event.go b/backend/vendor/github.com/quic-go/quic-go/qlog/event.go
new file mode 100644
index 00000000..da81bb5d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlog/event.go
@@ -0,0 +1,849 @@
+package qlog
+
+import (
+	"fmt"
+	"net/netip"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+func milliseconds(dur time.Duration) float64 { return float64(dur.Nanoseconds()) / 1e6 }
+
+type encoderHelper struct {
+	enc *jsontext.Encoder
+	err error
+}
+
+func (h *encoderHelper) WriteToken(t jsontext.Token) {
+	if h.err != nil {
+		return
+	}
+	h.err = h.enc.WriteToken(t)
+}
+
+type versions []Version
+
+func (v versions) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginArray)
+	for _, e := range v {
+		h.WriteToken(jsontext.String(fmt.Sprintf("%x", uint32(e))))
+	}
+	h.WriteToken(jsontext.EndArray)
+	return h.err
+}
+
+type RawInfo struct {
+	Length        int // full packet length, including header and AEAD authentication tag
+	PayloadLength int // length of the packet payload, excluding AEAD tag
+}
+
+func (i RawInfo) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("length"))
+	h.WriteToken(jsontext.Uint(uint64(i.Length)))
+	if i.PayloadLength != 0 {
+		h.WriteToken(jsontext.String("payload_length"))
+		h.WriteToken(jsontext.Uint(uint64(i.PayloadLength)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PathEndpointInfo struct {
+	IPv4 netip.AddrPort
+	IPv6 netip.AddrPort
+}
+
+func (p PathEndpointInfo) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if p.IPv4.IsValid() {
+		h.WriteToken(jsontext.String("ip_v4"))
+		h.WriteToken(jsontext.String(p.IPv4.Addr().String()))
+		h.WriteToken(jsontext.String("port_v4"))
+		h.WriteToken(jsontext.Int(int64(p.IPv4.Port())))
+	}
+	if p.IPv6.IsValid() {
+		h.WriteToken(jsontext.String("ip_v6"))
+		h.WriteToken(jsontext.String(p.IPv6.Addr().String()))
+		h.WriteToken(jsontext.String("port_v6"))
+		h.WriteToken(jsontext.Int(int64(p.IPv6.Port())))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type StartedConnection struct {
+	Local  PathEndpointInfo
+	Remote PathEndpointInfo
+}
+
+func (e StartedConnection) Name() string { return "transport:connection_started" }
+
+func (e StartedConnection) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("local"))
+	if err := e.Local.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("remote"))
+	if err := e.Remote.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type VersionInformation struct {
+	ClientVersions, ServerVersions []Version
+	ChosenVersion                  Version
+}
+
+func (e VersionInformation) Name() string { return "transport:version_information" }
+
+func (e VersionInformation) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if len(e.ClientVersions) > 0 {
+		h.WriteToken(jsontext.String("client_versions"))
+		if err := versions(e.ClientVersions).encode(enc); err != nil {
+			return err
+		}
+	}
+	if len(e.ServerVersions) > 0 {
+		h.WriteToken(jsontext.String("server_versions"))
+		if err := versions(e.ServerVersions).encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.String("chosen_version"))
+	h.WriteToken(jsontext.String(fmt.Sprintf("%x", uint32(e.ChosenVersion))))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type ConnectionClosed struct {
+	Initiator Initiator
+
+	ConnectionError  *TransportErrorCode
+	ApplicationError *ApplicationErrorCode
+
+	Reason string
+
+	Trigger ConnectionCloseTrigger
+}
+
+func (e ConnectionClosed) Name() string { return "transport:connection_closed" }
+
+func (e ConnectionClosed) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("initiator"))
+	h.WriteToken(jsontext.String(string(e.Initiator)))
+	if e.ConnectionError != nil {
+		h.WriteToken(jsontext.String("connection_error"))
+		if e.ConnectionError.IsCryptoError() {
+			h.WriteToken(jsontext.String(fmt.Sprintf("crypto_error_%#x", uint16(*e.ConnectionError))))
+		} else {
+			switch *e.ConnectionError {
+			case qerr.NoError:
+				h.WriteToken(jsontext.String("no_error"))
+			case qerr.InternalError:
+				h.WriteToken(jsontext.String("internal_error"))
+			case qerr.ConnectionRefused:
+				h.WriteToken(jsontext.String("connection_refused"))
+			case qerr.FlowControlError:
+				h.WriteToken(jsontext.String("flow_control_error"))
+			case qerr.StreamLimitError:
+				h.WriteToken(jsontext.String("stream_limit_error"))
+			case qerr.StreamStateError:
+				h.WriteToken(jsontext.String("stream_state_error"))
+			case qerr.FinalSizeError:
+				h.WriteToken(jsontext.String("final_size_error"))
+			case qerr.FrameEncodingError:
+				h.WriteToken(jsontext.String("frame_encoding_error"))
+			case qerr.TransportParameterError:
+				h.WriteToken(jsontext.String("transport_parameter_error"))
+			case qerr.ConnectionIDLimitError:
+				h.WriteToken(jsontext.String("connection_id_limit_error"))
+			case qerr.ProtocolViolation:
+				h.WriteToken(jsontext.String("protocol_violation"))
+			case qerr.InvalidToken:
+				h.WriteToken(jsontext.String("invalid_token"))
+			case qerr.ApplicationErrorErrorCode:
+				h.WriteToken(jsontext.String("application_error"))
+			case qerr.CryptoBufferExceeded:
+				h.WriteToken(jsontext.String("crypto_buffer_exceeded"))
+			case qerr.KeyUpdateError:
+				h.WriteToken(jsontext.String("key_update_error"))
+			case qerr.AEADLimitReached:
+				h.WriteToken(jsontext.String("aead_limit_reached"))
+			case qerr.NoViablePathError:
+				h.WriteToken(jsontext.String("no_viable_path"))
+			default:
+				h.WriteToken(jsontext.String("unknown"))
+				h.WriteToken(jsontext.String("error_code"))
+				h.WriteToken(jsontext.Uint(uint64(*e.ConnectionError)))
+			}
+		}
+	}
+	if e.ApplicationError != nil {
+		h.WriteToken(jsontext.String("application_error"))
+		h.WriteToken(jsontext.String("unknown"))
+		h.WriteToken(jsontext.String("error_code"))
+		h.WriteToken(jsontext.Uint(uint64(*e.ApplicationError)))
+	}
+	if e.ConnectionError != nil || e.ApplicationError != nil {
+		h.WriteToken(jsontext.String("reason"))
+		h.WriteToken(jsontext.String(e.Reason))
+	}
+	if e.Trigger != "" {
+		h.WriteToken(jsontext.String("trigger"))
+		h.WriteToken(jsontext.String(string(e.Trigger)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PacketSent struct {
+	Header                  PacketHeader
+	Raw                     RawInfo
+	DatagramPayloadChecksum DatagramPayloadChecksum
+	Frames                  []Frame
+	ECN                     ECN
+	IsCoalesced             bool
+	Trigger                 string
+	SupportedVersions       []Version
+}
+
+func (e PacketSent) Name() string { return "transport:packet_sent" }
+
+func (e PacketSent) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	if e.DatagramPayloadChecksum != 0 {
+		h.WriteToken(jsontext.String("datagram_payload_checksum"))
+		h.WriteToken(jsontext.Uint(uint64(e.DatagramPayloadChecksum)))
+	}
+	if len(e.Frames) > 0 {
+		h.WriteToken(jsontext.String("frames"))
+		if err := frames(e.Frames).encode(enc); err != nil {
+			return err
+		}
+	}
+	if e.IsCoalesced {
+		h.WriteToken(jsontext.String("is_coalesced"))
+		h.WriteToken(jsontext.True)
+	}
+	if e.ECN != ECNUnsupported {
+		h.WriteToken(jsontext.String("ecn"))
+		h.WriteToken(jsontext.String(string(e.ECN)))
+	}
+	if e.Trigger != "" {
+		h.WriteToken(jsontext.String("trigger"))
+		h.WriteToken(jsontext.String(e.Trigger))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PacketReceived struct {
+	Header                  PacketHeader
+	Raw                     RawInfo
+	DatagramPayloadChecksum DatagramPayloadChecksum
+	Frames                  []Frame
+	ECN                     ECN
+	IsCoalesced             bool
+	Trigger                 string
+}
+
+func (e PacketReceived) Name() string { return "transport:packet_received" }
+
+func (e PacketReceived) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	if e.DatagramPayloadChecksum != 0 {
+		h.WriteToken(jsontext.String("datagram_payload_checksum"))
+		h.WriteToken(jsontext.Uint(uint64(e.DatagramPayloadChecksum)))
+	}
+	if len(e.Frames) > 0 {
+		h.WriteToken(jsontext.String("frames"))
+		if err := frames(e.Frames).encode(enc); err != nil {
+			return err
+		}
+	}
+	if e.IsCoalesced {
+		h.WriteToken(jsontext.String("is_coalesced"))
+		h.WriteToken(jsontext.True)
+	}
+	if e.ECN != ECNUnsupported {
+		h.WriteToken(jsontext.String("ecn"))
+		h.WriteToken(jsontext.String(string(e.ECN)))
+	}
+	if e.Trigger != "" {
+		h.WriteToken(jsontext.String("trigger"))
+		h.WriteToken(jsontext.String(e.Trigger))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type VersionNegotiationReceived struct {
+	Header            PacketHeaderVersionNegotiation
+	SupportedVersions []Version
+}
+
+func (e VersionNegotiationReceived) Name() string { return "transport:packet_received" }
+
+func (e VersionNegotiationReceived) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("supported_versions"))
+	if err := versions(e.SupportedVersions).encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type VersionNegotiationSent struct {
+	Header            PacketHeaderVersionNegotiation
+	SupportedVersions []Version
+}
+
+func (e VersionNegotiationSent) Name() string { return "transport:packet_sent" }
+
+func (e VersionNegotiationSent) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("supported_versions"))
+	if err := versions(e.SupportedVersions).encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PacketBuffered struct {
+	Header                  PacketHeader
+	Raw                     RawInfo
+	DatagramPayloadChecksum DatagramPayloadChecksum
+}
+
+func (e PacketBuffered) Name() string { return "transport:packet_buffered" }
+
+func (e PacketBuffered) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	if e.DatagramPayloadChecksum != 0 {
+		h.WriteToken(jsontext.String("datagram_payload_checksum"))
+		h.WriteToken(jsontext.Uint(uint64(e.DatagramPayloadChecksum)))
+	}
+	h.WriteToken(jsontext.String("trigger"))
+	h.WriteToken(jsontext.String("keys_unavailable"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// PacketDropped is the transport:packet_dropped event.
+type PacketDropped struct {
+	Header                  PacketHeader
+	Raw                     RawInfo
+	DatagramPayloadChecksum DatagramPayloadChecksum
+	Trigger                 PacketDropReason
+}
+
+func (e PacketDropped) Name() string { return "transport:packet_dropped" }
+
+func (e PacketDropped) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("raw"))
+	if err := e.Raw.encode(enc); err != nil {
+		return err
+	}
+	if e.DatagramPayloadChecksum != 0 {
+		h.WriteToken(jsontext.String("datagram_payload_checksum"))
+		h.WriteToken(jsontext.Uint(uint64(e.DatagramPayloadChecksum)))
+	}
+	h.WriteToken(jsontext.String("trigger"))
+	h.WriteToken(jsontext.String(string(e.Trigger)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type MTUUpdated struct {
+	Value int
+	Done  bool
+}
+
+func (e MTUUpdated) Name() string { return "recovery:mtu_updated" }
+
+func (e MTUUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("mtu"))
+	h.WriteToken(jsontext.Uint(uint64(e.Value)))
+	h.WriteToken(jsontext.String("done"))
+	h.WriteToken(jsontext.Bool(e.Done))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// MetricsUpdated logs RTT and congestion metrics as defined in the
+// recovery:metrics_updated event.
+// The PTO count is logged via PTOCountUpdated.
+type MetricsUpdated struct {
+	MinRTT           time.Duration
+	SmoothedRTT      time.Duration
+	LatestRTT        time.Duration
+	RTTVariance      time.Duration
+	CongestionWindow int
+	BytesInFlight    int
+	PacketsInFlight  int
+}
+
+func (e MetricsUpdated) Name() string { return "recovery:metrics_updated" }
+
+func (e MetricsUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if e.MinRTT != 0 {
+		h.WriteToken(jsontext.String("min_rtt"))
+		h.WriteToken(jsontext.Float(milliseconds(e.MinRTT)))
+	}
+	if e.SmoothedRTT != 0 {
+		h.WriteToken(jsontext.String("smoothed_rtt"))
+		h.WriteToken(jsontext.Float(milliseconds(e.SmoothedRTT)))
+	}
+	if e.LatestRTT != 0 {
+		h.WriteToken(jsontext.String("latest_rtt"))
+		h.WriteToken(jsontext.Float(milliseconds(e.LatestRTT)))
+	}
+	if e.RTTVariance != 0 {
+		h.WriteToken(jsontext.String("rtt_variance"))
+		h.WriteToken(jsontext.Float(milliseconds(e.RTTVariance)))
+	}
+	if e.CongestionWindow != 0 {
+		h.WriteToken(jsontext.String("congestion_window"))
+		h.WriteToken(jsontext.Uint(uint64(e.CongestionWindow)))
+	}
+	if e.BytesInFlight != 0 {
+		h.WriteToken(jsontext.String("bytes_in_flight"))
+		h.WriteToken(jsontext.Uint(uint64(e.BytesInFlight)))
+	}
+	if e.PacketsInFlight != 0 {
+		h.WriteToken(jsontext.String("packets_in_flight"))
+		h.WriteToken(jsontext.Uint(uint64(e.PacketsInFlight)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// PTOCountUpdated logs the pto_count value of the
+// recovery:metrics_updated event.
+type PTOCountUpdated struct {
+	PTOCount uint32
+}
+
+func (e PTOCountUpdated) Name() string { return "recovery:metrics_updated" }
+
+func (e PTOCountUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("pto_count"))
+	h.WriteToken(jsontext.Uint(uint64(e.PTOCount)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PacketLost struct {
+	Header  PacketHeader
+	Trigger PacketLossReason
+}
+
+func (e PacketLost) Name() string { return "recovery:packet_lost" }
+
+func (e PacketLost) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("header"))
+	if err := e.Header.encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.String("trigger"))
+	h.WriteToken(jsontext.String(string(e.Trigger)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type SpuriousLoss struct {
+	EncryptionLevel  protocol.EncryptionLevel
+	PacketNumber     protocol.PacketNumber
+	PacketReordering uint64
+	TimeReordering   time.Duration
+}
+
+func (e SpuriousLoss) Name() string { return "recovery:spurious_loss" }
+
+func (e SpuriousLoss) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("packet_number_space"))
+	h.WriteToken(jsontext.String(encLevelToPacketNumberSpace(e.EncryptionLevel)))
+	h.WriteToken(jsontext.String("packet_number"))
+	h.WriteToken(jsontext.Uint(uint64(e.PacketNumber)))
+	h.WriteToken(jsontext.String("reordering_packets"))
+	h.WriteToken(jsontext.Uint(e.PacketReordering))
+	h.WriteToken(jsontext.String("reordering_time"))
+	h.WriteToken(jsontext.Float(milliseconds(e.TimeReordering)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type KeyUpdated struct {
+	Trigger  KeyUpdateTrigger
+	KeyType  KeyType
+	KeyPhase KeyPhase // only set for 1-RTT keys
+	// we don't log the keys here, so we don't need `old` and `new`.
+}
+
+func (e KeyUpdated) Name() string { return "security:key_updated" }
+
+func (e KeyUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("trigger"))
+	h.WriteToken(jsontext.String(string(e.Trigger)))
+	h.WriteToken(jsontext.String("key_type"))
+	h.WriteToken(jsontext.String(string(e.KeyType)))
+	if e.KeyType == KeyTypeClient1RTT || e.KeyType == KeyTypeServer1RTT {
+		h.WriteToken(jsontext.String("key_phase"))
+		h.WriteToken(jsontext.Uint(uint64(e.KeyPhase)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type KeyDiscarded struct {
+	KeyType  KeyType
+	KeyPhase KeyPhase // only set for 1-RTT keys
+}
+
+func (e KeyDiscarded) Name() string { return "security:key_discarded" }
+
+func (e KeyDiscarded) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if e.KeyType != KeyTypeClient1RTT && e.KeyType != KeyTypeServer1RTT {
+		h.WriteToken(jsontext.String("trigger"))
+		h.WriteToken(jsontext.String("tls"))
+	}
+	h.WriteToken(jsontext.String("key_type"))
+	h.WriteToken(jsontext.String(string(e.KeyType)))
+	if e.KeyType == KeyTypeClient1RTT || e.KeyType == KeyTypeServer1RTT {
+		h.WriteToken(jsontext.String("key_phase"))
+		h.WriteToken(jsontext.Uint(uint64(e.KeyPhase)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type ParametersSet struct {
+	Restore                         bool
+	Initiator                       Initiator
+	SentBy                          protocol.Perspective
+	OriginalDestinationConnectionID protocol.ConnectionID
+	InitialSourceConnectionID       protocol.ConnectionID
+	RetrySourceConnectionID         *protocol.ConnectionID
+	StatelessResetToken             *protocol.StatelessResetToken
+	DisableActiveMigration          bool
+	MaxIdleTimeout                  time.Duration
+	MaxUDPPayloadSize               protocol.ByteCount
+	AckDelayExponent                uint8
+	MaxAckDelay                     time.Duration
+	ActiveConnectionIDLimit         uint64
+	InitialMaxData                  protocol.ByteCount
+	InitialMaxStreamDataBidiLocal   protocol.ByteCount
+	InitialMaxStreamDataBidiRemote  protocol.ByteCount
+	InitialMaxStreamDataUni         protocol.ByteCount
+	InitialMaxStreamsBidi           int64
+	InitialMaxStreamsUni            int64
+	PreferredAddress                *PreferredAddress
+	MaxDatagramFrameSize            protocol.ByteCount
+	EnableResetStreamAt             bool
+}
+
+func (e ParametersSet) Name() string {
+	if e.Restore {
+		return "transport:parameters_restored"
+	}
+	return "transport:parameters_set"
+}
+
+func (e ParametersSet) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if !e.Restore {
+		h.WriteToken(jsontext.String("initiator"))
+		h.WriteToken(jsontext.String(string(e.Initiator)))
+		if e.SentBy == protocol.PerspectiveServer {
+			h.WriteToken(jsontext.String("original_destination_connection_id"))
+			h.WriteToken(jsontext.String(e.OriginalDestinationConnectionID.String()))
+			if e.StatelessResetToken != nil {
+				h.WriteToken(jsontext.String("stateless_reset_token"))
+				h.WriteToken(jsontext.String(fmt.Sprintf("%x", e.StatelessResetToken[:])))
+			}
+			if e.RetrySourceConnectionID != nil {
+				h.WriteToken(jsontext.String("retry_source_connection_id"))
+				h.WriteToken(jsontext.String((*e.RetrySourceConnectionID).String()))
+			}
+		}
+		h.WriteToken(jsontext.String("initial_source_connection_id"))
+		h.WriteToken(jsontext.String(e.InitialSourceConnectionID.String()))
+	}
+	h.WriteToken(jsontext.String("disable_active_migration"))
+	h.WriteToken(jsontext.Bool(e.DisableActiveMigration))
+	if e.MaxIdleTimeout != 0 {
+		h.WriteToken(jsontext.String("max_idle_timeout"))
+		h.WriteToken(jsontext.Float(milliseconds(e.MaxIdleTimeout)))
+	}
+	if e.MaxUDPPayloadSize != 0 {
+		h.WriteToken(jsontext.String("max_udp_payload_size"))
+		h.WriteToken(jsontext.Int(int64(e.MaxUDPPayloadSize)))
+	}
+	if e.AckDelayExponent != 0 {
+		h.WriteToken(jsontext.String("ack_delay_exponent"))
+		h.WriteToken(jsontext.Uint(uint64(e.AckDelayExponent)))
+	}
+	if e.MaxAckDelay != 0 {
+		h.WriteToken(jsontext.String("max_ack_delay"))
+		h.WriteToken(jsontext.Float(milliseconds(e.MaxAckDelay)))
+	}
+	if e.ActiveConnectionIDLimit != 0 {
+		h.WriteToken(jsontext.String("active_connection_id_limit"))
+		h.WriteToken(jsontext.Uint(e.ActiveConnectionIDLimit))
+	}
+	if e.InitialMaxData != 0 {
+		h.WriteToken(jsontext.String("initial_max_data"))
+		h.WriteToken(jsontext.Int(int64(e.InitialMaxData)))
+	}
+	if e.InitialMaxStreamDataBidiLocal != 0 {
+		h.WriteToken(jsontext.String("initial_max_stream_data_bidi_local"))
+		h.WriteToken(jsontext.Int(int64(e.InitialMaxStreamDataBidiLocal)))
+	}
+	if e.InitialMaxStreamDataBidiRemote != 0 {
+		h.WriteToken(jsontext.String("initial_max_stream_data_bidi_remote"))
+		h.WriteToken(jsontext.Int(int64(e.InitialMaxStreamDataBidiRemote)))
+	}
+	if e.InitialMaxStreamDataUni != 0 {
+		h.WriteToken(jsontext.String("initial_max_stream_data_uni"))
+		h.WriteToken(jsontext.Int(int64(e.InitialMaxStreamDataUni)))
+	}
+	if e.InitialMaxStreamsBidi != 0 {
+		h.WriteToken(jsontext.String("initial_max_streams_bidi"))
+		h.WriteToken(jsontext.Int(e.InitialMaxStreamsBidi))
+	}
+	if e.InitialMaxStreamsUni != 0 {
+		h.WriteToken(jsontext.String("initial_max_streams_uni"))
+		h.WriteToken(jsontext.Int(e.InitialMaxStreamsUni))
+	}
+	if e.PreferredAddress != nil {
+		h.WriteToken(jsontext.String("preferred_address"))
+		if err := e.PreferredAddress.encode(enc); err != nil {
+			return err
+		}
+	}
+	if e.MaxDatagramFrameSize != protocol.InvalidByteCount {
+		h.WriteToken(jsontext.String("max_datagram_frame_size"))
+		h.WriteToken(jsontext.Int(int64(e.MaxDatagramFrameSize)))
+	}
+	if e.EnableResetStreamAt {
+		h.WriteToken(jsontext.String("reset_stream_at"))
+		h.WriteToken(jsontext.True)
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type PreferredAddress struct {
+	IPv4, IPv6          netip.AddrPort
+	ConnectionID        protocol.ConnectionID
+	StatelessResetToken protocol.StatelessResetToken
+}
+
+func (a PreferredAddress) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	if a.IPv4.IsValid() {
+		h.WriteToken(jsontext.String("ip_v4"))
+		h.WriteToken(jsontext.String(a.IPv4.Addr().String()))
+		h.WriteToken(jsontext.String("port_v4"))
+		h.WriteToken(jsontext.Uint(uint64(a.IPv4.Port())))
+	}
+	if a.IPv6.IsValid() {
+		h.WriteToken(jsontext.String("ip_v6"))
+		h.WriteToken(jsontext.String(a.IPv6.Addr().String()))
+		h.WriteToken(jsontext.String("port_v6"))
+		h.WriteToken(jsontext.Uint(uint64(a.IPv6.Port())))
+	}
+	h.WriteToken(jsontext.String("connection_id"))
+	h.WriteToken(jsontext.String(a.ConnectionID.String()))
+	h.WriteToken(jsontext.String("stateless_reset_token"))
+	h.WriteToken(jsontext.String(fmt.Sprintf("%x", a.StatelessResetToken)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type LossTimerUpdated struct {
+	Type      LossTimerUpdateType
+	TimerType TimerType
+	EncLevel  EncryptionLevel
+	Time      time.Time
+}
+
+func (e LossTimerUpdated) Name() string { return "recovery:loss_timer_updated" }
+
+func (e LossTimerUpdated) Encode(enc *jsontext.Encoder, t time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("event_type"))
+	h.WriteToken(jsontext.String(string(e.Type)))
+	h.WriteToken(jsontext.String("timer_type"))
+	h.WriteToken(jsontext.String(string(e.TimerType)))
+	h.WriteToken(jsontext.String("packet_number_space"))
+	h.WriteToken(jsontext.String(encLevelToPacketNumberSpace(e.EncLevel)))
+	if e.Type == LossTimerUpdateTypeSet {
+		h.WriteToken(jsontext.String("delta"))
+		h.WriteToken(jsontext.Float(milliseconds(e.Time.Sub(t))))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type eventLossTimerCanceled struct{}
+
+func (e eventLossTimerCanceled) Name() string { return "recovery:loss_timer_updated" }
+
+func (e eventLossTimerCanceled) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("event_type"))
+	h.WriteToken(jsontext.String("cancelled"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type CongestionStateUpdated struct {
+	State CongestionState
+}
+
+func (e CongestionStateUpdated) Name() string { return "recovery:congestion_state_updated" }
+
+func (e CongestionStateUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("new"))
+	h.WriteToken(jsontext.String(e.State.String()))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type ECNStateUpdated struct {
+	State   ECNState
+	Trigger string
+}
+
+func (e ECNStateUpdated) Name() string { return "recovery:ecn_state_updated" }
+
+func (e ECNStateUpdated) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("new"))
+	h.WriteToken(jsontext.String(string(e.State)))
+	if e.Trigger != "" {
+		h.WriteToken(jsontext.String("trigger"))
+		h.WriteToken(jsontext.String(e.Trigger))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type ALPNInformation struct {
+	ChosenALPN string
+}
+
+func (e ALPNInformation) Name() string { return "transport:alpn_information" }
+
+func (e ALPNInformation) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("chosen_alpn"))
+	h.WriteToken(jsontext.String(e.ChosenALPN))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// DebugEvent is a generic event that can be used to log arbitrary messages.
+type DebugEvent struct {
+	EventName string
+	Message   string
+}
+
+func (e DebugEvent) Name() string {
+	if e.EventName == "" {
+		return "transport:debug"
+	}
+	return fmt.Sprintf("transport:%s", e.EventName)
+}
+
+func (e DebugEvent) Encode(enc *jsontext.Encoder, _ time.Time) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("message"))
+	h.WriteToken(jsontext.String(e.Message))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlog/frame.go b/backend/vendor/github.com/quic-go/quic-go/qlog/frame.go
new file mode 100644
index 00000000..b66fedc9
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlog/frame.go
@@ -0,0 +1,481 @@
+package qlog
+
+import (
+	"encoding/hex"
+
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+type Frame struct {
+	Frame any
+}
+
+type frames []Frame
+
+type (
+	// An AckFrame is an ACK frame.
+	AckFrame = wire.AckFrame
+	// A ConnectionCloseFrame is a CONNECTION_CLOSE frame.
+	ConnectionCloseFrame = wire.ConnectionCloseFrame
+	// A DataBlockedFrame is a DATA_BLOCKED frame.
+	DataBlockedFrame = wire.DataBlockedFrame
+	// A HandshakeDoneFrame is a HANDSHAKE_DONE frame.
+	HandshakeDoneFrame = wire.HandshakeDoneFrame
+	// A MaxDataFrame is a MAX_DATA frame.
+	MaxDataFrame = wire.MaxDataFrame
+	// A MaxStreamDataFrame is a MAX_STREAM_DATA frame.
+	MaxStreamDataFrame = wire.MaxStreamDataFrame
+	// A MaxStreamsFrame is a MAX_STREAMS_FRAME.
+	MaxStreamsFrame = wire.MaxStreamsFrame
+	// A NewConnectionIDFrame is a NEW_CONNECTION_ID frame.
+	NewConnectionIDFrame = wire.NewConnectionIDFrame
+	// A NewTokenFrame is a NEW_TOKEN frame.
+	NewTokenFrame = wire.NewTokenFrame
+	// A PathChallengeFrame is a PATH_CHALLENGE frame.
+	PathChallengeFrame = wire.PathChallengeFrame
+	// A PathResponseFrame is a PATH_RESPONSE frame.
+	PathResponseFrame = wire.PathResponseFrame
+	// A PingFrame is a PING frame.
+	PingFrame = wire.PingFrame
+	// A ResetStreamFrame is a RESET_STREAM frame.
+	ResetStreamFrame = wire.ResetStreamFrame
+	// A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame.
+	RetireConnectionIDFrame = wire.RetireConnectionIDFrame
+	// A StopSendingFrame is a STOP_SENDING frame.
+	StopSendingFrame = wire.StopSendingFrame
+	// A StreamsBlockedFrame is a STREAMS_BLOCKED frame.
+	StreamsBlockedFrame = wire.StreamsBlockedFrame
+	// A StreamDataBlockedFrame is a STREAM_DATA_BLOCKED frame.
+	StreamDataBlockedFrame = wire.StreamDataBlockedFrame
+	// An AckFrequencyFrame is an ACK_FREQUENCY frame.
+	AckFrequencyFrame = wire.AckFrequencyFrame
+	// An ImmediateAckFrame is an IMMEDIATE_ACK frame.
+	ImmediateAckFrame = wire.ImmediateAckFrame
+)
+
+type AckRange = wire.AckRange
+
+// A CryptoFrame is a CRYPTO frame.
+type CryptoFrame struct {
+	Offset int64
+	Length int64
+}
+
+// A StreamFrame is a STREAM frame.
+type StreamFrame struct {
+	StreamID StreamID
+	Offset   int64
+	Length   int64
+	Fin      bool
+}
+
+// A DatagramFrame is a DATAGRAM frame.
+type DatagramFrame struct {
+	Length int64
+}
+
+func (fs frames) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginArray)
+	for _, f := range fs {
+		if err := f.Encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.EndArray)
+	return h.err
+}
+
+func (f Frame) Encode(enc *jsontext.Encoder) error {
+	switch frame := f.Frame.(type) {
+	case *PingFrame:
+		return encodePingFrame(enc, frame)
+	case *AckFrame:
+		return encodeAckFrame(enc, frame)
+	case *ResetStreamFrame:
+		return encodeResetStreamFrame(enc, frame)
+	case *StopSendingFrame:
+		return encodeStopSendingFrame(enc, frame)
+	case *CryptoFrame:
+		return encodeCryptoFrame(enc, frame)
+	case *NewTokenFrame:
+		return encodeNewTokenFrame(enc, frame)
+	case *StreamFrame:
+		return encodeStreamFrame(enc, frame)
+	case *MaxDataFrame:
+		return encodeMaxDataFrame(enc, frame)
+	case *MaxStreamDataFrame:
+		return encodeMaxStreamDataFrame(enc, frame)
+	case *MaxStreamsFrame:
+		return encodeMaxStreamsFrame(enc, frame)
+	case *DataBlockedFrame:
+		return encodeDataBlockedFrame(enc, frame)
+	case *StreamDataBlockedFrame:
+		return encodeStreamDataBlockedFrame(enc, frame)
+	case *StreamsBlockedFrame:
+		return encodeStreamsBlockedFrame(enc, frame)
+	case *NewConnectionIDFrame:
+		return encodeNewConnectionIDFrame(enc, frame)
+	case *RetireConnectionIDFrame:
+		return encodeRetireConnectionIDFrame(enc, frame)
+	case *PathChallengeFrame:
+		return encodePathChallengeFrame(enc, frame)
+	case *PathResponseFrame:
+		return encodePathResponseFrame(enc, frame)
+	case *ConnectionCloseFrame:
+		return encodeConnectionCloseFrame(enc, frame)
+	case *HandshakeDoneFrame:
+		return encodeHandshakeDoneFrame(enc, frame)
+	case *DatagramFrame:
+		return encodeDatagramFrame(enc, frame)
+	case *AckFrequencyFrame:
+		return encodeAckFrequencyFrame(enc, frame)
+	case *ImmediateAckFrame:
+		return encodeImmediateAckFrame(enc, frame)
+	default:
+		panic("unknown frame type")
+	}
+}
+
+func encodePingFrame(enc *jsontext.Encoder, _ *PingFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("ping"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+type ackRanges []wire.AckRange
+
+func (ars ackRanges) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginArray)
+	for _, r := range ars {
+		if err := ackRange(r).encode(enc); err != nil {
+			return err
+		}
+	}
+	h.WriteToken(jsontext.EndArray)
+	return h.err
+}
+
+type ackRange wire.AckRange
+
+func (ar ackRange) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginArray)
+	h.WriteToken(jsontext.Int(int64(ar.Smallest)))
+	if ar.Smallest != ar.Largest {
+		h.WriteToken(jsontext.Int(int64(ar.Largest)))
+	}
+	h.WriteToken(jsontext.EndArray)
+	return h.err
+}
+
+func encodeAckFrame(enc *jsontext.Encoder, f *AckFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("ack"))
+	if f.DelayTime > 0 {
+		h.WriteToken(jsontext.String("ack_delay"))
+		h.WriteToken(jsontext.Float(milliseconds(f.DelayTime)))
+	}
+	h.WriteToken(jsontext.String("acked_ranges"))
+	if err := ackRanges(f.AckRanges).encode(enc); err != nil {
+		return err
+	}
+	hasECN := f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0
+	if hasECN {
+		h.WriteToken(jsontext.String("ect0"))
+		h.WriteToken(jsontext.Uint(f.ECT0))
+		h.WriteToken(jsontext.String("ect1"))
+		h.WriteToken(jsontext.Uint(f.ECT1))
+		h.WriteToken(jsontext.String("ce"))
+		h.WriteToken(jsontext.Uint(f.ECNCE))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeResetStreamFrame(enc *jsontext.Encoder, f *ResetStreamFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	if f.ReliableSize > 0 {
+		h.WriteToken(jsontext.String("reset_stream_at"))
+	} else {
+		h.WriteToken(jsontext.String("reset_stream"))
+	}
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Int(int64(f.StreamID)))
+	h.WriteToken(jsontext.String("error_code"))
+	h.WriteToken(jsontext.Int(int64(f.ErrorCode)))
+	h.WriteToken(jsontext.String("final_size"))
+	h.WriteToken(jsontext.Int(int64(f.FinalSize)))
+	if f.ReliableSize > 0 {
+		h.WriteToken(jsontext.String("reliable_size"))
+		h.WriteToken(jsontext.Int(int64(f.ReliableSize)))
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeStopSendingFrame(enc *jsontext.Encoder, f *StopSendingFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("stop_sending"))
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Int(int64(f.StreamID)))
+	h.WriteToken(jsontext.String("error_code"))
+	h.WriteToken(jsontext.Int(int64(f.ErrorCode)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeCryptoFrame(enc *jsontext.Encoder, f *CryptoFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("crypto"))
+	h.WriteToken(jsontext.String("offset"))
+	h.WriteToken(jsontext.Int(f.Offset))
+	h.WriteToken(jsontext.String("length"))
+	h.WriteToken(jsontext.Int(f.Length))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeNewTokenFrame(enc *jsontext.Encoder, f *NewTokenFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("new_token"))
+	h.WriteToken(jsontext.String("token"))
+	if err := (Token{Raw: f.Token}).encode(enc); err != nil {
+		return err
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeStreamFrame(enc *jsontext.Encoder, f *StreamFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("stream"))
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Int(int64(f.StreamID)))
+	h.WriteToken(jsontext.String("offset"))
+	h.WriteToken(jsontext.Int(f.Offset))
+	h.WriteToken(jsontext.String("length"))
+	h.WriteToken(jsontext.Int(f.Length))
+	if f.Fin {
+		h.WriteToken(jsontext.String("fin"))
+		h.WriteToken(jsontext.True)
+	}
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeMaxDataFrame(enc *jsontext.Encoder, f *MaxDataFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("max_data"))
+	h.WriteToken(jsontext.String("maximum"))
+	h.WriteToken(jsontext.Int(int64(f.MaximumData)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeMaxStreamDataFrame(enc *jsontext.Encoder, f *MaxStreamDataFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("max_stream_data"))
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Int(int64(f.StreamID)))
+	h.WriteToken(jsontext.String("maximum"))
+	h.WriteToken(jsontext.Int(int64(f.MaximumStreamData)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeMaxStreamsFrame(enc *jsontext.Encoder, f *MaxStreamsFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("max_streams"))
+	h.WriteToken(jsontext.String("stream_type"))
+	h.WriteToken(jsontext.String(streamType(f.Type).String()))
+	h.WriteToken(jsontext.String("maximum"))
+	h.WriteToken(jsontext.Int(int64(f.MaxStreamNum)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeDataBlockedFrame(enc *jsontext.Encoder, f *DataBlockedFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("data_blocked"))
+	h.WriteToken(jsontext.String("limit"))
+	h.WriteToken(jsontext.Int(int64(f.MaximumData)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeStreamDataBlockedFrame(enc *jsontext.Encoder, f *StreamDataBlockedFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("stream_data_blocked"))
+	h.WriteToken(jsontext.String("stream_id"))
+	h.WriteToken(jsontext.Int(int64(f.StreamID)))
+	h.WriteToken(jsontext.String("limit"))
+	h.WriteToken(jsontext.Int(int64(f.MaximumStreamData)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeStreamsBlockedFrame(enc *jsontext.Encoder, f *StreamsBlockedFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("streams_blocked"))
+	h.WriteToken(jsontext.String("stream_type"))
+	h.WriteToken(jsontext.String(streamType(f.Type).String()))
+	h.WriteToken(jsontext.String("limit"))
+	h.WriteToken(jsontext.Int(int64(f.StreamLimit)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeNewConnectionIDFrame(enc *jsontext.Encoder, f *NewConnectionIDFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("new_connection_id"))
+	h.WriteToken(jsontext.String("sequence_number"))
+	h.WriteToken(jsontext.Uint(f.SequenceNumber))
+	h.WriteToken(jsontext.String("retire_prior_to"))
+	h.WriteToken(jsontext.Uint(f.RetirePriorTo))
+	h.WriteToken(jsontext.String("length"))
+	h.WriteToken(jsontext.Int(int64(f.ConnectionID.Len())))
+	h.WriteToken(jsontext.String("connection_id"))
+	h.WriteToken(jsontext.String(f.ConnectionID.String()))
+	h.WriteToken(jsontext.String("stateless_reset_token"))
+	h.WriteToken(jsontext.String(hex.EncodeToString(f.StatelessResetToken[:])))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeRetireConnectionIDFrame(enc *jsontext.Encoder, f *RetireConnectionIDFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("retire_connection_id"))
+	h.WriteToken(jsontext.String("sequence_number"))
+	h.WriteToken(jsontext.Uint(f.SequenceNumber))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodePathChallengeFrame(enc *jsontext.Encoder, f *PathChallengeFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("path_challenge"))
+	h.WriteToken(jsontext.String("data"))
+	h.WriteToken(jsontext.String(hex.EncodeToString(f.Data[:])))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodePathResponseFrame(enc *jsontext.Encoder, f *PathResponseFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("path_response"))
+	h.WriteToken(jsontext.String("data"))
+	h.WriteToken(jsontext.String(hex.EncodeToString(f.Data[:])))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeConnectionCloseFrame(enc *jsontext.Encoder, f *ConnectionCloseFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("connection_close"))
+	h.WriteToken(jsontext.String("error_space"))
+	errorSpace := "transport"
+	if f.IsApplicationError {
+		errorSpace = "application"
+	}
+	h.WriteToken(jsontext.String(errorSpace))
+	errName := transportError(f.ErrorCode).String()
+	if len(errName) > 0 {
+		h.WriteToken(jsontext.String("error_code"))
+		h.WriteToken(jsontext.String(errName))
+	} else {
+		h.WriteToken(jsontext.String("error_code"))
+		h.WriteToken(jsontext.Uint(f.ErrorCode))
+	}
+	h.WriteToken(jsontext.String("raw_error_code"))
+	h.WriteToken(jsontext.Uint(f.ErrorCode))
+	h.WriteToken(jsontext.String("reason"))
+	h.WriteToken(jsontext.String(f.ReasonPhrase))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeHandshakeDoneFrame(enc *jsontext.Encoder, _ *HandshakeDoneFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("handshake_done"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeDatagramFrame(enc *jsontext.Encoder, f *DatagramFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("datagram"))
+	h.WriteToken(jsontext.String("length"))
+	h.WriteToken(jsontext.Int(f.Length))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeAckFrequencyFrame(enc *jsontext.Encoder, f *AckFrequencyFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("ack_frequency"))
+	h.WriteToken(jsontext.String("sequence_number"))
+	h.WriteToken(jsontext.Uint(f.SequenceNumber))
+	h.WriteToken(jsontext.String("ack_eliciting_threshold"))
+	h.WriteToken(jsontext.Uint(f.AckElicitingThreshold))
+	h.WriteToken(jsontext.String("request_max_ack_delay"))
+	h.WriteToken(jsontext.Float(milliseconds(f.RequestMaxAckDelay)))
+	h.WriteToken(jsontext.String("reordering_threshold"))
+	h.WriteToken(jsontext.Int(int64(f.ReorderingThreshold)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+func encodeImmediateAckFrame(enc *jsontext.Encoder, _ *ImmediateAckFrame) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("frame_type"))
+	h.WriteToken(jsontext.String("immediate_ack"))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlog/packet_header.go b/backend/vendor/github.com/quic-go/quic-go/qlog/packet_header.go
new file mode 100644
index 00000000..149ebcb6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlog/packet_header.go
@@ -0,0 +1,96 @@
+package qlog
+
+import (
+	"encoding/hex"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+type Token struct {
+	Raw []byte
+}
+
+func (t Token) encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("data"))
+	h.WriteToken(jsontext.String(hex.EncodeToString(t.Raw)))
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
+
+// PacketHeader is a QUIC packet header.
+type PacketHeader struct {
+	PacketType       PacketType
+	KeyPhaseBit      KeyPhaseBit
+	PacketNumber     PacketNumber
+	Version          Version
+	SrcConnectionID  ConnectionID
+	DestConnectionID ConnectionID
+	Token            *Token
+}
+
+func (h PacketHeader) encode(enc *jsontext.Encoder) error {
+	helper := encoderHelper{enc: enc}
+	helper.WriteToken(jsontext.BeginObject)
+	helper.WriteToken(jsontext.String("packet_type"))
+	helper.WriteToken(jsontext.String(string(h.PacketType)))
+	if h.PacketType != PacketTypeRetry && h.PacketType != PacketTypeVersionNegotiation && h.PacketType != "" &&
+		h.PacketNumber != protocol.InvalidPacketNumber {
+		helper.WriteToken(jsontext.String("packet_number"))
+		helper.WriteToken(jsontext.Int(int64(h.PacketNumber)))
+	}
+	if h.Version != 0 {
+		helper.WriteToken(jsontext.String("version"))
+		helper.WriteToken(jsontext.String(version(h.Version).String()))
+	}
+	if h.PacketType != PacketType1RTT {
+		helper.WriteToken(jsontext.String("scil"))
+		helper.WriteToken(jsontext.Int(int64(h.SrcConnectionID.Len())))
+		if h.SrcConnectionID.Len() > 0 {
+			helper.WriteToken(jsontext.String("scid"))
+			helper.WriteToken(jsontext.String(h.SrcConnectionID.String()))
+		}
+	}
+	helper.WriteToken(jsontext.String("dcil"))
+	helper.WriteToken(jsontext.Int(int64(h.DestConnectionID.Len())))
+	if h.DestConnectionID.Len() > 0 {
+		helper.WriteToken(jsontext.String("dcid"))
+		helper.WriteToken(jsontext.String(h.DestConnectionID.String()))
+	}
+	if h.KeyPhaseBit == KeyPhaseZero || h.KeyPhaseBit == KeyPhaseOne {
+		helper.WriteToken(jsontext.String("key_phase_bit"))
+		helper.WriteToken(jsontext.String(h.KeyPhaseBit.String()))
+	}
+	if h.Token != nil {
+		helper.WriteToken(jsontext.String("token"))
+		if err := h.Token.encode(enc); err != nil {
+			return err
+		}
+	}
+	helper.WriteToken(jsontext.EndObject)
+	return helper.err
+}
+
+type PacketHeaderVersionNegotiation struct {
+	SrcConnectionID  ArbitraryLenConnectionID
+	DestConnectionID ArbitraryLenConnectionID
+}
+
+func (h PacketHeaderVersionNegotiation) encode(enc *jsontext.Encoder) error {
+	helper := encoderHelper{enc: enc}
+	helper.WriteToken(jsontext.BeginObject)
+	helper.WriteToken(jsontext.String("packet_type"))
+	helper.WriteToken(jsontext.String("version_negotiation"))
+	helper.WriteToken(jsontext.String("scil"))
+	helper.WriteToken(jsontext.Int(int64(h.SrcConnectionID.Len())))
+	helper.WriteToken(jsontext.String("scid"))
+	helper.WriteToken(jsontext.String(h.SrcConnectionID.String()))
+	helper.WriteToken(jsontext.String("dcil"))
+	helper.WriteToken(jsontext.Int(int64(h.DestConnectionID.Len())))
+	helper.WriteToken(jsontext.String("dcid"))
+	helper.WriteToken(jsontext.String(h.DestConnectionID.String()))
+	helper.WriteToken(jsontext.EndObject)
+	return helper.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlog/qlog_dir.go b/backend/vendor/github.com/quic-go/quic-go/qlog/qlog_dir.go
new file mode 100644
index 00000000..83bb72b3
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlog/qlog_dir.go
@@ -0,0 +1,61 @@
+package qlog
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"slices"
+	"strings"
+
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// EventSchema is the qlog event schema for QUIC
+const EventSchema = "urn:ietf:params:qlog:events:quic-12"
+
+// DefaultConnectionTracer creates a qlog file in the qlog directory specified by the QLOGDIR environment variable.
+// File names are <odcid>_<perspective>.sqlog.
+// Returns nil if QLOGDIR is not set.
+func DefaultConnectionTracer(_ context.Context, isClient bool, connID ConnectionID) qlogwriter.Trace {
+	return defaultConnectionTracerWithSchemas(isClient, connID, []string{EventSchema})
+}
+
+func DefaultConnectionTracerWithSchemas(_ context.Context, isClient bool, connID ConnectionID, eventSchemas []string) qlogwriter.Trace {
+	if !slices.Contains(eventSchemas, EventSchema) {
+		eventSchemas = append([]string{EventSchema}, eventSchemas...)
+	}
+	return defaultConnectionTracerWithSchemas(isClient, connID, eventSchemas)
+}
+
+func defaultConnectionTracerWithSchemas(isClient bool, connID ConnectionID, eventSchemas []string) qlogwriter.Trace {
+	qlogDir := os.Getenv("QLOGDIR")
+	if qlogDir == "" {
+		return nil
+	}
+	if _, err := os.Stat(qlogDir); os.IsNotExist(err) {
+		if err := os.MkdirAll(qlogDir, 0o755); err != nil {
+			log.Fatalf("failed to create qlog dir %s: %v", qlogDir, err)
+		}
+	}
+	label := "server"
+	if isClient {
+		label = "client"
+	}
+	path := fmt.Sprintf("%s/%s_%s.sqlog", strings.TrimRight(qlogDir, "/"), connID, label)
+	f, err := os.Create(path)
+	if err != nil {
+		log.Printf("Failed to create qlog file %s: %s", path, err.Error())
+		return nil
+	}
+	fileSeq := qlogwriter.NewConnectionFileSeq(
+		utils.NewBufferedWriteCloser(bufio.NewWriter(f), f),
+		isClient,
+		connID,
+		eventSchemas,
+	)
+	go fileSeq.Run()
+	return fileSeq
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlog/types.go b/backend/vendor/github.com/quic-go/quic-go/qlog/types.go
new file mode 100644
index 00000000..97c7febe
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlog/types.go
@@ -0,0 +1,305 @@
+package qlog
+
+import (
+	"fmt"
+	"hash/crc32"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+)
+
+type (
+	ConnectionID             = protocol.ConnectionID
+	ArbitraryLenConnectionID = protocol.ArbitraryLenConnectionID
+	Version                  = protocol.Version
+	PacketNumber             = protocol.PacketNumber
+	EncryptionLevel          = protocol.EncryptionLevel
+	KeyPhaseBit              = protocol.KeyPhaseBit
+	KeyPhase                 = protocol.KeyPhase
+	StreamID                 = protocol.StreamID
+	TransportErrorCode       = qerr.TransportErrorCode
+	ApplicationErrorCode     = qerr.ApplicationErrorCode
+)
+
+const (
+	// KeyPhaseZero is key phase bit 0
+	KeyPhaseZero = protocol.KeyPhaseZero
+	// KeyPhaseOne is key phase bit 1
+	KeyPhaseOne = protocol.KeyPhaseOne
+)
+
+// ECN represents the Explicit Congestion Notification value.
+type ECN string
+
+const (
+	// ECNUnsupported means that no ECN value was set / received
+	ECNUnsupported ECN = ""
+	// ECTNot is Not-ECT
+	ECTNot ECN = "Not-ECT"
+	// ECT0 is ECT(0)
+	ECT0 ECN = "ECT(0)"
+	// ECT1 is ECT(1)
+	ECT1 ECN = "ECT(1)"
+	// ECNCE is CE
+	ECNCE ECN = "CE"
+)
+
+type Initiator string
+
+const (
+	InitiatorLocal  Initiator = "local"
+	InitiatorRemote Initiator = "remote"
+)
+
+type streamType protocol.StreamType
+
+func (s streamType) String() string {
+	switch protocol.StreamType(s) {
+	case protocol.StreamTypeUni:
+		return "unidirectional"
+	case protocol.StreamTypeBidi:
+		return "bidirectional"
+	default:
+		return "unknown stream type"
+	}
+}
+
+type version protocol.Version
+
+func (v version) String() string {
+	return fmt.Sprintf("%x", uint32(v))
+}
+
+func encLevelToPacketNumberSpace(encLevel protocol.EncryptionLevel) string {
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return "initial"
+	case protocol.EncryptionHandshake:
+		return "handshake"
+	case protocol.Encryption0RTT, protocol.Encryption1RTT:
+		return "application_data"
+	default:
+		return "unknown encryption level"
+	}
+}
+
+// KeyType represents the type of cryptographic key used in QUIC connections.
+type KeyType string
+
+const (
+	// KeyTypeServerInitial represents the server's initial secret key.
+	KeyTypeServerInitial KeyType = "server_initial_secret"
+	// KeyTypeClientInitial represents the client's initial secret key.
+	KeyTypeClientInitial KeyType = "client_initial_secret"
+	// KeyTypeServerHandshake represents the server's handshake secret key.
+	KeyTypeServerHandshake KeyType = "server_handshake_secret"
+	// KeyTypeClientHandshake represents the client's handshake secret key.
+	KeyTypeClientHandshake KeyType = "client_handshake_secret"
+	// KeyTypeServer0RTT represents the server's 0-RTT secret key.
+	KeyTypeServer0RTT KeyType = "server_0rtt_secret"
+	// KeyTypeClient0RTT represents the client's 0-RTT secret key.
+	KeyTypeClient0RTT KeyType = "client_0rtt_secret"
+	// KeyTypeServer1RTT represents the server's 1-RTT secret key.
+	KeyTypeServer1RTT KeyType = "server_1rtt_secret"
+	// KeyTypeClient1RTT represents the client's 1-RTT secret key.
+	KeyTypeClient1RTT KeyType = "client_1rtt_secret"
+)
+
+// KeyUpdateTrigger describes what caused a key update event.
+type KeyUpdateTrigger string
+
+const (
+	// KeyUpdateTLS indicates the key update was triggered by TLS.
+	KeyUpdateTLS KeyUpdateTrigger = "tls"
+	// KeyUpdateRemote indicates the key update was triggered by the remote peer.
+	KeyUpdateRemote KeyUpdateTrigger = "remote_update"
+	// KeyUpdateLocal indicates the key update was triggered locally.
+	KeyUpdateLocal KeyUpdateTrigger = "local_update"
+)
+
+type transportError uint64
+
+func (e transportError) String() string {
+	switch qerr.TransportErrorCode(e) {
+	case qerr.NoError:
+		return "no_error"
+	case qerr.InternalError:
+		return "internal_error"
+	case qerr.ConnectionRefused:
+		return "connection_refused"
+	case qerr.FlowControlError:
+		return "flow_control_error"
+	case qerr.StreamLimitError:
+		return "stream_limit_error"
+	case qerr.StreamStateError:
+		return "stream_state_error"
+	case qerr.FinalSizeError:
+		return "final_size_error"
+	case qerr.FrameEncodingError:
+		return "frame_encoding_error"
+	case qerr.TransportParameterError:
+		return "transport_parameter_error"
+	case qerr.ConnectionIDLimitError:
+		return "connection_id_limit_error"
+	case qerr.ProtocolViolation:
+		return "protocol_violation"
+	case qerr.InvalidToken:
+		return "invalid_token"
+	case qerr.ApplicationErrorErrorCode:
+		return "application_error"
+	case qerr.CryptoBufferExceeded:
+		return "crypto_buffer_exceeded"
+	case qerr.KeyUpdateError:
+		return "key_update_error"
+	case qerr.AEADLimitReached:
+		return "aead_limit_reached"
+	case qerr.NoViablePathError:
+		return "no_viable_path"
+	default:
+		return ""
+	}
+}
+
+type PacketType string
+
+const (
+	// PacketTypeInitial represents an Initial packet
+	PacketTypeInitial PacketType = "initial"
+	// PacketTypeHandshake represents a Handshake packet
+	PacketTypeHandshake PacketType = "handshake"
+	// PacketTypeRetry represents a Retry packet
+	PacketTypeRetry PacketType = "retry"
+	// PacketType0RTT represents a 0-RTT packet
+	PacketType0RTT PacketType = "0RTT"
+	// PacketTypeVersionNegotiation represents a Version Negotiation packet
+	PacketTypeVersionNegotiation PacketType = "version_negotiation"
+	// PacketTypeStatelessReset represents a Stateless Reset packet
+	PacketTypeStatelessReset PacketType = "stateless_reset"
+	// PacketType1RTT represents a 1-RTT packet
+	PacketType1RTT PacketType = "1RTT"
+	// // PacketTypeNotDetermined represents a packet type that could not be determined
+	// PacketTypeNotDetermined packetType = ""
+)
+
+func EncryptionLevelToPacketType(l EncryptionLevel) PacketType {
+	switch l {
+	case protocol.EncryptionInitial:
+		return PacketTypeInitial
+	case protocol.EncryptionHandshake:
+		return PacketTypeHandshake
+	case protocol.Encryption0RTT:
+		return PacketType0RTT
+	case protocol.Encryption1RTT:
+		return PacketType1RTT
+	default:
+		panic(fmt.Sprintf("unknown encryption level: %d", l))
+	}
+}
+
+type PacketLossReason string
+
+const (
+	// PacketLossReorderingThreshold is used when a packet is declared lost due to reordering threshold
+	PacketLossReorderingThreshold PacketLossReason = "reordering_threshold"
+	// PacketLossTimeThreshold is used when a packet is declared lost due to time threshold
+	PacketLossTimeThreshold PacketLossReason = "time_threshold"
+)
+
+type PacketDropReason string
+
+const (
+	// PacketDropKeyUnavailable is used when a packet is dropped because keys are unavailable
+	PacketDropKeyUnavailable PacketDropReason = "key_unavailable"
+	// PacketDropUnknownConnectionID is used when a packet is dropped because the connection ID is unknown
+	PacketDropUnknownConnectionID PacketDropReason = "unknown_connection_id"
+	// PacketDropHeaderParseError is used when a packet is dropped because header parsing failed
+	PacketDropHeaderParseError PacketDropReason = "header_parse_error"
+	// PacketDropPayloadDecryptError is used when a packet is dropped because decrypting the payload failed
+	PacketDropPayloadDecryptError PacketDropReason = "payload_decrypt_error"
+	// PacketDropProtocolViolation is used when a packet is dropped due to a protocol violation
+	PacketDropProtocolViolation PacketDropReason = "protocol_violation"
+	// PacketDropDOSPrevention is used when a packet is dropped to mitigate a DoS attack
+	PacketDropDOSPrevention PacketDropReason = "dos_prevention"
+	// PacketDropUnsupportedVersion is used when a packet is dropped because the version is not supported
+	PacketDropUnsupportedVersion PacketDropReason = "unsupported_version"
+	// PacketDropUnexpectedPacket is used when an unexpected packet is received
+	PacketDropUnexpectedPacket PacketDropReason = "unexpected_packet"
+	// PacketDropUnexpectedSourceConnectionID is used when a packet with an unexpected source connection ID is received
+	PacketDropUnexpectedSourceConnectionID PacketDropReason = "unexpected_source_connection_id"
+	// PacketDropUnexpectedVersion is used when a packet with an unexpected version is received
+	PacketDropUnexpectedVersion PacketDropReason = "unexpected_version"
+	// PacketDropDuplicate is used when a duplicate packet is received
+	PacketDropDuplicate PacketDropReason = "duplicate"
+)
+
+type LossTimerUpdateType string
+
+const (
+	LossTimerUpdateTypeSet       LossTimerUpdateType = "set"
+	LossTimerUpdateTypeExpired   LossTimerUpdateType = "expired"
+	LossTimerUpdateTypeCancelled LossTimerUpdateType = "cancelled"
+)
+
+type TimerType string
+
+const (
+	// TimerTypeACK represents an ACK timer
+	TimerTypeACK TimerType = "ack"
+	// TimerTypePTO represents a PTO (Probe Timeout) timer
+	TimerTypePTO TimerType = "pto"
+	// TimerTypePathProbe represents a path probe timer
+	TimerTypePathProbe TimerType = "path_probe"
+)
+
+type CongestionState string
+
+const (
+	// CongestionStateSlowStart is the slow start phase of Reno / Cubic
+	CongestionStateSlowStart CongestionState = "slow_start"
+	// CongestionStateCongestionAvoidance is the congestion avoidance phase of Reno / Cubic
+	CongestionStateCongestionAvoidance CongestionState = "congestion_avoidance"
+	// CongestionStateRecovery is the recovery phase of Reno / Cubic
+	CongestionStateRecovery CongestionState = "recovery"
+	// CongestionStateApplicationLimited means that the congestion controller is application limited
+	CongestionStateApplicationLimited CongestionState = "application_limited"
+)
+
+func (s CongestionState) String() string {
+	return string(s)
+}
+
+// ECNState is the state of the ECN state machine (see Appendix A.4 of RFC 9000)
+type ECNState string
+
+const (
+	// ECNStateTesting is the testing state
+	ECNStateTesting ECNState = "testing"
+	// ECNStateUnknown is the unknown state
+	ECNStateUnknown ECNState = "unknown"
+	// ECNStateFailed is the failed state
+	ECNStateFailed ECNState = "failed"
+	// ECNStateCapable is the capable state
+	ECNStateCapable ECNState = "capable"
+)
+
+type ConnectionCloseTrigger string
+
+const (
+	// IdleTimeout indicates the connection was closed due to idle timeout
+	ConnectionCloseTriggerIdleTimeout ConnectionCloseTrigger = "idle_timeout"
+	// Application indicates the connection was closed by the application
+	ConnectionCloseTriggerApplication ConnectionCloseTrigger = "application"
+	// VersionMismatch indicates the connection was closed due to a QUIC version mismatch
+	ConnectionCloseTriggerVersionMismatch ConnectionCloseTrigger = "version_mismatch"
+	// StatelessReset indicates the connection was closed due to receiving a stateless reset from the peer
+	ConnectionCloseTriggerStatelessReset ConnectionCloseTrigger = "stateless_reset"
+)
+
+// DatagramPayloadChecksum is the CRC32c checksum of a UDP datagram payload.
+// ponytail: zero means absent; use an optional value if zero-valued checksums need to be logged.
+type DatagramPayloadChecksum uint32
+
+// CalculateDatagramPayloadChecksum computes the checksum of a UDP datagram payload.
+func CalculateDatagramPayloadChecksum(payload []byte) DatagramPayloadChecksum {
+	return DatagramPayloadChecksum(crc32.Checksum(payload, crc32.MakeTable(crc32.Castagnoli)))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlogwriter/jsontext/encoder.go b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/jsontext/encoder.go
new file mode 100644
index 00000000..4f715bbd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/jsontext/encoder.go
@@ -0,0 +1,324 @@
+// Package jsontext provides a fast JSON encoder providing only the necessary features
+// for qlog encoding. No efforts are made to add any features beyond qlog's requirements.
+//
+// The API aims to be compatible with the standard library's encoding/json/jsontext package.
+package jsontext
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"unsafe"
+)
+
+type kind uint8
+
+const (
+	kindString kind = iota
+	kindInt
+	kindUint
+	kindFloat
+	kindBool
+	kindNull
+	kindObjectStart
+	kindObjectEnd
+	kindArrayStart
+	kindArrayEnd
+)
+
+// Token represents a JSON token.
+type Token struct {
+	kind kind
+	str  string
+	i64  int64
+	u64  uint64
+	f64  float64
+	b    bool
+}
+
+// String creates a string token.
+func String(s string) Token {
+	return Token{kind: kindString, str: s}
+}
+
+// Int creates an int token.
+func Int(i int64) Token {
+	return Token{kind: kindInt, i64: i}
+}
+
+// Uint creates a uint token.
+func Uint(u uint64) Token {
+	return Token{kind: kindUint, u64: u}
+}
+
+// Float creates a float token.
+func Float(f float64) Token {
+	return Token{kind: kindFloat, f64: f}
+}
+
+// Bool creates a bool token.
+func Bool(b bool) Token {
+	return Token{kind: kindBool, b: b}
+}
+
+// Null is a null token.
+var Null Token = Token{kind: kindNull}
+
+// BeginObject is the begin object token.
+var BeginObject Token = Token{kind: kindObjectStart}
+
+// EndObject is the end object token.
+var EndObject Token = Token{kind: kindObjectEnd}
+
+// BeginArray is the begin array token.
+var BeginArray Token = Token{kind: kindArrayStart}
+
+// EndArray is the end array token.
+var EndArray Token = Token{kind: kindArrayEnd}
+
+// True is a true token.
+var True Token = Bool(true)
+
+// False is a false token.
+var False Token = Bool(false)
+
+var hexDigits = [16]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
+
+var (
+	commaByte       = []byte(",")
+	quoteByte       = []byte(`"`)
+	colonByte       = []byte(":")
+	trueByte        = []byte("true")
+	falseByte       = []byte("false")
+	nullByte        = []byte("null")
+	openObjectByte  = []byte("{")
+	closeObjectByte = []byte("}")
+	openArrayByte   = []byte("[")
+	closeArrayByte  = []byte("]")
+	newlineByte     = []byte("\n")
+	escapeQuote     = []byte(`\"`)
+	escapeBackslash = []byte(`\\`)
+	escapeBackspace = []byte(`\b`)
+	escapeFormfeed  = []byte(`\f`)
+	escapeNewline   = []byte(`\n`)
+	escapeCarriage  = []byte(`\r`)
+	escapeTab       = []byte(`\t`)
+	escapeUnicode   = []byte(`\u00`)
+)
+
+type context struct {
+	isObject   bool
+	needsComma bool
+	expectKey  bool
+}
+
+// Encoder encodes JSON to an io.Writer.
+type Encoder struct {
+	w     io.Writer
+	buf   [64]byte // scratch buffer for number formatting
+	stack []context
+}
+
+// NewEncoder creates a new Encoder.
+func NewEncoder(w io.Writer) *Encoder {
+	stack := make([]context, 0, 8)
+	stack = append(stack, context{isObject: false, needsComma: false, expectKey: false})
+	return &Encoder{
+		w:     w,
+		stack: stack,
+	}
+}
+
+// WriteToken writes a token to the encoder.
+func (e *Encoder) WriteToken(t Token) error {
+	if len(e.stack) == 0 {
+		return fmt.Errorf("empty stack")
+	}
+	curr := &e.stack[len(e.stack)-1]
+	isClosing := t.kind == kindObjectEnd || t.kind == kindArrayEnd
+	if !isClosing && curr.needsComma {
+		if _, err := e.w.Write(commaByte); err != nil {
+			return err
+		}
+		curr.needsComma = false
+	}
+	var err error
+	switch t.kind {
+	case kindString:
+		data := stringToBytes(t.str)
+		needsEscape := false
+		for _, b := range data {
+			if b == '"' || b == '\\' || b < 0x20 {
+				needsEscape = true
+				break
+			}
+		}
+		if !needsEscape {
+			if _, err = e.w.Write(quoteByte); err != nil {
+				return err
+			}
+			if _, err = e.w.Write(data); err != nil {
+				return err
+			}
+			if _, err = e.w.Write(quoteByte); err != nil {
+				return err
+			}
+		} else {
+			if _, err = e.w.Write(quoteByte); err != nil {
+				return err
+			}
+			for i := 0; i < len(t.str); i++ {
+				c := t.str[i]
+				switch c {
+				case '"':
+					if _, err = e.w.Write(escapeQuote); err != nil {
+						return err
+					}
+				case '\\':
+					if _, err = e.w.Write(escapeBackslash); err != nil {
+						return err
+					}
+				case '\b':
+					if _, err = e.w.Write(escapeBackspace); err != nil {
+						return err
+					}
+				case '\f':
+					if _, err = e.w.Write(escapeFormfeed); err != nil {
+						return err
+					}
+				case '\n':
+					if _, err = e.w.Write(escapeNewline); err != nil {
+						return err
+					}
+				case '\r':
+					if _, err = e.w.Write(escapeCarriage); err != nil {
+						return err
+					}
+				case '\t':
+					if _, err = e.w.Write(escapeTab); err != nil {
+						return err
+					}
+				default:
+					if c < 0x20 {
+						if _, err = e.w.Write(escapeUnicode); err != nil {
+							return err
+						}
+						if _, err = e.w.Write([]byte{hexDigits[c>>4], hexDigits[c&0xf]}); err != nil {
+							return err
+						}
+					} else {
+						if _, err = e.w.Write([]byte{c}); err != nil {
+							return err
+						}
+					}
+				}
+			}
+			if _, err = e.w.Write(quoteByte); err != nil {
+				return err
+			}
+		}
+		if curr.isObject {
+			if curr.expectKey {
+				// key
+				if _, err = e.w.Write(colonByte); err != nil {
+					return err
+				}
+				curr.expectKey = false
+				return nil // do not call afterValue for keys
+			} else {
+				// value
+				e.afterValue()
+			}
+		} else {
+			e.afterValue()
+		}
+	case kindInt:
+		b := strconv.AppendInt(e.buf[:0], t.i64, 10)
+		if _, err = e.w.Write(b); err != nil {
+			return err
+		}
+		e.afterValue()
+	case kindUint:
+		b := strconv.AppendUint(e.buf[:0], t.u64, 10)
+		if _, err = e.w.Write(b); err != nil {
+			return err
+		}
+		e.afterValue()
+	case kindFloat:
+		b := strconv.AppendFloat(e.buf[:0], t.f64, 'g', -1, 64)
+		if _, err = e.w.Write(b); err != nil {
+			return err
+		}
+		e.afterValue()
+	case kindBool:
+		if t.b {
+			if _, err = e.w.Write(trueByte); err != nil {
+				return err
+			}
+		} else {
+			if _, err = e.w.Write(falseByte); err != nil {
+				return err
+			}
+		}
+		e.afterValue()
+	case kindNull:
+		if _, err = e.w.Write(nullByte); err != nil {
+			return err
+		}
+		e.afterValue()
+	case kindObjectStart:
+		if _, err = e.w.Write(openObjectByte); err != nil {
+			return err
+		}
+		e.stack = append(e.stack, context{isObject: true, needsComma: false, expectKey: true})
+		return nil
+	case kindObjectEnd:
+		if _, err = e.w.Write(closeObjectByte); err != nil {
+			return err
+		}
+		e.stack = e.stack[:len(e.stack)-1]
+		e.afterValue()
+		if len(e.stack) == 1 {
+			if _, err = e.w.Write(newlineByte); err != nil {
+				return err
+			}
+		}
+		return nil
+	case kindArrayStart:
+		if _, err = e.w.Write(openArrayByte); err != nil {
+			return err
+		}
+		e.stack = append(e.stack, context{isObject: false, needsComma: false, expectKey: false})
+		return nil
+	case kindArrayEnd:
+		if _, err = e.w.Write(closeArrayByte); err != nil {
+			return err
+		}
+		e.stack = e.stack[:len(e.stack)-1]
+		e.afterValue()
+		if len(e.stack) == 1 {
+			if _, err = e.w.Write(newlineByte); err != nil {
+				return err
+			}
+		}
+		return nil
+	default:
+		return fmt.Errorf("unknown token kind")
+	}
+	return err
+}
+
+// afterValue updates the state after encoding a value
+func (e *Encoder) afterValue() {
+	if len(e.stack) > 1 {
+		curr := &e.stack[len(e.stack)-1]
+		curr.needsComma = true
+		if curr.isObject {
+			curr.expectKey = true
+		}
+	}
+}
+
+func stringToBytes(s string) []byte {
+	return unsafe.Slice(unsafe.StringData(s), len(s))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlogwriter/trace.go b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/trace.go
new file mode 100644
index 00000000..eebcbaad
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/trace.go
@@ -0,0 +1,124 @@
+package qlogwriter
+
+import (
+	"runtime/debug"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+type ConnectionID = protocol.ConnectionID
+
+// Setting of this only works when quic-go is used as a library.
+// When building a binary from this repository, the version can be set using the following go build flag:
+// -ldflags="-X github.com/quic-go/quic-go/qlogwriter.quicGoVersion=foobar"
+var quicGoVersion = "(devel)"
+
+func init() {
+	if quicGoVersion != "(devel)" { // variable set by ldflags
+		return
+	}
+	info, ok := debug.ReadBuildInfo()
+	if !ok { // no build info available. This happens when quic-go is not used as a library.
+		return
+	}
+	for _, d := range info.Deps {
+		if d.Path == "github.com/quic-go/quic-go" {
+			quicGoVersion = d.Version
+			if d.Replace != nil {
+				if len(d.Replace.Version) > 0 {
+					quicGoVersion = d.Version
+				} else {
+					quicGoVersion += " (replaced)"
+				}
+			}
+			break
+		}
+	}
+}
+
+type encoderHelper struct {
+	enc *jsontext.Encoder
+	err error
+}
+
+func (h *encoderHelper) WriteToken(t jsontext.Token) {
+	if h.err != nil {
+		return
+	}
+	h.err = h.enc.WriteToken(t)
+}
+
+type traceHeader struct {
+	VantagePointType string
+	GroupID          *ConnectionID
+	ReferenceTime    time.Time
+	EventSchemas     []string
+}
+
+func (l traceHeader) Encode(enc *jsontext.Encoder) error {
+	h := encoderHelper{enc: enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("file_schema"))
+	h.WriteToken(jsontext.String("urn:ietf:params:qlog:file:sequential"))
+	h.WriteToken(jsontext.String("serialization_format"))
+	h.WriteToken(jsontext.String("application/qlog+json-seq"))
+	h.WriteToken(jsontext.String("title"))
+	h.WriteToken(jsontext.String("quic-go qlog"))
+	h.WriteToken(jsontext.String("code_version"))
+	h.WriteToken(jsontext.String(quicGoVersion))
+
+	h.WriteToken(jsontext.String("trace"))
+	// trace
+	h.WriteToken(jsontext.BeginObject)
+	if len(l.EventSchemas) > 0 {
+		h.WriteToken(jsontext.String("event_schemas"))
+		h.WriteToken(jsontext.BeginArray)
+		for _, schema := range l.EventSchemas {
+			h.WriteToken(jsontext.String(schema))
+		}
+		h.WriteToken(jsontext.EndArray)
+	}
+
+	h.WriteToken(jsontext.String("vantage_point"))
+	// -- vantage_point
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("type"))
+	h.WriteToken(jsontext.String(l.VantagePointType))
+	// -- end vantage_point
+	h.WriteToken(jsontext.EndObject)
+
+	h.WriteToken(jsontext.String("common_fields"))
+	// -- common_fields
+	h.WriteToken(jsontext.BeginObject)
+	if l.GroupID != nil {
+		h.WriteToken(jsontext.String("group_id"))
+		h.WriteToken(jsontext.String(l.GroupID.String()))
+	}
+	h.WriteToken(jsontext.String("reference_time"))
+	// ---- reference_time
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("clock_type"))
+	h.WriteToken(jsontext.String("monotonic"))
+	h.WriteToken(jsontext.String("epoch"))
+	h.WriteToken(jsontext.String("unknown"))
+	h.WriteToken(jsontext.String("wall_clock_time"))
+	h.WriteToken(jsontext.String(l.ReferenceTime.Format(time.RFC3339Nano)))
+	// ---- end reference_time
+	h.WriteToken(jsontext.EndObject)
+	// -- end common_fields
+	h.WriteToken(jsontext.EndObject)
+	// end trace
+	h.WriteToken(jsontext.EndObject)
+
+	// The following fields are not required by the qlog draft anymore,
+	// but qvis still requires them to be present.
+	h.WriteToken(jsontext.String("qlog_format"))
+	h.WriteToken(jsontext.String("JSON-SEQ"))
+	h.WriteToken(jsontext.String("qlog_version"))
+	h.WriteToken(jsontext.String("0.3"))
+
+	h.WriteToken(jsontext.EndObject)
+	return h.err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/qlogwriter/writer.go b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/writer.go
new file mode 100644
index 00000000..d728f596
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/qlogwriter/writer.go
@@ -0,0 +1,229 @@
+package qlogwriter
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"slices"
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/qlogwriter/jsontext"
+)
+
+// Trace represents a qlog trace that can have multiple event producers.
+// Each producer can record events to the trace independently.
+// When the last producer is closed, the underlying trace is closed as well.
+type Trace interface {
+	// AddProducer creates a new Recorder for this trace.
+	// Each Recorder can record events independently.
+	AddProducer() Recorder
+
+	// SupportsSchemas returns true if the trace supports the given schema.
+	SupportsSchemas(schema string) bool
+}
+
+// Recorder is used to record events to a qlog trace.
+// It is safe for concurrent use by multiple goroutines.
+type Recorder interface {
+	// RecordEvent records a single Event to the trace.
+	// It must not be called after Close.
+	RecordEvent(Event)
+	// Close signals that this producer is done recording events.
+	// When all producers are closed, the underlying trace is closed.
+	// It must not be called concurrently with RecordEvent.
+	io.Closer
+}
+
+// Event represents a qlog event that can be encoded to JSON.
+// Each event must provide its name and a method to encode itself using a jsontext.Encoder.
+type Event interface {
+	// Name returns the name of the event, as it should appear in the qlog output
+	Name() string
+	// Encode writes the event's data to the provided jsontext.Encoder
+	Encode(encoder *jsontext.Encoder, eventTime time.Time) error
+}
+
+// RecordSeparator is the record separator byte for the JSON-SEQ format
+const RecordSeparator byte = 0x1e
+
+var recordSeparator = []byte{RecordSeparator}
+
+type event struct {
+	Time  time.Time
+	Event Event
+}
+
+const eventChanSize = 50
+
+// FileSeq represents a qlog trace using the JSON-SEQ format,
+// https://www.ietf.org/archive/id/draft-ietf-quic-qlog-main-schema-12.html#section-5
+// qlog event producers can be created by calling AddProducer.
+// The underlying io.WriteCloser is closed when the last producer is removed.
+type FileSeq struct {
+	w             io.WriteCloser
+	enc           *jsontext.Encoder
+	referenceTime time.Time
+
+	runStopped chan struct{}
+	encodeErr  error
+	events     chan event
+	done       chan struct{}
+
+	mx        sync.Mutex
+	producers int
+	closed    bool
+
+	eventSchemas []string
+}
+
+var _ Trace = &FileSeq{}
+
+// NewFileSeq creates a new JSON-SEQ qlog trace to log transport events.
+func NewFileSeq(w io.WriteCloser) *FileSeq {
+	return newFileSeq(w, "transport", nil, nil)
+}
+
+// NewConnectionFileSeq creates a new qlog trace to log connection events.
+func NewConnectionFileSeq(w io.WriteCloser, isClient bool, odcid ConnectionID, eventSchemas []string) *FileSeq {
+	pers := "server"
+	if isClient {
+		pers = "client"
+	}
+	return newFileSeq(w, pers, &odcid, eventSchemas)
+}
+
+func newFileSeq(w io.WriteCloser, pers string, odcid *ConnectionID, eventSchemas []string) *FileSeq {
+	now := time.Now()
+	buf := &bytes.Buffer{}
+	enc := jsontext.NewEncoder(buf)
+	if _, err := buf.Write(recordSeparator); err != nil {
+		panic(fmt.Sprintf("qlog encoding into a bytes.Buffer failed: %s", err))
+	}
+	if err := (&traceHeader{
+		VantagePointType: pers,
+		GroupID:          odcid,
+		ReferenceTime:    now,
+		EventSchemas:     eventSchemas,
+	}).Encode(enc); err != nil {
+		panic(fmt.Sprintf("qlog encoding into a bytes.Buffer failed: %s", err))
+	}
+	_, encodeErr := w.Write(buf.Bytes())
+
+	return &FileSeq{
+		w:             w,
+		referenceTime: now,
+		enc:           jsontext.NewEncoder(w),
+		runStopped:    make(chan struct{}),
+		encodeErr:     encodeErr,
+		events:        make(chan event, eventChanSize),
+		done:          make(chan struct{}),
+		eventSchemas:  eventSchemas,
+	}
+}
+
+func (t *FileSeq) SupportsSchemas(schema string) bool {
+	return slices.Contains(t.eventSchemas, schema)
+}
+
+func (t *FileSeq) AddProducer() Recorder {
+	t.mx.Lock()
+	defer t.mx.Unlock()
+	if t.closed {
+		return nil
+	}
+
+	t.producers++
+
+	return &Writer{t: t}
+}
+
+func (t *FileSeq) record(eventTime time.Time, details Event) {
+	t.mx.Lock()
+
+	if t.closed {
+		t.mx.Unlock()
+		return
+	}
+	t.mx.Unlock()
+
+	t.events <- event{Time: eventTime, Event: details}
+}
+
+func (t *FileSeq) Run() {
+	defer close(t.runStopped)
+
+	for {
+		select {
+		case <-t.done:
+			for {
+				select {
+				case e := <-t.events:
+					t.encodeEvent(e)
+				default:
+					if t.encodeErr != nil {
+						log.Printf("exporting qlog failed: %s\n", t.encodeErr)
+					}
+					return
+				}
+			}
+		case e := <-t.events:
+			t.encodeEvent(e)
+		}
+	}
+}
+
+func (t *FileSeq) encodeEvent(e event) {
+	if t.encodeErr != nil {
+		return
+	}
+	if _, err := t.w.Write(recordSeparator); err != nil {
+		t.encodeErr = err
+		return
+	}
+	h := encoderHelper{enc: t.enc}
+	h.WriteToken(jsontext.BeginObject)
+	h.WriteToken(jsontext.String("time"))
+	h.WriteToken(jsontext.Float(float64(e.Time.Sub(t.referenceTime).Nanoseconds()) / 1e6))
+	h.WriteToken(jsontext.String("name"))
+	h.WriteToken(jsontext.String(e.Event.Name()))
+	h.WriteToken(jsontext.String("data"))
+	if err := e.Event.Encode(t.enc, e.Time); err != nil {
+		t.encodeErr = err
+		return
+	}
+	h.WriteToken(jsontext.EndObject)
+	if h.err != nil {
+		t.encodeErr = h.err
+	}
+}
+
+func (t *FileSeq) removeProducer() {
+	t.mx.Lock()
+	t.producers--
+	last := t.producers == 0
+	if last {
+		t.closed = true
+	}
+	t.mx.Unlock()
+
+	if last {
+		close(t.done)
+		<-t.runStopped // wait for Run to drain and exit
+		_ = t.w.Close()
+	}
+}
+
+type Writer struct {
+	t *FileSeq
+}
+
+func (w *Writer) Close() error {
+	w.t.removeProducer()
+	return nil
+}
+
+func (w *Writer) RecordEvent(ev Event) {
+	w.t.record(time.Now(), ev)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/quicvarint/io.go b/backend/vendor/github.com/quic-go/quic-go/quicvarint/io.go
new file mode 100644
index 00000000..8ea10acd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/quicvarint/io.go
@@ -0,0 +1,98 @@
+package quicvarint
+
+import (
+	"bytes"
+	"io"
+)
+
+// Reader implements both the io.ByteReader and io.Reader interfaces.
+type Reader interface {
+	io.ByteReader
+	io.Reader
+}
+
+var _ Reader = &bytes.Reader{}
+
+// A Peeker can peek bytes without consuming them.
+type Peeker interface {
+	Peek(b []byte) (int, error)
+}
+
+// Peek reads a number in the QUIC varint format without consuming bytes.
+func Peek(p Peeker) (uint64, error) {
+	var b [8]byte
+
+	// first peek 1 byte to determine the varint length
+	if _, err := p.Peek(b[:1]); err != nil {
+		return 0, err
+	}
+
+	l := 1 << (b[0] >> 6) // 1, 2, 4, or 8 bytes
+	if l == 1 {
+		return uint64(b[0] & 0b00111111), nil
+	}
+	if _, err := p.Peek(b[:l]); err != nil {
+		return 0, err
+	}
+	val, _, err := Parse(b[:l])
+	return val, err
+}
+
+type byteReader struct {
+	io.Reader
+}
+
+var _ Reader = &byteReader{}
+
+// NewReader returns a Reader for r.
+// If r already implements both io.ByteReader and io.Reader, NewReader returns r.
+// Otherwise, r is wrapped to add the missing interfaces.
+func NewReader(r io.Reader) Reader {
+	if r, ok := r.(Reader); ok {
+		return r
+	}
+	return &byteReader{r}
+}
+
+func (r *byteReader) ReadByte() (byte, error) {
+	var b [1]byte
+	var n int
+	var err error
+	for n == 0 && err == nil {
+		n, err = r.Read(b[:])
+	}
+
+	if n == 1 && err == io.EOF {
+		err = nil
+	}
+	return b[0], err
+}
+
+// Writer implements both the io.ByteWriter and io.Writer interfaces.
+type Writer interface {
+	io.ByteWriter
+	io.Writer
+}
+
+var _ Writer = &bytes.Buffer{}
+
+type byteWriter struct {
+	io.Writer
+}
+
+var _ Writer = &byteWriter{}
+
+// NewWriter returns a Writer for w.
+// If w already implements both io.ByteWriter and io.Writer, NewWriter returns w.
+// Otherwise, w is wrapped to add the missing interfaces.
+func NewWriter(w io.Writer) Writer {
+	if w, ok := w.(Writer); ok {
+		return w
+	}
+	return &byteWriter{w}
+}
+
+func (w *byteWriter) WriteByte(c byte) error {
+	_, err := w.Write([]byte{c})
+	return err
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/quicvarint/varint.go b/backend/vendor/github.com/quic-go/quic-go/quicvarint/varint.go
new file mode 100644
index 00000000..52fb153c
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/quicvarint/varint.go
@@ -0,0 +1,180 @@
+package quicvarint
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+)
+
+// taken from the QUIC draft
+const (
+	// Min is the minimum value allowed for a QUIC varint.
+	Min = 0
+
+	// Max is the maximum allowed value for a QUIC varint (2^62-1).
+	Max = maxVarInt8
+
+	maxVarInt1 = 63
+	maxVarInt2 = 16383
+	maxVarInt4 = 1073741823
+	maxVarInt8 = 4611686018427387903
+)
+
+type varintLengthError struct {
+	Num uint64
+}
+
+func (e *varintLengthError) Error() string {
+	return fmt.Sprintf("value doesn't fit into 62 bits: %d", e.Num)
+}
+
+// Read reads a number in the QUIC varint format from r.
+func Read(r io.ByteReader) (uint64, error) {
+	firstByte, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	// the first two bits of the first byte encode the length
+	l := 1 << ((firstByte & 0xc0) >> 6)
+	b1 := firstByte & (0xff - 0xc0)
+	if l == 1 {
+		return uint64(b1), nil
+	}
+	b2, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	if l == 2 {
+		return uint64(b2) + uint64(b1)<<8, nil
+	}
+	b3, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	b4, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	if l == 4 {
+		return uint64(b4) + uint64(b3)<<8 + uint64(b2)<<16 + uint64(b1)<<24, nil
+	}
+	b5, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	b6, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	b7, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	b8, err := r.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	return uint64(b8) + uint64(b7)<<8 + uint64(b6)<<16 + uint64(b5)<<24 + uint64(b4)<<32 + uint64(b3)<<40 + uint64(b2)<<48 + uint64(b1)<<56, nil
+}
+
+// Parse reads a number in the QUIC varint format.
+// It returns the number of bytes consumed.
+func Parse(b []byte) (uint64 /* value */, int /* bytes consumed */, error) {
+	if len(b) == 0 {
+		return 0, 0, io.EOF
+	}
+
+	first := b[0]
+	switch first >> 6 {
+	case 0: // 1-byte encoding: 00xxxxxx
+		return uint64(first & 0b00111111), 1, nil
+	case 1: // 2-byte encoding: 01xxxxxx
+		if len(b) < 2 {
+			return 0, 0, io.ErrUnexpectedEOF
+		}
+		return uint64(b[1]) | uint64(first&0b00111111)<<8, 2, nil
+	case 2: // 4-byte encoding: 10xxxxxx
+		if len(b) < 4 {
+			return 0, 0, io.ErrUnexpectedEOF
+		}
+		return uint64(b[3]) | uint64(b[2])<<8 | uint64(b[1])<<16 | uint64(first&0b00111111)<<24, 4, nil
+	case 3: // 8-byte encoding: 00xxxxxx
+		if len(b) < 8 {
+			return 0, 0, io.ErrUnexpectedEOF
+		}
+		// binary.BigEndian.Uint64 only reads the first 8 bytes. Passing the full slice avoids slicing overhead.
+		return binary.BigEndian.Uint64(b) & 0x3fffffffffffffff, 8, nil
+	}
+
+	panic("unreachable")
+}
+
+// Append appends i in the QUIC varint format.
+func Append(b []byte, i uint64) []byte {
+	if i <= maxVarInt1 {
+		return append(b, uint8(i))
+	}
+	if i <= maxVarInt2 {
+		return append(b, []byte{uint8(i>>8) | 0x40, uint8(i)}...)
+	}
+	if i <= maxVarInt4 {
+		return append(b, []byte{uint8(i>>24) | 0x80, uint8(i >> 16), uint8(i >> 8), uint8(i)}...)
+	}
+	if i <= maxVarInt8 {
+		return append(b, []byte{
+			uint8(i>>56) | 0xc0, uint8(i >> 48), uint8(i >> 40), uint8(i >> 32),
+			uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
+		}...)
+	}
+	panic(&varintLengthError{Num: i})
+}
+
+// AppendWithLen append i in the QUIC varint format with the desired length.
+func AppendWithLen(b []byte, i uint64, length int) []byte {
+	if length != 1 && length != 2 && length != 4 && length != 8 {
+		panic("invalid varint length")
+	}
+	l := Len(i)
+	if l == length {
+		return Append(b, i)
+	}
+	if l > length {
+		panic(fmt.Sprintf("cannot encode %d in %d bytes", i, length))
+	}
+	switch length {
+	case 2:
+		b = append(b, 0b01000000)
+	case 4:
+		b = append(b, 0b10000000)
+	case 8:
+		b = append(b, 0b11000000)
+	}
+	for range length - l - 1 {
+		b = append(b, 0)
+	}
+	for j := range l {
+		b = append(b, uint8(i>>(8*(l-1-j))))
+	}
+	return b
+}
+
+// Len determines the number of bytes that will be needed to write the number i.
+//
+//gcassert:inline
+func Len(i uint64) int {
+	if i <= maxVarInt1 {
+		return 1
+	}
+	if i <= maxVarInt2 {
+		return 2
+	}
+	if i <= maxVarInt4 {
+		return 4
+	}
+	if i <= maxVarInt8 {
+		return 8
+	}
+	// Don't use a fmt.Sprintf here to format the error message.
+	// The function would then exceed the inlining budget.
+	panic(&varintLengthError{Num: i})
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/receive_stream.go b/backend/vendor/github.com/quic-go/quic-go/receive_stream.go
new file mode 100644
index 00000000..7c136689
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/receive_stream.go
@@ -0,0 +1,578 @@
+package quic
+
+import (
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+// A ReceiveStream is a unidirectional Receive Stream.
+type ReceiveStream struct {
+	mutex sync.Mutex
+
+	streamID protocol.StreamID
+
+	sender streamSender
+
+	frameQueue               *frameSorter
+	finalOffset              protocol.ByteCount
+	receiveFinalSizeCallback func(int64)
+
+	currentFrame       []byte
+	currentFrameDone   func()
+	readPosInFrame     int
+	currentFrameIsLast bool // is the currentFrame the last frame on this stream
+
+	queuedStopSending   bool
+	queuedMaxStreamData bool
+
+	// Set once we read the io.EOF or the cancellation error.
+	// Note that for local cancellations, this doesn't necessarily mean that we know the final offset yet.
+	errorRead           bool
+	completed           bool // set once we've called streamSender.onStreamCompleted
+	cancelledRemotely   bool
+	cancelledLocally    bool
+	cancelErr           *StreamError
+	closeForShutdownErr error
+
+	readPos      protocol.ByteCount
+	reliableSize protocol.ByteCount
+
+	readChan chan struct{}
+	readOnce chan struct{} // cap: 1, to protect against concurrent use of Read
+	deadline monotime.Time
+
+	flowController *streamFlowController
+}
+
+var (
+	_ streamControlFrameGetter  = &ReceiveStream{}
+	_ receiveStreamFrameHandler = &ReceiveStream{}
+)
+
+func newReceiveStream(
+	streamID protocol.StreamID,
+	sender streamSender,
+	flowController *streamFlowController,
+) *ReceiveStream {
+	return &ReceiveStream{
+		streamID:       streamID,
+		sender:         sender,
+		flowController: flowController,
+		frameQueue:     newFrameSorter(),
+		readChan:       make(chan struct{}, 1),
+		readOnce:       make(chan struct{}, 1),
+		finalOffset:    protocol.MaxByteCount,
+	}
+}
+
+// StreamID returns the stream ID.
+func (s *ReceiveStream) StreamID() StreamID {
+	return s.streamID
+}
+
+// SetReceiveFinalSizeCallback sets a callback that is called when the receive stream's final size is known.
+// The final size is learned from a FIN or RESET_STREAM frame.
+// Most applications don't need this. It is mainly useful for protocol layers
+// that need exact stream final sizes, such as WebTransport flow control accounting.
+// If the final size is already known, the callback is called before this method returns.
+// When the final size is learned later, the callback is called from the connection's event loop and must not block.
+// The callback is not called if the connection is closed before the final size is known.
+// Setting a nil callback removes it if the final size is not yet known.
+func (s *ReceiveStream) SetReceiveFinalSizeCallback(callback func(int64)) {
+	s.mutex.Lock()
+	size := s.finalOffset
+
+	// final size is already known
+	if size != protocol.MaxByteCount {
+		s.mutex.Unlock()
+		if callback != nil {
+			callback(int64(size))
+		}
+		return
+	}
+
+	if s.closeForShutdownErr != nil {
+		s.mutex.Unlock()
+		return
+	}
+	s.receiveFinalSizeCallback = callback
+	s.mutex.Unlock()
+}
+
+// Read reads data from the stream.
+// Read can be made to time out using [ReceiveStream.SetReadDeadline].
+// If the stream was canceled, the error is a [StreamError].
+func (s *ReceiveStream) Read(p []byte) (int, error) {
+	// Concurrent use of Read is not permitted (and doesn't make any sense),
+	// but sometimes people do it anyway.
+	// Make sure that we only execute one call at any given time to avoid hard to debug failures.
+	s.readOnce <- struct{}{}
+	defer func() { <-s.readOnce }()
+
+	s.mutex.Lock()
+	queuedStreamWindowUpdate, queuedConnWindowUpdate, n, err := s.readImpl(p)
+	completed := s.isNewlyCompleted()
+	s.mutex.Unlock()
+
+	if completed {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	if queuedStreamWindowUpdate {
+		s.sender.onHasStreamControlFrame(s.streamID, s)
+	}
+	if queuedConnWindowUpdate {
+		s.sender.onHasConnectionData()
+	}
+	return n, err
+}
+
+func (s *ReceiveStream) isNewlyCompleted() bool {
+	if s.completed {
+		return false
+	}
+	// We need to know the final offset (either via FIN or RESET_STREAM) for flow control accounting.
+	if s.finalOffset == protocol.MaxByteCount {
+		return false
+	}
+	// We're done with the stream if it was cancelled locally...
+	if s.cancelledLocally {
+		s.completed = true
+		return true
+	}
+	// ... or if the error (either io.EOF or the reset error) was read
+	if s.errorRead {
+		s.completed = true
+		return true
+	}
+	return false
+}
+
+func (s *ReceiveStream) readImpl(p []byte) (hasStreamWindowUpdate bool, hasConnWindowUpdate bool, _ int, _ error) {
+	if s.currentFrameIsLast && s.currentFrame == nil {
+		s.errorRead = true
+		return false, false, 0, io.EOF
+	}
+	if s.cancelledLocally || s.isRemoteCancellationEffective() {
+		s.errorRead = true
+		return false, false, 0, s.cancelErr
+	}
+	if s.closeForShutdownErr != nil {
+		return false, false, 0, s.closeForShutdownErr
+	}
+
+	var bytesRead int
+	var deadlineTimer *time.Timer
+	for bytesRead < len(p) {
+		if s.currentFrame == nil || s.readPosInFrame >= len(s.currentFrame) {
+			s.dequeueNextFrame()
+		}
+		if s.currentFrame == nil && bytesRead > 0 {
+			return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, s.closeForShutdownErr
+		}
+
+		for {
+			// Stop waiting on errors
+			if s.closeForShutdownErr != nil {
+				return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, s.closeForShutdownErr
+			}
+			if s.cancelledLocally || s.isRemoteCancellationEffective() {
+				s.errorRead = true
+				return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, s.cancelErr
+			}
+
+			deadline := s.deadline
+			if !deadline.IsZero() && !monotime.Now().Before(deadline) {
+				return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, errDeadline
+			}
+
+			if s.currentFrame != nil || s.currentFrameIsLast {
+				break
+			}
+
+			s.mutex.Unlock()
+			if deadline.IsZero() {
+				<-s.readChan
+			} else {
+				if deadlineTimer == nil {
+					deadlineTimer = time.NewTimer(monotime.Until(deadline))
+					defer deadlineTimer.Stop()
+				} else {
+					deadlineTimer.Reset(monotime.Until(deadline))
+				}
+				select {
+				case <-s.readChan:
+				case <-deadlineTimer.C:
+				}
+			}
+			s.mutex.Lock()
+			s.dequeueNextFrame()
+		}
+
+		if bytesRead > len(p) {
+			return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, fmt.Errorf("BUG: bytesRead (%d) > len(p) (%d) in stream.Read", bytesRead, len(p))
+		}
+		if s.readPosInFrame > len(s.currentFrame) {
+			return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, fmt.Errorf("BUG: readPosInFrame (%d) > frame.DataLen (%d) in stream.Read", s.readPosInFrame, len(s.currentFrame))
+		}
+		m := copy(p[bytesRead:], s.currentFrame[s.readPosInFrame:])
+
+		// when a RESET_STREAM was received, the flow controller was already
+		// informed about the final offset for this stream
+		if !s.isRemoteCancellationEffective() {
+			hasStream, hasConn := s.flowController.AddBytesRead(protocol.ByteCount(m))
+			if hasStream {
+				s.queuedMaxStreamData = true
+				hasStreamWindowUpdate = true
+			}
+			if hasConn {
+				hasConnWindowUpdate = true
+			}
+		}
+
+		s.readPosInFrame += m
+		s.readPos += protocol.ByteCount(m)
+		bytesRead += m
+
+		if s.isRemoteCancellationEffective() {
+			s.flowController.Abandon()
+		}
+
+		if s.readPosInFrame >= len(s.currentFrame) && s.currentFrameIsLast {
+			s.currentFrame = nil
+			if s.currentFrameDone != nil {
+				s.currentFrameDone()
+			}
+			s.errorRead = true
+			return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, io.EOF
+		}
+	}
+	if s.isRemoteCancellationEffective() {
+		s.errorRead = true
+		return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, s.cancelErr
+	}
+	return hasStreamWindowUpdate, hasConnWindowUpdate, bytesRead, nil
+}
+
+// isRemoteCancellationEffective returns whether the stream was cancelled remotely
+// and all reliable data has been read.
+func (s *ReceiveStream) isRemoteCancellationEffective() bool {
+	return s.cancelledRemotely && s.readPos >= s.reliableSize
+}
+
+// Peek fills b with stream data, without consuming the stream data.
+// It blocks until len(b) bytes are available, or an error occurs.
+// It respects the stream deadline set by SetReadDeadline.
+// If the stream ends before len(b) bytes are available,
+// it returns the number of bytes peeked along with io.EOF.
+func (s *ReceiveStream) Peek(b []byte) (int, error) {
+	if len(b) == 0 {
+		return 0, nil
+	}
+
+	// prevent concurrent use with Read
+	s.readOnce <- struct{}{}
+	defer func() { <-s.readOnce }()
+
+	return s.peekImpl(b)
+}
+
+func (s *ReceiveStream) peekImpl(b []byte) (int, error) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	var deadlineTimer *time.Timer
+
+	for {
+		if s.currentFrameIsLast && s.currentFrame == nil {
+			return 0, io.EOF
+		}
+		if s.cancelledLocally || s.isRemoteCancellationEffective() {
+			return 0, s.cancelErr
+		}
+		if s.closeForShutdownErr != nil {
+			return 0, s.closeForShutdownErr
+		}
+
+		deadline := s.deadline
+		if !deadline.IsZero() && !monotime.Now().Before(deadline) {
+			return 0, errDeadline
+		}
+
+		if s.currentFrame == nil || s.readPosInFrame >= len(s.currentFrame) {
+			s.dequeueNextFrame()
+		}
+
+		if s.currentFrame != nil && s.readPosInFrame < len(s.currentFrame) {
+			availableInCurrentFrame := len(s.currentFrame) - s.readPosInFrame
+
+			if availableInCurrentFrame >= len(b) {
+				copy(b, s.currentFrame[s.readPosInFrame:])
+				return len(b), nil
+			}
+
+			offset := s.readPos + protocol.ByteCount(availableInCurrentFrame)
+			// First peek, then copy.
+			// This avoids copying data if there's not enough data in the queue.
+			if err := s.frameQueue.Peek(offset, b[availableInCurrentFrame:]); err == nil {
+				copy(b[:availableInCurrentFrame], s.currentFrame[s.readPosInFrame:])
+				return len(b), nil
+			}
+
+			if s.currentFrameIsLast {
+				copy(b[:availableInCurrentFrame], s.currentFrame[s.readPosInFrame:])
+				return availableInCurrentFrame, io.EOF
+			}
+
+			// If the stream was remotely cancelled and the request extends beyond the reliable size,
+			// return the data available with the cancel error (once it's all received).
+			if s.cancelledRemotely && s.readPos+protocol.ByteCount(len(b)) > s.reliableSize {
+				total := int(s.reliableSize - s.readPos)
+				needed := total - availableInCurrentFrame
+				// only return once all available data is contiguous
+				if needed <= 0 || s.frameQueue.Peek(offset, b[availableInCurrentFrame:total]) == nil {
+					copy(b[:availableInCurrentFrame], s.currentFrame[s.readPosInFrame:])
+					return total, s.cancelErr
+				}
+			}
+
+			// If the request extends beyond the stream's final offset,
+			// return the data available with EOF (once it's all received).
+			if s.readPos+protocol.ByteCount(len(b)) > s.finalOffset {
+				total := int(s.finalOffset - s.readPos)
+				needed := total - availableInCurrentFrame
+				// only return once all available data is contiguous
+				if needed <= 0 || s.frameQueue.Peek(offset, b[availableInCurrentFrame:total]) == nil {
+					copy(b[:availableInCurrentFrame], s.currentFrame[s.readPosInFrame:])
+					return total, io.EOF
+				}
+			}
+		}
+
+		if s.currentFrameIsLast || s.readPos >= s.finalOffset {
+			return 0, io.EOF
+		}
+
+		s.mutex.Unlock()
+		if deadline.IsZero() {
+			<-s.readChan
+		} else {
+			if deadlineTimer == nil {
+				deadlineTimer = time.NewTimer(monotime.Until(deadline))
+				defer deadlineTimer.Stop()
+			} else {
+				deadlineTimer.Reset(monotime.Until(deadline))
+			}
+			select {
+			case <-s.readChan:
+			case <-deadlineTimer.C:
+			}
+		}
+		s.mutex.Lock()
+		if s.currentFrame == nil || s.readPosInFrame >= len(s.currentFrame) {
+			s.dequeueNextFrame()
+		}
+	}
+}
+
+func (s *ReceiveStream) dequeueNextFrame() {
+	var offset protocol.ByteCount
+	// We're done with the last frame. Release the buffer.
+	if s.currentFrameDone != nil {
+		s.currentFrameDone()
+	}
+	offset, s.currentFrame, s.currentFrameDone = s.frameQueue.Pop()
+	s.currentFrameIsLast = offset+protocol.ByteCount(len(s.currentFrame)) >= s.finalOffset && !s.cancelledRemotely
+	s.readPosInFrame = 0
+}
+
+// CancelRead aborts receiving on this stream.
+// It instructs the peer to stop transmitting stream data.
+// Read will unblock immediately, and future Read calls will fail.
+// When called multiple times or after reading the io.EOF it is a no-op.
+func (s *ReceiveStream) CancelRead(errorCode StreamErrorCode) {
+	s.mutex.Lock()
+	queuedNewControlFrame := s.cancelReadImpl(errorCode)
+	completed := s.isNewlyCompleted()
+	s.mutex.Unlock()
+
+	if queuedNewControlFrame {
+		s.sender.onHasStreamControlFrame(s.streamID, s)
+	}
+	if completed {
+		s.flowController.Abandon()
+		s.sender.onStreamCompleted(s.streamID)
+	}
+}
+
+func (s *ReceiveStream) cancelReadImpl(errorCode qerr.StreamErrorCode) (queuedNewControlFrame bool) {
+	if s.cancelledLocally { // duplicate call to CancelRead
+		return false
+	}
+	if s.closeForShutdownErr != nil {
+		return false
+	}
+	s.cancelledLocally = true
+	if s.errorRead || s.cancelledRemotely {
+		return false
+	}
+	s.queuedStopSending = true
+	s.cancelErr = &StreamError{StreamID: s.streamID, ErrorCode: errorCode, Remote: false}
+	s.signalRead()
+	return true
+}
+
+func (s *ReceiveStream) handleStreamFrame(frame *wire.StreamFrame, now monotime.Time) error {
+	s.mutex.Lock()
+	err := s.handleStreamFrameImpl(frame, now)
+	completed := s.isNewlyCompleted()
+	size, callback := s.takeReceiveFinalSizeCallback()
+	s.mutex.Unlock()
+
+	if completed {
+		s.flowController.Abandon()
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	if callback != nil {
+		callback(size)
+	}
+	return err
+}
+
+func (s *ReceiveStream) handleStreamFrameImpl(frame *wire.StreamFrame, now monotime.Time) error {
+	if s.closeForShutdownErr != nil {
+		return nil
+	}
+	maxOffset := frame.Offset + frame.DataLen()
+	if err := s.flowController.UpdateHighestReceived(maxOffset, frame.Fin, now); err != nil {
+		return err
+	}
+	if frame.Fin {
+		s.finalOffset = maxOffset
+	}
+	if s.cancelledLocally {
+		return nil
+	}
+	if err := s.frameQueue.Push(frame.Data, frame.Offset, frame.PutBack); err != nil {
+		return err
+	}
+	s.signalRead()
+	return nil
+}
+
+func (s *ReceiveStream) handleResetStreamFrame(frame *wire.ResetStreamFrame, now monotime.Time) error {
+	s.mutex.Lock()
+	err := s.handleResetStreamFrameImpl(frame, now)
+	completed := s.isNewlyCompleted()
+	size, callback := s.takeReceiveFinalSizeCallback()
+	s.mutex.Unlock()
+
+	if completed {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	if callback != nil {
+		callback(size)
+	}
+	return err
+}
+
+func (s *ReceiveStream) handleResetStreamFrameImpl(frame *wire.ResetStreamFrame, now monotime.Time) error {
+	if s.closeForShutdownErr != nil {
+		return nil
+	}
+	if err := s.flowController.UpdateHighestReceived(frame.FinalSize, true, now); err != nil {
+		return err
+	}
+	s.finalOffset = frame.FinalSize
+
+	// senders are allowed to reduce the reliable size, but frames might have been reordered
+	if (!s.cancelledRemotely && s.reliableSize == 0) || frame.ReliableSize < s.reliableSize {
+		s.reliableSize = frame.ReliableSize
+	}
+	if s.readPos >= s.reliableSize {
+		// calling Abandon multiple times is a no-op
+		s.flowController.Abandon()
+	}
+	// ignore duplicate RESET_STREAM frames for this stream (after checking their final offset)
+	if s.cancelledRemotely {
+		return nil
+	}
+
+	// don't save the error if the RESET_STREAM frames was received after CancelRead was called
+	if s.cancelledLocally {
+		return nil
+	}
+	s.cancelledRemotely = true
+	s.cancelErr = &StreamError{StreamID: s.streamID, ErrorCode: frame.ErrorCode, Remote: true}
+	s.signalRead()
+	return nil
+}
+
+func (s *ReceiveStream) takeReceiveFinalSizeCallback() (int64, func(int64)) {
+	if s.finalOffset == protocol.MaxByteCount {
+		return 0, nil
+	}
+	callback := s.receiveFinalSizeCallback
+	s.receiveFinalSizeCallback = nil
+	return int64(s.finalOffset), callback
+}
+
+func (s *ReceiveStream) getControlFrame(now monotime.Time) (_ ackhandler.Frame, ok, hasMore bool) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if !s.queuedStopSending && !s.queuedMaxStreamData {
+		return ackhandler.Frame{}, false, false
+	}
+	if s.queuedStopSending {
+		s.queuedStopSending = false
+		return ackhandler.Frame{
+			Frame: &wire.StopSendingFrame{StreamID: s.streamID, ErrorCode: s.cancelErr.ErrorCode},
+		}, true, s.queuedMaxStreamData
+	}
+
+	s.queuedMaxStreamData = false
+	return ackhandler.Frame{
+		Frame: &wire.MaxStreamDataFrame{
+			StreamID:          s.streamID,
+			MaximumStreamData: s.flowController.GetWindowUpdate(now),
+		},
+	}, true, false
+}
+
+// SetReadDeadline sets the deadline for future Read calls and
+// any currently-blocked Read call.
+// A zero value for t means Read will not time out.
+func (s *ReceiveStream) SetReadDeadline(t time.Time) error {
+	s.mutex.Lock()
+	s.deadline = monotime.FromTime(t)
+	s.mutex.Unlock()
+	s.signalRead()
+	return nil
+}
+
+// CloseForShutdown closes a stream abruptly.
+// It makes Read unblock (and return the error) immediately.
+// The peer will NOT be informed about this: the stream is closed without sending a FIN or RESET.
+func (s *ReceiveStream) closeForShutdown(err error) {
+	s.mutex.Lock()
+	s.closeForShutdownErr = err
+	s.receiveFinalSizeCallback = nil
+	s.mutex.Unlock()
+	s.signalRead()
+}
+
+// signalRead performs a non-blocking send on the readChan
+func (s *ReceiveStream) signalRead() {
+	select {
+	case s.readChan <- struct{}{}:
+	default:
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/retransmission_queue.go b/backend/vendor/github.com/quic-go/quic-go/retransmission_queue.go
new file mode 100644
index 00000000..323af5b0
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/retransmission_queue.go
@@ -0,0 +1,158 @@
+package quic
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type framesToRetransmit struct {
+	crypto []*wire.CryptoFrame
+	other  []wire.Frame
+}
+
+type retransmissionQueue struct {
+	initial   *framesToRetransmit
+	handshake *framesToRetransmit
+	appData   framesToRetransmit
+}
+
+func newRetransmissionQueue() *retransmissionQueue {
+	return &retransmissionQueue{
+		initial:   &framesToRetransmit{},
+		handshake: &framesToRetransmit{},
+	}
+}
+
+func (q *retransmissionQueue) addInitial(f wire.Frame) {
+	if q.initial == nil {
+		return
+	}
+	if cf, ok := f.(*wire.CryptoFrame); ok {
+		q.initial.crypto = append(q.initial.crypto, cf)
+		return
+	}
+	q.initial.other = append(q.initial.other, f)
+}
+
+func (q *retransmissionQueue) addHandshake(f wire.Frame) {
+	if q.handshake == nil {
+		return
+	}
+	if cf, ok := f.(*wire.CryptoFrame); ok {
+		q.handshake.crypto = append(q.handshake.crypto, cf)
+		return
+	}
+	q.handshake.other = append(q.handshake.other, f)
+}
+
+func (q *retransmissionQueue) addAppData(f wire.Frame) {
+	switch f := f.(type) {
+	case *wire.StreamFrame:
+		panic("STREAM frames are handled with their respective streams.")
+	case *wire.CryptoFrame:
+		q.appData.crypto = append(q.appData.crypto, f)
+	default:
+		q.appData.other = append(q.appData.other, f)
+	}
+}
+
+func (q *retransmissionQueue) HasData(encLevel protocol.EncryptionLevel) bool {
+	//nolint:exhaustive // 0-RTT data is retransmitted in 1-RTT packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return q.initial != nil &&
+			(len(q.initial.crypto) > 0 || len(q.initial.other) > 0)
+	case protocol.EncryptionHandshake:
+		return q.handshake != nil &&
+			(len(q.handshake.crypto) > 0 || len(q.handshake.other) > 0)
+	case protocol.Encryption1RTT:
+		return len(q.appData.crypto) > 0 || len(q.appData.other) > 0
+	}
+	return false
+}
+
+func (q *retransmissionQueue) GetFrame(encLevel protocol.EncryptionLevel, maxLen protocol.ByteCount, v protocol.Version) wire.Frame {
+	var r *framesToRetransmit
+	//nolint:exhaustive // 0-RTT data is retransmitted in 1-RTT packets.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		r = q.initial
+	case protocol.EncryptionHandshake:
+		r = q.handshake
+	case protocol.Encryption1RTT:
+		r = &q.appData
+	}
+	if r == nil {
+		return nil
+	}
+
+	if len(r.crypto) > 0 {
+		f := r.crypto[0]
+		newFrame, needsSplit := f.MaybeSplitOffFrame(maxLen, v)
+		if newFrame == nil && !needsSplit { // the whole frame fits
+			r.crypto = r.crypto[1:]
+			return f
+		}
+		if newFrame != nil { // frame was split. Leave the original frame in the queue.
+			return newFrame
+		}
+	}
+	if len(r.other) == 0 {
+		return nil
+	}
+	f := r.other[0]
+	if f.Length(v) > maxLen {
+		return nil
+	}
+	r.other = r.other[1:]
+	return f
+}
+
+func (q *retransmissionQueue) DropPackets(encLevel protocol.EncryptionLevel) {
+	//nolint:exhaustive // Can only drop Initial and Handshake packet number space.
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		q.initial = nil
+	case protocol.EncryptionHandshake:
+		q.handshake = nil
+	default:
+		panic(fmt.Sprintf("unexpected encryption level: %s", encLevel))
+	}
+}
+
+func (q *retransmissionQueue) AckHandler(encLevel protocol.EncryptionLevel) ackhandler.FrameHandler {
+	switch encLevel {
+	case protocol.EncryptionInitial:
+		return (*retransmissionQueueInitialAckHandler)(q)
+	case protocol.EncryptionHandshake:
+		return (*retransmissionQueueHandshakeAckHandler)(q)
+	case protocol.Encryption0RTT, protocol.Encryption1RTT:
+		return (*retransmissionQueueAppDataAckHandler)(q)
+	}
+	return nil
+}
+
+type retransmissionQueueInitialAckHandler retransmissionQueue
+
+func (q *retransmissionQueueInitialAckHandler) OnAcked(wire.Frame) {}
+func (q *retransmissionQueueInitialAckHandler) OnLost(f wire.Frame) {
+	(*retransmissionQueue)(q).addInitial(f)
+}
+
+type retransmissionQueueHandshakeAckHandler retransmissionQueue
+
+func (q *retransmissionQueueHandshakeAckHandler) OnAcked(wire.Frame) {}
+func (q *retransmissionQueueHandshakeAckHandler) OnLost(f wire.Frame) {
+	(*retransmissionQueue)(q).addHandshake(f)
+}
+
+type retransmissionQueueAppDataAckHandler retransmissionQueue
+
+func (q *retransmissionQueueAppDataAckHandler) OnAcked(wire.Frame) {}
+func (q *retransmissionQueueAppDataAckHandler) OnLost(f wire.Frame) {
+	(*retransmissionQueue)(q).addAppData(f)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/send_conn.go b/backend/vendor/github.com/quic-go/quic-go/send_conn.go
new file mode 100644
index 00000000..4cbffc71
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/send_conn.go
@@ -0,0 +1,124 @@
+package quic
+
+import (
+	"net"
+	"sync/atomic"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+// A sendConn allows sending using a simple Write() on a non-connected packet conn.
+type sendConn interface {
+	Write(b []byte, gsoSize uint16, ecn protocol.ECN) error
+	WriteTo([]byte, net.Addr, packetInfo) error
+	Close() error
+	LocalAddr() net.Addr
+	RemoteAddr() net.Addr
+	ChangeRemoteAddr(addr net.Addr, info packetInfo)
+
+	capabilities() connCapabilities
+}
+
+type remoteAddrInfo struct {
+	addr net.Addr
+	oob  []byte
+}
+
+type sconn struct {
+	rawConn
+
+	localAddr net.Addr
+
+	remoteAddrInfo atomic.Pointer[remoteAddrInfo]
+
+	logger utils.Logger
+
+	// If GSO enabled, and we receive a GSO error for this remote address, GSO is disabled.
+	gotGSOError bool
+	// Used to catch the error sometimes returned by the first sendmsg call on Linux,
+	// see https://github.com/golang/go/issues/63322.
+	wroteFirstPacket bool
+}
+
+var _ sendConn = &sconn{}
+
+func newSendConn(c rawConn, remote net.Addr, info packetInfo, logger utils.Logger) *sconn {
+	localAddr := c.LocalAddr()
+	if info.addr.IsValid() {
+		if udpAddr, ok := localAddr.(*net.UDPAddr); ok {
+			addrCopy := *udpAddr
+			addrCopy.IP = info.addr.AsSlice()
+			localAddr = &addrCopy
+		}
+	}
+
+	oob := info.OOB()
+	// increase oob slice capacity, so we can add the UDP_SEGMENT and ECN control messages without allocating
+	l := len(oob)
+	oob = append(oob, make([]byte, 64)...)[:l]
+	sc := &sconn{
+		rawConn:   c,
+		localAddr: localAddr,
+		logger:    logger,
+	}
+	sc.remoteAddrInfo.Store(&remoteAddrInfo{
+		addr: remote,
+		oob:  oob,
+	})
+	return sc
+}
+
+func (c *sconn) Write(p []byte, gsoSize uint16, ecn protocol.ECN) error {
+	ai := c.remoteAddrInfo.Load()
+	err := c.writePacket(p, ai.addr, ai.oob, gsoSize, ecn)
+	if err != nil && isGSOError(err) {
+		// disable GSO for future calls
+		c.gotGSOError = true
+		if c.logger.Debug() {
+			c.logger.Debugf("GSO failed when sending to %s", ai.addr)
+		}
+		// send out the packets one by one
+		for len(p) > 0 {
+			l := min(len(p), int(gsoSize))
+			if err := c.writePacket(p[:l], ai.addr, ai.oob, 0, ecn); err != nil {
+				return err
+			}
+			p = p[l:]
+		}
+		return nil
+	}
+	return err
+}
+
+func (c *sconn) writePacket(p []byte, addr net.Addr, oob []byte, gsoSize uint16, ecn protocol.ECN) error {
+	_, err := c.WritePacket(p, addr, oob, gsoSize, ecn)
+	if err != nil && !c.wroteFirstPacket && isPermissionError(err) {
+		_, err = c.WritePacket(p, addr, oob, gsoSize, ecn)
+	}
+	c.wroteFirstPacket = true
+	return err
+}
+
+func (c *sconn) WriteTo(b []byte, addr net.Addr, info packetInfo) error {
+	_, err := c.WritePacket(b, addr, info.OOB(), 0, protocol.ECNUnsupported)
+	return err
+}
+
+func (c *sconn) capabilities() connCapabilities {
+	capabilities := c.rawConn.capabilities()
+	if capabilities.GSO {
+		capabilities.GSO = !c.gotGSOError
+	}
+	return capabilities
+}
+
+func (c *sconn) ChangeRemoteAddr(addr net.Addr, info packetInfo) {
+	c.remoteAddrInfo.Store(&remoteAddrInfo{
+		addr: addr,
+		oob:  info.OOB(),
+	})
+}
+
+func (c *sconn) RemoteAddr() net.Addr { return c.remoteAddrInfo.Load().addr }
+func (c *sconn) LocalAddr() net.Addr  { return c.localAddr }
diff --git a/backend/vendor/github.com/quic-go/quic-go/send_queue.go b/backend/vendor/github.com/quic-go/quic-go/send_queue.go
new file mode 100644
index 00000000..c8060cb3
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/send_queue.go
@@ -0,0 +1,112 @@
+package quic
+
+import (
+	"net"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type sender interface {
+	Send(p *packetBuffer, gsoSize uint16, ecn protocol.ECN)
+	SendProbe(*packetBuffer, net.Addr, packetInfo)
+	Run() error
+	WouldBlock() bool
+	Available() <-chan struct{}
+	Close()
+}
+
+type queueEntry struct {
+	buf     *packetBuffer
+	gsoSize uint16
+	ecn     protocol.ECN
+}
+
+type sendQueue struct {
+	queue       chan queueEntry
+	closeCalled chan struct{} // runStopped when Close() is called
+	runStopped  chan struct{} // runStopped when the run loop returns
+	available   chan struct{}
+	conn        sendConn
+}
+
+var _ sender = &sendQueue{}
+
+const sendQueueCapacity = 8
+
+func newSendQueue(conn sendConn) sender {
+	return &sendQueue{
+		conn:        conn,
+		runStopped:  make(chan struct{}),
+		closeCalled: make(chan struct{}),
+		available:   make(chan struct{}, 1),
+		queue:       make(chan queueEntry, sendQueueCapacity),
+	}
+}
+
+// Send sends out a packet. It's guaranteed to not block.
+// Callers need to make sure that there's actually space in the send queue by calling WouldBlock.
+// Otherwise Send will panic.
+func (h *sendQueue) Send(p *packetBuffer, gsoSize uint16, ecn protocol.ECN) {
+	select {
+	case h.queue <- queueEntry{buf: p, gsoSize: gsoSize, ecn: ecn}:
+		// clear available channel if we've reached capacity
+		if len(h.queue) == sendQueueCapacity {
+			select {
+			case <-h.available:
+			default:
+			}
+		}
+	case <-h.runStopped:
+	default:
+		panic("sendQueue.Send would have blocked")
+	}
+}
+
+func (h *sendQueue) SendProbe(p *packetBuffer, addr net.Addr, info packetInfo) {
+	h.conn.WriteTo(p.Data, addr, info)
+}
+
+func (h *sendQueue) WouldBlock() bool {
+	return len(h.queue) == sendQueueCapacity
+}
+
+func (h *sendQueue) Available() <-chan struct{} {
+	return h.available
+}
+
+func (h *sendQueue) Run() error {
+	defer close(h.runStopped)
+	var shouldClose bool
+	for {
+		if shouldClose && len(h.queue) == 0 {
+			return nil
+		}
+		select {
+		case <-h.closeCalled:
+			h.closeCalled = nil // prevent this case from being selected again
+			// make sure that all queued packets are actually sent out
+			shouldClose = true
+		case e := <-h.queue:
+			if err := h.conn.Write(e.buf.Data, e.gsoSize, e.ecn); err != nil {
+				// This additional check enables:
+				// 1. Checking for "datagram too large" message from the kernel, as such,
+				// 2. Path MTU discovery,and
+				// 3. Eventual detection of loss PingFrame.
+				if !isSendMsgSizeErr(err) {
+					return err
+				}
+			}
+			e.buf.Release()
+			select {
+			case h.available <- struct{}{}:
+			default:
+			}
+		}
+	}
+}
+
+func (h *sendQueue) Close() {
+	close(h.closeCalled)
+	// wait until the run loop returned
+	<-h.runStopped
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/send_stream.go b/backend/vendor/github.com/quic-go/quic-go/send_stream.go
new file mode 100644
index 00000000..70f9405d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/send_stream.go
@@ -0,0 +1,915 @@
+package quic
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+// A SendStream is a unidirectional Send Stream.
+type SendStream struct {
+	mutex sync.Mutex
+
+	numOutstandingFrames int64 // outstanding STREAM and RESET_STREAM frames
+	retransmissionQueue  []*wire.StreamFrame
+
+	ctx       context.Context
+	ctxCancel context.CancelCauseFunc
+
+	streamID protocol.StreamID
+	sender   streamSender
+
+	// reliableSize is the portion of the stream that needs to be transmitted reliably,
+	// even if the stream is cancelled.
+	// This requires the peer to support RESET_STREAM_AT.
+	// This value should not be accessed directly, but only through the reliableOffset method.
+	// This method returns 0 if the peer doesn't support the RESET_STREAM_AT extension.
+	reliableSize protocol.ByteCount
+	writeOffset  protocol.ByteCount
+
+	shutdownErr            error
+	resetErr               *StreamError
+	queuedResetStreamFrame *wire.ResetStreamFrame
+
+	dataForWriting []byte // during a Write() call, this slice is the part of p that still needs to be sent out
+
+	writeLimiter func(int) int
+	// Set by the packetizer when writeLimiter reduces the allowed byte count. It makes the blocked
+	// WriteWithLimit return ErrWriteLimitReached and prevents another dequeue before it wakes up.
+	writeLimited bool
+
+	nextFrame *wire.StreamFrame
+	// set if flow control credit for nextFrame was already consumed
+	nextFrameReserved bool
+
+	supportsResetStreamAt bool
+	finishedWriting       bool // set once Close() is called
+	finSent               bool // set when a STREAM_FRAME with FIN bit has been sent
+	// Set when the application knows about the cancellation.
+	// This can happen because the application called CancelWrite,
+	// or because Write returned the error (for remote cancellations).
+	cancellationFlagged bool
+	completed           bool // set when this stream has been reported to the streamSender as completed
+
+	writeChan chan struct{}
+	writeOnce chan struct{}
+	deadline  monotime.Time
+
+	flowController *streamFlowController
+}
+
+var (
+	_ streamControlFrameGetter = &SendStream{}
+	_ outgoingStream           = &SendStream{}
+	_ sendStreamFrameHandler   = &SendStream{}
+)
+
+func newSendStream(
+	ctx context.Context,
+	streamID protocol.StreamID,
+	sender streamSender,
+	flowController *streamFlowController,
+	supportsResetStreamAt bool,
+) *SendStream {
+	s := &SendStream{
+		streamID:              streamID,
+		sender:                sender,
+		flowController:        flowController,
+		writeChan:             make(chan struct{}, 1),
+		writeOnce:             make(chan struct{}, 1), // cap: 1, to protect against concurrent use of Write
+		supportsResetStreamAt: supportsResetStreamAt,
+	}
+	s.ctx, s.ctxCancel = context.WithCancelCause(ctx)
+	return s
+}
+
+// StreamID returns the stream ID.
+func (s *SendStream) StreamID() StreamID {
+	return s.streamID // same for receiveStream and sendStream
+}
+
+// Write writes data to the stream.
+// Write can be made to time out using [SendStream.SetWriteDeadline].
+// If the stream was canceled, the error is a [StreamError].
+func (s *SendStream) Write(p []byte) (int, error) {
+	return s.WriteWithLimit(p, nil)
+}
+
+// WriteWithLimit writes data to the stream, subject to an additional send limit.
+// During packetization, limiter receives the bytes allowed for the next STREAM frame after
+// QUIC flow control and returns how many may be sent. Returning n in [0, maxBytes] commits
+// n bytes of limiter credit; the limiter is not called again when those bytes are retransmitted.
+// Values outside [0, maxBytes] are clamped.
+// A short result returns the accepted prefix and [ErrWriteLimitReached]; the caller can wait
+// for external credit and retry the suffix. QUIC blocking behaves like [SendStream.Write].
+// limiter can run multiple times on another goroutine while QUIC send flow-control accounting
+// is locked. It must be concurrency-safe and must not block or call QUIC methods.
+// A nil limiter behaves like [SendStream.Write].
+func (s *SendStream) WriteWithLimit(p []byte, limiter func(maxBytes int) int) (int, error) {
+	// Concurrent use of Write is not permitted (and doesn't make any sense),
+	// but sometimes people do it anyway.
+	// Make sure that we only execute one call at any given time to avoid hard to debug failures.
+	s.writeOnce <- struct{}{}
+	defer func() { <-s.writeOnce }()
+
+	isNewlyCompleted, n, err := s.write(p, limiter)
+	if isNewlyCompleted {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	return n, err
+}
+
+// TryWriteAll writes data to the stream if it can be queued immediately.
+// It doesn't block for flow control credit and doesn't respect the write deadline.
+// If the entire slice can't be queued immediately, it queues nothing and returns [ErrWouldBlock].
+func (s *SendStream) TryWriteAll(p []byte) error {
+	select {
+	case s.writeOnce <- struct{}{}:
+		defer func() { <-s.writeOnce }()
+	default:
+		return ErrWouldBlock
+	}
+
+	isNewlyCompleted, hasData, err := s.tryWriteAll(p)
+	if isNewlyCompleted {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	if hasData {
+		s.sender.onHasStreamData(s.streamID, s)
+	}
+	return err
+}
+
+func (s *SendStream) tryWriteAll(p []byte) (bool /* is newly completed */, bool /* has data */, error) {
+	// This might wait briefly while a packet is dequeuing stream data.
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if s.resetErr != nil {
+		s.cancellationFlagged = true
+		return s.isNewlyCompleted(), false, s.resetErr
+	}
+	if s.shutdownErr != nil {
+		return false, false, s.shutdownErr
+	}
+	if s.finishedWriting {
+		return false, false, fmt.Errorf("write on closed stream %d", s.streamID)
+	}
+	if len(p) == 0 {
+		return false, false, nil
+	}
+
+	bytesToReserve := protocol.ByteCount(len(p))
+	if s.nextFrame != nil && !s.nextFrameReserved {
+		bytesToReserve += s.nextFrame.DataLen()
+	}
+	if !s.flowController.TryAddBytesSent(bytesToReserve) {
+		return false, false, ErrWouldBlock
+	}
+
+	if s.nextFrame == nil {
+		s.nextFrame = wire.GetStreamFrame()
+		s.nextFrame.Offset = s.writeOffset
+		s.nextFrame.StreamID = s.streamID
+		s.nextFrame.DataLenPresent = true
+		s.nextFrame.Data = s.nextFrame.Data[:0]
+	}
+	l := len(s.nextFrame.Data)
+	if l+len(p) > cap(s.nextFrame.Data) {
+		// Pooled STREAM frames must keep their packet-sized buffer.
+		// Use a non-pooled frame when the queued data grows beyond that.
+		nextFrame := &wire.StreamFrame{
+			StreamID:       s.streamID,
+			Offset:         s.nextFrame.Offset,
+			DataLenPresent: true,
+			Data:           make([]byte, l+len(p)),
+		}
+		copy(nextFrame.Data, s.nextFrame.Data)
+		s.nextFrame.PutBack()
+		s.nextFrame = nextFrame
+	} else {
+		s.nextFrame.Data = s.nextFrame.Data[:l+len(p)]
+	}
+	copy(s.nextFrame.Data[l:], p)
+	s.nextFrameReserved = true
+	return false, true, nil
+}
+
+func (s *SendStream) write(p []byte, limiter func(int) int) (bool /* is newly completed */, int, error) {
+	s.mutex.Lock()
+	s.writeLimiter = limiter
+	s.writeLimited = false
+	defer func() {
+		s.writeLimiter = nil
+		s.writeLimited = false
+		s.mutex.Unlock()
+	}()
+
+	if s.resetErr != nil {
+		s.cancellationFlagged = true
+		return s.isNewlyCompleted(), 0, s.resetErr
+	}
+	if s.shutdownErr != nil {
+		return false, 0, s.shutdownErr
+	}
+	if s.finishedWriting {
+		return false, 0, fmt.Errorf("write on closed stream %d", s.streamID)
+	}
+	if !s.deadline.IsZero() && !monotime.Now().Before(s.deadline) {
+		return false, 0, errDeadline
+	}
+	if len(p) == 0 {
+		return false, 0, nil
+	}
+
+	s.dataForWriting = p
+
+	var (
+		deadlineTimer  *time.Timer
+		bytesWritten   int
+		notifiedSender bool
+	)
+	for {
+		if s.writeLimited {
+			bytesWritten = len(p) - len(s.dataForWriting)
+			s.dataForWriting = nil
+			break
+		}
+		var copied bool
+		var deadline monotime.Time
+		// As soon as dataForWriting becomes smaller than a certain size x, we copy all the data to a STREAM frame (s.nextFrame),
+		// which can then be popped the next time we assemble a packet.
+		// This allows us to return Write() when all data but x bytes have been sent out.
+		// When the user now calls Close(), this is much more likely to happen before we popped that last STREAM frame,
+		// allowing us to set the FIN bit on that frame (instead of sending an empty STREAM frame with FIN).
+		if s.canBufferStreamFrame() && len(s.dataForWriting) > 0 {
+			if s.nextFrame == nil {
+				f := wire.GetStreamFrame()
+				f.Offset = s.writeOffset
+				f.StreamID = s.streamID
+				f.DataLenPresent = true
+				f.Data = f.Data[:len(s.dataForWriting)]
+				copy(f.Data, s.dataForWriting)
+				s.nextFrame = f
+			} else {
+				l := len(s.nextFrame.Data)
+				s.nextFrame.Data = s.nextFrame.Data[:l+len(s.dataForWriting)]
+				copy(s.nextFrame.Data[l:], s.dataForWriting)
+			}
+			s.dataForWriting = nil
+			bytesWritten = len(p)
+			copied = true
+		} else {
+			bytesWritten = len(p) - len(s.dataForWriting)
+			deadline = s.deadline
+			if !deadline.IsZero() {
+				if !monotime.Now().Before(deadline) {
+					s.dataForWriting = nil
+					return false, bytesWritten, errDeadline
+				}
+				if deadlineTimer == nil {
+					deadlineTimer = time.NewTimer(monotime.Until(deadline))
+					defer deadlineTimer.Stop()
+				} else {
+					deadlineTimer.Reset(monotime.Until(deadline))
+				}
+			}
+			if s.dataForWriting == nil || s.shutdownErr != nil || s.resetErr != nil {
+				break
+			}
+		}
+
+		s.mutex.Unlock()
+		if !notifiedSender {
+			s.sender.onHasStreamData(s.streamID, s) // must be called without holding the mutex
+			notifiedSender = true
+		}
+		if copied {
+			s.mutex.Lock()
+			break
+		}
+		if deadline.IsZero() {
+			<-s.writeChan
+		} else {
+			select {
+			case <-s.writeChan:
+			case <-deadlineTimer.C:
+			}
+		}
+		s.mutex.Lock()
+	}
+
+	if bytesWritten == len(p) {
+		return false, bytesWritten, nil
+	}
+	if s.shutdownErr != nil {
+		return false, bytesWritten, s.shutdownErr
+	}
+	if s.resetErr != nil {
+		s.cancellationFlagged = true
+		return s.isNewlyCompleted(), bytesWritten, s.resetErr
+	}
+	if s.writeLimited {
+		return false, bytesWritten, ErrWriteLimitReached
+	}
+	return false, bytesWritten, nil
+}
+
+func (s *SendStream) canBufferStreamFrame() bool {
+	if s.writeLimiter != nil || s.nextFrameReserved {
+		return false
+	}
+	var l protocol.ByteCount
+	if s.nextFrame != nil {
+		l = s.nextFrame.DataLen()
+	}
+	return l+protocol.ByteCount(len(s.dataForWriting)) <= protocol.MaxPacketBufferSize
+}
+
+// popStreamFrame returns the next STREAM frame that is supposed to be sent on this stream
+// maxBytes is the maximum length this frame (including frame header) will have.
+func (s *SendStream) popStreamFrame(maxBytes protocol.ByteCount, v protocol.Version) (_ ackhandler.StreamFrame, _ *wire.StreamDataBlockedFrame, hasMore bool) {
+	s.mutex.Lock()
+	f, blocked, hasMoreData := s.popNewOrRetransmittedStreamFrame(maxBytes, v)
+	if f != nil {
+		s.numOutstandingFrames++
+	}
+	s.mutex.Unlock()
+
+	if f == nil {
+		return ackhandler.StreamFrame{}, blocked, hasMoreData
+	}
+	return ackhandler.StreamFrame{
+		Frame:   f,
+		Handler: (*sendStreamAckHandler)(s),
+	}, blocked, hasMoreData
+}
+
+func (s *SendStream) popNewOrRetransmittedStreamFrame(maxBytes protocol.ByteCount, v protocol.Version) (_ *wire.StreamFrame, _ *wire.StreamDataBlockedFrame, hasMoreData bool) {
+	if s.shutdownErr != nil {
+		return nil, nil, false
+	}
+	if s.resetErr != nil {
+		reliableOffset := s.reliableOffset()
+		if reliableOffset == 0 || (s.writeOffset >= reliableOffset && len(s.retransmissionQueue) == 0) {
+			return nil, nil, false
+		}
+	}
+
+	if len(s.retransmissionQueue) > 0 {
+		f, hasMoreRetransmissions := s.maybeGetRetransmission(maxBytes, v)
+		if f != nil || hasMoreRetransmissions {
+			if f == nil {
+				return nil, nil, true
+			}
+			// We always claim that we have more data to send.
+			// This might be incorrect, in which case there'll be a spurious call to popStreamFrame in the future.
+			return f, nil, true
+		}
+	}
+	if s.writeLimited {
+		return nil, nil, false
+	}
+
+	if len(s.dataForWriting) == 0 && s.nextFrame == nil {
+		if s.finishedWriting && !s.finSent {
+			s.finSent = true
+			return &wire.StreamFrame{
+				StreamID:       s.streamID,
+				Offset:         s.writeOffset,
+				DataLenPresent: true,
+				Fin:            true,
+			}, nil, false
+		}
+		return nil, nil, false
+	}
+
+	// if the stream is canceled, only data up to the reliable size needs to be sent
+	reliableOffset := s.reliableOffset()
+	limitedWrite := s.writeLimiter != nil && s.nextFrame == nil
+	var maxDataLen protocol.ByteCount
+	if s.nextFrameReserved {
+		maxDataLen = s.nextFrame.DataLen()
+	} else {
+		maxDataLen = s.flowController.SendWindowSize()
+	}
+	if s.resetErr != nil && reliableOffset > 0 {
+		maxDataLen = min(maxDataLen, reliableOffset-s.writeOffset)
+	}
+	if s.nextFrame != nil {
+		maxDataLen = min(maxDataLen, s.nextFrame.MaxDataLen(maxBytes, v), s.nextFrame.DataLen())
+	} else {
+		f := wire.StreamFrame{
+			StreamID:       s.streamID,
+			Offset:         s.writeOffset,
+			DataLenPresent: true,
+		}
+		maxDataLen = min(maxDataLen, f.MaxDataLen(maxBytes, v), protocol.ByteCount(len(s.dataForWriting)))
+	}
+	if maxDataLen == 0 {
+		return nil, nil, true
+	}
+	if limitedWrite {
+		added, limited := s.flowController.AddBytesSentWithLimiter(maxDataLen, s.writeLimiter)
+		if limited {
+			s.writeLimited = true
+			s.signalWrite()
+		}
+		maxDataLen = added
+		if maxDataLen == 0 {
+			return nil, nil, !limited
+		}
+	} else if !s.nextFrameReserved && !s.flowController.TryAddBytesSent(maxDataLen) {
+		return nil, nil, true
+	}
+	f, hasMoreData := s.popNewStreamFrame(maxDataLen)
+	if f.DataLen() > 0 {
+		s.writeOffset += f.DataLen()
+	}
+	if s.resetErr != nil && s.writeOffset >= reliableOffset {
+		hasMoreData = false
+	}
+	if s.writeLimited {
+		hasMoreData = false
+	}
+	var blocked *wire.StreamDataBlockedFrame
+	if f.DataLen() > 0 {
+		if isBlocked, offset := s.flowController.isNewlyBlocked(); isBlocked {
+			blocked = &wire.StreamDataBlockedFrame{StreamID: s.streamID, MaximumStreamData: offset}
+		}
+	}
+	f.Fin = s.finishedWriting && s.dataForWriting == nil && s.nextFrame == nil && !s.finSent
+	if f.Fin {
+		s.finSent = true
+	}
+	return f, blocked, hasMoreData
+}
+
+// popNewStreamFrame returns a new STREAM frame to send for this stream
+// hasMoreData says if there's more data to send, *not* taking into account the reliable size
+func (s *SendStream) popNewStreamFrame(maxDataLen protocol.ByteCount) (_ *wire.StreamFrame, hasMoreData bool) {
+	if s.nextFrame != nil {
+		nextFrame := s.nextFrame
+		nextFrameReserved := s.nextFrameReserved
+		s.nextFrame = nil
+		s.nextFrameReserved = false
+		if nextFrame.DataLen() > maxDataLen {
+			if nextFrame.DataLen()-maxDataLen > protocol.MaxPacketBufferSize {
+				s.nextFrame = &wire.StreamFrame{
+					Data: make([]byte, nextFrame.DataLen()-maxDataLen),
+				}
+			} else {
+				s.nextFrame = wire.GetStreamFrame()
+				s.nextFrame.Data = s.nextFrame.Data[:nextFrame.DataLen()-maxDataLen]
+			}
+			s.nextFrame.StreamID = s.streamID
+			s.nextFrame.Offset = s.writeOffset + maxDataLen
+			s.nextFrame.DataLenPresent = true
+			copy(s.nextFrame.Data, nextFrame.Data[maxDataLen:])
+			nextFrame.Data = nextFrame.Data[:maxDataLen]
+			s.nextFrameReserved = nextFrameReserved
+		} else {
+			s.signalWrite()
+		}
+		return nextFrame, s.nextFrame != nil || s.dataForWriting != nil
+	}
+
+	f := wire.GetStreamFrame()
+	f.Fin = false
+	f.StreamID = s.streamID
+	f.Offset = s.writeOffset
+	f.DataLenPresent = true
+	f.Data = f.Data[:0]
+
+	s.getDataForWriting(f, maxDataLen)
+	return f, s.dataForWriting != nil || s.nextFrame != nil || s.finishedWriting
+}
+
+func (s *SendStream) maybeGetRetransmission(maxBytes protocol.ByteCount, v protocol.Version) (*wire.StreamFrame, bool /* has more retransmissions */) {
+	f := s.retransmissionQueue[0]
+	newFrame, needsSplit := f.MaybeSplitOffFrame(maxBytes, v)
+	if needsSplit {
+		return newFrame, true
+	}
+	s.retransmissionQueue = s.retransmissionQueue[1:]
+	return f, len(s.retransmissionQueue) > 0
+}
+
+func (s *SendStream) getDataForWriting(f *wire.StreamFrame, maxBytes protocol.ByteCount) {
+	if protocol.ByteCount(len(s.dataForWriting)) <= maxBytes {
+		f.Data = f.Data[:len(s.dataForWriting)]
+		copy(f.Data, s.dataForWriting)
+		s.dataForWriting = nil
+		s.signalWrite()
+		return
+	}
+	f.Data = f.Data[:maxBytes]
+	copy(f.Data, s.dataForWriting)
+	s.dataForWriting = s.dataForWriting[maxBytes:]
+	if s.canBufferStreamFrame() {
+		s.signalWrite()
+	}
+}
+
+func (s *SendStream) isNewlyCompleted() bool {
+	if s.completed {
+		return false
+	}
+	if s.nextFrame != nil && s.nextFrame.DataLen() > 0 {
+		return false
+	}
+	// We need to keep the stream around until all frames have been sent and acknowledged.
+	if s.numOutstandingFrames > 0 || len(s.retransmissionQueue) > 0 || s.queuedResetStreamFrame != nil {
+		return false
+	}
+	// The stream is completed if we sent the FIN.
+	if s.finSent {
+		s.completed = true
+		return true
+	}
+	// The stream is also completed if:
+	// 1. the application called CancelWrite, or
+	// 2. we received a STOP_SENDING, and
+	// 		* the application consumed the error via Write, or
+	//		* the application called Close
+	if s.resetErr != nil && (s.cancellationFlagged || s.finishedWriting) {
+		s.completed = true
+		return true
+	}
+	return false
+}
+
+// Close closes the write-direction of the stream.
+// Future calls to Write are not permitted after calling Close.
+// It must not be called concurrently with Write.
+// It must not be called after calling CancelWrite.
+func (s *SendStream) Close() error {
+	s.mutex.Lock()
+	if s.shutdownErr != nil || s.finishedWriting {
+		s.mutex.Unlock()
+		return nil
+	}
+	s.finishedWriting = true
+	cancelled := s.resetErr != nil
+	if cancelled {
+		s.cancellationFlagged = true
+	}
+	completed := s.isNewlyCompleted()
+	s.mutex.Unlock()
+
+	if completed {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+	if cancelled {
+		return fmt.Errorf("close called for canceled stream %d", s.streamID)
+	}
+	s.sender.onHasStreamData(s.streamID, s) // need to send the FIN, must be called without holding the mutex
+
+	s.ctxCancel(nil)
+	return nil
+}
+
+// SetReliableBoundary marks the data written to this stream so far as reliable.
+// It is valid to call this function multiple times, thereby increasing the reliable size.
+// It only has an effect if the peer enabled support for the RESET_STREAM_AT extension,
+// otherwise, it is a no-op.
+func (s *SendStream) SetReliableBoundary() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if s.nextFrame != nil {
+		s.reliableSize = max(s.reliableSize, s.writeOffset+s.nextFrame.DataLen())
+	} else {
+		s.reliableSize = max(s.reliableSize, s.writeOffset)
+	}
+}
+
+// returnFramesToPool returns all queued frames to the sync.Pool
+func (s *SendStream) returnFramesToPool() {
+	for _, f := range s.retransmissionQueue {
+		f.PutBack()
+	}
+	clear(s.retransmissionQueue)
+	s.retransmissionQueue = nil
+	if s.nextFrame != nil {
+		s.nextFrame.PutBack()
+		s.nextFrame = nil
+	}
+	s.nextFrameReserved = false
+}
+
+// CancelWrite aborts sending on this stream.
+// Data already written, but not yet delivered to the peer is not guaranteed to be delivered reliably.
+// Write will unblock immediately, and future calls to Write will fail.
+// When called multiple times it is a no-op.
+// When called after Close, it aborts reliable delivery of outstanding stream data.
+// Note that there is no guarantee if the peer will receive the FIN or the cancellation error first.
+func (s *SendStream) CancelWrite(errorCode StreamErrorCode) {
+	s.mutex.Lock()
+	if s.shutdownErr != nil {
+		s.mutex.Unlock()
+		return
+	}
+
+	s.cancellationFlagged = true
+
+	if s.resetErr != nil {
+		completed := s.isNewlyCompleted()
+		s.mutex.Unlock()
+		// The user has called CancelWrite. If the previous cancellation was because of a
+		// STOP_SENDING, we don't need to flag the error to the user anymore.
+		if completed {
+			s.sender.onStreamCompleted(s.streamID)
+		}
+		return
+	}
+	s.resetErr = &StreamError{StreamID: s.streamID, ErrorCode: errorCode, Remote: false}
+	s.ctxCancel(s.resetErr)
+
+	reliableOffset := s.reliableOffset()
+	finalSize := max(s.writeOffset, reliableOffset)
+	if s.nextFrameReserved && s.nextFrame != nil {
+		finalSize = max(finalSize, s.nextFrame.Offset+s.nextFrame.DataLen())
+	}
+	if reliableOffset == 0 {
+		s.numOutstandingFrames = 0
+		s.returnFramesToPool()
+	}
+	s.queuedResetStreamFrame = &wire.ResetStreamFrame{
+		StreamID:  s.streamID,
+		FinalSize: finalSize,
+		ErrorCode: errorCode,
+		// if the peer doesn't support the extension, the reliable offset will always be 0
+		ReliableSize: reliableOffset,
+	}
+	if reliableOffset > 0 {
+		if s.nextFrame != nil {
+			if s.nextFrame.Offset >= reliableOffset {
+				s.nextFrame.PutBack()
+				s.nextFrame = nil
+				s.nextFrameReserved = false
+			} else if s.nextFrame.Offset+s.nextFrame.DataLen() > reliableOffset {
+				s.nextFrame.Data = s.nextFrame.Data[:reliableOffset-s.nextFrame.Offset]
+			}
+		}
+		if len(s.retransmissionQueue) > 0 {
+			retransmissionQueue := make([]*wire.StreamFrame, 0, len(s.retransmissionQueue))
+			for _, f := range s.retransmissionQueue {
+				if f.Offset >= reliableOffset {
+					f.PutBack()
+					continue
+				}
+				if f.Offset+f.DataLen() <= reliableOffset {
+					retransmissionQueue = append(retransmissionQueue, f)
+				} else {
+					f.Data = f.Data[:reliableOffset-f.Offset]
+					retransmissionQueue = append(retransmissionQueue, f)
+				}
+			}
+			s.retransmissionQueue = retransmissionQueue
+		}
+	}
+	s.mutex.Unlock()
+
+	s.signalWrite()
+	s.sender.onHasStreamControlFrame(s.streamID, s)
+}
+
+func (s *SendStream) enableResetStreamAt() {
+	s.mutex.Lock()
+	s.supportsResetStreamAt = true
+	s.mutex.Unlock()
+}
+
+func (s *SendStream) updateSendWindow(limit protocol.ByteCount) {
+	s.mutex.Lock()
+	updated := s.flowController.UpdateSendWindow(limit)
+	if !updated { // duplicate or reordered MAX_STREAM_DATA frame
+		s.mutex.Unlock()
+		return
+	}
+	hasStreamData := s.dataForWriting != nil || s.nextFrame != nil
+	s.mutex.Unlock()
+	if hasStreamData {
+		s.sender.onHasStreamData(s.streamID, s)
+	}
+}
+
+func (s *SendStream) handleStopSendingFrame(f *wire.StopSendingFrame) {
+	s.mutex.Lock()
+	if s.shutdownErr != nil {
+		s.mutex.Unlock()
+		return
+	}
+
+	// If the stream was already cancelled (either locally, or due to a previous STOP_SENDING frame),
+	// there's nothing else to do.
+	if s.resetErr != nil && s.reliableOffset() == 0 {
+		s.mutex.Unlock()
+		return
+	}
+	// if the peer stopped reading from the stream, there's no need to transmit any data reliably
+	s.reliableSize = 0
+	s.numOutstandingFrames = 0
+	finalSize := s.writeOffset
+	if s.nextFrameReserved && s.nextFrame != nil {
+		finalSize = max(finalSize, s.nextFrame.Offset+s.nextFrame.DataLen())
+	}
+	s.returnFramesToPool()
+	if s.resetErr == nil {
+		s.resetErr = &StreamError{StreamID: s.streamID, ErrorCode: f.ErrorCode, Remote: true}
+		s.ctxCancel(s.resetErr)
+	}
+	s.queuedResetStreamFrame = &wire.ResetStreamFrame{
+		StreamID:  s.streamID,
+		FinalSize: finalSize,
+		ErrorCode: s.resetErr.ErrorCode,
+	}
+	s.mutex.Unlock()
+
+	s.signalWrite()
+	s.sender.onHasStreamControlFrame(s.streamID, s)
+}
+
+func (s *SendStream) getControlFrame(monotime.Time) (_ ackhandler.Frame, ok, hasMore bool) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if s.queuedResetStreamFrame == nil {
+		return ackhandler.Frame{}, false, false
+	}
+	s.numOutstandingFrames++
+	f := ackhandler.Frame{
+		Frame:   s.queuedResetStreamFrame,
+		Handler: (*sendStreamResetStreamHandler)(s),
+	}
+	s.queuedResetStreamFrame = nil
+	return f, true, false
+}
+
+func (s *SendStream) reliableOffset() protocol.ByteCount {
+	if !s.supportsResetStreamAt {
+		return 0
+	}
+	return s.reliableSize
+}
+
+// The Context is canceled as soon as the write-side of the stream is closed.
+// This happens when Close() or CancelWrite() is called, or when the peer
+// cancels the read-side of their stream.
+// The cancellation cause is set to the error that caused the stream to
+// close, or `context.Canceled` in case the stream is closed without error.
+func (s *SendStream) Context() context.Context {
+	return s.ctx
+}
+
+// SetWriteDeadline sets the deadline for future Write calls
+// and any currently-blocked Write call.
+// Even if write times out, it may return n > 0, indicating that
+// some data was successfully written.
+// A zero value for t means Write will not time out.
+func (s *SendStream) SetWriteDeadline(t time.Time) error {
+	s.mutex.Lock()
+	s.deadline = monotime.FromTime(t)
+	s.mutex.Unlock()
+	s.signalWrite()
+	return nil
+}
+
+// CloseForShutdown closes a stream abruptly.
+// It makes Write unblock (and return the error) immediately.
+// The peer will NOT be informed about this: the stream is closed without sending a FIN or RST.
+func (s *SendStream) closeForShutdown(err error) {
+	s.mutex.Lock()
+	if s.shutdownErr == nil && !s.finishedWriting {
+		s.shutdownErr = err
+		s.returnFramesToPool()
+	}
+	s.mutex.Unlock()
+	s.ctxCancel(err)
+	s.signalWrite()
+}
+
+// signalWrite performs a non-blocking send on the writeChan
+func (s *SendStream) signalWrite() {
+	select {
+	case s.writeChan <- struct{}{}:
+	default:
+	}
+}
+
+type sendStreamAckHandler SendStream
+
+var _ ackhandler.FrameHandler = &sendStreamAckHandler{}
+
+func (s *sendStreamAckHandler) OnAcked(f wire.Frame) {
+	sf := f.(*wire.StreamFrame)
+	sf.PutBack()
+
+	s.mutex.Lock()
+	if s.resetErr != nil && (*SendStream)(s).reliableOffset() == 0 {
+		s.mutex.Unlock()
+		return
+	}
+	s.numOutstandingFrames--
+	if s.numOutstandingFrames < 0 {
+		panic("numOutStandingFrames negative")
+	}
+	completed := (*SendStream)(s).isNewlyCompleted()
+	s.mutex.Unlock()
+
+	if completed {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+}
+
+func (s *sendStreamAckHandler) OnLost(f wire.Frame) {
+	sf := f.(*wire.StreamFrame)
+	s.mutex.Lock()
+	// If the reliable size was 0 when the stream was cancelled,
+	// the number of outstanding frames was immediately set to 0, and the retransmission queue was dropped.
+	if s.resetErr != nil && (*SendStream)(s).reliableOffset() == 0 {
+		// Return the frame to pool since it won't be retransmitted
+		sf.PutBack()
+		s.mutex.Unlock()
+		return
+	}
+	s.numOutstandingFrames--
+	if s.numOutstandingFrames < 0 {
+		panic("numOutStandingFrames negative")
+	}
+
+	if s.resetErr != nil && (*SendStream)(s).reliableOffset() > 0 {
+		// If the stream was reset, and this frame is beyond the reliable offset,
+		// it doesn't need to be retransmitted.
+		if sf.Offset >= (*SendStream)(s).reliableOffset() {
+			sf.PutBack()
+			// If this frame was the last one tracked, losing it might cause the stream to be completed.
+			completed := (*SendStream)(s).isNewlyCompleted()
+			s.mutex.Unlock()
+			if completed {
+				s.sender.onStreamCompleted(s.streamID)
+			}
+			return
+		}
+		// If the payload of the frame extends beyond the reliable size,
+		// truncate the frame to the reliable size.
+		if sf.Offset+sf.DataLen() > (*SendStream)(s).reliableOffset() {
+			sf.Data = sf.Data[:(*SendStream)(s).reliableOffset()-sf.Offset]
+		}
+	}
+
+	sf.DataLenPresent = true
+	s.retransmissionQueue = append(s.retransmissionQueue, sf)
+	s.mutex.Unlock()
+
+	s.sender.onHasStreamData(s.streamID, (*SendStream)(s))
+}
+
+type sendStreamResetStreamHandler SendStream
+
+var _ ackhandler.FrameHandler = &sendStreamResetStreamHandler{}
+
+func (s *sendStreamResetStreamHandler) OnAcked(f wire.Frame) {
+	rsf := f.(*wire.ResetStreamFrame)
+	s.mutex.Lock()
+	// If the peer sent a STOP_SENDING after we sent a RESET_STREAM_AT frame,
+	// we sent 1. reduced the reliable size to 0 and 2. sent a RESET_STREAM frame.
+	// In this case, we don't care about the acknowledgment of this frame.
+	if rsf.ReliableSize != (*SendStream)(s).reliableOffset() {
+		s.mutex.Unlock()
+		return
+	}
+	s.numOutstandingFrames--
+	if s.numOutstandingFrames < 0 {
+		panic("numOutStandingFrames negative")
+	}
+	completed := (*SendStream)(s).isNewlyCompleted()
+	s.mutex.Unlock()
+
+	if completed {
+		s.sender.onStreamCompleted(s.streamID)
+	}
+}
+
+func (s *sendStreamResetStreamHandler) OnLost(f wire.Frame) {
+	rsf := f.(*wire.ResetStreamFrame)
+	s.mutex.Lock()
+	// If the peer sent a STOP_SENDING after we sent a RESET_STREAM_AT frame,
+	// we sent 1. reduced the reliable size to 0 and 2. sent a RESET_STREAM frame.
+	// In this case, the loss of the RESET_STREAM_AT frame can be ignored.
+	if rsf.ReliableSize != (*SendStream)(s).reliableOffset() {
+		s.mutex.Unlock()
+		return
+	}
+	s.queuedResetStreamFrame = rsf
+	s.numOutstandingFrames--
+	s.mutex.Unlock()
+	s.sender.onHasStreamControlFrame(s.streamID, (*SendStream)(s))
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/server.go b/backend/vendor/github.com/quic-go/quic-go/server.go
new file mode 100644
index 00000000..3cd28b7c
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/server.go
@@ -0,0 +1,1119 @@
+package quic
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/handshake"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// ErrServerClosed is returned by the [Listener] or [EarlyListener]'s Accept method after a call to Close.
+var ErrServerClosed = errServerClosed{}
+
+type errServerClosed struct{}
+
+func (errServerClosed) Error() string { return "quic: server closed" }
+func (errServerClosed) Unwrap() error { return net.ErrClosed }
+
+// packetHandler handles packets
+type packetHandler interface {
+	handlePacket(receivedPacket)
+	destroy(error)
+	closeWithTransportError(qerr.TransportErrorCode)
+}
+
+type zeroRTTQueue struct {
+	packets    []receivedPacket
+	expiration monotime.Time
+}
+
+type rejectedPacket struct {
+	receivedPacket
+	hdr *wire.Header
+}
+
+// A Listener of QUIC
+type baseServer struct {
+	tr                        *packetHandlerMap
+	disableVersionNegotiation bool
+	acceptEarlyConns          bool
+
+	tlsConf *tls.Config
+	config  *Config
+
+	conn rawConn
+
+	tokenGenerator *handshake.TokenGenerator
+	maxTokenAge    time.Duration
+
+	connIDGenerator   ConnectionIDGenerator
+	statelessResetter *statelessResetter
+	onClose           func()
+
+	receivedPackets chan receivedPacket
+
+	nextZeroRTTCleanup monotime.Time
+	zeroRTTQueues      map[protocol.ConnectionID]*zeroRTTQueue // only initialized if acceptEarlyConns == true
+
+	connContext func(context.Context, *ClientInfo) (context.Context, error)
+
+	// set as a member, so they can be set in the tests
+	newConn func(
+		context.Context,
+		context.CancelCauseFunc,
+		sendConn,
+		connRunner,
+		protocol.ConnectionID, /* original dest connection ID */
+		*protocol.ConnectionID, /* retry src connection ID */
+		protocol.ConnectionID, /* client dest connection ID */
+		protocol.ConnectionID, /* destination connection ID */
+		protocol.ConnectionID, /* source connection ID */
+		ConnectionIDGenerator,
+		*statelessResetter,
+		*Config,
+		*tls.Config,
+		*handshake.TokenGenerator,
+		bool, /* client address validated by an address validation token */
+		time.Duration,
+		qlogwriter.Trace,
+		utils.Logger,
+		protocol.Version,
+	) *wrappedConn
+
+	closeMx sync.Mutex
+	// errorChan is closed when Close is called. This has two effects:
+	// 1. it cancels handshakes that are still in flight (using CONNECTION_REFUSED) errors
+	// 2. it stops handling of packets passed to this server
+	errorChan chan struct{}
+	// acceptChan is closed when Close returns.
+	// This only happens once all handshake in flight have either completed and canceled.
+	// Calls to Accept will first drain the queue of connections that have completed the handshake,
+	// and then return ErrServerClosed.
+	stopAccepting chan struct{}
+	closeErr      error
+	running       chan struct{} // closed as soon as run() returns
+
+	versionNegotiationQueue chan receivedPacket
+	invalidTokenQueue       chan rejectedPacket
+	connectionRefusedQueue  chan rejectedPacket
+	retryQueue              chan rejectedPacket
+	handshakingCount        sync.WaitGroup
+
+	verifySourceAddress func(net.Addr) bool
+
+	connQueue chan *Conn
+
+	qlogger qlogwriter.Recorder
+
+	logger utils.Logger
+}
+
+// A Listener listens for incoming QUIC connections.
+// It returns connections once the handshake has completed.
+type Listener struct {
+	baseServer *baseServer
+}
+
+// Accept returns new connections. It should be called in a loop.
+func (l *Listener) Accept(ctx context.Context) (*Conn, error) {
+	return l.baseServer.Accept(ctx)
+}
+
+// Close closes the listener.
+// Accept will return [ErrServerClosed] as soon as all connections in the accept queue have been accepted.
+// QUIC handshakes that are still in flight will be rejected with a CONNECTION_REFUSED error.
+// Already established (accepted) connections will be unaffected.
+func (l *Listener) Close() error {
+	return l.baseServer.Close()
+}
+
+// Addr returns the local network address that the server is listening on.
+func (l *Listener) Addr() net.Addr {
+	return l.baseServer.Addr()
+}
+
+// An EarlyListener listens for incoming QUIC connections, and returns them before the handshake completes.
+// For connections that don't use 0-RTT, this allows the server to send 0.5-RTT data.
+// This data is encrypted with forward-secure keys, however, the client's identity has not yet been verified.
+// For connection using 0-RTT, this allows the server to accept and respond to streams that the client opened in the
+// 0-RTT data it sent. Note that at this point during the handshake, the live-ness of the
+// client has not yet been confirmed, and the 0-RTT data could have been replayed by an attacker.
+type EarlyListener struct {
+	baseServer *baseServer
+}
+
+// Accept returns a new connections. It should be called in a loop.
+func (l *EarlyListener) Accept(ctx context.Context) (*Conn, error) {
+	conn, err := l.baseServer.accept(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+// Close closes the listener.
+// Accept will return [ErrServerClosed] as soon as all connections in the accept queue have been accepted.
+// Early connections that are still in flight will be rejected with a CONNECTION_REFUSED error.
+// Already established (accepted) connections will be unaffected.
+func (l *EarlyListener) Close() error {
+	return l.baseServer.Close()
+}
+
+// Addr returns the local network addr that the server is listening on.
+func (l *EarlyListener) Addr() net.Addr {
+	return l.baseServer.Addr()
+}
+
+// ListenAddr creates a QUIC server listening on a given address.
+// See [Listen] for more details.
+func ListenAddr(addr string, tlsConf *tls.Config, config *Config) (*Listener, error) {
+	conn, err := listenUDP(addr)
+	if err != nil {
+		return nil, err
+	}
+	return (&Transport{
+		Conn:        conn,
+		createdConn: true,
+		isSingleUse: true,
+	}).Listen(tlsConf, config)
+}
+
+// ListenAddrEarly works like [ListenAddr], but it returns connections before the handshake completes.
+func ListenAddrEarly(addr string, tlsConf *tls.Config, config *Config) (*EarlyListener, error) {
+	conn, err := listenUDP(addr)
+	if err != nil {
+		return nil, err
+	}
+	return (&Transport{
+		Conn:        conn,
+		createdConn: true,
+		isSingleUse: true,
+	}).ListenEarly(tlsConf, config)
+}
+
+func listenUDP(addr string) (*net.UDPConn, error) {
+	udpAddr, err := net.ResolveUDPAddr("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+	return net.ListenUDP("udp", udpAddr)
+}
+
+// Listen listens for QUIC connections on a given net.PacketConn.
+// If the PacketConn satisfies the [OOBCapablePacketConn] interface (as a [net.UDPConn] does),
+// ECN and packet info support will be enabled. In this case, ReadMsgUDP and WriteMsgUDP
+// will be used instead of ReadFrom and WriteTo to read/write packets.
+// A single net.PacketConn can only be used for a single call to Listen.
+//
+// The tls.Config must not be nil and must contain a certificate configuration.
+// Furthermore, it must define an application control (using [NextProtos]).
+// The quic.Config may be nil, in that case the default values will be used.
+//
+// This is a convenience function. More advanced use cases should instantiate a [Transport],
+// which offers configuration options for a more fine-grained control of the connection establishment,
+// including reusing the underlying UDP socket for outgoing QUIC connections.
+// When closing a listener created with Listen, all established QUIC connections will be closed immediately.
+func Listen(conn net.PacketConn, tlsConf *tls.Config, config *Config) (*Listener, error) {
+	tr := &Transport{Conn: conn, isSingleUse: true}
+	return tr.Listen(tlsConf, config)
+}
+
+// ListenEarly works like [Listen], but it returns connections before the handshake completes.
+func ListenEarly(conn net.PacketConn, tlsConf *tls.Config, config *Config) (*EarlyListener, error) {
+	tr := &Transport{Conn: conn, isSingleUse: true}
+	return tr.ListenEarly(tlsConf, config)
+}
+
+func newServer(
+	conn rawConn,
+	tr *packetHandlerMap,
+	connIDGenerator ConnectionIDGenerator,
+	statelessResetter *statelessResetter,
+	connContext func(context.Context, *ClientInfo) (context.Context, error),
+	tlsConf *tls.Config,
+	config *Config,
+	qlogger qlogwriter.Recorder,
+	onClose func(),
+	tokenGeneratorKey TokenGeneratorKey,
+	maxTokenAge time.Duration,
+	verifySourceAddress func(net.Addr) bool,
+	disableVersionNegotiation bool,
+	acceptEarly bool,
+) *baseServer {
+	s := &baseServer{
+		conn:                      conn,
+		connContext:               connContext,
+		tr:                        tr,
+		tlsConf:                   tlsConf,
+		config:                    config,
+		tokenGenerator:            handshake.NewTokenGenerator(tokenGeneratorKey),
+		maxTokenAge:               maxTokenAge,
+		verifySourceAddress:       verifySourceAddress,
+		connIDGenerator:           connIDGenerator,
+		statelessResetter:         statelessResetter,
+		connQueue:                 make(chan *Conn, protocol.MaxAcceptQueueSize),
+		errorChan:                 make(chan struct{}),
+		stopAccepting:             make(chan struct{}),
+		running:                   make(chan struct{}),
+		receivedPackets:           make(chan receivedPacket, protocol.MaxServerUnprocessedPackets),
+		versionNegotiationQueue:   make(chan receivedPacket, 4),
+		invalidTokenQueue:         make(chan rejectedPacket, 4),
+		connectionRefusedQueue:    make(chan rejectedPacket, 4),
+		retryQueue:                make(chan rejectedPacket, 8),
+		newConn:                   newConnection,
+		qlogger:                   qlogger,
+		logger:                    utils.DefaultLogger.WithPrefix("server"),
+		acceptEarlyConns:          acceptEarly,
+		disableVersionNegotiation: disableVersionNegotiation,
+		onClose:                   onClose,
+	}
+	if acceptEarly {
+		s.zeroRTTQueues = map[protocol.ConnectionID]*zeroRTTQueue{}
+	}
+	go s.run()
+	go s.runSendQueue()
+	s.logger.Debugf("Listening for %s connections on %s", conn.LocalAddr().Network(), conn.LocalAddr().String())
+	return s
+}
+
+func (s *baseServer) run() {
+	defer close(s.running)
+	for {
+		select {
+		case <-s.errorChan:
+			return
+		default:
+		}
+		select {
+		case <-s.errorChan:
+			return
+		case p := <-s.receivedPackets:
+			if bufferStillInUse := s.handlePacketImpl(p); !bufferStillInUse {
+				p.buffer.Release()
+			}
+		}
+	}
+}
+
+func (s *baseServer) runSendQueue() {
+	for {
+		select {
+		case <-s.running:
+			return
+		case p := <-s.versionNegotiationQueue:
+			s.maybeSendVersionNegotiationPacket(p)
+		case p := <-s.invalidTokenQueue:
+			s.maybeSendInvalidToken(p)
+		case p := <-s.connectionRefusedQueue:
+			s.sendConnectionRefused(p)
+		case p := <-s.retryQueue:
+			s.sendRetry(p)
+		}
+	}
+}
+
+// Accept returns connections that already completed the handshake.
+// It is only valid if acceptEarlyConns is false.
+func (s *baseServer) Accept(ctx context.Context) (*Conn, error) {
+	return s.accept(ctx)
+}
+
+func (s *baseServer) accept(ctx context.Context) (*Conn, error) {
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	case conn := <-s.connQueue:
+		return conn, nil
+	case <-s.stopAccepting:
+		// first drain the queue
+		select {
+		case conn := <-s.connQueue:
+			return conn, nil
+		default:
+		}
+		return nil, s.closeErr
+	}
+}
+
+func (s *baseServer) Close() error {
+	s.close(ErrServerClosed, false)
+	return nil
+}
+
+// close closes the server. The Transport mutex must not be held while calling this method.
+// This method closes any handshaking connections which requires the tranpsort mutex.
+func (s *baseServer) close(e error, transportClose bool) {
+	s.closeMx.Lock()
+	if s.closeErr != nil {
+		s.closeMx.Unlock()
+		return
+	}
+	s.closeErr = e
+	close(s.errorChan)
+	<-s.running
+	s.closeMx.Unlock()
+
+	if !transportClose {
+		s.onClose()
+	}
+
+	// wait until all handshakes in flight have terminated
+	s.handshakingCount.Wait()
+	close(s.stopAccepting)
+
+	if transportClose {
+		// if the transport is closing, drain the connQueue. All connections in the queue
+		// will be closed by the transport.
+		for {
+			select {
+			case <-s.connQueue:
+			default:
+				return
+			}
+		}
+	}
+}
+
+// Addr returns the server's network address
+func (s *baseServer) Addr() net.Addr {
+	return s.conn.LocalAddr()
+}
+
+func (s *baseServer) handlePacket(p receivedPacket) {
+	select {
+	case s.receivedPackets <- p:
+	case <-s.errorChan:
+		return
+	default:
+		s.logger.Debugf("Dropping packet from %s (%d bytes). Server receive queue full.", p.remoteAddr, p.Size())
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropDOSPrevention,
+			})
+		}
+	}
+}
+
+func (s *baseServer) handlePacketImpl(p receivedPacket) bool /* is the buffer still in use? */ {
+	if !s.nextZeroRTTCleanup.IsZero() && p.rcvTime.After(s.nextZeroRTTCleanup) {
+		defer s.cleanupZeroRTTQueues(p.rcvTime)
+	}
+
+	if wire.IsVersionNegotiationPacket(p.data) {
+		s.logger.Debugf("Dropping Version Negotiation packet.")
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header:  qlog.PacketHeader{PacketType: qlog.PacketTypeVersionNegotiation},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return false
+	}
+	// Short header packets should never end up here in the first place
+	if !wire.IsLongHeaderPacket(p.data[0]) {
+		panic(fmt.Sprintf("misrouted packet: %#v", p.data))
+	}
+	v, err := wire.ParseVersion(p.data)
+	// drop the packet if we failed to parse the protocol version
+	if err != nil {
+		s.logger.Debugf("Dropping a packet with an unknown version")
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return false
+	}
+	// send a Version Negotiation Packet if the client is speaking a different protocol version
+	if !protocol.IsSupportedVersion(s.config.Versions, v) {
+		if s.disableVersionNegotiation {
+			if s.qlogger != nil {
+				s.qlogger.RecordEvent(qlog.PacketDropped{
+					Header:  qlog.PacketHeader{Version: v},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropUnexpectedVersion,
+				})
+			}
+			return false
+		}
+
+		if p.Size() < protocol.MinUnknownVersionPacketSize {
+			s.logger.Debugf("Dropping a packet with an unsupported version number %d that is too small (%d bytes)", v, p.Size())
+			if s.qlogger != nil {
+				s.qlogger.RecordEvent(qlog.PacketDropped{
+					Header:  qlog.PacketHeader{Version: v},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropUnexpectedPacket,
+				})
+			}
+			return false
+		}
+		return s.enqueueVersionNegotiationPacket(p)
+	}
+
+	if wire.Is0RTTPacket(p.data) {
+		if !s.acceptEarlyConns {
+			if s.qlogger != nil {
+				s.qlogger.RecordEvent(qlog.PacketDropped{
+					Header: qlog.PacketHeader{
+						PacketType:   qlog.PacketType0RTT,
+						PacketNumber: protocol.InvalidPacketNumber,
+					},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropUnexpectedPacket,
+				})
+			}
+			return false
+		}
+		return s.handle0RTTPacket(p)
+	}
+
+	// If we're creating a new connection, the packet will be passed to the connection.
+	// The header will then be parsed again.
+	hdr, _, _, err := wire.ParsePacket(p.data)
+	if err != nil {
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropHeaderParseError,
+			})
+		}
+		s.logger.Debugf("Error parsing packet: %s", err)
+		return false
+	}
+	if hdr.Type == protocol.PacketTypeInitial && p.Size() < protocol.MinInitialPacketSize {
+		s.logger.Debugf("Dropping a packet that is too small to be a valid Initial (%d bytes)", p.Size())
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketTypeInitial,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      v,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return false
+	}
+
+	if hdr.Type != protocol.PacketTypeInitial {
+		// Drop long header packets.
+		// There's little point in sending a Stateless Reset, since the client
+		// might not have received the token yet.
+		s.logger.Debugf("Dropping long header packet of type %s (%d bytes)", hdr.Type, len(p.data))
+		if s.qlogger != nil {
+			var pt qlog.PacketType
+			switch hdr.Type {
+			case protocol.PacketTypeInitial:
+				pt = qlog.PacketTypeInitial
+			case protocol.PacketTypeHandshake:
+				pt = qlog.PacketTypeHandshake
+			case protocol.PacketType0RTT:
+				pt = qlog.PacketType0RTT
+			case protocol.PacketTypeRetry:
+				pt = qlog.PacketTypeRetry
+			}
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   pt,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      v,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return false
+	}
+
+	s.logger.Debugf("<- Received Initial packet.")
+
+	if err := s.handleInitialImpl(p, hdr); err != nil {
+		s.logger.Errorf("Error occurred handling initial packet: %s", err)
+	}
+	// Don't put the packet buffer back.
+	// handleInitialImpl deals with the buffer.
+	return true
+}
+
+func (s *baseServer) handle0RTTPacket(p receivedPacket) bool {
+	connID, err := wire.ParseConnectionID(p.data, 0)
+	if err != nil {
+		if s.qlogger != nil {
+			v, _ := wire.ParseVersion(p.data)
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketType0RTT,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      v,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropHeaderParseError,
+			})
+		}
+		return false
+	}
+
+	// check again if we might have a connection now
+	if handler, ok := s.tr.Get(connID); ok {
+		handler.handlePacket(p)
+		return true
+	}
+
+	if q, ok := s.zeroRTTQueues[connID]; ok {
+		if len(q.packets) >= protocol.Max0RTTQueueLen {
+			if s.qlogger != nil {
+				v, _ := wire.ParseVersion(p.data)
+				s.qlogger.RecordEvent(qlog.PacketDropped{
+					Header: qlog.PacketHeader{
+						PacketType:   qlog.PacketType0RTT,
+						PacketNumber: protocol.InvalidPacketNumber,
+						Version:      v,
+					},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropDOSPrevention,
+				})
+			}
+			return false
+		}
+		q.packets = append(q.packets, p)
+		return true
+	}
+
+	if len(s.zeroRTTQueues) >= protocol.Max0RTTQueues {
+		if s.qlogger != nil {
+			v, _ := wire.ParseVersion(p.data)
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketType0RTT,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      v,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropDOSPrevention,
+			})
+		}
+		return false
+	}
+	queue := &zeroRTTQueue{packets: make([]receivedPacket, 1, 8)}
+	queue.packets[0] = p
+	expiration := p.rcvTime.Add(protocol.Max0RTTQueueingDuration)
+	queue.expiration = expiration
+	if s.nextZeroRTTCleanup.IsZero() || s.nextZeroRTTCleanup.After(expiration) {
+		s.nextZeroRTTCleanup = expiration
+	}
+	s.zeroRTTQueues[connID] = queue
+	return true
+}
+
+func (s *baseServer) cleanupZeroRTTQueues(now monotime.Time) {
+	// Iterate over all queues to find those that are expired.
+	// This is ok since we're placing a pretty low limit on the number of queues.
+	var nextCleanup monotime.Time
+	for connID, q := range s.zeroRTTQueues {
+		if q.expiration.After(now) {
+			if nextCleanup.IsZero() || nextCleanup.After(q.expiration) {
+				nextCleanup = q.expiration
+			}
+			continue
+		}
+		for _, p := range q.packets {
+			if s.qlogger != nil {
+				v, _ := wire.ParseVersion(p.data)
+				s.qlogger.RecordEvent(qlog.PacketDropped{
+					Header: qlog.PacketHeader{
+						PacketType:   qlog.PacketType0RTT,
+						PacketNumber: protocol.InvalidPacketNumber,
+						Version:      v,
+					},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropDOSPrevention,
+				})
+			}
+			p.buffer.Release()
+		}
+		delete(s.zeroRTTQueues, connID)
+		if s.logger.Debug() {
+			s.logger.Debugf("Removing 0-RTT queue for %s.", connID)
+		}
+	}
+	s.nextZeroRTTCleanup = nextCleanup
+}
+
+// validateToken returns false if:
+//   - address is invalid
+//   - token is expired
+//   - token is null
+func (s *baseServer) validateToken(token *handshake.Token, addr net.Addr) bool {
+	if token == nil {
+		return false
+	}
+	if !token.ValidateRemoteAddr(addr) {
+		return false
+	}
+	if !token.IsRetryToken && time.Since(token.SentTime) > s.maxTokenAge {
+		return false
+	}
+	if token.IsRetryToken && time.Since(token.SentTime) > s.config.maxRetryTokenAge() {
+		return false
+	}
+	return true
+}
+
+func (s *baseServer) handleInitialImpl(p receivedPacket, hdr *wire.Header) error {
+	if len(hdr.Token) == 0 && hdr.DestConnectionID.Len() < protocol.MinConnectionIDLenInitial {
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketTypeInitial,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		p.buffer.Release()
+		return errors.New("too short connection ID")
+	}
+
+	// The server queues packets for a while, and we might already have established a connection by now.
+	// This results in a second check in the connection map.
+	// That's ok since it's not the hot path (it's only taken by some Initial and 0-RTT packets).
+	if handler, ok := s.tr.Get(hdr.DestConnectionID); ok {
+		handler.handlePacket(p)
+		return nil
+	}
+
+	var (
+		token              *handshake.Token
+		retrySrcConnID     *protocol.ConnectionID
+		clientAddrVerified bool
+	)
+	origDestConnID := hdr.DestConnectionID
+	if len(hdr.Token) > 0 {
+		tok, err := s.tokenGenerator.DecodeToken(hdr.Token)
+		if err == nil {
+			if tok.IsRetryToken {
+				origDestConnID = tok.OriginalDestConnectionID
+				retrySrcConnID = &tok.RetrySrcConnectionID
+			}
+			token = tok
+		}
+	}
+	if token != nil {
+		clientAddrVerified = s.validateToken(token, p.remoteAddr)
+		if !clientAddrVerified {
+			// For invalid and expired non-retry tokens, we don't send an INVALID_TOKEN error.
+			// We just ignore them, and act as if there was no token on this packet at all.
+			// This also means we might send a Retry later.
+			if !token.IsRetryToken {
+				token = nil
+			} else {
+				// For Retry tokens, we send an INVALID_ERROR if
+				// * the token is too old, or
+				// * the token is invalid, in case of a retry token.
+				select {
+				case s.invalidTokenQueue <- rejectedPacket{receivedPacket: p, hdr: hdr}:
+				default:
+					// drop packet if we can't send out the  INVALID_TOKEN packets fast enough
+					p.buffer.Release()
+				}
+				return nil
+			}
+		}
+	}
+
+	if token == nil && s.verifySourceAddress != nil && s.verifySourceAddress(p.remoteAddr) {
+		// Retry invalidates all 0-RTT packets sent.
+		delete(s.zeroRTTQueues, hdr.DestConnectionID)
+		select {
+		case s.retryQueue <- rejectedPacket{receivedPacket: p, hdr: hdr}:
+		default:
+			// drop packet if we can't send out Retry packets fast enough
+			p.buffer.Release()
+		}
+		return nil
+	}
+
+	// restore RTT from token
+	var rtt time.Duration
+	if token != nil && !token.IsRetryToken {
+		rtt = token.RTT
+	}
+
+	config := s.config
+	clientInfo := &ClientInfo{
+		RemoteAddr:   p.remoteAddr,
+		AddrVerified: clientAddrVerified,
+	}
+	if s.config.GetConfigForClient != nil {
+		conf, err := s.config.GetConfigForClient(clientInfo)
+		if err != nil {
+			s.logger.Debugf("Rejecting new connection due to GetConfigForClient callback")
+			s.refuseNewConn(p, hdr)
+			return nil
+		}
+		config = populateConfig(conf)
+	}
+
+	var conn *wrappedConn
+	var cancel context.CancelCauseFunc
+	ctx, cancel1 := context.WithCancelCause(context.Background())
+	if s.connContext != nil {
+		var err error
+		ctx, err = s.connContext(ctx, clientInfo)
+		if err != nil {
+			cancel1(err)
+			s.logger.Debugf("Rejecting new connection due to ConnContext callback: %s", err)
+			s.refuseNewConn(p, hdr)
+			return nil
+		}
+		if ctx == nil {
+			panic("quic: ConnContext returned nil")
+		}
+		// There's no guarantee that the application returns a context
+		// that's derived from the context we passed into ConnContext.
+		// We need to make sure that both contexts are cancelled.
+		var cancel2 context.CancelCauseFunc
+		ctx, cancel2 = context.WithCancelCause(ctx)
+		cancel = func(cause error) {
+			cancel1(cause)
+			cancel2(cause)
+		}
+	} else {
+		cancel = cancel1
+	}
+	var qlogTrace qlogwriter.Trace
+	if config.Tracer != nil {
+		// Use the same connection ID that is passed to the client's GetLogWriter callback.
+		connID := hdr.DestConnectionID
+		if origDestConnID.Len() > 0 {
+			connID = origDestConnID
+		}
+		qlogTrace = config.Tracer(ctx, false, connID)
+	}
+	connID, err := s.connIDGenerator.GenerateConnectionID()
+	if err != nil {
+		return err
+	}
+	s.logger.Debugf("Changing connection ID to %s.", connID)
+	conn = s.newConn(
+		ctx,
+		cancel,
+		newSendConn(s.conn, p.remoteAddr, p.info, s.logger),
+		s.tr,
+		origDestConnID,
+		retrySrcConnID,
+		hdr.DestConnectionID,
+		hdr.SrcConnectionID,
+		connID,
+		s.connIDGenerator,
+		s.statelessResetter,
+		config,
+		s.tlsConf,
+		s.tokenGenerator,
+		clientAddrVerified,
+		rtt,
+		qlogTrace,
+		s.logger,
+		hdr.Version,
+	)
+	conn.handlePacket(p)
+	// Adding the connection will fail if the client's chosen Destination Connection ID is already in use.
+	// This is very unlikely: Even if an attacker chooses a connection ID that's already in use,
+	// under normal circumstances the packet would just be routed to that connection.
+	// The only time this collision will occur if we receive the two Initial packets at the same time.
+	if added := s.tr.AddWithConnID(hdr.DestConnectionID, connID, conn); !added {
+		delete(s.zeroRTTQueues, hdr.DestConnectionID)
+		conn.closeWithTransportError(ConnectionRefused)
+		return nil
+	}
+	// Pass queued 0-RTT to the newly established connection.
+	if q, ok := s.zeroRTTQueues[hdr.DestConnectionID]; ok {
+		for _, p := range q.packets {
+			conn.handlePacket(p)
+		}
+		delete(s.zeroRTTQueues, hdr.DestConnectionID)
+	}
+
+	s.handshakingCount.Go(func() { s.handleNewConn(conn) })
+	go conn.run()
+	return nil
+}
+
+func (s *baseServer) refuseNewConn(p receivedPacket, hdr *wire.Header) {
+	delete(s.zeroRTTQueues, hdr.DestConnectionID)
+	select {
+	case s.connectionRefusedQueue <- rejectedPacket{receivedPacket: p, hdr: hdr}:
+	default:
+		// drop packet if we can't send out the CONNECTION_REFUSED fast enough
+		p.buffer.Release()
+	}
+}
+
+func (s *baseServer) handleNewConn(conn *wrappedConn) {
+	if s.acceptEarlyConns {
+		// wait until the early connection is ready, the handshake fails, or the server is closed
+		select {
+		case <-s.errorChan:
+			conn.closeWithTransportError(ConnectionRefused)
+			return
+		case <-conn.Context().Done():
+			return
+		case <-conn.earlyConnReady():
+		}
+	} else {
+		// wait until the handshake completes, fails, or the server is closed
+		select {
+		case <-s.errorChan:
+			conn.closeWithTransportError(ConnectionRefused)
+			return
+		case <-conn.Context().Done():
+			return
+		case <-conn.HandshakeComplete():
+		}
+	}
+
+	select {
+	case s.connQueue <- conn.Conn:
+	default:
+		conn.closeWithTransportError(ConnectionRefused)
+	}
+}
+
+func (s *baseServer) sendRetry(p rejectedPacket) {
+	if err := s.sendRetryPacket(p); err != nil {
+		s.logger.Debugf("Error sending Retry packet: %s", err)
+	}
+}
+
+func (s *baseServer) sendRetryPacket(p rejectedPacket) error {
+	hdr := p.hdr
+	// Log the Initial packet now.
+	// If no Retry is sent, the packet will be logged by the connection.
+	(&wire.ExtendedHeader{Header: *hdr}).Log(s.logger)
+	srcConnID, err := s.connIDGenerator.GenerateConnectionID()
+	if err != nil {
+		return err
+	}
+	token, err := s.tokenGenerator.NewRetryToken(p.remoteAddr, hdr.DestConnectionID, srcConnID)
+	if err != nil {
+		return err
+	}
+	replyHdr := &wire.ExtendedHeader{}
+	replyHdr.Type = protocol.PacketTypeRetry
+	replyHdr.Version = hdr.Version
+	replyHdr.SrcConnectionID = srcConnID
+	replyHdr.DestConnectionID = hdr.SrcConnectionID
+	replyHdr.Token = token
+	if s.logger.Debug() {
+		s.logger.Debugf("Changing connection ID to %s.", srcConnID)
+		s.logger.Debugf("-> Sending Retry")
+		replyHdr.Log(s.logger)
+	}
+
+	buf := getPacketBuffer()
+	defer buf.Release()
+	buf.Data, err = replyHdr.Append(buf.Data, hdr.Version)
+	if err != nil {
+		return err
+	}
+	// append the Retry integrity tag
+	tag := handshake.GetRetryIntegrityTag(buf.Data, hdr.DestConnectionID, hdr.Version)
+	buf.Data = append(buf.Data, tag[:]...)
+	if s.qlogger != nil {
+		s.qlogger.RecordEvent(qlog.PacketSent{
+			Header: qlog.PacketHeader{
+				PacketType:       qlog.PacketTypeRetry,
+				SrcConnectionID:  replyHdr.SrcConnectionID,
+				DestConnectionID: replyHdr.DestConnectionID,
+				Version:          replyHdr.Version,
+				Token:            &qlog.Token{Raw: token},
+			},
+			Raw: qlog.RawInfo{
+				Length:        len(buf.Data),
+				PayloadLength: int(replyHdr.Length),
+			},
+		})
+	}
+	_, err = s.conn.WritePacket(buf.Data, p.remoteAddr, p.info.OOB(), 0, protocol.ECNUnsupported)
+	return err
+}
+
+func (s *baseServer) maybeSendInvalidToken(p rejectedPacket) {
+	defer p.buffer.Release()
+
+	// Only send INVALID_TOKEN if we can unprotect the packet.
+	// This makes sure that we won't send it for packets that were corrupted.
+	hdr := p.hdr
+	sealer, opener := handshake.NewInitialAEAD(hdr.DestConnectionID, protocol.PerspectiveServer, hdr.Version)
+	data := p.data[:hdr.ParsedLen()+hdr.Length]
+	extHdr, err := unpackLongHeader(opener, hdr, data)
+	// Only send INVALID_TOKEN if we can unprotect the packet.
+	// This makes sure that we won't send it for packets that were corrupted.
+	if err != nil {
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketTypeInitial,
+					PacketNumber: protocol.InvalidPacketNumber,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropHeaderParseError,
+			})
+		}
+		return
+	}
+	hdrLen := extHdr.ParsedLen()
+	if _, err := opener.Open(data[hdrLen:hdrLen], data[hdrLen:], extHdr.PacketNumber, data[:hdrLen]); err != nil {
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Header: qlog.PacketHeader{
+					PacketType:   qlog.PacketTypeInitial,
+					PacketNumber: protocol.InvalidPacketNumber,
+					Version:      hdr.Version,
+				},
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropPayloadDecryptError,
+			})
+		}
+		return
+	}
+	if s.logger.Debug() {
+		s.logger.Debugf("Client sent an invalid retry token. Sending INVALID_TOKEN to %s.", p.remoteAddr)
+	}
+	if err := s.sendError(p.remoteAddr, hdr, sealer, InvalidToken, p.info); err != nil {
+		s.logger.Debugf("Error sending INVALID_TOKEN error: %s", err)
+	}
+}
+
+func (s *baseServer) sendConnectionRefused(p rejectedPacket) {
+	defer p.buffer.Release()
+	sealer, _ := handshake.NewInitialAEAD(p.hdr.DestConnectionID, protocol.PerspectiveServer, p.hdr.Version)
+	if err := s.sendError(p.remoteAddr, p.hdr, sealer, ConnectionRefused, p.info); err != nil {
+		s.logger.Debugf("Error sending CONNECTION_REFUSED error: %s", err)
+	}
+}
+
+// sendError sends the error as a response to the packet received with header hdr
+func (s *baseServer) sendError(remoteAddr net.Addr, hdr *wire.Header, sealer handshake.LongHeaderSealer, errorCode qerr.TransportErrorCode, info packetInfo) error {
+	b := getPacketBuffer()
+	defer b.Release()
+
+	ccf := &wire.ConnectionCloseFrame{ErrorCode: uint64(errorCode)}
+
+	replyHdr := &wire.ExtendedHeader{}
+	replyHdr.Type = protocol.PacketTypeInitial
+	replyHdr.Version = hdr.Version
+	replyHdr.SrcConnectionID = hdr.DestConnectionID
+	replyHdr.DestConnectionID = hdr.SrcConnectionID
+	replyHdr.PacketNumberLen = protocol.PacketNumberLen4
+	replyHdr.Length = 4 /* packet number len */ + ccf.Length(hdr.Version) + protocol.ByteCount(sealer.Overhead())
+	var err error
+	b.Data, err = replyHdr.Append(b.Data, hdr.Version)
+	if err != nil {
+		return err
+	}
+	payloadOffset := len(b.Data)
+
+	b.Data, err = ccf.Append(b.Data, hdr.Version)
+	if err != nil {
+		return err
+	}
+
+	_ = sealer.Seal(b.Data[payloadOffset:payloadOffset], b.Data[payloadOffset:], replyHdr.PacketNumber, b.Data[:payloadOffset])
+	b.Data = b.Data[0 : len(b.Data)+sealer.Overhead()]
+
+	pnOffset := payloadOffset - int(replyHdr.PacketNumberLen)
+	sealer.EncryptHeader(
+		b.Data[pnOffset+4:pnOffset+4+16],
+		&b.Data[0],
+		b.Data[pnOffset:payloadOffset],
+	)
+
+	replyHdr.Log(s.logger)
+	wire.LogFrame(s.logger, ccf, true)
+	if s.qlogger != nil {
+		s.qlogger.RecordEvent(qlog.PacketSent{
+			Header: qlog.PacketHeader{
+				PacketType:       qlog.PacketTypeInitial,
+				SrcConnectionID:  replyHdr.SrcConnectionID,
+				DestConnectionID: replyHdr.DestConnectionID,
+				PacketNumber:     replyHdr.PacketNumber,
+				Version:          replyHdr.Version,
+			},
+			Raw: qlog.RawInfo{
+				Length:        len(b.Data),
+				PayloadLength: int(replyHdr.Length),
+			},
+			Frames: []qlog.Frame{{Frame: ccf}},
+		})
+	}
+	_, err = s.conn.WritePacket(b.Data, remoteAddr, info.OOB(), 0, protocol.ECNUnsupported)
+	return err
+}
+
+func (s *baseServer) enqueueVersionNegotiationPacket(p receivedPacket) (bufferInUse bool) {
+	select {
+	case s.versionNegotiationQueue <- p:
+		return true
+	default:
+		// it's fine to not send version negotiation packets when we are busy
+	}
+	return false
+}
+
+func (s *baseServer) maybeSendVersionNegotiationPacket(p receivedPacket) {
+	defer p.buffer.Release()
+
+	v, err := wire.ParseVersion(p.data)
+	if err != nil {
+		s.logger.Debugf("failed to parse version for sending version negotiation packet: %s", err)
+		return
+	}
+
+	_, src, dest, err := wire.ParseArbitraryLenConnectionIDs(p.data)
+	if err != nil { // should never happen
+		s.logger.Debugf("Dropping a packet with an unknown version for which we failed to parse connection IDs")
+		if s.qlogger != nil {
+			s.qlogger.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnexpectedPacket,
+			})
+		}
+		return
+	}
+
+	s.logger.Debugf("Client offered version %s, sending Version Negotiation", v)
+
+	data := wire.ComposeVersionNegotiation(dest, src, s.config.Versions)
+	if s.qlogger != nil {
+		s.qlogger.RecordEvent(qlog.VersionNegotiationSent{
+			Header: qlog.PacketHeaderVersionNegotiation{
+				SrcConnectionID:  src,
+				DestConnectionID: dest,
+			},
+			SupportedVersions: s.config.Versions,
+		})
+	}
+	if _, err := s.conn.WritePacket(data, p.remoteAddr, p.info.OOB(), 0, protocol.ECNUnsupported); err != nil {
+		s.logger.Debugf("Error sending Version Negotiation: %s", err)
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sni.go b/backend/vendor/github.com/quic-go/quic-go/sni.go
new file mode 100644
index 00000000..f63023f9
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sni.go
@@ -0,0 +1,136 @@
+package quic
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+const (
+	extTypeSNI = 0
+	extTypeECH = 0xfe0d
+)
+
+// findSNIAndECH parses the given byte slice as a ClientHello, and locates:
+// - the position and length of the Server Name Indication (SNI) extension,
+// - the position of the Encrypted Client Hello (ECH) extension.
+// If no SNI extension is found, it returns -1 for the SNI position.
+// If no ECH extension is found, it returns -1 for the ECH position.
+func findSNIAndECH(data []byte) (sniPos, sniLen, echPos int, err error) {
+	if len(data) < 4 {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	if data[0] != 1 {
+		return 0, 0, 0, errors.New("not a ClientHello")
+	}
+	handshakeLen := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
+	if len(data) != 4+handshakeLen {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+
+	parsePos := 4
+	// Skip protocol version (2 bytes)
+	if parsePos+2 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	parsePos += 2
+	// skip random (32 bytes)
+	if parsePos+32 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	parsePos += 32
+	// session ID
+	if parsePos+1 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	sessionIDLen := int(data[parsePos])
+	parsePos++
+	if parsePos+sessionIDLen > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	parsePos += sessionIDLen
+	// cipher suites
+	if parsePos+2 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	cipherSuitesLen := int(binary.BigEndian.Uint16(data[parsePos:]))
+	parsePos += 2
+	if parsePos+cipherSuitesLen > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	parsePos += cipherSuitesLen
+	// compression methods
+	if parsePos+1 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	compressionMethodsLen := int(data[parsePos])
+	parsePos++
+	if parsePos+compressionMethodsLen > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	parsePos += compressionMethodsLen
+
+	// extensions
+	if parsePos+2 > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	extensionsLen := int(binary.BigEndian.Uint16(data[parsePos:]))
+	parsePos += 2
+	if parsePos+extensionsLen > len(data) {
+		return 0, 0, 0, io.ErrUnexpectedEOF
+	}
+	extensionsStart := parsePos
+	extensions := data[extensionsStart : extensionsStart+extensionsLen]
+
+	// parse extensions
+	var extPos int
+	sniPos = -1
+	echPos = -1
+	for extPos+4 <= extensionsLen {
+		extType := binary.BigEndian.Uint16(extensions[extPos:])
+		extLen := int(binary.BigEndian.Uint16(extensions[extPos+2:]))
+		if extPos+4+extLen > extensionsLen {
+			return 0, 0, 0, io.ErrUnexpectedEOF
+		}
+		switch extType {
+		case extTypeSNI:
+			if sniPos != -1 {
+				return 0, 0, 0, errors.New("multiple SNI extensions")
+			}
+			sniData := extensions[extPos+4 : extPos+4+extLen]
+			if len(sniData) < 2 {
+				return 0, 0, 0, io.ErrUnexpectedEOF
+			}
+			nameListLen := int(binary.BigEndian.Uint16(sniData))
+			if len(sniData) != 2+nameListLen {
+				return 0, 0, 0, io.ErrUnexpectedEOF
+			}
+			listPos := 2
+			for listPos+3 <= nameListLen+2 {
+				nameType := sniData[listPos]
+				sniLen = int(binary.BigEndian.Uint16(sniData[listPos+1:]))
+				if listPos+3+sniLen > len(sniData) {
+					return 0, 0, 0, io.ErrUnexpectedEOF
+				}
+				if nameType == 0 { // host_name
+					sniPos = extensionsStart + extPos + 4 + listPos + 3
+					break // stop after first host_name
+				}
+				listPos += 3 + sniLen
+			}
+			if sniPos == 0 {
+				return 0, 0, 0, errors.New("SNI host_name not found")
+			}
+		case extTypeECH:
+			if echPos != -1 {
+				return 0, 0, 0, errors.New("multiple ECH extensions")
+			}
+			echPos = extensionsStart + extPos
+		}
+		extPos += 4 + extLen
+		if sniPos != -1 && echPos != -1 {
+			break
+		}
+	}
+	return sniPos, sniLen, echPos, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/stateless_reset.go b/backend/vendor/github.com/quic-go/quic-go/stateless_reset.go
new file mode 100644
index 00000000..cd0059a5
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/stateless_reset.go
@@ -0,0 +1,42 @@
+package quic
+
+import (
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"hash"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+type statelessResetter struct {
+	mx sync.Mutex
+	h  hash.Hash
+}
+
+// newStatelessRetter creates a new stateless reset generator.
+// It is valid to use a nil key. In that case, a random key will be used.
+// This makes is impossible for on-path attackers to shut down established connections.
+func newStatelessResetter(key *StatelessResetKey) *statelessResetter {
+	var h hash.Hash
+	if key != nil {
+		h = hmac.New(sha256.New, key[:])
+	} else {
+		b := make([]byte, 32)
+		_, _ = rand.Read(b)
+		h = hmac.New(sha256.New, b)
+	}
+	return &statelessResetter{h: h}
+}
+
+func (r *statelessResetter) GetStatelessResetToken(connID protocol.ConnectionID) protocol.StatelessResetToken {
+	r.mx.Lock()
+	defer r.mx.Unlock()
+
+	var token protocol.StatelessResetToken
+	r.h.Write(connID.Bytes())
+	copy(token[:], r.h.Sum(nil))
+	r.h.Reset()
+	return token
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/stream.go b/backend/vendor/github.com/quic-go/quic-go/stream.go
new file mode 100644
index 00000000..75479c2d
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/stream.go
@@ -0,0 +1,253 @@
+package quic
+
+import (
+	"context"
+	"net"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/ackhandler"
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type deadlineError struct{}
+
+func (deadlineError) Error() string   { return "deadline exceeded" }
+func (deadlineError) Temporary() bool { return true }
+func (deadlineError) Timeout() bool   { return true }
+func (deadlineError) Unwrap() error   { return os.ErrDeadlineExceeded }
+
+var errDeadline net.Error = &deadlineError{}
+
+// The streamSender is notified by the stream about various events.
+type streamSender interface {
+	onHasConnectionData()
+	onHasStreamData(protocol.StreamID, *SendStream)
+	onHasStreamControlFrame(protocol.StreamID, streamControlFrameGetter)
+	// must be called without holding the mutex that is acquired by closeForShutdown
+	onStreamCompleted(protocol.StreamID)
+}
+
+// Each of the both stream halves gets its own uniStreamSender.
+// This is necessary in order to keep track when both halves have been completed.
+type uniStreamSender struct {
+	streamSender
+	onStreamCompletedImpl       func()
+	onHasStreamControlFrameImpl func(protocol.StreamID, streamControlFrameGetter)
+}
+
+func (s *uniStreamSender) onHasStreamData(id protocol.StreamID, str *SendStream) {
+	s.streamSender.onHasStreamData(id, str)
+}
+func (s *uniStreamSender) onStreamCompleted(protocol.StreamID) { s.onStreamCompletedImpl() }
+func (s *uniStreamSender) onHasStreamControlFrame(id protocol.StreamID, str streamControlFrameGetter) {
+	s.onHasStreamControlFrameImpl(id, str)
+}
+
+var _ streamSender = &uniStreamSender{}
+
+type Stream struct {
+	receiveStr *ReceiveStream
+	sendStr    *SendStream
+
+	completedMutex         sync.Mutex
+	sender                 streamSender
+	receiveStreamCompleted bool
+	sendStreamCompleted    bool
+}
+
+var (
+	_ outgoingStream            = &Stream{}
+	_ sendStreamFrameHandler    = &Stream{}
+	_ receiveStreamFrameHandler = &Stream{}
+)
+
+// newStream creates a new Stream
+func newStream(
+	ctx context.Context,
+	streamID protocol.StreamID,
+	sender streamSender,
+	flowController *streamFlowController,
+	supportsResetStreamAt bool,
+) *Stream {
+	s := &Stream{sender: sender}
+	senderForSendStream := &uniStreamSender{
+		streamSender: sender,
+		onStreamCompletedImpl: func() {
+			s.completedMutex.Lock()
+			s.sendStreamCompleted = true
+			s.checkIfCompleted()
+			s.completedMutex.Unlock()
+		},
+		onHasStreamControlFrameImpl: func(id protocol.StreamID, str streamControlFrameGetter) {
+			sender.onHasStreamControlFrame(streamID, s)
+		},
+	}
+	s.sendStr = newSendStream(ctx, streamID, senderForSendStream, flowController, supportsResetStreamAt)
+	senderForReceiveStream := &uniStreamSender{
+		streamSender: sender,
+		onStreamCompletedImpl: func() {
+			s.completedMutex.Lock()
+			s.receiveStreamCompleted = true
+			s.checkIfCompleted()
+			s.completedMutex.Unlock()
+		},
+		onHasStreamControlFrameImpl: func(id protocol.StreamID, str streamControlFrameGetter) {
+			sender.onHasStreamControlFrame(streamID, s)
+		},
+	}
+	s.receiveStr = newReceiveStream(streamID, senderForReceiveStream, flowController)
+	return s
+}
+
+// StreamID returns the stream ID.
+func (s *Stream) StreamID() StreamID {
+	// the result is same for receiveStream and sendStream
+	return s.sendStr.StreamID()
+}
+
+// Read reads data from the stream.
+// Read can be made to time out using [Stream.SetReadDeadline] and [Stream.SetDeadline].
+// If the stream was canceled, the error is a [StreamError].
+func (s *Stream) Read(p []byte) (int, error) {
+	return s.receiveStr.Read(p)
+}
+
+// Peek fills b with stream data, without consuming the stream data.
+// It blocks until len(b) bytes are available, or an error occurs.
+// It respects the stream deadline set by SetReadDeadline.
+// If the stream ends before len(b) bytes are available,
+// it returns the number of bytes peeked along with io.EOF.
+func (s *Stream) Peek(b []byte) (int, error) {
+	return s.receiveStr.Peek(b)
+}
+
+// Write writes data to the stream.
+// Write can be made to time out using [Stream.SetWriteDeadline] or [Stream.SetDeadline].
+// If the stream was canceled, the error is a [StreamError].
+func (s *Stream) Write(p []byte) (int, error) {
+	return s.sendStr.Write(p)
+}
+
+// WriteWithLimit writes data to the stream, subject to an additional send limit.
+// See [SendStream.WriteWithLimit] for more details.
+func (s *Stream) WriteWithLimit(p []byte, limiter func(maxBytes int) int) (int, error) {
+	return s.sendStr.WriteWithLimit(p, limiter)
+}
+
+// TryWriteAll writes data to the stream if it can be queued immediately.
+// See [SendStream.TryWriteAll] for more details.
+func (s *Stream) TryWriteAll(p []byte) error {
+	return s.sendStr.TryWriteAll(p)
+}
+
+// SetReliableBoundary marks the data written to this stream so far as reliable.
+// It is valid to call this function multiple times, thereby increasing the reliable size.
+// It only has an effect if the peer enabled support for the RESET_STREAM_AT extension,
+// otherwise, it is a no-op.
+func (s *Stream) SetReliableBoundary() {
+	s.sendStr.SetReliableBoundary()
+}
+
+// CancelWrite aborts sending on this stream.
+// See [SendStream.CancelWrite] for more details.
+func (s *Stream) CancelWrite(errorCode StreamErrorCode) {
+	s.sendStr.CancelWrite(errorCode)
+}
+
+// CancelRead aborts receiving on this stream.
+// See [ReceiveStream.CancelRead] for more details.
+func (s *Stream) CancelRead(errorCode StreamErrorCode) {
+	s.receiveStr.CancelRead(errorCode)
+}
+
+// SetReceiveFinalSizeCallback sets a callback that is called when the receive side's final size is known.
+// See [ReceiveStream.SetReceiveFinalSizeCallback] for more details.
+// Most applications don't need this. It is mainly useful for protocol layers
+// that need exact stream final sizes, such as WebTransport flow control accounting.
+func (s *Stream) SetReceiveFinalSizeCallback(callback func(int64)) {
+	s.receiveStr.SetReceiveFinalSizeCallback(callback)
+}
+
+// The Context is canceled as soon as the write-side of the stream is closed.
+// See [SendStream.Context] for more details.
+func (s *Stream) Context() context.Context {
+	return s.sendStr.Context()
+}
+
+// Close closes the send-direction of the stream.
+// It does not close the receive-direction of the stream.
+func (s *Stream) Close() error {
+	return s.sendStr.Close()
+}
+
+func (s *Stream) handleResetStreamFrame(frame *wire.ResetStreamFrame, rcvTime monotime.Time) error {
+	return s.receiveStr.handleResetStreamFrame(frame, rcvTime)
+}
+
+func (s *Stream) handleStreamFrame(frame *wire.StreamFrame, rcvTime monotime.Time) error {
+	return s.receiveStr.handleStreamFrame(frame, rcvTime)
+}
+
+func (s *Stream) handleStopSendingFrame(frame *wire.StopSendingFrame) {
+	s.sendStr.handleStopSendingFrame(frame)
+}
+
+func (s *Stream) updateSendWindow(limit protocol.ByteCount) {
+	s.sendStr.updateSendWindow(limit)
+}
+
+func (s *Stream) enableResetStreamAt() {
+	s.sendStr.enableResetStreamAt()
+}
+
+func (s *Stream) popStreamFrame(maxBytes protocol.ByteCount, v protocol.Version) (_ ackhandler.StreamFrame, _ *wire.StreamDataBlockedFrame, hasMore bool) {
+	return s.sendStr.popStreamFrame(maxBytes, v)
+}
+
+func (s *Stream) getControlFrame(now monotime.Time) (_ ackhandler.Frame, ok, hasMore bool) {
+	f, ok, _ := s.sendStr.getControlFrame(now)
+	if ok {
+		return f, true, true
+	}
+	return s.receiveStr.getControlFrame(now)
+}
+
+// SetReadDeadline sets the deadline for future Read calls.
+// See [ReceiveStream.SetReadDeadline] for more details.
+func (s *Stream) SetReadDeadline(t time.Time) error {
+	return s.receiveStr.SetReadDeadline(t)
+}
+
+// SetWriteDeadline sets the deadline for future Write calls.
+// See [SendStream.SetWriteDeadline] for more details.
+func (s *Stream) SetWriteDeadline(t time.Time) error {
+	return s.sendStr.SetWriteDeadline(t)
+}
+
+// SetDeadline sets the read and write deadlines associated with the stream.
+// It is equivalent to calling both SetReadDeadline and SetWriteDeadline.
+func (s *Stream) SetDeadline(t time.Time) error {
+	_ = s.receiveStr.SetReadDeadline(t) // SetReadDeadline never errors
+	_ = s.sendStr.SetWriteDeadline(t)   // SetWriteDeadline never errors
+	return nil
+}
+
+// CloseForShutdown closes a stream abruptly.
+// It makes Read and Write unblock (and return the error) immediately.
+// The peer will NOT be informed about this: the stream is closed without sending a FIN or RST.
+func (s *Stream) closeForShutdown(err error) {
+	s.sendStr.closeForShutdown(err)
+	s.receiveStr.closeForShutdown(err)
+}
+
+// checkIfCompleted is called from the uniStreamSender, when one of the stream halves is completed.
+// It makes sure that the onStreamCompleted callback is only called if both receive and send side have completed.
+func (s *Stream) checkIfCompleted() {
+	if s.sendStreamCompleted && s.receiveStreamCompleted {
+		s.sender.onStreamCompleted(s.StreamID())
+	}
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/streams_map.go b/backend/vendor/github.com/quic-go/quic-go/streams_map.go
new file mode 100644
index 00000000..c7c1886b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/streams_map.go
@@ -0,0 +1,356 @@
+package quic
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+// StreamLimitReachedError is returned from Conn.OpenStream and Conn.OpenUniStream
+// when it is not possible to open a new stream because the number of opens streams reached
+// the peer's stream limit.
+type StreamLimitReachedError struct{}
+
+func (e StreamLimitReachedError) Error() string { return "too many open streams" }
+
+type streamsMap struct {
+	ctx         context.Context // not used for cancellations, but carries the values associated with the connection
+	perspective protocol.Perspective
+
+	maxIncomingBidiStreams uint64
+	maxIncomingUniStreams  uint64
+
+	sender            streamSender
+	queueControlFrame func(wire.Frame)
+	newFlowController func(protocol.StreamID) *streamFlowController
+
+	mutex                 sync.Mutex
+	outgoingBidiStreams   *outgoingStreamsMap[*Stream]
+	outgoingUniStreams    *outgoingStreamsMap[*SendStream]
+	incomingBidiStreams   *incomingStreamsMap[*Stream]
+	incomingUniStreams    *incomingStreamsMap[*ReceiveStream]
+	reset                 bool
+	supportsResetStreamAt bool
+}
+
+func newStreamsMap(
+	ctx context.Context,
+	sender streamSender,
+	queueControlFrame func(wire.Frame),
+	newFlowController func(protocol.StreamID) *streamFlowController,
+	maxIncomingBidiStreams uint64,
+	maxIncomingUniStreams uint64,
+	perspective protocol.Perspective,
+) *streamsMap {
+	m := &streamsMap{
+		ctx:                    ctx,
+		perspective:            perspective,
+		queueControlFrame:      queueControlFrame,
+		newFlowController:      newFlowController,
+		maxIncomingBidiStreams: maxIncomingBidiStreams,
+		maxIncomingUniStreams:  maxIncomingUniStreams,
+		sender:                 sender,
+	}
+	m.initMaps()
+	return m
+}
+
+func (m *streamsMap) initMaps() {
+	m.outgoingBidiStreams = newOutgoingStreamsMap(
+		protocol.StreamTypeBidi,
+		func(id protocol.StreamID) *Stream {
+			return newStream(m.ctx, id, m.sender, m.newFlowController(id), m.supportsResetStreamAt)
+		},
+		m.queueControlFrame,
+		m.perspective,
+	)
+	m.incomingBidiStreams = newIncomingStreamsMap(
+		protocol.StreamTypeBidi,
+		func(id protocol.StreamID) *Stream {
+			return newStream(m.ctx, id, m.sender, m.newFlowController(id), m.supportsResetStreamAt)
+		},
+		m.maxIncomingBidiStreams,
+		m.queueControlFrame,
+		m.perspective,
+	)
+	m.outgoingUniStreams = newOutgoingStreamsMap(
+		protocol.StreamTypeUni,
+		func(id protocol.StreamID) *SendStream {
+			return newSendStream(m.ctx, id, m.sender, m.newFlowController(id), m.supportsResetStreamAt)
+		},
+		m.queueControlFrame,
+		m.perspective,
+	)
+	m.incomingUniStreams = newIncomingStreamsMap(
+		protocol.StreamTypeUni,
+		func(id protocol.StreamID) *ReceiveStream {
+			return newReceiveStream(id, m.sender, m.newFlowController(id))
+		},
+		m.maxIncomingUniStreams,
+		m.queueControlFrame,
+		m.perspective,
+	)
+}
+
+func (m *streamsMap) OpenStream() (*Stream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.outgoingBidiStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.OpenStream()
+}
+
+func (m *streamsMap) OpenStreamSync(ctx context.Context) (*Stream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.outgoingBidiStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.OpenStreamSync(ctx)
+}
+
+func (m *streamsMap) OpenUniStream() (*SendStream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.outgoingUniStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.OpenStream()
+}
+
+func (m *streamsMap) OpenUniStreamSync(ctx context.Context) (*SendStream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.outgoingUniStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.OpenStreamSync(ctx)
+}
+
+func (m *streamsMap) AcceptStream(ctx context.Context) (*Stream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.incomingBidiStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.AcceptStream(ctx)
+}
+
+func (m *streamsMap) AcceptUniStream(ctx context.Context) (*ReceiveStream, error) {
+	m.mutex.Lock()
+	reset := m.reset
+	mm := m.incomingUniStreams
+	m.mutex.Unlock()
+	if reset {
+		return nil, Err0RTTRejected
+	}
+	return mm.AcceptStream(ctx)
+}
+
+func (m *streamsMap) DeleteStream(id protocol.StreamID) error {
+	switch protocol.StreamTypeOf(id) {
+	case protocol.StreamTypeUni:
+		if protocol.StreamInitiator(id) == m.perspective {
+			return m.outgoingUniStreams.DeleteStream(id)
+		}
+		return m.incomingUniStreams.DeleteStream(id)
+	case protocol.StreamTypeBidi:
+		if protocol.StreamInitiator(id) == m.perspective {
+			return m.outgoingBidiStreams.DeleteStream(id)
+		}
+		return m.incomingBidiStreams.DeleteStream(id)
+	}
+	panic("")
+}
+
+func (m *streamsMap) HandleMaxStreamsFrame(f *wire.MaxStreamsFrame) {
+	switch f.Type {
+	case protocol.StreamTypeUni:
+		m.outgoingUniStreams.SetMaxStream(f.MaxStreamNum.StreamID(protocol.StreamTypeUni, m.perspective))
+	case protocol.StreamTypeBidi:
+		m.outgoingBidiStreams.SetMaxStream(f.MaxStreamNum.StreamID(protocol.StreamTypeBidi, m.perspective))
+	}
+}
+
+type sendStreamFrameHandler interface {
+	updateSendWindow(protocol.ByteCount)
+	handleStopSendingFrame(*wire.StopSendingFrame)
+}
+
+func (m *streamsMap) getSendStream(id protocol.StreamID) (sendStreamFrameHandler, error) {
+	switch protocol.StreamTypeOf(id) {
+	case protocol.StreamTypeUni:
+		if protocol.StreamInitiator(id) != m.perspective {
+			// an outgoing unidirectional stream is a send stream, not a receive stream
+			return nil, &qerr.TransportError{
+				ErrorCode:    qerr.StreamStateError,
+				ErrorMessage: fmt.Sprintf("invalid frame for send stream %d", id),
+			}
+		}
+		str, err := m.outgoingUniStreams.GetStream(id)
+		if str == nil || err != nil {
+			return nil, err
+		}
+		return str, nil
+	case protocol.StreamTypeBidi:
+		if protocol.StreamInitiator(id) == m.perspective {
+			str, err := m.outgoingBidiStreams.GetStream(id)
+			if str == nil || err != nil {
+				return nil, err
+			}
+			return str, nil
+		}
+		str, err := m.incomingBidiStreams.GetOrOpenStream(id)
+		if str == nil || err != nil {
+			return nil, err
+		}
+		return str, nil
+	}
+	panic("unreachable")
+}
+
+func (m *streamsMap) HandleMaxStreamDataFrame(f *wire.MaxStreamDataFrame) error {
+	str, err := m.getSendStream(f.StreamID)
+	if err != nil {
+		return err
+	}
+	if str == nil { // stream already deleted
+		return nil
+	}
+	str.updateSendWindow(f.MaximumStreamData)
+	return nil
+}
+
+func (m *streamsMap) HandleStopSendingFrame(f *wire.StopSendingFrame) error {
+	str, err := m.getSendStream(f.StreamID)
+	if err != nil {
+		return err
+	}
+	if str == nil { // stream already deleted
+		return nil
+	}
+	str.handleStopSendingFrame(f)
+	return nil
+}
+
+type receiveStreamFrameHandler interface {
+	handleResetStreamFrame(*wire.ResetStreamFrame, monotime.Time) error
+	handleStreamFrame(*wire.StreamFrame, monotime.Time) error
+}
+
+func (m *streamsMap) getReceiveStream(id protocol.StreamID) (receiveStreamFrameHandler, error) {
+	switch protocol.StreamTypeOf(id) {
+	case protocol.StreamTypeUni:
+		// an outgoing unidirectional stream is a send stream, not a receive stream
+		if protocol.StreamInitiator(id) == m.perspective {
+			return nil, &qerr.TransportError{
+				ErrorCode:    qerr.StreamStateError,
+				ErrorMessage: fmt.Sprintf("invalid frame for receive stream %d", id),
+			}
+		}
+		str, err := m.incomingUniStreams.GetOrOpenStream(id)
+		if err != nil || str == nil {
+			return nil, err
+		}
+		return str, nil
+	case protocol.StreamTypeBidi:
+		var str *Stream
+		var err error
+		if protocol.StreamInitiator(id) == m.perspective {
+			str, err = m.outgoingBidiStreams.GetStream(id)
+		} else {
+			str, err = m.incomingBidiStreams.GetOrOpenStream(id)
+		}
+		if str == nil || err != nil {
+			return nil, err
+		}
+		return str, nil
+	}
+	panic("unreachable")
+}
+
+func (m *streamsMap) HandleStreamDataBlockedFrame(f *wire.StreamDataBlockedFrame) error {
+	if _, err := m.getReceiveStream(f.StreamID); err != nil {
+		return err
+	}
+	// We don't need to do anything in response to a STREAM_DATA_BLOCKED frame,
+	// but we need to make sure that the stream ID is valid.
+	return nil // we don't need to do anything in response to a STREAM_DATA_BLOCKED frame
+}
+
+func (m *streamsMap) HandleResetStreamFrame(f *wire.ResetStreamFrame, rcvTime monotime.Time) error {
+	str, err := m.getReceiveStream(f.StreamID)
+	if err != nil {
+		return err
+	}
+	if str == nil { // stream already deleted
+		return nil
+	}
+	return str.handleResetStreamFrame(f, rcvTime)
+}
+
+func (m *streamsMap) HandleStreamFrame(f *wire.StreamFrame, rcvTime monotime.Time) error {
+	str, err := m.getReceiveStream(f.StreamID)
+	if err != nil {
+		return err
+	}
+	if str == nil { // stream already deleted
+		return nil
+	}
+	return str.handleStreamFrame(f, rcvTime)
+}
+
+func (m *streamsMap) HandleTransportParameters(p *wire.TransportParameters) {
+	m.supportsResetStreamAt = p.EnableResetStreamAt
+	if p.EnableResetStreamAt {
+		m.outgoingBidiStreams.EnableResetStreamAt()
+		m.outgoingUniStreams.EnableResetStreamAt()
+	}
+	m.outgoingBidiStreams.UpdateSendWindow(p.InitialMaxStreamDataBidiRemote)
+	m.outgoingBidiStreams.SetMaxStream(p.MaxBidiStreamNum.StreamID(protocol.StreamTypeBidi, m.perspective))
+	m.outgoingUniStreams.UpdateSendWindow(p.InitialMaxStreamDataUni)
+	m.outgoingUniStreams.SetMaxStream(p.MaxUniStreamNum.StreamID(protocol.StreamTypeUni, m.perspective))
+}
+
+func (m *streamsMap) CloseWithError(err error) {
+	m.outgoingBidiStreams.CloseWithError(err)
+	m.outgoingUniStreams.CloseWithError(err)
+	m.incomingBidiStreams.CloseWithError(err)
+	m.incomingUniStreams.CloseWithError(err)
+}
+
+// ResetFor0RTT resets is used when 0-RTT is rejected. In that case, the streams maps are
+// 1. closed with an Err0RTTRejected, making calls to Open{Uni}Stream{Sync} / Accept{Uni}Stream return that error.
+// 2. reset to their initial state, such that we can immediately process new incoming stream data.
+// Afterwards, calls to Open{Uni}Stream{Sync} / Accept{Uni}Stream will continue to return the error,
+// until UseResetMaps() has been called.
+func (m *streamsMap) ResetFor0RTT() {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+	m.reset = true
+	m.CloseWithError(Err0RTTRejected)
+	m.supportsResetStreamAt = false
+	m.initMaps()
+}
+
+func (m *streamsMap) UseResetMaps() {
+	m.mutex.Lock()
+	m.reset = false
+	m.mutex.Unlock()
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/streams_map_incoming.go b/backend/vendor/github.com/quic-go/quic-go/streams_map_incoming.go
new file mode 100644
index 00000000..c714eaf1
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/streams_map_incoming.go
@@ -0,0 +1,209 @@
+package quic
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type incomingStream interface {
+	closeForShutdown(error)
+}
+
+// When a stream is deleted before it was accepted, we can't delete it from the map immediately.
+// We need to wait until the application accepts it, and delete it then.
+type incomingStreamEntry[T incomingStream] struct {
+	stream       T
+	shouldDelete bool
+}
+
+type incomingStreamsMap[T incomingStream] struct {
+	mutex         sync.RWMutex
+	newStreamChan chan struct{}
+
+	streamType protocol.StreamType
+	streams    map[protocol.StreamID]incomingStreamEntry[T]
+
+	nextStreamToAccept protocol.StreamID // the next stream that will be returned by AcceptStream()
+	nextStreamToOpen   protocol.StreamID // the highest stream that the peer opened
+	maxStream          protocol.StreamID // the highest stream that the peer is allowed to open
+	maxNumStreams      uint64            // maximum number of streams
+
+	newStream        func(protocol.StreamID) T
+	queueMaxStreamID func(*wire.MaxStreamsFrame)
+
+	closeErr error
+}
+
+func newIncomingStreamsMap[T incomingStream](
+	streamType protocol.StreamType,
+	newStream func(protocol.StreamID) T,
+	maxStreams uint64,
+	queueControlFrame func(wire.Frame),
+	pers protocol.Perspective,
+) *incomingStreamsMap[T] {
+	var nextStreamToAccept protocol.StreamID
+	switch {
+	case streamType == protocol.StreamTypeBidi && pers == protocol.PerspectiveServer:
+		nextStreamToAccept = protocol.FirstIncomingBidiStreamServer
+	case streamType == protocol.StreamTypeBidi && pers == protocol.PerspectiveClient:
+		nextStreamToAccept = protocol.FirstIncomingBidiStreamClient
+	case streamType == protocol.StreamTypeUni && pers == protocol.PerspectiveServer:
+		nextStreamToAccept = protocol.FirstIncomingUniStreamServer
+	case streamType == protocol.StreamTypeUni && pers == protocol.PerspectiveClient:
+		nextStreamToAccept = protocol.FirstIncomingUniStreamClient
+	}
+	return &incomingStreamsMap[T]{
+		newStreamChan:      make(chan struct{}, 1),
+		streamType:         streamType,
+		streams:            make(map[protocol.StreamID]incomingStreamEntry[T]),
+		maxStream:          protocol.StreamNum(maxStreams).StreamID(streamType, pers.Opposite()),
+		maxNumStreams:      maxStreams,
+		newStream:          newStream,
+		nextStreamToOpen:   nextStreamToAccept,
+		nextStreamToAccept: nextStreamToAccept,
+		queueMaxStreamID:   func(f *wire.MaxStreamsFrame) { queueControlFrame(f) },
+	}
+}
+
+func (m *incomingStreamsMap[T]) AcceptStream(ctx context.Context) (T, error) {
+	// drain the newStreamChan, so we don't check the map twice if the stream doesn't exist
+	select {
+	case <-m.newStreamChan:
+	default:
+	}
+
+	m.mutex.Lock()
+
+	var id protocol.StreamID
+	var entry incomingStreamEntry[T]
+	for {
+		id = m.nextStreamToAccept
+		if m.closeErr != nil {
+			m.mutex.Unlock()
+			return *new(T), m.closeErr
+		}
+		var ok bool
+		entry, ok = m.streams[id]
+		if ok {
+			break
+		}
+		m.mutex.Unlock()
+		select {
+		case <-ctx.Done():
+			return *new(T), ctx.Err()
+		case <-m.newStreamChan:
+		}
+		m.mutex.Lock()
+	}
+	m.nextStreamToAccept += 4
+	// If this stream was completed before being accepted, we can delete it now.
+	if entry.shouldDelete {
+		if err := m.deleteStream(id); err != nil {
+			m.mutex.Unlock()
+			return *new(T), err
+		}
+	}
+	m.mutex.Unlock()
+	return entry.stream, nil
+}
+
+func (m *incomingStreamsMap[T]) GetOrOpenStream(id protocol.StreamID) (T, error) {
+	m.mutex.RLock()
+	if id > m.maxStream {
+		m.mutex.RUnlock()
+		return *new(T), &qerr.TransportError{
+			ErrorCode:    qerr.StreamLimitError,
+			ErrorMessage: fmt.Sprintf("peer tried to open stream %d (current limit: %d)", id, m.maxStream),
+		}
+	}
+	// if the num is smaller than the highest we accepted
+	// * this stream exists in the map, and we can return it, or
+	// * this stream was already closed, then we can return the nil
+	if id < m.nextStreamToOpen {
+		var s T
+		// If the stream was already queued for deletion, and is just waiting to be accepted, don't return it.
+		if entry, ok := m.streams[id]; ok && !entry.shouldDelete {
+			s = entry.stream
+		}
+		m.mutex.RUnlock()
+		return s, nil
+	}
+	m.mutex.RUnlock()
+
+	m.mutex.Lock()
+	// no need to check the two error conditions from above again
+	// * maxStream can only increase, so if the id was valid before, it definitely is valid now
+	// * highestStream is only modified by this function
+	for newNum := m.nextStreamToOpen; newNum <= id; newNum += 4 {
+		m.streams[newNum] = incomingStreamEntry[T]{stream: m.newStream(newNum)}
+		select {
+		case m.newStreamChan <- struct{}{}:
+		default:
+		}
+	}
+	m.nextStreamToOpen = id + 4
+	entry := m.streams[id]
+	m.mutex.Unlock()
+	return entry.stream, nil
+}
+
+func (m *incomingStreamsMap[T]) DeleteStream(id protocol.StreamID) error {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if err := m.deleteStream(id); err != nil {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.StreamStateError,
+			ErrorMessage: err.Error(),
+		}
+	}
+	return nil
+}
+
+func (m *incomingStreamsMap[T]) deleteStream(id protocol.StreamID) error {
+	if _, ok := m.streams[id]; !ok {
+		return fmt.Errorf("tried to delete unknown incoming stream %d", id)
+	}
+
+	// Don't delete this stream yet, if it was not yet accepted.
+	// Just save it to streamsToDelete map, to make sure it is deleted as soon as it gets accepted.
+	if id >= m.nextStreamToAccept {
+		entry, ok := m.streams[id]
+		if ok && entry.shouldDelete {
+			return fmt.Errorf("tried to delete incoming stream %d multiple times", id)
+		}
+		entry.shouldDelete = true
+		m.streams[id] = entry // can't assign to struct in map, so we need to reassign
+		return nil
+	}
+
+	delete(m.streams, id)
+	// queue a MAX_STREAM_ID frame, giving the peer the option to open a new stream
+	if m.maxNumStreams > uint64(len(m.streams)) {
+		maxStream := m.nextStreamToOpen + 4*protocol.StreamID(m.maxNumStreams-uint64(len(m.streams))-1)
+		// never send a value larger than the maximum value for a stream number
+		if maxStream <= protocol.MaxStreamID {
+			m.maxStream = maxStream
+			m.queueMaxStreamID(&wire.MaxStreamsFrame{
+				Type:         m.streamType,
+				MaxStreamNum: m.maxStream.StreamNum(),
+			})
+		}
+	}
+	return nil
+}
+
+func (m *incomingStreamsMap[T]) CloseWithError(err error) {
+	m.mutex.Lock()
+	m.closeErr = err
+	for _, entry := range m.streams {
+		entry.stream.closeForShutdown(err)
+	}
+	m.mutex.Unlock()
+	close(m.newStreamChan)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/streams_map_outgoing.go b/backend/vendor/github.com/quic-go/quic-go/streams_map_outgoing.go
new file mode 100644
index 00000000..14e087c6
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/streams_map_outgoing.go
@@ -0,0 +1,253 @@
+package quic
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/internal/wire"
+)
+
+type outgoingStream interface {
+	updateSendWindow(protocol.ByteCount)
+	enableResetStreamAt()
+	closeForShutdown(error)
+}
+
+type outgoingStreamsMap[T outgoingStream] struct {
+	mutex sync.RWMutex
+
+	streamType protocol.StreamType
+	streams    map[protocol.StreamID]T
+
+	openQueue []chan struct{}
+
+	nextStream  protocol.StreamID // stream ID of the stream returned by OpenStream(Sync)
+	maxStream   protocol.StreamID // the maximum stream ID we're allowed to open
+	blockedSent bool              // was a STREAMS_BLOCKED sent for the current maxStream
+
+	newStream            func(protocol.StreamID) T
+	queueStreamIDBlocked func(*wire.StreamsBlockedFrame)
+
+	closeErr error
+}
+
+func newOutgoingStreamsMap[T outgoingStream](
+	streamType protocol.StreamType,
+	newStream func(protocol.StreamID) T,
+	queueControlFrame func(wire.Frame),
+	pers protocol.Perspective,
+) *outgoingStreamsMap[T] {
+	var nextStream protocol.StreamID
+	switch {
+	case streamType == protocol.StreamTypeBidi && pers == protocol.PerspectiveServer:
+		nextStream = protocol.FirstOutgoingBidiStreamServer
+	case streamType == protocol.StreamTypeBidi && pers == protocol.PerspectiveClient:
+		nextStream = protocol.FirstOutgoingBidiStreamClient
+	case streamType == protocol.StreamTypeUni && pers == protocol.PerspectiveServer:
+		nextStream = protocol.FirstOutgoingUniStreamServer
+	case streamType == protocol.StreamTypeUni && pers == protocol.PerspectiveClient:
+		nextStream = protocol.FirstOutgoingUniStreamClient
+	}
+	return &outgoingStreamsMap[T]{
+		streamType:           streamType,
+		streams:              make(map[protocol.StreamID]T),
+		maxStream:            protocol.InvalidStreamNum,
+		nextStream:           nextStream,
+		newStream:            newStream,
+		queueStreamIDBlocked: func(f *wire.StreamsBlockedFrame) { queueControlFrame(f) },
+	}
+}
+
+func (m *outgoingStreamsMap[T]) OpenStream() (T, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if m.closeErr != nil {
+		return *new(T), m.closeErr
+	}
+
+	// if there are OpenStreamSync calls waiting, return an error here
+	if len(m.openQueue) > 0 || m.nextStream > m.maxStream {
+		m.maybeSendBlockedFrame()
+		return *new(T), &StreamLimitReachedError{}
+	}
+	return m.openStream(), nil
+}
+
+func (m *outgoingStreamsMap[T]) OpenStreamSync(ctx context.Context) (T, error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if m.closeErr != nil {
+		return *new(T), m.closeErr
+	}
+	if err := ctx.Err(); err != nil {
+		return *new(T), err
+	}
+	if len(m.openQueue) == 0 && m.nextStream <= m.maxStream {
+		return m.openStream(), nil
+	}
+
+	waitChan := make(chan struct{}, 1)
+	m.openQueue = append(m.openQueue, waitChan)
+	m.maybeSendBlockedFrame()
+
+	for {
+		m.mutex.Unlock()
+		select {
+		case <-ctx.Done():
+			m.mutex.Lock()
+			m.openQueue = slices.DeleteFunc(m.openQueue, func(c chan struct{}) bool {
+				return c == waitChan
+			})
+			// If we just received a MAX_STREAMS frame, this might have been the next stream
+			// that could be opened. Make sure we unblock the next OpenStreamSync call.
+			m.maybeUnblockOpenSync()
+			return *new(T), ctx.Err()
+		case <-waitChan:
+		}
+
+		m.mutex.Lock()
+		if m.closeErr != nil {
+			return *new(T), m.closeErr
+		}
+		if err := ctx.Err(); err != nil {
+			m.openQueue = slices.DeleteFunc(m.openQueue, func(c chan struct{}) bool {
+				return c == waitChan
+			})
+			m.maybeUnblockOpenSync()
+			return *new(T), err
+		}
+		if m.nextStream > m.maxStream {
+			// no stream available. Continue waiting
+			continue
+		}
+		str := m.openStream()
+		m.openQueue = m.openQueue[1:]
+		m.maybeUnblockOpenSync()
+		return str, nil
+	}
+}
+
+func (m *outgoingStreamsMap[T]) openStream() T {
+	s := m.newStream(m.nextStream)
+	m.streams[m.nextStream] = s
+	m.nextStream += 4
+	return s
+}
+
+// maybeSendBlockedFrame queues a STREAMS_BLOCKED frame for the current stream offset,
+// if we haven't sent one for this offset yet
+func (m *outgoingStreamsMap[T]) maybeSendBlockedFrame() {
+	if m.blockedSent {
+		return
+	}
+
+	var streamLimit protocol.StreamNum
+	if m.maxStream != protocol.InvalidStreamID {
+		streamLimit = m.maxStream.StreamNum()
+	}
+	m.queueStreamIDBlocked(&wire.StreamsBlockedFrame{
+		Type:        m.streamType,
+		StreamLimit: streamLimit,
+	})
+	m.blockedSent = true
+}
+
+func (m *outgoingStreamsMap[T]) GetStream(id protocol.StreamID) (T, error) {
+	m.mutex.RLock()
+	if id >= m.nextStream {
+		m.mutex.RUnlock()
+		return *new(T), &qerr.TransportError{
+			ErrorCode:    qerr.StreamStateError,
+			ErrorMessage: fmt.Sprintf("peer attempted to open stream %d", id),
+		}
+	}
+	s := m.streams[id]
+	m.mutex.RUnlock()
+	return s, nil
+}
+
+func (m *outgoingStreamsMap[T]) DeleteStream(id protocol.StreamID) error {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if _, ok := m.streams[id]; !ok {
+		return &qerr.TransportError{
+			ErrorCode:    qerr.StreamStateError,
+			ErrorMessage: fmt.Sprintf("tried to delete unknown outgoing stream %d", id),
+		}
+	}
+	delete(m.streams, id)
+	return nil
+}
+
+func (m *outgoingStreamsMap[T]) SetMaxStream(id protocol.StreamID) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	if id <= m.maxStream {
+		return
+	}
+	m.maxStream = id
+	m.blockedSent = false
+	if m.maxStream < m.nextStream-4+4*protocol.StreamID(len(m.openQueue)) {
+		m.maybeSendBlockedFrame()
+	}
+	m.maybeUnblockOpenSync()
+}
+
+// UpdateSendWindow is called when the peer's transport parameters are received.
+// Only in the case of a 0-RTT handshake will we have open streams at this point.
+// We might need to update the send window, in case the server increased it.
+func (m *outgoingStreamsMap[T]) UpdateSendWindow(limit protocol.ByteCount) {
+	m.mutex.Lock()
+	for _, str := range m.streams {
+		str.updateSendWindow(limit)
+	}
+	m.mutex.Unlock()
+}
+
+func (m *outgoingStreamsMap[T]) EnableResetStreamAt() {
+	m.mutex.Lock()
+	for _, str := range m.streams {
+		str.enableResetStreamAt()
+	}
+	m.mutex.Unlock()
+}
+
+// unblockOpenSync unblocks the next OpenStreamSync go-routine to open a new stream
+func (m *outgoingStreamsMap[T]) maybeUnblockOpenSync() {
+	if len(m.openQueue) == 0 {
+		return
+	}
+	if m.nextStream > m.maxStream {
+		return
+	}
+	// unblockOpenSync is called both from OpenStreamSync and from SetMaxStream.
+	// It's sufficient to only unblock OpenStreamSync once.
+	select {
+	case m.openQueue[0] <- struct{}{}:
+	default:
+	}
+}
+
+func (m *outgoingStreamsMap[T]) CloseWithError(err error) {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	m.closeErr = err
+	for _, str := range m.streams {
+		str.closeForShutdown(err)
+	}
+	for _, c := range m.openQueue {
+		if c != nil {
+			close(c)
+		}
+	}
+	m.openQueue = nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn.go
new file mode 100644
index 00000000..ce35de88
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn.go
@@ -0,0 +1,143 @@
+package quic
+
+import (
+	"io"
+	"log"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+type connCapabilities struct {
+	// This connection has the Don't Fragment (DF) bit set.
+	// This means it makes to run DPLPMTUD.
+	DF bool
+	// GSO (Generic Segmentation Offload) supported
+	GSO bool
+	// ECN (Explicit Congestion Notifications) supported
+	ECN bool
+}
+
+// rawConn is a connection that allow reading of a receivedPackeh.
+type rawConn interface {
+	ReadPacket() (receivedPacket, error)
+	// WritePacket writes a packet on the wire.
+	// gsoSize is the size of a single packet, or 0 to disable GSO.
+	// It is invalid to set gsoSize if capabilities.GSO is not set.
+	WritePacket(b []byte, addr net.Addr, packetInfoOOB []byte, gsoSize uint16, ecn protocol.ECN) (int, error)
+	LocalAddr() net.Addr
+	SetReadDeadline(time.Time) error
+	io.Closer
+
+	capabilities() connCapabilities
+}
+
+// OOBCapablePacketConn is a connection that allows the reading of ECN bits from the IP header.
+// If the PacketConn passed to the [Transport] satisfies this interface, quic-go will use it.
+// In this case, ReadMsgUDP() will be used instead of ReadFrom() to read packets.
+type OOBCapablePacketConn interface {
+	net.PacketConn
+	SyscallConn() (syscall.RawConn, error)
+	SetReadBuffer(int) error
+	ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *net.UDPAddr, err error)
+	WriteMsgUDP(b, oob []byte, addr *net.UDPAddr) (n, oobn int, err error)
+}
+
+var _ OOBCapablePacketConn = &net.UDPConn{}
+
+func wrapConn(pc net.PacketConn) (rawConn, error) {
+	if err := setReceiveBuffer(pc); err != nil {
+		if !strings.Contains(err.Error(), "use of closed network connection") {
+			setBufferWarningOnce.Do(func() {
+				if disable, _ := strconv.ParseBool(os.Getenv("QUIC_GO_DISABLE_RECEIVE_BUFFER_WARNING")); disable {
+					return
+				}
+				log.Printf("%s. See https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes for details.", err)
+			})
+		}
+	}
+	if err := setSendBuffer(pc); err != nil {
+		if !strings.Contains(err.Error(), "use of closed network connection") {
+			setBufferWarningOnce.Do(func() {
+				if disable, _ := strconv.ParseBool(os.Getenv("QUIC_GO_DISABLE_RECEIVE_BUFFER_WARNING")); disable {
+					return
+				}
+				log.Printf("%s. See https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes for details.", err)
+			})
+		}
+	}
+
+	conn, ok := pc.(interface {
+		SyscallConn() (syscall.RawConn, error)
+	})
+	var supportsDF bool
+	if ok {
+		rawConn, err := conn.SyscallConn()
+		if err != nil {
+			return nil, err
+		}
+
+		// only set DF on UDP sockets
+		if _, ok := pc.LocalAddr().(*net.UDPAddr); ok {
+			var err error
+			supportsDF, err = setDF(rawConn)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	c, ok := pc.(OOBCapablePacketConn)
+	if !ok {
+		utils.DefaultLogger.Infof("PacketConn is not a net.UDPConn. Disabling optimizations possible on UDP connections.")
+		return &basicConn{PacketConn: pc, supportsDF: supportsDF}, nil
+	}
+	return newConn(c, supportsDF)
+}
+
+// The basicConn is the most trivial implementation of a rawConn.
+// It reads a single packet from the underlying net.PacketConn.
+// It is used when
+// * the net.PacketConn is not a OOBCapablePacketConn, and
+// * when the OS doesn't support OOB.
+type basicConn struct {
+	net.PacketConn
+	supportsDF bool
+}
+
+var _ rawConn = &basicConn{}
+
+func (c *basicConn) ReadPacket() (receivedPacket, error) {
+	buffer := getPacketBuffer()
+	// The packet size should not exceed protocol.MaxPacketBufferSize bytes
+	// If it does, we only read a truncated packet, which will then end up undecryptable
+	buffer.Data = buffer.Data[:protocol.MaxPacketBufferSize]
+	n, addr, err := c.ReadFrom(buffer.Data)
+	if err != nil {
+		return receivedPacket{}, err
+	}
+	return receivedPacket{
+		remoteAddr: addr,
+		rcvTime:    monotime.Now(),
+		data:       buffer.Data[:n],
+		buffer:     buffer,
+	}, nil
+}
+
+func (c *basicConn) WritePacket(b []byte, addr net.Addr, _ []byte, gsoSize uint16, ecn protocol.ECN) (n int, err error) {
+	if gsoSize != 0 {
+		panic("cannot use GSO with a basicConn")
+	}
+	if ecn != protocol.ECNUnsupported {
+		panic("cannot use ECN with a basicConn")
+	}
+	return c.WriteTo(b, addr)
+}
+
+func (c *basicConn) capabilities() connCapabilities { return connCapabilities{DF: c.supportsDF} }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers.go
new file mode 100644
index 00000000..8fe49162
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers.go
@@ -0,0 +1,68 @@
+package quic
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"syscall"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+//go:generate sh -c "echo '// Code generated by go generate. DO NOT EDIT.\n// Source: sys_conn_buffers.go\n' > sys_conn_buffers_write.go && sed -e 's/SetReadBuffer/SetWriteBuffer/g' -e 's/setReceiveBuffer/setSendBuffer/g' -e 's/inspectReadBuffer/inspectWriteBuffer/g' -e 's/protocol\\.DesiredReceiveBufferSize/protocol\\.DesiredSendBufferSize/g' -e 's/forceSetReceiveBuffer/forceSetSendBuffer/g' -e 's/receive buffer/send buffer/g' sys_conn_buffers.go | sed '/^\\/\\/go:generate/d' >> sys_conn_buffers_write.go"
+func setReceiveBuffer(c net.PacketConn) error {
+	conn, ok := c.(interface{ SetReadBuffer(int) error })
+	if !ok {
+		return errors.New("connection doesn't allow setting of receive buffer size. Not a *net.UDPConn?")
+	}
+
+	var syscallConn syscall.RawConn
+	if sc, ok := c.(interface {
+		SyscallConn() (syscall.RawConn, error)
+	}); ok {
+		var err error
+		syscallConn, err = sc.SyscallConn()
+		if err != nil {
+			syscallConn = nil
+		}
+	}
+	// The connection has a SetReadBuffer method, but we couldn't obtain a syscall.RawConn.
+	// This shouldn't happen for a net.UDPConn, but is possible if the connection just implements the
+	// net.PacketConn interface and the SetReadBuffer method.
+	// We have no way of checking if increasing the buffer size actually worked.
+	if syscallConn == nil {
+		return conn.SetReadBuffer(protocol.DesiredReceiveBufferSize)
+	}
+
+	size, err := inspectReadBuffer(syscallConn)
+	if err != nil {
+		return fmt.Errorf("failed to determine receive buffer size: %w", err)
+	}
+	if size >= protocol.DesiredReceiveBufferSize {
+		utils.DefaultLogger.Debugf("Conn has receive buffer of %d kiB (wanted: at least %d kiB)", size/1024, protocol.DesiredReceiveBufferSize/1024)
+		return nil
+	}
+	// Ignore the error. We check if we succeeded by querying the buffer size afterward.
+	_ = conn.SetReadBuffer(protocol.DesiredReceiveBufferSize)
+	newSize, err := inspectReadBuffer(syscallConn)
+	if newSize < protocol.DesiredReceiveBufferSize {
+		// Try again with RCVBUFFORCE on Linux
+		_ = forceSetReceiveBuffer(syscallConn, protocol.DesiredReceiveBufferSize)
+		newSize, err = inspectReadBuffer(syscallConn)
+		if err != nil {
+			return fmt.Errorf("failed to determine receive buffer size: %w", err)
+		}
+	}
+	if err != nil {
+		return fmt.Errorf("failed to determine receive buffer size: %w", err)
+	}
+	if newSize == size {
+		return fmt.Errorf("failed to increase receive buffer size (wanted: %d kiB, got %d kiB)", protocol.DesiredReceiveBufferSize/1024, newSize/1024)
+	}
+	if newSize < protocol.DesiredReceiveBufferSize {
+		return fmt.Errorf("failed to sufficiently increase receive buffer size (was: %d kiB, wanted: %d kiB, got: %d kiB)", size/1024, protocol.DesiredReceiveBufferSize/1024, newSize/1024)
+	}
+	utils.DefaultLogger.Debugf("Increased receive buffer size to %d kiB", newSize/1024)
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers_write.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers_write.go
new file mode 100644
index 00000000..c01a931b
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_buffers_write.go
@@ -0,0 +1,70 @@
+// Code generated by go generate. DO NOT EDIT.
+// Source: sys_conn_buffers.go
+
+package quic
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"syscall"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+func setSendBuffer(c net.PacketConn) error {
+	conn, ok := c.(interface{ SetWriteBuffer(int) error })
+	if !ok {
+		return errors.New("connection doesn't allow setting of send buffer size. Not a *net.UDPConn?")
+	}
+
+	var syscallConn syscall.RawConn
+	if sc, ok := c.(interface {
+		SyscallConn() (syscall.RawConn, error)
+	}); ok {
+		var err error
+		syscallConn, err = sc.SyscallConn()
+		if err != nil {
+			syscallConn = nil
+		}
+	}
+	// The connection has a SetWriteBuffer method, but we couldn't obtain a syscall.RawConn.
+	// This shouldn't happen for a net.UDPConn, but is possible if the connection just implements the
+	// net.PacketConn interface and the SetWriteBuffer method.
+	// We have no way of checking if increasing the buffer size actually worked.
+	if syscallConn == nil {
+		return conn.SetWriteBuffer(protocol.DesiredSendBufferSize)
+	}
+
+	size, err := inspectWriteBuffer(syscallConn)
+	if err != nil {
+		return fmt.Errorf("failed to determine send buffer size: %w", err)
+	}
+	if size >= protocol.DesiredSendBufferSize {
+		utils.DefaultLogger.Debugf("Conn has send buffer of %d kiB (wanted: at least %d kiB)", size/1024, protocol.DesiredSendBufferSize/1024)
+		return nil
+	}
+	// Ignore the error. We check if we succeeded by querying the buffer size afterward.
+	_ = conn.SetWriteBuffer(protocol.DesiredSendBufferSize)
+	newSize, err := inspectWriteBuffer(syscallConn)
+	if newSize < protocol.DesiredSendBufferSize {
+		// Try again with RCVBUFFORCE on Linux
+		_ = forceSetSendBuffer(syscallConn, protocol.DesiredSendBufferSize)
+		newSize, err = inspectWriteBuffer(syscallConn)
+		if err != nil {
+			return fmt.Errorf("failed to determine send buffer size: %w", err)
+		}
+	}
+	if err != nil {
+		return fmt.Errorf("failed to determine send buffer size: %w", err)
+	}
+	if newSize == size {
+		return fmt.Errorf("failed to increase send buffer size (wanted: %d kiB, got %d kiB)", protocol.DesiredSendBufferSize/1024, newSize/1024)
+	}
+	if newSize < protocol.DesiredSendBufferSize {
+		return fmt.Errorf("failed to sufficiently increase send buffer size (was: %d kiB, wanted: %d kiB, got: %d kiB)", size/1024, protocol.DesiredSendBufferSize/1024, newSize/1024)
+	}
+	utils.DefaultLogger.Debugf("Increased send buffer size to %d kiB", newSize/1024)
+	return nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_df.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df.go
new file mode 100644
index 00000000..0db61509
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df.go
@@ -0,0 +1,22 @@
+//go:build !linux && !windows && !darwin
+
+package quic
+
+import (
+	"syscall"
+)
+
+func setDF(syscall.RawConn) (bool, error) {
+	// no-op on unsupported platforms
+	return false, nil
+}
+
+func isSendMsgSizeErr(err error) bool {
+	// to be implemented for more specific platforms
+	return false
+}
+
+func isRecvMsgSizeErr(err error) bool {
+	// to be implemented for more specific platforms
+	return false
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_darwin.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_darwin.go
new file mode 100644
index 00000000..afaa6841
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_darwin.go
@@ -0,0 +1,90 @@
+//go:build darwin
+
+package quic
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+// for macOS versions, see https://en.wikipedia.org/wiki/Darwin_(operating_system)#Darwin_20_onwards
+const (
+	macOSVersion11 = 20
+	macOSVersion15 = 24
+)
+
+func setDF(rawConn syscall.RawConn) (bool, error) {
+	// Setting DF bit is only supported from macOS 11.
+	// https://github.com/chromium/chromium/blob/117.0.5881.2/net/socket/udp_socket_posix.cc#L555
+	version, err := getMacOSVersion()
+	if err != nil || version < macOSVersion11 {
+		return false, err
+	}
+
+	var controlErr error
+	var disableDF bool
+	if err := rawConn.Control(func(fd uintptr) {
+		addr, err := unix.Getsockname(int(fd))
+		if err != nil {
+			controlErr = fmt.Errorf("getsockname: %w", err)
+			return
+		}
+
+		// Dual-stack sockets are effectively IPv6 sockets (with IPV6_ONLY set to 0).
+		// On macOS, the DF bit on dual-stack sockets is controlled by the IPV6_DONTFRAG option.
+		// See https://datatracker.ietf.org/doc/draft-seemann-tsvwg-udp-fragmentation/ for details.
+		switch addr.(type) {
+		case *unix.SockaddrInet4:
+			controlErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_DONTFRAG, 1)
+		case *unix.SockaddrInet6:
+			controlErr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_DONTFRAG, 1)
+
+			// Setting the DF bit on dual-stack sockets works since macOS Sequoia.
+			// Disable DF on dual-stack sockets before Sequoia.
+			if version < macOSVersion15 {
+				// check if this is a dual-stack socket by reading the IPV6_V6ONLY flag
+				v6only, err := unix.GetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_V6ONLY)
+				if err != nil {
+					controlErr = fmt.Errorf("getting IPV6_V6ONLY: %w", err)
+					return
+				}
+				disableDF = v6only == 0
+			}
+		default:
+			controlErr = fmt.Errorf("unknown address type: %T", addr)
+		}
+	}); err != nil {
+		return false, err
+	}
+	if controlErr != nil {
+		return false, controlErr
+	}
+	return !disableDF, nil
+}
+
+func isSendMsgSizeErr(err error) bool {
+	return errors.Is(err, unix.EMSGSIZE)
+}
+
+func isRecvMsgSizeErr(error) bool { return false }
+
+func getMacOSVersion() (int, error) {
+	uname := &unix.Utsname{}
+	if err := unix.Uname(uname); err != nil {
+		return 0, err
+	}
+	before, _, ok := strings.Cut(string(uname.Release[:]), ".")
+	if !ok {
+		return 0, nil
+	}
+	version, err := strconv.Atoi(before)
+	if err != nil {
+		return 0, err
+	}
+	return version, nil
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_linux.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_linux.go
new file mode 100644
index 00000000..b09a2394
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_linux.go
@@ -0,0 +1,42 @@
+//go:build linux
+
+package quic
+
+import (
+	"errors"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+func setDF(rawConn syscall.RawConn) (bool, error) {
+	// Enabling IP_MTU_DISCOVER will force the kernel to return "sendto: message too long"
+	// and the datagram will not be fragmented
+	var errDFIPv4, errDFIPv6 error
+	if err := rawConn.Control(func(fd uintptr) {
+		errDFIPv4 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_MTU_DISCOVER, unix.IP_PMTUDISC_PROBE)
+		errDFIPv6 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_MTU_DISCOVER, unix.IPV6_PMTUDISC_PROBE)
+	}); err != nil {
+		return false, err
+	}
+	switch {
+	case errDFIPv4 == nil && errDFIPv6 == nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv4 and IPv6.")
+	case errDFIPv4 == nil && errDFIPv6 != nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv4.")
+	case errDFIPv4 != nil && errDFIPv6 == nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv6.")
+	case errDFIPv4 != nil && errDFIPv6 != nil:
+		return false, errors.New("setting DF failed for both IPv4 and IPv6")
+	}
+	return true, nil
+}
+
+func isSendMsgSizeErr(err error) bool {
+	// https://man7.org/linux/man-pages/man7/udp.7.html
+	return errors.Is(err, unix.EMSGSIZE)
+}
+
+func isRecvMsgSizeErr(error) bool { return false }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_windows.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_windows.go
new file mode 100644
index 00000000..4c140f00
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_df_windows.go
@@ -0,0 +1,52 @@
+//go:build windows
+
+package quic
+
+import (
+	"errors"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+const (
+	// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/constant.IP_DONTFRAGMENT.html
+	//nolint:stylecheck
+	IP_DONTFRAGMENT = 14
+	// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/constant.IPV6_DONTFRAG.html
+	//nolint:stylecheck
+	IPV6_DONTFRAG = 14
+)
+
+func setDF(rawConn syscall.RawConn) (bool, error) {
+	var errDFIPv4, errDFIPv6 error
+	if err := rawConn.Control(func(fd uintptr) {
+		errDFIPv4 = windows.SetsockoptInt(windows.Handle(fd), windows.IPPROTO_IP, IP_DONTFRAGMENT, 1)
+		errDFIPv6 = windows.SetsockoptInt(windows.Handle(fd), windows.IPPROTO_IPV6, IPV6_DONTFRAG, 1)
+	}); err != nil {
+		return false, err
+	}
+	switch {
+	case errDFIPv4 == nil && errDFIPv6 == nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv4 and IPv6.")
+	case errDFIPv4 == nil && errDFIPv6 != nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv4.")
+	case errDFIPv4 != nil && errDFIPv6 == nil:
+		utils.DefaultLogger.Debugf("Setting DF for IPv6.")
+	case errDFIPv4 != nil && errDFIPv6 != nil:
+		return false, errors.New("setting DF failed for both IPv4 and IPv6")
+	}
+	return true, nil
+}
+
+func isSendMsgSizeErr(err error) bool {
+	// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
+	return errors.Is(err, windows.WSAEMSGSIZE)
+}
+
+func isRecvMsgSizeErr(err error) bool {
+	// https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
+	return errors.Is(err, windows.WSAEMSGSIZE)
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_darwin.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_darwin.go
new file mode 100644
index 00000000..a04bfb3c
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_darwin.go
@@ -0,0 +1,38 @@
+//go:build darwin
+
+package quic
+
+import (
+	"encoding/binary"
+	"net/netip"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	msgTypeIPTOS = unix.IP_RECVTOS
+	ipv4PKTINFO  = unix.IP_RECVPKTINFO
+)
+
+const ecnIPv4DataLen = 4
+
+// ReadBatch only returns a single packet on OSX,
+// see https://godoc.org/golang.org/x/net/ipv4#PacketConn.ReadBatch.
+const batchSize = 1
+
+func parseIPv4PktInfo(body []byte) (ip netip.Addr, ifIndex uint32, ok bool) {
+	// struct in_pktinfo {
+	// 	unsigned int   ipi_ifindex;  /* Interface index */
+	// 	struct in_addr ipi_spec_dst; /* Local address */
+	// 	struct in_addr ipi_addr;     /* Header Destination address */
+	// };
+	if len(body) != 12 {
+		return netip.Addr{}, 0, false
+	}
+	return netip.AddrFrom4(*(*[4]byte)(body[8:12])), binary.NativeEndian.Uint32(body), true
+}
+
+func isGSOEnabled(syscall.RawConn) bool { return false }
+
+func isECNEnabled() bool { return !isECNDisabledUsingEnv() }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_freebsd.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_freebsd.go
new file mode 100644
index 00000000..521f80d4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_freebsd.go
@@ -0,0 +1,33 @@
+//go:build freebsd
+
+package quic
+
+import (
+	"net/netip"
+	"syscall"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	msgTypeIPTOS = unix.IP_RECVTOS
+	ipv4PKTINFO  = 0x7
+)
+
+const ecnIPv4DataLen = 1
+
+const batchSize = 8
+
+func parseIPv4PktInfo(body []byte) (ip netip.Addr, _ uint32, ok bool) {
+	// struct in_pktinfo {
+	// 	struct in_addr ipi_addr;     /* Header Destination address */
+	// };
+	if len(body) != 4 {
+		return netip.Addr{}, 0, false
+	}
+	return netip.AddrFrom4(*(*[4]byte)(body)), 0, true
+}
+
+func isGSOEnabled(syscall.RawConn) bool { return false }
+
+func isECNEnabled() bool { return !isECNDisabledUsingEnv() }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_linux.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_linux.go
new file mode 100644
index 00000000..9a890cbe
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_linux.go
@@ -0,0 +1,156 @@
+//go:build linux
+
+package quic
+
+import (
+	"encoding/binary"
+	"errors"
+	"net/netip"
+	"os"
+	"strconv"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+const (
+	msgTypeIPTOS = unix.IP_TOS
+	ipv4PKTINFO  = unix.IP_PKTINFO
+)
+
+const ecnIPv4DataLen = 1
+
+const batchSize = 8 // needs to smaller than MaxUint8 (otherwise the type of oobConn.readPos has to be changed)
+
+var kernelVersionMajor int
+
+func init() {
+	kernelVersionMajor, _ = kernelVersion()
+}
+
+func forceSetReceiveBuffer(c syscall.RawConn, bytes int) error {
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		serr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUFFORCE, bytes)
+	}); err != nil {
+		return err
+	}
+	return serr
+}
+
+func forceSetSendBuffer(c syscall.RawConn, bytes int) error {
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		serr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_SNDBUFFORCE, bytes)
+	}); err != nil {
+		return err
+	}
+	return serr
+}
+
+func parseIPv4PktInfo(body []byte) (ip netip.Addr, ifIndex uint32, ok bool) {
+	// struct in_pktinfo {
+	// 	unsigned int   ipi_ifindex;  /* Interface index */
+	// 	struct in_addr ipi_spec_dst; /* Local address */
+	// 	struct in_addr ipi_addr;     /* Header Destination address */
+	// };
+	if len(body) != 12 {
+		return netip.Addr{}, 0, false
+	}
+	return netip.AddrFrom4(*(*[4]byte)(body[8:12])), binary.NativeEndian.Uint32(body), true
+}
+
+// isGSOEnabled tests if the kernel supports GSO.
+// Sending with GSO might still fail later on, if the interface doesn't support it (see isGSOError).
+func isGSOEnabled(conn syscall.RawConn) bool {
+	if kernelVersionMajor < 5 {
+		return false
+	}
+	disabled, err := strconv.ParseBool(os.Getenv("QUIC_GO_DISABLE_GSO"))
+	if err == nil && disabled {
+		return false
+	}
+	var serr error
+	if err := conn.Control(func(fd uintptr) {
+		_, serr = unix.GetsockoptInt(int(fd), unix.IPPROTO_UDP, unix.UDP_SEGMENT)
+	}); err != nil {
+		return false
+	}
+	return serr == nil
+}
+
+func appendUDPSegmentSizeMsg(b []byte, size uint16) []byte {
+	startLen := len(b)
+	const dataLen = 2 // payload is a uint16
+	b = append(b, make([]byte, unix.CmsgSpace(dataLen))...)
+	h := (*unix.Cmsghdr)(unsafe.Pointer(&b[startLen]))
+	h.Level = syscall.IPPROTO_UDP
+	h.Type = unix.UDP_SEGMENT
+	h.SetLen(unix.CmsgLen(dataLen))
+
+	// UnixRights uses the private `data` method, but I *think* this achieves the same goal.
+	offset := startLen + unix.CmsgSpace(0)
+	*(*uint16)(unsafe.Pointer(&b[offset])) = size
+	return b
+}
+
+func isGSOError(err error) bool {
+	var serr *os.SyscallError
+	if errors.As(err, &serr) {
+		// EIO is returned by udp_send_skb() if the device driver does not have tx checksums enabled,
+		// which is a hard requirement of UDP_SEGMENT. See:
+		// https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/man7/udp.7?id=806eabd74910447f21005160e90957bde4db0183#n228
+		// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/ipv4/udp.c?h=v6.2&id=c9c3395d5e3dcc6daee66c6908354d47bf98cb0c#n942
+		return serr.Err == unix.EIO
+	}
+	return false
+}
+
+// The first sendmsg call on a new UDP socket sometimes errors on Linux.
+// It's not clear why this happens.
+// See https://github.com/golang/go/issues/63322.
+func isPermissionError(err error) bool {
+	var serr *os.SyscallError
+	if errors.As(err, &serr) {
+		return serr.Syscall == "sendmsg" && serr.Err == unix.EPERM
+	}
+	return false
+}
+
+func isECNEnabled() bool {
+	return kernelVersionMajor >= 5 && !isECNDisabledUsingEnv()
+}
+
+// kernelVersion returns major and minor kernel version numbers, parsed from
+// the syscall.Uname's Release field, or 0, 0 if the version can't be obtained
+// or parsed.
+//
+// copied from the standard library's internal/syscall/unix/kernel_version_linux.go
+func kernelVersion() (major, minor int) {
+	var uname syscall.Utsname
+	if err := syscall.Uname(&uname); err != nil {
+		return
+	}
+
+	var (
+		values    [2]int
+		value, vi int
+	)
+	for _, c := range uname.Release {
+		if '0' <= c && c <= '9' {
+			value = (value * 10) + int(c-'0')
+		} else {
+			// Note that we're assuming N.N.N here.
+			// If we see anything else, we are likely to mis-parse it.
+			values[vi] = value
+			vi++
+			if vi >= len(values) {
+				break
+			}
+			value = 0
+		}
+	}
+
+	return values[0], values[1]
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_nonlinux.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_nonlinux.go
new file mode 100644
index 00000000..f8d69803
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_helper_nonlinux.go
@@ -0,0 +1,10 @@
+//go:build !linux
+
+package quic
+
+func forceSetReceiveBuffer(c any, bytes int) error { return nil }
+func forceSetSendBuffer(c any, bytes int) error    { return nil }
+
+func appendUDPSegmentSizeMsg([]byte, uint16) []byte { return nil }
+func isGSOError(error) bool                         { return false }
+func isPermissionError(err error) bool              { return false }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_no_oob.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_no_oob.go
new file mode 100644
index 00000000..2a1f807e
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_no_oob.go
@@ -0,0 +1,21 @@
+//go:build !darwin && !linux && !freebsd && !windows
+
+package quic
+
+import (
+	"net"
+	"net/netip"
+)
+
+func newConn(c net.PacketConn, supportsDF bool) (*basicConn, error) {
+	return &basicConn{PacketConn: c, supportsDF: supportsDF}, nil
+}
+
+func inspectReadBuffer(any) (int, error)  { return 0, nil }
+func inspectWriteBuffer(any) (int, error) { return 0, nil }
+
+type packetInfo struct {
+	addr netip.Addr
+}
+
+func (i *packetInfo) OOB() []byte { return nil }
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_oob.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_oob.go
new file mode 100644
index 00000000..8a5f37bd
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_oob.go
@@ -0,0 +1,338 @@
+//go:build darwin || linux || freebsd
+
+package quic
+
+import (
+	"encoding/binary"
+	"errors"
+	"log"
+	"net"
+	"net/netip"
+	"os"
+	"strconv"
+	"sync"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/net/ipv4"
+	"golang.org/x/net/ipv6"
+	"golang.org/x/sys/unix"
+
+	"github.com/quic-go/quic-go/internal/monotime"
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+const (
+	ecnMask       = 0x3
+	oobBufferSize = 128
+)
+
+// Contrary to what the naming suggests, the ipv{4,6}.Message is not dependent on the IP version.
+// They're both just aliases for x/net/internal/socket.Message.
+// This means we can use this struct to read from a socket that receives both IPv4 and IPv6 messages.
+var _ ipv4.Message = ipv6.Message{}
+
+type batchConn interface {
+	ReadBatch(ms []ipv4.Message, flags int) (int, error)
+}
+
+func inspectReadBuffer(c syscall.RawConn) (int, error) {
+	var size int
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		size, serr = unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF)
+	}); err != nil {
+		return 0, err
+	}
+	return size, serr
+}
+
+func inspectWriteBuffer(c syscall.RawConn) (int, error) {
+	var size int
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		size, serr = unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_SNDBUF)
+	}); err != nil {
+		return 0, err
+	}
+	return size, serr
+}
+
+func isECNDisabledUsingEnv() bool {
+	disabled, err := strconv.ParseBool(os.Getenv("QUIC_GO_DISABLE_ECN"))
+	return err == nil && disabled
+}
+
+type oobConn struct {
+	OOBCapablePacketConn
+	batchConn batchConn
+
+	readPos uint8
+	// Packets received from the kernel, but not yet returned by ReadPacket().
+	messages []ipv4.Message
+	buffers  [batchSize]*packetBuffer
+
+	cap connCapabilities
+}
+
+var _ rawConn = &oobConn{}
+
+func newConn(c OOBCapablePacketConn, supportsDF bool) (*oobConn, error) {
+	rawConn, err := c.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+	var needsPacketInfo bool
+	if udpAddr, ok := c.LocalAddr().(*net.UDPAddr); ok && udpAddr.IP.IsUnspecified() {
+		needsPacketInfo = true
+	}
+	// We don't know if this a IPv4-only, IPv6-only or a IPv4-and-IPv6 connection.
+	// Try enabling receiving of ECN and packet info for both IP versions.
+	// We expect at least one of those syscalls to succeed.
+	var errECNIPv4, errECNIPv6, errPIIPv4, errPIIPv6 error
+	if err := rawConn.Control(func(fd uintptr) {
+		errECNIPv4 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_RECVTOS, 1)
+		errECNIPv6 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVTCLASS, 1)
+
+		if needsPacketInfo {
+			errPIIPv4 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, ipv4PKTINFO, 1)
+			errPIIPv6 = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVPKTINFO, 1)
+		}
+	}); err != nil {
+		return nil, err
+	}
+	switch {
+	case errECNIPv4 == nil && errECNIPv6 == nil:
+		utils.DefaultLogger.Debugf("Activating reading of ECN bits for IPv4 and IPv6.")
+	case errECNIPv4 == nil && errECNIPv6 != nil:
+		utils.DefaultLogger.Debugf("Activating reading of ECN bits for IPv4.")
+	case errECNIPv4 != nil && errECNIPv6 == nil:
+		utils.DefaultLogger.Debugf("Activating reading of ECN bits for IPv6.")
+	case errECNIPv4 != nil && errECNIPv6 != nil:
+		return nil, errors.New("activating ECN failed for both IPv4 and IPv6")
+	}
+	if needsPacketInfo {
+		switch {
+		case errPIIPv4 == nil && errPIIPv6 == nil:
+			utils.DefaultLogger.Debugf("Activating reading of packet info for IPv4 and IPv6.")
+		case errPIIPv4 == nil && errPIIPv6 != nil:
+			utils.DefaultLogger.Debugf("Activating reading of packet info bits for IPv4.")
+		case errPIIPv4 != nil && errPIIPv6 == nil:
+			utils.DefaultLogger.Debugf("Activating reading of packet info bits for IPv6.")
+		case errPIIPv4 != nil && errPIIPv6 != nil:
+			return nil, errors.New("activating packet info failed for both IPv4 and IPv6")
+		}
+	}
+
+	// Allows callers to pass in a connection that already satisfies batchConn interface
+	// to make use of the optimisation. Otherwise, ipv4.NewPacketConn would unwrap the file descriptor
+	// via SyscallConn(), and read it that way, which might not be what the caller wants.
+	var bc batchConn
+	if ibc, ok := c.(batchConn); ok {
+		bc = ibc
+	} else {
+		bc = ipv4.NewPacketConn(c)
+	}
+
+	msgs := make([]ipv4.Message, batchSize)
+	for i := range msgs {
+		// preallocate the [][]byte
+		msgs[i].Buffers = make([][]byte, 1)
+	}
+	oobConn := &oobConn{
+		OOBCapablePacketConn: c,
+		batchConn:            bc,
+		messages:             msgs,
+		readPos:              batchSize,
+		cap: connCapabilities{
+			DF:  supportsDF,
+			GSO: isGSOEnabled(rawConn),
+			ECN: isECNEnabled(),
+		},
+	}
+	for i := range batchSize {
+		oobConn.messages[i].OOB = make([]byte, oobBufferSize)
+	}
+	return oobConn, nil
+}
+
+var invalidCmsgOnceV4, invalidCmsgOnceV6 sync.Once
+
+func (c *oobConn) ReadPacket() (receivedPacket, error) {
+	if len(c.messages) == int(c.readPos) { // all messages read. Read the next batch of messages.
+		c.messages = c.messages[:batchSize]
+		// replace buffers data buffers up to the packet that has been consumed during the last ReadBatch call
+		for i := uint8(0); i < c.readPos; i++ {
+			buffer := getPacketBuffer()
+			buffer.Data = buffer.Data[:protocol.MaxPacketBufferSize]
+			c.buffers[i] = buffer
+			c.messages[i].Buffers[0] = c.buffers[i].Data
+		}
+		c.readPos = 0
+
+		n, err := c.batchConn.ReadBatch(c.messages, 0)
+		if n == 0 || err != nil {
+			return receivedPacket{}, err
+		}
+		c.messages = c.messages[:n]
+	}
+
+	msg := c.messages[c.readPos]
+	buffer := c.buffers[c.readPos]
+	c.readPos++
+
+	data := msg.OOB[:msg.NN]
+	p := receivedPacket{
+		remoteAddr: msg.Addr,
+		rcvTime:    monotime.Now(),
+		data:       msg.Buffers[0][:msg.N],
+		buffer:     buffer,
+	}
+	for len(data) > 0 {
+		hdr, body, remainder, err := unix.ParseOneSocketControlMessage(data)
+		if err != nil {
+			return receivedPacket{}, err
+		}
+		if hdr.Level == unix.IPPROTO_IP {
+			switch hdr.Type {
+			case msgTypeIPTOS:
+				if len(body) != 1 {
+					return receivedPacket{}, errors.New("invalid IPTOS size")
+				}
+				p.ecn = protocol.ParseECNHeaderBits(body[0] & ecnMask)
+			case ipv4PKTINFO:
+				ip, ifIndex, ok := parseIPv4PktInfo(body)
+				if ok {
+					p.info.addr = ip
+					p.info.ifIndex = ifIndex
+				} else {
+					invalidCmsgOnceV4.Do(func() {
+						log.Printf("Received invalid IPv4 packet info control message: %+x. "+
+							"This should never occur, please open a new issue and include details about the architecture.", body)
+					})
+				}
+			}
+		}
+		if hdr.Level == unix.IPPROTO_IPV6 {
+			switch hdr.Type {
+			case unix.IPV6_TCLASS:
+				if len(body) != 4 {
+					return receivedPacket{}, errors.New("invalid IPV6_TCLASS size")
+				}
+				bits := uint8(binary.NativeEndian.Uint32(body)) & ecnMask
+				p.ecn = protocol.ParseECNHeaderBits(bits)
+			case unix.IPV6_PKTINFO:
+				// struct in6_pktinfo {
+				// 	struct in6_addr ipi6_addr;    /* src/dst IPv6 address */
+				// 	unsigned int    ipi6_ifindex; /* send/recv interface index */
+				// };
+				if len(body) == 20 {
+					p.info.addr = netip.AddrFrom16(*(*[16]byte)(body[:16])).Unmap()
+					p.info.ifIndex = binary.NativeEndian.Uint32(body[16:])
+				} else {
+					invalidCmsgOnceV6.Do(func() {
+						log.Printf("Received invalid IPv6 packet info control message: %+x. "+
+							"This should never occur, please open a new issue and include details about the architecture.", body)
+					})
+				}
+			}
+		}
+		data = remainder
+	}
+	return p, nil
+}
+
+// WritePacket writes a new packet.
+func (c *oobConn) WritePacket(b []byte, addr net.Addr, packetInfoOOB []byte, gsoSize uint16, ecn protocol.ECN) (int, error) {
+	oob := packetInfoOOB
+	if gsoSize > 0 {
+		if !c.capabilities().GSO {
+			panic("GSO disabled")
+		}
+		oob = appendUDPSegmentSizeMsg(oob, gsoSize)
+	}
+	if ecn != protocol.ECNUnsupported {
+		if !c.capabilities().ECN {
+			panic("tried to send an ECN-marked packet although ECN is disabled")
+		}
+		if remoteUDPAddr, ok := addr.(*net.UDPAddr); ok {
+			if remoteUDPAddr.IP.To4() != nil {
+				oob = appendIPv4ECNMsg(oob, ecn)
+			} else {
+				oob = appendIPv6ECNMsg(oob, ecn)
+			}
+		}
+	}
+	n, _, err := c.WriteMsgUDP(b, oob, addr.(*net.UDPAddr))
+	return n, err
+}
+
+func (c *oobConn) capabilities() connCapabilities {
+	return c.cap
+}
+
+type packetInfo struct {
+	addr    netip.Addr
+	ifIndex uint32
+}
+
+func (info *packetInfo) OOB() []byte {
+	if info == nil {
+		return nil
+	}
+	if info.addr.Is4() {
+		ip := info.addr.As4()
+		// struct in_pktinfo {
+		// 	unsigned int   ipi_ifindex;  /* Interface index */
+		// 	struct in_addr ipi_spec_dst; /* Local address */
+		// 	struct in_addr ipi_addr;     /* Header Destination address */
+		// };
+		cm := ipv4.ControlMessage{
+			Src:     ip[:],
+			IfIndex: int(info.ifIndex),
+		}
+		return cm.Marshal()
+	} else if info.addr.Is6() {
+		ip := info.addr.As16()
+		// struct in6_pktinfo {
+		// 	struct in6_addr ipi6_addr;    /* src/dst IPv6 address */
+		// 	unsigned int    ipi6_ifindex; /* send/recv interface index */
+		// };
+		cm := ipv6.ControlMessage{
+			Src:     ip[:],
+			IfIndex: int(info.ifIndex),
+		}
+		return cm.Marshal()
+	}
+	return nil
+}
+
+func appendIPv4ECNMsg(b []byte, val protocol.ECN) []byte {
+	startLen := len(b)
+	b = append(b, make([]byte, unix.CmsgSpace(ecnIPv4DataLen))...)
+	h := (*unix.Cmsghdr)(unsafe.Pointer(&b[startLen]))
+	h.Level = syscall.IPPROTO_IP
+	h.Type = unix.IP_TOS
+	h.SetLen(unix.CmsgLen(ecnIPv4DataLen))
+
+	// UnixRights uses the private `data` method, but I *think* this achieves the same goal.
+	offset := startLen + unix.CmsgSpace(0)
+	b[offset] = val.ToHeaderBits()
+	return b
+}
+
+func appendIPv6ECNMsg(b []byte, val protocol.ECN) []byte {
+	startLen := len(b)
+	const dataLen = 4
+	b = append(b, make([]byte, unix.CmsgSpace(dataLen))...)
+	h := (*unix.Cmsghdr)(unsafe.Pointer(&b[startLen]))
+	h.Level = syscall.IPPROTO_IPV6
+	h.Type = unix.IPV6_TCLASS
+	h.SetLen(unix.CmsgLen(dataLen))
+
+	// UnixRights uses the private `data` method, but I *think* this achieves the same goal.
+	offset := startLen + unix.CmsgSpace(0)
+	binary.NativeEndian.PutUint32(b[offset:offset+dataLen], uint32(val.ToHeaderBits()))
+	return b
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/sys_conn_windows.go b/backend/vendor/github.com/quic-go/quic-go/sys_conn_windows.go
new file mode 100644
index 00000000..b9c1cbc8
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/sys_conn_windows.go
@@ -0,0 +1,42 @@
+//go:build windows
+
+package quic
+
+import (
+	"net/netip"
+	"syscall"
+
+	"golang.org/x/sys/windows"
+)
+
+func newConn(c OOBCapablePacketConn, supportsDF bool) (*basicConn, error) {
+	return &basicConn{PacketConn: c, supportsDF: supportsDF}, nil
+}
+
+func inspectReadBuffer(c syscall.RawConn) (int, error) {
+	var size int
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		size, serr = windows.GetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_RCVBUF)
+	}); err != nil {
+		return 0, err
+	}
+	return size, serr
+}
+
+func inspectWriteBuffer(c syscall.RawConn) (int, error) {
+	var size int
+	var serr error
+	if err := c.Control(func(fd uintptr) {
+		size, serr = windows.GetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_SNDBUF)
+	}); err != nil {
+		return 0, err
+	}
+	return size, serr
+}
+
+type packetInfo struct {
+	addr netip.Addr
+}
+
+func (i *packetInfo) OOB() []byte { return nil }
diff --git a/backend/vendor/github.com/quic-go/quic-go/token_store.go b/backend/vendor/github.com/quic-go/quic-go/token_store.go
new file mode 100644
index 00000000..a5c1c185
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/token_store.go
@@ -0,0 +1,116 @@
+package quic
+
+import (
+	"sync"
+
+	list "github.com/quic-go/quic-go/internal/utils/linkedlist"
+)
+
+type singleOriginTokenStore struct {
+	tokens []*ClientToken
+	len    int
+	p      int
+}
+
+func newSingleOriginTokenStore(size int) *singleOriginTokenStore {
+	return &singleOriginTokenStore{tokens: make([]*ClientToken, size)}
+}
+
+func (s *singleOriginTokenStore) Add(token *ClientToken) {
+	s.tokens[s.p] = token
+	s.p = s.index(s.p + 1)
+	s.len = min(s.len+1, len(s.tokens))
+}
+
+func (s *singleOriginTokenStore) Pop() *ClientToken {
+	s.p = s.index(s.p - 1)
+	token := s.tokens[s.p]
+	s.tokens[s.p] = nil
+	s.len = max(s.len-1, 0)
+	return token
+}
+
+func (s *singleOriginTokenStore) Len() int {
+	return s.len
+}
+
+func (s *singleOriginTokenStore) index(i int) int {
+	mod := len(s.tokens)
+	return (i + mod) % mod
+}
+
+type lruTokenStoreEntry struct {
+	key   string
+	cache *singleOriginTokenStore
+}
+
+type lruTokenStore struct {
+	mutex sync.Mutex
+
+	m                map[string]*list.Element[*lruTokenStoreEntry]
+	q                *list.List[*lruTokenStoreEntry]
+	capacity         int
+	singleOriginSize int
+}
+
+var _ TokenStore = &lruTokenStore{}
+
+// NewLRUTokenStore creates a new LRU cache for tokens received by the client.
+// maxOrigins specifies how many origins this cache is saving tokens for.
+// tokensPerOrigin specifies the maximum number of tokens per origin.
+func NewLRUTokenStore(maxOrigins, tokensPerOrigin int) TokenStore {
+	return &lruTokenStore{
+		m:                make(map[string]*list.Element[*lruTokenStoreEntry]),
+		q:                list.New[*lruTokenStoreEntry](),
+		capacity:         maxOrigins,
+		singleOriginSize: tokensPerOrigin,
+	}
+}
+
+func (s *lruTokenStore) Put(key string, token *ClientToken) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	if el, ok := s.m[key]; ok {
+		entry := el.Value
+		entry.cache.Add(token)
+		s.q.MoveToFront(el)
+		return
+	}
+
+	if s.q.Len() < s.capacity {
+		entry := &lruTokenStoreEntry{
+			key:   key,
+			cache: newSingleOriginTokenStore(s.singleOriginSize),
+		}
+		entry.cache.Add(token)
+		s.m[key] = s.q.PushFront(entry)
+		return
+	}
+
+	elem := s.q.Back()
+	entry := elem.Value
+	delete(s.m, entry.key)
+	entry.key = key
+	entry.cache = newSingleOriginTokenStore(s.singleOriginSize)
+	entry.cache.Add(token)
+	s.q.MoveToFront(elem)
+	s.m[key] = elem
+}
+
+func (s *lruTokenStore) Pop(key string) *ClientToken {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	var token *ClientToken
+	if el, ok := s.m[key]; ok {
+		s.q.MoveToFront(el)
+		cache := el.Value.cache
+		token = cache.Pop()
+		if cache.Len() == 0 {
+			s.q.Remove(el)
+			delete(s.m, key)
+		}
+	}
+	return token
+}
diff --git a/backend/vendor/github.com/quic-go/quic-go/transport.go b/backend/vendor/github.com/quic-go/quic-go/transport.go
new file mode 100644
index 00000000..e597c3f4
--- /dev/null
+++ b/backend/vendor/github.com/quic-go/quic-go/transport.go
@@ -0,0 +1,848 @@
+package quic
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+	"github.com/quic-go/quic-go/internal/wire"
+	"github.com/quic-go/quic-go/qlog"
+	"github.com/quic-go/quic-go/qlogwriter"
+)
+
+// ErrTransportClosed is returned by the [Transport]'s Listen or Dial method after it was closed.
+var ErrTransportClosed = &errTransportClosed{}
+
+type errTransportClosed struct {
+	err error
+}
+
+func (e *errTransportClosed) Unwrap() []error { return []error{net.ErrClosed, e.err} }
+
+func (e *errTransportClosed) Error() string {
+	if e.err == nil {
+		return "quic: transport closed"
+	}
+	return fmt.Sprintf("quic: transport closed: %s", e.err)
+}
+
+func (e *errTransportClosed) Is(target error) bool {
+	_, ok := target.(*errTransportClosed)
+	return ok
+}
+
+var errListenerAlreadySet = errors.New("listener already set")
+
+type closePacket struct {
+	payload []byte
+	addr    net.Addr
+	info    packetInfo
+}
+
+// The Transport is the central point to manage incoming and outgoing QUIC connections.
+// QUIC demultiplexes connections based on their QUIC Connection IDs, not based on the 4-tuple.
+// This means that a single UDP socket can be used for listening for incoming connections, as well as
+// for dialing an arbitrary number of outgoing connections.
+// A Transport handles a single net.PacketConn, and offers a range of configuration options
+// compared to the simple helper functions like [Listen] and [Dial] that this package provides.
+type Transport struct {
+	// A single net.PacketConn can only be handled by one Transport.
+	// Bad things will happen if passed to multiple Transports.
+	//
+	// A number of optimizations will be enabled if the connections implements the OOBCapablePacketConn interface,
+	// as a *net.UDPConn does.
+	// 1. It enables the Don't Fragment (DF) bit on the IP header.
+	//    This is required to run DPLPMTUD (Path MTU Discovery, RFC 8899).
+	// 2. It enables reading of the ECN bits from the IP header.
+	//    This allows the remote node to speed up its loss detection and recovery.
+	// 3. It uses batched syscalls (recvmmsg) to more efficiently receive packets from the socket.
+	// 4. It uses Generic Segmentation Offload (GSO) to efficiently send batches of packets (on Linux).
+	//
+	// After passing the connection to the Transport, it's invalid to call ReadFrom or WriteTo on the connection.
+	Conn net.PacketConn
+
+	// The length of the connection ID in bytes.
+	// It can be any value between 1 and 20.
+	// Due to the increased risk of collisions, it is not recommended to use connection IDs shorter than 4 bytes.
+	// If unset, a 4 byte connection ID will be used.
+	ConnectionIDLength int
+
+	// Use for generating new connection IDs.
+	// This allows the application to control of the connection IDs used,
+	// which allows routing / load balancing based on connection IDs.
+	// All Connection IDs returned by the ConnectionIDGenerator MUST
+	// have the same length.
+	ConnectionIDGenerator ConnectionIDGenerator
+
+	// The StatelessResetKey is used to generate stateless reset tokens.
+	// If no key is configured, sending of stateless resets is disabled.
+	// It is highly recommended to configure a stateless reset key, as stateless resets
+	// allow the peer to quickly recover from crashes and reboots of this node.
+	// See section 10.3 of RFC 9000 for details.
+	StatelessResetKey *StatelessResetKey
+
+	// The TokenGeneratorKey is used to encrypt session resumption tokens.
+	// If no key is configured, a random key will be generated.
+	// If multiple servers are authoritative for the same domain, they should use the same key,
+	// see section 8.1.3 of RFC 9000 for details.
+	TokenGeneratorKey *TokenGeneratorKey
+
+	// MaxTokenAge is the maximum age of the resumption token presented during the handshake.
+	// These tokens allow skipping address resumption when resuming a QUIC connection,
+	// and are especially useful when using 0-RTT.
+	// If not set, it defaults to 24 hours.
+	// See section 8.1.3 of RFC 9000 for details.
+	MaxTokenAge time.Duration
+
+	// DisableVersionNegotiationPackets disables the sending of Version Negotiation packets.
+	// This can be useful if version information is exchanged out-of-band.
+	// It has no effect for clients.
+	DisableVersionNegotiationPackets bool
+
+	// VerifySourceAddress decides if a connection attempt originating from unvalidated source
+	// addresses first needs to go through source address validation using QUIC's Retry mechanism,
+	// as described in RFC 9000 section 8.1.2.
+	// Note that the address passed to this callback is unvalidated, and might be spoofed in case
+	// of an attack.
+	// Validating the source address adds one additional network roundtrip to the handshake,
+	// and should therefore only be used if a suspiciously high number of incoming connection is recorded.
+	// For most use cases, wrapping the Allow function of a rate.Limiter will be a reasonable
+	// implementation of this callback (negating its return value).
+	VerifySourceAddress func(net.Addr) bool
+
+	// ConnContext is called when the server accepts a new connection. To reject a connection return
+	// a non-nil error.
+	// The context is closed when the connection is closed, or when the handshake fails for any reason.
+	// The context returned from the callback is used to derive every other context used during the
+	// lifetime of the connection:
+	// * the context passed to crypto/tls (and used on the tls.ClientHelloInfo)
+	// * the context used in Config.QlogTrace
+	// * the context returned from Conn.Context
+	// * the context returned from SendStream.Context
+	// It is not used for dialed connections.
+	ConnContext func(context.Context, *ClientInfo) (context.Context, error)
+
+	// A Tracer traces events that don't belong to a single QUIC connection.
+	// Recorder.Close is called when the transport is closed.
+	Tracer qlogwriter.Recorder
+
+	mutex       sync.Mutex
+	handlers    map[protocol.ConnectionID]packetHandler
+	resetTokens map[protocol.StatelessResetToken]packetHandler
+
+	initOnce sync.Once
+	initErr  error
+
+	// If no ConnectionIDGenerator is set, this is the ConnectionIDLength.
+	connIDLen int
+	// Set in init.
+	// If no ConnectionIDGenerator is set, this is set to a default.
+	connIDGenerator   ConnectionIDGenerator
+	statelessResetter *statelessResetter
+
+	server *baseServer
+
+	conn rawConn
+
+	closeQueue          chan closePacket
+	statelessResetQueue chan receivedPacket
+
+	listening   chan struct{} // is closed when listen returns
+	closeErr    error
+	createdConn bool
+	isSingleUse bool // was created for a single server or client, i.e. by calling quic.Listen or quic.Dial
+
+	readingNonQUICPackets atomic.Bool
+	nonQUICPackets        chan receivedPacket
+
+	logger utils.Logger
+}
+
+// Listen starts listening for incoming QUIC connections.
+// There can only be a single listener on any net.PacketConn.
+// Listen may only be called again after the current listener was closed.
+func (t *Transport) Listen(tlsConf *tls.Config, conf *Config) (*Listener, error) {
+	s, err := t.createServer(tlsConf, conf, false)
+	if err != nil {
+		return nil, err
+	}
+	return &Listener{baseServer: s}, nil
+}
+
+// ListenEarly starts listening for incoming QUIC connections.
+// There can only be a single listener on any net.PacketConn.
+// ListenEarly may only be called again after the current listener was closed.
+func (t *Transport) ListenEarly(tlsConf *tls.Config, conf *Config) (*EarlyListener, error) {
+	s, err := t.createServer(tlsConf, conf, true)
+	if err != nil {
+		return nil, err
+	}
+	return &EarlyListener{baseServer: s}, nil
+}
+
+func (t *Transport) createServer(tlsConf *tls.Config, conf *Config, allow0RTT bool) (*baseServer, error) {
+	if tlsConf == nil {
+		return nil, errors.New("quic: tls.Config not set")
+	}
+	if err := validateConfig(conf); err != nil {
+		return nil, err
+	}
+
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+
+	if t.closeErr != nil {
+		return nil, t.closeErr
+	}
+	if t.server != nil {
+		return nil, errListenerAlreadySet
+	}
+	conf = populateConfig(conf)
+	if err := t.init(false); err != nil {
+		return nil, err
+	}
+	maxTokenAge := t.MaxTokenAge
+	if maxTokenAge == 0 {
+		maxTokenAge = 24 * time.Hour
+	}
+	s := newServer(
+		t.conn,
+		(*packetHandlerMap)(t),
+		t.connIDGenerator,
+		t.statelessResetter,
+		t.ConnContext,
+		tlsConf,
+		conf,
+		t.Tracer,
+		t.closeServer,
+		*t.TokenGeneratorKey,
+		maxTokenAge,
+		t.VerifySourceAddress,
+		t.DisableVersionNegotiationPackets,
+		allow0RTT,
+	)
+	t.server = s
+	return s, nil
+}
+
+// Dial dials a new connection to a remote host (not using 0-RTT).
+func (t *Transport) Dial(ctx context.Context, addr net.Addr, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	return t.dial(ctx, addr, "", tlsConf, conf, false)
+}
+
+// DialEarly dials a new connection, attempting to use 0-RTT if possible.
+func (t *Transport) DialEarly(ctx context.Context, addr net.Addr, tlsConf *tls.Config, conf *Config) (*Conn, error) {
+	return t.dial(ctx, addr, "", tlsConf, conf, true)
+}
+
+func (t *Transport) dial(ctx context.Context, addr net.Addr, host string, tlsConf *tls.Config, conf *Config, use0RTT bool) (*Conn, error) {
+	if err := t.init(t.isSingleUse); err != nil {
+		return nil, err
+	}
+	if err := validateConfig(conf); err != nil {
+		return nil, err
+	}
+	conf = populateConfig(conf)
+	tlsConf = tlsConf.Clone()
+	setTLSConfigServerName(tlsConf, addr, host)
+	return t.doDial(ctx,
+		newSendConn(t.conn, addr, packetInfo{}, utils.DefaultLogger),
+		tlsConf,
+		conf,
+		0,
+		false,
+		use0RTT,
+		conf.Versions[0],
+	)
+}
+
+func (t *Transport) doDial(
+	ctx context.Context,
+	sendConn sendConn,
+	tlsConf *tls.Config,
+	config *Config,
+	initialPacketNumber protocol.PacketNumber,
+	hasNegotiatedVersion bool,
+	use0RTT bool,
+	version protocol.Version,
+) (*Conn, error) {
+	srcConnID, err := t.connIDGenerator.GenerateConnectionID()
+	if err != nil {
+		return nil, err
+	}
+	destConnID, err := generateConnectionIDForInitial()
+	if err != nil {
+		return nil, err
+	}
+
+	t.mutex.Lock()
+	if t.closeErr != nil {
+		t.mutex.Unlock()
+		return nil, t.closeErr
+	}
+
+	var qlogTrace qlogwriter.Trace
+	if config.Tracer != nil {
+		qlogTrace = config.Tracer(ctx, true, destConnID)
+	}
+
+	logger := utils.DefaultLogger.WithPrefix("client")
+	logger.Infof("Starting new connection to %s (%s -> %s), source connection ID %s, destination connection ID %s, version %s", tlsConf.ServerName, sendConn.LocalAddr(), sendConn.RemoteAddr(), srcConnID, destConnID, version)
+
+	conn := newClientConnection(
+		context.WithoutCancel(ctx),
+		sendConn,
+		(*packetHandlerMap)(t),
+		destConnID,
+		srcConnID,
+		t.connIDGenerator,
+		t.statelessResetter,
+		config,
+		tlsConf,
+		initialPacketNumber,
+		use0RTT,
+		hasNegotiatedVersion,
+		qlogTrace,
+		logger,
+		version,
+	)
+	t.handlers[srcConnID] = conn
+	t.mutex.Unlock()
+
+	// The error channel needs to be buffered, as the run loop will continue running
+	// after doDial returns (if the handshake is successful).
+	// Similarly, the recreateChan needs to be buffered; in case a different case is selected.
+	errChan := make(chan error, 1)
+	recreateChan := make(chan errCloseForRecreating, 1)
+	go func() {
+		err := conn.run()
+		var recreateErr *errCloseForRecreating
+		if errors.As(err, &recreateErr) {
+			recreateChan <- *recreateErr
+			return
+		}
+		if t.isSingleUse {
+			t.Close()
+		}
+		errChan <- err
+	}()
+
+	// Only set when we're using 0-RTT.
+	// Otherwise, earlyConnChan will be nil. Receiving from a nil chan blocks forever.
+	var earlyConnChan <-chan struct{}
+	if use0RTT {
+		earlyConnChan = conn.earlyConnReady()
+	}
+
+	select {
+	case <-ctx.Done():
+		conn.destroy(nil)
+		// wait until the Go routine that called Conn.run() returns
+		select {
+		case <-errChan:
+		case <-recreateChan:
+		}
+		return nil, context.Cause(ctx)
+	case params := <-recreateChan:
+		return t.doDial(ctx,
+			sendConn,
+			tlsConf,
+			config,
+			params.nextPacketNumber,
+			true,
+			use0RTT,
+			params.nextVersion,
+		)
+	case err := <-errChan:
+		return nil, err
+	case <-earlyConnChan:
+		// ready to send 0-RTT data
+		return conn.Conn, nil
+	case <-conn.HandshakeComplete():
+		// handshake successfully completed
+		return conn.Conn, nil
+	}
+}
+
+func (t *Transport) init(allowZeroLengthConnIDs bool) error {
+	t.initOnce.Do(func() {
+		var conn rawConn
+		if c, ok := t.Conn.(rawConn); ok {
+			conn = c
+		} else {
+			var err error
+			conn, err = wrapConn(t.Conn)
+			if err != nil {
+				t.initErr = err
+				return
+			}
+		}
+
+		t.logger = utils.DefaultLogger // TODO: make this configurable
+		t.conn = conn
+		t.handlers = make(map[protocol.ConnectionID]packetHandler)
+		t.resetTokens = make(map[protocol.StatelessResetToken]packetHandler)
+		t.listening = make(chan struct{})
+
+		t.closeQueue = make(chan closePacket, 4)
+		t.statelessResetQueue = make(chan receivedPacket, 4)
+		if t.TokenGeneratorKey == nil {
+			var key TokenGeneratorKey
+			if _, err := rand.Read(key[:]); err != nil {
+				t.initErr = err
+				return
+			}
+			t.TokenGeneratorKey = &key
+		}
+
+		if t.ConnectionIDGenerator != nil {
+			t.connIDGenerator = t.ConnectionIDGenerator
+			t.connIDLen = t.ConnectionIDGenerator.ConnectionIDLen()
+		} else {
+			connIDLen := t.ConnectionIDLength
+			if t.ConnectionIDLength == 0 && !allowZeroLengthConnIDs {
+				connIDLen = protocol.DefaultConnectionIDLength
+			}
+			t.connIDLen = connIDLen
+			t.connIDGenerator = &protocol.DefaultConnectionIDGenerator{ConnLen: t.connIDLen}
+		}
+		t.statelessResetter = newStatelessResetter(t.StatelessResetKey)
+
+		go func() {
+			defer close(t.listening)
+			t.listen(conn)
+
+			if t.createdConn {
+				conn.Close()
+			}
+		}()
+		go t.runSendQueue()
+	})
+	return t.initErr
+}
+
+// WriteTo sends a packet on the underlying connection.
+func (t *Transport) WriteTo(b []byte, addr net.Addr) (int, error) {
+	if err := t.init(false); err != nil {
+		return 0, err
+	}
+	return t.conn.WritePacket(b, addr, nil, 0, protocol.ECNUnsupported)
+}
+
+func (t *Transport) runSendQueue() {
+	for {
+		select {
+		case <-t.listening:
+			return
+		case p := <-t.closeQueue:
+			t.conn.WritePacket(p.payload, p.addr, p.info.OOB(), 0, protocol.ECNUnsupported)
+		case p := <-t.statelessResetQueue:
+			t.sendStatelessReset(p)
+		}
+	}
+}
+
+// Close stops listening for UDP datagrams on the Transport.Conn.
+// It abruptly terminates all existing connections, without sending a CONNECTION_CLOSE
+// to the peers. It is the application's responsibility to cleanly terminate existing
+// connections prior to calling Close.
+//
+// If a server was started, it will be closed as well.
+// It is not possible to start any new server or dial new connections after that.
+func (t *Transport) Close() error {
+	// avoid race condition if the transport is currently being initialized
+	t.init(false)
+
+	t.close(nil)
+	if t.createdConn {
+		if err := t.Conn.Close(); err != nil {
+			return err
+		}
+	} else if t.conn != nil {
+		t.conn.SetReadDeadline(time.Now())
+		defer func() { t.conn.SetReadDeadline(time.Time{}) }()
+	}
+	if t.listening != nil {
+		<-t.listening // wait until listening returns
+	}
+	return nil
+}
+
+func (t *Transport) closeServer() {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+
+	t.server = nil
+	if t.isSingleUse {
+		t.closeErr = ErrServerClosed
+	}
+
+	if len(t.handlers) == 0 {
+		t.maybeStopListening()
+	}
+}
+
+func (t *Transport) close(e error) {
+	t.mutex.Lock()
+
+	if t.closeErr != nil {
+		t.mutex.Unlock()
+		return
+	}
+
+	e = &errTransportClosed{err: e}
+	t.closeErr = e
+	server := t.server
+	t.server = nil
+	if server != nil {
+		t.mutex.Unlock()
+		server.close(e, true)
+		t.mutex.Lock()
+	}
+
+	// Close existing connections
+	var wg sync.WaitGroup
+	for _, handler := range t.handlers {
+		wg.Go(func() { handler.destroy(e) })
+	}
+	t.mutex.Unlock() // closing connections requires releasing transport mutex
+	wg.Wait()
+
+	if t.Tracer != nil {
+		t.Tracer.Close()
+	}
+}
+
+// only print warnings about the UDP receive buffer size once
+var setBufferWarningOnce sync.Once
+
+func (t *Transport) listen(conn rawConn) {
+	for {
+		p, err := conn.ReadPacket()
+		//nolint:staticcheck // SA1019 ignore this!
+		// TODO: This code is used to ignore wsa errors on Windows.
+		// Since net.Error.Temporary is deprecated as of Go 1.18, we should find a better solution.
+		// See https://github.com/quic-go/quic-go/issues/1737 for details.
+		if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
+			t.mutex.Lock()
+			closed := t.closeErr != nil
+			t.mutex.Unlock()
+			if closed {
+				return
+			}
+			t.logger.Debugf("Temporary error reading from conn: %w", err)
+			continue
+		}
+		if err != nil {
+			// Windows returns an error when receiving a UDP datagram that doesn't fit into the provided buffer.
+			if isRecvMsgSizeErr(err) {
+				continue
+			}
+			t.close(err)
+			return
+		}
+		t.handlePacket(p)
+	}
+}
+
+func (t *Transport) maybeStopListening() {
+	if t.isSingleUse && t.closeErr != nil {
+		t.conn.SetReadDeadline(time.Now())
+	}
+}
+
+func (t *Transport) handlePacket(p receivedPacket) {
+	if len(p.data) == 0 {
+		return
+	}
+	if !wire.IsPotentialQUICPacket(p.data[0]) && !wire.IsLongHeaderPacket(p.data[0]) {
+		t.handleNonQUICPacket(p)
+		return
+	}
+	connID, err := wire.ParseConnectionID(p.data, t.connIDLen)
+	if err != nil {
+		t.logger.Debugf("error parsing connection ID on packet from %s: %s", p.remoteAddr, err)
+		if t.Tracer != nil {
+			t.Tracer.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropHeaderParseError,
+			})
+		}
+		p.buffer.MaybeRelease()
+		return
+	}
+
+	// If there's a connection associated with the connection ID, pass the packet there.
+	if handler, ok := (*packetHandlerMap)(t).Get(connID); ok {
+		handler.handlePacket(p)
+		return
+	}
+	// RFC 9000 section 10.3.1 requires that the stateless reset detection logic is run for both
+	// packets that cannot be associated with any connections, and for packets that can't be decrypted.
+	// We deviate from the RFC and ignore the latter: If a packet's connection ID is associated with an
+	// existing connection, it is dropped there if if it can't be decrypted.
+	// Stateless resets use random connection IDs, and at reasonable connection ID lengths collisions are
+	// exceedingly rare. In the unlikely event that a stateless reset is misrouted to an existing connection,
+	// it is to be expected that the next stateless reset will be correctly detected.
+	if isStatelessReset := t.maybeHandleStatelessReset(p.data); isStatelessReset {
+		return
+	}
+	if !wire.IsLongHeaderPacket(p.data[0]) {
+		if statelessResetQueued := t.maybeSendStatelessReset(p); !statelessResetQueued {
+			if t.Tracer != nil {
+				t.Tracer.RecordEvent(qlog.PacketDropped{
+					Header:  qlog.PacketHeader{PacketType: qlog.PacketType1RTT},
+					Raw:     qlog.RawInfo{Length: int(p.Size())},
+					Trigger: qlog.PacketDropUnknownConnectionID,
+				})
+			}
+			p.buffer.Release()
+		}
+		return
+	}
+
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	if t.server == nil { // no server set
+		t.logger.Debugf("received a packet with an unexpected connection ID %s", connID)
+		if t.Tracer != nil {
+			t.Tracer.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropUnknownConnectionID,
+			})
+		}
+		p.buffer.MaybeRelease()
+		return
+	}
+	t.server.handlePacket(p)
+}
+
+func (t *Transport) maybeSendStatelessReset(p receivedPacket) (statelessResetQueued bool) {
+	if t.StatelessResetKey == nil {
+		return false
+	}
+
+	// Don't send a stateless reset in response to very small packets.
+	// This includes packets that could be stateless resets.
+	if len(p.data) <= protocol.MinStatelessResetSize {
+		return false
+	}
+
+	select {
+	case t.statelessResetQueue <- p:
+		return true
+	default:
+		// it's fine to not send a stateless reset when we're busy
+		return false
+	}
+}
+
+func (t *Transport) sendStatelessReset(p receivedPacket) {
+	defer p.buffer.Release()
+
+	connID, err := wire.ParseConnectionID(p.data, t.connIDLen)
+	if err != nil {
+		t.logger.Errorf("error parsing connection ID on packet from %s: %s", p.remoteAddr, err)
+		return
+	}
+	token := t.statelessResetter.GetStatelessResetToken(connID)
+	t.logger.Debugf("Sending stateless reset to %s (connection ID: %s). Token: %#x", p.remoteAddr, connID, token)
+	data := make([]byte, protocol.MinStatelessResetSize-16, protocol.MinStatelessResetSize)
+	rand.Read(data)
+	data[0] = (data[0] & 0x7f) | 0x40
+	data = append(data, token[:]...)
+	if _, err := t.conn.WritePacket(data, p.remoteAddr, p.info.OOB(), 0, protocol.ECNUnsupported); err != nil {
+		t.logger.Debugf("Error sending Stateless Reset to %s: %s", p.remoteAddr, err)
+	}
+}
+
+func (t *Transport) maybeHandleStatelessReset(data []byte) bool {
+	// stateless resets are always short header packets
+	if wire.IsLongHeaderPacket(data[0]) {
+		return false
+	}
+	if len(data) < 17 /* type byte + 16 bytes for the reset token */ {
+		return false
+	}
+
+	token := protocol.StatelessResetToken(data[len(data)-16:])
+	t.mutex.Lock()
+	conn, ok := t.resetTokens[token]
+	t.mutex.Unlock()
+
+	if ok {
+		t.logger.Debugf("Received a stateless reset with token %#x. Closing connection.", token)
+		go conn.destroy(&StatelessResetError{})
+		return true
+	}
+	return false
+}
+
+func (t *Transport) handleNonQUICPacket(p receivedPacket) {
+	// Strictly speaking, this is racy,
+	// but we only care about receiving packets at some point after ReadNonQUICPacket has been called.
+	if !t.readingNonQUICPackets.Load() {
+		return
+	}
+	select {
+	case t.nonQUICPackets <- p:
+	default:
+		if t.Tracer != nil {
+			t.Tracer.RecordEvent(qlog.PacketDropped{
+				Raw:     qlog.RawInfo{Length: int(p.Size())},
+				Trigger: qlog.PacketDropDOSPrevention,
+			})
+		}
+	}
+}
+
+const maxQueuedNonQUICPackets = 32
+
+// ReadNonQUICPacket reads non-QUIC packets received on the underlying connection.
+// The detection logic is very simple: Any packet that has the first and second bit of the packet set to 0.
+// Note that this is stricter than the detection logic defined in RFC 9443.
+func (t *Transport) ReadNonQUICPacket(ctx context.Context, b []byte) (int, net.Addr, error) {
+	if err := t.init(false); err != nil {
+		return 0, nil, err
+	}
+	if !t.readingNonQUICPackets.Load() {
+		t.nonQUICPackets = make(chan receivedPacket, maxQueuedNonQUICPackets)
+		t.readingNonQUICPackets.Store(true)
+	}
+	select {
+	case <-ctx.Done():
+		return 0, nil, ctx.Err()
+	case p := <-t.nonQUICPackets:
+		n := copy(b, p.data)
+		return n, p.remoteAddr, nil
+	case <-t.listening:
+		return 0, nil, errors.New("closed")
+	}
+}
+
+func setTLSConfigServerName(tlsConf *tls.Config, addr net.Addr, host string) {
+	// If no ServerName is set, infer the ServerName from the host we're connecting to.
+	if tlsConf.ServerName != "" {
+		return
+	}
+	if host == "" {
+		if udpAddr, ok := addr.(*net.UDPAddr); ok {
+			tlsConf.ServerName = udpAddr.IP.String()
+			return
+		}
+	}
+	h, _, err := net.SplitHostPort(host)
+	if err != nil { // This happens if the host doesn't contain a port number.
+		tlsConf.ServerName = host
+		return
+	}
+	tlsConf.ServerName = h
+}
+
+type packetHandlerMap Transport
+
+var _ connRunner = &packetHandlerMap{}
+
+func (h *packetHandlerMap) Add(id protocol.ConnectionID, handler packetHandler) bool /* was added */ {
+	h.mutex.Lock()
+	defer h.mutex.Unlock()
+
+	if _, ok := h.handlers[id]; ok {
+		h.logger.Debugf("Not adding connection ID %s, as it already exists.", id)
+		return false
+	}
+	h.handlers[id] = handler
+	h.logger.Debugf("Adding connection ID %s.", id)
+	return true
+}
+
+func (h *packetHandlerMap) Get(connID protocol.ConnectionID) (packetHandler, bool) {
+	h.mutex.Lock()
+	defer h.mutex.Unlock()
+	handler, ok := h.handlers[connID]
+	return handler, ok
+}
+
+func (h *packetHandlerMap) AddResetToken(token protocol.StatelessResetToken, handler packetHandler) {
+	h.mutex.Lock()
+	h.resetTokens[token] = handler
+	h.mutex.Unlock()
+}
+
+func (h *packetHandlerMap) RemoveResetToken(token protocol.StatelessResetToken) {
+	h.mutex.Lock()
+	delete(h.resetTokens, token)
+	h.mutex.Unlock()
+}
+
+func (h *packetHandlerMap) AddWithConnID(clientDestConnID, newConnID protocol.ConnectionID, handler packetHandler) bool {
+	h.mutex.Lock()
+	defer h.mutex.Unlock()
+
+	if _, ok := h.handlers[clientDestConnID]; ok {
+		h.logger.Debugf("Not adding connection ID %s for a new connection, as it already exists.", clientDestConnID)
+		return false
+	}
+	h.handlers[clientDestConnID] = handler
+	h.handlers[newConnID] = handler
+	h.logger.Debugf("Adding connection IDs %s and %s for a new connection.", clientDestConnID, newConnID)
+	return true
+}
+
+func (h *packetHandlerMap) Remove(id protocol.ConnectionID) {
+	h.mutex.Lock()
+	delete(h.handlers, id)
+	h.mutex.Unlock()
+	h.logger.Debugf("Removing connection ID %s.", id)
+}
+
+// ReplaceWithClosed is called when a connection is closed.
+// Depending on which side closed the connection, we need to:
+// * remote close: absorb delayed packets
+// * local close: retransmit the CONNECTION_CLOSE packet, in case it was lost
+func (h *packetHandlerMap) ReplaceWithClosed(ids []protocol.ConnectionID, connClosePacket []byte, expiry time.Duration) {
+	var handler packetHandler
+	if connClosePacket != nil {
+		handler = newClosedLocalConn(
+			func(addr net.Addr, info packetInfo) {
+				select {
+				case h.closeQueue <- closePacket{payload: connClosePacket, addr: addr, info: info}:
+				default:
+					// We're backlogged.
+					// Just drop the packet, sending CONNECTION_CLOSE copies is best effort anyway.
+				}
+			},
+			h.logger,
+		)
+	} else {
+		handler = newClosedRemoteConn()
+	}
+
+	h.mutex.Lock()
+	for _, id := range ids {
+		h.handlers[id] = handler
+	}
+	h.mutex.Unlock()
+	h.logger.Debugf("Replacing connection for connection IDs %s with a closed connection.", ids)
+
+	time.AfterFunc(expiry, func() {
+		h.mutex.Lock()
+		for _, id := range ids {
+			delete(h.handlers, id)
+		}
+		if len(h.handlers) == 0 {
+			t := (*Transport)(h)
+			t.maybeStopListening()
+		}
+		h.mutex.Unlock()
+		h.logger.Debugf("Removing connection IDs %s for a closed connection after it has been retired.", ids)
+	})
+}
diff --git a/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go
new file mode 100644
index 00000000..5a74c4f4
--- /dev/null
+++ b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go
@@ -0,0 +1,24 @@
+//go:build testify_yaml_custom && !testify_yaml_fail && !testify_yaml_default
+
+// Package yaml is an implementation of YAML functions that calls a pluggable implementation.
+//
+// This implementation is selected with the testify_yaml_custom build tag.
+//
+//	go test -tags testify_yaml_custom
+//
+// This implementation can be used at build time to replace the default implementation
+// to avoid linking with [gopkg.in/yaml.v3].
+//
+// In your test package:
+//
+//		import assertYaml "github.com/stretchr/testify/assert/yaml"
+//
+//		func init() {
+//			assertYaml.Unmarshal = func (in []byte, out interface{}) error {
+//				// ...
+//	     			return nil
+//			}
+//		}
+package yaml
+
+var Unmarshal func(in []byte, out interface{}) error
diff --git a/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go
new file mode 100644
index 00000000..0bae80e3
--- /dev/null
+++ b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go
@@ -0,0 +1,36 @@
+//go:build !testify_yaml_fail && !testify_yaml_custom
+
+// Package yaml is just an indirection to handle YAML deserialization.
+//
+// This package is just an indirection that allows the builder to override the
+// indirection with an alternative implementation of this package that uses
+// another implementation of YAML deserialization. This allows to not either not
+// use YAML deserialization at all, or to use another implementation than
+// [gopkg.in/yaml.v3] (for example for license compatibility reasons, see [PR #1120]).
+//
+// Alternative implementations are selected using build tags:
+//
+//   - testify_yaml_fail: [Unmarshal] always fails with an error
+//   - testify_yaml_custom: [Unmarshal] is a variable. Caller must initialize it
+//     before calling any of [github.com/stretchr/testify/assert.YAMLEq] or
+//     [github.com/stretchr/testify/assert.YAMLEqf].
+//
+// Usage:
+//
+//	go test -tags testify_yaml_fail
+//
+// You can check with "go list" which implementation is linked:
+//
+//	go list -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
+//	go list -tags testify_yaml_fail -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
+//	go list -tags testify_yaml_custom -f '{{.Imports}}' github.com/stretchr/testify/assert/yaml
+//
+// [PR #1120]: https://github.com/stretchr/testify/pull/1120
+package yaml
+
+import goyaml "gopkg.in/yaml.v3"
+
+// Unmarshal is just a wrapper of [gopkg.in/yaml.v3.Unmarshal].
+func Unmarshal(in []byte, out interface{}) error {
+	return goyaml.Unmarshal(in, out)
+}
diff --git a/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go
new file mode 100644
index 00000000..8041803f
--- /dev/null
+++ b/backend/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go
@@ -0,0 +1,17 @@
+//go:build testify_yaml_fail && !testify_yaml_custom && !testify_yaml_default
+
+// Package yaml is an implementation of YAML functions that always fail.
+//
+// This implementation can be used at build time to replace the default implementation
+// to avoid linking with [gopkg.in/yaml.v3]:
+//
+//	go test -tags testify_yaml_fail
+package yaml
+
+import "errors"
+
+var errNotImplemented = errors.New("YAML functions are not available (see https://pkg.go.dev/github.com/stretchr/testify/assert/yaml)")
+
+func Unmarshal([]byte, interface{}) error {
+	return errNotImplemented
+}
diff --git a/backend/vendor/golang.org/x/crypto/internal/poly1305/sum_riscv64.s b/backend/vendor/golang.org/x/crypto/internal/poly1305/sum_riscv64.s
new file mode 100644
index 00000000..ce5eb3d4
--- /dev/null
+++ b/backend/vendor/golang.org/x/crypto/internal/poly1305/sum_riscv64.s
@@ -0,0 +1,158 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build gc && !purego
+
+#define LOAD64U(base, offset, t0, t1, t2, t3, dst) \
+	MOVBU	(offset+0*1)(base), t0; \
+	MOVBU	(offset+1*1)(base), t1; \
+	MOVBU	(offset+2*1)(base), t2; \
+	MOVBU	(offset+3*1)(base), t3; \
+	SLL	$8, t1; \
+	SLL	$16, t2; \
+	SLL	$24, t3; \
+	OR	t1, t0; \
+	OR	t3, t2; \
+	OR	t2, t0, dst; \
+	MOVBU	(offset+4*1)(base), t0; \
+	MOVBU	(offset+5*1)(base), t1; \
+	MOVBU	(offset+6*1)(base), t2; \
+	MOVBU	(offset+7*1)(base), t3; \
+	SLL	$32, t0; \
+	SLL	$40, t1; \
+	SLL	$48, t2; \
+	SLL	$56, t3; \
+	OR	t1, t0; \
+	OR	t3, t2; \
+	OR	t2, t0; \
+	OR	t0, dst
+
+// func update(state *macState, msg []byte)
+TEXT ·update(SB), $0-32
+	MOV	state+0(FP), X5
+	MOV	msg_base+8(FP), X6
+	MOV	msg_len+16(FP), X7
+
+	MOV	$16, X8
+
+	AND	$7, X6, X28
+
+	MOV	(0*8)(X5), X9		// h0
+	MOV	(1*8)(X5), X10		// h1
+	MOV	(2*8)(X5), X11		// h2
+	MOV	(3*8)(X5), X12		// r0
+	MOV	(4*8)(X5), X13		// r1
+
+	BLT	X7, X8, tail
+
+loop:
+	BEQZ	X28, aligned_load
+
+	LOAD64U(X6, 0*8, X16, X18, X19, X20, X15)	// msg[0:8]
+	LOAD64U(X6, 1*8, X16, X18, X19, X20, X17)	// msg[8:16]
+	JMP	block
+
+aligned_load:
+	MOV	(0*8)(X6), X15		// msg[0:8]
+	MOV	(1*8)(X6), X17		// msg[8:16]
+
+block:
+	ADD	X15, X9		// h0 (x1 + y1 = z1', if z1' < x1 then z1' overflow)
+	SLTU	X15, X9, X19	// h0.carry
+	ADD	X17, X10, X22
+	SLTU	X17, X22, X23
+	ADD	X22, X19, X10	// h1
+	SLTU	X22, X10, X19
+	OR	X23, X19	// h1.carry
+	ADD	$1, X19
+	ADD	X19, X11	// h2
+
+	ADD	$16, X6		// msg = msg[16:]
+
+multiply:
+	MULHU	X9, X12, X16	// h0r0.hi
+	MUL	X9, X12, X15	// h0r0.lo
+	MULHU	X10, X12, X17	// h1r0.hi
+	MUL	X10, X12, X14	// h1r0.lo
+	ADD	X14, X16
+	SLTU	X14, X16, X19
+	ADD	X19, X17
+	MUL	X11, X12, X20
+	ADD	X17, X20
+	MULHU	X9, X13, X17	// h0r1.hi
+	MUL	X9, X13, X14	// h0r1.lo
+	ADD	X14, X16
+	SLTU	X14, X16, X19
+	ADD	X19, X17
+	MOV	X17, X9
+	MUL	X11, X13, X21	// h2r1
+	MULHU	X10, X13, X17	// h1r1.hi
+	MUL	X10, X13, X14	// h1r1.lo
+	ADD	X14, X20
+	ADD	X17, X21, X22
+	SLTU	X14, X20, X19
+	ADD	X22, X19, X21
+	ADD	X9, X20
+	SLTU	X9, X20, X19
+	ADD	X19, X21
+	AND	$3, X20, X11
+	AND	$-4, X20, X18
+	ADD	X18, X15, X9
+	ADD	X21, X16, X22
+	SLTU	X18, X9, X19
+	SLTU	X21, X22, X23
+	ADD	X22, X19, X10
+	SLTU	X22, X10, X19
+	OR	X19, X23, X19
+	ADD	X19, X11
+	SLL	$62, X21, X22
+	SRL	$2, X20, X23
+	SRL	$2, X21, X21
+	OR	X22, X23, X20
+	ADD	X20, X9, X9
+	ADD	X21, X10, X22
+	SLTU	X20, X9, X19
+	SLTU	X21, X22, X23
+	ADD	X22, X19, X10
+	SLTU	X22, X10, X19
+	OR	X19, X23, X19
+	ADD	X19, X11, X11
+
+	SUB	$16, X7, X7
+	BGE	X7, X8, loop
+
+tail:
+	BEQ	X7, X0, done
+	MOV	$1, X15
+	MOV $0, X16
+	ADD	X7, X6, X6
+
+flush_buffer:
+	MOVBU	-1(X6), X20
+	SRL	$56, X15, X19
+	SLL	$8, X16, X23
+	SLL	$8, X15, X15
+	OR	X19, X23, X16
+	XOR	X20, X15
+	SUB	$1, X7, X7
+	SUB	$1, X6, X6
+	BNE	X7, X0, flush_buffer
+
+	ADD	X15, X9
+	SLTU	X15, X9, X19
+	ADD	X16, X10, X22
+	SLTU	X16, X22, X23
+	ADD	X22, X19, X10
+	SLTU	X22, X10, X19
+	OR	X23, X19
+	ADD	X19, X11
+
+	MOV	$16, X7
+	JMP	multiply
+
+done:
+	MOV	X9, (0*8)(X5)	// h0
+	MOV	X10, (1*8)(X5)
+	MOV	X11, (2*8)(X5)
+	RET
diff --git a/backend/vendor/golang.org/x/tools/internal/moremaps/maps.go b/backend/vendor/golang.org/x/tools/internal/moremaps/maps.go
new file mode 100644
index 00000000..a1bae078
--- /dev/null
+++ b/backend/vendor/golang.org/x/tools/internal/moremaps/maps.go
@@ -0,0 +1,116 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package moremaps contains more functions for working with maps.
+package moremaps
+
+import (
+	"cmp"
+	"iter"
+	"maps"
+	"slices"
+)
+
+// Arbitrary returns an arbitrary (key, value) entry from the map and ok is true, if
+// the map is not empty. Otherwise, it returns zero values for K and V, and false.
+func Arbitrary[K comparable, V any](m map[K]V) (_ K, _ V, ok bool) {
+	for k, v := range m {
+		return k, v, true
+	}
+	return
+}
+
+// Group returns a new non-nil map containing the elements of s grouped by the
+// keys returned from the key func.
+func Group[K comparable, V any](s []V, key func(V) K) map[K][]V {
+	m := make(map[K][]V)
+	for _, v := range s {
+		k := key(v)
+		m[k] = append(m[k], v)
+	}
+	return m
+}
+
+// KeySlice returns the keys of the map M, like slices.Collect(maps.Keys(m)).
+func KeySlice[M ~map[K]V, K comparable, V any](m M) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
+
+// ValueSlice returns the values of the map M, like slices.Collect(maps.Values(m)).
+func ValueSlice[M ~map[K]V, K comparable, V any](m M) []V {
+	r := make([]V, 0, len(m))
+	for _, v := range m {
+		r = append(r, v)
+	}
+	return r
+}
+
+// SameKeys reports whether x and y have equal sets of keys.
+func SameKeys[K comparable, V1, V2 any](x map[K]V1, y map[K]V2) bool {
+	ignoreValues := func(V1, V2) bool { return true }
+	return maps.EqualFunc(x, y, ignoreValues)
+}
+
+// Sorted returns an iterator over the entries of m in key order.
+func Sorted[M ~map[K]V, K cmp.Ordered, V any](m M) iter.Seq2[K, V] {
+	// TODO(adonovan): use maps.Sorted if proposal #68598 is accepted.
+	return func(yield func(K, V) bool) {
+		keys := KeySlice(m)
+		slices.Sort(keys)
+		for _, k := range keys {
+			if !yield(k, m[k]) {
+				break
+			}
+		}
+	}
+}
+
+// SortedFunc returns an iterator over the entries of m in the key order determined by cmp.
+func SortedFunc[M ~map[K]V, K comparable, V any](m M, cmp func(x, y K) int) iter.Seq2[K, V] {
+	// TODO(adonovan): use maps.SortedFunc if proposal #68598 is accepted.
+	return func(yield func(K, V) bool) {
+		keys := KeySlice(m)
+		slices.SortFunc(keys, cmp)
+		for _, k := range keys {
+			if !yield(k, m[k]) {
+				break
+			}
+		}
+	}
+}
+
+// Delete is like delete(m, k) but reports whether deletion occurred.
+func Delete[M ~map[K]V, K comparable, V any](m M, k K) bool {
+	pre := len(m)
+	delete(m, k)
+	return pre != len(m)
+}
+
+// Entry is a key-value pair obtained from a map.
+type Entry[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Entries returns a new unordered array of the entries of a map.
+func Entries[M ~map[K]V, K comparable, V any](m M) []Entry[K, V] {
+	entries := make([]Entry[K, V], 0, len(m))
+	for k, v := range m {
+		entries = append(entries, Entry[K, V]{k, v})
+	}
+	return entries
+}
+
+// FromEntries returns a new map into which the entries have been inserted in order.
+func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V {
+	m := make(map[K]V, len(entries))
+	for _, e := range entries {
+		m[e.Key] = e.Value
+	}
+	return m
+}
diff --git a/backend/vendor/golang.org/x/tools/internal/typesinternal/assignedaddress.go b/backend/vendor/golang.org/x/tools/internal/typesinternal/assignedaddress.go
new file mode 100644
index 00000000..020defc3
--- /dev/null
+++ b/backend/vendor/golang.org/x/tools/internal/typesinternal/assignedaddress.go
@@ -0,0 +1,128 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/ast/edge"
+	"golang.org/x/tools/go/ast/inspector"
+)
+
+// IsAssignedOrAddressTaken reports whether the expression cur denotes a
+// variable and appears in a context that assigns it or that takes its address,
+// potentially leading to indirect assignment.
+//
+// These examples cause IsAssignedOrAddressTaken on the identifier for x to
+// return true:
+//
+//		x = 1
+//		x++
+//		x[i] = 1	   (assume x is an array)
+//		x.a[i] = 1	 (assume x.a is a non-pointer struct field)
+//	  use(&x)
+//
+// whereas these cause it to return false:
+//
+//	y = x
+//	f(x)
+//	use(x.a[i])
+//	use(*x)
+//
+// The expression may itself be a compound, for example:
+//
+//	use(&(*ptr))  => IsAssignedOrAddressTaken("*ptr") = true
+//	x.a[i] = 1    => IsAssignedOrAddressTaken("x.a")  = true
+//	_ = x.a[i]    => IsAssignedOrAddressTaken("x.a")  = false
+//
+// A variable's declaration is not considered to be an assignment:
+//
+//	var x int     => IsAssignedOrAddressTaken(x) = false
+//	x := 1        => IsAssignedOrAddressTaken(x) = false
+//
+// TODO(adonovan): revisit the surprising behavior for declarations.
+func IsAssignedOrAddressTaken(info *types.Info, cur inspector.Cursor) bool {
+	// Unfortunately we can't simply use info.Types[e].Assignable()
+	// as it is always true for a variable even when that variable is
+	// used only as an r-value. So we must inspect enclosing syntax.
+outer:
+	// Ascend to outermost aggregate of which
+	// original cur is a part:
+	//    x -> (x) | x.f | x[i] | x[i:j]
+	for cur = range cur.Enclosing() {
+		switch cur.ParentEdgeKind() {
+		case edge.ParenExpr_X:
+			// If x is an lvalue, then (x) is an lvalue.
+		case edge.SelectorExpr_X:
+			// If x is an lvalue, then x.f is an lvalue iff
+			// the selection does not traverse a pointer.
+			sel := cur.Parent().Node().(*ast.SelectorExpr)
+			if seln, ok := info.Selections[sel]; ok {
+				// Note: there is a bug in Indirect() where it spuriously returns true
+				// when both the selection receiver and parameter are pointers. However,
+				// it's okay in this case because there is no address taken when a
+				// pointer receiver method is called on a pointer type.
+				if seln.Indirect() {
+					return false
+				}
+				if seln.Kind() == types.MethodVal {
+					sig := seln.Obj().Type().(*types.Signature)
+					if is[*types.Pointer](sig.Recv().Type().Underlying()) {
+						t := seln.Recv()
+						// The receiver may be an embedded field, so we need
+						// to get the inner-most type (right before the method
+						// call in seln.Index())
+						for _, idx := range seln.Index()[:len(seln.Index())-1] {
+							t = t.Underlying().(*types.Struct).Field(idx).Type()
+						}
+						if !is[*types.Pointer](t.Underlying()) {
+							return true // takes address of receiver
+						}
+					}
+					return false
+				}
+			}
+		case edge.IndexExpr_X, edge.SliceExpr_X:
+			// If x[i] or x[i:j] is an lvalue,
+			// then x is an lvalue iff x is an array.
+			if !is[*types.Array](info.TypeOf(cur.Node().(ast.Expr)).Underlying()) {
+				return false
+			}
+		default:
+			break outer
+		}
+	}
+	switch cur.ParentEdgeKind() {
+	case edge.AssignStmt_Lhs:
+		assign := cur.Parent().Node().(*ast.AssignStmt)
+		if assign.Tok != token.DEFINE {
+			return true // x = j or x += j
+		}
+		id := cur.Node().(*ast.Ident)
+		// Re-assigned identifiers are recorded in the Uses map.
+		if _, ok := info.Uses[id]; ok {
+			return true // reassignment of x (x, y := 1, 2)
+		}
+	case edge.RangeStmt_Key, edge.RangeStmt_Value:
+		rng := cur.Parent().Node().(*ast.RangeStmt)
+		if rng.Tok == token.ASSIGN {
+			return true // "for k, v = range x" is like an AssignStmt to k, v
+		}
+	case edge.IncDecStmt_X:
+		return true // x++, x--
+	case edge.UnaryExpr_X:
+		if cur.Parent().Node().(*ast.UnaryExpr).Op == token.AND {
+			return true // &x
+		}
+	}
+	return false
+}
+
+func is[T any](x any) bool {
+	_, ok := x.(T)
+	return ok
+}