protocol-htty 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c222bcf565b63477735114b057e88c45508674629d78646c0fa73ab34b1abbd9
+  data.tar.gz: fd7405a11f04ee961c218473951ef8f0051dde6f0c581c2ecc129a87f9fbfe37
+SHA512:
+  metadata.gz: 0cf629cde9cb0d76603be89e9290335087a540c92be10e0f433732e6f323306ec8ddd7ba5cbe104ea0b7ef9ac57983bd3b0017005742c4065af1ecceebeca34d
+  data.tar.gz: db74e7230fdd22dbc18f1f4e85526856d3ebdd9eb550c1f7c3fdd6c3e84fcfc45d9ccb97559f813c9985d39d693e0ba2ef21d28a337086f94f76367c8de6dbfc

data/lib/protocol/htty/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+# @namespace
+module Protocol
+	# @namespace
+	module HTTY
+		# The base class for HTTY transport errors.
+		class Error < StandardError
+		end
+		
+		# Raised when an HTTY control packet is malformed or unsupported.
+		class ProtocolError < Error
+		end
+	end
+end

data/lib/protocol/htty/framer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "base64"
+require "protocol/http2/framer"
+
+module Protocol
+	module HTTY
+		# Encode and decode HTTY chunks on top of byte-oriented IO objects.
+		class Framer
+			ESC = "\e"
+			DCS = "#{ESC}P"
+			ST = "#{ESC}\\"
+			PREFIX = "HTTY;1;"
+			
+			# Create a framer around the given input and output streams.
+			# @parameter input [Interface(:read)] The stream to read framed packets from.
+			# @parameter output [Interface(:write, :flush) | Nil] The stream to write framed packets to.
+			def initialize(input, output = input)
+				@input = input
+				@output = output
+			end
+			
+			attr :input
+			attr :output
+			
+			# Write a single HTTY chunk to the output stream.
+			# @parameter payload [String | Array(Integer)] The opaque bytes to encode.
+			# @returns [void]
+			def write_chunk(payload)
+				encoded = Base64.strict_encode64(payload.to_s.b)
+				@output.write("#{DCS}#{PREFIX}#{encoded}#{ST}")
+			end
+			
+			# Read the next HTTY chunk from the input stream.
+			# Non-HTTY terminal output is ignored until a valid chunk prefix is found.
+			# @returns [String | Nil] The decoded payload, or `nil` on end of stream.
+			# @raises [ProtocolError] If the chunk prefix or chunk structure is invalid.
+			# @raises [ArgumentError] If the packet payload is not valid base64.
+			# @raises [EOFError] If the chunk terminator is missing.
+			def read_chunk
+				while payload = read_payload
+					if payload.start_with?("HTTY;") && !payload.start_with?(PREFIX)
+						raise ProtocolError, "Unsupported HTTY chunk version: #{payload.inspect}"
+					end
+					
+					next unless payload.start_with?(PREFIX)
+					encoded = payload.delete_prefix(PREFIX)
+					return Base64.strict_decode64(encoded)
+				end
+				
+				return nil
+			end
+			
+			# Flush the output stream if it supports flushing.
+			# @returns [void]
+			def flush
+				@output.flush if @output.respond_to?(:flush)
+			end
+			
+			# Close the wrapped input and output streams.
+			# If input and output are the same object, it is only closed once.
+			# @returns [void]
+			def close
+				@output.close if @output.respond_to?(:close)
+				@input.close if !@input.equal?(@output) && @input.respond_to?(:close)
+			end
+			
+			# Check whether the output stream has been closed.
+			# @returns [bool] True if the output stream reports that it is closed.
+			def closed?
+				@output.respond_to?(:closed?) && @output.closed?
+			end
+			
+			private
+			
+			def read_payload
+				while prefix = @input.read(1)
+					next unless prefix == ESC
+					
+					marker = @input.read(1)
+					return nil unless marker
+					next unless marker == "P"
+					
+					return consume_packet
+				end
+				
+				return nil
+			end
+			
+			def consume_packet
+				buffer = +""
+				
+				while chunk = @input.read(1)
+					if chunk == ESC
+						terminator = @input.read(1)
+						return buffer if terminator == "\\"
+						
+						buffer << chunk
+						buffer << terminator if terminator
+					else
+						buffer << chunk
+					end
+				end
+				
+				raise EOFError, "Incomplete HTTY chunk!"
+			end
+		end
+	end
+end

data/lib/protocol/htty/stream.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "io/stream"
+
+module Protocol
+	module HTTY
+		# Transport an opaque byte stream over HTTY chunks.
+		class Stream
+			# Since base64 encoding adds 33% overhead, we can fit 3KB of binary data into a single HTTY chunk without exceeding the typical MTU of 4KB:
+			PACKET_SIZE = 1024*3
+			
+			# Create a stream on top of HTTY framed input and output.
+			# @parameter input [IO | IO::Stream] The source of framed HTTY chunks.
+			# @parameter output [IO | IO::Stream | Nil] The sink for framed HTTY chunks.
+			# @parameter packet_size [Integer] The maximum payload size for each chunk.
+			def initialize(input, output = input, packet_size: PACKET_SIZE)
+				@framer = Framer.new(::IO::Stream(input), ::IO::Stream(output))
+				@packet_size = packet_size
+				@buffer = +"".b
+				@local_closed = false
+				@remote_closed = false
+			end
+			
+			attr :framer
+			
+			# Return the writable IO object used by the underlying framer.
+			# @returns [IO | IO::Stream] The output side of the framed transport.
+			def io
+				@framer.output
+			end
+			
+			# Read application bytes from the HTTY transport.
+			# @parameter length [Integer | Nil] The exact number of bytes to read, or `nil` for all buffered bytes.
+			# @returns [String | Nil] The requested bytes, an empty binary string for `0`, or `nil` if more data is required or the remote side is closed.
+			def read(length = nil)
+				return +"".b if length == 0
+				
+				fill(length)
+				
+				return nil if @buffer.empty? && @remote_closed
+				return nil if @buffer.empty?
+				return nil if length && @buffer.bytesize < length && !@remote_closed
+				
+				if length
+					return @buffer.slice!(0, length)
+				else
+					return @buffer.slice!(0, @buffer.bytesize)
+				end
+			end
+			
+			# Write application bytes as one or more HTTY chunks.
+			# @parameter data [String | Array(Integer)] The opaque bytes to send.
+			# @returns [self]
+			# @raises [IOError] If the local side of the transport is closed.
+			def write(data)
+				raise IOError, "HTTY stream is closed for writing!" if @local_closed
+				
+				data = data.to_s.b
+				
+				until data.empty?
+					chunk = data.byteslice(0, @packet_size)
+					@framer.write_chunk(chunk)
+					data = data.byteslice(chunk.bytesize..)
+				end
+				
+				@framer.flush
+				
+				return self
+			end
+			
+			# Flush any buffered output through the underlying framer.
+			# @returns [void]
+			def flush
+				@framer.flush
+			end
+			
+			# Close the local write side of this stream abstraction.
+			# HTTY does not define a close packet, and closing this object does not close the underlying terminal IO.
+			# @returns [void]
+			def close
+				unless @local_closed
+					@local_closed = true
+					@framer.flush
+				end
+			end
+			
+			# Check whether the local side of the transport is closed.
+			# @returns [bool] True if local writes have been closed.
+			def closed?
+				@local_closed
+			end
+			
+			# Check whether the remote side may still provide more data.
+			# @returns [bool] True if the remote side has not sent or implied a close.
+			def readable?
+				!@remote_closed
+			end
+			
+			private
+			
+			def fill(length)
+				while needs_more_data?(length)
+					chunk = @framer.read_chunk
+					
+					unless chunk
+						@remote_closed = true
+						break
+					end
+					@buffer << chunk
+				end
+			end
+			
+			def needs_more_data?(length)
+				return false if @remote_closed
+				return @buffer.empty? unless length
+				
+				@buffer.bytesize < length
+			end
+		end
+	end
+end

data/lib/protocol/htty/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Protocol
+	module HTTY
+		VERSION = "0.1.0"
+	end
+end

data/lib/protocol/htty.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "htty/version"
+require_relative "htty/error"
+require_relative "htty/framer"
+require_relative "htty/stream"

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, by Samuel Williams.  
+
+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.

data/readme.md

@@ -0,0 +1,73 @@
+# Protocol::HTTY
+
+`protocol-htty` defines a small, terminal-safe framing layer for carrying an opaque byte stream over TTY side channels.
+
+[![Development Status](https://github.com/socketry/protocol-htty/workflows/Test/badge.svg)](https://github.com/socketry/protocol-htty/actions?workflow=Test)
+
+## Motivation
+
+Traditional terminal user interfaces are useful, but they are also a poor fit for many modern interactions. They are constrained by character-cell rendering, limited layout semantics, awkward input models, and a presentation layer that was never designed for rich documents or structured application state.
+
+In practice, this means TUIs often force applications into compromises: text-heavy layouts, ad-hoc protocols, and bespoke escape-sequence behavior that is hard to standardise across runtimes and terminals.
+
+HTTY exists to keep the portability and deployment advantages of terminal workflows while avoiding the need to build an entire application model out of terminal control codes. Instead of asking the terminal stream itself to represent higher-level UI state, HTTY provides a small framing layer that can carry a normal plaintext HTTP/2 connection alongside terminal traffic, enabling applications to attach browser surfaces to a normal terminal session over HTTY.
+
+## Design
+
+HTTY does not model application requests, regions, or resources. It transports the two directions of a single plaintext HTTP/2 (`h2c`) connection over terminal-safe chunks without introducing a second session protocol.
+
+Each chunk is encoded as a DCS sequence:
+
+``` text
+ESC P HTTY;1;BASE64_CHUNK ESC \
+```
+
+The framing layer intentionally stays small so it can be reimplemented in other runtimes.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/protocol-htty/) for more details.
+
+  - [Getting Started](https://socketry.github.io/protocol-htty/guides/getting-started/index) - This guide explains how to get started with `protocol-htty` for terminal-safe HTTP/2 byte stream transport.
+
+  - [HTTY Specification](https://socketry.github.io/protocol-htty/guides/specification/index) - This document specifies HTTY as a terminal-safe framing layer for carrying a plaintext HTTP/2 (`h2c`) byte stream over terminal side channels.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/protocol-htty/releases/index) for all releases.
+
+### v0.1.0
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Running Tests
+
+To run the test suite:
+
+``` shell
+bundle exec sus
+```
+
+### Making Releases
+
+To make a new release:
+
+``` shell
+bundle exec bake gem:release:patch # or minor or major
+```
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,3 @@
+# Releases
+
+## v0.1.0

data/test/protocol/htty/framer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "stringio"
+require "protocol/http2/framer"
+require "protocol/htty"
+
+describe Protocol::HTTY::Framer do
+	let(:input) {StringIO.new}
+	let(:output) {StringIO.new}
+	let(:framer) {subject.new(input, output)}
+	
+	it "writes terminal-safe chunks" do
+		framer.write_chunk(Protocol::HTTP2::CONNECTION_PREFACE)
+		
+		expect(output.string).to be == "\ePHTTY;1;UFJJICogSFRUUC8yLjANCg0KU00NCg0K\e\\"
+	end
+	
+	it "reads terminal-safe chunks" do
+		input.string = "hello\ePHTTY;1;UFJJICogSFRUUC8yLjANCg0KU00NCg0K\e\\world"
+		input.rewind
+		
+		chunk = framer.read_chunk
+		
+		expect(chunk).to be == Protocol::HTTP2::CONNECTION_PREFACE
+	end
+	
+	it "raises on malformed chunks" do
+		input.string = "\ePHTTY;1\e\\"
+		input.rewind
+		
+		expect do
+			framer.read_chunk
+		end.to raise_exception(Protocol::HTTY::ProtocolError)
+	end
+	
+	it "raises on incomplete chunks" do
+		input.string = "\ePHTTY;1;QUJD"
+		input.rewind
+		
+		expect do
+			framer.read_chunk
+		end.to raise_exception(EOFError)
+	end
+	
+	it "closes distinct input and output streams" do
+		framer.close
+		
+		expect(input).to be(:closed?)
+		expect(output).to be(:closed?)
+		expect(framer).to be(:closed?)
+	end
+	
+	it "handles escaped bytes inside an invalid chunk payload" do
+		input.string = "\ePHTTY;1;QUJD\eXRA==\e\\"
+		input.rewind
+		
+		expect do
+			framer.read_chunk
+		end.to raise_exception(ArgumentError)
+	end
+end

data/test/protocol/htty/stream.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "stringio"
+require "tempfile"
+require "protocol/http2/framer"
+require "protocol/htty"
+
+describe Protocol::HTTY::Stream do
+	let(:writer) {StringIO.new}
+	let(:stream) {subject.new(StringIO.new, writer, packet_size: 8)}
+	
+	it "chunks opaque payload into HTTY chunks" do
+		stream.write(Protocol::HTTP2::CONNECTION_PREFACE)
+		
+		expect(writer.string.scan(/\ePHTTY;1;/).size).to be > 1
+	end
+	
+	it "reads back opaque bytes from HTTY chunks" do
+		stream.write(Protocol::HTTP2::CONNECTION_PREFACE)
+		writer.rewind
+		
+		reader = subject.new(writer, StringIO.new)
+		
+		expect(reader.read(Protocol::HTTP2::CONNECTION_PREFACE.bytesize)).to be == Protocol::HTTP2::CONNECTION_PREFACE
+		reader.close
+		expect(reader.read).to be_nil
+	end
+	
+	it "returns all buffered bytes when length is omitted" do
+		stream.write("hello")
+		stream.close
+		writer.rewind
+		
+		reader = subject.new(writer, StringIO.new)
+		
+		expect(reader.read).to be == "hello"
+		expect(reader.read).to be_nil
+	end
+	
+	it "exposes the underlying output stream" do
+		expect(stream.io).to be(:is_a?, ::IO::Stream::Buffered)
+	end
+	
+	it "flushes through the underlying framer" do
+		stream.write("hello")
+		
+		expect do
+			stream.flush
+		end.not.to raise_exception
+	end
+	
+	it "reports when the local side is closed" do
+		expect(stream).not.to be(:closed?)
+		
+		stream.close
+		
+		expect(stream).to be(:closed?)
+	end
+	
+	it "does not close the underlying output stream" do
+		stream.close
+		
+		expect(writer).not.to be(:closed?)
+	end
+	
+	it "reports when the remote side is still readable" do
+		expect(stream).to be(:readable?)
+	end
+	
+	it "rejects writes after the local side is closed" do
+		stream.close
+		
+		expect do
+			stream.write("hello")
+		end.to raise_exception(IOError)
+	end
+	
+	it "wraps raw IO handles using IO::Stream" do
+		Tempfile.create("protocol-htty") do |file|
+			io_stream = subject.new(file, file).io
+			
+			expect(io_stream).to be(:is_a?, ::IO::Stream::Buffered)
+			io_stream.close
+		end
+	end
+	
+	it "does not close wrapped raw IO handles when closed" do
+		Tempfile.create("protocol-htty") do |file|
+			wrapped_stream = subject.new(file, file)
+			
+			wrapped_stream.close
+			
+			expect(file).not.to be(:closed?)
+			file.close
+		end
+	end
+end

data/test/protocol/htty.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "protocol/htty/version"
+
+describe Protocol::HTTY do
+	it "has a version number" do
+		expect(Protocol::HTTY::VERSION).to be =~ /\d+\.\d+\.\d+/
+	end
+end

data.tar.gz.sig

@@ -0,0 +1,3 @@
+9�1H��t���e&�a�A\�����~�d{i����N��`�޿�
��i�0�T���ې%��
+`��/���З�!��h��2_���VN�PUϳ�q�r�.D�Mn���&���a�@�����Қ4�ovK�Sn����0�Ͼl�-�;W�
s�è�mI �����w�����.��0��ȷ��8�(^t[)�	k����|�J��(ƻ�g'ۉIk�&�Hy��T�mk�:"�[�
+_��u����<���T:�C�ga��jW����rP-My��f����O

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: protocol-htty
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: protocol-http2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: io-stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/protocol/htty.rb
+- lib/protocol/htty/error.rb
+- lib/protocol/htty/framer.rb
+- lib/protocol/htty/stream.rb
+- lib/protocol/htty/version.rb
+- license.md
+- readme.md
+- releases.md
+- test/protocol/htty.rb
+- test/protocol/htty/framer.rb
+- test/protocol/htty/stream.rb
+homepage: https://github.com/socketry/protocol-htty
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/protocol-htty/
+  source_code_uri: https://github.com/socketry/protocol-htty.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A terminal-safe transport for carrying opaque HTTP/2 bytes over TTY side
+  channels.
+test_files: []