lz4rip 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f66c12c967a06a207c9e8e742fac306280863bf655bd7b4318a2265d08c1cdf
-  data.tar.gz: be95ea7eb336509e7077737f0d4703dc500931f1608fdc2f52dc3b170904b16d
+  metadata.gz: ca8b2f012551b63cf5efaaee91d49b319486300a9bb1e22f0d79d64d868ba076
+  data.tar.gz: ff7f8c704a56fa29e80ade1d046f3e7fb93eac22bca44d8b684a4727db69355d
 SHA512:
-  metadata.gz: 2fc02b8f797989ca99f23e97658dab9442c4fbb70ab03ff3436a73b5026b78d20c1bbf240e4febba0baed905863b225655f03c627d6db4ddee128224b419c82c
-  data.tar.gz: 92b2aa66f6282317c5b805f77cf47715288c8debc013520e5dffc78fb7d9c102f62f330906042b062b93aa2104ca21c5b1b0830edd87852b585f6451f4146efd
+  metadata.gz: 689b55762fed92109d07f280cc1d534e3f4e71ba76c63c1a6c149441ded0ae08d21e4d134a7000f1b4fb40941e7768856113e82272ce88e359bfedcc1b97e3ff
+  data.tar.gz: 7f0a1a29b634874f60bde320df035aa14e6cd0080758a3dbd7e3147a74e88e3c1327ee77d1cf383448f591c6162d76e6355637286eed3ee74958e0315eb3d3fc

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-11
+
+- Update the `lz4rip` crate dependency to 0.11.10 and `rb-sys` to 0.9.130.
+- Make `FrameCodec` instances Ractor-shareable as documented, with native
+  dictionary copies that leave caller strings mutable.
+- Unlock input strings and free native results when Ruby interrupts a call
+  that released the GVL.
+- Protect mutable inputs when mutex contention releases the GVL, including
+  calls below the normal size threshold.
+- Catch Rust panics inside native callbacks instead of aborting the process.
+- Preserve Ruby exceptions, `Thread#kill`, and `catch`/`throw` through
+  protected native calls.
+- Avoid trainer deadlocks during sample coercion and borrow decompression
+  input after size coercion.
+- Update GitHub Actions checkout to v7 and check Rust tests, formatting, and
+  Clippy in CI.
+
 ## [0.2.0] - 2026-08-07
 
 - Release the Ruby GVL around large frame/block compression and frame

data/Cargo.lock

@@ -31,9 +31,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.13.1"
+version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "cexpr"
@@ -46,9 +46,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 
 [[package]]
 name = "clang-sys"
@@ -63,9 +63,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.17.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
 
 [[package]]
 name = "glob"
@@ -84,15 +84,15 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
 
 [[package]]
 name = "libc"
-version = "0.2.189"
+version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
 [[package]]
 name = "libloading"
@@ -106,17 +106,17 @@ dependencies = [
 
 [[package]]
 name = "lz4rip"
-version = "0.1.2"
+version = "0.2.1"
 dependencies = [
- "lz4rip 0.11.3",
+ "lz4rip 0.11.10",
  "rb-sys",
 ]
 
 [[package]]
 name = "lz4rip"
-version = "0.11.3"
+version = "0.11.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55bde261679fd1d14bcae126094d7afb98c63c1a5018d0718741b658b686e950"
+checksum = "37d8ecd80125a8e67ebcaacd9fad5757efa2b6f5b875e1b4ce567814d758a419"
 dependencies = [
  "lz4rip-core",
  "lz4rip-decode",
@@ -126,24 +126,24 @@ dependencies = [
 
 [[package]]
 name = "lz4rip-core"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22fc4edb61fcaf1cdad24ac2982eff7af4417ef463c33bcf5c42ba549abd8b96"
+checksum = "edb50206b4d66e3ec849d2e7ac9257d79c19733c435909a0a46cbb34f9ec7107"
 
 [[package]]
 name = "lz4rip-decode"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60d65bfd4c032fefcf8c18fb5f8d9958f4925146845db16dbc9d416f1566b9bf"
+checksum = "d89c54c126f2acb3979c7d8fc9482506d6371438f514f2e83ef96ede9b585594"
 dependencies = [
  "lz4rip-core",
 ]
 
 [[package]]
 name = "lz4rip-encode"
-version = "0.10.5"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09e92b7345788ec0d32b5e31051dc6a86730e17b01267e502e9ec2744b689d34"
+checksum = "51a3509ddaac04400136c19f6a2d8427c18c46357eb584c9908b3ff476dcd13e"
 dependencies = [
  "lz4rip-core",
 ]
@@ -190,18 +190,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -272,15 +272,15 @@ dependencies = [
 
 [[package]]
 name = "twox-hash"
-version = "2.1.3"
+version = "2.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8464ec13c3691491391d9fce00f6416c9a48e46972f72d7865688be2080192c9"
+checksum = "86a801b3cea342a06d468c8710662aa29e5e05e4f5c0d62f00bbb7f2ad7941c2"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.24"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
 
 [[package]]
 name = "windows-link"

data/Cargo.toml

@@ -6,4 +6,3 @@ resolver = "2"
 opt-level     = 3
 lto           = true
 codegen-units = 1
-panic         = "abort"

data/ext/lz4rip/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name    = "lz4rip"
-version = "0.1.2"
+version = "0.2.1"
 edition = "2021"
 build   = "build.rs"
 
@@ -9,8 +9,8 @@ name       = "lz4rip"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-lz4    = { version = "0.11.3", package = "lz4rip" }
-rb-sys = "0.9"
+lz4    = { version = "0.11.10", package = "lz4rip" }
+rb-sys = "0.9.130"
 
 [build-dependencies]
-rb-sys = "0.9"
+rb-sys = "0.9.130"

data/ext/lz4rip/src/lib.rs

@@ -40,27 +40,38 @@ fn should_release_frame_decompress_gvl(input_len: usize) -> bool {
     input_len >= GVL_FRAME_DECOMPRESS_THRESHOLD
 }
 
-fn with_mutex<T, R, F>(mutex: &Mutex<T>, release_gvl: bool, name: &str, func: F) -> RbResult<R>
+fn with_mutex<T, R, F>(
+    mutex: &Mutex<T>,
+    release_gvl: bool,
+    name: &str,
+    input: &mut rb::InputBytes,
+    func: F,
+) -> RbResult<R>
 where
-    F: FnOnce(&mut T) -> RbResult<R>,
+    F: FnOnce(&mut T, &[u8]) -> RbResult<R>,
 {
     if release_gvl {
+        input.lock_for_without_gvl(true)?;
         return rb::maybe_without_gvl(true, || {
             let mut guard = mutex
                 .lock()
                 .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
-            func(&mut guard)
-        });
+            func(&mut guard, input.as_slice())
+        })?;
     }
 
     match mutex.try_lock() {
-        Ok(mut guard) => func(&mut guard),
-        Err(TryLockError::WouldBlock) => rb::maybe_without_gvl(true, || {
-            let mut guard = mutex
-                .lock()
-                .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
-            func(&mut guard)
-        }),
+        Ok(mut guard) => func(&mut guard, input.as_slice()),
+        Err(TryLockError::WouldBlock) => {
+            // Even a small input needs protection when contention releases GVL.
+            input.lock_for_without_gvl(true)?;
+            rb::maybe_without_gvl(true, || {
+                let mut guard = mutex
+                    .lock()
+                    .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
+                func(&mut guard, input.as_slice())
+            })?
+        }
         Err(TryLockError::Poisoned(_)) => Err(RubyErr::runtime(format!("{name} mutex poisoned"))),
     }
 }
@@ -122,7 +133,7 @@ fn make_frame_codec_data_type() -> rb_data_type_t {
         },
         parent: std::ptr::null(),
         data: std::ptr::null_mut(),
-        flags: 1,
+        flags: rb::frozen_shareable_flags(),
     }
 }
 
@@ -260,10 +271,14 @@ fn block_codec_compress_impl(rb_self: VALUE, rb_input: VALUE) -> RbResult<VALUE>
     input.lock_for_without_gvl(release_gvl)?;
 
     let out = match &rb_self.compressor {
-        None => rb::maybe_without_gvl(release_gvl, || Ok(block::compress(input.as_slice())))?,
-        Some(comp) => with_mutex(comp, release_gvl, "BlockCodec compressor", |comp| {
-            Ok(comp.compress(input.as_slice()))
-        })?,
+        None => rb::maybe_without_gvl(release_gvl, || block::compress(input.as_slice()))?,
+        Some(comp) => with_mutex(
+            comp,
+            release_gvl,
+            "BlockCodec compressor",
+            &mut input,
+            |comp, input| Ok(comp.compress(input)),
+        )?,
     };
 
     rb::new_binary_string(&out)
@@ -275,14 +290,18 @@ fn block_codec_decompress_impl(
     decompressed_size: VALUE,
 ) -> RbResult<VALUE> {
     let rb_self = unsafe { block_codec_ref(rb_self)? };
-    let compressed = rb::input_bytes(rb_input)?;
     let decompressed_size = rb::value_to_usize(decompressed_size)?;
+    let mut compressed = rb::input_bytes(rb_input)?;
 
     let result = match &rb_self.decompressor {
         None => block::decompress(compressed.as_slice(), decompressed_size),
-        Some(decomp) => with_mutex(decomp, false, "BlockCodec decompressor", |decomp| {
-            Ok(decomp.decompress(compressed.as_slice(), decompressed_size))
-        })?,
+        Some(decomp) => with_mutex(
+            decomp,
+            false,
+            "BlockCodec decompressor",
+            &mut compressed,
+            |decomp, compressed| Ok(decomp.decompress(compressed, decompressed_size)),
+        )?,
     };
 
     match result {
@@ -331,23 +350,16 @@ struct DictBound {
 
 fn frame_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE) -> RbResult<VALUE> {
     let id = rb::value_to_u32(id)?;
-    let dict = if rb_dict == rb::qnil() {
-        None
-    } else {
-        let rb_dict = rb::string_value(rb_dict)?;
-        rb::freeze_value(rb_dict)?;
-        Some(DictBound {
-            bytes: rb::value_to_bytes(rb_dict)?,
-            id,
-        })
-    };
-    unsafe {
+    let dict = rb::value_to_option_bytes(rb_dict)?.map(|bytes| DictBound { bytes, id });
+    let codec = unsafe {
         rb::wrap_typed_data(
             class,
             Box::new(FrameCodec { dict }),
             frame_codec_data_type(),
-        )
-    }
+        )?
+    };
+    rb::make_shareable(codec)?;
+    Ok(codec)
 }
 
 fn frame_codec_compress_impl(rb_self: VALUE, rb_input: VALUE) -> RbResult<VALUE> {
@@ -356,7 +368,7 @@ fn frame_codec_compress_impl(rb_self: VALUE, rb_input: VALUE) -> RbResult<VALUE>
     let release_gvl = should_release_compress_gvl(input.len());
     input.lock_for_without_gvl(release_gvl)?;
 
-    let out = rb::maybe_without_gvl(release_gvl, || compress_frame(rb_self, input.as_slice()))
+    let out = rb::maybe_without_gvl(release_gvl, || compress_frame(rb_self, input.as_slice()))?
         .map_err(RubyErr::runtime)?;
 
     rb::new_binary_string(&out)
@@ -389,8 +401,8 @@ fn frame_codec_decompress_impl(
     max_decompressed_size: VALUE,
 ) -> RbResult<VALUE> {
     let rb_self = unsafe { frame_codec_ref(rb_self)? };
-    let mut input = rb::input_bytes(rb_input)?;
     let max_decompressed_size = rb::value_to_option_usize(max_decompressed_size)?;
+    let mut input = rb::input_bytes(rb_input)?;
     let release_gvl = should_release_frame_decompress_gvl(input.len());
     input.lock_for_without_gvl(release_gvl)?;
 
@@ -403,7 +415,7 @@ fn frame_codec_decompress_impl(
 
     let out = rb::maybe_without_gvl(release_gvl, || {
         decompress_frame(rb_self, input.as_slice(), max_decompressed_size)
-    })
+    })?
     .map_err(|e| RubyErr::new(decompress_error(), e))?;
 
     rb::new_binary_string(&out)
@@ -496,6 +508,7 @@ fn dict_trainer_new_impl(class: VALUE, max_dict_size: VALUE) -> RbResult<VALUE>
 }
 
 fn dict_trainer_add_sample_impl(rb_self: VALUE, rb_data: VALUE) -> RbResult<VALUE> {
+    let data = rb::input_bytes(rb_data)?;
     let rb_self = unsafe { dict_trainer_ref(rb_self)? };
     let mut borrow = rb_self
         .inner
@@ -504,7 +517,6 @@ fn dict_trainer_add_sample_impl(rb_self: VALUE, rb_data: VALUE) -> RbResult<VALU
     let trainer = borrow
         .as_mut()
         .ok_or_else(|| RubyErr::runtime("DictTrainer already consumed by #train"))?;
-    let data = rb::input_bytes(rb_data)?;
     let sample = if data.len() > rb_self.max_dict_size {
         &data.as_slice()[..rb_self.max_dict_size]
     } else {

data/ext/lz4rip/src/rb.rs

@@ -1,6 +1,4 @@
 use std::ffi::{c_char, c_long, c_void, CStr, CString};
-#[cfg(ruby_engine = "mri")]
-use std::mem::MaybeUninit;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::ptr;
 
@@ -32,7 +30,7 @@ unsafe extern "C" {
 
 #[derive(Debug)]
 pub enum RubyErr {
-    Exception(VALUE),
+    Jump(i32),
     Error { class: VALUE, message: String },
 }
 
@@ -55,15 +53,6 @@ impl RubyErr {
     pub fn type_error(message: impl Into<String>) -> Self {
         Self::new(unsafe { rb_sys::rb_eTypeError }, message)
     }
-
-    fn current_exception() -> Self {
-        let err = unsafe { rb_sys::rb_errinfo() };
-        if err == qnil() {
-            Self::runtime("Ruby exception")
-        } else {
-            Self::Exception(err)
-        }
-    }
 }
 
 pub fn wrap<F>(f: F) -> VALUE
@@ -89,12 +78,15 @@ where
 }
 
 pub fn raise(err: RubyErr) -> ! {
-    let exc = match err {
-        RubyErr::Exception(exc) => exc,
-        RubyErr::Error { class, message } => error_exception(class, message),
-    };
-
-    unsafe { rb_sys::rb_exc_raise(exc) }
+    match err {
+        // Preserve Ruby's tag and pending error info for Thread#kill and
+        // catch/throw, as well as ordinary exceptions.
+        RubyErr::Jump(state) => unsafe { rb_sys::rb_jump_tag(state) },
+        RubyErr::Error { class, message } => {
+            let exc = error_exception(class, message);
+            unsafe { rb_sys::rb_exc_raise(exc) }
+        }
+    }
 }
 
 fn error_exception(class: VALUE, message: String) -> VALUE {
@@ -145,7 +137,7 @@ where
     };
 
     if state != 0 {
-        Err(RubyErr::current_exception())
+        Err(RubyErr::Jump(state))
     } else if data.panicked {
         Err(RubyErr::runtime("native Rust panic"))
     } else {
@@ -167,7 +159,7 @@ where
 #[cfg(ruby_engine = "mri")]
 struct WithoutGvlData<F, R> {
     func: Option<F>,
-    output: MaybeUninit<R>,
+    output: Option<std::thread::Result<R>>,
 }
 
 #[cfg(ruby_engine = "mri")]
@@ -176,49 +168,55 @@ where
     F: FnOnce() -> R,
 {
     let data = unsafe { &mut *(data.cast::<WithoutGvlData<F, R>>()) };
-    let func = data.func.take().expect("missing without-GVL function");
-    data.output.write(func());
+    // Rust panics must be caught before returning through the C callback.
+    data.output = Some(catch_unwind(AssertUnwindSafe(|| {
+        data.func.take().expect("missing without-GVL function")()
+    })));
     ptr::null_mut()
 }
 
 #[cfg(ruby_engine = "mri")]
-fn without_gvl<F, R>(func: F) -> R
+fn without_gvl<F, R>(func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
     let mut data = WithoutGvlData {
         func: Some(func),
-        output: MaybeUninit::uninit(),
+        output: None,
     };
-    unsafe {
+    // Ruby checks interrupts before and after the callback. Protect the call
+    // so an exception still drops native output and unlocks borrowed strings.
+    protect_unit(|| unsafe {
         rb_thread_call_without_gvl(
             Some(without_gvl_trampoline::<F, R>),
             (&mut data as *mut WithoutGvlData<F, R>).cast::<c_void>(),
             None,
             ptr::null_mut(),
         );
-        data.output.assume_init()
-    }
+    })?;
+    data.output
+        .ok_or_else(|| RubyErr::runtime("without-GVL callback did not run"))?
+        .map_err(|_| RubyErr::runtime("native Rust panic"))
 }
 
 #[cfg(ruby_engine = "mri")]
-pub fn maybe_without_gvl<F, R>(release_gvl: bool, func: F) -> R
+pub fn maybe_without_gvl<F, R>(release_gvl: bool, func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
     if release_gvl {
         without_gvl(func)
     } else {
-        func()
+        Ok(func())
     }
 }
 
 #[cfg(not(ruby_engine = "mri"))]
-pub fn maybe_without_gvl<F, R>(_release_gvl: bool, func: F) -> R
+pub fn maybe_without_gvl<F, R>(_release_gvl: bool, func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
-    func()
+    Ok(func())
 }
 
 pub const fn qnil() -> VALUE {
@@ -255,8 +253,23 @@ pub fn string_value(value: VALUE) -> RbResult<VALUE> {
     protect_value(|| unsafe { rb_sys::rb_str_to_str(value) })
 }
 
-pub fn freeze_value(value: VALUE) -> RbResult<()> {
-    protect_unit(|| unsafe { rb_sys::RB_OBJ_FREEZE(value) })
+pub fn frozen_shareable_flags() -> VALUE {
+    #[cfg(ruby_engine = "mri")]
+    {
+        // RUBY_TYPED_FROZEN_SHAREABLE equals RUBY_FL_SHAREABLE in Ruby headers.
+        1 | rb_sys::ruby_fl_type::RUBY_FL_SHAREABLE as VALUE
+    }
+    #[cfg(not(ruby_engine = "mri"))]
+    {
+        1
+    }
+}
+
+pub fn make_shareable(value: VALUE) -> RbResult<()> {
+    protect_unit(|| unsafe { rb_sys::RB_OBJ_FREEZE(value) })?;
+    #[cfg(ruby_engine = "mri")]
+    protect_value(|| unsafe { rb_sys::rb_ractor_make_shareable(value) })?;
+    Ok(())
 }
 
 pub fn value_to_bytes(value: VALUE) -> RbResult<Vec<u8>> {
@@ -626,3 +639,42 @@ unsafe fn transmute_3(
 fn c_long_len(len: usize) -> RbResult<c_long> {
     c_long::try_from(len).map_err(|_| RubyErr::arg("length too large"))
 }
+
+#[cfg(all(test, ruby_engine = "mri"))]
+mod tests {
+    use super::*;
+
+    fn run_callback<F, R>(func: F) -> std::thread::Result<R>
+    where
+        F: FnOnce() -> R,
+    {
+        let mut data = WithoutGvlData {
+            func: Some(func),
+            output: None,
+        };
+        unsafe {
+            without_gvl_trampoline::<F, R>(
+                (&mut data as *mut WithoutGvlData<F, R>).cast::<c_void>(),
+            );
+        }
+        data.output.unwrap()
+    }
+
+    #[test]
+    fn callback_catches_panics_before_returning_to_c() {
+        let dropped = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+        struct OnDrop(std::sync::Arc<std::sync::atomic::AtomicBool>);
+        impl Drop for OnDrop {
+            fn drop(&mut self) {
+                self.0.store(true, std::sync::atomic::Ordering::SeqCst);
+            }
+        }
+        let captured = OnDrop(dropped.clone());
+        let result = run_callback(move || {
+            let _captured = captured;
+            panic!("callback panic");
+        });
+        assert!(result.is_err());
+        assert!(dropped.load(std::sync::atomic::Ordering::SeqCst));
+    }
+}

data/lib/lz4rip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lz4rip
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lz4rip
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,6 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
 description: Ruby bindings (via Rust/rb-sys) for lz4rip, a pure-Rust LZ4 implementation.
   Block-format and frame-format compress/decompress with optional dictionary support
   and COVER-based dictionary training. Ractor-safe.
@@ -54,7 +60,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/paddor/lz4rip-rb
-  source_code_uri: https://github.com/paddor/lz4rip-rb
+  source_code_uri: https://github.com/paddor/lz4rip-rb/tree/main
   documentation_uri: https://rubydoc.info/gems/lz4rip
   changelog_uri: https://github.com/paddor/lz4rip-rb/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
@@ -72,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ractor-safe LZ4 compression for Ruby
 test_files: []