baseh 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d62aeddba45748e9bf4c1d40935e09d8f18bbe032f7d97320e4f78b7598d33ed
+  data.tar.gz: 29a24ad4f909e9832ae668c1d0d1765d94884c4533b7fa1a98bfbc72d86e2347
+SHA512:
+  metadata.gz: e8b586ae0ac27e61037a413032bfcff338140ffb0a9fd0f99bebe3377657244d326e8a03e53c185c58713408d0968df71a8bfaf0ed908a80faea6c29b805de98
+  data.tar.gz: a0a5578f2f70d553415396b47e28183edab7eab72e780fdd76834863a79ef8e0b3a99b7a7fb1fa55b8310ad38c7fcde2c82cc6a62cf87eb3b57d9f401a0ce97e

data/README.md

@@ -0,0 +1,123 @@
+# baseh
+
+Ruby port of the baseH (Human Reference Code) codec. Encodes integer IDs as
+fixed-length, checksummed, human-friendly reference codes with an opt-in
+reversible feistel-v1 permutation and profanity safety. The normative spec
+is `spec/IMPLEMENTATION_CODEC.md` in the monorepo root.
+
+## Install
+
+```ruby
+# Gemfile
+gem "baseh", path: "ruby"
+```
+
+or
+
+```sh
+gem build baseh.gemspec
+gem install ./baseh-1.0.0.gem
+```
+
+Zero runtime dependencies. Only `openssl` and `json` from the standard
+library are used.
+
+## Frozen tiers
+
+Four frozen tiers ship with the gem, built from the full alphanumeric set
+with cumulative visual and spoken strips. All four encode 6 body symbols,
+are case-insensitive and run the default profanity blocklist.
+
+| Tier | Helper | Body symbols | Checksum | Format | Capacity |
+| ---- | ------ | ------------ | -------- | ------ | -------- |
+| Minimum | `Baseh.baseh_minimum_v1` | 36 | none | `XXX-XXX` | 2,176,782,336 |
+| Light | `Baseh.baseh_light_v1` | 31 | 1 | plain | 887,503,681 |
+| Medium | `Baseh.baseh_medium_v1` | 28 | 1 | plain | 481,890,304 |
+| Heavy | `Baseh.baseh_heavy_v1` | 26 | 1 | plain | 308,915,776 |
+
+Medium is the default. Minimum keeps the full alphabet and uses a hyphen
+delimiter; the rest have no separator. Each tier keeps the typed O/I/L
+aliases where possible and adds spoken-confusion aliases for the stripped
+symbols.
+
+Every helper returns a freshly built mutable profile hash on each call, so
+callers can load a default and modify it before constructing a codec.
+
+## Usage
+
+```ruby
+require "baseh"
+
+codec = Baseh::Baseh.new(Baseh.baseh_medium_v1)
+
+code = codec.encode(id: 123_456)           # => raw fixed-width code
+
+result = codec.decode(code)
+result.id                                  # => 123456
+result.canonical_code                      # => canonical form
+result.corrected                           # => true when input needed correction
+
+codec.capacity                             # => 481890304
+
+check = codec.validate("0000000")
+check.valid                                # => false
+check.reason                               # => "INVALID_CHECKSUM"
+
+# Spoken-confusion correction
+result = codec.decode("TB14QDF", try_correction: true, confusion_profile: :light)
+```
+
+## Permutation (opt-in)
+
+The `-p` variants opt a tier into the reversible feistel-v1 permutation.
+`key_bytes:` is required; keep the key in a secret manager and never change
+it for a live profile:
+
+```ruby
+profile = Baseh.baseh_medium_p_v1(
+  key_bytes: File.binread("path/to/key.bin"),
+  key_id: "prod-01"                        # optional, defaults to "default"
+)
+codec = Baseh::Baseh.new(profile)
+```
+
+`rounds:` is also accepted (default 8). The `-p` profile is identical to
+its plain tier apart from the permutation; its profile id gains a `-p`
+segment, for example `baseh-medium-p-v1`.
+
+## Profanity safety (spec 18)
+
+Profiles accept an optional `profanity:` object:
+
+```ruby
+# mode "no-vowels": vowels are stripped from both alphabets at construction
+# and can never appear in issued codes.
+profanity: { mode: "no-vowels" }
+
+# mode "blocklist": encode raises BLOCKED_CODE when the raw code contains an
+# entry. words replaces the default list, extra_words appends to it.
+profanity: { mode: "blocklist", words: ["ZZZZ"], extra_words: ["QQQQ"] }
+```
+
+The frozen tiers run the default blocklist out of the box.
+
+All failures raise `Baseh::BasehError` with a `#code` from the spec:
+`INVALID_PROFILE`, `OUT_OF_RANGE`, `PERMUTATION_FAILURE`, `INVALID_LENGTH`,
+`INVALID_CHARACTER`, `INVALID_CHECKSUM`, `AMBIGUOUS_INPUT`,
+`TOO_MANY_CANDIDATES` and `BLOCKED_CODE`. `validate` never raises on user
+input.
+
+Ruby `Integer` is arbitrary precision, so every capacity and ID operation is
+exact at any size.
+
+## Tests
+
+```sh
+rake            # or: ruby -Ilib -Itest -e 'Dir["test/test_*.rb"].each { |f| require "./#{f}" }'
+SLOW=1 rake     # includes the 10k sequential round trip and bijection checks
+```
+
+The vector tests load `../vectors/vectors.json` and
+`../vectors/feistel-vectors.json` from the monorepo root and assert every
+entry. Running the suite from a different directory layout requires those
+files at that relative path.

data/lib/baseh/baseh.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Codec engine, spec sections 8 through 12 and 18. Instances wrap one
+  # validated profile and are stateless and safe to share across threads.
+  class Baseh
+    # Built-in spoken-confusion candidate maps, spec section 3.3.
+    # Pairs apply to body symbols only, never to checksum characters.
+    CONFUSION_MAPS = {
+      light: {
+        "B" => %w[D], "D" => %w[B], "P" => %w[T], "T" => %w[P]
+      }.freeze,
+      medium: {
+        "B" => %w[D], "D" => %w[B], "P" => %w[T], "T" => %w[P],
+        "M" => %w[N], "N" => %w[M], "V" => %w[W], "W" => %w[V]
+      }.freeze,
+      heavy: {
+        "B" => %w[D], "D" => %w[B], "P" => %w[T], "T" => %w[P],
+        "M" => %w[N], "N" => %w[M], "V" => %w[W], "W" => %w[V],
+        "F" => %w[S], "S" => %w[F], "C" => %w[G], "G" => %w[C]
+      }.freeze
+    }.freeze
+
+    MAX_CANDIDATES = 64
+
+    ASCII_WS = /\A[\t\n\v\f\r ]+|[\t\n\v\f\r ]+\z/.freeze
+
+    # Result of a successful decode.
+    DecodeResult = Struct.new(:id, :canonical_code, :corrected, keyword_init: true)
+
+    # Result of validate, which never raises on user input.
+    ValidateResult = Struct.new(:valid, :canonical_code, :reason, keyword_init: true)
+
+    attr_reader :profile
+
+    # @param profile [Hash] profile definition per spec 2.1 (symbol keys)
+    # @raise [BasehError] INVALID_PROFILE when the profile violates spec 2.2
+    def initialize(profile)
+      @profile = Profile.prepare(profile)
+      @body_index = BaseN.alphabet_index(@profile.body_alphabet)
+    end
+
+    # Spec section 4. Capacity is an arbitrary-precision Integer.
+    def capacity
+      @profile.capacity
+    end
+
+    # Spec section 8, with the spec 18.2 blocklist scan over the raw code.
+    #
+    # @param id [Integer] 0 <= id < capacity
+    # @return [String] canonical code (grouped only when a separator is set)
+    # @raise [BasehError] OUT_OF_RANGE, PERMUTATION_FAILURE, BLOCKED_CODE
+    def encode(id:)
+      unless id.is_a?(Integer)
+        raise TypeError, "id must be an Integer"
+      end
+      if id.negative? || id >= @profile.capacity
+        raise BasehError.new("OUT_OF_RANGE", "ID #{id} is outside the profile capacity")
+      end
+
+      value = id
+      perm = @profile.permutation
+      if perm[:enabled]
+        value = Feistel.permute(
+          value, @profile.capacity,
+          profile_id: @profile.profile_id,
+          key_bytes: perm[:key_bytes],
+          rounds: perm[:rounds]
+        )
+      end
+
+      body = BaseN.encode_base_n(value, @profile.body_alphabet, @profile.body_length)
+      checksum = Checksum.calculate_checksum(@profile, body, @body_index)
+      raw = body + checksum
+      check_blocklist!(raw)
+      format_raw(raw)
+    end
+
+    # Spec section 9.
+    #
+    # @param input [String]
+    # @param accept_spaces [Boolean] strip ASCII spaces before validation
+    # @param try_correction [Boolean] attempt single-symbol spoken correction
+    # @param confusion_profile [:none, :light, :medium, :heavy]
+    # @param max_corrections [0, 1]
+    # @return [DecodeResult]
+    # @raise [BasehError] INVALID_LENGTH, INVALID_CHARACTER, INVALID_CHECKSUM,
+    #   AMBIGUOUS_INPUT, TOO_MANY_CANDIDATES, PERMUTATION_FAILURE, BLOCKED_CODE
+    def decode(input, accept_spaces: false, try_correction: false,
+               confusion_profile: :none, max_corrections: 1)
+      unless input.is_a?(String)
+        raise BasehError.new("INVALID_CHARACTER", "Input must be a string")
+      end
+
+      raw = normalize(input, accept_spaces)
+      body = raw.slice(0, @profile.body_length)
+      supplied_checksum = raw.slice(@profile.body_length..) || ""
+
+      # normalize validates every symbol against the union of the body and
+      # checksum alphabets (spec 3.1 step 6). A checksum-only symbol in a
+      # body slot is INVALID_CHARACTER before any checksum work. A body-only
+      # symbol in the checksum slot survives to the checksum comparison and
+      # fails as INVALID_CHECKSUM; the frozen error vectors require that
+      # exact outcome.
+      body.each_char do |ch|
+        next if @body_index.key?(ch)
+
+        raise BasehError.new(
+          "INVALID_CHARACTER",
+          "Symbol #{ch.inspect} cannot appear in the body"
+        )
+      end
+
+      if Checksum.calculate_checksum(@profile, body, @body_index) != supplied_checksum
+        unless try_correction && max_corrections != 0
+          raise BasehError.new(
+            "INVALID_CHECKSUM",
+            "The reference code did not pass validation"
+          )
+        end
+        # Spec 10: replacements that are not body alphabet symbols are
+        # dropped before candidate generation. A suggested symbol the alphabet
+        # cannot contain (say a spoken drop on a stripped-alphabet profile)
+        # could never validate; generating it anyway would throw
+        # INVALID_CHARACTER from the checksum step instead of reporting an
+        # honest INVALID_CHECKSUM.
+        map = confusion_map(confusion_profile)
+        filtered = {}
+        map.each do |source, replacements|
+          kept = replacements.select { |r| @body_index.key?(r) }
+          filtered[source] = kept unless kept.empty?
+        end
+        valid = {}
+        generate_candidates(body, filtered, max_corrections).each do |candidate|
+          if Checksum.calculate_checksum(@profile, candidate, @body_index) == supplied_checksum
+            valid[candidate] = true
+          end
+        end
+        case valid.size
+        when 0
+          raise BasehError.new(
+            "INVALID_CHECKSUM",
+            "The reference code did not pass validation"
+          )
+        when 1
+          body = valid.keys.first
+        else
+          raise BasehError.new(
+            "AMBIGUOUS_INPUT",
+            "The reference code matches more than one record",
+            safe_for_customer: false
+          )
+        end
+      end
+
+      value = BaseN.decode_base_n(body, @profile.body_alphabet, @body_index)
+      perm = @profile.permutation
+      if perm[:enabled]
+        value = Feistel.inverse_permute(
+          value, @profile.capacity,
+          profile_id: @profile.profile_id,
+          key_bytes: perm[:key_bytes],
+          rounds: perm[:rounds]
+        )
+      end
+
+      # encode re-scans the blocklist, so decode raises BLOCKED_CODE when
+      # reconstructing a canonical form that could never have been issued
+      # (spec 18.2).
+      canonical_code = encode(id: value)
+      corrected = raw != canonical_raw(canonical_code)
+      DecodeResult.new(id: value, canonical_code: canonical_code, corrected: corrected)
+    end
+
+    # Spec section 12.4. Never raises on user input; returns a ValidateResult
+    # with the failing error code in #reason instead.
+    def validate(input, **options)
+      result = decode(input, **options)
+      ValidateResult.new(valid: true, canonical_code: result.canonical_code)
+    rescue BasehError => e
+      ValidateResult.new(valid: false, reason: e.code)
+    end
+
+    # Spec 3.1 normalization, steps 1-9, with the spec 3.4 re-pad. Returns
+    # the raw unformatted string.
+    def normalize(input, accept_spaces)
+      s = input.gsub(ASCII_WS, "")
+      s = s.delete(@profile.separator) unless @profile.separator.empty?
+      s = s.delete(" ") if accept_spaces
+      s = s.upcase unless @profile.case_sensitive
+      s = s.each_char.map { |ch| @profile.aliases.fetch(ch, ch) }.join
+
+      s.each_char do |ch|
+        next if @body_index.key?(ch) || @profile.checksum_alphabet.include?(ch)
+
+        raise BasehError.new(
+          "INVALID_CHARACTER",
+          "Symbol #{ch.inspect} is not accepted"
+        )
+      end
+
+      expected = @profile.body_length + @profile.checksum_length
+      # Spec 3.4: a code that lost leading zero body symbols is re-padded
+      # with the body zero symbol. The checksum symbols always remain, so
+      # the split point is unambiguous. A fully stripped no-checksum code
+      # would be empty and stays a length error.
+      if s.length < expected && s.length >= [@profile.checksum_length, 1].max
+        s = @profile.body_alphabet[0] * (expected - s.length) + s
+      end
+      if s.length != expected
+        raise BasehError.new(
+          "INVALID_LENGTH",
+          "Expected #{expected} symbols, got #{s.length}"
+        )
+      end
+      s
+    end
+
+    # Spec section 10. Substitution-only generation, capped and deduplicated.
+    def generate_candidates(body, confusion_map, max_edits = 1)
+      return [] if max_edits.zero?
+
+      results = {}
+      chars = body.chars
+      chars.each_index do |pos|
+        Array(confusion_map[chars[pos]]).each do |replacement|
+          candidate = chars.dup
+          candidate[pos] = replacement
+          results[candidate.join] = true
+          next unless results.size > MAX_CANDIDATES
+
+          raise BasehError.new(
+            "TOO_MANY_CANDIDATES",
+            "Candidate generation exceeded 64 entries",
+            safe_for_customer: false
+          )
+        end
+      end
+      results.keys
+    end
+
+    private
+
+    # Spec 18.2: case-insensitive substring scan over the raw unformatted
+    # code. BLOCKED_CODE is an issuance decision, not an end-user condition.
+    def check_blocklist!(raw)
+      return if @profile.blocklist.empty?
+
+      upper = raw.upcase
+      @profile.blocklist.each do |word|
+        next unless upper.include?(word)
+
+        raise BasehError.new(
+          "BLOCKED_CODE",
+          "The generated reference contains a blocked substring",
+          safe_for_customer: false
+        )
+      end
+    end
+
+    def confusion_map(name)
+      case name
+      when :none, "none" then {}.freeze
+      when :light, "light" then CONFUSION_MAPS[:light]
+      when :medium, "medium" then CONFUSION_MAPS[:medium]
+      when :heavy, "heavy" then CONFUSION_MAPS[:heavy]
+      else
+        raise ArgumentError, "unknown confusion profile #{name.inspect}"
+      end
+    end
+
+    def format_raw(raw)
+      return raw if @profile.separator.empty?
+
+      parts = []
+      offset = 0
+      @profile.grouping.each do |size|
+        parts << raw.slice(offset, size)
+        offset += size
+      end
+      parts.join(@profile.separator)
+    end
+
+    def canonical_raw(canonical_code)
+      return canonical_code if @profile.separator.empty?
+
+      canonical_code.delete(@profile.separator)
+    end
+  end
+end

data/lib/baseh/basen.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Fixed-length base-N encoding, spec section 5. Most significant digit first.
+  module BaseN
+    module_function
+
+    # Spec 5.1. All arithmetic stays in Integer (arbitrary precision).
+    def encode_base_n(value, alphabet, length)
+      base = alphabet.length
+      out = Array.new(length)
+      v = value
+      (length - 1).downto(0) do |pos|
+        digit = v % base
+        out[pos] = alphabet[digit]
+        v /= base
+      end
+      out.join
+    end
+
+    # Spec 5.2. Raises INVALID_CHARACTER for symbols outside the alphabet.
+    def decode_base_n(text, alphabet, index = nil)
+      index ||= alphabet_index(alphabet)
+      base = alphabet.length
+      value = 0
+      text.each_char do |ch|
+        digit = index[ch]
+        if digit.nil?
+          raise BasehError.new(
+            "INVALID_CHARACTER",
+            "Symbol #{ch.inspect} is not in the alphabet"
+          )
+        end
+        value = value * base + digit
+      end
+      value
+    end
+
+    def alphabet_index(alphabet)
+      alphabet.each_char.each_with_index.to_h
+    end
+  end
+end

data/lib/baseh/checksum.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Version 1 checksum, spec section 6.2. Rolling polynomial over symbol
+  # values, then modulus conversion into the checksum alphabet.
+  module Checksum
+    INITIAL_STATE = 17
+    MULTIPLIER = 37
+
+    module_function
+
+    # Returns the checksum value in [0, modulus).
+    def checksum_value(prepared, body, body_index = nil)
+      body_index ||= BaseN.alphabet_index(prepared.body_alphabet)
+      modulus = prepared.checksum_modulus
+
+      state = INITIAL_STATE
+      prepared.profile_id.each_byte do |byte|
+        state = (state * MULTIPLIER + byte + 1) % modulus
+      end
+      state = (state * MULTIPLIER) % modulus
+      body.each_char.each_with_index do |ch, pos|
+        symbol_value = body_index[ch]
+        unless symbol_value
+          raise BasehError.new(
+            "INVALID_CHARACTER",
+            "Body symbol #{ch.inspect} is not in the body alphabet"
+          )
+        end
+        state = (state * MULTIPLIER + symbol_value + pos + 1) % modulus
+      end
+      state
+    end
+
+    # Expected checksum string for a normalized body.
+    def calculate_checksum(prepared, body, body_index = nil)
+      return "" if prepared.checksum_length.zero?
+
+      body_index ||= BaseN.alphabet_index(prepared.body_alphabet)
+      value = checksum_value(prepared, body, body_index)
+      BaseN.encode_base_n(value, prepared.checksum_alphabet, prepared.checksum_length)
+    end
+  end
+end

data/lib/baseh/errors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Error raised by every baseH failure path. #code is one of the spec error
+  # codes (spec sections 12, 13 and 18).
+  class BasehError < StandardError
+    CODES = %w[
+      INVALID_PROFILE
+      OUT_OF_RANGE
+      PERMUTATION_FAILURE
+      INVALID_LENGTH
+      INVALID_CHARACTER
+      INVALID_CHECKSUM
+      AMBIGUOUS_INPUT
+      TOO_MANY_CANDIDATES
+      BLOCKED_CODE
+    ].freeze
+
+    # @return [String] one of CODES
+    attr_reader :code
+
+    # @return [Boolean] true when the message may be shown to an end user
+    attr_reader :safe_for_customer
+
+    def initialize(code, message, safe_for_customer: true)
+      raise ArgumentError, "unknown baseH error code #{code}" unless CODES.include?(code)
+
+      super(message)
+      @code = code
+      @safe_for_customer = safe_for_customer
+    end
+  end
+end

data/lib/baseh/feistel.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Baseh
+  # Balanced Feistel network with cycle walking, spec section 7.3.
+  # HMAC-SHA-256 comes from OpenSSL; HMAC and SHA-256 are never implemented
+  # by hand (section 7.5).
+  module Feistel
+    TAG = "BASEH-FEISTEL-V1".b
+    MAX_WALKS = 1000
+
+    module_function
+
+    # ceil(log2(capacity)); capacity >= 2 so bits >= 1.
+    def bit_length(capacity)
+      (capacity - 1).bit_length
+    end
+
+    # Low n bits of the HMAC-SHA-256 digest: first ceil(n / 8) bytes read as
+    # a big-endian integer and masked with 2^n - 1.
+    def low_bits(digest, n)
+      byte_count = (n + 7) / 8
+      v = digest.byteslice(0, byte_count).unpack("C*").inject(0) { |acc, b| (acc << 8) | b }
+      v & ((1 << n) - 1)
+    end
+
+    def to_be(value, byte_count)
+      return "".b if byte_count.zero?
+
+      bytes = Array.new(byte_count)
+      v = value
+      (byte_count - 1).downto(0) do |i|
+        bytes[i] = v & 0xff
+        v >>= 8
+      end
+      bytes.pack("C*")
+    end
+
+    # Normative round message, spec 7.3 step 4.
+    def round_message(profile_id, round, right, wr)
+      "".b
+        .concat(TAG)
+        .concat(0.chr(Encoding::BINARY))
+        .concat(profile_id)
+        .concat(0.chr(Encoding::BINARY))
+        .concat(round.chr(Encoding::BINARY))
+        .concat(to_be(right, (wr + 7) / 8))
+    end
+
+    def hmac(key_bytes, message)
+      OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), key_bytes, message)
+    end
+
+    def run_rounds(left, right, profile_id, key_bytes, rounds, w0, w1)
+      rounds.times do |i|
+        even = i.even?
+        wr = even ? w1 : w0
+        wl = even ? w0 : w1
+        f = low_bits(hmac(key_bytes, round_message(profile_id, i, right, wr)), wl)
+        new_left = right
+        new_right = left ^ f
+        left = new_left
+        right = new_right
+      end
+      [left, right]
+    end
+
+    def run_inverse(left, right, profile_id, key_bytes, rounds, w0, w1)
+      (rounds - 1).downto(0) do |i|
+        even = i.even?
+        wr = even ? w1 : w0
+        wl = even ? w0 : w1
+        f = low_bits(hmac(key_bytes, round_message(profile_id, i, left, wr)), wl)
+        prev_right = left
+        prev_left = right ^ f
+        left = prev_left
+        right = prev_right
+      end
+      [left, right]
+    end
+
+    # Forward permutation with cycle walking.
+    def permute(value, capacity, profile_id:, key_bytes:, rounds:)
+      walk(value, capacity, profile_id, key_bytes, rounds) do |left, right, w0, w1|
+        run_rounds(left, right, profile_id, key_bytes, rounds, w0, w1)
+      end
+    end
+
+    # Inverse permutation with cycle walking.
+    def inverse_permute(value, capacity, profile_id:, key_bytes:, rounds:)
+      walk(value, capacity, profile_id, key_bytes, rounds) do |left, right, w0, w1|
+        run_inverse(left, right, profile_id, key_bytes, rounds, w0, w1)
+      end
+    end
+
+    def walk(value, capacity, profile_id, key_bytes, rounds)
+      bits = bit_length(capacity)
+      w1 = bits / 2
+      w0 = bits - w1
+      v = value
+      MAX_WALKS.times do
+        left = v >> w1
+        right = v & ((1 << w1) - 1)
+        out_left, out_right = yield(left, right, w0, w1)
+        combined = (out_left << w1) | out_right
+        return combined if combined < capacity
+
+        v = combined
+      end
+      raise BasehError.new(
+        "PERMUTATION_FAILURE",
+        "Feistel cycle walking exceeded 1000 iterations",
+        safe_for_customer: false
+      )
+    end
+  end
+end

data/lib/baseh/profanity.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Profanity safety, spec section 18. Profiles gain an optional
+  # profanity: { mode:, words:, extra_words: } object. It never changes
+  # decode behavior for issued codes and never changes capacity accounting.
+  module Profanity
+    # Spec 18.2 default list. Deliberately small; applications extend it.
+    DEFAULT_BLOCKLIST = %w[
+      CRAP TWAT SHAG DAMN FCK FUC SHT CNT TWT DCK AZZ BCH
+    ].freeze
+
+    MODES = %w[none no-vowels blocklist].freeze
+    WORD = /\A[A-Za-z]{2,32}\z/.freeze
+    VOWELS = "AEIOU"
+
+    module_function
+
+    # Spec 18.1: vowels removed for no-vowels mode, applied after case
+    # normalization.
+    def strip_vowels(alphabet_norm)
+      alphabet_norm.delete(VOWELS)
+    end
+
+    # Spec 18.2: replacement semantics, then augmentation, uppercased and
+    # deduplicated. Raises BasehError INVALID_PROFILE for malformed entries.
+    def effective_blocklist(profanity)
+      base = profanity[:words] || DEFAULT_BLOCKLIST
+      list = Array(base) + Array(profanity[:extra_words] || [])
+      out = []
+      list.each do |word|
+        unless word.is_a?(String) && WORD.match?(word)
+          raise BasehError.new(
+            "INVALID_PROFILE",
+            "Invalid baseH profile: blocklist entries must be 2 through 32 ASCII letters",
+            safe_for_customer: false
+          )
+        end
+        upper = word.upcase
+        out << upper unless out.include?(upper)
+      end
+      out
+    end
+  end
+end

data/lib/baseh/profile.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Profile validation and derived values, spec section 2.2.
+  # Validation runs once at construction, never per encode/decode.
+  #
+  # Profiles are plain hashes with symbol keys:
+  #   profile_id:, body_alphabet:, body_length:, checksum_alphabet:,
+  #   checksum_length:, case_sensitive:, separator:, grouping:, aliases:,
+  #   permutation: { enabled: true, algorithm: "feistel-v1", key_id:,
+  #                  key_bytes:, rounds: } or { enabled: false },
+  #   profanity: { mode: "none" | "no-vowels" | "blocklist",
+  #                words: [...], extra_words: [...] } (optional, spec 18)
+  module Profile
+    ASCII_ONLY = /\A[\x20-\x7e]*\z/.freeze
+
+    # Immutable, fully validated profile with pre-computed derived values.
+    class Prepared
+      attr_reader :profile_id, :body_alphabet, :body_length,
+                  :checksum_alphabet, :checksum_length, :case_sensitive,
+                  :separator, :grouping, :aliases, :permutation,
+                  :capacity, :checksum_modulus, :profanity_mode, :blocklist
+
+      def initialize(profile)
+        validate_type!(profile)
+        @profile_id = validate_profile_id!(profile[:profile_id])
+        @case_sensitive = profile[:case_sensitive] == true
+
+        @body_alphabet = validate_body_alphabet!(profile[:body_alphabet])
+        @body_length = validate_integer!(profile[:body_length], 1, 32, "bodyLength")
+        @checksum_length = validate_integer!(profile[:checksum_length], 0, 8, "checksumLength")
+        @checksum_alphabet = validate_checksum_alphabet!(
+          profile[:checksum_alphabet], @checksum_length
+        )
+
+        # Spec 18: validation happens before the vowel strip so malformed
+        # alphabets are reported as such, then no-vowels strips and
+        # re-validates the result.
+        @profanity_mode = validate_profanity_mode!(profile[:profanity])
+        if @profanity_mode == "no-vowels"
+          @body_alphabet = Profanity.strip_vowels(@body_alphabet)
+          @checksum_alphabet = Profanity.strip_vowels(@checksum_alphabet)
+          validate_stripped!(@body_alphabet, "body")
+          validate_stripped!(@checksum_alphabet, "checksum") if @checksum_length.positive?
+          @body_alphabet.freeze
+          @checksum_alphabet.freeze
+        end
+        @blocklist =
+          if @profanity_mode == "blocklist"
+            Profanity.effective_blocklist(profile[:profanity]).freeze
+          else
+            [].freeze
+          end
+
+        @separator = validate_separator!(
+          profile[:separator].to_s, @body_alphabet, @checksum_alphabet
+        )
+        @aliases = validate_aliases!(
+          profile[:aliases] || {}, @body_alphabet, @checksum_alphabet, @case_sensitive
+        )
+        @grouping = validate_grouping!(
+          profile[:grouping], @separator, @body_length, @checksum_length
+        )
+        @permutation = validate_permutation!(profile[:permutation] || { enabled: false })
+
+        @capacity = @body_alphabet.length**@body_length
+        @checksum_modulus = [@checksum_alphabet.length, 1].max**@checksum_length
+        freeze
+      end
+
+      private
+
+      def self.fail_profile!(reason)
+        raise BasehError.new("INVALID_PROFILE", "Invalid baseH profile: #{reason}", safe_for_customer: false)
+      end
+
+      def ascii_char?(ch)
+        ch.is_a?(String) && ch.length == 1 && ASCII_ONLY.match?(ch)
+      end
+
+      def validate_type!(profile)
+        self.class.fail_profile!("profile is required") unless profile.is_a?(Hash)
+      end
+
+      def validate_profile_id!(value)
+        unless value.is_a?(String) && !value.empty?
+          self.class.fail_profile!("profileId must be non-empty")
+        end
+        unless ASCII_ONLY.match?(value)
+          self.class.fail_profile!("profileId must be ASCII")
+        end
+        value
+      end
+
+      def validate_alphabet_symbols!(alphabet, label)
+        alphabet.each_char do |ch|
+          next if ascii_char?(ch)
+
+          self.class.fail_profile!("#{label} symbol is not single ASCII: #{ch.inspect}")
+        end
+      end
+
+      def norm_string(str)
+        @case_sensitive ? str : str.upcase
+      end
+
+      def validate_body_alphabet!(alphabet)
+        unless alphabet.is_a?(String) && alphabet.length >= 2
+          self.class.fail_profile!("bodyAlphabet needs at least two symbols")
+        end
+        validate_alphabet_symbols!(alphabet, "body alphabet")
+        normed = norm_string(alphabet)
+        unless normed.each_char.uniq.length == normed.length
+          self.class.fail_profile!("body alphabet symbols must be unique after case normalization")
+        end
+        normed.freeze
+      end
+
+      def validate_integer!(value, min, max, label)
+        unless value.is_a?(Integer) && value >= min && value <= max
+          self.class.fail_profile!("#{label} must be an integer from #{min} through #{max}")
+        end
+        value
+      end
+
+      def validate_checksum_alphabet!(alphabet, checksum_length)
+        alphabet = alphabet.to_s
+        if checksum_length.positive?
+          unless alphabet.is_a?(String) && alphabet.length >= 2
+            self.class.fail_profile!(
+              "checksumAlphabet needs at least two symbols when checksumLength is positive"
+            )
+          end
+          validate_alphabet_symbols!(alphabet, "checksum alphabet")
+        end
+        normed = norm_string(alphabet)
+        unless normed.each_char.uniq.length == normed.length
+          self.class.fail_profile!(
+            "checksum alphabet symbols must be unique after case normalization"
+          )
+        end
+        normed.freeze
+      end
+
+      def validate_profanity_mode!(profanity)
+        mode = "none"
+        if profanity.is_a?(Hash)
+          mode = profanity[:mode].to_s
+        elsif !profanity.nil?
+          self.class.fail_profile!("profanity must be a mapping")
+        end
+        unless Profanity::MODES.include?(mode)
+          self.class.fail_profile!("profanity mode must be none, no-vowels or blocklist")
+        end
+        mode
+      end
+
+      def validate_stripped!(alphabet, label)
+        return if alphabet.length >= 2
+
+        self.class.fail_profile!(
+          "no-vowels mode leaves the #{label} alphabet with fewer than two symbols"
+        )
+      end
+
+      def validate_separator!(separator, body_norm, checksum_norm)
+        separator.each_char do |ch|
+          next unless body_norm.include?(ch) || checksum_norm.include?(ch)
+
+          self.class.fail_profile!("separator must not occur in either alphabet")
+        end
+        separator.freeze
+      end
+
+      def validate_aliases!(aliases, body_norm, checksum_norm, case_sensitive)
+        unless aliases.is_a?(Hash)
+          self.class.fail_profile!("aliases must be a mapping")
+        end
+        canonical = (body_norm + checksum_norm).each_char.to_a.to_set
+        result = {}
+        aliases.each do |src, tgt|
+          src = src.to_s
+          tgt = tgt.to_s
+          unless ascii_char?(src)
+            self.class.fail_profile!("alias source is not single ASCII: #{src.inspect}")
+          end
+          unless ascii_char?(tgt)
+            self.class.fail_profile!("alias target is not single ASCII: #{tgt.inspect}")
+          end
+          s_norm = case_sensitive ? src : src.upcase
+          t_norm = case_sensitive ? tgt : tgt.upcase
+          if canonical.include?(s_norm)
+            self.class.fail_profile!("alias source #{src.inspect} is already a canonical symbol")
+          end
+          unless canonical.include?(t_norm)
+            self.class.fail_profile!("alias target #{tgt.inspect} is not a canonical symbol")
+          end
+          if result.key?(s_norm)
+            self.class.fail_profile!("duplicate alias source #{s_norm.inspect} after case normalization")
+          end
+          # Alias chains (and therefore cycles) are forbidden: a target may
+          # never itself be an alias source.
+          chain = result.key?(t_norm) ||
+                  aliases.keys.any? { |k| (case_sensitive ? k.to_s : k.to_s.upcase) == t_norm }
+          if chain
+            self.class.fail_profile!("alias chain forbidden: target #{t_norm} is also an alias source")
+          end
+          result[s_norm] = t_norm
+        end
+        result.freeze
+      end
+
+      def validate_grouping!(grouping, separator, body_length, checksum_length)
+        unless grouping.is_a?(Array)
+          self.class.fail_profile!("group sizes must be positive integers")
+        end
+        if separator.empty?
+          unless grouping.empty?
+            self.class.fail_profile!("grouping must be empty when separator is empty")
+          end
+        else
+          unless grouping.all? { |g| g.is_a?(Integer) && g >= 1 }
+            self.class.fail_profile!("group sizes must be positive integers")
+          end
+          unless grouping.sum == body_length + checksum_length
+            self.class.fail_profile!("group sizes must sum to bodyLength + checksumLength")
+          end
+        end
+        grouping.dup.freeze
+      end
+
+      def validate_permutation!(permutation)
+        unless permutation.is_a?(Hash)
+          self.class.fail_profile!("permutation must be a mapping")
+        end
+        return { enabled: false }.freeze unless permutation[:enabled] == true
+
+        if permutation[:algorithm] != "feistel-v1"
+          self.class.fail_profile!("unknown permutation algorithm")
+        end
+        key_id = permutation[:key_id]
+        unless key_id.is_a?(String) && !key_id.empty?
+          self.class.fail_profile!("permutation requires a keyId")
+        end
+        key_bytes = permutation[:key_bytes]
+        unless key_bytes.is_a?(String) && !key_bytes.empty?
+          self.class.fail_profile!("permutation requires key material")
+        end
+        rounds = permutation[:rounds]
+        unless rounds.is_a?(Integer) && rounds >= 4 && rounds <= 16 && rounds.even?
+          self.class.fail_profile!("Feistel rounds must be an even integer from 4 through 16")
+        end
+        {
+          enabled: true,
+          algorithm: "feistel-v1",
+          key_id: key_id.dup.freeze,
+          key_bytes: key_bytes.dup.force_encoding(Encoding::BINARY).freeze,
+          rounds: rounds
+        }.freeze
+      end
+    end
+
+    # Validates a profile hash and returns a Prepared instance.
+    # Raises BasehError with code INVALID_PROFILE on any violation.
+    def self.prepare(profile)
+      Prepared.new(profile)
+    end
+  end
+end

data/lib/baseh/profiles.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Frozen tier profiles. Each is built from the full alphanumeric set with
+  # cumulative visual and spoken strips; the spoken strips interact with the
+  # visual ones exactly as the web tools derive them, so the tool capacities
+  # match.
+  #
+  #   Minimum  36 symbols, no checksum      2,176,782,336 ids
+  #   Light    31 symbols, 1 checksum         887,503,681 ids
+  #   Medium   28 symbols, 1 checksum         481,890,304 ids (default)
+  #   Heavy    26 symbols, 1 checksum         308,915,776 ids
+  #
+  # All four keep the typed O/I/L aliases where possible and run the default
+  # profanity blocklist. Minimum also uses a hyphen delimiter; the rest have
+  # none. The _p variants are identical but with feistel-v1 permutation and
+  # require caller-supplied key material.
+  module Profiles
+    OIL_ALIASES = { "O" => "0", "I" => "1", "L" => "1" }.freeze
+
+    # Tier shapes shared by the plain and (-p) keyed helpers. The values are
+    # thawed on every build, so each helper returns a fresh mutable profile.
+    TIERS = {
+      minimum: {
+        profile_id: "baseh-minimum",
+        body_alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+        checksum_alphabet: "",
+        checksum_length: 0,
+        separator: "-",
+        grouping: [3, 3],
+        aliases: {}
+      },
+      light: {
+        profile_id: "baseh-light",
+        body_alphabet: "0123456789ABCEFGHJKMNPQRSUVWXYZ",
+        checksum_alphabet: "234679ACEFGHJKMNPQRUVWXY",
+        checksum_length: 1,
+        separator: "",
+        grouping: [],
+        aliases: { **OIL_ALIASES, "D" => "B", "T" => "P" }
+      },
+      medium: {
+        profile_id: "baseh-medium",
+        body_alphabet: "0123456789ACDEFGHJKMPQRUVXYZ",
+        checksum_alphabet: "234679ACDEFGHJKMPQRUVXY",
+        checksum_length: 1,
+        separator: "",
+        grouping: [],
+        # B and S are dropped for looking like 8 and 5; since they can never
+        # be issued, a typed B is always an 8 and a typed S always a 5.
+        aliases: { **OIL_ALIASES, "B" => "8", "S" => "5", "T" => "P",
+                   "N" => "M", "W" => "V" }
+      },
+      heavy: {
+        profile_id: "baseh-heavy",
+        body_alphabet: "0123456789ABCEFHJKMPQRVXYZ",
+        checksum_alphabet: "234679ACEFHJKMPQRUVXY",
+        checksum_length: 1,
+        separator: "",
+        grouping: [],
+        aliases: { **OIL_ALIASES, "D" => "B", "T" => "P", "N" => "M",
+                   "W" => "V", "S" => "F", "G" => "C" }
+      }
+    }.freeze
+
+    module_function
+
+    # Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX.
+    def baseh_minimum_v1
+      tier(:minimum, { enabled: false }, false)
+    end
+
+    # baseh-minimum with feistel-v1 permutation. key_bytes is required.
+    def baseh_minimum_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      tier(:minimum, keyed_permutation(key_bytes, key_id, rounds), true)
+    end
+
+    # Visual light plus spoken light, one checksum symbol.
+    def baseh_light_v1
+      tier(:light, { enabled: false }, false)
+    end
+
+    # baseh-light with feistel-v1 permutation. key_bytes is required.
+    def baseh_light_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      tier(:light, keyed_permutation(key_bytes, key_id, rounds), true)
+    end
+
+    # Visual medium plus spoken medium, one checksum symbol. The default.
+    def baseh_medium_v1
+      tier(:medium, { enabled: false }, false)
+    end
+
+    # baseh-medium with feistel-v1 permutation. key_bytes is required.
+    def baseh_medium_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      tier(:medium, keyed_permutation(key_bytes, key_id, rounds), true)
+    end
+
+    # Conservative alphabet plus spoken heavy, one checksum symbol.
+    def baseh_heavy_v1
+      tier(:heavy, { enabled: false }, false)
+    end
+
+    # baseh-heavy with feistel-v1 permutation. key_bytes is required.
+    def baseh_heavy_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      tier(:heavy, keyed_permutation(key_bytes, key_id, rounds), true)
+    end
+
+    # feistel-v1 permutation block for the keyed (p) helpers.
+    def keyed_permutation(key_bytes, key_id, rounds)
+      {
+        enabled: true,
+        algorithm: "feistel-v1",
+        key_id: key_id,
+        key_bytes: key_bytes,
+        rounds: rounds
+      }
+    end
+
+    # Builds a fresh mutable profile for a tier. Every call returns new
+    # strings, arrays and hashes so callers can load a default and modify it.
+    def tier(tier_name, permutation, p_suffix)
+      shape = TIERS.fetch(tier_name)
+      {
+        profile_id: shape[:profile_id] + (p_suffix ? "-p" : "") + "-v1",
+        body_alphabet: shape[:body_alphabet].dup,
+        body_length: 6,
+        checksum_alphabet: shape[:checksum_alphabet].dup,
+        checksum_length: shape[:checksum_length],
+        case_sensitive: false,
+        separator: shape[:separator].dup,
+        grouping: shape[:grouping].dup,
+        aliases: shape[:aliases].dup,
+        permutation: permutation,
+        profanity: { mode: "blocklist" }
+      }
+    end
+    private_class_method :keyed_permutation, :tier
+  end
+end

data/lib/baseh/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Baseh
+  VERSION = "1.1.0"
+end

data/lib/baseh/zero.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Baseh
+  # Zero-config pair over the frozen baseh-medium-v1 profile. No profile
+  # object, no key: just the two functions an application needs when it
+  # does not want to think about configuration.
+  #
+  #   Baseh.to_code(481890303)     -> "ZZZZZZV"
+  #   Baseh.from_code("ZZZZZZV")   -> 481890303
+  #
+  # to_code accepts an Integer or a decimal string of digits. from_code
+  # strips every whitespace character (edges and internal), accepts
+  # lowercase and the typed aliases (O, I, L) and returns the id as an
+  # Integer. Any invalid input raises BasehError, including the rare
+  # BLOCKED_CODE identifiers that spell a blocklisted word; no correction
+  # attempts are ever made.
+  module Zero
+    DECIMAL = /\A[0-9]+\z/.freeze
+    WHITESPACE = /\s+/.freeze
+
+    ZERO = Baseh.new(Profiles.baseh_medium_v1)
+
+    module_function
+
+    # Encode an identifier with the zero-config Medium profile.
+    #
+    # @param id [Integer, String] Integer or decimal string of digits
+    # @return [String] canonical code
+    # @raise [ArgumentError] when id is neither an Integer nor a decimal string
+    # @raise [BasehError] OUT_OF_RANGE, BLOCKED_CODE
+    def to_code(id)
+      value =
+        case id
+        when Integer then id
+        when String
+          if DECIMAL.match?(id)
+            id.to_i
+          else
+            raise ArgumentError,
+                  "to_code expects a non-negative Integer or a decimal string"
+          end
+        else
+          raise ArgumentError,
+                "to_code expects a non-negative Integer or a decimal string"
+        end
+      ZERO.encode(id: value)
+    end
+
+    # Decode a code from the zero-config Medium profile back to its id.
+    #
+    # @param code [String]
+    # @return [Integer]
+    # @raise [BasehError] INVALID_LENGTH, INVALID_CHARACTER, INVALID_CHECKSUM
+    def from_code(code)
+      input = code.is_a?(String) ? code.gsub(WHITESPACE, "") : code
+      ZERO.decode(input).id
+    end
+  end
+
+  class << self
+    # See Baseh::Zero.to_code.
+    def to_code(id)
+      Zero.to_code(id)
+    end
+
+    # See Baseh::Zero.from_code.
+    def from_code(code)
+      Zero.from_code(code)
+    end
+  end
+end

data/lib/baseh.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "baseh/version"
+require_relative "baseh/errors"
+require_relative "baseh/profanity"
+require_relative "baseh/profile"
+require_relative "baseh/basen"
+require_relative "baseh/checksum"
+require_relative "baseh/feistel"
+require_relative "baseh/profiles"
+require_relative "baseh/baseh"
+require_relative "baseh/zero"
+
+# baseH (Human Reference Code) codec. See spec/IMPLEMENTATION_CODEC.md in the
+# repository root for the normative specification.
+module Baseh
+  class << self
+    # Frozen tier baseh-minimum-v1: alphanumeric with no strips, no checksum,
+    # hyphen-delimited XXX-XXX. Permutation off.
+    def baseh_minimum_v1
+      Profiles.baseh_minimum_v1
+    end
+
+    # baseh-minimum with feistel-v1 permutation. key_bytes is required.
+    def baseh_minimum_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      Profiles.baseh_minimum_p_v1(key_bytes: key_bytes, key_id: key_id, rounds: rounds)
+    end
+
+    # Frozen tier baseh-light-v1: visual light plus spoken light, one
+    # checksum symbol. Permutation off.
+    def baseh_light_v1
+      Profiles.baseh_light_v1
+    end
+
+    # baseh-light with feistel-v1 permutation. key_bytes is required.
+    def baseh_light_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      Profiles.baseh_light_p_v1(key_bytes: key_bytes, key_id: key_id, rounds: rounds)
+    end
+
+    # Frozen tier baseh-medium-v1: visual medium plus spoken medium, one
+    # checksum symbol. The default. Permutation off.
+    def baseh_medium_v1
+      Profiles.baseh_medium_v1
+    end
+
+    # baseh-medium with feistel-v1 permutation. key_bytes is required.
+    def baseh_medium_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      Profiles.baseh_medium_p_v1(key_bytes: key_bytes, key_id: key_id, rounds: rounds)
+    end
+
+    # Frozen tier baseh-heavy-v1: conservative alphabet plus spoken heavy,
+    # one checksum symbol. Permutation off.
+    def baseh_heavy_v1
+      Profiles.baseh_heavy_v1
+    end
+
+    # baseh-heavy with feistel-v1 permutation. key_bytes is required.
+    def baseh_heavy_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      Profiles.baseh_heavy_p_v1(key_bytes: key_bytes, key_id: key_id, rounds: rounds)
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: baseh
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- cloudyventures
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 'Encodes and decodes human reference codes per the baseH codec specification:
+  fixed-length base-N bodies, rolling polynomial checksums, optional feistel-v1 permutation,
+  spoken-confusion correction and profanity safety.'
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/baseh.rb
+- lib/baseh/baseh.rb
+- lib/baseh/basen.rb
+- lib/baseh/checksum.rb
+- lib/baseh/errors.rb
+- lib/baseh/feistel.rb
+- lib/baseh/profanity.rb
+- lib/baseh/profile.rb
+- lib/baseh/profiles.rb
+- lib/baseh/version.rb
+- lib/baseh/zero.rb
+homepage:
+licenses:
+- AGPL-3.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: baseH (Human Reference Code) codec, Ruby port of the frozen spec
+test_files: []