omnizip 0.3.13 → 0.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e86ca6410983afcc2259af21021ae0049d2b5f4def32975d9fa1568297417e3
-  data.tar.gz: b52224b6ef3a5b2dab3f56c9117daf36b679ecda95983cafd62ddd7d7f05b35a
+  metadata.gz: 978a7f51735e4fd90dbb0432b933ccdd17009d74c682db94f6ee6730fe1f893a
+  data.tar.gz: c02f967a72d720edbbc204bd6b36dc60a4c4f773aed3e308800880351a32c218
 SHA512:
-  metadata.gz: 3b74c21559d4c813b83c82d80957c97d3f57f0d512cdb1895a92f869bd27594f5c0b60ae108179431e50f52bb44bfbb795343facb2de8f853258e483f4b63e75
-  data.tar.gz: ff4f463c54686edc825f514bb74c527d33a0a9319e2952ac628984392eb5acfb26ce77077a12ae711ddb44a419361a93e3336ae43d8c85a23d01e3efd445a029
+  metadata.gz: 6664a917d2c82bca2779e62a082e1462c1dd8c36f3f4777a47a871feafd4d3bb25e7ae4eb492623a823aed8755777fce93374075a502b0a8beabe2becf9aed05
+  data.tar.gz: ccf0ff7279dc03c4c5aec2fd6a679419c3fa275966e3b7f076e3bdd4e5890e2141664f6137df46681d29738dbf7fb25ef95e1ec3e450c0e3cfc7509dd9f759d7

data/lib/omnizip/algorithm.rb

@@ -23,6 +23,8 @@ module Omnizip
   # the required methods. Algorithms are automatically registered with the
   # AlgorithmRegistry when defined.
   class Algorithm
+    require "stringio"
+
     attr_reader :options, :filter
 
     # Initialize algorithm with options.
@@ -38,7 +40,7 @@ module Omnizip
     # The filter will be applied before compression and reversed after
     # decompression. Returns self for method chaining.
     #
-    # @param filter [Filters::FilterBase, FilterPipeline] Filter or
+    # @param filter [Omnizip::Filter, FilterPipeline] Filter or
     #   pipeline to use
     # @return [self] For method chaining
     def with_filter(filter)
@@ -82,6 +84,39 @@ module Omnizip
               "#{self} must implement .metadata"
       end
 
+      # Class-level convenience: compress `data` and return the
+      # compressed bytes. Carries the algorithm's streaming contract
+      # over a single StringIO so callers with the whole payload in
+      # memory (parallel compressors, small files) don't need to
+      # instantiate and wire streams themselves.
+      #
+      # @param data [String, IO] Input to compress
+      # @param options [Hash] Forwarded to the algorithm
+      # @return [String] Compressed bytes
+      def compress(data, **options)
+        instance = new(options)
+        input = data.is_a?(::IO) ? data : ::StringIO.new(data.to_s.b)
+        output = ::StringIO.new
+        output.set_encoding(Encoding::BINARY)
+        instance.compress(input, output, options)
+        output.string
+      end
+
+      # Class-level convenience: decompress `data` and return the
+      # uncompressed bytes. Mirror of +.compress+.
+      #
+      # @param data [String, IO] Input to decompress
+      # @param options [Hash] Forwarded to the algorithm
+      # @return [String] Decompressed bytes
+      def decompress(data, **options)
+        instance = new(options)
+        input = data.is_a?(::IO) ? data : ::StringIO.new(data.to_s.b)
+        output = ::StringIO.new
+        output.set_encoding(Encoding::BINARY)
+        instance.decompress(input, output, options)
+        output.string
+      end
+
       # Automatically register algorithm when inherited.
       #
       # This hook is called whenever a class inherits from Algorithm,

data/lib/omnizip/algorithms/bzip2.rb

@@ -82,9 +82,7 @@ module Omnizip
       # @param options [Models::CompressionOptions] Decompression options
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
-        if output_stream.respond_to?(:set_encoding)
-          output_stream.set_encoding(Encoding::BINARY)
-        end
+        output_stream.set_encoding(Encoding::BINARY)
         decoder = Decoder.new(input_stream)
         decompressed = decoder.decode_stream
         output_stream.write(decompressed)

data/lib/omnizip/algorithms/deflate.rb

@@ -77,9 +77,7 @@ module Omnizip
       # @param options [Models::CompressionOptions] Decompression options
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
-        if output_stream.respond_to?(:set_encoding)
-          output_stream.set_encoding(Encoding::BINARY)
-        end
+        output_stream.set_encoding(Encoding::BINARY)
         decoder = Decoder.new(input_stream)
         decompressed = decoder.decode_stream
         output_stream.write(decompressed)

data/lib/omnizip/algorithms/deflate64.rb

@@ -73,8 +73,8 @@ module Omnizip
         return if compressed.nil? || compressed.empty?
 
         # Set output to binary mode if it's a StringIO
-        output.set_encoding(Encoding::BINARY) if output.respond_to?(:set_encoding)
-        output.binmode if output.respond_to?(:binmode)
+        output.set_encoding(Encoding::BINARY)
+        output.binmode
 
         # Use Zlib::Inflate with maximum window size
         inflater = Zlib::Inflate.new(Zlib::MAX_WBITS)

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

@@ -100,13 +100,14 @@ module Omnizip
 
           # We didn't find a long enough repeated match.
           # Encode it as a normal match if the match length is at least nice_len
-          # AND the match distance is within the dictionary buffer.
+          # AND the match distance stays within the data decoded so far.
+          # A match may reference anything before `position`: bytes already
+          # committed to the dictionary *and* bytes decoded earlier within
+          # the chunk currently being encoded.
           best_normal = matches.max_by { |m| [m.length, m.distance] }
 
           if best_normal && best_normal.length >= nice_len &&
-              best_normal.distance <= match_finder.dictionary.buffer.bytesize
-            # CRITICAL: Only use normal match if distance is within actual dictionary buffer
-            # This prevents invalid matches that reference bytes not yet written to dictionary
+              best_normal.distance <= position
             # Use normal match
             return [best_normal.distance + REPS, best_normal.length]
           end
@@ -116,10 +117,8 @@ module Omnizip
           if rep_len >= 2 && rep_len >= (best_normal&.length || 0)
             # Use repeated match
             [rep_index, rep_len]
-          elsif best_normal && best_normal.distance <= match_finder.dictionary.buffer.bytesize
-            # CRITICAL: Only use normal match if distance is within actual dictionary buffer
-            # Use dictionary.buffer.bytesize (actual data), NOT dictionary.size (max capacity)
-            # This prevents invalid matches that reference bytes not yet written to dictionary
+          elsif best_normal && best_normal.distance <= position
+            # Use normal match (any length beats encoding literals)
             [best_normal.distance + REPS, best_normal.length]
           else
             # Use literal - return UINT32_MAX to indicate literal (not 0!)

data/lib/omnizip/algorithms/lzma.rb

@@ -136,7 +136,7 @@ module Omnizip
       # @return [IO] The output_stream (for chaining)
       def decompress(input_stream, output_stream, options = nil)
         # Set binary encoding on output stream for proper byte handling
-        output_stream.set_encoding(Encoding::BINARY) if output_stream.respond_to?(:set_encoding)
+        output_stream.set_encoding(Encoding::BINARY)
 
         # Build decoder options, merging with instance variables as fallbacks
         decoder_opts = build_decoder_options(options)

data/lib/omnizip/algorithms/lzma2/lzma2_chunk.rb

@@ -152,7 +152,11 @@ module Omnizip
             comp_size & 0xFF,            # Compressed size low byte (BIG-ENDIAN)
           ].pack("CCCCC")
 
-          prop_bytes = @properties ? [@properties].pack("C") : ""
+          # The properties byte is only present when the control byte
+          # announces it (reset level >= 2, i.e. 0xC0/0xE0). Writing it for
+          # plain continuation chunks (0x80) desynchronizes the decoder,
+          # which does not expect a byte there.
+          prop_bytes = @need_props && @properties ? [@properties].pack("C") : ""
           header + prop_bytes + @compressed_data
         end
       end

data/lib/omnizip/algorithms/lzma2.rb

@@ -83,23 +83,19 @@ module Omnizip
         )
 
         # Read input
-        input_data = input.respond_to?(:read) ? input.read : input
+        input_data = Omnizip::IO::Source.for(input).read
 
         # Encode with LZMA2
         compressed = encoder.encode(input_data)
 
         # Write to output
-        if output.respond_to?(:write)
-          output.write(compressed)
-        else
-          output.replace(compressed)
-        end
+        Omnizip::IO::Sink.for(output).write(compressed)
       end
 
       # Decompress LZMA2 data
       def decompress(input, output, options = {})
         # Read input data
-        input_data = input.respond_to?(:read) ? input.read : input
+        input_data = Omnizip::IO::Source.for(input).read
         input_stream = StringIO.new(input_data)
         input_stream.set_encoding(Encoding::BINARY)
 
@@ -120,11 +116,7 @@ module Omnizip
         decompressed = decoder.decode_stream
 
         # Write to output
-        if output.respond_to?(:write)
-          output.write(decompressed)
-        else
-          output.replace(decompressed)
-        end
+        Omnizip::IO::Sink.for(output).write(decompressed)
       end
 
       # Encode dictionary size as single byte for LZMA2 properties

data/lib/omnizip/algorithms/zstandard/constants.rb

@@ -73,10 +73,12 @@ module Omnizip
         HUFFMAN_MAX_LOG = 11
         HUFFMAN_MAX_CODE_LENGTH = 11
         HUFFMAN_STANDARD_TABLE_SIZE = 256
+        HUF_SYMBOLVALUE_MAX = 255
 
         # FSE Table Limits (RFC 8878 Section 4.1)
         FSE_MAX_ACCURACY_LOG = 9
         FSE_MIN_ACCURACY_LOG = 5
+        FSE_DEFAULT_TABLELOG = 6
 
         # Compression levels
         MIN_LEVEL = 1
@@ -86,55 +88,66 @@ module Omnizip
         # Buffer size for streaming operations
         BUFFER_SIZE = 128 * 1024 # 128KB
 
-        # Literal length codes (RFC 8878 Table 9)
+        # Literal length codes (RFC 8878 Table: literals length codes)
         # Each entry: [baseline, extra_bits]
         LITERAL_LENGTH_TABLE = [
           [0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [5, 0], [6, 0], [7, 0],
           [8, 0], [9, 0], [10, 0], [11, 0], [12, 0], [13, 0], [14, 0], [15, 0],
-          [16, 1], [18, 1], [20, 1], [22, 1], [24, 1], [28, 1], [32, 1], [40, 1],
-          [48, 1], [64, 1], [128, 2], [256, 2], [512, 2], [1024, 2], [2048, 2],
-          [4096, 2], [8192, 2], [16384, 3], [32768, 3], [65536, 3]
+          [16, 1], [18, 1], [20, 1], [22, 1], [24, 2], [28, 2], [32, 3], [40, 3],
+          [48, 4], [64, 6], [128, 7], [256, 8], [512, 9], [1024, 10], [2048, 11],
+          [4096, 12], [8192, 13], [16384, 14], [32768, 15], [65536, 16]
         ].freeze
 
-        # Match length codes (RFC 8878 Table 10)
+        # Match length codes (RFC 8878 Table: match length codes, 53 entries)
         # Each entry: [baseline, extra_bits]
         MATCH_LENGTH_TABLE = [
           [3, 0], [4, 0], [5, 0], [6, 0], [7, 0], [8, 0], [9, 0], [10, 0],
           [11, 0], [12, 0], [13, 0], [14, 0], [15, 0], [16, 0], [17, 0], [18, 0],
           [19, 0], [20, 0], [21, 0], [22, 0], [23, 0], [24, 0], [25, 0], [26, 0],
           [27, 0], [28, 0], [29, 0], [30, 0], [31, 0], [32, 0], [33, 0], [34, 0],
-          [35, 1], [37, 1], [39, 1], [41, 1], [43, 1], [47, 1], [51, 1], [59, 1],
-          [67, 1], [83, 1], [99, 1], [131, 2], [195, 2], [259, 2], [323, 2],
-          [387, 2], [451, 2], [515, 2], [579, 2], [643, 2], [707, 2], [771, 2],
-          [835, 2], [899, 2], [963, 2], [1027, 2], [1283, 2], [1539, 2],
-          [1795, 2], [2051, 2], [2307, 2], [2563, 2]
+          [35, 1], [37, 1], [39, 1], [41, 1], [43, 2], [47, 2], [51, 3], [59, 3],
+          [67, 4], [83, 4], [99, 5], [131, 7], [259, 8], [515, 9], [1027, 10],
+          [2051, 11], [4099, 12], [8195, 13], [16387, 14], [32771, 15], [65539, 16]
         ].freeze
 
-        # Predefined FSE distribution for literals length (RFC 8878 Section 4.1.3)
+        # Offset codes (RFC 8878 Section 3.1.2.2.3.2)
+        # OF_BASE[c] + read(c bits) = match distance for c >= 2; codes 0 and
+        # 1 are the repeat-offset specials handled by the executor.
+        OF_BASE = [
+          0, 1, 1, 5, 13, 29, 61, 125, 253, 509, 1021, 2045, 4093, 8189,
+          16381, 32765, 65533, 131069, 262141, 524285, 1048573, 2097149,
+          4194301, 8388605, 16777213, 33554429, 67108861, 134217725,
+          268435453, 536870909, 1073741821, 2147483645
+        ].freeze
+        OF_BITS = (0..31).to_a.freeze
+
+        # Predefined FSE distributions (RFC 8878 Section 4.1.3, matching
+        # the zstd C reference). -1 marks a "less than 1" probability that
+        # occupies a single cell at the top of the table.
         PREDEFINED_LL_DISTRIBUTION = [
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-          0, 0, 0, 0
+          4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
+          2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
+          -1, -1, -1, -1
         ].freeze
 
-        # Predefined FSE distribution for match length (RFC 8878 Section 4.1.3)
-        # Sum = 64 (must equal 2^6 = 64)
+        # Sum: 4+3+2*11+1*3 + 2*8+3+2*2+1*5 = 32 + 32 = 64 = 2^6
         PREDEFINED_ML_DISTRIBUTION = [
           1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-          1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
+          -1, -1, -1, -1, -1
         ].freeze
 
-        # Predefined FSE distribution for offset (RFC 8878 Section 4.1.3)
+        # Sum: 27 positive + 5 low-probability = 32 = 2^5
         PREDEFINED_OFFSET_DISTRIBUTION = [
-          1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0,
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+          1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
+          1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, 0, 0
         ].freeze
+
+        # floor(log2(x)); 0 for x == 0 (C ZSTD_highbit32 defensive value)
+        def self.highbit32(value)
+          value.zero? ? 0 : value.bit_length - 1
+        end
       end
     end
   end

data/lib/omnizip/algorithms/zstandard/decoder.rb

@@ -23,61 +23,57 @@
 module Omnizip
   module Algorithms
     class Zstandard
-      # Pure Ruby Zstandard decoder (RFC 8878)
+      # Pure Ruby Zstandard decoder (RFC 8878).
       #
-      # Decodes Zstandard-compressed data according to RFC 8878.
+      # Pipeline:
       #
-      # Decoder pipeline:
-      # 1. Parse frame header
-      # 2. For each block:
-      #    a. Parse block header
-      #    b. Decode literals section
-      #    c. Decode sequences section
-      #    d. Execute sequences (LZ77 copy operations)
-      # 3. Verify content checksum if present
+      # 1. For each frame: parse the frame header and reset per-frame
+      #    state (repeat offsets, previous Huffman table, previous FSE
+      #    tables).
+      # 2. For each block: parse the 3-byte block header and dispatch on
+      #    the block type (raw copy, RLE expansion, or compressed =
+      #    literals + sequences).
+      # 3. Verify the optional content checksum: the low 32 bits of
+      #    XXHash64 over the decoded frame content.
       class Decoder
         include Constants
 
-        # @return [IO] Input stream
+        # @return [IO] input stream
         attr_reader :input_stream
 
-        # Initialize decoder
-        #
-        # @param input_stream [IO] Input stream of compressed data
         def initialize(input_stream)
           @input_stream = input_stream
-          @repeat_offsets = DEFAULT_REPEAT_OFFSETS.dup
+          @executor = SequenceExecutor.new
           @previous_huffman_table = nil
           @previous_fse_tables = {}
         end
 
-        # Decode compressed data stream
+        # Decode a complete stream (one or more concatenated frames).
         #
-        # @return [String] Decompressed data
+        # @return [String] decompressed data (binary)
         def decode_stream
+          data = read_all
           output = String.new(encoding: Encoding::BINARY)
+          pos = 0
 
           loop do
-            # Read magic number
-            magic = read_u32le
+            remaining = data.bytesize - pos
+            break if remaining.zero?
+            raise Omnizip::DecompressionError, "trailing bytes are not a frame" if remaining < 4
+
+            magic = data.byteslice(pos, 4).unpack1("V")
 
-            # Check for skippable frame
-            if skippable_frame?(magic)
-              skip_frame
+            if (magic & SKIPPABLE_MAGIC_MASK) == SKIPPABLE_MAGIC_BASE
+              pos = skip_skippable_frame(data, pos)
               next
             end
-
-            # Validate magic number
             unless magic == MAGIC_NUMBER
-              raise "Invalid Zstandard magic: 0x#{magic.to_s(16)}"
+              raise Omnizip::DecompressionError,
+                    "invalid Zstandard magic: 0x#{magic.to_s(16)}"
             end
 
-            # Parse frame
-            frame_output = decode_frame
+            frame_output, pos = decode_frame(data, pos + 4)
             output << frame_output
-
-            # Check for more frames
-            break if @input_stream.eof?
           end
 
           output
@@ -85,139 +81,108 @@ module Omnizip
 
         private
 
-        # Check if frame is skippable
-        def skippable_frame?(magic)
-          (magic & SKIPPABLE_MAGIC_MASK) == SKIPPABLE_MAGIC_BASE
+        def read_all
+          data = @input_stream.read
+          data ||= ""
+          data.dup.force_encoding(Encoding::BINARY)
         end
 
-        # Skip skippable frame
-        def skip_frame
-          # Read frame size (4 bytes)
-          size = read_u32le
-          @input_stream.seek(size, IO::SEEK_CUR)
-        end
+        def skip_skippable_frame(data, pos)
+          raise Omnizip::DecompressionError, "truncated skippable frame" if data.bytesize < pos + 8
 
-        # Read unsigned 32-bit little-endian
-        def read_u32le
-          bytes = @input_stream.read(4)
-          return 0 if bytes.nil? || bytes.length < 4
+          size = data.byteslice(pos + 4, 4).unpack1("V")
+          end_pos = pos + 8 + size
+          if data.bytesize < end_pos
+            raise Omnizip::DecompressionError, "truncated skippable frame body"
+          end
 
-          bytes.unpack1("V")
+          end_pos
         end
 
-        # Decode a single frame
-        def decode_frame
-          # Parse frame header
-          header = Frame::Header.parse(@input_stream)
+        # Decode one frame (input positioned after the magic).
+        # Returns [frame_output, pos_after_frame].
+        def decode_frame(data, pos)
+          header, pos = Frame::Header.parse_from(data, pos)
 
-          # Calculate window size
-          calculate_window_size(header)
+          # Reset per-frame state: repeat offsets, previous Huffman
+          # table, previous FSE tables.
+          @executor = SequenceExecutor.new
+          @previous_huffman_table = nil
+          @previous_fse_tables = {}
 
-          # Decode blocks
           output = String.new(encoding: Encoding::BINARY)
-
           loop do
-            block = Frame::Block.parse(@input_stream)
-
-            # Decode block content
-            block_output = decode_block(block, header)
-            output << block_output
+            block, pos = Frame::Block.parse_from(data, pos)
+            if block.reserved?
+              raise Omnizip::DecompressionError,
+                    "reserved block type in frame"
+            end
 
+            pos = decode_block(block, data, pos, output)
             break if block.last_block
           end
 
-          # Verify checksum if present
           if header.content_checksum?
-            verify_checksum(output)
-          end
-
-          output
-        end
+            if data.bytesize < pos + 4
+              raise Omnizip::DecompressionError, "truncated frame checksum"
+            end
 
-        # Calculate window size from header
-        def calculate_window_size(header)
-          return BLOCK_MAX_SIZE if header.single_segment
-          return nil unless header.window_log
+            expected = data.byteslice(pos, 4).unpack1("V")
+            actual = XXHash64.frame_checksum(output)
+            if expected != actual
+              raise Omnizip::DecompressionError,
+                    "frame checksum mismatch: stored 0x#{expected.to_s(16)}, " \
+                    "computed 0x#{actual.to_s(16)}"
+            end
+            pos += 4
+          end
 
-          header.window_size || BLOCK_MAX_SIZE
+          [output, pos]
         end
 
-        # Decode a single block
-        def decode_block(block, _header)
+        def decode_block(block, data, pos, output)
           case block.block_type
           when BLOCK_TYPE_RAW
-            decode_raw_block(block)
-          when BLOCK_TYPE_RLE
-            decode_rle_block(block)
-          when BLOCK_TYPE_COMPRESSED
-            decode_compressed_block(block)
-          else
-            raise "Reserved block type: #{block.block_type}"
-          end
-        end
-
-        # Decode raw (uncompressed) block
-        def decode_raw_block(block)
-          @input_stream.read(block.block_size)
-        end
-
-        # Decode RLE block
-        def decode_rle_block(block)
-          byte = @input_stream.read(1)
-          byte * block.block_size
-        end
-
-        # Decode compressed block
-        def decode_compressed_block(_block)
-          # Record start position for calculating remaining bytes
-          @input_stream.pos
-
-          # Decode literals section
-          literals_decoder = LiteralsDecoder.decode(@input_stream,
-                                                    @previous_huffman_table)
-          literals = literals_decoder.literals
-          @previous_huffman_table = literals_decoder.huffman_table
-
-          # Decode sequences section
-          sequences_decoder = SequencesDecoder.decode(@input_stream,
-                                                      literals.bytesize,
-                                                      @previous_fse_tables)
-          sequences = sequences_decoder.sequences
-
-          # Execute sequences to produce output
-          if sequences.empty?
-            # No sequences - literals are the output
-            literals
-          else
-            SequenceExecutor.execute(literals, sequences)
-          end
-        end
+            if data.bytesize < pos + block.block_size
+              raise Omnizip::DecompressionError, "truncated raw block"
+            end
 
-        # Verify content checksum
-        def verify_checksum(output)
-          # Read checksum (4 bytes)
-          checksum_bytes = @input_stream.read(4)
-          return unless checksum_bytes && checksum_bytes.length == 4
+            output << data.byteslice(pos, block.block_size)
+            pos + block.block_size
+          when BLOCK_TYPE_RLE
+            raise Omnizip::DecompressionError, "truncated RLE block" if data.bytesize < pos + 1
 
-          expected = checksum_bytes.unpack1("V")
-          calculated = xxhash32(output)
+            output << (data.getbyte(pos).chr * block.block_size)
+            pos + 1
+          when BLOCK_TYPE_COMPRESSED
+            block_end = pos + block.block_size
+            if data.bytesize < block_end
+              raise Omnizip::DecompressionError, "truncated compressed block"
+            end
 
-          if calculated != expected
-            warn "Zstandard checksum mismatch (expected #{expected}, got #{calculated})"
+            decode_compressed_block(data.byteslice(pos...block_end), output)
+            block_end
           end
         end
 
-        # Calculate XXHash32 checksum (simplified)
-        def xxhash32(data, seed = 0)
-          # Simplified XXHash32 - for checksum verification only
-          # Full implementation would use proper XXHash32 algorithm
-          hash = seed
-
-          data.each_byte do |byte|
-            hash = ((hash << 5) + hash + byte) & 0xFFFFFFFF
-          end
-
-          hash
+        def decode_compressed_block(block_input, output)
+          literals_decoder = LiteralsDecoder.decode(block_input,
+                                                    @previous_huffman_table)
+          @previous_huffman_table = literals_decoder.huffman_table ||
+            @previous_huffman_table
+
+          sequences_decoder = SequencesDecoder.decode(
+            block_input.byteslice(literals_decoder.consumed..),
+            @previous_fse_tables,
+            @executor,
+          )
+          # Merge: Repeat-mode tables are not re-emitted, so the entries
+          # carried from earlier blocks must survive.
+          @previous_fse_tables =
+            @previous_fse_tables.merge(sequences_decoder.fse_tables)
+
+          @executor.execute(literals_decoder.literals,
+                            sequences_decoder.sequences, output)
         end
       end
     end