omnizip 0.3.57 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ea5d1a7c799ac0f1b17c60e1c715fc0bf95a2d8dc3d3a02e0776bac6efbccf0
-  data.tar.gz: 198583bbdc571acdd26a8a1e25f4a6ce0e5aa6b33d613c247bf49556d164200c
+  metadata.gz: 7a04b0c83ee4e9c6b57823c8db709178ed2b88e073f658fb6573d9f69fa7459f
+  data.tar.gz: 1c5d9b7e86c1d1322cfd8a8193fcec2c8b7a4d28a21b6ee4b6fca3a359bc01e3
 SHA512:
-  metadata.gz: edaf17357204a214beecdd32e18bd53139bb6a7b9797b29a181a44db80b531e847f6d3e48da97f6ce5f02e80feeb456c71e593df92b471b4d5875a8d13ae1e98
-  data.tar.gz: 6f82822274ad086eef57304f2386a43f979525dd6893f0eabf693b6c8c60a08a71729beb5c2a3328c8617871bbbc4b9d33a2b6801ae801eeb3614a8f4cbd6d4e
+  metadata.gz: c22355d1136d66e0c6632ce6b4ad57a1b27c8cf826b0f5593318bffd20e85de77ed8072e280a88aa01433ef658fb1adc9139ff1ff8aa6d31735efb6aea1fc9f5
+  data.tar.gz: b06259b9ca3ede7ed15bdfa33537a9d9a17099a59ac5b0d5dc95a4f29a46ead222641abf4e8a17f17a283b1272f99d589c3541d799da0f932fc58a1401aa0d2c

data/CHANGELOG.md

@@ -7,6 +7,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- Rust-accelerated backend tier: `Omnizip::Backends` is the single
+  tier switch between the pure-Ruby cores and the `omnizip-ffi`
+  cdylib (stdlib Fiddle — no compiled extension). Under the default
+  `auto` policy decode prefers the Rust decoders (output-invariant
+  and carrying fixes the Ruby cores lack); encode stays pure-Ruby
+  so frame bytes never depend on the tier (content addressing
+  stability). `OMNIZIP_BACKEND=rust|ruby` forces a tier; load
+  failures fall back to pure Ruby silently. A cross-tier
+  differential spec pins decode agreement in both encode
+  directions.
+- BZip2 routes its byte core through the backend seam (both paths
+  share the algorithm class's IO plumbing).
+
+### Fixed
+- Ruby 4.0 compatibility for the tier loader: fiddle moved out of
+  the default gems and is now required lazily with a fallback;
+  library resolution no longer references Fiddle constants when
+  fiddle is absent and considers `.dll` candidates on Windows.
+
+## [0.3.58] - 2026-09-03
+
+### Fixed
+- `solid: true` on the RAR5 writer silently fell back to
+  independent STORE entries (the RAR-compatible LZSS encoder is not
+  available); the writer now warns about the fallback. The
+  creating-archives guide's solid section stops advertising
+  compression ratios the option cannot deliver and the stale
+  `(v0.5.0)` version-gate labels are gone from shipped features.
+- The ZIP writer never emits ZIP64 structures; past the classic
+  limits `Array#pack` failed with a bare `RangeError` that named no
+  limit. Both write paths now raise `UnsupportedFormatError` naming
+  the 65,535-entry / 4 GiB size / 4 GiB offset classic-ZIP limits
+  (ZIP64 writing is not supported).
+
+### Changed
+- The decompress command's archive-vs-stream routing derives from
+  the registry's extension routes instead of a private table, so
+  formats added to the registry route correctly instead of silently
+  falling into the single-file stream path.
+
+## [0.3.57] - 2026-09-02
+
+### Fixed
+- TAR archives no longer corrupt silently on long paths: the writer
+  now splits entry names over 99 bytes across the ustar prefix +
+  name fields at a "/" boundary, the reader joins them back for
+  consumers, and paths no ustar fields can represent raise
+  `FormatError` instead of truncating. Verified against system tar.
+- `:auto` profile sampling walked directories in the OS's
+  iteration order, resolving different files (and compression
+  settings) per platform; the walk is sorted and deterministic now.
+- The getting-started docs' 7z examples used a Reader API that
+  never shipped (`each_file`, `close`, `Reader.info`) — every
+  snippet raised NoMethodError verbatim. Rewritten against the real
+  surface and executed to verify.
+
+### Changed
+- The last 28 bare `raise "string"` sites (RAR tree, cpio entries,
+  parity internals, zip compat streams, two commands) gained their
+  matching error classes — `lib/` now contains zero bare raises.
+- The dead `--preserve-ntfs-streams` CLI flag is removed; nothing
+  read it and no code path implements NTFS stream preservation.
+
 ## [0.3.56] - 2026-09-02
 
 ### Fixed

data/docs/guides/creating-archives.adoc

@@ -76,7 +76,7 @@ writer.write
 
 IMPORTANT: RAR5 CRC32 checksums only work with STORE compression. When LZMA is used, CRC32 is automatically disabled. Use BLAKE2sp (always present) for compressed file integrity.
 
-=== RAR5 Multi-Volume Archives (v0.5.0)
+=== RAR5 Multi-Volume Archives
 
 Split large archives across multiple volumes:
 
@@ -110,36 +110,30 @@ volumes = writer.write
 # Minimum volume size: 64 KB
 ----
 
-=== RAR5 Solid Compression (v0.5.0)
+=== RAR5 Solid Archives
 
-Achieve 10-30% better compression ratios for similar files:
+`solid: true` requests a shared solid block, but the RAR-compatible
+LZSS encoder is not implemented yet — the writer warns and writes
+independent STORE entries instead, so the archive stays extractable
+by official unrar:
 
 [source,ruby]
 ----
 require 'omnizip/formats/rar/rar5/writer'
 
-# Enable solid compression
 writer = Omnizip::Formats::Rar::Rar5::Writer.new('project.rar',
-  compression: :lzma,
-  level: 5,
-  solid: true  # Shared dictionary across files
+  solid: true  # warns: falls back to independent STORE entries
 )
 writer.add_directory('source_code/')
 writer.write
+----
 
-# Best for:
-# - Source code repositories
-# - Log files
-# - Text documents
-# - Similar structured data
-
-# Trade-offs:
-# - Cannot extract individual files without decompressing entire block
-# - Corruption may affect multiple files
-# - Slightly longer extraction time for single files
+Solid compression (shared dictionary across files, better ratios
+for similar content) arrives when the RAR-compatible LZSS encoder
+lands.
 ----
 
-=== RAR5 AES-256 Encryption (v0.5.0)
+=== RAR5 AES-256 Encryption
 
 Password-protect archives with industry-standard encryption:
 
@@ -177,7 +171,7 @@ writer.write
 # - Password verification before decryption
 ----
 
-=== RAR5 PAR2 Recovery Records (v0.5.0)
+=== RAR5 PAR2 Recovery Records
 
 Add error correction for archive recovery:
 
@@ -216,7 +210,7 @@ files = writer.write
 # - Works with multi-volume, solid, and encrypted archives
 ----
 
-=== RAR5 Combined Features (v0.5.0)
+=== RAR5 Combined Features
 
 Use all features together for comprehensive protection:
 
@@ -262,13 +256,13 @@ puts "  Total size: #{files.sum { |f| File.size(f) } / 1024 / 1024}MB"
 
 === RAR5 Best Practices
 
-**For Maximum Compression:**
+**For Maximum Compatibility:**
 [source,ruby]
 ----
 writer = Omnizip::Formats::Rar::Rar5::Writer.new('archive.rar',
   compression: :lzma,
-  level: 5,        # Best compression
-  solid: true,     # 10-30% better ratios
+  level: 5,        # Honored by the 7z-style writers; RAR5 entries
+                   # are STORE until the LZSS encoder lands
   include_mtime: true
 )
 ----

data/lib/omnizip/algorithms/bzip2.rb

@@ -67,7 +67,10 @@ module Omnizip
       # @return [void]
       def compress(input_stream, output_stream, options = nil)
         level = level_from(options)
-        output_stream.write(Bz2.compress(input_stream.read, level))
+        data = input_stream.read
+        output_stream.write(
+          Backends.compress("bzip2", data, level) { Bz2.compress(data, level) },
+        )
       end
 
       # Decompress BZip2-compressed data
@@ -78,7 +81,11 @@ module Omnizip
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
         output_stream.set_encoding(Encoding::BINARY)
-        output_stream.write(Bz2.decompress(input_stream.read))
+        compressed = input_stream.read
+        plain = Backends.decompress("bzip2", compressed, Backends::UNKNOWN_LENGTH) do
+          Bz2.decompress(compressed)
+        end
+        output_stream.write(plain)
       end
 
       private

data/lib/omnizip/backends.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Byte-level codec backend resolution — THE tier switch
+  # (TODO.ref-parity/62). Both paths share the algorithm classes'
+  # IO plumbing; only the byte core swaps.
+  #
+  # Policy:
+  #   OMNIZIP_BACKEND=ruby   force pure Ruby everywhere
+  #   OMNIZIP_BACKEND=rust   require the Rust library (raises when absent)
+  #   OMNIZIP_BACKEND=auto   (default) Rust for directions marked
+  #                          safe, Ruby otherwise, whenever the
+  #                          cdylib is loadable
+  #
+  # Safety marks (owner guidance 2026-09-19: some Ruby cores are
+  # LESS accurate than the Rust ports — be careful which tier is
+  # trusted for what):
+  #   - decompress -> :rust by default. Decode is output-invariant
+  #     AND the Rust decoders carry fixes the Ruby cores lack;
+  #     disagreements are treated as Ruby-side accuracy findings
+  #     (see the cross-tier differential spec), not coin flips.
+  #   - compress -> :ruby by default. Byte-stability for content
+  #     addressing (DropId dedup assumes identical frames); the
+  #     Rust encoders produce DIFFERENT valid streams (probed:
+  #     bzip2 L6, Ruby 906 B vs Rust 874 B). OMNIZIP_BACKEND=rust
+  #     opts into Rust encode where correctness-of-ratio is wanted
+  #     over frame stability.
+  module Backends
+    # Codecs whose Rust encoder is BYTE-IDENTICAL to the pure-Ruby
+    # encoder (empirical, differential-corpus-proven). 2026-09-19
+    # probe: bzip2 L6 on a 50 KB corpus => Ruby 906 B vs Rust 874 B —
+    # DIFFERENT valid streams. No codec qualifies; encode stays
+    # pure-Ruby under :auto so downstream content addressing never
+    # sees tier-dependent bytes. Force with OMNIZIP_BACKEND=rust.
+    RUST_ENCODE_IDENTICAL = {}.freeze
+
+    # usize::MAX — the FFI's "caller does not know the plaintext
+    # size" sentinel (streaming decode contract).
+    UNKNOWN_LENGTH = 0xFFFF_FFFF_FFFF_FFFF
+
+    class << self
+      def for(codec, direction)
+        mode = ENV.fetch("OMNIZIP_BACKEND", "auto")
+
+        return backend_rust if mode == "rust"
+        return backend_ruby if mode == "ruby"
+
+        return backend_ruby unless Implementations::Rust::Library.available?
+        return backend_ruby unless Implementations::Rust::Library::CODECS.include?(codec)
+
+        direction == :encode && !RUST_ENCODE_IDENTICAL.fetch(codec, false) ? backend_ruby : backend_rust
+      end
+
+      # Compress through the tier-selected backend. The block is
+      # the pure-Ruby core — evaluated ONLY on the Ruby path, so
+      # the accelerated path never pays for it.
+      def compress(codec, data, level, &ruby_core)
+        backend = Backends.for(codec, :encode)
+        return yield if backend == RubyBackend
+
+        backend.compress(codec, data, level)
+      end
+
+      # Decompress through the tier-selected backend (output-
+      # invariant: :auto prefers Rust whenever loadable).
+      def decompress(codec, data, expected_len, &ruby_core)
+        backend = Backends.for(codec, :decode)
+        return yield if backend == RubyBackend
+
+        backend.decompress(codec, data, expected_len)
+      end
+
+      private
+
+      def backend_rust
+        RustBackend
+      end
+
+      def backend_ruby
+        RubyBackend
+      end
+    end
+
+    # The pure-Ruby path: a no-op backend — callers fall back to
+    # their own in-tree cores, which ARE the reference. Kept as an
+    # object for symmetry with the Rust side.
+    module RubyBackend
+      module_function
+
+      # :nocov:
+      def compress(codec, _data, _level)
+        raise Error, "#{codec}: ruby core not wired through Backends (call it directly)"
+      end
+
+      def decompress(codec, _data, _expected_len)
+        raise Error, "#{codec}: ruby core not wired through Backends (call it directly)"
+      end
+      # :nocov:
+    end
+
+    # The Rust-accelerated path over the Fiddle handle.
+    module RustBackend
+      module_function
+
+      def compress(codec, data, level)
+        Implementations::Rust::Library.instance.compress(codec, data, level)
+      end
+
+      def decompress(codec, data, expected_len)
+        Implementations::Rust::Library.instance.decompress(codec, data, expected_len)
+      end
+    end
+
+    class Error < StandardError; end
+  end
+end

data/lib/omnizip/commands/decompress_command.rb

@@ -80,7 +80,10 @@ module Omnizip
         end
       end
 
-      ARCHIVE_EXTENSIONS = %w[.zip .7z .tar .rar .cpio .iso .rpm .xar .msi].freeze
+      # Archive-vs-stream routing derives from the registry's
+      # extension routes so new formats route here automatically
+      ARCHIVE_EXTENSIONS = (Convenience::ARCHIVE_FORMAT_EXTENSIONS.keys +
+                            Convenience::READ_ARCHIVE_FORMAT_EXTENSIONS.keys).freeze
 
       private
 

data/lib/omnizip/formats/rar/rar5/writer.rb

@@ -199,6 +199,11 @@ module Omnizip
               if @options[:solid] && Compression::Lzss.available?
                 write_solid_block(f, @files)
               else
+                if @options[:solid]
+                  warn "omnizip: solid: true requested but the " \
+                       "RAR-compatible LZSS encoder is not available " \
+                       "— writing independent STORE entries instead"
+                end
                 @files.each do |file|
                   write_file_entry(f, file)
                 end

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

@@ -152,6 +152,8 @@ module Omnizip
         end
 
         def write_precompressed_to_io(io, compression_method: COMPRESSION_DEFLATE)
+          check_classic_entry_count!
+          entries.each { |entry| check_classic_size_limit!(entry) }
           local_header_offsets = []
 
           entries.each do |entry|
@@ -189,6 +191,7 @@ module Omnizip
 
         # Write to an IO object
         def write_to_io(io, compression_method: COMPRESSION_DEFLATE, level: 6)
+          check_classic_entry_count!
           local_header_offsets = []
 
           # Write local file headers and data. An entry-level
@@ -220,6 +223,8 @@ module Omnizip
               entry[:crc32] = calculate_crc32(entry[:uncompressed_data])
             end
 
+            check_classic_size_limit!(entry)
+
             # Update local header with compressed sizes
             local_header.compressed_size = entry[:compressed_size]
             local_header.uncompressed_size = entry[:uncompressed_size]
@@ -234,6 +239,7 @@ module Omnizip
 
           # Record start of central directory
           central_directory_offset = io.pos
+          check_classic_offset_limit!(central_directory_offset)
 
           # Write central directory headers
           entries.each_with_index do |entry, index|
@@ -257,8 +263,42 @@ module Omnizip
           io.write(eocd.to_binary)
         end
 
+        # Classic (non-ZIP64) ZIP headers pack sizes and offsets as
+        # 32-bit values and entry counts as 16-bit; exceeding them
+        # raises instead of letting Array#pack fail with a bare
+        # RangeError. ZIP64 writing is not supported.
+        MAX_CLASSIC_SIZE = 0xFFFFFFFF
+        MAX_CLASSIC_ENTRIES = 0xFFFF
+        private_constant :MAX_CLASSIC_SIZE, :MAX_CLASSIC_ENTRIES
+
         private
 
+        def check_classic_entry_count!
+          return if entries.size <= MAX_CLASSIC_ENTRIES
+
+          raise Omnizip::UnsupportedFormatError,
+                "#{entries.size} entries exceed the classic ZIP " \
+                "limit of #{MAX_CLASSIC_ENTRIES} (ZIP64 writing is " \
+                "not supported)"
+        end
+
+        def check_classic_size_limit!(entry)
+          return if entry[:compressed_size].to_i <= MAX_CLASSIC_SIZE &&
+            entry[:uncompressed_size].to_i <= MAX_CLASSIC_SIZE
+
+          raise Omnizip::UnsupportedFormatError,
+                "entry #{entry[:filename].inspect} exceeds the 4 GiB " \
+                "classic ZIP size limit (ZIP64 writing is not supported)"
+        end
+
+        def check_classic_offset_limit!(offset)
+          return if offset <= MAX_CLASSIC_SIZE
+
+          raise Omnizip::UnsupportedFormatError,
+                "archive layout exceeds the 4 GiB classic ZIP " \
+                "offset limit (ZIP64 writing is not supported)"
+        end
+
         # Create an entry hash
         def create_entry(
           filename:,

data/lib/omnizip/implementations/rust/library.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+begin
+  # Ruby 4.0 moved fiddle out of the default gems.
+  require "fiddle"
+  require "pathname"
+rescue LoadError
+  # :nocov:
+end
+
+module Omnizip
+  module Implementations
+    module Rust
+      # The loaded cdylib: one handle, lazily opened, thread-safe
+      # after initialization (Fiddle::Function is immutable once
+      # built; compress/decompress are pure C calls).
+      class Library
+        # Codecs the cdylib dispatches by name.
+        CODECS = %w[bzip2 zstd lzma xz].freeze
+
+        class << self
+          # The shared handle, or nil when the cdylib cannot load.
+          # Load failures are cached: a missing library is a stable
+          # condition, not something to re-attempt per call.
+          def instance
+            return @instance if defined?(@instance)
+
+            @instance = open
+          end
+
+          def available?
+            !instance.nil?
+          end
+
+          # Drop the cached handle so resolution reruns (test seam:
+          # specs exercising fallback/absence paths need a clean
+          # slate; production never calls this).
+          def forget!
+            @instance = nil if defined?(@instance)
+            nil
+          end
+
+          # Built lazily: the Fiddle::TYPE_* constants only resolve
+          # after a successful require; environments without fiddle
+          # (Ruby 4.0 without the gem) never touch this table.
+          def function_table
+            {
+              last_error: ["ozip_last_error", [], Fiddle::TYPE_VOIDP],
+              free: ["ozip_free", %i[voidp size_t], Fiddle::TYPE_VOID],
+              compress: [
+                "ozip_compress",
+                %i[voidp voidp size_t int voidp],
+                Fiddle::TYPE_VOIDP,
+              ],
+              decompress: [
+                "ozip_decompress",
+                %i[voidp voidp size_t size_t voidp],
+                Fiddle::TYPE_VOIDP,
+              ],
+            }
+          end
+
+          private
+
+          def open
+            path = resolve_path
+            return nil if path.nil?
+
+            handle = Fiddle.dlopen(path.to_s)
+            funcs = function_table.each_with_object({}) do |(key, (name, args, ret)), h|
+              h[key] = Fiddle::Function.new(handle[name], args, ret)
+            end
+            new(funcs)
+          rescue StandardError => e # includes Fiddle::DLError
+            warn "omnizip: rust backend unavailable (#{e.message}); using pure Ruby" if ENV["OMNIZIP_BACKEND"] == "rust"
+            nil
+          end
+
+          def resolve_path
+            explicit = ENV.fetch("OMNIZIP_FFI_DYLIB", nil)
+            return Pathname.new(explicit) if explicit && File.file?(explicit)
+
+            candidates = [
+              Pathname.new(__dir__).join("../../../../ext/libomnizip_ffi"),
+              sibling_checkout,
+            ].compact.flatten
+
+            %w[.dylib .so .dll].each do |ext|
+              candidates.each do |dir|
+                path = dir.join("libomnizip_ffi#{ext}")
+                return path if path.file?
+              end
+            end
+            nil
+          end
+
+          # A sibling omnizip-rs checkout: ../omnizip-rs relative to
+          # this gem's repository root.
+          def sibling_checkout
+            gem_root = Pathname.new(__dir__).join("../../../../..")
+            %w[omnizip-rs target/release].map do |rel|
+              gem_root.join(rel, "target/release")
+            end
+          end
+        end
+
+        def initialize(functions)
+          @functions = functions.freeze
+        end
+
+        def compress(codec, data, level)
+          out_len = [0].pack("Q")
+          ptr = call(:compress, codec, data, data.bytesize, level, out_len)
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def decompress(codec, data, expected_len)
+          out_len = [0].pack("Q")
+          ptr = call(:decompress, codec, data, data.bytesize, expected_len, out_len)
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def last_error
+          ptr = @functions[:last_error].call
+          ptr.null? ? "unknown error" : ptr.to_s
+        end
+
+        private
+
+        def call(name, codec, input, input_len, a, out_len)
+          ptr = @functions[name].call(codec, input, input_len, a, out_len)
+          raise Error, last_error if ptr.null?
+
+          ptr
+        end
+
+        # Copy out + free in one breath: the buffer belongs to the
+        # Rust allocator and must never outlive ozip_free.
+        def take(ptr, len)
+          string = ptr.to_s(len)
+          @functions[:free].call(ptr, len)
+          string
+        end
+      end
+
+      # Raised when a codec call fails; #message carries the Rust
+      # side's last_error text.
+      class Error < StandardError; end
+    end
+  end
+end

data/lib/omnizip/implementations/rust.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    # Rust-accelerated codec backend (TODO.ref-parity/62).
+    #
+    # Loads the omnizip-ffi cdylib through stdlib Fiddle — no
+    # compiled Ruby extension, no rake-compiler. When the library
+    # is unavailable the gem transparently stays on the pure-Ruby
+    # path; nothing about the fallback is an error.
+    #
+    # Library resolution order:
+    #   1. ENV['OMNIZIP_FFI_DYLIB'] (explicit path)
+    #   2. ../target/release/ inside a sibling omnizip-rs checkout
+    #
+    # Tier policy (see Omnizip::Backends): decode is always
+    # output-invariant, so `auto` uses Rust for decode whenever
+    # available; encode uses Rust only when byte-identity with the
+    # pure-Ruby encoder has been verified for that codec
+    # (RUST_ENCODE_IDENTICAL), keeping content addressing stable.
+    module Rust
+      autoload :Library, "omnizip/implementations/rust/library"
+    end
+  end
+end

data/lib/omnizip/version.rb

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

data/lib/omnizip.rb

@@ -18,6 +18,7 @@
 
 module Omnizip
   autoload :VERSION, "omnizip/version"
+  autoload :Backends, "omnizip/backends"
 
   autoload :Error, "omnizip/error"
   autoload :CompressionError, "omnizip/error"
@@ -120,6 +121,7 @@ module Omnizip
   module Implementations
     autoload :SevenZip, "omnizip/implementations/seven_zip"
     autoload :XZUtils, "omnizip/implementations/xz_utils"
+    autoload :Rust, "omnizip/implementations/rust"
 
     module SevenZip
       module LZMA

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.57
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-02 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -334,6 +334,7 @@ files:
 - lib/omnizip/archive_handlers/tar_handler.rb
 - lib/omnizip/archive_handlers/xar_handler.rb
 - lib/omnizip/archive_handlers/zip_handler.rb
+- lib/omnizip/backends.rb
 - lib/omnizip/buffer.rb
 - lib/omnizip/buffer/memory_archive.rb
 - lib/omnizip/buffer/memory_extractor.rb
@@ -598,6 +599,8 @@ files:
 - lib/omnizip/implementations/base/lzma_decoder_base.rb
 - lib/omnizip/implementations/base/lzma_encoder_base.rb
 - lib/omnizip/implementations/base/state_machine_base.rb
+- lib/omnizip/implementations/rust.rb
+- lib/omnizip/implementations/rust/library.rb
 - lib/omnizip/implementations/seven_zip.rb
 - lib/omnizip/implementations/seven_zip/lzma.rb
 - lib/omnizip/implementations/seven_zip/lzma/decoder.rb