quicsilver 0.3.0 → 0.5.0

data/lib/quicsilver/protocol/priority.rb

@@ -0,0 +1,65 @@
+# 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.
+      # RFC 9218 §4: Encode as Structured Field Value.
+      # e.g. "u=0, i" or "u=5" or "u=3" (default)
+      def to_s
+        parts = []
+        parts << "u=#{@urgency}" if @urgency != DEFAULT_URGENCY
+        parts << "i" if @incremental
+        parts.empty? ? "u=#{DEFAULT_URGENCY}" : parts.join(", ")
+      end
+
+      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

@@ -38,42 +38,12 @@ module Quicsilver
           [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]
-
+        # Byte-array variant. Results are not cached: the input is mutable, so
+        # keying on identity or object_id returns a stale decode after an
+        # in-place edit. Production decoding uses the String variant above.
         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
 
@@ -100,15 +70,7 @@ module Quicsilver
             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
+          [str, len_bytes + length].freeze
         end
 
         # String-based prefix integer decoding

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

@@ -26,37 +26,27 @@ module Quicsilver
           @huffman = huffman
           @field_cache = {}
           @block_cache = {}
-          @oid_cache = {}
         end
 
+        # Caches are keyed by header content, never by identity or object_id:
+        # callers may reuse and mutate the same array, and an identity hit
+        # would return the previous encoding.
+        #
+        # Caching a whole field block is only sound because encoding is
+        # static-table-only: Required Insert Count is always zero, so the bytes
+        # never depend on connection state. Implementing the dynamic table
+        # would invalidate @block_cache, since indices are relative to a Base.
         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
+            return cached_block if cached_block
 
-            result = encode_fields(headers)
-            result_frozen = result.freeze
+            result_frozen = encode_fields(headers).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
 
@@ -71,7 +61,7 @@ module Quicsilver
             name = name.to_s
             value = value.to_s
             # Downcase only if needed (most HTTP/3 headers are already lowercase)
-            name = name.downcase if name =~ /[A-Z]/
+            name = name.downcase if name.match?(/[A-Z]/)
 
             cache_key = "#{name}\0#{value}"
 
@@ -166,8 +156,46 @@ module Quicsilver
           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

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

@@ -51,7 +51,22 @@ module Quicsilver
           end
 
           headers = []
-          offset = 2 # skip required insert count + delta base prefix
+
+          # Decode Required Insert Count (RFC 9204 §4.5.1) — 8-bit prefix integer
+          required_insert_count, ric_bytes = decode_prefix_integer_str(payload, 0, 8, 0x00)
+          offset = ric_bytes
+
+          # Decode Delta Base (RFC 9204 §4.5.1) — 7-bit prefix integer with sign bit
+          delta_base, db_bytes = decode_prefix_integer_str(payload, offset, 7, 0x80)
+          offset += db_bytes
+
+          # Static-only mode: Required Insert Count and Delta Base must be 0
+          if required_insert_count != 0 || delta_base != 0
+            raise Protocol::FrameError.new(
+              "Dynamic QPACK table not supported (required_insert_count=#{required_insert_count}, delta_base=#{delta_base})",
+              error_code: Protocol::QPACK_DECOMPRESSION_FAILED
+            )
+          end
 
           while offset < payload.bytesize
             byte = payload.getbyte(offset)

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

@@ -364,8 +364,8 @@ module Quicsilver
 
             result = encode_uncached(data)
 
-            # Cache short strings (frozen)
-            if data.bytesize <= 128 && HUFF_ENCODE_CACHE.size < CACHE_MAX
+            # Cache encoded results (frozen) — includes large headers like CSP
+            if HUFF_ENCODE_CACHE.size < CACHE_MAX
               HUFF_ENCODE_MUTEX.synchronize do
                 HUFF_ENCODE_CACHE[data.frozen? ? data : data.dup.freeze] = result.freeze if HUFF_ENCODE_CACHE.size < CACHE_MAX
               end
@@ -410,8 +410,8 @@ module Quicsilver
 
             result = decode_uncached(encoded_data)
 
-            # Cache short encoded data (frozen)
-            if encoded_data.bytesize <= 128 && result && HUFF_DECODE_CACHE.size < CACHE_MAX
+            # Cache decoded results (frozen)
+            if result && HUFF_DECODE_CACHE.size < CACHE_MAX
               HUFF_DECODE_MUTEX.synchronize do
                 key = encoded_data.frozen? ? encoded_data : encoded_data.dup.freeze
                 HUFF_DECODE_CACHE[key] = result.freeze if HUFF_DECODE_CACHE.size < CACHE_MAX

data/lib/quicsilver/protocol/request_encoder.rb

@@ -3,7 +3,8 @@
 module Quicsilver
   module Protocol
     class RequestEncoder
-      def initialize(method:, path:, scheme: "https", authority: "localhost:4433", headers: {}, body: nil, encoder: Qpack::Encoder.new)
+      def initialize(method:, path:, scheme: "https", authority: "localhost:4433", headers: {}, body: nil, priority: nil, encoder: Qpack::Encoder.new)
+        @priority = priority
         @method = method.upcase
         @path = path
         @scheme = scheme
@@ -36,11 +37,13 @@ module Quicsilver
           headers << [":authority", @authority]
           headers << [":path", @path]
         end
-        headers + @headers.map { |k, v| [k.to_s, v.to_s] }
+        pairs = headers + @headers.map { |k, v| [k.to_s, v.to_s] }
+        pairs << ["priority", @priority.to_s] if @priority
+        pairs
       end
 
       def build_frame(type, payload)
-        Protocol.encode_varint(type) + Protocol.encode_varint(payload.bytesize) + payload
+        Protocol.build_frame(type, payload)
       end
     end
   end

data/lib/quicsilver/protocol/request_parser.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
-require "stringio"
-require_relative "qpack/header_block_decoder"
+require_relative "frame_parser"
+require_relative "priority"
 
 module Quicsilver
   module Protocol
-    class RequestParser
-      attr_reader :headers
+    class RequestParser < FrameParser
 
-      def frames
-        @frames || []
+      # The parsed priority from the `priority` header (RFC 9218).
+      # Returns a Priority with defaults if no header present.
+      def priority
+        @priority ||= Priority.parse(@headers["priority"])
       end
 
+      METHOD_CONNECT = "CONNECT"
+
       # Known HTTP/3 request pseudo-headers (RFC 9114 §4.3.1)
       VALID_PSEUDO_HEADERS = %w[:method :scheme :authority :path :protocol].freeze
       VALID_PSEUDO_SET = VALID_PSEUDO_HEADERS.each_with_object({}) { |h, s| s[h] = true }.freeze
@@ -20,35 +23,26 @@ module Quicsilver
       FORBIDDEN_HEADERS = %w[connection transfer-encoding keep-alive upgrade proxy-connection te].freeze
       FORBIDDEN_SET = FORBIDDEN_HEADERS.each_with_object({}) { |h, s| s[h] = true }.freeze
 
-      # Frame types forbidden on request streams — use Set-like hash for O(1) lookup
-      CONTROL_ONLY_SET = Protocol::CONTROL_ONLY_FRAMES.each_with_object({}) { |f, h| h[f] = true }.freeze
-
       # Cache for validated header results: payload → headers hash
       # Only used when no custom limits are set (max_header_count, max_header_size)
       HEADERS_CACHE = {}
       HEADERS_CACHE_MAX = 256
 
-      DEFAULT_DECODER = Qpack::HeaderBlockDecoder.default
-
       def initialize(data, **opts)
+        decoder = opts.delete(:decoder) || DEFAULT_DECODER
+        super(decoder: decoder, max_body_size: opts[:max_body_size],
+              max_header_size: opts[:max_header_size],
+              max_header_count: opts[:max_header_count],
+              max_frame_payload_size: opts[:max_frame_payload_size])
         @data = data
-        if opts.empty?
-          @decoder = DEFAULT_DECODER
-          @use_parse_cache = true
-        else
-          @decoder = opts[:decoder] || DEFAULT_DECODER
-          @max_body_size = opts[:max_body_size]
-          @max_header_size = opts[:max_header_size]
-          @max_header_count = opts[:max_header_count]
-          @max_frame_payload_size = opts[:max_frame_payload_size]
-          @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size && !@max_header_count && !@max_frame_payload_size
-        end
+        @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size && !@max_header_count && !@max_frame_payload_size
       end
 
       # Reset parser with new data for object reuse (avoids allocation overhead)
       def reset(data)
         @data = data
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
         @body = nil
         @cached_body_str = nil
@@ -76,7 +70,8 @@ module Quicsilver
             return
           end
         end
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
         @body = nil
         @cached_body_str = nil
@@ -84,20 +79,6 @@ module Quicsilver
         cache_result if @use_parse_cache
       end
 
-      def body
-        if @body
-          @body
-        elsif @cached_body_str
-          @body = StringIO.new(@cached_body_str)
-          @body.set_encoding(Encoding::ASCII_8BIT)
-          @body
-        else
-          EMPTY_BODY
-        end
-      end
-
-      EMPTY_BODY = StringIO.new("".b).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
-
       # Class-level parse result cache
       PARSE_CACHE = {}
       PARSE_CACHE_MAX = 128
@@ -146,7 +127,13 @@ module Quicsilver
 
         method = @headers[":method"]
 
-        if method == "CONNECT"
+        if method == METHOD_CONNECT && @headers[":protocol"]
+          # Extended CONNECT (RFC 9220) — requires :scheme, :path, :authority, :protocol
+          raise Protocol::MessageError, "Extended CONNECT must include :scheme" unless @headers[":scheme"]
+          raise Protocol::MessageError, "Extended CONNECT must include :path" unless @headers[":path"]
+          raise Protocol::MessageError, "Extended CONNECT must include :authority" unless @headers[":authority"]
+        elsif method == METHOD_CONNECT
+          # Regular CONNECT (RFC 9114 §4.4)
           raise Protocol::MessageError, "CONNECT request must include :authority" unless @headers[":authority"]
           raise Protocol::MessageError, "CONNECT request must not include :scheme" if @headers[":scheme"]
           raise Protocol::MessageError, "CONNECT request must not include :path" if @headers[":path"]
@@ -155,8 +142,13 @@ module Quicsilver
           raise Protocol::MessageError, "Request missing required pseudo-header :scheme" unless @headers[":scheme"]
           raise Protocol::MessageError, "Request missing required pseudo-header :path" unless @headers[":path"]
 
-          # RFC 9114 §4.3.1: schemes with mandatory authority (http/https) require :authority or host
+          # RFC 9114 §4.3.1: :path MUST NOT be empty for http or https URIs
           scheme = @headers[":scheme"]
+          if %w[http https].include?(scheme) && @headers[":path"].empty?
+            raise Protocol::MessageError, ":path must not be empty for #{scheme} requests"
+          end
+
+          # RFC 9114 §4.3.1: schemes with mandatory authority (http/https) require :authority or host
           if %w[http https].include?(scheme) && !@headers[":authority"] && !@headers["host"]
             raise Protocol::MessageError, "Request with #{scheme} scheme must include :authority or host"
           end
@@ -168,15 +160,6 @@ module Quicsilver
             raise Protocol::MessageError, ":authority and host header must be consistent"
           end
         end
-
-        # Content-length vs body size (RFC 9114 §4.1.2)
-        if @headers["content-length"]
-          expected = @headers["content-length"].to_i
-          actual = body.size
-          unless expected == actual
-            raise Protocol::MessageError, "Content-length mismatch: header=#{expected}, body=#{actual}"
-          end
-        end
       end
 
       def to_rack_env(stream_info = {})
@@ -184,7 +167,11 @@ module Quicsilver
 
         method = @headers[":method"]
 
-        if method == "CONNECT"
+        if method == METHOD_CONNECT && @headers[":protocol"]
+          # Extended CONNECT (RFC 9220) — has :scheme, :path, :authority, :protocol
+          return nil unless @headers[":scheme"] && @headers[":path"] && @headers[":authority"]
+        elsif method == METHOD_CONNECT
+          # Regular CONNECT (RFC 9114 §4.4)
           return nil unless @headers[":authority"]
         else
           return nil unless method && @headers[":scheme"] && @headers[":path"]
@@ -220,6 +207,11 @@ module Quicsilver
           env["HTTP_HOST"] = @headers[":authority"]
         end
 
+        # Extended CONNECT (RFC 9220) — expose :protocol as rack.protocol
+        if @headers[":protocol"]
+          env["rack.protocol"] = @headers[":protocol"]
+        end
+
         @headers.each do |name, value|
           next if name.start_with?(":")
           key = name.upcase.tr("-", "_")
@@ -237,76 +229,6 @@ module Quicsilver
 
       private
 
-      def parse!
-        @headers = {}
-        buffer = @data
-        offset = 0
-        headers_received = false
-        buf_size = buffer.bytesize
-
-        while offset < buf_size
-          break if buf_size - offset < 2
-
-          # Inline single-byte varint fast path (covers frame types 0x00-0x3F)
-          type_byte = buffer.getbyte(offset)
-          if type_byte < 0x40
-            type = type_byte
-            type_len = 1
-          else
-            type, type_len = Protocol.decode_varint_str(buffer, offset)
-          end
-
-          len_byte = buffer.getbyte(offset + type_len)
-          if len_byte < 0x40
-            length = len_byte
-            length_len = 1
-          else
-            length, length_len = Protocol.decode_varint_str(buffer, offset + type_len)
-            break if length_len == 0
-          end
-          break if type_len == 0
-
-          header_len = type_len + length_len
-
-          break if buf_size < offset + header_len + length
-
-          payload = buffer.byteslice(offset + header_len, length)
-
-          if @max_frame_payload_size && length > @max_frame_payload_size
-            raise Protocol::FrameError, "Frame payload #{length} exceeds limit #{@max_frame_payload_size}"
-          end
-
-          (@frames ||= []) << { type: type, length: length, payload: payload }
-
-          if CONTROL_ONLY_SET.key?(type)
-            raise Protocol::FrameError, "Frame type 0x#{type.to_s(16)} not allowed on request streams"
-          end
-
-          case type
-          when 0x01 # HEADERS
-            if @max_header_size && length > @max_header_size
-              raise Protocol::MessageError, "Header block #{length} exceeds limit #{@max_header_size}"
-            end
-            parse_headers(payload)
-            headers_received = true
-          when 0x00 # DATA
-            raise Protocol::FrameError, "DATA frame before HEADERS" unless headers_received
-            unless @body
-              @body = StringIO.new
-              @body.set_encoding(Encoding::ASCII_8BIT)
-            end
-            @body.write(payload)
-            if @max_body_size && @body.size > @max_body_size
-              raise Protocol::MessageError, "Body size #{@body.size} exceeds limit #{@max_body_size}"
-            end
-          end
-
-          offset += header_len + length
-        end
-
-        @body&.rewind
-      end
-
       # Decode QPACK header block and validate per RFC 9114 §4.2 and §4.3.1:
       # - Header names MUST be lowercase
       # - Pseudo-headers MUST appear before regular headers
@@ -329,7 +251,7 @@ module Quicsilver
 
         @decoder.decode(payload) do |name, value|
           # RFC 9114 §4.2: Header field names MUST be lowercase
-          if name =~ /[A-Z]/
+          if name.match?(/[A-Z]/)
             raise Protocol::MessageError, "Header name '#{name}' contains uppercase characters"
           end
 
@@ -362,26 +284,6 @@ module Quicsilver
           HEADERS_CACHE[key] = @headers.dup.freeze
         end
       end
-
-      # RFC 9110 §5.3: Combine duplicate header values.
-      # - set-cookie: join with "\n" (Rack convention, MUST NOT combine with comma)
-      # - cookie: join with "; " (RFC 9114 §4.2.1)
-      # - all others: join with ", "
-      def store_header(name, value)
-        if @headers.key?(name)
-          separator = case name
-            when "set-cookie" then "\n"
-            when "cookie" then "; "
-            else ", "
-          end
-          @headers[name] = "#{@headers[name]}#{separator}#{value}"
-        else
-          if @max_header_count && @headers.size >= @max_header_count
-            raise Protocol::MessageError, "Header count exceeds limit #{@max_header_count}"
-          end
-          @headers[name] = value
-        end
-      end
     end
   end
 end

data/lib/quicsilver/protocol/response_encoder.rb

@@ -3,12 +3,23 @@
 module Quicsilver
   module Protocol
     class ResponseEncoder
-      def initialize(status, headers, body, encoder: Qpack::Encoder.new, head_request: false)
+      # Encode an informational (1xx) response as a single HEADERS frame.
+      # RFC 9114 §4.1: informational responses are encoded as HEADERS with no body.
+      def self.encode_informational(status, headers, encoder: Qpack::Encoder.new)
+        raise ArgumentError, "Informational status must be 1xx, got #{status}" unless (100..199).include?(status)
+
+        pairs = [[":status", status.to_s]]
+        headers.each { |name, value| pairs << [name.to_s.downcase, value.to_s] }
+        Protocol.build_headers_frame(pairs, encoder: encoder)
+      end
+
+      def initialize(status, headers, body, encoder: Qpack::Encoder.new, head_request: false, trailers: nil)
         @status = status
         @headers = headers
         @body = body
         @encoder = encoder
         @head_request = head_request
+        @trailers = trailers
       end
 
       # Buffered encode - returns all frames at once
@@ -20,8 +31,10 @@ module Quicsilver
             frames << build_frame(FRAME_DATA, chunk) unless chunk.empty?
           end
         end
+        frames << build_frame(FRAME_HEADERS, @encoder.encode(trailer_headers)) if @trailers&.any?
         @body.close if @body.respond_to?(:close)
-        frames
+        # Frozen so send_stream can hand MsQuic the bytes without a copy.
+        frames.freeze
       end
 
       # Streaming encode - yields frames as they're ready
@@ -35,7 +48,10 @@ module Quicsilver
             last_chunk = chunk
           end
 
-          if last_chunk && !last_chunk.empty?
+          if @trailers&.any?
+            yield build_frame(FRAME_DATA, last_chunk), false if last_chunk && !last_chunk.empty?
+            yield build_frame(FRAME_HEADERS, @encoder.encode(trailer_headers)), true
+          elsif last_chunk && !last_chunk.empty?
             yield build_frame(FRAME_DATA, last_chunk), true
           else
             yield "".b, true
@@ -54,19 +70,38 @@ module Quicsilver
 
       def all_headers
         headers = [[":status", @status.to_s]]
+        has_content_length = false
         @headers.each do |name, value|
           downcased = name.to_s.downcase
           next if downcased.start_with?("rack.")
           next if FORBIDDEN_HEADERS.include?(downcased)
+          has_content_length = true if downcased == "content-length"
           headers << [downcased, value.to_s]
         end
+
+        # RFC 9110 §8.6: Auto-set content-length for known-size bodies when not already present.
+        # Skip for 1xx, 204, 304 (no body) and HEAD responses.
+        if !has_content_length && !@head_request && @status >= 200 && @status != 204 && @status != 304
+          if @body.respond_to?(:to_ary)
+            length = @body.to_ary.sum { |chunk| chunk.to_s.bytesize }
+            headers << ["content-length", length.to_s] if length > 0
+          elsif @body.respond_to?(:length) && @body.length
+            headers << ["content-length", @body.length.to_s]
+          end
+        end
+
         headers
       end
 
+      def trailer_headers
+        @trailers.map { |name, value| [name.to_s.downcase, value.to_s] }
+      end
+
       def build_frame(type, payload)
-        payload = payload.to_s.b
-        Protocol.encode_varint(type) + Protocol.encode_varint(payload.bytesize) + payload
+        Protocol.build_frame(type, payload)
       end
+
+
     end
   end
 end