omnizip 0.3.8 → 0.3.10

data/lib/omnizip/algorithms/lzma/distance_coder.rb

@@ -49,6 +49,8 @@ module Omnizip
           end
 
           # Position encoders for slots 4-13
+          # SDK convention: size = NUM_FULL_DISTANCES - END_POS_MODEL_INDEX = 128 - 14 = 114
+          # Indexed by: base - slot - 1 (matches LZMA SDK and XZ Utils)
           @pos_encoders = Array.new(NUM_FULL_DISTANCES - END_POS_MODEL_INDEX) do
             BitModel.new
           end
@@ -71,19 +73,11 @@ module Omnizip
         #
         # @return [void]
         def reset_models
-          if ENV.fetch("DEBUG_RESET_MODELS",
-                       nil) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-            puts "    [DistanceCoder.reset_models] Resetting #{@slot_encoders.size} len_states, each with #{@slot_encoders[0]&.size || '?'} models"
-          end
           @slot_encoders.each do |len_state_models|
             len_state_models.each(&:reset)
           end
           @pos_encoders.each(&:reset)
           @align_encoder.each(&:reset)
-          if ENV.fetch("DEBUG_RESET_MODELS",
-                       nil) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-            puts "    [DistanceCoder.reset_models] Done resetting"
-          end
         end
 
         # Encode a match distance using SDK-compatible encoding
@@ -95,11 +89,6 @@ module Omnizip
         def encode(range_encoder, distance, len_state)
           slot = get_dist_slot(distance)
 
-          if ENV["LZMA_DEBUG_ENCODE"]
-            puts "[DistanceCoder.encode] distance=#{distance} slot=#{slot} len_state=#{len_state}"
-            puts "[DistanceCoder.encode] CALLING encode_tree with symbol=#{slot}"
-          end
-
           # Encode the slot using the appropriate slot encoder
           encode_tree(range_encoder, @slot_encoders[len_state], slot,
                       NUM_DIST_SLOT_BITS)
@@ -111,6 +100,7 @@ module Omnizip
 
             if slot < END_POS_MODEL_INDEX
               # Slots 4-13: Use position encoders (reverse tree encoding)
+              # SDK/XZ Utils convention: base_idx = base - slot - 1
               encode_reverse_tree(range_encoder,
                                   @pos_encoders,
                                   base - slot - 1,
@@ -138,61 +128,24 @@ module Omnizip
         # @param len_state [Integer] Length state for slot selection
         # @return [Integer] Decoded distance value (before adding 1)
         def decode(range_decoder, len_state)
-          # DEBUG: Trace specific calls to find corruption
-          $distance_decode_count ||= 0
-          debug_calls = (320..330)
-          debug_this = debug_calls.include?($distance_decode_count)
-          trace_326 = ($distance_decode_count == 326)
-          trace_325 = ($distance_decode_count == 325)
-
-          # DEBUG: Trace large distances (> 100000)
-          trace_large = $distance_decode_count.between?(25,
-                                                        35) || $distance_decode_count.between?(
-                                                          315, 330
-                                                        )
-
-          # DEBUG: Trace all when LZMA_DEBUG_DISTANCE is set
-          trace_all = ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-
-          if (trace_325 || trace_large || trace_all) && ENV.fetch(
-            "LZMA_DEBUG_DISTANCE", nil
-          )
-            puts "  [DistanceCoder.decode ##{$distance_decode_count}] START - len_state=#{len_state}"
-            puts "    BEFORE: range=#{range_decoder.range.inspect}, code=#{range_decoder.code.inspect}"
-          end
-
           slot = decode_tree(range_decoder, @slot_encoders[len_state],
                              NUM_DIST_SLOT_BITS)
 
-          if (debug_this || trace_large || trace_all) && ENV.fetch(
-            "LZMA_DEBUG_DISTANCE", nil
-          )
-            puts "  [DistanceCoder.decode ##{$distance_decode_count}] len_state=#{len_state}, slot=#{slot}"
-            puts "    @slot_encoders[#{len_state}] object_id=#{@slot_encoders[len_state].object_id}"
-          end
-
           # Decode extra bits based on slot
           if slot < START_POS_MODEL_INDEX
             # Slots 0-3: No extra bits
-            $distance_decode_count += 1
-            if debug_this && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-              puts "    -> distance=#{slot}"
-            end
             slot
           else
             footer_bits = (slot >> 1) - 1
 
             if slot < END_POS_MODEL_INDEX
               # Slots 4-13: Use position encoders (reverse tree decoding)
+              # SDK/XZ Utils convention: base_idx = base - slot - 1
               base = (2 | (slot & 1)) << footer_bits
               result = base + decode_reverse_tree(range_decoder,
                                                   @pos_encoders,
                                                   base - slot - 1,
                                                   footer_bits)
-              $distance_decode_count += 1
-              if debug_this && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-                puts "    -> distance=#{result} (slot #{slot})"
-              end
             else
               # Slots 14+: Fixed direct bits + aligned bits
               # XZ Utils pattern (lzma_decoder.c:500-514):
@@ -225,23 +178,10 @@ module Omnizip
                                              @align_encoder,
                                              0,
                                              DIST_ALIGN_BITS)
-              if trace_326 && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-                puts "    TRACE_326: low_bits=#{low_bits}"
-              end
 
               # Final result: (result << 4) + low_bits
               # NOTE: slot value is NOT added (XZ Utils pattern - line 513 adds symbol for EOPM check only)
               result = (result << DIST_ALIGN_BITS) + low_bits
-              $distance_decode_count += 1
-              if (debug_this || trace_large) && ENV.fetch(
-                "LZMA_DEBUG_DISTANCE", nil
-              )
-                puts "    -> slot=#{slot}, result_after_direct=#{result >> DIST_ALIGN_BITS}, low_bits=#{low_bits}, distance=#{result}"
-              end
-              if result > 100000
-                puts "    [LARGE_DISTANCE ##{$distance_decode_count}] distance=#{result}, slot=#{slot}" if ENV["LZMA_DEBUG_DISTANCE"]
-                puts "      BEFORE: range_decoder.range=#{range_decoder.range}, range_decoder.code=#{range_decoder.code}" if ENV["LZMA_DEBUG_DISTANCE"]
-              end
             end
             result
           end
@@ -321,29 +261,11 @@ module Omnizip
         # @return [void]
         def encode_tree(range_encoder, models, symbol, num_bits)
           m = 1
-          trace_all = ENV.fetch("TRACE_ALL_SLOT_ENCODE", nil)
-          iteration = 0
-
-          if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
-            puts "    [encode_tree START] RECEIVED symbol=#{symbol}, num_bits=#{num_bits}"
-            puts "      BEFORE: range=#{range_encoder.range}, low=#{range_encoder.low}"
-          end
-
           (num_bits - 1).downto(0) do |i|
-            iteration += 1
             bit = (symbol >> i) & 1
-            if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
-              model_idx = m
-              puts "      [#{iteration}/#{num_bits}] i=#{i}, bit=#{bit}, m=#{m}, model_idx=#{model_idx}, prob=#{models[m].probability}"
-            end
             range_encoder.encode_bit(models[m], bit)
             m = (m << 1) | bit
           end
-
-          if trace_all && ENV.fetch("LZMA_DEBUG_ENCODE", nil)
-            puts "      AFTER: range=#{range_encoder.range}, low=#{range_encoder.low}"
-            puts "    [encode_tree END] ENCODED symbol=#{symbol}"
-          end
         end
 
         # Decode a value using a tree of bit models
@@ -355,29 +277,10 @@ module Omnizip
         def decode_tree(range_decoder, models, num_bits)
           m = 1
           symbol = 0
-          trace_this = (num_bits == 6 && ENV.fetch("TRACE_SLOT_DECODE",
-                                                   nil)) || ($distance_decode_count == 28)
-          trace_all = ENV.fetch("TRACE_ALL_SLOT_DECODE", nil)
-          iteration = 0
-
-          if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-            puts "    [decode_tree START] num_bits=#{num_bits}, range=#{range_decoder.range}, code=#{range_decoder.code}"
-            puts "      models array object_id=#{models.object_id}"
-          end
-
           (num_bits - 1).downto(0) do |i|
-            iteration += 1
-            model = models[m]
-            bit = range_decoder.decode_bit(model)
+            bit = range_decoder.decode_bit(models[m])
             m = (m << 1) | bit
             symbol |= (bit << i)
-            if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE",
-                                                      nil)
-              puts "      [#{iteration}/#{num_bits}] i=#{i}, bit=#{bit}, m=#{m}, model.object_id=#{model.object_id}, prob=#{model.probability}, symbol=#{symbol}"
-            end
-          end
-          if (trace_this || trace_all) && ENV.fetch("LZMA_DEBUG_DISTANCE", nil)
-            puts "    [decode_tree END] symbol=#{symbol}"
           end
           symbol
         end

data/lib/omnizip/algorithms/lzma/length_coder.rb

@@ -67,67 +67,25 @@ module Omnizip
         # @param pos_state [Integer] Position state for tree selection
         # @return [void]
         def encode(range_encoder, length, pos_state)
-          trace_encode = ENV.fetch("LZMA_DEBUG_ENCODE",
-                                   nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
-
-          if trace_encode
-            puts "    [LengthCoder.encode] START: length=#{length}, pos_state=#{pos_state}"
-            puts "      @choice.prob=#{@choice.probability} @choice2.prob=#{@choice2.probability}"
-          end
-
           if length < LEN_LOW_SYMBOLS
             # 0-7: Use low tree
-            if trace_encode
-              puts "      Using LOW tree (length #{length} < #{LEN_LOW_SYMBOLS})"
-              puts "      Encoding choice=0 with prob=#{@choice.probability}"
-            end
             range_encoder.encode_bit(@choice, 0)
-            if trace_encode
-              puts "      After choice: @choice.prob=#{@choice.probability}"
-            end
             encode_tree(range_encoder, @low[pos_state], length,
                         NUM_LEN_LOW_BITS)
           elsif length < LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS
             # 8-15: Use mid tree
-            if trace_encode
-              puts "      Using MID tree (length #{length} < #{LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS})"
-              puts "      Encoding choice=1 with prob=#{@choice.probability}"
-            end
             range_encoder.encode_bit(@choice, 1)
-            if trace_encode
-              puts "      After choice: @choice.prob=#{@choice.probability}"
-              puts "      Encoding choice2=0 with prob=#{@choice2.probability}"
-            end
             range_encoder.encode_bit(@choice2, 0)
-            if trace_encode
-              puts "      After choice2: @choice2.prob=#{@choice2.probability}"
-            end
             encode_tree(range_encoder, @mid[pos_state],
                         length - LEN_LOW_SYMBOLS, NUM_LEN_MID_BITS)
           else
             # 16+: Use high tree
-            if trace_encode
-              puts "      Using HIGH tree (length #{length} >= #{LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS})"
-              puts "      Encoding choice=1 with prob=#{@choice.probability}"
-            end
             range_encoder.encode_bit(@choice, 1)
-            if trace_encode
-              puts "      After choice: @choice.prob=#{@choice.probability}"
-              puts "      Encoding choice2=1 with prob=#{@choice2.probability}"
-            end
             range_encoder.encode_bit(@choice2, 1)
-            if trace_encode
-              puts "      After choice2: @choice2.prob=#{@choice2.probability}"
-            end
             encode_tree(range_encoder, @high,
                         length - LEN_LOW_SYMBOLS - LEN_MID_SYMBOLS,
                         NUM_LEN_HIGH_BITS)
           end
-
-          if trace_encode
-            puts "      FINAL @choice.prob=#{@choice.probability} @choice2.prob=#{@choice2.probability}"
-            puts "    [LengthCoder.encode] END"
-          end
         end
 
         # Decode a match length using SDK-compatible decoding
@@ -136,58 +94,21 @@ module Omnizip
         # @param pos_state [Integer] Position state for tree selection
         # @return [Integer] Decoded length value (before adding MATCH_LEN_MIN)
         def decode(range_decoder, pos_state)
-          trace_decode = ENV.fetch("LZMA_DEBUG_DISTANCE",
-                                   nil) && ENV.fetch("TRACE_LENGTH_CODER", nil)
-
-          if trace_decode
-            caller_loc = caller_locations(2, 1).first
-            puts "    [LengthCoder.decode] START: pos_state=#{pos_state}"
-            puts "      self.object_id=#{object_id}"
-            puts "      @choice.object_id=#{@choice.object_id} prob=#{@choice.probability}"
-            puts "      @choice2.object_id=#{@choice2.object_id} prob=#{@choice2.probability}"
-            puts "      Called from: #{caller_loc.label} at #{caller_loc.lineno}"
-          end
-
           choice_bit = range_decoder.decode_bit(@choice)
-          if trace_decode
-            puts "      Decoded choice=#{choice_bit} with prob=#{@choice.probability}"
-            puts "      After choice decode: @choice.prob=#{@choice.probability}"
-          end
 
           if choice_bit.zero?
             # Low tree
-            if trace_decode
-              puts "      Using LOW tree"
-            end
-            result = decode_tree(range_decoder, @low[pos_state],
-                                 NUM_LEN_LOW_BITS)
+            decode_tree(range_decoder, @low[pos_state],
+                        NUM_LEN_LOW_BITS)
           elsif range_decoder.decode_bit(@choice2).zero?
             # Mid tree
-            if trace_decode
-              puts "      Decoded choice2=0 with prob=#{@choice2.probability}"
-              puts "      After choice2 decode: @choice2.prob=#{@choice2.probability}"
-              puts "      Using MID tree"
-            end
-            result = LEN_LOW_SYMBOLS +
+            LEN_LOW_SYMBOLS +
               decode_tree(range_decoder, @mid[pos_state], NUM_LEN_MID_BITS)
           else
             # High tree
-            if trace_decode
-              puts "      Decoded choice2=1 with prob=#{@choice2.probability}"
-              puts "      After choice2 decode: @choice2.prob=#{@choice2.probability}"
-              puts "      Using HIGH tree"
-            end
-            result = LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS +
+            LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS +
               decode_tree(range_decoder, @high, NUM_LEN_HIGH_BITS)
           end
-
-          if trace_decode
-            puts "      FINAL @choice.prob=#{@choice.probability} @choice2.prob=#{@choice2.probability}"
-            puts "      Result: length_encoded=#{result}"
-            puts "    [LengthCoder.decode] END"
-          end
-
-          result
         end
 
         # Reset probability models to initial values
@@ -197,12 +118,6 @@ module Omnizip
         #
         # @return [void]
         def reset_models
-          if ENV["TRACE_RESET_MODELS"]
-            puts "    [LengthCoder.reset_models] CALLED!"
-            puts "      Before reset: @choice.prob=#{@choice.probability} @choice2.prob=#{@choice2.probability}"
-            caller_loc = caller_locations(2, 1).first
-            puts "      Called from: #{caller_loc.label} at #{caller_loc.path}:#{caller_loc.lineno}"
-          end
           @choice.reset
           @choice2.reset
 
@@ -215,9 +130,6 @@ module Omnizip
           end
 
           @high.each(&:reset)
-          if ENV["TRACE_RESET_MODELS"]
-            puts "      After reset: @choice.prob=#{@choice.probability} @choice2.prob=#{@choice2.probability}"
-          end
         end
 
         private

data/lib/omnizip/algorithms/lzma/literal_decoder.rb

@@ -68,24 +68,6 @@ module Omnizip
           # We build it up bit by bit until it reaches 0x100
           symbol = 1
 
-          # TEMP DEBUG: Trace first literal decode
-          if ENV["TRACE_LITERAL_DECODE"] && lit_state.zero?
-            # range = range_decoder.instance_variable_get(:@range)
-            # code = range_decoder.instance_variable_get(:@code)
-            # puts ""
-            # puts "=== decode_unmatched START: lit_state=#{lit_state}, base_offset=#{base_offset} ==="
-            # puts "Initial: range=0x#{range.to_s(16)}, code=0x#{code.to_s(16)}"
-          end
-
-          # DEBUG: Trace lit_state=96 (the corrupted literal)
-          if lit_state == 96
-            # range = range_decoder.instance_variable_get(:@range)
-            # code = range_decoder.instance_variable_get(:@code)
-            # puts ""
-            # puts "=== decode_unmatched START: lit_state=#{lit_state}, base_offset=#{base_offset} ==="
-            # puts "Initial: range=0x#{range.to_s(16)}, code=0x#{code.to_s(16)}"
-          end
-
           # Decode 8 bits to build the symbol from 1 to 0x100
           while symbol < 0x100
             # Model index based on current symbol value
@@ -94,34 +76,13 @@ module Omnizip
             # Decode next bit
             bit = range_decoder.decode_bit(models[model_index])
 
-            if ENV["TRACE_LITERAL_DECODE"] && lit_state.zero?
-              range_after = range_decoder.instance_variable_get(:@range)
-              code_after = range_decoder.instance_variable_get(:@code)
-              puts "Bit #{symbol}: model_index=#{model_index}, bit=#{bit}, range=0x#{range_after.to_s(16)}, code=0x#{code_after.to_s(16)}" if ENV["LZMA_DEBUG_BITS"]
-            end
-
-            # DEBUG: Trace bits for lit_state=96
-            if ENV["LZMA_DEBUG_BITS"] && lit_state == 96
-              range_after = range_decoder.instance_variable_get(:@range)
-              code_after = range_decoder.instance_variable_get(:@code)
-              puts "  symbol=#{symbol}: model_index=#{model_index}, bit=#{bit}, range=0x#{range_after.to_s(16)}, code=0x#{code_after.to_s(16)}"
-            end
-
             # Update symbol: shift left and add bit
             symbol = (symbol << 1) | bit
           end
 
           # Symbol is now in range 0x100-0x1FF
           # Extract the byte value by subtracting 0x100
-          result = symbol - 0x100
-
-          if ENV["TRACE_LITERAL_DECODE"] && lit_state.zero?
-            puts "Result: 0x#{result.to_s(16)} ('#{result.chr}')"
-            puts "=== decode_unmatched END ==="
-            puts ""
-          end
-
-          result
+          symbol - 0x100
         end
 
         # Decode literal byte in matched mode (SDK feature)
@@ -153,34 +114,9 @@ module Omnizip
           # See: /Users/mulgogi/src/external/xz/src/liblzma/rangecoder/range_decoder.h:342-357
           offset = 0x100
 
-          # DEBUG: Trace matched literal decode at position 61
-          if ENV["TRACE_MATCHED_DECODE"] && lit_state == 96
-            puts "=== MATCHED LITERAL DECODE: lit_state=#{lit_state}, match_byte=0x#{match_byte.to_s(16).upcase} ==="
-            puts "  base_offset=#{base_offset}"
-            puts "  Initial: symbol=#{symbol}, offset=0x#{offset.to_s(16).upcase}"
-          end
-
           # SDK matched literal decoding algorithm
           # Process bits while match byte provides context
-          bit_num = 0
-          result_bits = [] # DEBUG: Track decoded bits
-
-          # DEBUG: Trace at dict_full=233
-          trace_233 = ENV.fetch("DICT_FULL_233_TRACE", nil) && lit_state.zero?
-
-          if trace_233
-            puts "=== MATCHED LITERAL TRACE at dict_full=233 ==="
-            puts "  match_byte=0x#{match_byte.to_s(16).upcase}"
-            puts "  base_offset=#{base_offset}"
-            puts "  Initial: symbol=#{symbol}, offset=0x#{offset.to_s(16).upcase}"
-          end
-
           loop do
-            if trace_233
-              puts "\n  Bit #{bit_num}:"
-              puts "    match_sym=0x#{(match_sym & 0xFF).to_s(16).upcase}, offset=0x#{offset.to_s(16).upcase}"
-            end
-
             # XZ Utils pattern: t_match_byte <<= 1; t_match_bit = t_match_byte & t_offset;
             # IMPORTANT: Shift FIRST, then extract the bit!
             # Shift match symbol (brings next bit into position 8)
@@ -198,31 +134,8 @@ module Omnizip
             # where t_offset is updated based on PREVIOUS decoded bit, t_match_bit is from match byte
             model_index = base_offset + offset + match_bit + symbol
 
-            if trace_233
-              puts "    match_bit=0x#{match_bit.to_s(16).upcase}, symbol=#{symbol}"
-              puts "    model_index=#{model_index}"
-              puts "    offset_from_base=#{model_index - base_offset}"
-              prob_before = models[model_index].probability
-              puts "    probability_before=0x#{prob_before.to_s(16).upcase} (#{prob_before})"
-              # Trace range decoder state BEFORE decode_bit
-              rd_range_before = range_decoder.instance_variable_get(:@range)
-              rd_code_before = range_decoder.instance_variable_get(:@code)
-              puts "    range_decoder BEFORE: range=0x#{rd_range_before.to_s(16)}, code=0x#{rd_code_before.to_s(16)}"
-            end
-
             # Decode literal bit
             bit = range_decoder.decode_bit(models[model_index])
-            result_bits << bit # DEBUG: Track bit
-
-            if trace_233
-              prob_after = models[model_index].probability
-              puts "    decoded_bit=#{bit}"
-              puts "    probability_after=0x#{prob_after.to_s(16).upcase} (#{prob_after})"
-              # Also trace the range decoder state after decode_bit
-              rd_range = range_decoder.instance_variable_get(:@range)
-              rd_code = range_decoder.instance_variable_get(:@code)
-              puts "    range_decoder AFTER: range=0x#{rd_range.to_s(16)}, code=0x#{rd_code.to_s(16)}"
-            end
 
             # Update offset based on DECODED bit (XZ Utils pattern)
             # IMPORTANT: XZ Utils rc_bit macro updates symbol BEFORE running the action!
@@ -246,48 +159,20 @@ module Omnizip
               symbol = (symbol << 1) | 1
             end
 
-            if ENV["TRACE_MATCHED_DECODE"] && lit_state == 96
-              puts "    new_offset=0x#{offset.to_s(16).upcase}"
-              puts "    new_symbol=#{symbol} (0x#{symbol.to_s(16).upcase})"
-            end
-
             # If bits diverge, switch to unmatched mode
             if (match_bit.positive? ? 1 : 0) != bit
-              if ENV["TRACE_MATCHED_DECODE"] && lit_state == 96
-                puts "    *** BITS DIVERGE - switching to unmatched mode ***"
-              end
-              if trace_233
-                puts "    *** BITS DIVERGE at bit #{bit_num} - match_bit=#{match_bit.positive? ? 1 : 0}, decoded_bit=#{bit} ***"
-              end
               # Continue in unmatched mode for remaining bits
               break if symbol >= 0x100
 
-              result = decode_unmatched_tail(symbol, base_offset, lc, range_decoder,
-                                             models)
-              if trace_233
-                puts "\n  FINAL RESULT (after unmatched tail): 0x#{result.to_s(16).upcase} ('#{result.chr}')"
-                puts "  Result bits: #{result_bits.join}"
-                puts "=== END MATCHED LITERAL TRACE ===\n"
-              end
-              return result
+              return decode_unmatched_tail(symbol, base_offset, lc,
+                                           range_decoder, models)
             end
 
             # Done when symbol reaches 0x100
             break if symbol >= 0x100
-
-            bit_num += 1
           end
 
-          result = symbol - 0x100
-          if trace_233 || (ENV.fetch("TRACE_MATCHED_DECODE",
-                                     nil) && lit_state == 96)
-            puts "\n  FINAL RESULT: 0x#{result.to_s(16).upcase} ('#{result.chr}')"
-            if trace_233
-              puts "  Result bits: #{result_bits.join}"
-            end
-            puts "=== END MATCHED LITERAL DECODE ===\n"
-          end
-          result
+          symbol - 0x100
         end
 
         private

data/lib/omnizip/algorithms/lzma/lzip_decoder.rb

@@ -52,6 +52,8 @@ module Omnizip
       #   result = decoder.decode_stream
       #
       class LzipDecoder
+        attr_reader :version, :dict_size, :member_size
+
         # Lzip magic bytes: "LZIP" in ASCII
         # Reference: lzip_decoder.c:106
         MAGIC = [0x4C, 0x5A, 0x49, 0x50].freeze