omnizip 0.3.52 → 0.3.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8002bf03f99715929f352dfb92a91a10d02f6dac7152006a6cb87ca20b3647ae
-  data.tar.gz: b095258b0b0af358ae9c0a21482a6f8b29de1620bb2162d64dd8794f29eb8f59
+  metadata.gz: 87089cc22eb4f5edd1cb37e7a0de297527fb2f7c0a2815f29d1ff271c73f7461
+  data.tar.gz: e6b7848399a98ae4f38f80cbc71833ada099e071d4f4126437ebbfcca820dc48
 SHA512:
-  metadata.gz: 527be0108ee0fa63b6e7ebafdeaafd05430a17c08e0d59b0f731db7a3b76401da96daec205947c7c3b5baa07aba886515959513ef3d4b31438889761219e958d
-  data.tar.gz: e1f8665f545fc81a4459cbdffbb9e5d5aca219a177a5b2d2ac3bd47c589a2ceb11b02d8cfdc748ac39381417f12682bf53cf14105dcbcd3d04bd59b77d7f9e87
+  metadata.gz: cfd421337992988889d3e5e8d4e85177248c5586238c2c79a5d87e5fc2229de3620f53e93d582ac72992c90b213421b1832cd44ecb9e1ff94e94622a48fa6b88
+  data.tar.gz: 33ca53cfe50c72a1d31afbbf0848ed9559824867edf34f1a4fdc37484300c029fcbf36bdb3135d92f607e31c517d6a519e945065a6c17f817cfbdc0af9ee6de9

data/CHANGELOG.md

@@ -7,6 +7,65 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.53] - 2026-09-01
+
+### Changed
+- The last six hand-rolled `to_h` serializers migrate onto
+  lutaml-model like their siblings: `ConversionResult`,
+  `PerformanceResult`, `ProfileReport` (with a nested Summary model
+  built from aggregates), `OptimizationSuggestion`, `MatchResult`,
+  and `FilterConfig`. Computed report fields (size_reduction,
+  throughput, priority_score, summary aggregates) serialize through
+  lutaml derived attributes keyed under their documented names.
+  Serialized hashes now use string keys (`to_hash`, matching the
+  other migrated models).
+- `Formats::Zip::Reader` gains `read_entry_stream`, yielding bounded
+  chunks (raw copy for STORE, incremental inflater for DEFLATE) with
+  a CRC check after the last chunk. `Chunked.decompress_file`
+  streams through it — the memory-efficient path no longer holds the
+  whole decompressed entry in memory to slice it. Extracting a
+  single 7z entry in memory (`MemoryExtractor`) extracts just that
+  entry instead of decompressing the entire archive.
+
+### Fixed
+- Boundary errors stop masquerading as bare RuntimeErrors:
+  `Checksums::Verifier` raises `UnknownChecksumError` (the class
+  existed unused), and thirty more `raise "string"` sites gained
+  their matching classes (`Errno::ENOENT` for missing entries
+  — matching the handler-registry convention — `Errno::EEXIST`,
+  `IOError`, `InvalidArchiveError`, `DecompressionError`,
+  `RarNotAvailableError`). The never-called placeholder
+  `decode_escape_code` in the RAR PPMd decoder is deleted.
+
+## [0.3.52] - 2026-09-01
+
+### Changed
+- The extract command's pattern path opens archives through the
+  Archive facade instead of a hand-rolled extension `case` that
+  misrouted `.cpio`/`.iso`/`.rpm` files into the 7z reader — pattern
+  extraction now works for every routed format. The metadata
+  command's 7z view lists through the handler registry (the detail
+  contract gains `:crc`), and SafeExtract extracts through
+  `extract_archive`, so every routed format gets rollback and
+  verification instead of ZIP-only with a `NotImplementedError`
+  for 7z. SelectiveExtractor understands both entry contracts
+  (legacy `entry_name` and reader-session `name`) and skips
+  directory entries when extracting.
+- `CliOutputFormatter.format_size` is now the single byte formatter;
+  the nine private `format_bytes`/`format_size` copies (four
+  different shapes, two unit ceilings) become delegators.
+
+### Fixed
+- The long-deferred parity spec flake: `Par2Verifier` crashed five
+  frames deep on a nil PAR2 path (`File.exist?(nil)` → TypeError)
+  where the repairer already raised a clean ArgumentError; the
+  verifier now mirrors it, and the spec's `.verify` group gains the
+  nil-index fallback `.repair` already had. The dead shadowed
+  `analyze_file` definition in `Par2Creator` (silently overridden
+  by a second definition with a divergent file_id format) is
+  deleted. The tautological "LZMA2 is implicit" xz assertion became
+  a real block-header parse asserting the explicit 0x21 filter ID.
+
 ## [0.3.51] - 2026-09-01
 
 ### Changed

data/lib/omnizip/archive_handlers/zip_handler.rb

@@ -38,7 +38,7 @@ module Omnizip
           extracted = []
           reader.entries.each do |entry|
             dest_path = ::File.join(output_dir, entry.filename)
-            raise "File exists: #{dest_path}" if ::File.exist?(dest_path)
+            raise Errno::EEXIST, "File exists: #{dest_path}" if ::File.exist?(dest_path)
 
             reader.extract_entry(entry, output_dir)
             extracted << dest_path

data/lib/omnizip/buffer/memory_archive.rb

@@ -9,27 +9,24 @@ module Omnizip
     # (for creating) and InputStream (for reading).
     #
     # @example Creating an archive
-    #   buffer = StringIO.new
-    #   Omnizip::Zip::OutputStream.open(buffer) do |zos|
-    #     archive = MemoryArchive.new(zos, :zip)
-    #     archive.add('file.txt', 'content')
-    #   end
+    #   writer = Formats::Zip::Writer.new(nil)
+    #   archive = MemoryArchive.new(writer, :zip)
+    #   archive.add('file.txt', 'content')
+    #   writer.write_to_io(buffer)
     #
     # @example Reading an archive
-    #   Omnizip::Zip::InputStream.open(buffer) do |zis|
-    #     archive = MemoryArchive.new(zis, :zip)
-    #     archive.each_entry do |entry|
-    #       puts entry.name
-    #     end
+    #   archive = MemoryArchive.new(Formats::Zip::Reader.new(path), :zip)
+    #   archive.each_entry do |entry|
+    #     puts entry.name
     #   end
     class MemoryArchive
       attr_reader :format, :stream
 
       # Initialize memory archive wrapper
       #
-      # @param stream [Omnizip::Zip::OutputStream, Omnizip::Zip::InputStream]
-      #   Underlying stream
-      # @param format [Symbol] Archive format (:zip, :seven_zip)
+      # @param stream [Formats::Zip::Writer, Formats::Zip::Reader]
+      #   Native writer (write mode) or reader (read mode)
+      # @param format [Symbol] Archive format (:zip)
       def initialize(stream, format)
         @stream = stream
         @format = format
@@ -57,13 +54,13 @@ module Omnizip
       def add(name, data, **options)
         ensure_write_mode!
 
-        case stream
-        when Omnizip::Zip::OutputStream
-          stream.put_next_entry(name, **options)
-          stream.write(data) unless name.end_with?("/")
+        if name.end_with?("/") && data.to_s.empty?
+          stream.add_directory(name)
         else
-          raise NotImplementedError,
-                "Unsupported stream type: #{stream.class}"
+          method = if options[:compression] == :store
+                     Formats::Zip::Constants::COMPRESSION_STORE
+                   end
+          stream.add_data(name, data, nil, compression_method: method)
         end
 
         self
@@ -101,15 +98,8 @@ module Omnizip
       def each_entry
         ensure_read_mode!
 
-        case stream
-        when Omnizip::Zip::InputStream
-          while (zip_entry = stream.get_next_entry)
-            entry = Entry.new(zip_entry, stream)
-            yield(entry)
-          end
-        else
-          raise NotImplementedError,
-                "Unsupported stream type: #{stream.class}"
+        stream.entries.each do |zip_entry|
+          yield(Entry.new(zip_entry, stream))
         end
       end
 
@@ -142,22 +132,10 @@ module Omnizip
       def to_s
         ensure_write_mode!
 
-        case stream
-        when Omnizip::Zip::OutputStream
-          # OutputStream wraps the IO, we need to get the underlying buffer
-          # This is only safe after close
-          unless stream.closed?
-            raise "Archive must be closed before accessing data"
-          end
-
-          # The buffer was passed in during creation, but we don't have
-          # direct access. This method should be called on the StringIO
-          # returned by Buffer.create instead.
-          raise NotImplementedError,
-                "Use Buffer.create return value instead"
-        else
-          raise "Cannot get string from read mode archive"
-        end
+        # The buffer is owned by Buffer.create; this method should be
+        # called on the StringIO it returns instead.
+        raise NotImplementedError,
+              "Use Buffer.create return value instead"
       end
 
       # Entry wrapper with read capability
@@ -169,17 +147,19 @@ module Omnizip
 
         # Initialize entry wrapper
         #
-        # @param entry [Omnizip::Zip::Entry] Underlying entry
-        # @param stream [Omnizip::Zip::InputStream] Stream to read from
-        def initialize(entry, stream)
+        # @param entry [Formats::Zip::CentralDirectoryHeader] entry
+        # @param reader [Formats::Zip::Reader] Native archive reader
+        def initialize(entry, reader)
           @entry = entry
-          @stream = stream
-          @name = entry.name
-          @size = entry.size
+          @reader = reader
+          @name = entry.filename
+          @size = entry.uncompressed_size
           @compressed_size = entry.compressed_size
           @time = entry.time
-          @comment = entry.comment
+          @comment = entry.comment.to_s
           @directory = entry.directory?
+          @content = nil
+          @pos = 0
         end
 
         # Read entry content
@@ -195,7 +175,20 @@ module Omnizip
         #     process_chunk(chunk)
         #   end
         def read(size = nil)
-          @stream.read(size)
+          # IO-like streaming semantics: successive reads return
+          # successive chunks, nil at end-of-content. Callers like
+          # Pipe::StreamDecompressor loop on this — a read that
+          # always returns data would loop forever.
+          @content ||= @reader.read_entry(@name)
+          return nil if @pos >= @content.bytesize
+
+          chunk = if size
+                    @content.byteslice(@pos, size)
+                  else
+                    @content.byteslice(@pos, @content.bytesize - @pos)
+                  end
+          @pos += chunk.bytesize
+          chunk
         end
 
         # Check if entry is a directory
@@ -229,22 +222,24 @@ module Omnizip
 
       private
 
-      # Ensure stream is in write mode (OutputStream)
+      # Ensure stream is in write mode (native Writer)
       #
-      # @raise [RuntimeError] If not in write mode
+      # @raise [Omnizip::IOError] If not in write mode
       def ensure_write_mode!
-        return if stream.is_a?(Omnizip::Zip::OutputStream)
+        return if stream.is_a?(Omnizip::Formats::Zip::Writer)
 
-        raise "Operation requires write mode (OutputStream)"
+        raise Omnizip::IOError,
+              "Operation requires write mode (Formats::Zip::Writer)"
       end
 
-      # Ensure stream is in read mode (InputStream)
+      # Ensure stream is in read mode (native Reader)
       #
-      # @raise [RuntimeError] If not in read mode
+      # @raise [Omnizip::IOError] If not in read mode
       def ensure_read_mode!
-        return if stream.is_a?(Omnizip::Zip::InputStream)
+        return if stream.is_a?(Omnizip::Formats::Zip::Reader)
 
-        raise "Operation requires read mode (InputStream)"
+        raise Omnizip::IOError,
+              "Operation requires read mode (Formats::Zip::Reader)"
       end
     end
   end

data/lib/omnizip/buffer/memory_extractor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "tmpdir"
 
 module Omnizip
   module Buffer
@@ -151,38 +152,36 @@ module Omnizip
 
       private
 
-      # Detect archive format from magic bytes
+      # Delegate to the shared buffer-side sniffer
       #
       # @return [Symbol] Detected format
       # @raise [Omnizip::FormatError] If format cannot be detected
       def detect_format
-        magic = @buffer.read(4).to_s.b
-        @buffer.rewind
+        Omnizip::Buffer.detect_format(@buffer)
+      end
 
-        case magic
-        when "PK\x03\x04".b, "PK\x05\x06".b, "PK\x07\x08".b
-          # ZIP signatures: local file header, EOCD, data descriptor
-          :zip
-        when "7z\xBC\xAF".b
-          :seven_zip
-        else
-          raise Omnizip::FormatError,
-                "Unknown archive format (magic: #{magic.inspect})"
+      # The native ZIP reader parses from a path; spill the buffer to
+      # a temporary file and yield a reader over it.
+      def with_zip_reader
+        @buffer.rewind
+        Dir.mktmpdir("omnizip_extractor_zip") do |tmp|
+          path = File.join(tmp, "buffer.zip")
+          File.binwrite(path, @buffer.read)
+          yield Omnizip::Formats::Zip::Reader.new(path)
         end
       end
 
-      # Extract all entries from ZIP
+      # Extract all entries from ZIP through the native reader
       #
       # @param result [Hash] Hash to populate with entries
       def extract_all_zip(result)
-        @buffer.rewind
-        Omnizip::Zip::InputStream.open(@buffer) do |zis|
-          while (entry = zis.get_next_entry)
+        with_zip_reader do |reader|
+          reader.entries.each do |entry|
             next if entry.directory?
 
-            content = zis.read
-            result[entry.name] = content
-            @extracted_cache[entry.name] = content
+            content = reader.read_entry(entry.filename)
+            result[entry.filename] = content
+            @extracted_cache[entry.filename] = content
           end
         end
       end
@@ -207,41 +206,27 @@ module Omnizip
       def extract_entry_seven_zip(name)
         @buffer.rewind
         SevenZipBridge.open(@buffer) do |archive|
-          entry = archive.raw_entries.find { |e| e.name == name }
-          archive.extract_all_to_memory[name] if entry
+          archive.read_entry(name)
         end
       end
 
-      # Extract single entry from ZIP
+      # Extract single entry from ZIP through the native reader
       #
       # @param name [String] Entry name
       # @return [String, nil] Entry content or nil if not found
       def extract_entry_zip(name)
-        @buffer.rewind
-        content = nil
-
-        Omnizip::Zip::InputStream.open(@buffer) do |zis|
-          while (entry = zis.get_next_entry)
-            if entry.name == name
-              content = zis.read unless entry.directory?
-              break
-            end
-          end
+        with_zip_reader do |reader|
+          entry = reader.entries.find { |e| e.filename == name }
+          reader.read_entry(name) if entry && !entry.directory?
         end
-
-        content
       end
 
-      # List all entry names from ZIP
+      # List all entry names from ZIP through the native reader
       #
       # @param names [Array] Array to populate with names
       def list_entries_zip(names)
-        @buffer.rewind
-
-        Omnizip::Zip::InputStream.open(@buffer) do |zis|
-          while (entry = zis.get_next_entry)
-            names << entry.name
-          end
+        with_zip_reader do |reader|
+          reader.entries.each { |entry| names << entry.filename }
         end
       end
     end

data/lib/omnizip/buffer/seven_zip_bridge.rb

@@ -112,6 +112,19 @@ module Omnizip
           @reader.list_files
         end
 
+        # Content of a single named file entry, or nil when absent
+        # (directories carry no content). Extracts just that entry —
+        # not the whole archive.
+        #
+        # @param name [String] Entry name
+        # @return [String, nil]
+        def read_entry(name)
+          entry = raw_entries.find { |e| e.name == name && !e.is_dir }
+          return nil unless entry
+
+          Entry.new(entry, @reader, @tmp).read
+        end
+
         # Entry wrapper matching MemoryArchive::Entry's surface
         class Entry
           attr_reader :name, :size

data/lib/omnizip/buffer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "tmpdir"
 
 module Omnizip
   # In-memory archive operations without filesystem I/O
@@ -107,27 +108,9 @@ module Omnizip
         extractor.extract_all
       end
 
-      # Create archive from Hash of filename => content
-      #
-      # @param hash [Hash<String, String>] Filename => content mapping
-      # @param format [Symbol] Archive format
-      # @param options [Hash] Format-specific options
-      # @return [StringIO] Complete archive in memory
-      #
-      # @example Create from Hash
-      #   data = {'file1.txt' => 'content1', 'file2.txt' => 'content2'}
-      #   zip = Omnizip::Buffer.create_from_hash(data, :zip)
-      def create_from_hash(hash, format = :zip, **options)
-        create(format, **options) do |archive|
-          hash.each do |name, content|
-            archive.add(name, content)
-          end
-        end
-      end
-
-      private
-
-      # Detect archive format from magic bytes
+      # Detect archive format from magic bytes. THE buffer-side
+      # sniffer — in-memory data has no extension to route by, so
+      # every consumer delegates here.
       #
       # @param buffer [StringIO] Buffer containing archive data
       # @return [Symbol] Detected format
@@ -148,27 +131,53 @@ module Omnizip
         end
       end
 
-      # Create ZIP archive in buffer
+      # Create archive from Hash of filename => content
+      #
+      # @param hash [Hash<String, String>] Filename => content mapping
+      # @param format [Symbol] Archive format
+      # @param options [Hash] Format-specific options
+      # @return [StringIO] Complete archive in memory
+      #
+      # @example Create from Hash
+      #   data = {'file1.txt' => 'content1', 'file2.txt' => 'content2'}
+      #   zip = Omnizip::Buffer.create_from_hash(data, :zip)
+      def create_from_hash(hash, format = :zip, **options)
+        create(format, **options) do |archive|
+          hash.each do |name, content|
+            archive.add(name, content)
+          end
+        end
+      end
+
+      private
+
+      # Create ZIP archive in buffer through the native writer
       #
       # @param buffer [StringIO] Buffer to write to
       # @param options [Hash] ZIP-specific options
       # @yield [archive] Block to populate archive
       def create_zip(buffer, _options, &block)
-        Omnizip::Zip::OutputStream.open(buffer) do |zos|
-          archive = Buffer::MemoryArchive.new(zos, :zip)
-          block&.call(archive)
-        end
+        writer = Formats::Zip::Writer.new(nil)
+        archive = Buffer::MemoryArchive.new(writer, :zip)
+        block&.call(archive)
+        writer.write_to_io(buffer)
       end
 
-      # Open ZIP archive from buffer
+      # Open ZIP archive from buffer through the native reader.
+      # The reader parses from a path, so the buffer spills to a
+      # temporary file (same pattern as the 7z bridge).
       #
       # @param buffer [StringIO] Buffer containing ZIP data
       # @yield [archive] Block to read from archive
       # @return [MemoryArchive, Object] Archive or block return value
       def open_zip(buffer, &block)
         result = nil
-        Omnizip::Zip::InputStream.open(buffer) do |zis|
-          archive = Buffer::MemoryArchive.new(zis, :zip)
+        Dir.mktmpdir("omnizip_buffer_zip") do |tmp|
+          path = File.join(tmp, "buffer.zip")
+          File.binwrite(path, buffer.string)
+
+          archive = Buffer::MemoryArchive.new(Formats::Zip::Reader.new(path),
+                                              :zip)
           result = block ? yield(archive) : archive
         end
         result

data/lib/omnizip/checksums/verifier.rb

@@ -94,7 +94,7 @@ module Omnizip
         when CHECK_SHA256
           verify_sha256(data, expected)
         else
-          raise "Unknown check type: #{check_type}"
+          raise Omnizip::UnknownChecksumError, "Unknown check type: #{check_type}"
         end
       end
 
@@ -122,7 +122,7 @@ module Omnizip
         when CHECK_SHA256
           Digest::SHA256.digest(data)
         else
-          raise "Unknown check type: #{check_type}"
+          raise Omnizip::UnknownChecksumError, "Unknown check type: #{check_type}"
         end
       end
     end

data/lib/omnizip/chunked.rb

@@ -95,30 +95,23 @@ module Omnizip
                 "Input archive not found: #{input}"
         end
 
-        writer = Writer.new(output, chunk_size: chunk_size)
-        processed = 0
-
-        Omnizip::Zip::File.open(input) do |zip|
-          entry = zip.entries.first
-          total_size = entry.size
-
-          # Read the full entry content
-          content = zip.get_input_stream(entry)
+        reader = Omnizip::Formats::Zip::Reader.new(input)
+        entry = reader.entries.first
+        raise Omnizip::Error, "No entries to decompress in #{input}" unless entry
 
-          # Write in chunks
-          offset = 0
-          while offset < content.bytesize
-            chunk = content.byteslice(offset, chunk_size) || ""
-            break if chunk.empty?
+        total_size = entry.uncompressed_size.to_i
+        processed = 0
+        writer = Writer.new(output, chunk_size: chunk_size)
 
-            writer.write_chunk(chunk)
-            processed += chunk.bytesize
-            offset += chunk.bytesize
+        # Streams entry-by-entry in bounded memory — the whole entry
+        # is never held at once
+        reader.read_entry_stream(entry.filename, chunk_size: chunk_size) do |chunk|
+          writer.write_chunk(chunk)
+          processed += chunk.bytesize
 
-            if progress
-              percentage = (processed.to_f / total_size * 100).round(2)
-              progress.call(processed, total_size, percentage)
-            end
+          if progress
+            percentage = (processed.to_f / total_size * 100).round(2)
+            progress.call(processed, total_size, percentage)
           end
         end
 

data/lib/omnizip/formats/cpio/reader.rb

@@ -64,7 +64,7 @@ module Omnizip
         # @raise [RuntimeError] if entry not found
         def extract_entry(entry_name, output_path)
           entry = @entries.find { |e| e.name == entry_name }
-          raise "Entry not found: #{entry_name}" unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
 
           extract_single_entry(entry, output_path)
         end

data/lib/omnizip/formats/iso/reader.rb

@@ -67,7 +67,7 @@ module Omnizip
         # @param output_path [String] Destination path
         def extract_entry(entry_path, output_path)
           entry = find_entry(entry_path)
-          raise "Entry not found: #{entry_path}" unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_path}" unless entry
 
           if entry.directory?
             FileUtils.mkdir_p(output_path)
@@ -111,7 +111,7 @@ module Omnizip
           loop do
             @io.seek(sector * Iso::SECTOR_SIZE)
             data = @io.read(Iso::SECTOR_SIZE)
-            raise "Failed to read volume descriptor" unless data
+            raise Omnizip::InvalidArchiveError, "Failed to read volume descriptor" unless data
 
             vd = VolumeDescriptor.parse(data)
 
@@ -127,7 +127,7 @@ module Omnizip
 
           return if @primary_volume_descriptor
 
-          raise "No primary volume descriptor found"
+          raise Omnizip::InvalidArchiveError, "No primary volume descriptor found"
         end
 
         # Parse directory structure

data/lib/omnizip/formats/iso/volume_descriptor.rb

@@ -29,7 +29,7 @@ module Omnizip
         #
         # @param data [String] Binary data
         def parse(data)
-          raise "Invalid volume descriptor size" unless data.bytesize >= 2048
+          raise Omnizip::InvalidArchiveError, "Invalid volume descriptor size" unless data.bytesize >= 2048
 
           # Byte 0: Volume descriptor type
           @type = data.getbyte(0)
@@ -37,7 +37,7 @@ module Omnizip
           # Bytes 1-5: Standard identifier "CD001"
           @identifier = data[1, 5]
           unless @identifier == ISO_IDENTIFIER
-            raise "Invalid ISO identifier: expected #{ISO_IDENTIFIER}, got #{@identifier}"
+            raise Omnizip::InvalidArchiveError, "Invalid ISO identifier: expected #{ISO_IDENTIFIER}, got #{@identifier}"
           end
 
           # Byte 6: Version (should be 1)

data/lib/omnizip/formats/rar/compression/ppmd/decoder.rb

@@ -230,26 +230,6 @@ module Omnizip
               # Decode as 8 direct bits
               @range_decoder.decode_direct_bits(8)
             end
-
-            # Decode RAR-specific escape code
-            #
-            # RAR variant H uses different escape code values
-            # and handling compared to standard PPMd7.
-            #
-            # Escape codes in RAR:
-            # - 0: New symbol follows
-            # - 1: Same as last symbol (run-length)
-            # - 2-255: Reserved for future use
-            #
-            # @return [Integer, nil] Escape code or nil
-            def decode_escape_code
-              # RAR escape codes differ from PPMd7
-              # This is a placeholder for the proper implementation
-
-              # For now, return 0 (new symbol follows)
-              # Real implementation would decode from range coder
-              0
-            end
           end
         end
       end