quicsilver 0.2.0 → 0.4.0

data/lib/quicsilver/{http3.rb → protocol/frames.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Quicsilver
-  module HTTP3
+  module Protocol
     # HTTP/3 Frame Types (RFC 9114)
     FRAME_DATA = 0x00
     FRAME_HEADERS = 0x01
@@ -10,6 +10,53 @@ module Quicsilver
     FRAME_PUSH_PROMISE = 0x05
     FRAME_GOAWAY = 0x07
     FRAME_MAX_PUSH_ID = 0x0d
+    FRAME_PRIORITY_UPDATE = 0xF0700  # RFC 9218 — request stream priority update
+
+    # Frame types forbidden on request streams (RFC 9114 Section 7.2.4, 7.2.6, 7.2.7)
+    CONTROL_ONLY_FRAMES = [FRAME_CANCEL_PUSH, FRAME_SETTINGS, FRAME_GOAWAY, FRAME_MAX_PUSH_ID].freeze
+
+    # HTTP/3 Error Codes (RFC 9114 Section 8.1)
+    H3_NO_ERROR = 0x100
+    H3_GENERAL_PROTOCOL_ERROR = 0x101
+    H3_INTERNAL_ERROR = 0x102
+    H3_STREAM_CREATION_ERROR = 0x103
+    H3_CLOSED_CRITICAL_STREAM = 0x104
+    H3_FRAME_UNEXPECTED = 0x105
+    H3_FRAME_ERROR = 0x106
+    H3_EXCESSIVE_LOAD = 0x107
+    H3_ID_ERROR = 0x108
+    H3_SETTINGS_ERROR = 0x109
+    H3_MISSING_SETTINGS = 0x10a
+    H3_REQUEST_REJECTED = 0x10b
+    H3_REQUEST_CANCELLED = 0x10c
+    H3_REQUEST_INCOMPLETE = 0x10d
+    H3_MESSAGE_ERROR = 0x10e
+    H3_CONNECT_ERROR = 0x10f
+    H3_VERSION_FALLBACK = 0x110
+
+    # QPACK Error Codes (RFC 9204 Section 6)
+    QPACK_DECOMPRESSION_FAILED = 0x200
+    QPACK_ENCODER_STREAM_ERROR = 0x201
+    QPACK_DECODER_STREAM_ERROR = 0x202
+
+    # Protocol errors that carry an HTTP/3 error code for CONNECTION_CLOSE / RESET_STREAM.
+    # FrameError → connection error (CONNECTION_CLOSE)
+    # MessageError → stream error (RESET_STREAM) on request streams
+    class FrameError < StandardError
+      attr_reader :error_code
+      def initialize(msg = nil, error_code: H3_FRAME_UNEXPECTED)
+        @error_code = error_code
+        super(msg)
+      end
+    end
+
+    class MessageError < StandardError
+      attr_reader :error_code
+      def initialize(msg = nil, error_code: H3_MESSAGE_ERROR)
+        @error_code = error_code
+        super(msg)
+      end
+    end
 
     # QPACK Static Table Indices (RFC 9204 Appendix A)
     STATIC_TABLE = [
@@ -70,8 +117,8 @@ module Quicsilver
       ['content-type', 'text/plain;charset=utf-8'],            # 54
       ['range', 'bytes=0-'],                                   # 55
       ['strict-transport-security', 'max-age=31536000'],       # 56
-      ['strict-transport-security', 'max-age=31536000; includesubdomains'], # 57
-      ['strict-transport-security', 'max-age=31536000; includesubdomains; preload'], # 58
+      ['strict-transport-security', 'max-age=31536000; includeSubDomains'], # 57
+      ['strict-transport-security', 'max-age=31536000; includeSubDomains; preload'], # 58
       ['vary', 'accept-encoding'],                             # 59
       ['vary', 'origin'],                                      # 60
       ['x-content-type-options', 'nosniff'],                   # 61
@@ -134,22 +181,40 @@ module Quicsilver
     QPACK_CONTENT_TYPE_JSON = 46
     QPACK_CONTENT_TYPE_PLAIN = 53
 
+    # Maximum stream ID for initial GOAWAY (2^62 - 4, per RFC 9114)
+    MAX_STREAM_ID = (2**62) - 4
+
     class << self
+      # Precomputed varint encodings for single-byte values (0-63)
+      VARINT_SMALL = Array.new(64) { |v| [v].pack('C').freeze }.freeze
+      VARINT_MED = Array.new(16384 - 64) { |i| v = i + 64; [0x40 | (v >> 8), v & 0xFF].pack('C*').freeze }.freeze
+
+      # Cache for large varint encodings (values >= 16384)
+      VARINT_LARGE_CACHE = {}
+      VARINT_LARGE_CACHE_MAX = 256
+
       # Encode variable-length integer
       def encode_varint(value)
-        case value
-        when 0..63
-          [value].pack('C')
-        when 64..16383
-          [0x40 | (value >> 8), value & 0xFF].pack('C*')
-        when 16384..1073741823
-          [0x80 | (value >> 24), (value >> 16) & 0xFF,
-          (value >> 8) & 0xFF, value & 0xFF].pack('C*')
+        if value < 64
+          VARINT_SMALL[value]
+        elsif value < 16384
+          VARINT_MED[value - 64]
         else
-          [0xC0 | (value >> 56), (value >> 48) & 0xFF,
-          (value >> 40) & 0xFF, (value >> 32) & 0xFF,
-          (value >> 24) & 0xFF, (value >> 16) & 0xFF,
-          (value >> 8) & 0xFF, value & 0xFF].pack('C*')
+          cached = VARINT_LARGE_CACHE[value]
+          return cached if cached
+
+          result = if value < 1073741824
+            [0x80 | (value >> 24), (value >> 16) & 0xFF,
+            (value >> 8) & 0xFF, value & 0xFF].pack('C*').freeze
+          else
+            [0xC0 | (value >> 56), (value >> 48) & 0xFF,
+            (value >> 40) & 0xFF, (value >> 32) & 0xFF,
+            (value >> 24) & 0xFF, (value >> 16) & 0xFF,
+            (value >> 8) & 0xFF, value & 0xFF].pack('C*').freeze
+          end
+
+          VARINT_LARGE_CACHE[value] = result if VARINT_LARGE_CACHE.size < VARINT_LARGE_CACHE_MAX
+          result
         end
       end
 
@@ -166,12 +231,25 @@ module Quicsilver
         frame_type + frame_length + payload
       end
 
+      # Generate a random GREASE ID (RFC 9297): 31 * n + 33
+      def grease_id
+        31 * rand(0..20) + 33
+      end
+
       # Build control stream data
-      def build_control_stream
+      # @param max_field_section_size [Integer, nil] Advertise SETTINGS_MAX_FIELD_SECTION_SIZE (0x06)
+      #   to the peer (RFC 9114 §4.2.2 / §7.2.4.1). nil = don't advertise.
+      def build_control_stream(max_field_section_size: nil)
         stream_type = [0x00].pack('C')  # Control stream type
-        settings = build_settings_frame({})
+        settings_hash = {
+          0x01 => 0,           # QPACK_MAX_TABLE_CAPACITY = 0 (no dynamic table)
+          0x07 => 0,           # QPACK_BLOCKED_STREAMS = 0
+          0x08 => 1,           # SETTINGS_ENABLE_CONNECT_PROTOCOL (RFC 9220)
+        }
+        settings_hash[0x06] = max_field_section_size if max_field_section_size  # SETTINGS_MAX_FIELD_SECTION_SIZE
+        settings_hash[grease_id] = grease_id  # GREASE setting (RFC 9297)
 
-        stream_type + settings
+        stream_type + build_settings_frame(settings_hash)
       end
 
       # Build GOAWAY frame (RFC 9114 Section 7.2.6)
@@ -184,32 +262,71 @@ module Quicsilver
         frame_type + frame_length + payload
       end
 
-      # Maximum stream ID for initial GOAWAY (2^62 - 4, per RFC 9114)
-      MAX_STREAM_ID = (2**62) - 4
+      # Cache for decode_varint_str: (object_id << 16 | offset) → [value, consumed]
+      VARINT_STR_CACHE = {}
+      VARINT_STR_CACHE_MAX = 256
+
+      # Decode variable-length integer from a String using getbyte (no array needed)
+      # Returns [value, bytes_consumed]
+      def decode_varint_str(str, offset = 0)
+        cache_key = (str.object_id << 16) | offset
+        cached = VARINT_STR_CACHE[cache_key]
+        return cached if cached
+
+        first = str.getbyte(offset)
+        return [0, 0] unless first
+
+        if first < 0x40
+          result = VARINT_DECODE_SMALL[first]
+        else
+          prefix = (first & 0xC0) >> 6
+          length = 1 << prefix
+
+          return [0, 0] if offset + length > str.bytesize
+
+          result = case prefix
+          when 0
+            [first & 0x3F, 1]
+          when 1
+            [(first & 0x3F) << 8 | str.getbyte(offset + 1), 2]
+          when 2
+            [(first & 0x3F) << 24 | str.getbyte(offset + 1) << 16 |
+            str.getbyte(offset + 2) << 8 | str.getbyte(offset + 3), 4]
+          else
+            [(first & 0x3F) << 56 | str.getbyte(offset + 1) << 48 |
+            str.getbyte(offset + 2) << 40 | str.getbyte(offset + 3) << 32 |
+            str.getbyte(offset + 4) << 24 | str.getbyte(offset + 5) << 16 |
+              str.getbyte(offset + 6) << 8 | str.getbyte(offset + 7), 8]
+          end
+        end
+
+        VARINT_STR_CACHE[cache_key] = result if VARINT_STR_CACHE.size < VARINT_STR_CACHE_MAX
+        result
+      end
+
+      # Precomputed decode results for single-byte varints (0-63)
+      VARINT_DECODE_SMALL = Array.new(64) { |v| [v, 1].freeze }.freeze
 
       # Decode variable-length integer (RFC 9000)
       # Returns [value, bytes_consumed]
       def decode_varint(bytes, offset = 0)
-        return [0, 0] if offset >= bytes.size
-
         first = bytes[offset]
-        return [0, 0] if first.nil?
+        return [0, 0] unless first
 
-        prefix = (first & 0xC0) >> 6 # Extract 2 MSB
-        length = 1 << prefix # 1, 2, 4, or 8 bytes
+        # Fast path for single-byte varints (most common: frame types, small lengths)
+        return VARINT_DECODE_SMALL[first] if first < 0x40
 
-        # Check if we have enough bytes
+        prefix = (first & 0xC0) >> 6
+        length = 1 << prefix
         return [0, 0] if offset + length > bytes.size
 
         case prefix
-        when 0
-          [first & 0x3F, 1]
         when 1
           [(first & 0x3F) << 8 | bytes[offset + 1], 2]
         when 2
           [(first & 0x3F) << 24 | bytes[offset + 1] << 16 |
           bytes[offset + 2] << 8 | bytes[offset + 3], 4]
-        else # when 3
+        else # 3
           [(first & 0x3F) << 56 | bytes[offset + 1] << 48 |
           bytes[offset + 2] << 40 | bytes[offset + 3] << 32 |
           bytes[offset + 4] << 24 | bytes[offset + 5] << 16 |
@@ -219,4 +336,3 @@ module Quicsilver
     end
   end
 end
-

data/lib/quicsilver/protocol/priority.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Protocol
+    # HTTP Extensible Priorities (RFC 9218).
+    #
+    # Parses the `priority` header from HTTP requests. Urgency ranges from
+    # 0 (highest) to 7 (lowest), defaulting to 3. Incremental indicates
+    # whether partial data is useful to the client (e.g. progressive images).
+    #
+    # Usage:
+    #   priority = Priority.parse("u=0, i")
+    #   priority.urgency     # => 0
+    #   priority.incremental # => true
+    #
+    #   priority = Priority.parse(nil)  # default
+    #   priority.urgency     # => 3
+    #   priority.incremental # => false
+    class Priority
+      DEFAULT_URGENCY = 3
+      MIN_URGENCY = 0
+      MAX_URGENCY = 7
+
+      attr_reader :urgency, :incremental
+
+      def initialize(urgency: DEFAULT_URGENCY, incremental: false)
+        @urgency = urgency.clamp(MIN_URGENCY, MAX_URGENCY)
+        @incremental = incremental
+      end
+
+      # Parse a priority header value (RFC 9218 §4, Structured Field Values).
+      # Returns a Priority with defaults for missing or invalid values.
+      def self.parse(value)
+        return new unless value && !value.empty?
+
+        urgency = DEFAULT_URGENCY
+        incremental = false
+
+        value.split(",").each do |param|
+          param = param.strip
+          if param.start_with?("u=")
+            urgency = param[2..].to_i
+          elsif param == "i"
+            incremental = true
+          elsif param == "i=?0"
+            incremental = false
+          elsif param == "i=?1"
+            incremental = true
+          end
+        end
+
+        new(urgency: urgency, incremental: incremental)
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/qpack/decoder.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "huffman"
+
+module Quicsilver
+  module Protocol
+    module Qpack
+      module Decoder
+        # Decode a QPACK string literal (RFC 9204 Section 4.1.2)
+        # Returns [string, bytes_consumed]
+        # String-based variant: accepts a binary String instead of byte array
+        def decode_qpack_string_from_str(data, offset)
+          first = data.getbyte(offset)
+          huffman = (first & 0x80) != 0
+
+          length = first & 0x7F
+          len_bytes = 1
+          if length == 0x7F
+            multiplier = 1
+            while offset + len_bytes < data.bytesize
+              next_byte = data.getbyte(offset + len_bytes)
+              len_bytes += 1
+              length += (next_byte & 0x7F) * multiplier
+              break if (next_byte & 0x80) == 0
+              multiplier *= 128
+            end
+          end
+
+          data_offset = offset + len_bytes
+          raw = data.byteslice(data_offset, length)
+
+          str = if huffman
+            Huffman.decode(raw) || raw
+          else
+            raw
+          end
+
+          [str, len_bytes + length]
+        end
+
+        # Cache for decode_qpack_string
+        DQS_CACHE = {}        # array-content → [str, consumed]
+        DQS_OID_CACHE = {}    # object_id|offset → [str, consumed]
+        DQS_CACHE_MAX = 128
+
+        # 2-slot last-result cache for decode_qpack_string
+        DQS_LAST_A = [nil, nil, nil] # [bytes, offset, result]
+        DQS_LAST_B = [nil, nil, nil]
+
+        def decode_qpack_string(bytes, offset)
+          # 2-slot equal? fast path (covers alternating-object patterns)
+          return DQS_LAST_A[2] if bytes.equal?(DQS_LAST_A[0]) && offset == DQS_LAST_A[1]
+          return DQS_LAST_B[2] if bytes.equal?(DQS_LAST_B[0]) && offset == DQS_LAST_B[1]
+
+          # Object-id cache
+          oid_key = (bytes.object_id << 16) | offset
+          cached = DQS_OID_CACHE[oid_key]
+          if cached
+            # Rotate 2-slot cache
+            DQS_LAST_B[0], DQS_LAST_B[1], DQS_LAST_B[2] = DQS_LAST_A[0], DQS_LAST_A[1], DQS_LAST_A[2]
+            DQS_LAST_A[0], DQS_LAST_A[1], DQS_LAST_A[2] = bytes, offset, cached
+            return cached
+          end
+
+          # Dispatch to string variant if given a String
+          return decode_qpack_string_from_str(bytes, offset) if bytes.is_a?(String)
+
+          # Content-based cache for offset=0
+          if offset == 0
+            cached = DQS_CACHE[bytes]
+            if cached
+              DQS_OID_CACHE[oid_key] = cached
+              return cached
+            end
+          end
+
+          first = bytes[offset]
+          huffman = (first & 0x80) != 0
+
+          # Inline 7-bit prefix integer decode to avoid method call
+          length = first & 0x7F
+          len_bytes = 1
+          if length == 0x7F
+            multiplier = 1
+            while offset + len_bytes < bytes.size
+              next_byte = bytes[offset + len_bytes]
+              len_bytes += 1
+              length += (next_byte & 0x7F) * multiplier
+              break if (next_byte & 0x80) == 0
+              multiplier *= 128
+            end
+          end
+
+          data_offset = offset + len_bytes
+          raw = bytes[data_offset, length].pack("C*")
+
+          str = if huffman
+            Huffman.decode(raw) || raw
+          else
+            raw
+          end
+
+          result = [str, len_bytes + length].freeze
+
+          # Cache for offset=0 (common case: standalone decode)
+          if offset == 0 && DQS_CACHE.size < DQS_CACHE_MAX
+            DQS_CACHE[bytes.frozen? ? bytes : bytes.dup.freeze] = result
+          end
+          DQS_OID_CACHE[oid_key] = result if DQS_OID_CACHE.size < DQS_CACHE_MAX
+
+          result
+        end
+
+        # String-based prefix integer decoding
+        def decode_prefix_integer_str(data, offset, prefix_bits, pattern_mask)
+          max_prefix = (1 << prefix_bits) - 1
+          first_byte = data.getbyte(offset)
+          value = first_byte & max_prefix
+          bytes_consumed = 1
+
+          if value == max_prefix
+            multiplier = 1
+            loop do
+              return [value, bytes_consumed] if offset + bytes_consumed >= data.bytesize
+              next_byte = data.getbyte(offset + bytes_consumed)
+              bytes_consumed += 1
+              value += (next_byte & 0x7F) * multiplier
+              break if (next_byte & 0x80) == 0
+              multiplier *= 128
+            end
+          end
+
+          [value, bytes_consumed]
+        end
+
+        # RFC 7541 prefix integer decoding
+        # Returns [value, bytes_consumed]
+        def decode_prefix_integer(bytes, offset, prefix_bits, pattern_mask)
+          max_prefix = (1 << prefix_bits) - 1
+
+          first_byte = bytes[offset]
+          value = first_byte & max_prefix
+          bytes_consumed = 1
+
+          if value == max_prefix
+            multiplier = 1
+            loop do
+              return [value, bytes_consumed] if offset + bytes_consumed >= bytes.size
+
+              next_byte = bytes[offset + bytes_consumed]
+              bytes_consumed += 1
+
+              value += (next_byte & 0x7F) * multiplier
+              break if (next_byte & 0x80) == 0
+
+              multiplier *= 128
+            end
+          end
+
+          [value, bytes_consumed]
+        end
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/qpack/encoder.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+require_relative "huffman"
+
+module Quicsilver
+  module Protocol
+    module Qpack
+      class Encoder
+        STATIC_TABLE = Protocol::STATIC_TABLE
+
+        # Pre-built hash for O(1) static table lookups
+        STATIC_LOOKUP_FULL = {} # "name\0value" => index
+        STATIC_LOOKUP_NAME = {} # name => first_index
+
+        STATIC_TABLE.each_with_index do |(tbl_name, tbl_value), idx|
+          STATIC_LOOKUP_FULL["#{tbl_name}\0#{tbl_value}".freeze] = idx
+          STATIC_LOOKUP_NAME[tbl_name] ||= idx
+        end
+        STATIC_LOOKUP_FULL.freeze
+        STATIC_LOOKUP_NAME.freeze
+
+        PREFIX = "\x00\x00".b.freeze
+
+        FIELD_CACHE_MAX = 512
+
+        def initialize(huffman: true)
+          @huffman = huffman
+          @field_cache = {}
+          @block_cache = {}
+          @oid_cache = {}
+        end
+
+        def encode(headers)
+          # Fastest path: exact same object as last call
+          return @last_result if headers.equal?(@last_headers)
+
+          # Fast path: check object_id cache (same array object reused)
+          oid = headers.object_id
+          cached = @oid_cache[oid]
+          if cached
+            @last_headers = headers
+            @last_result = cached
+            return cached
+          end
+
+          if headers.is_a?(Array) && headers.size <= 16
+            # Content-based caching for small header sets
+            block_key = headers.map { |n, v| "#{n}\0#{v}" }.join("\x01")
+            cached_block = @block_cache[block_key]
+            if cached_block
+              @oid_cache[oid] = cached_block if @oid_cache.size < BLOCK_CACHE_MAX
+              return cached_block
+            end
+
+            result = encode_fields(headers)
+            result_frozen = result.freeze
+            if @block_cache.size < BLOCK_CACHE_MAX
+              @block_cache[block_key.freeze] = result_frozen
+            end
+            @oid_cache[oid] = result_frozen if @oid_cache.size < BLOCK_CACHE_MAX
+            return result_frozen
+          end
+
+          encode_fields(headers)
+        end
+
+        BLOCK_CACHE_MAX = 128
+
+        private def encode_fields(headers)
+          out = encode_prefix
+          headers.each do |name, value|
+            name = name.to_s
+            value = value.to_s
+            # Downcase only if needed (most HTTP/3 headers are already lowercase)
+            name = name.downcase if name.match?(/[A-Z]/)
+
+            cache_key = "#{name}\0#{value}"
+
+            # Check field cache
+            cached = @field_cache[cache_key]
+            if cached
+              out << cached
+              next
+            end
+
+            field_start = out.bytesize
+
+            full_idx = STATIC_LOOKUP_FULL[cache_key]
+
+            if full_idx
+              # Indexed Field Line
+              out << encode_prefixed_int(full_idx, 6, 0xC0)
+            else
+              name_idx = STATIC_LOOKUP_NAME[name]
+              if name_idx
+                # Literal with Name Reference
+                out << encode_prefixed_int(name_idx, 4, 0x50)
+                encode_str_into(out, value)
+              else
+                # Literal with Literal Name
+                encode_literal_into(out, name, value)
+              end
+            end
+
+            # Cache the encoded field bytes
+            if @field_cache.size < FIELD_CACHE_MAX
+              @field_cache[cache_key.freeze] = out.byteslice(field_start..).freeze
+            end
+          end
+          out
+        end
+
+        def lookup(name, value)
+          name = name.to_s.downcase
+          value = value.to_s
+          full_idx = STATIC_LOOKUP_FULL["#{name}\0#{value}"]
+          return [full_idx, true] if full_idx
+          name_idx = STATIC_LOOKUP_NAME[name]
+          name_idx ? [name_idx, false] : nil
+        end
+
+        def encode_prefix
+          PREFIX.dup
+        end
+
+        # Public API for encoding a single string value (used by tests/external code)
+        def encode_str(value)
+          out = "".b
+          encode_str_into(out, value.to_s)
+          out
+        end
+
+        private
+
+        # Pattern 1: Indexed Field Line (1xxxxxxx) — kept for test compatibility
+        def encode_indexed(index)
+          encode_prefixed_int(index, 6, 0xC0)
+        end
+
+        def encode_literal_into(out, name, value)
+          name_b = name.b
+          if @huffman
+            huffman_name = Huffman.encode(name_b)
+            if huffman_name.bytesize < name_b.bytesize
+              out << encode_prefixed_int(huffman_name.bytesize, 3, 0x28)
+              out << huffman_name
+              encode_str_into(out, value)
+              return
+            end
+          end
+          out << encode_prefixed_int(name_b.bytesize, 3, 0x20)
+          out << name_b
+          encode_str_into(out, value)
+        end
+
+        def encode_str_into(out, value)
+          value_b = value.b
+          if @huffman
+            huffman = Huffman.encode(value_b)
+            if huffman.bytesize < value_b.bytesize
+              out << encode_prefixed_int(huffman.bytesize, 7, 0x80)
+              out << huffman
+              return
+            end
+          end
+          out << encode_prefixed_int(value_b.bytesize, 7, 0x00)
+          out << value_b
+        end
+
+        # Pre-computed prefix integer tables for hot encode paths.
+        # Key: [prefix_bits, pattern] => Array of frozen encoded strings indexed by value.
+        # Covers all values up to max_prefix (single-byte) and a range beyond.
+        PREFIXED_INT_CACHE = {}
+        [
+          [6, 0xC0],  # Indexed Field Line
+          [4, 0x50],  # Literal with Name Reference (static)
+          [7, 0x80],  # Huffman string length
+          [7, 0x00],  # Raw string length
+          [3, 0x28],  # Huffman literal name length
+          [3, 0x20],  # Raw literal name length
+        ].each do |prefix_bits, pattern|
+          max_prefix = (1 << prefix_bits) - 1
+          # Pre-compute single-byte range + a bit beyond for multi-byte
+          limit = [max_prefix + 64, 256].min
+          table = Array.new(limit) do |value|
+            if value < max_prefix
+              (pattern | value).chr(Encoding::BINARY).freeze
+            else
+              buf = (pattern | max_prefix).chr(Encoding::BINARY)
+              v = value - max_prefix
+              while v >= 128
+                buf << ((v & 0x7F) | 0x80).chr(Encoding::BINARY)
+                v >>= 7
+              end
+              buf << v.chr(Encoding::BINARY)
+              buf.freeze
+            end
+          end
+          PREFIXED_INT_CACHE[[prefix_bits, pattern]] = table.freeze
+        end
+        PREFIXED_INT_CACHE.freeze
+
+        # RFC 7541 prefix integer encoding
+        def encode_prefixed_int(value, prefix_bits, pattern)
+          table = PREFIXED_INT_CACHE[[prefix_bits, pattern]]
+          if table && value < table.size
+            return table[value]
+          end
+
+          max_prefix = (1 << prefix_bits) - 1
+
+          if value < max_prefix
+            (pattern | value).chr(Encoding::BINARY)
+          else
+            buf = (pattern | max_prefix).chr(Encoding::BINARY)
+            value -= max_prefix
+            while value >= 128
+              buf << ((value & 0x7F) | 0x80).chr(Encoding::BINARY)
+              value >>= 7
+            end
+            buf << value.chr(Encoding::BINARY)
+            buf
+          end
+        end
+      end
+    end
+  end
+end