baseh 1.1.0 → 2.0.2

data/lib/baseh/checksum.rb

@@ -10,9 +10,16 @@ module Baseh
     module_function
 
     # Returns the checksum value in [0, modulus).
-    def checksum_value(prepared, body, body_index = nil)
+    # Spec 22: expandable generations may pass a shorter effective checksum
+    # length; the modulus is then S^length instead of the profile default.
+    def checksum_value(prepared, body, body_index = nil, length = prepared.checksum_length)
       body_index ||= BaseN.alphabet_index(prepared.body_alphabet)
-      modulus = prepared.checksum_modulus
+      modulus =
+        if length == prepared.checksum_length
+          prepared.checksum_modulus
+        else
+          [prepared.checksum_alphabet.length, 1].max**length
+        end
 
       state = INITIAL_STATE
       prepared.profile_id.each_byte do |byte|
@@ -33,12 +40,12 @@ module Baseh
     end
 
     # Expected checksum string for a normalized body.
-    def calculate_checksum(prepared, body, body_index = nil)
-      return "" if prepared.checksum_length.zero?
+    def calculate_checksum(prepared, body, body_index = nil, length = prepared.checksum_length)
+      return "" if 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)
+      value = checksum_value(prepared, body, body_index, length)
+      BaseN.encode_base_n(value, prepared.checksum_alphabet, length)
     end
   end
 end

data/lib/baseh/feistel.rb

@@ -37,13 +37,17 @@ module Baseh
       bytes.pack("C*")
     end
 
-    # Normative round message, spec 7.3 step 4.
-    def round_message(profile_id, round, right, wr)
+    # Normative round message, spec 7.3 step 4. In expandable mode the
+    # generation's total code length L is mixed in as ASCII decimal plus a
+    # 0x00 terminator after the profileId field (spec 7.3/19.4); fixed-mode
+    # messages stay byte-for-byte unchanged.
+    def round_message(profile_id, round, right, wr, length = nil)
       "".b
         .concat(TAG)
         .concat(0.chr(Encoding::BINARY))
         .concat(profile_id)
         .concat(0.chr(Encoding::BINARY))
+        .concat(length.nil? ? "".b : "#{length}\x00".b)
         .concat(round.chr(Encoding::BINARY))
         .concat(to_be(right, (wr + 7) / 8))
     end
@@ -52,12 +56,12 @@ module Baseh
       OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), key_bytes, message)
     end
 
-    def run_rounds(left, right, profile_id, key_bytes, rounds, w0, w1)
+    def run_rounds(left, right, profile_id, key_bytes, rounds, w0, w1, length)
       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)
+        f = low_bits(hmac(key_bytes, round_message(profile_id, i, right, wr, length)), wl)
         new_left = right
         new_right = left ^ f
         left = new_left
@@ -66,12 +70,12 @@ module Baseh
       [left, right]
     end
 
-    def run_inverse(left, right, profile_id, key_bytes, rounds, w0, w1)
+    def run_inverse(left, right, profile_id, key_bytes, rounds, w0, w1, length)
       (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)
+        f = low_bits(hmac(key_bytes, round_message(profile_id, i, left, wr, length)), wl)
         prev_right = left
         prev_left = right ^ f
         left = prev_left
@@ -80,21 +84,23 @@ module Baseh
       [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)
+    # Forward permutation with cycle walking. length is expandable mode only
+    # (spec 7.3/19.4): the generation's total code length mixed into the round
+    # message; omit it in fixed mode.
+    def permute(value, capacity, profile_id:, key_bytes:, rounds:, length: nil)
+      walk(value, capacity, profile_id, key_bytes, rounds, length) do |left, right, w0, w1|
+        run_rounds(left, right, profile_id, key_bytes, rounds, w0, w1, length)
       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)
+    def inverse_permute(value, capacity, profile_id:, key_bytes:, rounds:, length: nil)
+      walk(value, capacity, profile_id, key_bytes, rounds, length) do |left, right, w0, w1|
+        run_inverse(left, right, profile_id, key_bytes, rounds, w0, w1, length)
       end
     end
 
-    def walk(value, capacity, profile_id, key_bytes, rounds)
+    def walk(value, capacity, profile_id, key_bytes, rounds, length)
       bits = bit_length(capacity)
       w1 = bits / 2
       w0 = bits - w1
@@ -114,5 +120,12 @@ module Baseh
         safe_for_customer: false
       )
     end
+
+    # Only permute and inverse_permute are public; the round machinery is
+    # internal to the spec 7.3 permutation.
+    class << self
+      private :bit_length, :low_bits, :to_be, :round_message, :hmac,
+              :run_rounds, :run_inverse, :walk
+    end
   end
 end

data/lib/baseh/profile.rb

@@ -11,27 +11,111 @@ module Baseh
   #                  key_bytes:, rounds: } or { enabled: false },
   #   profanity: { mode: "none" | "no-vowels" | "blocklist",
   #                words: [...], extra_words: [...] } (optional, spec 18)
+  #   max_repetition: 0 (off) or an integer >= 3 (optional, spec 21)
+  #   short_checksum_length:, short_checksum_until: (expandable only,
+  #     spec 22; 0 or absent disables)
   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
+      attr_reader :profile_id, :mode, :body_alphabet, :body_length,
+                  :min_length, :checksum_alphabet, :checksum_length,
+                  :short_checksum_length, :short_checksum_until,
+                  :case_sensitive, :separator, :separator_min_length,
+                  :grouping, :aliases, :permutation,
+                  :capacity, :checksum_modulus, :profanity_mode, :blocklist,
+                  :max_repetition
 
       def initialize(profile)
         validate_type!(profile)
         @profile_id = validate_profile_id!(profile[:profile_id])
         @case_sensitive = profile[:case_sensitive] == true
 
+        # Spec 2.2/19.9. A persisted or frozen profile declares its mode;
+        # profiles built before the mode field existed are fixed, so the
+        # frozen vectors keep matching byte for byte.
+        @mode = (profile[:mode] || "fixed").to_s
+        unless %w[fixed expandable].include?(@mode)
+          self.class.fail_profile!("mode must be fixed or expandable")
+        end
+
         @body_alphabet = validate_body_alphabet!(profile[:body_alphabet])
-        @body_length = validate_integer!(profile[:body_length], 1, 32, "bodyLength")
+        # Spec 19.2: in expandable mode the zero ban strips 0 and O from the
+        # body alphabet silently, before any other validation, exactly like
+        # the no-vowels strip of section 18.1.
+        if @mode == "expandable"
+          @body_alphabet = @body_alphabet.delete("0O").freeze
+        end
+        @body_length =
+          if @mode == "fixed"
+            validate_integer!(profile[:body_length], 1, 32, "bodyLength")
+          end
         @checksum_length = validate_integer!(profile[:checksum_length], 0, 8, "checksumLength")
-        @checksum_alphabet = validate_checksum_alphabet!(
-          profile[:checksum_alphabet], @checksum_length
-        )
+        @min_length = (profile[:min_length] || 4)
+        @separator_min_length = (profile[:separator_min_length] || 0)
+        if @mode == "fixed"
+          unless @separator_min_length.is_a?(Integer) && @separator_min_length.zero?
+            self.class.fail_profile!("separatorMinLength must be 0 in fixed mode")
+          end
+        else
+          unless @min_length.is_a?(Integer) && @min_length >= 1
+            self.class.fail_profile!("minLength must be an integer of at least 1")
+          end
+          unless @min_length > @checksum_length
+            self.class.fail_profile!("minLength must be greater than checksumLength")
+          end
+          unless @separator_min_length.is_a?(Integer) && @separator_min_length >= 0
+            self.class.fail_profile!("separatorMinLength must be an integer of at least 0")
+          end
+        end
+        # Spec 22. The short checksum is expandable-only; 0 or absent turns
+        # it off.
+        @short_checksum_length = profile[:short_checksum_length] || 0
+        @short_checksum_until = profile[:short_checksum_until] || 0
+        # Spec 22. The window field is the switch: shortChecksumUntil of 0
+        # turns the feature off (the codebase convention, like
+        # maxRepetition), and the length field without a window is
+        # INVALID_PROFILE. With a window set, a shortChecksumLength of 0 is
+        # legal: the window's generations carry no checksum symbols at all.
+        if @mode == "fixed"
+          unless @short_checksum_length == 0 && @short_checksum_until == 0
+            self.class.fail_profile!(
+              "shortChecksumLength and shortChecksumUntil are expandable-mode only"
+            )
+          end
+        elsif @short_checksum_until != 0
+          unless @short_checksum_until.is_a?(Integer) && @short_checksum_until >= @min_length
+            self.class.fail_profile!("shortChecksumUntil must be an integer of at least minLength")
+          end
+          # Beyond 8 the window would swallow nearly every practical code,
+          # and long codes genuinely want two checksum symbols.
+          if @short_checksum_until > 8
+            self.class.fail_profile!("shortChecksumUntil must be at most 8")
+          end
+          unless @short_checksum_length.is_a?(Integer) && @short_checksum_length >= 0 &&
+                 @short_checksum_length < @checksum_length
+            self.class.fail_profile!(
+              "shortChecksumLength must be an integer from 0 through checksumLength - 1"
+            )
+          end
+          unless @min_length > @short_checksum_length
+            self.class.fail_profile!("minLength must be greater than shortChecksumLength")
+          end
+        elsif @short_checksum_length != 0
+          self.class.fail_profile!("shortChecksumLength requires shortChecksumUntil")
+        end
+        # Spec 19.3: in expandable mode the checksum alphabet is derived from
+        # the body alphabet after every body strip; the configured
+        # checksumAlphabet is not consulted.
+        @checksum_alphabet =
+          if @mode == "expandable"
+            "".freeze
+          else
+            validate_checksum_alphabet!(
+              profile[:checksum_alphabet], @checksum_length
+            )
+          end
 
         # Spec 18: validation happens before the vowel strip so malformed
         # alphabets are reported as such, then no-vowels strips and
@@ -41,10 +125,20 @@ module Baseh
           @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?
+          if @mode == "fixed" && @checksum_length.positive?
+            validate_stripped!(@checksum_alphabet, "checksum")
+          end
           @body_alphabet.freeze
           @checksum_alphabet.freeze
         end
+        if @mode == "expandable"
+          # Spec 19.3: the checksum alphabet is derived, "0" followed by the
+          # body alphabet in order, after every body strip (zero ban,
+          # no-vowels) so all downstream rules see the final alphabets. The
+          # configured checksumAlphabet is not consulted.
+          @checksum_alphabet = ("0" + @body_alphabet).freeze
+          validate_stripped!(@body_alphabet, "body")
+        end
         @blocklist =
           if @profanity_mode == "blocklist"
             Profanity.effective_blocklist(profile[:profanity]).freeze
@@ -52,6 +146,14 @@ module Baseh
             [].freeze
           end
 
+        # Spec 21: 0 disables the filter; an active filter needs a floor of
+        # 3 — banning pairs (2) would destroy roughly 9% of every generation.
+        @max_repetition = profile[:max_repetition] || 0
+        unless @max_repetition.is_a?(Integer) && @max_repetition >= 0 &&
+               (@max_repetition.zero? || @max_repetition >= 3)
+          self.class.fail_profile!("maxRepetition must be 0 (off) or an integer of at least 3")
+        end
+
         @separator = validate_separator!(
           profile[:separator].to_s, @body_alphabet, @checksum_alphabet
         )
@@ -63,11 +165,28 @@ module Baseh
         )
         @permutation = validate_permutation!(profile[:permutation] || { enabled: false })
 
-        @capacity = @body_alphabet.length**@body_length
+        # Capacity is the fixed-mode A^bodyLength; meaningless in expandable
+        # mode, where Baseh#capacity refuses per spec 12.3.
+        @capacity = @body_alphabet.length**(@body_length || 0)
         @checksum_modulus = [@checksum_alphabet.length, 1].max**@checksum_length
         freeze
       end
 
+      # Spec 22. The checksum length that applies to a generation of the
+      # given total length: short_checksum_length at or below
+      # short_checksum_until, checksum_length above it (and always in fixed
+      # mode). The feature is on exactly when short_checksum_until is
+      # non-zero; a short_checksum_length of 0 then means the window's
+      # generations carry no checksum symbols at all.
+      def effective_checksum_length(length)
+        if @mode == "expandable" && @short_checksum_until.positive? &&
+           length <= @short_checksum_until
+          @short_checksum_length
+        else
+          @checksum_length
+        end
+      end
+
       private
 
       def self.fail_profile!(reason)
@@ -189,7 +308,13 @@ module Baseh
           end
           s_norm = case_sensitive ? src : src.upcase
           t_norm = case_sensitive ? tgt : tgt.upcase
-          if canonical.include?(s_norm)
+          # Spec 3.2: an alias must never map two distinct canonical symbols
+          # into one value. Fixed mode rejects a canonical alias source
+          # outright. In expandable mode the frozen tier (spec 17.1) carries
+          # aliases whose sources are canonical body symbols (T, N, W stay in
+          # the body alphabet); the canonical symbol wins at normalization,
+          # making those entries inert instead of destructive.
+          if @mode == "fixed" && canonical.include?(s_norm)
             self.class.fail_profile!("alias source #{src.inspect} is already a canonical symbol")
           end
           unless canonical.include?(t_norm)
@@ -222,7 +347,13 @@ module Baseh
           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
+          if @mode == "expandable"
+            # Spec 2.2/19.5: the split is derived from the total length; a
+            # configurable pattern no longer exists in expandable mode.
+            unless grouping.empty?
+              self.class.fail_profile!("grouping must be empty in expandable mode")
+            end
+          elsif grouping.sum != body_length + checksum_length
             self.class.fail_profile!("group sizes must sum to bodyLength + checksumLength")
           end
         end

data/lib/baseh/profiles.rb

@@ -6,18 +6,27 @@ module Baseh
   # 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
+  #   Minimum  36 symbols, no checksum, XXX-XXX      2,176,782,336 ids
+  #   Light    31 symbols, 2 checksums, XXXX-XXXX      887,503,681 ids
+  #   Medium   28 symbols, 2 checksums, XXXX-XXXX      481,890,304 ids (default)
+  #   Heavy    26 symbols, 2 checksums, XXXX-XXXX      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.
+  # All four keep the typed O/I/L aliases where possible, use a hyphen
+  # delimiter at the midpoint and run the default profanity blocklist. Every
+  # tier permutes with the frozen published key (FROZEN_KEY_BYTES below): the
+  # key is public, so the permutation obscures sequence but is not secrecy.
+  # The -p variants are identical but permute with caller-supplied key
+  # material instead.
   module Profiles
     OIL_ALIASES = { "O" => "0", "I" => "1", "L" => "1" }.freeze
 
+    # The frozen published permutation key. Public by design: it makes issued
+    # codes look non-sequential but offers no secrecy, since anyone can read
+    # it here. Never swap it on a live namespace; codes only decode with the
+    # key they were issued under. Use the -p variants to supply private key
+    # material.
+    FROZEN_KEY_BYTES = "baseh-frozen-key-v1".b.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 = {
@@ -34,18 +43,18 @@ module Baseh
         profile_id: "baseh-light",
         body_alphabet: "0123456789ABCEFGHJKMNPQRSUVWXYZ",
         checksum_alphabet: "234679ACEFGHJKMNPQRUVWXY",
-        checksum_length: 1,
-        separator: "",
-        grouping: [],
+        checksum_length: 2,
+        separator: "-",
+        grouping: [4, 4],
         aliases: { **OIL_ALIASES, "D" => "B", "T" => "P" }
       },
       medium: {
         profile_id: "baseh-medium",
         body_alphabet: "0123456789ACDEFGHJKMPQRUVXYZ",
         checksum_alphabet: "234679ACDEFGHJKMPQRUVXY",
-        checksum_length: 1,
-        separator: "",
-        grouping: [],
+        checksum_length: 2,
+        separator: "-",
+        grouping: [4, 4],
         # 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",
@@ -55,9 +64,9 @@ module Baseh
         profile_id: "baseh-heavy",
         body_alphabet: "0123456789ABCEFHJKMPQRVXYZ",
         checksum_alphabet: "234679ACEFHJKMPQRUVXY",
-        checksum_length: 1,
-        separator: "",
-        grouping: [],
+        checksum_length: 2,
+        separator: "-",
+        grouping: [4, 4],
         aliases: { **OIL_ALIASES, "D" => "B", "T" => "P", "N" => "M",
                    "W" => "V", "S" => "F", "G" => "C" }
       }
@@ -65,46 +74,80 @@ module Baseh
 
     module_function
 
+    # Permutation every plain tier applies, built from the frozen published
+    # key.
+    def frozen_permutation
+      keyed_permutation(FROZEN_KEY_BYTES, "frozen", 8)
+    end
+
     # Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX.
     def baseh_minimum_v1
-      tier(:minimum, { enabled: false }, false)
+      tier(:minimum, frozen_permutation, false)
     end
 
-    # baseh-minimum with feistel-v1 permutation. key_bytes is required.
+    # baseh-minimum permuted with caller-supplied key material.
     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.
+    # Visual light plus spoken light, two checksum symbols, hyphen-delimited.
     def baseh_light_v1
-      tier(:light, { enabled: false }, false)
+      tier(:light, frozen_permutation, false)
     end
 
-    # baseh-light with feistel-v1 permutation. key_bytes is required.
+    # baseh-light permuted with caller-supplied key material.
     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.
+    # Visual medium plus spoken medium, two checksum symbols, hyphen-delimited. The default.
     def baseh_medium_v1
-      tier(:medium, { enabled: false }, false)
+      tier(:medium, frozen_permutation, false)
     end
 
-    # baseh-medium with feistel-v1 permutation. key_bytes is required.
+    # baseh-medium permuted with caller-supplied key material.
     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.
+    # Conservative alphabet plus spoken heavy, two checksum symbols, hyphen-delimited.
     def baseh_heavy_v1
-      tier(:heavy, { enabled: false }, false)
+      tier(:heavy, frozen_permutation, false)
     end
 
-    # baseh-heavy with feistel-v1 permutation. key_bytes is required.
+    # baseh-heavy permuted with caller-supplied key material.
     def baseh_heavy_p_v1(key_bytes:, key_id: "default", rounds: 8)
       tier(:heavy, keyed_permutation(key_bytes, key_id, rounds), true)
     end
 
+    # Spec 17.1. The expandable recommended default carries the same safety
+    # posture as baseh-medium-v1: the medium visual strips (O, I, L, B, S) and
+    # the medium spoken strips (T, N, W), so an issued code never emits a
+    # visual or spoken confusable. The zero ban of section 19.2 then removes 0
+    # (and O, already gone), leaving a 27-symbol body. The checksum alphabet
+    # derives as "0" plus the body (28 symbols).
+    EXPANDABLE_BODY = "123456789ACDEFGHJKMPQRUVXYZ"
+
+    # The frozen expandable tier; the recommended starting point for new
+    # namespaces. Four characters while the namespace is small, gaining one
+    # symbol automatically as issuance climbs past each generation's
+    # capacity. The body alphabet is the medium safety set (the full
+    # alphanumeric set minus the visual look-alikes O, I, L, B, S and the
+    # spoken-confusable T, N, W), with the zero ban of spec 19.2 removing 0
+    # (27 symbols); the checksum alphabet derives as "0" plus the body (28
+    # symbols). The short checksum of spec 22 is on: one checksum symbol
+    # through five characters (27^3 = 19,683 ids at length 4, 27^4 = 531,441
+    # at length 5), two from six characters up. The hyphen appears from six
+    # characters up, split by the balanced grouping rule of spec 19.5.
+    def baseh_expandable_v1
+      expandable_tier(frozen_permutation, false)
+    end
+
+    # baseh-expandable permuted with caller-supplied key material.
+    def baseh_expandable_p_v1(key_bytes:, key_id: "default", rounds: 8)
+      expandable_tier(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)
       {
@@ -131,9 +174,33 @@ module Baseh
         grouping: shape[:grouping].dup,
         aliases: shape[:aliases].dup,
         permutation: permutation,
-        profanity: { mode: "blocklist" }
+        profanity: { mode: "blocklist" },
+        max_repetition: 4
+      }
+    end
+    # Builds a fresh mutable profile for the expandable tier, plain or (-p)
+    # keyed. Every call returns new strings, arrays and hashes.
+    def expandable_tier(permutation, p_suffix)
+      {
+        profile_id: "baseh-expandable" + (p_suffix ? "-p" : "") + "-v1",
+        mode: "expandable",
+        body_alphabet: EXPANDABLE_BODY.dup,
+        min_length: 4,
+        checksum_alphabet: ("0" + EXPANDABLE_BODY).dup,
+        checksum_length: 2,
+        short_checksum_length: 1,
+        short_checksum_until: 5,
+        case_sensitive: false,
+        separator: "-",
+        separator_min_length: 6,
+        grouping: [],
+        aliases: { **OIL_ALIASES, "B" => "8", "S" => "5", "T" => "P",
+                   "N" => "M", "W" => "V" },
+        permutation: permutation,
+        profanity: { mode: "blocklist" },
+        max_repetition: 4
       }
     end
-    private_class_method :keyed_permutation, :tier
+    private_class_method :frozen_permutation, :keyed_permutation, :tier, :expandable_tier
   end
 end

data/lib/baseh/version.rb

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