RubyGems - quicsilver - Versions diffs - 0.5.0-x86_64-linux - Mend

quicsilver 0.5.0-x86_64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (107) hide show

checksums.yaml +7 -0
data/.github/workflows/ci.yml +49 -0
data/.github/workflows/cibuildgem.yaml +117 -0
data/.gitignore +21 -0
data/.gitmodules +3 -0
data/.ruby-version +1 -0
data/CHANGELOG.md +175 -0
data/Gemfile +6 -0
data/Gemfile.lock +67 -0
data/LICENSE +21 -0
data/README.md +261 -0
data/Rakefile +130 -0
data/benchmarks/baseline.rb +175 -0
data/benchmarks/compare.rb +398 -0
data/benchmarks/components.rb +191 -0
data/benchmarks/helpers.rb +162 -0
data/benchmarks/latency.rb +128 -0
data/benchmarks/loss.rb +193 -0
data/benchmarks/mobile.rb +125 -0
data/bin/console +14 -0
data/bin/setup +8 -0
data/docs/connection_identity.md +141 -0
data/examples/README.md +58 -0
data/examples/benchmark.rb +191 -0
data/examples/connection_pool_demo.rb +47 -0
data/examples/example_helper.rb +69 -0
data/examples/falcon_middleware.rb +44 -0
data/examples/feature_demo.rb +125 -0
data/examples/grpc_style.rb +97 -0
data/examples/latency_aware_routing.rb +382 -0
data/examples/lifecycle_drain.rb +264 -0
data/examples/minimal_http3_server.rb +14 -0
data/examples/priorities.rb +60 -0
data/examples/protocol_http_server.rb +31 -0
data/examples/rack_http3_server.rb +42 -0
data/examples/rails_feature_test.rb +280 -0
data/examples/server_stats.rb +117 -0
data/examples/simple_client_test.rb +26 -0
data/examples/streaming_sse.rb +33 -0
data/examples/trailers.rb +69 -0
data/examples/webtransport_smoke.rb +546 -0
data/examples/worker_load_balancing.rb +425 -0
data/ext/quicsilver/extconf.rb +124 -0
data/ext/quicsilver/include/msquic.h +2226 -0
data/ext/quicsilver/include/msquic_posix.h +696 -0
data/ext/quicsilver/include/quic_sal_stub.h +314 -0
data/ext/quicsilver/msquic_patch.rb +68 -0
data/ext/quicsilver/patches/reliable-reset.patch +723 -0
data/ext/quicsilver/patches/stream-final-size.patch +47 -0
data/ext/quicsilver/quicsilver.c +2741 -0
data/lib/quicsilver/3.4/quicsilver.so +0 -0
data/lib/quicsilver/4.0/quicsilver.so +0 -0
data/lib/quicsilver/client/client.rb +708 -0
data/lib/quicsilver/client/connection_pool.rb +202 -0
data/lib/quicsilver/client/request.rb +190 -0
data/lib/quicsilver/errors.rb +39 -0
data/lib/quicsilver/libmsquic.so.2 +0 -0
data/lib/quicsilver/protocol/adapter.rb +196 -0
data/lib/quicsilver/protocol/capsule.rb +38 -0
data/lib/quicsilver/protocol/connect_stream_decoder.rb +75 -0
data/lib/quicsilver/protocol/control_stream_parser.rb +117 -0
data/lib/quicsilver/protocol/datagram.rb +40 -0
data/lib/quicsilver/protocol/frame_parser.rb +141 -0
data/lib/quicsilver/protocol/frame_reader.rb +84 -0
data/lib/quicsilver/protocol/frames.rb +454 -0
data/lib/quicsilver/protocol/priority.rb +65 -0
data/lib/quicsilver/protocol/qpack/decoder.rb +127 -0
data/lib/quicsilver/protocol/qpack/encoder.rb +217 -0
data/lib/quicsilver/protocol/qpack/header_block_decoder.rb +140 -0
data/lib/quicsilver/protocol/qpack/huffman.rb +459 -0
data/lib/quicsilver/protocol/request_encoder.rb +50 -0
data/lib/quicsilver/protocol/request_parser.rb +289 -0
data/lib/quicsilver/protocol/response_encoder.rb +107 -0
data/lib/quicsilver/protocol/response_parser.rb +147 -0
data/lib/quicsilver/protocol/stream_input.rb +98 -0
data/lib/quicsilver/protocol/stream_output.rb +59 -0
data/lib/quicsilver/protocol/unidirectional_stream.rb +12 -0
data/lib/quicsilver/protocol/web_transport.rb +214 -0
data/lib/quicsilver/rack/context.rb +33 -0
data/lib/quicsilver/response.rb +40 -0
data/lib/quicsilver/server/listener_data.rb +14 -0
data/lib/quicsilver/server/rack_adapter.rb +77 -0
data/lib/quicsilver/server/receive_queue.rb +106 -0
data/lib/quicsilver/server/request_handler.rb +149 -0
data/lib/quicsilver/server/request_registry.rb +63 -0
data/lib/quicsilver/server/scheduler.rb +50 -0
data/lib/quicsilver/server/schedulers/fiber_scheduler.rb +79 -0
data/lib/quicsilver/server/schedulers/thread_scheduler.rb +76 -0
data/lib/quicsilver/server/server.rb +1080 -0
data/lib/quicsilver/server/web_transport_flow_control.rb +270 -0
data/lib/quicsilver/server/web_transport_manager.rb +281 -0
data/lib/quicsilver/server/web_transport_registry.rb +40 -0
data/lib/quicsilver/server/web_transport_session.rb +812 -0
data/lib/quicsilver/server/web_transport_stream.rb +326 -0
data/lib/quicsilver/transport/configuration.rb +234 -0
data/lib/quicsilver/transport/connection.rb +594 -0
data/lib/quicsilver/transport/connection_stats.rb +53 -0
data/lib/quicsilver/transport/event_loop.rb +74 -0
data/lib/quicsilver/transport/inbound_stream.rb +53 -0
data/lib/quicsilver/transport/stream.rb +43 -0
data/lib/quicsilver/transport/stream_event.rb +49 -0
data/lib/quicsilver/transport/stream_id.rb +26 -0
data/lib/quicsilver/version.rb +3 -0
data/lib/quicsilver.rb +96 -0
data/lib/rackup/handler/quicsilver.rb +96 -0
data/quicsilver.gemspec +66 -0
metadata +362 -0

data/examples/webtransport_smoke.rb ADDED Viewed

@@ -0,0 +1,546 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# Minimal browser WebTransport smoke test.
+#
+#   ruby examples/webtransport_smoke.rb
+#   open https://localhost:8443/
+#
+# Chrome discovers HTTP/3 using Alt-Svc from a normal HTTPS/TCP origin. This
+# example therefore starts two servers:
+#
+# - Tiny HTTPS/TCP server on https://localhost:8443 serving this page + Alt-Svc.
+# - Quicsilver HTTP/3/UDP on localhost:8443 handling the same origin via Alt-Svc.
+#
+# It intentionally avoids Rails, framing, endpoints, and stress testing. It only
+# answers: does browser WebTransport reach Rack as
+# env["quicsilver.context"].webtransport, can we accept it, and can one bidi
+# stream echo bytes?
+require_relative "example_helper"
+require "openssl"
+require "socket"
+require "tmpdir"
+HTTPS_PORT = Integer(ENV.fetch("HTTPS_PORT", "8443"))
+H3_PORT = Integer(ENV.fetch("H3_PORT", HTTPS_PORT.to_s))
+HOST = ENV.fetch("HOST", "quicsilver.test")
+ALT_SVC = %(h3=":#{H3_PORT}"; ma=3600)
+CERT_DIR = File.dirname(EXAMPLE_TLS_CONFIG.cert_file)
+ISSUER_CERT = File.join(CERT_DIR, "development.crt")
+PAGE_CERT = ENV.fetch("PAGE_CERT") { File.join(CERT_DIR, "#{HOST}.crt") }
+PAGE_KEY = ENV.fetch("PAGE_KEY") { File.join(CERT_DIR, "#{HOST}.key") }
+PAGE_CERT = EXAMPLE_TLS_CONFIG.cert_file unless File.exist?(PAGE_CERT)
+PAGE_KEY = EXAMPLE_TLS_CONFIG.key_file unless File.exist?(PAGE_KEY)
+CERT_FILE = File.join(Dir.tmpdir, "quicsilver-#{HOST}-short.crt")
+KEY_FILE = File.join(Dir.tmpdir, "quicsilver-#{HOST}-short.key")
+key = OpenSSL::PKey::EC.generate("prime256v1")
+cert = OpenSSL::X509::Certificate.new
+cert.version = 2
+cert.serial = Random.rand(1..2**64)
+cert.subject = OpenSSL::X509::Name.parse("/CN=#{HOST}")
+cert.issuer = cert.subject
+cert.public_key = key
+cert.not_before = Time.now - 60
+cert.not_after = Time.now + (13 * 24 * 60 * 60)
+extensions = OpenSSL::X509::ExtensionFactory.new
+extensions.subject_certificate = cert
+extensions.issuer_certificate = cert
+cert.add_extension extensions.create_extension("basicConstraints", "CA:FALSE", true)
+cert.add_extension extensions.create_extension("keyUsage", "digitalSignature", true)
+cert.add_extension extensions.create_extension("extendedKeyUsage", "serverAuth", false)
+cert.add_extension extensions.create_extension("subjectAltName", "DNS:#{HOST},DNS:localhost,IP:127.0.0.1,IP:::1", false)
+cert.sign(key, OpenSSL::Digest::SHA256.new)
+File.write(CERT_FILE, cert.to_pem)
+File.write(KEY_FILE, key.to_pem)
+CERT_SHA256 = [OpenSSL::Digest::SHA256.digest(cert.to_der)].pack("m0")
+SMOKE_TLS_CONFIG = Quicsilver::Transport::Configuration.new(
+  CERT_FILE,
+  KEY_FILE,
+  idle_timeout_ms: 120_000,
+  keep_alive_interval_ms: 20_000,
+  max_unidirectional_streams: 100
+)
+HTML = <<~HTML
+  <!doctype html>
+  <meta charset="utf-8">
+  <title>Quicsilver WebTransport Smoke</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 2rem; }
+    button { margin: .25rem; }
+    pre { background: #111; color: #0f0; padding: 1rem; min-height: 16rem; white-space: pre-wrap; }
+  </style>
+  <h1>Quicsilver WebTransport Smoke</h1>
+  <p>
+    This page is served over HTTPS/TCP with <code>Alt-Svc: #{ALT_SVC}</code>.
+    The browser should use HTTP/3 on UDP port #{H3_PORT} for WebTransport.
+    TCP and UDP intentionally share the same port, matching production HTTPS/H3 deployments.
+  </p>
+  <button onclick="connectWT()">Connect WebTransport</button>
+  <button onclick="sendBidi()">Open bidi stream + send hello</button>
+  <button onclick="sendUni()">Open uni stream + send hello</button>
+  <button onclick="sendDatagram()">Send datagram</button>
+  <button onclick="sendBulk()">Send 20 MiB (exercise flow control)</button>
+  <button onclick="requestServerBidi()">Request server bidi stream</button>
+  <button onclick="requestServerUni()">Request server uni stream</button>
+  <button onclick="closeWT()">Close</button>
+  <button onclick="clearLog()">Clear</button>
+  <pre id="log"></pre>
+  <script type="module">
+    let transport
+    let readyPromise
+    const encoder = new TextEncoder()
+    const decoder = new TextDecoder()
+    function log(message) {
+      console.log(message)
+      document.getElementById("log").textContent += `${new Date().toISOString()} ${message}\n`
+    }
+    window.clearLog = function() {
+      document.getElementById("log").textContent = ""
+    }
+    function wtURL() {
+      return new URL("/wt", location.href).toString()
+    }
+    window.connectWT = async function() {
+      try {
+        if (transport && readyPromise) {
+          log("using existing WebTransport")
+          await readyPromise
+          return transport
+        }
+        log(`creating WebTransport ${wtURL()}`)
+        log(`using serverCertificateHashes sha-256 #{CERT_SHA256}`)
+        const certificateHash = Uint8Array.from(atob("#{CERT_SHA256}"), character => character.charCodeAt(0))
+        transport = new WebTransport(wtURL(), {
+          serverCertificateHashes: [{
+            algorithm: "sha-256",
+            value: certificateHash,
+          }],
+        })
+        readyPromise = transport.ready
+        transport.closed.then(
+          () => log("transport closed cleanly"),
+          error => log(`transport closed with error: ${error}`)
+        ).finally(() => {
+          transport = null
+          readyPromise = null
+        })
+        log("waiting for ready")
+        await readyPromise
+        log("ready")
+        readIncomingBidi(transport)
+        readIncomingUni(transport)
+        return transport
+      } catch (error) {
+        transport = null
+        readyPromise = null
+        log(`connect failed: ${error.stack || error}`)
+      }
+    }
+    window.sendBidi = async function() {
+      try {
+        const wt = await connectWT()
+        if (!wt) return
+        log("creating bidirectional stream")
+        const stream = await wt.createBidirectionalStream()
+        const writer = stream.writable.getWriter()
+        const reader = stream.readable.getReader()
+        const message = `hello from browser ${Date.now()}`
+        log(`writing: ${message}`)
+        await writer.write(encoder.encode(message))
+        await writer.close()
+        log("waiting for echo")
+        while (true) {
+          const { value, done } = await reader.read()
+          if (done) {
+            log("reader done")
+            break
+          }
+          log(`read: ${decoder.decode(value)}`)
+        }
+      } catch (error) {
+        log(`send failed: ${error.stack || error}`)
+      }
+    }
+    // Push more than the 16 MiB session window the server advertises, so that
+    // if session flow control negotiated, the server must issue WT_MAX_DATA as
+    // it reads. Without flow control this is just a large upload.
+    window.sendBulk = async function() {
+      try {
+        const wt = await connectWT()
+        if (!wt) return
+        const total = 20 * 1024 * 1024
+        const chunk = new Uint8Array(64 * 1024).fill(120)
+        log(`bulk: sending ${total} bytes`)
+        const started = performance.now()
+        const stream = await wt.createUnidirectionalStream()
+        const writer = stream.getWriter()
+        let sent = 0
+        while (sent < total) {
+          await writer.ready
+          await writer.write(chunk)
+          sent += chunk.byteLength
+          if (sent % (4 * 1024 * 1024) === 0) log(`bulk: ${sent} bytes sent`)
+        }
+        await writer.close()
+        log(`bulk: done, ${total} bytes in ${Math.round(performance.now() - started)}ms`)
+      } catch (error) {
+        log(`bulk failed: ${error}`)
+      }
+    }
+    window.sendUni = async function() {
+      try {
+        const wt = await connectWT()
+        if (!wt) return
+        log("creating unidirectional stream")
+        const stream = await wt.createUnidirectionalStream()
+        const writer = stream.getWriter()
+        const message = `hello uni from browser ${Date.now()}`
+        log(`writing uni: ${message}`)
+        await writer.write(encoder.encode(message))
+        await writer.close()
+        log("uni writer closed")
+      } catch (error) {
+        log(`uni failed: ${error.stack || error}`)
+      }
+    }
+    async function readIncomingBidi(wt) {
+      try {
+        const reader = wt.incomingBidirectionalStreams.getReader()
+        while (true) {
+          const { value: stream, done } = await reader.read()
+          if (done) return
+          log("incoming server bidi stream")
+          const streamReader = stream.readable.getReader()
+          while (true) {
+            const { value, done } = await streamReader.read()
+            if (done) {
+              log("incoming server bidi reader done")
+              break
+            }
+            log(`incoming server bidi read: ${decoder.decode(value)}`)
+          }
+        }
+      } catch (error) {
+        log(`incoming bidi failed: ${error.stack || error}`)
+      }
+    }
+    async function readIncomingUni(wt) {
+      try {
+        const reader = wt.incomingUnidirectionalStreams.getReader()
+        while (true) {
+          const { value: stream, done } = await reader.read()
+          if (done) return
+          log("incoming server uni stream")
+          const streamReader = stream.getReader()
+          while (true) {
+            const { value, done } = await streamReader.read()
+            if (done) {
+              log("incoming server uni reader done")
+              break
+            }
+            log(`incoming server uni read: ${decoder.decode(value)}`)
+          }
+        }
+      } catch (error) {
+        log(`incoming uni failed: ${error.stack || error}`)
+      }
+    }
+    window.sendDatagram = async function() {
+      try {
+        const wt = await connectWT()
+        if (!wt) return
+        const message = `datagram from browser ${Date.now()}`
+        log(`sending datagram: ${message}`)
+        const writer = wt.datagrams.writable.getWriter()
+        await writer.write(encoder.encode(message))
+        writer.releaseLock()
+        log("waiting for datagram echo")
+        const reader = wt.datagrams.readable.getReader()
+        const { value, done } = await reader.read()
+        reader.releaseLock()
+        if (done) {
+          log("datagram reader done")
+        } else {
+          log(`datagram read: ${decoder.decode(value)}`)
+        }
+      } catch (error) {
+        log(`datagram failed: ${error.stack || error}`)
+      }
+    }
+    async function sendControlDatagram(command) {
+      const wt = await connectWT()
+      if (!wt) return
+      const writer = wt.datagrams.writable.getWriter()
+      await writer.write(encoder.encode(command))
+      writer.releaseLock()
+    }
+    window.requestServerBidi = async function() {
+      try {
+        log("requesting server bidi stream")
+        await sendControlDatagram("__open_server_bidi__")
+      } catch (error) {
+        log(`server bidi request failed: ${error.stack || error}`)
+      }
+    }
+    window.requestServerUni = async function() {
+      try {
+        log("requesting server uni stream")
+        await sendControlDatagram("__open_server_uni__")
+      } catch (error) {
+        log(`server uni request failed: ${error.stack || error}`)
+      }
+    }
+    window.closeWT = function() {
+      if (transport) {
+        log("closing transport")
+        transport.close()
+      }
+    }
+  </script>
+HTML
+close_stream = lambda do |stream|
+  stream.close
+  true
+rescue StandardError => error
+  warn "WT stream #{stream.stream_id} cleanup error: #{error.class}: #{error.message}"
+  false
+end
+app = lambda do |env|
+  path = env["PATH_INFO"]
+  method = env["REQUEST_METHOD"]
+  context = env["quicsilver.context"]
+  session = context&.webtransport || env["quicsilver.webtransport"]
+  puts "H3 HTTP #{method} #{path} authority=#{env['HTTP_HOST']} protocol=#{env['SERVER_PROTOCOL']} wt=#{!!session} context=#{context.class if context}"
+  if path == "/wt"
+    unless session
+      puts "WT endpoint hit without WebTransport session"
+      next [426, { "content-type" => "text/plain", "alt-svc" => ALT_SVC }, ["No WebTransport session\n"]]
+    end
+    puts "WT session arrived path=#{session.path.inspect} authority=#{session.authority.inspect} stream_id=#{session.stream_id}"
+    session.accept!
+    puts "WT session accepted"
+    # Did session flow control negotiate (draft-ietf-webtrans-http3-16 5.1)?
+    # It needs a non-zero WT_INITIAL_MAX_* from both endpoints. We send ours;
+    # this reports whether the browser sends any, which decides whether the
+    # whole of section 5 is reachable against a browser at all.
+    peer = session.connection.settings
+    offered = {
+      "WT_INITIAL_MAX_DATA" => peer[Quicsilver::Protocol::SETTINGS_WT_INITIAL_MAX_DATA],
+      "WT_INITIAL_MAX_STREAMS_BIDI" => peer[Quicsilver::Protocol::SETTINGS_WT_INITIAL_MAX_STREAMS_BIDI],
+      "WT_INITIAL_MAX_STREAMS_UNI" => peer[Quicsilver::Protocol::SETTINGS_WT_INITIAL_MAX_STREAMS_UNI]
+    }
+    puts "WT peer flow control settings: #{offered.inspect}"
+    puts "WT session flow control enabled: #{session.connection.wt_flow_control_enabled?}"
+    puts "WT peer SETTINGS seen: #{peer.keys.map { |k| "0x#{k.to_s(16)}" }.join(", ")}"
+    session.on_stream do |stream|
+      puts "WT accepted bidi stream id=#{stream.stream_id}"
+      Thread.new do
+        total = 0
+        # A bulk sender pushes more than the advertised window, so reading it
+        # is what makes us grant more credit. Report totals rather than every
+        # chunk, or the logging dominates.
+        while (chunk = stream.read)
+          total += chunk.bytesize
+          if chunk.bytesize > 4096 || total > 65_536
+            puts "WT stream #{stream.stream_id} read #{total} bytes so far"
+            next
+          end
+          puts "WT stream #{stream.stream_id} read #{chunk.bytesize} bytes"
+          response = "echo: #{chunk}"
+          stream.write(response)
+          puts "WT stream #{stream.stream_id} wrote #{response.bytesize} bytes"
+        end
+        puts "WT stream #{stream.stream_id} finished after #{total} bytes"
+      rescue => error
+        warn "WT stream #{stream.stream_id} error: #{error.class}: #{error.message}"
+        warn error.backtrace&.first(5)&.join("\n")
+      ensure
+        close_stream.call(stream)
+      end
+    end
+    session.on_uni_stream do |stream|
+      puts "WT accepted uni stream id=#{stream.stream_id}"
+      Thread.new do
+        total = 0
+        # A bulk upload arrives here. Reading it is what releases session
+        # window, so the server grants more credit as this loop drains it.
+        # Totals only, or the logging drowns out everything else.
+        while (chunk = stream.read)
+          total += chunk.bytesize
+          next if total > 65_536
+          puts "WT uni stream #{stream.stream_id} read #{chunk.bytesize} bytes"
+        end
+        puts "WT uni stream #{stream.stream_id} finished after #{total} bytes"
+      rescue => error
+        warn "WT uni stream #{stream.stream_id} error: #{error.class}: #{error.message}"
+        warn error.backtrace&.first(5)&.join("\n")
+      ensure
+        puts "WT uni stream #{stream.stream_id} closed" if close_stream.call(stream)
+      end
+    end
+    session.on_datagram do |datagram|
+      puts "WT datagram read #{datagram.bytesize} bytes"
+      case datagram
+      when "__open_server_bidi__"
+        stream = session.open_stream
+        message = "hello from server bidi #{Time.now.to_f}"
+        stream.write(message)
+        stream.close
+        puts "WT server bidi stream #{stream.stream_id || "pending (token #{stream.stream_handle})"} wrote #{message.bytesize} bytes"
+      when "__open_server_uni__"
+        stream = session.open_uni_stream
+        message = "hello from server uni #{Time.now.to_f}"
+        stream.write(message)
+        stream.close
+        puts "WT server uni stream #{stream.stream_id || "pending (token #{stream.stream_handle})"} wrote #{message.bytesize} bytes"
+      else
+        response = "echo: #{datagram}"
+        session.send_datagram(response)
+        puts "WT datagram wrote #{response.bytesize} bytes"
+      end
+    rescue => error
+      warn "WT datagram error: #{error.class}: #{error.message}"
+      warn error.backtrace&.first(5)&.join("\n")
+    end
+    session.on_close do
+      puts "WT session closed"
+    end
+    next [200, { "alt-svc" => ALT_SVC }, []]
+  end
+  [200, { "content-type" => "text/html", "alt-svc" => ALT_SVC }, [HTML]]
+end
+h3_server = Quicsilver::Server.new(H3_PORT, app: app, server_configuration: SMOKE_TLS_CONFIG)
+h3_thread = Thread.new { h3_server.start }
+https_server = TCPServer.new(HOST, HTTPS_PORT)
+ssl_context = OpenSSL::SSL::SSLContext.new
+ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(PAGE_CERT))
+ssl_context.extra_chain_cert = [OpenSSL::X509::Certificate.new(File.read(ISSUER_CERT))] if File.exist?(ISSUER_CERT)
+ssl_context.key = OpenSSL::PKey.read(File.read(PAGE_KEY))
+stopping = false
+https_thread = Thread.new do
+  until stopping
+    next unless IO.select([https_server], nil, nil, 0.1)
+    socket = https_server.accept_nonblock(exception: false)
+    next if socket == :wait_readable
+    Thread.new(socket) do |client|
+      begin
+        client = OpenSSL::SSL::SSLSocket.new(client, ssl_context)
+        client.sync_close = true
+        client.accept
+        request_line = client.gets&.strip
+        puts "HTTPS #{request_line}" if request_line
+        # Drain request headers.
+        client.gets until $_ == "\r\n" || $_ == "\n" || $_.nil?
+        body = HTML
+        headers = [
+          "HTTP/1.1 200 OK",
+          "content-type: text/html; charset=utf-8",
+          "content-length: #{body.bytesize}",
+          "alt-svc: #{ALT_SVC}",
+          "connection: close",
+          "",
+          ""
+        ].join("\r\n")
+        client.write(headers)
+        client.write(body)
+      rescue => error
+        warn "HTTPS server error: #{error.class}: #{error.message}"
+      ensure
+        client.close rescue nil
+      end
+    end
+  end
+end
+trap("INT") { stopping = true }
+trap("TERM") { stopping = true }
+puts "🚇 WebTransport smoke test"
+puts "   Page:         https://#{HOST}:#{HTTPS_PORT}/   (HTTPS/TCP + Alt-Svc)"
+puts "   WebTransport: https://#{HOST}:#{HTTPS_PORT}/wt (H3 UDP :#{H3_PORT})"
+puts "   Alt-Svc:      #{ALT_SVC}"
+puts "   Page cert:    #{PAGE_CERT}"
+puts "   Page key:     #{PAGE_KEY}"
+puts "   WT cert:      #{CERT_FILE}"
+puts "   WT key:       #{KEY_FILE}"
+puts "   WT SHA256:    #{CERT_SHA256}"
+puts "   /etc/hosts:   127.0.0.1 #{HOST}"
+puts "   Watch this terminal and the browser console."
+puts
+begin
+  https_thread.join
+ensure
+  stopping = true
+  puts "\nStopping..."
+  begin
+    https_thread.join
+  ensure
+    https_server.close
+    h3_server.stop
+    h3_thread.join(2)
+  end
+end