nosj 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d57a15d6dbdf7dc81518662ef44348f538b6dcf2a95098c3491c741b9e2517b6
-  data.tar.gz: e5508e9cf8ea61c51e21599ef4a887f024ab08a920a0c642dfcb3ac7fd7b4954
+  metadata.gz: 938bbe04908f0865a510008040c4a1bf8f1e4b1cb80821de3757e3ac078f2e47
+  data.tar.gz: feea0d89e6f7559642127a2333d01cc3f93b1d3763e54f6ed620b596a7102d30
 SHA512:
-  metadata.gz: 9a7797c890345c879153069e63808fa916fe0e5944376680a86ba30696ef7eec16a6a0f45ae7c428c08783c56bb1a08bed448c27d3b7a7075caea064edee4205
-  data.tar.gz: 29113d820443054acafaeda1a976f4a388424466d79d09353fac5980cc80d803937a800b6384ed9395d9386735420cbd378cc8a6e6629cd5bdbefd1bd70fd5bd
+  metadata.gz: b1ff3aef1231141f9333030016f1ff308a81ca27a1ad8318fadf2ce42c77869756c5674716485c4b5be4ca948290f4450142c59eed76df2894bde460cd0530bc
+  data.tar.gz: 5e40f2cfb493c13b546ef3367e02efafb7eea5697181b0daad9efeed89f06db58b0db798cd5cad2f09555ee900c673753595584829ab333bdc125c45eaeca41a

data/CHANGELOG.md

@@ -1,3 +1,47 @@
+## [0.4.1] - 2026-09-25
+
+- Fixed a crash in `NOSJ.generate`: an object whose `to_json` or
+  `to_s` shrank the array being generated (for example with
+  `Array#clear`) made the generator read freed memory, usually a
+  segfault. The array length is now re-read for every element, like
+  the json gem, so elements a callback appends are emitted too.
+- Fixed memory corruption in `NOSJ.splice`: a replacement value whose
+  `to_json` modified the source string, deduplicated a frozen String
+  subclass (`-str`), or removed entries from the edits hash could make
+  splice read freed memory, copying unrelated heap bytes into the
+  result or crashing. All values are now generated before the source
+  is read.
+- Fixed `NOSJ.lazy` and `NOSJ.each_line` reading freed memory when the
+  source is a frozen String subclass (such as
+  `ActiveSupport::SafeBuffer`) or a frozen string carrying instance
+  variables, and it is deduplicated with `-str` while the lazy
+  document is alive or between lines: Ruby swaps such a string's
+  buffer, and the old one kept being read (wrong values, or a crash).
+- Fixed a memory leak in `NOSJ.generate` and `NOSJ.write_file`: an
+  exception raised by user code the generator calls bypassed its
+  cleanup and leaked its output buffer (megabytes per call after large
+  documents). Affected: a raising `respond_to?` or
+  `respond_to_missing?`, a raising `to_s` on an encoding-conversion
+  error, a raising autoload of `JSON::Fragment` (strict and Rails
+  modes), and a raising `Errno` constructor for a failed write. The
+  exception still propagates unchanged.
+- Fixed: after a `NoMemoryError` in the middle of a parse (or
+  `minify`/`reformat`), the next call on that thread aborted the whole
+  process. Per-thread parser state is now recovered instead.
+- `NOSJ::Lazy` nodes now take part in generational GC: holding many
+  nodes no longer slows down every minor GC (200,000 live nodes: 2.9 ms
+  per minor GC before, 0.1 ms now), and they are freed immediately
+  when collected.
+- Fixed: lazy documents opened with `allow_trailing_comma: true` or
+  `allow_nan: true` could not be walked. `size`, `keys`, `each`, and
+  any lookup that missed or stepped over a trailing comma or a `NaN`
+  raised `NOSJ::ParserError`, even though `value` worked.
+- `NOSJ.at_pointer`, `NOSJ.at_pointers`, and `NOSJ.at_pointer_file`
+  now honor `allow_nan` and `allow_trailing_comma` while resolving the
+  pointer, not only when materializing the matched value.
+- Updated the nosj crate to 0.2.2.
+- Updated dependencies, Magnus bumped to 0.9.0.
+
 ## [0.4.0] - 2026-09-05
 
 - Ractors: on Ruby 4.0+, `NOSJ.parse`, `NOSJ.generate`, and every

data/Cargo.lock

@@ -44,9 +44,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"
@@ -59,9 +59,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"
@@ -137,9 +137,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
+checksum = "379d50b6eea4ca84074ccd3e551eb9b07f7865194d5b3198325317e9ef78e5e9"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -149,9 +149,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
+checksum = "4ca70566af98184bb92d4d9853daaf533c1a3418b9570d0547ea44970035f3fe"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -191,16 +191,16 @@ dependencies = [
 
 [[package]]
 name = "nosj"
-version = "0.2.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d25913644b7871b36095cc3da27daf95ebf9508189c5d8ccfb16da3bdb9f802f"
+checksum = "3d398b0019f2d8bf39b10de6038451b0f3d96a9e3111748097192d8f57d6f120"
 dependencies = [
  "fast-float2",
 ]
 
 [[package]]
 name = "nosj_native"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "ahash",
  "magnus",
@@ -335,9 +335,9 @@ dependencies = [
 
 [[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 = "version_check"
@@ -368,18 +368,18 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.56"
+version = "0.8.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb"
+checksum = "c17e8fafad82b542ff3717217ecdc736231b59e387768c9630123b4ce4d2db44"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.56"
+version = "0.8.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1"
+checksum = "595f56e044df4f46a0c9a626f65c3d99eb8488f7e8a8baa12dd76326d9710bf2"
 dependencies = [
  "proc-macro2",
  "quote",

data/README.md

@@ -151,7 +151,8 @@ Example: an early field resolves in ~0.35µs where `JSON.parse(json).dig(...)`
 costs ~980µs on the same document—three orders of magnitude. A field
 at the far end of a 570 KB document costs ~71µs, still 13× faster
 than parse-then-dig. Misses return nil; matched subtrees materialize
-with the same options as `parse` (`symbolize_names:`, `freeze:`).
+with the same options as `parse` (`symbolize_names:`, `freeze:`), and
+`allow_nan:`/`allow_trailing_comma:` govern the walk to them too.
 
 ### Files API
 

data/ext/nosj/Cargo.toml

@@ -5,7 +5,7 @@
 # required by lib/nosj.rb as "nosj/nosj" (Init_nosj set explicitly in
 # lib.rs). Gem name, module, and API are plain nosj.
 name = "nosj_native"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 authors = ["Yaroslav Markin <yaroslav@markin.net>"]
 license = "MIT"
@@ -16,13 +16,13 @@ name = "nosj"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-magnus = { version = "0.8", features = ["rb-sys"] }
-rb-sys = { version = "0.9.124", default-features = false }
-ahash = "0.8.11"
+magnus = { version = "0.9", features = ["rb-sys"] }
+rb-sys = { version = "0.9.130", default-features = false }
+ahash = "0.8.12"
 # Read-only file mapping for the file entry points (load_lazy_file,
 # at_pointer_file, dig_file): pages never touched are never read.
-memmap2 = "0.9"
+memmap2 = "0.9.11"
 # First-party SIMD JSON parse/generate library (github.com/yaroslav/nosj).
 # For coordinated crate+gem work, temporarily flip to
 # { path = "../../../nosj" } and restore before any commit or release.
-nosj = "0.2.0"
+nosj = "0.2.2"

data/ext/nosj/fuzz/Cargo.toml

@@ -13,7 +13,7 @@ libfuzzer-sys = "0.4"
 # crate. Only this harness enables "embed" (rb-sys/link-ruby): fuzz
 # binaries host their own VM, while the extension must never link
 # libruby (its symbols resolve from the host process at load time).
-magnus = { version = "0.8", features = ["embed", "rb-sys"] }
+magnus = { version = "0.9", features = ["embed", "rb-sys"] }
 # The extension as an rlib; its lib target is named `nosj` (the bundle
 # name), so rename the dependency to keep fuzz code readable.
 nosj_ext = { path = "..", package = "nosj_native" }

data/ext/nosj/src/files.rs

@@ -10,7 +10,7 @@
 //! I/O failures raise the mapped `Errno::*` exception, like `File`
 //! methods do.
 
-use std::cell::RefCell;
+use std::cell::Cell;
 use std::fs;
 use std::io::Read;
 
@@ -22,14 +22,15 @@ use crate::gen;
 use crate::lazy::{self, DocBytes};
 use crate::parse::{err, materialize, materialize_at, parse_native_opts, span_of, ParseNativeOpts};
 use crate::pointer::path_to_pointer;
-use crate::state::PULL_STATE;
+use crate::state::{with_pull_state, with_taken};
 
 const NOT_UTF8: &str = "input is not valid UTF-8";
 
 thread_local! {
     /// Reused read buffer for `load_file`: capacity survives across
-    /// calls, so a hot loop over files allocates nothing.
-    static FILE_BUF: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
+    /// calls, so a hot loop over files allocates nothing (see
+    /// `state::with_taken`).
+    static FILE_BUF: Cell<Vec<u8>> = const { Cell::new(Vec::new()) };
 }
 
 /// On Unix the raw OS error IS the errno `rb_syserr_new` expects.
@@ -58,6 +59,9 @@ fn errno_of(e: &std::io::Error) -> Option<i32> {
 
 /// Map an I/O failure onto the matching `Errno::*` exception (class
 /// parity with `File.read`/`File.write`; the message carries the path).
+/// Constructing it runs the class's `initialize` (overridable Ruby), so
+/// the call is protected; a raise there propagates in its place, as it
+/// would from `File.read`.
 fn io_error(ruby: &Ruby, path: &str, e: &std::io::Error) -> Error {
     use magnus::rb_sys::FromRawValue;
     let Some(errno) = errno_of(e) else {
@@ -66,8 +70,13 @@ fn io_error(ruby: &Ruby, path: &str, e: &std::io::Error) -> Error {
     let Ok(cpath) = std::ffi::CString::new(path) else {
         return runtime_error(ruby, format!("{e} - {path}"));
     };
+    let raw =
+        match magnus::rb_sys::protect(|| unsafe { rb_sys::rb_syserr_new(errno, cpath.as_ptr()) }) {
+            Ok(raw) => raw,
+            Err(raised) => return raised,
+        };
     // SAFETY: rb_syserr_new returns a live Errno exception instance.
-    let exc = unsafe { Value::from_raw(rb_sys::rb_syserr_new(errno, cpath.as_ptr())) };
+    let exc = unsafe { Value::from_raw(raw) };
     match magnus::Exception::from_value(exc) {
         Some(exc) => exc.into(),
         None => runtime_error(ruby, format!("{e} - {path}")),
@@ -84,23 +93,16 @@ pub fn load_file_native(
 ) -> Result<Value, Error> {
     let o = parse_native_opts(ruby, opts)?;
     let p = path.to_string()?;
-    FILE_BUF.with(|cell| {
-        let mut buf = cell
-            .try_borrow_mut()
-            .map_or_else(|_| Vec::new(), |mut b| std::mem::take(&mut *b));
+    with_taken(&FILE_BUF, |buf| {
         buf.clear();
-        let result = read_into(&mut buf, &p)
+        read_into(buf, &p)
             .map_err(|e| io_error(ruby, &p, &e))
             .and_then(|()| {
-                if std::str::from_utf8(&buf).is_err() {
+                if std::str::from_utf8(buf).is_err() {
                     return Err(err(ruby, NOT_UTF8.into()));
                 }
-                materialize(ruby, &buf, &o)
-            });
-        if let Ok(mut slot) = cell.try_borrow_mut() {
-            *slot = buf;
-        }
-        result
+                materialize(ruby, buf, &o)
+            })
     })
 }
 
@@ -190,10 +192,9 @@ fn resolve_file_pointer(
     o: &ParseNativeOpts,
 ) -> Result<Value, Error> {
     with_mapped_file(ruby, path, |map| {
-        let resolved = PULL_STATE.with(|cell| {
-            let mut state = cell.borrow_mut();
+        let resolved = with_pull_state(|state| {
             // SAFETY: UTF-8 checked by with_mapped_file.
-            unsafe { nosj::pointer_utf8_unchecked(&map, pointer, &mut state.bufs) }
+            unsafe { nosj::pointer_utf8_unchecked_with(&map, pointer, &mut state.bufs, o.popts) }
         });
         match resolved {
             Ok(None) => Ok(ruby.qnil().as_value()),

data/ext/nosj/src/gen/errors.rs

@@ -7,7 +7,7 @@ use magnus::rb_sys::AsRawValue;
 use magnus::value::ReprValue;
 use magnus::{Error, Ruby};
 
-use super::ruby::rstring_bytes;
+use super::ruby::{protected_to_s, rstring_bytes};
 use crate::errors::nosj_exception;
 
 pub(super) enum GenFail {
@@ -24,26 +24,28 @@ pub(super) enum GenFail {
 }
 
 /// The exception's `to_s` (its message), matching what the gem embeds
-/// when it wraps a secondary exception.
-fn error_message(err: &Error) -> String {
+/// when it wraps a secondary exception. Protected: an exception class
+/// may override `to_s`, and a raise there propagates in place of the
+/// GeneratorError (as it does from the gem).
+fn error_message(err: &Error) -> Result<String, Error> {
     if let ErrorType::Exception(exc) = err.error_type() {
-        let s = unsafe { rb_sys::rb_obj_as_string(exc.as_value().as_raw()) };
+        let s = protected_to_s(exc.as_value().as_raw())?;
         // Safety: rb_obj_as_string returns a T_STRING; the bytes are
         // copied into an owned String before any further Ruby call.
         let bytes = unsafe { rstring_bytes(s) };
-        return String::from_utf8_lossy(bytes).into_owned();
+        return Ok(String::from_utf8_lossy(bytes).into_owned());
     }
-    err.to_string()
+    Ok(err.to_string())
 }
 
 pub(super) fn raise_fail(ruby: &Ruby, fail: GenFail) -> Error {
     match fail {
         GenFail::Reraise(err) => err,
         GenFail::Generator(msg) => Error::new(nosj_exception(ruby, "GeneratorError"), msg),
-        GenFail::GeneratorFrom(err) => {
-            let msg = error_message(&err);
-            Error::new(nosj_exception(ruby, "GeneratorError"), msg)
-        }
+        GenFail::GeneratorFrom(err) => match error_message(&err) {
+            Ok(msg) => Error::new(nosj_exception(ruby, "GeneratorError"), msg),
+            Err(raised) => raised,
+        },
         GenFail::Nesting(limit) => Error::new(
             nosj_exception(ruby, "NestingError"),
             format!(

data/ext/nosj/src/gen/mod.rs

@@ -31,6 +31,7 @@ use magnus::rb_sys::{AsRawValue, FromRawValue};
 use magnus::{Error, RString, Ruby, Value};
 use std::cell::Cell;
 
+use crate::state::with_taken;
 use errors::raise_fail;
 use keys::GenKeyCache;
 pub(crate) use ruby::warm_up;
@@ -57,6 +58,7 @@ struct GenScratch {
 }
 
 impl GenScratch {
+    #[cold]
     fn fresh() -> Box<Self> {
         Box::new(GenScratch {
             buf: Vec::new(),
@@ -70,17 +72,13 @@ thread_local! {
     static GEN_SCRATCH: Cell<Option<Box<GenScratch>>> = const { Cell::new(None) };
 }
 
-/// Run `f` on this thread's scratch, then store it back, replacing one a
-/// recursive generate stored meanwhile (the outermost call's is the warm
-/// one; the replaced scratch's key cache keeps its shadow, exactly as
-/// the old fallback arm's did).
+/// Run `f` on this thread's scratch (see [`with_taken`]). A recursive
+/// generate stores its own fresh scratch meanwhile; the outermost call's
+/// warm one replaces it (the replaced key cache keeps its shadow).
 fn with_scratch<R>(f: impl FnOnce(&mut GenScratch) -> R) -> R {
-    let mut scratch = GEN_SCRATCH
-        .with(Cell::take)
-        .unwrap_or_else(GenScratch::fresh);
-    let result = f(&mut scratch);
-    GEN_SCRATCH.with(|cell| cell.set(Some(scratch)));
-    result
+    with_taken(&GEN_SCRATCH, |slot| {
+        f(slot.get_or_insert_with(GenScratch::fresh))
+    })
 }
 
 /// `NOSJ.generate(obj, opts = nil)`, registered as a variadic native

data/ext/nosj/src/gen/ruby.rs

@@ -23,6 +23,21 @@ pub(super) fn protected_to_json(v: VALUE) -> Result<VALUE, Error> {
     magnus::rb_sys::protect(|| unsafe { rb_sys::rb_funcall(v, to_json_id(), 0) })
 }
 
+/// `v.to_json` if `v.respond_to?(:to_json)`, else `None`, under ONE
+/// protect: `rb_respond_to` dispatches to a user-defined `respond_to?` /
+/// `respond_to_missing?`, which may raise just like `to_json` itself.
+pub(super) fn protected_to_json_if_responds(v: VALUE) -> Result<Option<VALUE>, Error> {
+    const QUNDEF: VALUE = ruby_special_consts::RUBY_Qundef as VALUE;
+    let json = magnus::rb_sys::protect(|| unsafe {
+        if rb_sys::rb_respond_to(v, to_json_id()) != 0 {
+            rb_sys::rb_funcall(v, to_json_id(), 0)
+        } else {
+            QUNDEF
+        }
+    })?;
+    Ok((json != QUNDEF).then_some(json))
+}
+
 /// `v.as_json`, protected. Argument-less on purpose: ActiveSupport's
 /// JSONGemEncoder#jsonify recursion also calls as_json without
 /// options (only the top-level value receives them).
@@ -53,33 +68,37 @@ pub(crate) fn warm_up() {
 /// first generate is still found; a fragment instance existing implies
 /// its class does. The cached VALUE is a constant of the JSON module,
 /// so it can never be collected.
-pub(super) fn is_json_fragment(v: VALUE) -> bool {
+pub(super) fn is_json_fragment(v: VALUE) -> Result<bool, Error> {
     use std::sync::atomic::{AtomicUsize, Ordering};
     static FRAGMENT: AtomicUsize = AtomicUsize::new(0);
-    let mut cls = FRAGMENT.load(Ordering::Relaxed);
+    let mut cls = FRAGMENT.load(Ordering::Relaxed) as VALUE;
     if cls == 0 {
-        cls = resolve_json_fragment();
+        cls = resolve_json_fragment()?;
         if cls == 0 {
-            return false;
+            return Ok(false);
         }
-        FRAGMENT.store(cls, Ordering::Relaxed);
+        FRAGMENT.store(cls as usize, Ordering::Relaxed);
     }
-    unsafe { rb_sys::rb_obj_is_kind_of(v, cls as VALUE) != QFALSE }
+    Ok(unsafe { rb_sys::rb_obj_is_kind_of(v, cls) != QFALSE })
 }
 
-fn resolve_json_fragment() -> usize {
+/// `JSON::Fragment`, or 0 while undefined. Only the `rb_const_get`s are
+/// protected: fetching a constant can run its pending autoload (user
+/// code, whose raise propagates as any constant reference's would),
+/// while `rb_const_defined` never loads anything.
+fn resolve_json_fragment() -> Result<VALUE, Error> {
     unsafe {
         let object = rb_sys::rb_cObject;
         let json_id = rb_sys::rb_intern(c"JSON".as_ptr());
         if rb_sys::rb_const_defined(object, json_id) == 0 {
-            return 0;
+            return Ok(0);
         }
-        let json = rb_sys::rb_const_get(object, json_id);
+        let json = magnus::rb_sys::protect(|| rb_sys::rb_const_get(object, json_id))?;
         let fragment_id = rb_sys::rb_intern(c"Fragment".as_ptr());
         if rb_sys::rb_const_defined(json, fragment_id) == 0 {
-            return 0;
+            return Ok(0);
         }
-        rb_sys::rb_const_get(json, fragment_id) as usize
+        magnus::rb_sys::protect(|| rb_sys::rb_const_get(json, fragment_id))
     }
 }
 
@@ -95,7 +114,7 @@ pub(super) fn protected_encode_utf8(v: VALUE) -> Result<VALUE, Error> {
 }
 
 /// Interned `to_json` method ID, resolved once per process.
-pub(super) fn to_json_id() -> rb_sys::ID {
+fn to_json_id() -> rb_sys::ID {
     static TO_JSON: OnceLock<usize> = OnceLock::new();
     *TO_JSON.get_or_init(|| unsafe { rb_sys::rb_intern(c"to_json".as_ptr()) } as usize)
         as rb_sys::ID
@@ -109,12 +128,16 @@ pub(super) fn utf8_encindexes() -> (c_int, c_int) {
 // Coderange and encoding index live in RBasic flags (public ABI); reading
 // them inline instead of calling rb_enc_str_coderange / rb_enc_get_index is
 // how the gem avoids two C calls per string (RB_ENC_CODERANGE,
-// RB_ENCODING_GET_INLINED).
-const CR_MASK: u64 = 3 << 20;
-pub(super) const CR_7BIT: u64 = 1 << 20;
-pub(super) const CR_VALID: u64 = 2 << 20;
-const ENC_SHIFT: u64 = 22;
-const ENC_MASK: u64 = 127 << 22;
+// RB_ENCODING_GET_INLINED). The bit layout comes from rb-sys's bindings,
+// generated from the headers of the Ruby being built against, so it
+// follows any layout change instead of silently misreading flags.
+const CR_MASK: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_MASK as u64;
+pub(super) const CR_7BIT: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_7BIT as u64;
+pub(super) const CR_VALID: u64 = rb_sys::ruby_coderange_type::RUBY_ENC_CODERANGE_VALID as u64;
+const ENC_SHIFT: u64 = rb_sys::ruby_encoding_consts::RUBY_ENCODING_SHIFT as u64;
+const ENC_MASK: u64 = rb_sys::ruby_encoding_consts::RUBY_ENCODING_MASK as u64;
+/// Inline encoding-index sentinel: the real index is stored out of line.
+const ENC_INLINE_MAX: c_int = rb_sys::ruby_encoding_consts::RUBY_ENCODING_INLINE_MAX as c_int;
 
 #[inline(always)]
 pub(super) fn str_coderange(s: VALUE) -> u64 {
@@ -131,18 +154,18 @@ pub(super) fn str_coderange(s: VALUE) -> u64 {
 pub(super) fn str_enc_index(s: VALUE) -> c_int {
     let flags = unsafe { (*(s as *const rb_sys::RBasic)).flags };
     let idx = ((flags & ENC_MASK) >> ENC_SHIFT) as c_int;
-    if idx == 127 {
-        // RUBY_ENCODING_INLINE_MAX sentinel: index stored out of line.
+    if idx == ENC_INLINE_MAX {
         unsafe { rb_sys::rb_enc_get_index(s) }
     } else {
         idx
     }
 }
 
+/// `RB_SPECIAL_CONST_P` (immediates plus Qnil/Qfalse), through rb-sys's
+/// inline versioned stable API rather than a hand-copied bit test.
 #[inline(always)]
 pub(super) fn is_special_const(v: VALUE) -> bool {
-    // RB_SPECIAL_CONST_P: immediates plus Qnil/Qfalse.
-    (v & (ruby_special_consts::RUBY_IMMEDIATE_MASK as VALUE)) != 0 || v == QNIL || v == QFALSE
+    rb_sys::macros::SPECIAL_CONST_P(v)
 }
 
 /// Borrow a Ruby String's bytes.