omnizip 0.3.53 → 0.3.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7e72a57eaeb6e597e40020de67aa0242da65c6e6e8ceaa933d779d926e55666
-  data.tar.gz: 105cf4f238610f518462c115d398403fef5daca9b2994788361b027c7c5ec648
+  metadata.gz: 87089cc22eb4f5edd1cb37e7a0de297527fb2f7c0a2815f29d1ff271c73f7461
+  data.tar.gz: e6b7848399a98ae4f38f80cbc71833ada099e071d4f4126437ebbfcca820dc48
 SHA512:
-  metadata.gz: a5301b14047d1150885624527d03176c61a979464b7a16329a47449e13fe05679c1e5ce11a650bfd29101aaaf502b5ab81513558fc080dca85554266ae30f8dc
-  data.tar.gz: a44ffd04cc02fa03e2b23a330da4f6612d268bfd350d9b9672e42d7a107dcad65201ed9707651b3533fdd790a5841a5ff9297d6f3a8e937b51e0f1614d756c55
+  metadata.gz: cfd421337992988889d3e5e8d4e85177248c5586238c2c79a5d87e5fc2229de3620f53e93d582ac72992c90b213421b1832cd44ecb9e1ff94e94622a48fa6b88
+  data.tar.gz: 33ca53cfe50c72a1d31afbbf0848ed9559824867edf34f1a4fdc37484300c029fcbf36bdb3135d92f607e31c517d6a519e945065a6c17f817cfbdc0af9ee6de9

data/CHANGELOG.md

@@ -7,6 +7,36 @@ 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

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
@@ -159,18 +160,28 @@ module Omnizip
         Omnizip::Buffer.detect_format(@buffer)
       end
 
-      # Extract all entries from ZIP
+      # 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 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
@@ -199,36 +210,23 @@ module Omnizip
         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.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "tmpdir"
 
 module Omnizip
   # In-memory archive operations without filesystem I/O
@@ -150,27 +151,33 @@ module Omnizip
 
       private
 
-      # Create ZIP archive in buffer
+      # 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/formats/seven_zip/bcj2_stream_decompressor.rb

@@ -46,7 +46,7 @@ module Omnizip
           bcj2_coder = @folder.coders.find { |c| c.method_id == FilterId::BCJ2 }
           compression_coder = find_compression_coder
 
-          raise "BCJ2 coder not found" unless bcj2_coder
+          raise Omnizip::InvalidArchiveError, "BCJ2 coder not found" unless bcj2_coder
 
           # Determine stream layout based on folder structure
           # BCJ2 has 4 input streams: main, call, jump, rc
@@ -217,7 +217,7 @@ module Omnizip
           return packed_data unless algo_sym
 
           algo_class = Omnizip::AlgorithmRegistry.get(algo_sym)
-          raise "Algorithm not found: #{algo_sym}" unless algo_class
+          raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{algo_sym}" unless algo_class
 
           # Build decoder options
           options = build_decoder_options(coder, algo_sym)

data/lib/omnizip/formats/seven_zip/coder_chain.rb

@@ -20,7 +20,7 @@ module Omnizip
           # Find the compression method (not a filter) among coders
           # Filters like BCJ, BCJ2 have specific method IDs
           main_coder = find_compression_coder(folder.coders)
-          raise "No compression method found in folder" unless main_coder
+          raise Omnizip::InvalidArchiveError, "No compression method found in folder" unless main_coder
 
           algorithm = algorithm_for_method(main_coder.method_id)
 
@@ -82,8 +82,8 @@ module Omnizip
           when MethodId::DEFLATE64
             :deflate64
           else
-            raise "Unsupported compression method: " \
-                  "0x#{method_id.to_s(16)}"
+            raise Omnizip::UnsupportedFormatError, "Unsupported compression method: " \
+                                                   "0x#{method_id.to_s(16)}"
           end
         end
 
@@ -126,7 +126,7 @@ module Omnizip
           # Get algorithm
           algo_class = AlgorithmRegistry.get(chain_config[:algorithm])
           unless algo_class
-            raise "Algorithm not found: #{chain_config[:algorithm]}"
+            raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{chain_config[:algorithm]}"
           end
 
           # Create algorithm instance
@@ -143,7 +143,7 @@ module Omnizip
             pipeline = FilterPipeline.new
             chain_config[:filters].each do |filter_sym|
               filter_class = FilterRegistry.get(filter_sym)
-              raise "Filter not found: #{filter_sym}" unless filter_class
+              raise Omnizip::UnknownFilterError, "Filter not found: #{filter_sym}" unless filter_class
 
               pipeline.add_filter(filter_class.new)
             end

data/lib/omnizip/formats/seven_zip/encrypted_header.rb

@@ -69,7 +69,7 @@ module Omnizip
         # @return [EncryptedHeader] Parsed header
         # @raise [RuntimeError] if data is invalid
         def self.from_binary(data)
-          raise "Invalid encrypted header: too short" if data.bytesize < 54
+          raise Omnizip::InvalidArchiveError, "Invalid encrypted header: too short" if data.bytesize < 54
 
           pos = 0
 
@@ -77,7 +77,7 @@ module Omnizip
           marker = data.getbyte(pos)
           pos += 1
           unless marker == PropertyId::ENCODED_HEADER
-            raise "Invalid encrypted header marker: expected #{PropertyId::ENCODED_HEADER}, got #{marker}"
+            raise Omnizip::InvalidArchiveError, "Invalid encrypted header marker: expected #{PropertyId::ENCODED_HEADER}, got #{marker}"
           end
 
           # Read encrypted data size

data/lib/omnizip/formats/seven_zip/file_collector.rb

@@ -23,7 +23,7 @@ module Omnizip
         # @param recursive [Boolean] Recursively add directories
         def add_path(path, archive_path: nil, recursive: true)
           path = File.expand_path(path)
-          raise "Path not found: #{path}" unless File.exist?(path)
+          raise Errno::ENOENT, "Path not found: #{path}" unless File.exist?(path)
 
           @base_path ||= File.dirname(path)
 

data/lib/omnizip/formats/seven_zip/header.rb

@@ -29,14 +29,14 @@ module Omnizip
         def parse(io)
           # Read complete start header (32 bytes)
           header_data = io.read(START_HEADER_SIZE)
-          raise "Invalid .7z file: too short" if header_data.nil? ||
+          raise Omnizip::InvalidArchiveError, "Invalid .7z file: too short" if header_data.nil? ||
             header_data.bytesize < START_HEADER_SIZE
 
           # Validate signature
           signature = header_data[0, SIGNATURE_SIZE]
           unless signature == SIGNATURE
-            raise "Invalid .7z signature: expected #{SIGNATURE.inspect}, " \
-                  "got #{signature.inspect}"
+            raise Omnizip::InvalidArchiveError, "Invalid .7z signature: expected #{SIGNATURE.inspect}, " \
+                                                "got #{signature.inspect}"
           end
 
           # Parse version
@@ -44,7 +44,7 @@ module Omnizip
           @minor_version = header_data.getbyte(7)
 
           unless @major_version == MAJOR_VERSION
-            raise "Unsupported .7z version: #{@major_version}.#{@minor_version}"
+            raise Omnizip::UnsupportedFormatError, "Unsupported .7z version: #{@major_version}.#{@minor_version}"
           end
 
           # Parse start header CRC (bytes 8-11)

data/lib/omnizip/formats/seven_zip/header_encryptor.rb

@@ -83,9 +83,9 @@ module Omnizip
           begin
             decipher.update(encrypted_data) + decipher.final
           rescue OpenSSL::Cipher::CipherError => e
-            raise "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
+            raise Omnizip::PasswordError, "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
           rescue StandardError => e
-            raise "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
+            raise Omnizip::PasswordError, "Failed to decrypt header: incorrect password or corrupted data (#{e.message})"
           end
         end
 

data/lib/omnizip/formats/seven_zip/parser.rb

@@ -82,7 +82,7 @@ module Omnizip
           end
 
           value = read_number
-          raise "Unsupported 32-bit value" if value >= 0x80000000
+          raise Omnizip::InvalidArchiveError, "Unsupported 32-bit value" if value >= 0x80000000
 
           value
         end
@@ -233,7 +233,7 @@ module Omnizip
           end
 
           # Verify required SIZE property was present
-          raise "Missing SIZE property in pack info" unless sizes_read
+          raise Omnizip::InvalidArchiveError, "Missing SIZE property in pack info" unless sizes_read
 
           # K_END is optional in some 7-Zip versions
           read_byte if !eof? && peek_byte == PropertyId::K_END
@@ -259,7 +259,7 @@ module Omnizip
             end
           else
             # External folders not supported
-            raise "External folders not supported"
+            raise Omnizip::UnsupportedFormatError, "External folders not supported"
           end
         end
 
@@ -268,7 +268,7 @@ module Omnizip
         # @param folder [Models::Folder] Folder to populate
         def read_folder(folder)
           num_coders = read_number
-          raise "Too many coders" if num_coders > Constants::MAX_NUM_CODERS
+          raise Omnizip::InvalidArchiveError, "Too many coders" if num_coders > Constants::MAX_NUM_CODERS
 
           num_in_streams = 0
           num_out_streams = 0
@@ -386,8 +386,8 @@ module Omnizip
           end
 
           # Verify required properties were present
-          raise "Missing FOLDER property in unpack info" unless folders_read
-          raise "Missing CODERS_UNPACK_SIZE property in unpack info" unless unpack_sizes_read
+          raise Omnizip::InvalidArchiveError, "Missing FOLDER property in unpack info" unless folders_read
+          raise Omnizip::InvalidArchiveError, "Missing CODERS_UNPACK_SIZE property in unpack info" unless unpack_sizes_read
 
           # K_END is optional in some 7-Zip versions
           read_byte if !eof? && peek_byte == PropertyId::K_END
@@ -611,8 +611,8 @@ module Omnizip
           actual = read_byte
           return if actual == expected
 
-          raise "Expected property 0x#{expected.to_s(16)}, " \
-                "got 0x#{actual.to_s(16)}"
+          raise Omnizip::InvalidArchiveError, "Expected property 0x#{expected.to_s(16)}, " \
+                                              "got 0x#{actual.to_s(16)}"
         end
 
         # Skip size field

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

@@ -223,18 +223,13 @@ module Omnizip
                 EncryptedHeader.from_binary(next_header_data)
                 # If we got here, it's encrypted - try to decrypt
                 next_header_data = decrypt_header(next_header_data)
-              rescue RuntimeError => e
-                # Re-raise password-related errors
-                if e.message.include?("Password required") || e.message.include?("incorrect password")
-                  raise
-                end
-
-                # Not encrypted - it's a compressed header
-                # Decompress it using the encoded stream info
-                next_header_data = decompress_encoded_header(io,
-                                                             next_header_data)
+              rescue Omnizip::PasswordError
+                # Decryption refused or failed — a password problem,
+                # never a compressed header
+                raise
               rescue StandardError
-                # Parsing error - not an encrypted header, try decompression
+                # Not an encrypted header — it's a compressed header;
+                # decompress it using the encoded stream info
                 next_header_data = decompress_encoded_header(io,
                                                              next_header_data)
               end
@@ -250,8 +245,8 @@ module Omnizip
             @stream_info, @entries = parse_metadata(parser)
           rescue StandardError => e
             if @headers_decrypted
-              raise "Failed to decrypt headers: incorrect password " \
-                    "or corrupted data (#{e.message})"
+              raise Omnizip::PasswordError, "Failed to decrypt headers: incorrect password " \
+                                            "or corrupted data (#{e.message})"
             end
 
             raise
@@ -271,7 +266,7 @@ module Omnizip
           @encrypted_header = EncryptedHeader.from_binary(encrypted_data)
 
           unless @password
-            raise "Archive headers are encrypted. Password required to access."
+            raise Omnizip::PasswordError, "Archive headers are encrypted. Password required to access."
           end
 
           # Decrypt using password
@@ -287,7 +282,7 @@ module Omnizip
           @headers_decrypted = true
           decrypted
         rescue OpenSSL::Cipher::CipherError => e
-          raise "Failed to decrypt headers: incorrect password (#{e.message})"
+          raise Omnizip::PasswordError, "Failed to decrypt headers: incorrect password (#{e.message})"
         end
 
         # Decompress encoded (compressed) header
@@ -317,7 +312,7 @@ module Omnizip
               parser.read_unpack_info(stream_info)
             end
           else
-            raise "Unexpected property in encoded header: 0x#{type.to_s(16)}"
+            raise Omnizip::InvalidArchiveError, "Unexpected property in encoded header: 0x#{type.to_s(16)}"
           end
 
           # Decompress the header using the stream info
@@ -341,7 +336,7 @@ module Omnizip
 
           # Read main header
           type = parser.read_byte
-          raise "Expected Header, got 0x#{type.to_s(16)}" unless
+          raise Omnizip::InvalidArchiveError, "Expected Header, got 0x#{type.to_s(16)}" unless
             type == PropertyId::HEADER
 
           # Parse header sections
@@ -529,7 +524,7 @@ module Omnizip
             crc = Omnizip::Checksums::Crc32.new
             crc.update(data)
             unless crc.value == entry.crc
-              raise "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+              raise Omnizip::ChecksumError, "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
             end
           end
 
@@ -589,7 +584,7 @@ module Omnizip
               crc = Omnizip::Checksums::Crc32.new
               crc.update(data)
               unless crc.value == entry.crc
-                raise "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+                raise Omnizip::ChecksumError, "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
               end
             end
 

data/lib/omnizip/formats/seven_zip/split_archive_reader.rb

@@ -167,7 +167,7 @@ module Omnizip
             volume_num += 1
           end
 
-          raise "No volumes found for #{@base_path}" if @volumes.empty?
+          raise Errno::ENOENT, "No volumes found for #{@base_path}" if @volumes.empty?
         end
 
         # Detect volumes with alpha naming (.aa, .ab, ...)
@@ -185,7 +185,7 @@ module Omnizip
             volume_num += 1
           end
 
-          raise "No volumes found for #{@base_path}" if @volumes.empty?
+          raise Errno::ENOENT, "No volumes found for #{@base_path}" if @volumes.empty?
         end
 
         # Open all volume files
@@ -293,7 +293,7 @@ module Omnizip
 
           # Read main header
           type = parser.read_byte
-          raise "Expected Header, got 0x#{type.to_s(16)}" unless
+          raise Omnizip::InvalidArchiveError, "Expected Header, got 0x#{type.to_s(16)}" unless
             type == PropertyId::HEADER
 
           # Parse header sections
@@ -372,7 +372,7 @@ module Omnizip
               parser.read_unpack_info(stream_info)
             end
           else
-            raise "Unexpected property in encoded header: 0x#{type.to_s(16)}"
+            raise Omnizip::InvalidArchiveError, "Unexpected property in encoded header: 0x#{type.to_s(16)}"
           end
 
           # Decompress the header using the stream info
@@ -491,7 +491,7 @@ module Omnizip
               crc = Omnizip::Checksums::Crc32.new
               crc.update(data)
               unless crc.value == entry.crc
-                raise "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
+                raise Omnizip::ChecksumError, "CRC mismatch for #{entry.name}: expected 0x#{entry.crc.to_s(16)}, got 0x#{crc.value.to_s(16)}"
               end
             end
 

data/lib/omnizip/formats/seven_zip/stream_compressor.rb

@@ -44,7 +44,7 @@ module Omnizip
           # Apply compression algorithm
           if @algorithm && @algorithm != :copy
             algo_class = Omnizip::AlgorithmRegistry.get(@algorithm)
-            raise "Algorithm not found: #{@algorithm}" unless algo_class
+            raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{@algorithm}" unless algo_class
 
             encoder = algo_class.new
             input_io = StringIO.new(result)

data/lib/omnizip/formats/seven_zip/stream_decompressor.rb

@@ -57,7 +57,7 @@ module Omnizip
 
           # Get algorithm class
           algo_class = Omnizip::AlgorithmRegistry.get(algo_sym)
-          raise "Algorithm not found: #{algo_sym}" unless algo_class
+          raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{algo_sym}" unless algo_class
 
           # Decompress
           input_io = StringIO.new(packed_data)
@@ -80,8 +80,8 @@ module Omnizip
 
               # BCJ2 requires special handling with multiple streams
               if filter_sym == :bcj2
-                raise "BCJ2 archives require multi-stream decompression which is not yet implemented. " \
-                      "Please use the 7z command-line tool for this archive."
+                raise Omnizip::UnsupportedFormatError, "BCJ2 archives require multi-stream decompression which is not yet implemented. " \
+                                                       "Please use the 7z command-line tool for this archive."
               end
 
               filter = filter_class.new
@@ -109,8 +109,8 @@ module Omnizip
             actual_crc = crc.value
 
             unless actual_crc == expected_crc
-              raise "CRC mismatch: expected 0x#{expected_crc.to_s(16)}, " \
-                    "got 0x#{actual_crc.to_s(16)}"
+              raise Omnizip::ChecksumError, "CRC mismatch: expected 0x#{expected_crc.to_s(16)}, " \
+                                            "got 0x#{actual_crc.to_s(16)}"
             end
           end
 

data/lib/omnizip/formats/seven_zip/writer.rb

@@ -299,7 +299,7 @@ module Omnizip
         # @return [String] Encrypted header with metadata
         def encrypt_header(header_data)
           unless @options[:password]
-            raise "Password required for header encryption"
+            raise Omnizip::PasswordError, "Password required for header encryption"
           end
 
           encryptor = HeaderEncryptor.new(@options[:password])

data/lib/omnizip/formats/zip/writer.rb

@@ -92,14 +92,17 @@ module Omnizip
           @entries << entry
         end
 
-        # Add data directly to the archive
-        def add_data(archive_path, data, stat = nil)
+        # Add data directly to the archive. +compression_method+
+        # (a ZIP method code) overrides the archive-wide default for
+        # this entry alone.
+        def add_data(archive_path, data, stat = nil, compression_method: nil)
           entry = create_entry(
             filename: archive_path,
             uncompressed_data: data,
             stat: stat,
           )
 
+          entry[:compression_method] = compression_method
           @entries << entry
         end
 
@@ -188,13 +191,17 @@ module Omnizip
         def write_to_io(io, compression_method: COMPRESSION_DEFLATE, level: 6)
           local_header_offsets = []
 
-          # Write local file headers and data
+          # Write local file headers and data. An entry-level
+          # :compression_method overrides the archive-wide default
+          # (used by the buffer layer's per-entry :store option).
           entries.each do |entry|
             offset = io.pos
             local_header_offsets << offset
 
+            entry_method = entry[:compression_method] || compression_method
+
             # Create local file header
-            local_header = create_local_header(entry, compression_method)
+            local_header = create_local_header(entry, entry_method)
 
             # Compress data if not a directory
             if entry[:directory]
@@ -205,7 +212,7 @@ module Omnizip
             else
               compressed_data = compress_data(
                 entry[:uncompressed_data],
-                compression_method,
+                entry_method,
                 level,
               )
               entry[:compressed_size] = compressed_data.bytesize
@@ -232,7 +239,7 @@ module Omnizip
           entries.each_with_index do |entry, index|
             central_header = create_central_header(
               entry,
-              compression_method,
+              entry[:compression_method] || compression_method,
               local_header_offsets[index],
             )
             io.write(central_header.to_binary)

data/lib/omnizip/parallel/engine.rb

@@ -31,17 +31,21 @@ module Omnizip
       # @return [Array<Fractor::WorkResult>] the failed results, for
       #   the caller to decide how to surface.
       def run(work_items)
-        pool = Fractor::WorkerPool.new(
+        pool = WorkerPool.new(
           worker_class: @worker_class,
           num_workers: @threads,
           continuous: false,
         )
         pool.start
-        pool.submit_batch(work_items)
-        pool.run
+        begin
+          pool.submit_batch(work_items)
+          pool.run
 
-        pool.successful_results.each { |r| yield r if block_given? }
-        pool.failed_results
+          pool.successful_results.each { |r| yield r if block_given? }
+          pool.failed_results
+        ensure
+          pool.shutdown
+        end
       end
     end
   end

data/lib/omnizip/parallel/job_scheduler.rb

@@ -38,6 +38,10 @@ module Omnizip
           schedule_dynamic(jobs, worker_count)
         when :static
           schedule_static(jobs, worker_count)
+        when :round_robin
+          schedule_round_robin(jobs, worker_count)
+        when :bin_packing
+          schedule_bin_packing(jobs, worker_count)
         end
       end
 
@@ -99,7 +103,7 @@ bytes_per_second: 10_000_000)
       #
       # @raise [ArgumentError] if strategy is invalid
       def validate_strategy!
-        valid_strategies = %i[dynamic static]
+        valid_strategies = %i[dynamic static round_robin bin_packing]
         return if valid_strategies.include?(@strategy)
 
         raise ArgumentError,

data/lib/omnizip/parallel/parallel_extractor.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "fractor"
 require "fileutils"
 
 module Omnizip
@@ -21,101 +20,6 @@ module Omnizip
     #   extractor = Omnizip::Parallel::ParallelExtractor.new(options)
     #   extractor.extract('backup.zip', 'output/')
     class ParallelExtractor
-      # Fractor Work class for extraction jobs
-      class ExtractionWork < Fractor::Work
-        def initialize(entry:, archive_path:, dest_dir:)
-          super({
-            entry: entry,
-            archive_path: archive_path,
-            dest_dir: dest_dir,
-          })
-        end
-
-        def entry
-          input[:entry]
-        end
-
-        def archive_path
-          input[:archive_path]
-        end
-
-        def dest_dir
-          input[:dest_dir]
-        end
-      end
-
-      # Fractor Worker class for extraction
-      class ExtractionWorker < Fractor::Worker
-        def process(work)
-          entry = work.entry
-          archive_path = work.archive_path
-          dest_dir = work.dest_dir
-
-          # Read and decompress entry data
-          data = read_entry_data(archive_path, entry)
-
-          # Determine destination path
-          dest_path = ::File.join(dest_dir, entry.name)
-
-          # Return result
-          Fractor::WorkResult.new(
-            result: {
-              entry_name: entry.name,
-              dest_path: dest_path,
-              data: data,
-              directory: entry.directory?,
-              unix_perms: safe_unix_perms(entry),
-            },
-            work: work,
-          )
-        rescue StandardError => e
-          Fractor::WorkResult.new(
-            error: e,
-            work: work,
-          )
-        end
-
-        private
-
-        def read_entry_data(archive_path, entry)
-          return "" if entry.directory?
-
-          # Open archive and extract entry
-          reader = Omnizip::Formats::Zip::Reader.new(archive_path)
-          reader.read
-
-          ::File.open(archive_path, "rb") do |io|
-            # Find the entry in reader
-            reader_entry = reader.entries.find { |e| e.filename == entry.name }
-            raise Errno::ENOENT, "Entry not found in archive: #{entry.name}" unless reader_entry
-
-            # Seek to entry data
-            io.seek(reader_entry.local_header_offset, ::IO::SEEK_SET)
-
-            # Read and parse local file header
-            fixed_header = io.read(30)
-            return "" unless fixed_header && fixed_header.size == 30
-
-            _signature, _version, _flags, _method, _time, _date, _crc32,
-            _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
-
-            # Skip filename and extra field
-            io.read(filename_length + extra_length)
-
-            # Read compressed data
-            compressed_data = io.read(reader_entry.compressed_size)
-            return "" unless compressed_data
-
-            # Decompress
-            reader.decompress(
-              compressed_data,
-              reader_entry.compression_method,
-              reader_entry.uncompressed_size,
-            )
-          end
-        end
-      end
-
       # @return [Omnizip::Models::ParallelOptions] parallel options
       attr_reader :options
 
@@ -179,41 +83,41 @@ module Omnizip
 
         # Schedule jobs
         entries.each do |entry|
-          file_size = safe_entry_size(entry)
-
           job_queue.push_with_size(
-            file: entry.name,
-            size: file_size,
-            data: { entry: entry },
+            file: entry.filename,
+            size: safe_entry_size(entry),
+            data: { entry_name: entry.filename },
           )
         end
 
-        # Create work items from jobs
+        # Create work items from jobs, largest first
         work_items = []
         until job_queue.empty?
           job = job_queue.pop(timeout: 0.1)
           break unless job
 
-          work_items << ExtractionWork.new(
-            entry: job.data[:entry],
-            archive_path: archive,
-            dest_dir: dest,
-          )
+          work_items << job.data[:entry_name]
+        end
+
+        # Threads, not Ractors: Omnizip's autoloads and Proc-holding
+        # codec constants cannot cross Ractor boundaries on Ruby <= 3.3
+        pool = ThreadPool.new(size: @options.threads)
+        raw_results, raw_errors = pool.map(work_items) do |entry_name|
+          process_entry(archive, dest, entry_name)
         end
 
-        # Run the worker pool through the shared engine.
-        engine = Engine.new(worker_class: ExtractionWorker,
-                            threads: @options.threads)
-        results = []
-        errors = engine.run(work_items) { |r| results << r }
-
-        # Handle errors
-        unless errors.empty?
-          error_msgs = errors.map do |e|
-            "#{e.work&.entry&.name}: #{e.error}"
-          end.join("\n")
-          raise Omnizip::ExtractionError, "Extraction errors:\n#{error_msgs}"
+        # Handle errors (raw_errors holds nil for every item that
+        # succeeded — zip+compact would keep those pairs)
+        failure_pairs = raw_errors.each_with_index.filter_map do |error, index|
+          [work_items[index], error] if error
         end
+        unless failure_pairs.empty?
+          error_msgs = failure_pairs.map { |name, e| "#{name}: #{e.message}" }
+            .join("\n")
+          raise Omnizip::DecompressionError, "Extraction errors:\n#{error_msgs}"
+        end
+
+        results = raw_results
 
         # Write files to disk (thread-safe)
         extracted_paths = write_extracted_files(results, overwrite: overwrite)
@@ -242,32 +146,37 @@ module Omnizip
 
       private
 
-      def safe_unix_perms(entry)
-        entry.unix_perms
-      rescue NoMethodError
-        0
+      # Decompress one entry in a worker thread. Each worker opens
+      # the archive independently — its own file handle per thread.
+      def process_entry(archive_path, dest_dir, entry_name)
+        entry = Omnizip::Formats::Zip::Reader.new(archive_path)
+          .entries.find { |e| e.filename == entry_name }
+        raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+        {
+          entry_name: entry_name,
+          dest_path: ::File.join(dest_dir, entry_name),
+          data: entry.directory? ? "" : read_entry_data(archive_path, entry_name),
+          directory: entry.directory?,
+          unix_perms: entry.unix_permissions.to_i,
+        }
+      end
+
+      def read_entry_data(archive_path, entry_name)
+        Omnizip::Formats::Zip::Reader.new(archive_path)
+          .read_entry(entry_name)
       end
 
       def safe_entry_size(entry)
-        entry.size
-      rescue NoMethodError
-        0
+        entry.uncompressed_size.to_i
       end
 
-      # Read archive entries
+      # Read archive entries through the native reader
       #
       # @param archive_path [String] archive path
-      # @return [Array<Entry>] array of entries
+      # @return [Array<CentralDirectoryHeader>] array of entries
       def read_archive_entries(archive_path)
-        entries = []
-
-        Omnizip::Zip::File.open(archive_path) do |zip|
-          zip.each do |entry|
-            entries << entry
-          end
-        end
-
-        entries
+        Omnizip::Formats::Zip::Reader.new(archive_path).entries
       end
 
       # Write extracted files to disk
@@ -278,34 +187,36 @@ module Omnizip
       def write_extracted_files(results, overwrite: false)
         extracted_paths = []
 
-        results.each do |work_result|
-          result = work_result.result
+        results.each do |result|
           next unless result
 
           dest_path = result[:dest_path]
 
           # Thread-safe file writing
           @write_mutex.synchronize do
+            if result[:directory]
+              # mkdir_p is idempotent — a file entry may already have
+              # created this directory as its parent
+              FileUtils.mkdir_p(dest_path)
+              extracted_paths << dest_path
+              next
+            end
+
             # Check if file exists
             if ::File.exist?(dest_path) && !overwrite
               raise Errno::EEXIST, "File exists: #{dest_path}"
             end
 
-            # Write file or create directory
-            if result[:directory]
-              FileUtils.mkdir_p(dest_path)
-            else
-              FileUtils.mkdir_p(::File.dirname(dest_path))
-              ::File.binwrite(dest_path, result[:data])
+            FileUtils.mkdir_p(::File.dirname(dest_path))
+            ::File.binwrite(dest_path, result[:data])
 
-              # Set permissions if Unix
-              if result[:unix_perms].positive?
-                ::File.chmod(result[:unix_perms] & 0o777, dest_path)
-              end
-
-              @stats[:bytes_extracted] += result[:data].bytesize
+            # Set permissions if Unix
+            if result[:unix_perms].positive?
+              ::File.chmod(result[:unix_perms] & 0o777, dest_path)
             end
 
+            @stats[:bytes_extracted] += result[:data].bytesize
+
             extracted_paths << dest_path
           end
         end

data/lib/omnizip/parallel/thread_pool.rb

@@ -0,0 +1,60 @@
+# frozen_string: true
+
+module Omnizip
+  module Parallel
+    # Bounded thread pool for library work.
+    #
+    # Unlike the Fractor pool, threads share the VM state — Ractor
+    # workers cannot trigger Omnizip's autoloads or touch Proc-holding
+    # codec constants on Ruby <= 3.3 ("require by autoload on
+    # non-main Ractor is not supported"). Decompression itself still
+    # parallelizes: the zlib/bzip2 C extensions release the GVL.
+    class ThreadPool
+      # @return [Integer] number of worker threads
+      attr_reader :size
+
+      # Initialize the pool
+      #
+      # @param size [Integer] worker thread count (at least 1)
+      def initialize(size:)
+        @size = [size.to_i, 1].max
+      end
+
+      # Run +block+ for every item, at most +size+ at a time, and
+      # return a pair of parallel arrays: results (nil where an item
+      # raised) and errors (nil where it succeeded). Item order is
+      # preserved in both arrays.
+      #
+      # @param items [Array] work items
+      # @yieldparam item [Object] one work item
+      # @return [Array<Array, Array>]
+      def map(items)
+        results = Array.new(items.size)
+        errors = Array.new(items.size)
+        queue = Queue.new
+        items.each_with_index { |item, index| queue << [item, index] }
+
+        threads = Array.new(@size) do
+          Thread.new do
+            loop do
+              begin
+                item, index = queue.pop(true)
+              rescue ThreadError
+                break
+              end
+
+              begin
+                results[index] = yield(item)
+              rescue StandardError => e
+                errors[index] = e
+              end
+            end
+          end
+        end
+        threads.each(&:join)
+
+        [results, errors]
+      end
+    end
+  end
+end

data/lib/omnizip/parallel/worker_pool.rb

@@ -132,8 +132,12 @@ module Omnizip
       def shutdown(timeout: 30)
         return unless @running
 
+        # Stop in BOTH modes: batch worker Ractors otherwise linger
+        # in Ractor.receive for the life of the process, burning CPU
+        # after the batch completes
+        @supervisor&.stop
+
         if @continuous
-          @supervisor.stop
           @supervisor_thread&.join(timeout)
         end
 

data/lib/omnizip/parallel.rb

@@ -29,6 +29,7 @@ module Omnizip
     autoload :Engine, "omnizip/parallel/engine"
     autoload :ParallelCompressor, "omnizip/parallel/parallel_compressor"
     autoload :ParallelExtractor, "omnizip/parallel/parallel_extractor"
+    autoload :ThreadPool, "omnizip/parallel/thread_pool"
 
     class << self
       # Global configuration

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.53"
+  VERSION = "0.3.54"
 end

data/lib/omnizip.rb

@@ -85,6 +85,9 @@ module Omnizip
   autoload :ArchiveHandlers, "omnizip/archive_handlers"
   autoload :Archive, "omnizip/archive"
   autoload :Password, "omnizip/password"
+  # The class lives at the top level of omnizip/password.rb; without
+  # this entry, referencing it does not trigger the Password autoload
+  autoload :PasswordError, "omnizip/password"
   autoload :Convenience, "omnizip/convenience"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.53
+  version: 0.3.54
 platform: ruby
 authors:
 - Ribose Inc.
@@ -650,6 +650,7 @@ files:
 - lib/omnizip/parallel/job_scheduler.rb
 - lib/omnizip/parallel/parallel_compressor.rb
 - lib/omnizip/parallel/parallel_extractor.rb
+- lib/omnizip/parallel/thread_pool.rb
 - lib/omnizip/parallel/worker_pool.rb
 - lib/omnizip/parity.rb
 - lib/omnizip/parity/chunked_block_processor.rb