omnizip 0.4.9-arm-linux → 0.4.10-arm-linux

data/.rubocop.yml

@@ -1,7 +1,15 @@
 # Auto-generated by Cimas: Do not edit it manually!
 # See https://github.com/metanorma/cimas
+#
+# PINNED SNAPSHOT (2026-09-21): the config used to inherit the
+# oss-guides file over HTTPS directly. A remote main that moves under
+# us — combined with CI's fresh dependency resolution — made rubocop
+# behavior change with zero repo-side diffs (the 2026-09-21
+# Metrics/BlockLength + standard-custom CI breakage). The snapshot is
+# refreshed deliberately: refresh with
+#   curl -sL https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml -o .rubocop-oss.yml
 inherit_from:
-  - https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml
+  - .rubocop-oss.yml
   - .rubocop_todo.yml
 
 # local repo-specific modifications
@@ -10,6 +18,12 @@ inherit_from:
 AllCops:
   NewCops: enable
   TargetRubyVersion: 3.0
+  # rake rust:build clones omnizip-rs under lib/tasks/build (and a
+  # build/ dir may exist at the root) — never lint the vendored
+  # checkout's Ruby files.
+  Exclude:
+    - "build/**/*"
+    - "lib/tasks/build/**/*"
 
 # 7-Zip SDK uses is_char_state? naming convention (IsCharState in C)
 # We keep this naming to match the SDK reference

data/.rubocop_todo.yml

@@ -138,9 +138,15 @@ Metrics/AbcSize:
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 81
+  # Merge with the inherited exclusions (oss-guides excludes
+  # spec/**/* here) — a bare Exclude key REPLACES the inherited list,
+  # which un-excluded every spec and re-activated ~190 dormant
+  # offenses under rubocop 1.91 (2026-09-21 CI).
+  inherit_mode:
+    merge:
+      - Exclude
   Exclude:
     - "lib/tasks/platform_gems.rake"
-    - "spec/omnizip/archive_handlers/rust_tier_handlers_spec.rb"
 
 # Offense count: 5
 # Configuration parameters: CountBlocks, CountModifierForms.

data/CHANGELOG.md

@@ -7,7 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- ffi tier — JRuby/TruffleRuby acceleration (leptris-ruby model):
+  the cdylib's C ABI is additionally bound through the `ffi` gem
+  (`FfiLibrary`, same surface as the Fiddle binding), with
+  `Library` dispatching Fiddle → ffi → pure Ruby and
+  `OMNIZIP_BINDING=fiddle|ffi` to force a layer. `ffi` becomes a
+  runtime dependency (JRuby/TruffleRuby bundle it).
+- Owned CI build matrix (windows-11-arm, musl containers, armv7
+  qemu, JRuby ffi gate) replacing the cimas rake job, whose fresh
+  dependency resolution made rubocop break with zero repo-side
+  diffs. The installed-gem smoke reports its binding layer.
+
 ### Fixed
+- `Zlib::RLE` is CRuby-only: `require "omnizip"` raised NameError on
+  JRuby (and any engine without CRuby's zlib extension) as soon as
+  the Deflate algorithm loaded. RLE/FIXED strategy constants are now
+  guarded with their spec-defined values (3 and 4). Found by the new
+  JRuby CI leg — the matrix found a bug on day one.
 - RPM archive-tier readiness: the dylib requirement is
   **0.21.112**, not 0.21.111 — 0.21.111's `./`-stripping was half the
   fix (the Ruby handler's names are ABSOLUTE, from the header's

data/Gemfile

@@ -9,7 +9,16 @@ gemspec
 gem "csv"
 gem "rake"
 gem "rspec"
-gem "rubocop"
+# Pinned: CI resolves dependencies fresh (no lockfile), and rubocop
+# 1.91 changed Metrics/BlockLength scoping + plugin loading, which
+# resurrected ~190 dormant spec offenses and crashes on the inherited
+# oss-guides `standard-custom` require. Re-pin after triage upstream.
+gem "rubocop", "1.90.0"
+# rubocop's plugin loader auto-declares this via standard's
+# default_lint_roller_plugin metadata where the gem is present; on
+# runners without it the require crashes rubocop outright. Ship it in
+# the bundle so the load always resolves (its plugin is inert without
+# a .standard.yml).
 gem "rubocop-performance"
 gem "rubocop-rake"
 gem "rubocop-rspec"

data/README.adoc

@@ -38,9 +38,11 @@ automatically — no Rust toolchain, no compilation:
 * arm64-darwin, x86_64-darwin
 * x64-mingw-ucrt, aarch64-mingw-ucrt, x64-mingw32
 
-Everywhere else — including JRuby/TruffleRuby and any platform without
-a binary — the gem stays fully functional on its pure-Ruby core (the
-acceleration is strictly optional). Three escape hatches:
+Everywhere else — including any platform without a binary — the gem
+stays fully functional on its pure-Ruby core (the acceleration is
+strictly optional). JRuby and TruffleRuby get acceleration too
+whenever a cdylib is available: they bind through the bundled `ffi`
+gem (MRI uses stdlib Fiddle). Three escape hatches:
 
 * `OMNIZIP_NO_RUST=1` — force the pure-Ruby core everywhere.
 * `OMNIZIP_FFI_DYLIB=/path/to/libomnizip_ffi` — load a specific build.

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

@@ -13,11 +13,13 @@ module Omnizip
         BEST_COMPRESSION = Zlib::BEST_COMPRESSION
         DEFAULT_COMPRESSION = Zlib::DEFAULT_COMPRESSION
 
-        # Compression strategies
+        # Compression strategies. RLE and FIXED are CRuby-only Zlib
+        # constants (JRuby's zlib omits them — found by the JRuby CI
+        # leg); the numeric values are fixed by the zlib spec.
         FILTERED = Zlib::FILTERED
         HUFFMAN_ONLY = Zlib::HUFFMAN_ONLY
-        RLE = Zlib::RLE
-        FIXED = Zlib::FIXED
+        RLE = Zlib.const_defined?(:RLE) ? Zlib::RLE : 3
+        FIXED = Zlib.const_defined?(:FIXED) ? Zlib::FIXED : 4
         DEFAULT_STRATEGY = Zlib::DEFAULT_STRATEGY
 
         # Buffer size for streaming operations

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

@@ -7,64 +7,45 @@ module Omnizip
       # format (auto-detected), list entries, read entry bytes. This is
       # the archive-level tier surface — the Ruby core remains the
       # fallback (the cdylib unavailable ⇒ these raise LibraryMissing
-      # and callers fall back).
+      # and callers fall back). Binding-agnostic: dispatches through
+      # whichever backend loaded (Fiddle on MRI, ffi on
+      # JRuby/TruffleRuby).
       class Archive
         class LibraryMissing < StandardError; end
 
-        # Built lazily inside #initialize: the Fiddle::TYPE_* constants
-        # only resolve after a successful require, and Ruby 4.0 moved
-        # fiddle out of the default gems (same reason
-        # Library.function_table is a method, not a constant).
         def initialize(data, password: nil)
           lib = Library.instance
           raise LibraryMissing, "omnizip-ffi cdylib not loaded" unless lib
 
           @lib = lib
-          funcs = function_table
-          @funcs = funcs.each_with_object({}) do |(key, (name, args, ret)), h|
-            h[key] = lib.bind(name, args, ret)
-          end
-
-          pw = password&.to_s
-          pw_ptr = pw && !pw.empty? ? Fiddle::Pointer[pw] : nil
-          @handle = @funcs[:arch_open].call(Fiddle::Pointer[data], data.bytesize, pw_ptr)
-          return unless @handle.null?
-
-          raise Error, @lib.last_error
+          @handle = @lib.arch_open(data, password)
         end
 
         def entry_count
-          @funcs[:arch_count].call(@handle)
+          @lib.arch_count(@handle)
         end
 
         def entry_names
           (0...entry_count).map do |i|
-            ptr = @funcs[:arch_entry_name].call(@handle, i)
-            next nil if ptr.null?
-
-            ptr.to_s
+            @lib.arch_entry_name(@handle, i)
           end
         end
 
         def entry_size(index)
-          @funcs[:arch_entry_size].call(@handle, index)
+          @lib.arch_entry_size(@handle, index)
         end
 
         # Read one entry's uncompressed bytes.
         #
         # @return [String] binary
         def read_entry(index)
-          out_len = [0].pack("Q")
-          ptr = @funcs[:arch_read_entry].call(@handle, index, out_len)
-          raise Error, @lib.last_error if ptr.null?
-
-          @lib.take_buffer(ptr, out_len.unpack1("Q"))
+          @lib.arch_read_entry(@handle, index)
         end
 
         def close
           return unless @handle
 
-          @funcs[:arch_close].call(@handle)
+          @lib.arch_close(@handle)
           @handle = nil
         end
 
@@ -74,19 +55,6 @@ module Omnizip
         ensure
           archive&.close
         end
-
-        private
-
-        def function_table
-          {
-            arch_open: ["ozip_arch_open", %i[voidp size_t voidp], Fiddle::TYPE_VOIDP],
-            arch_count: ["ozip_arch_count", [:voidp], Fiddle::TYPE_SIZE_T],
-            arch_entry_name: ["ozip_arch_entry_name", %i[voidp size_t], Fiddle::TYPE_VOIDP],
-            arch_entry_size: ["ozip_arch_entry_size", %i[voidp size_t], Fiddle::TYPE_VOIDP],
-            arch_read_entry: ["ozip_arch_read_entry", %i[voidp size_t voidp], Fiddle::TYPE_VOIDP],
-            arch_close: ["ozip_arch_close", [:voidp], Fiddle::TYPE_VOID],
-          }
-        end
       end
     end
   end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module Rust
+      # The ffi-gem binding of the cdylib's C ABI — the JRuby /
+      # TruffleRuby acceleration path (leptris-ruby's model): those
+      # engines ship no Fiddle, so the Fiddle tier cannot load.
+      # Mirrors FiddleLibrary's public surface exactly, so the Library
+      # facade and the Archive class are binding-agnostic.
+      class FfiLibrary
+        attr_reader :mod
+
+        # Attach via a fresh module: FFI::Library is an extend-time
+        # DSL — one module per loaded image, like one Fiddle::Handle.
+        def self.attach(path)
+          mod = Module.new do
+            extend ::FFI::Library
+
+            ffi_lib path.to_s
+          end
+          mod.attach_function :ozip_compress,
+                              %i[string buffer_in size_t int pointer], :pointer
+          mod.attach_function :ozip_decompress,
+                              %i[string buffer_in size_t size_t pointer], :pointer
+          mod.attach_function :ozip_last_error, [], :pointer
+          mod.attach_function :ozip_free, %i[pointer size_t], :void
+          mod.attach_function :ozip_version, [], :pointer
+          mod.attach_function :ozip_arch_open,
+                              %i[buffer_in size_t string], :pointer
+          mod.attach_function :ozip_arch_count, [:pointer], :size_t
+          mod.attach_function :ozip_arch_entry_name,
+                              %i[pointer size_t], :pointer
+          mod.attach_function :ozip_arch_entry_size,
+                              %i[pointer size_t], :uint64
+          mod.attach_function :ozip_arch_read_entry,
+                              %i[pointer size_t pointer], :pointer
+          mod.attach_function :ozip_arch_close, [:pointer], :void
+          mod
+        end
+
+        def initialize(path)
+          @mod = self.class.attach(path)
+        end
+
+        def compress(codec, data, level)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_compress(codec, data, data.bytesize, level, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def decompress(codec, data, expected_len)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_decompress(codec, data, data.bytesize,
+                                    expected_len, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def last_error
+          ptr = mod.ozip_last_error
+          ptr.null? ? "unknown error" : ptr.read_string
+        end
+
+        # Copy out + free one returned buffer: the buffer belongs to
+        # the Rust allocator and must never outlive ozip_free.
+        def take(ptr, len)
+          s = ptr.read_string(len)
+          mod.ozip_free(ptr, len)
+          s
+        end
+
+        def take_buffer(ptr, len)
+          take(ptr, len)
+        end
+
+        # The Rust release this cdylib was built from, or nil when the
+        # symbol is absent (dylibs older than 0.21.109).
+        def dylib_version
+          ptr = mod.ozip_version
+          ptr.null? ? nil : ptr.read_string
+        rescue ::FFI::NotFoundError
+          nil
+        end
+
+        # ---- whole-archive surface (ArchHandle) ----
+        # FFI auto-converts a Ruby String for a :pointer argument and
+        # nil to NULL, and the handle travels as a naked pointer.
+
+        def arch_open(data, password)
+          ptr = mod.ozip_arch_open(data, data.bytesize, password)
+          raise Rust::Error, last_error if ptr.null?
+
+          ptr
+        end
+
+        def arch_count(handle)
+          mod.ozip_arch_count(handle)
+        end
+
+        def arch_entry_name(handle, index)
+          ptr = mod.ozip_arch_entry_name(handle, index)
+          ptr.null? ? nil : ptr.read_string
+        end
+
+        def arch_entry_size(handle, index)
+          mod.ozip_arch_entry_size(handle, index)
+        end
+
+        def arch_read_entry(handle, index)
+          out_len = ::FFI::MemoryPointer.new(:size_t)
+          ptr = mod.ozip_arch_read_entry(handle, index, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.read_ulong)
+        end
+
+        def arch_close(handle)
+          mod.ozip_arch_close(handle)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Implementations
+    module Rust
+      # The Fiddle binding of the cdylib's C ABI — the MRI fast path
+      # (stdlib, zero gems). One public surface shared with
+      # FfiLibrary: codec methods, whole-archive methods, error and
+      # version accessors — the binding Library's facade and the
+      # Archive class dispatch through.
+      class FiddleLibrary
+        attr_reader :handle
+
+        # The shared function table (Fiddle::TYPE_* constants resolve
+        # only after a successful require — same reason Library keeps
+        # this out of the class body).
+        FUNCTION_TABLE = lambda {
+          {
+            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,
+            ],
+          }
+        }
+
+        FIDDLE_ARG_TYPES = {
+          pointer: ->(v) { v.nil? ? nil : Fiddle::Pointer[v] },
+        }.freeze
+        FIDDLE_RET_TYPES = {
+          pointer: Fiddle::TYPE_VOIDP,
+          void: Fiddle::TYPE_VOID,
+          size_t: Fiddle::TYPE_SIZE_T,
+          uint64: Fiddle::TYPE_VOIDP,
+        }.freeze
+
+        def initialize(path)
+          @handle = Fiddle.dlopen(path.to_s)
+          @funcs = FUNCTION_TABLE.call.each_with_object({}) do |(key, (name, args, ret)), h|
+            h[key] = Fiddle::Function.new(@handle[name], args, ret)
+          end
+        end
+
+        def compress(codec, data, level)
+          out_len = [0].pack("Q")
+          ptr = @funcs[:compress].call(codec, data, data.bytesize, level, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def decompress(codec, data, expected_len)
+          out_len = [0].pack("Q")
+          ptr = @funcs[:decompress].call(codec, data, data.bytesize, expected_len, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def last_error
+          ptr = @funcs[:last_error].call
+          ptr.null? ? "unknown error" : ptr.to_s
+        end
+
+        # Copy out + free one returned buffer: the buffer belongs to
+        # the Rust allocator and must never outlive ozip_free.
+        def take(ptr, len)
+          s = ptr.to_s(len)
+          @funcs[:free].call(ptr, len)
+          s
+        end
+
+        def take_buffer(ptr, len)
+          take(ptr, len)
+        end
+
+        # The Rust release this cdylib was built from, or nil when the
+        # symbol is absent (dylibs older than 0.21.109).
+        def dylib_version
+          func = Fiddle::Function.new(@handle["ozip_version"], [], Fiddle::TYPE_VOIDP)
+          ptr = func.call
+          ptr.null? ? nil : ptr.to_s
+        rescue StandardError
+          nil
+        end
+
+        # ---- whole-archive surface (ArchHandle) ----
+
+        def arch_open(data, password)
+          pw = password&.to_s
+          pw_ptr = pw && !pw.empty? ? Fiddle::Pointer[pw] : nil
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_open"],
+            %i[voidp size_t voidp],
+            Fiddle::TYPE_VOIDP,
+          ).call(Fiddle::Pointer[data], data.bytesize, pw_ptr)
+          raise Rust::Error, last_error if ptr.null?
+
+          ptr
+        end
+
+        def arch_count(handle)
+          fn = Fiddle::Function.new(@handle["ozip_arch_count"], [:voidp], Fiddle::TYPE_SIZE_T)
+          fn.call(handle)
+        end
+
+        def arch_entry_name(handle, index)
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_entry_name"], %i[voidp size_t], Fiddle::TYPE_VOIDP
+          ).call(handle, index)
+          ptr.null? ? nil : ptr.to_s
+        end
+
+        def arch_entry_size(handle, index)
+          Fiddle::Function.new(
+            @handle["ozip_arch_entry_size"], %i[voidp size_t], Fiddle::TYPE_VOIDP
+          ).call(handle, index)
+        end
+
+        def arch_read_entry(handle, index)
+          out_len = [0].pack("Q")
+          ptr = Fiddle::Function.new(
+            @handle["ozip_arch_read_entry"], %i[voidp size_t voidp], Fiddle::TYPE_VOIDP
+          ).call(handle, index, out_len)
+          raise Rust::Error, last_error if ptr.null?
+
+          take(ptr, out_len.unpack1("Q"))
+        end
+
+        def arch_close(handle)
+          Fiddle::Function.new(@handle["ozip_arch_close"], [:voidp], Fiddle::TYPE_VOID)
+            .call(handle)
+        end
+      end
+    end
+  end
+end

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

@@ -11,23 +11,32 @@ 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).
+      # The loaded cdylib binding: one handle, lazily opened. The
+      # BINDING LAYER is chosen at load (leptris-ruby's model):
+      #
+      #   1. Fiddle (MRI stdlib — the zero-gem fast path)
+      #   2. the ffi gem (JRuby / TruffleRuby ship it bundled; MRI
+      #      without fiddle — Ruby 4.0 without the gem — uses it too)
+      #   3. unavailable (pure-Ruby core everywhere)
+      #
+      # OMNIZIP_BINDING=fiddle|ffi forces a layer (spec seam; also the
+      # way to prove the ffi path on MRI). `instance` returns a
+      # FiddleLibrary or FfiLibrary — both expose the identical
+      # surface (compress / decompress / last_error / take_buffer /
+      # dylib_version / arch_*), so callers are binding-agnostic.
       class Library
-        # Codecs the cdylib dispatches by name.
-        # Names the cdylib dispatches: the codec-level acceleration
-        # surface (both directions by default — Rust is the
-        # authority; Ruby is the fallback).
+        # Codecs the cdylib dispatches by name: the codec-level
+        # acceleration surface (both directions by default — Rust is
+        # the authority; Ruby is the fallback).
         CODECS = %w[
           bzip2 zstd lzma xz lzma-alone lzip
           deflate deflate64 zlib gzip ppmd7 ppmd8
         ].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.
+          # The shared binding, or nil when no layer can load. Load
+          # failures are cached per layer: a missing library is a
+          # stable condition, not something to re-attempt per call.
           def instance
             return @instance if defined?(@instance)
 
@@ -38,6 +47,13 @@ module Omnizip
             !instance.nil?
           end
 
+          # Which binding loaded: "fiddle", "ffi", or nil.
+          def binding_layer
+            return nil if instance.nil?
+
+            instance.class.name.end_with?("FfiLibrary") ? "ffi" : "fiddle"
+          end
+
           # Whether the cdylib dispatches this codec name — exact, or
           # a param-carrying prefix ("ppmd7:o6:m16777216" under
           # "ppmd7").
@@ -45,7 +61,7 @@ module Omnizip
             CODECS.any? { |c| name == c || name.start_with?("#{c}:") }
           end
 
-          # Drop the cached handle so resolution reruns (test seam:
+          # Drop the cached binding so resolution reruns (test seam:
           # specs exercising fallback/absence paths need a clean
           # slate; production never calls this).
           def forget!
@@ -56,39 +72,12 @@ module Omnizip
             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
-
           # The Rust release the loaded cdylib was built from (e.g.
-          # "0.21.108"), read through the ozip_version symbol — the
+          # "0.21.112"), read through the ozip_version symbol — the
           # platform-gem smoke gate asserts it matches. nil when the
           # library is absent or predates the symbol.
           def dylib_version
-            handle = instance&.instance_handle
-            return nil if handle.nil?
-
-            func = Fiddle::Function.new(handle["ozip_version"], [], Fiddle::TYPE_VOIDP)
-            ptr = func.call
-            ptr.null? ? nil : ptr.to_s
-          rescue StandardError
-            nil
+            instance&.dylib_version
           end
 
           # Resolve the cdylib path. Precedence:
@@ -133,12 +122,17 @@ module Omnizip
             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)
+            forced = ENV.fetch("OMNIZIP_BINDING", nil)
+            if forced != "ffi" && defined?(Fiddle)
+              return FiddleLibrary.new(path)
             end
-            new(funcs, handle)
-          rescue StandardError => e # includes Fiddle::DLError
+
+            # The ffi path: JRuby/TruffleRuby bundle the gem; MRI
+            # needs it installed (it is a runtime dependency). A
+            # forced layer must not silently fall back to another.
+            require "ffi"
+            FfiLibrary.new(path)
+          rescue LoadError, StandardError => e # Fiddle::DLError, FFI::LoadError, ...
             warn "omnizip: rust backend unavailable (#{e.message}); using pure Ruby" if ENV["OMNIZIP_BACKEND"] == "rust"
             nil
           end
@@ -152,65 +146,6 @@ module Omnizip
             end
           end
         end
-
-        def initialize(functions, handle = nil)
-          @functions = functions.freeze
-          @handle = handle
-        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
-
-        # Bind one extra C symbol from the loaded cdylib (the archive
-        # surface uses this; Fiddle::Function is immutable once built).
-        def bind(symbol, args, ret)
-          handle = instance_handle
-          raise Error, "cdylib not loaded" if handle.nil?
-
-          Fiddle::Function.new(handle[symbol.to_s], args, ret)
-        end
-
-        def last_error
-          ptr = @functions[:last_error].call
-          ptr.null? ? "unknown error" : ptr.to_s
-        end
-
-        # The raw Fiddle::Handle (for extra symbol binds).
-        def instance_handle
-          @handle
-        end
-
-        # Copy out + free one returned buffer (public seam for the
-        # archive surface).
-        def take_buffer(ptr, len)
-          take(ptr, len)
-        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