mini_racer_rs 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b53466394528b78785dc0cac7e884a5b59f0200ca037d405c95375152a12d72
-  data.tar.gz: 06b9b34066ec568f0a41186f5f7c533c3a17f7acb90a625ec8e9fff22b3069f5
+  metadata.gz: dfd3987a3aebfd95013e67e552b2041b991fd7b0da4933f98ae92335f7caa3a4
+  data.tar.gz: 51ccdf38b39ab3f33f771f3cf7fdbd7422bda16037e8bc026cfd64dc6fdfbdae
 SHA512:
-  metadata.gz: 7e9f4ee092b37374b56a701831bd4ba868af74de863c220a9f58aae583505cc3c4000106107cfe8c8e709552863d5b484b8715cd016306ecb06241f2d84fe759
-  data.tar.gz: d5dc38c171b8d11683d53840d6c671cbf90ae042dba02f1a46e9786f343e555356808e41e2fb460b00a440c326a2da23f737b1149ab96d359b4e2269981c8b36
+  metadata.gz: ca5321d48ea8913f86d8966b6f475857d11b962c1f109e15f049fed590a517233f2cc3772fad99a9ff189f110995d3b2a0268f54e9f90aa48fcdd3cc1ac2b916
+  data.tar.gz: 3c2a6c804148cfd0bdf198d5a63ef4b440d63c667d7468ab646e8b85b277eb15ec0fa26f5d9877f426c01427e8f841723cf31d00bec0ee546881c895d373c61b

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.3](https://github.com/andymai/mini_racer_rs/compare/v1.0.2...v1.0.3) (2026-10-18)
+
+
+### Performance
+
+* **decode:** intern hash keys, build each Hash at once, and transcode strings in one pass ([#87](https://github.com/andymai/mini_racer_rs/issues/87)) ([220bfe7](https://github.com/andymai/mini_racer_rs/commit/220bfe7e6a9c8fa5a38befefcb4995756c377944))
+
 ## [1.0.2](https://github.com/andymai/mini_racer_rs/compare/v1.0.1...v1.0.2) (2026-10-18)
 
 

data/Cargo.lock

@@ -458,7 +458,7 @@ checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "mini_racer_engine"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "deno_core_icudata",
  "libc",
@@ -470,7 +470,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_rs"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "magnus",
  "mini_racer_engine",
@@ -481,7 +481,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_sync"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "loom",
  "thiserror",
@@ -489,7 +489,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_wire"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "proptest",
  "thiserror",

data/Cargo.toml

@@ -14,7 +14,7 @@ license = "MIT"
 publish = false
 repository = "https://github.com/andymai/mini_racer_rs"
 rust-version = "1.91"
-version = "1.0.2"
+version = "1.0.3"
 
 [workspace.dependencies]
 deno_core_icudata = "=0.78.0"

data/crates/mini_racer_wire/src/decode.rs

@@ -85,6 +85,12 @@ pub trait Visitor {
 
     fn end(&mut self, frame: Self::Frame) -> Result<Self::Value, Self::Error>;
 
+    /// A key that is a string, for an entry of `frame` other than an error's
+    /// fields, which would otherwise reach `scalar` as text.
+    fn key(&mut self, _frame: &Self::Frame, text: Text<'_>) -> Result<Self::Value, Self::Error> {
+        self.scalar(Scalar::Text(text))
+    }
+
     /// Remembers `value` as V8's object `id` for later back references. Ids
     /// arrive in increasing order, except that a container whose `begin`
     /// returned no value is registered when it ends.
@@ -650,11 +656,27 @@ impl<'a, 'v, V: Visitor> Decoder<'a, 'v, V> {
     }
 
     fn insert(&mut self, frame: &mut V::Frame, depth: u32) -> Result<(), DecodeError<V::Error>> {
-        let key = self.value(Self::child(depth)?)?;
-        let value = self.value(Self::child(depth)?)?;
+        let depth = Self::child(depth)?;
+        let key = self.entry_key(frame, depth)?;
+        let value = self.value(depth)?;
         Self::visit(self.visitor.insert(frame, key, value))
     }
 
+    // A key that is not a string is read again as a value: handing `value` its
+    // tag would split `value` in two, and the half with the containers takes
+    // them all inline. Out of line, so `insert` stays inside the container's
+    // frame; a deep result repeats every frame on the way down.
+    #[inline(never)]
+    fn entry_key(&mut self, frame: &V::Frame, depth: u32) -> Decoded<V> {
+        let start = self.reader;
+        let tag = self.tag()?;
+        if let Some(text) = self.text(tag)? {
+            return Self::visit(self.visitor.key(frame, text));
+        }
+        self.reader = start;
+        self.value(depth)
+    }
+
     // Reads keyed entries up to `end`, which may follow padding only if a key does.
     fn entries(
         &mut self,

data/crates/mini_racer_wire/src/text.rs

@@ -1,68 +1,130 @@
-// Returned HTML is mostly ASCII, which is copied in spans; only blocks holding
-// another byte are converted a byte at a time.
+// Returned HTML is mostly ASCII, which is copied in blocks; only blocks
+// holding another byte are converted a byte at a time.
 const LATIN1_BLOCK: usize = 32;
-// Each block's count of non-ASCII bytes is summed in a u8.
-const _: () = assert!(LATIN1_BLOCK <= u8::MAX as usize);
+// Lengths are counted a block at a time in a u8, which vectorizes; a UTF-16
+// unit adds at most 3.
+const COUNT_BLOCK: usize = 64;
+const _: () = assert!(COUNT_BLOCK * 3 <= u8::MAX as usize);
 
-#[expect(clippy::expect_used, reason = "callers pass only spans of ASCII bytes")]
-fn ascii(bytes: &[u8]) -> &str {
-    std::str::from_utf8(bytes).expect("ASCII is UTF-8")
+/// The length in UTF-8 of Latin-1 `bytes`.
+#[must_use]
+pub fn latin1_utf8_len(bytes: &[u8]) -> usize {
+    let wide = bytes.chunks(COUNT_BLOCK).fold(0_usize, |wide, block| {
+        let count = block.iter().fold(0_u8, |count, &byte| {
+            count.wrapping_add(u8::from(!byte.is_ascii()))
+        });
+        wide.saturating_add(usize::from(count))
+    });
+    bytes.len().saturating_add(wide)
 }
 
-#[must_use]
-pub fn latin1_to_utf8(bytes: &[u8]) -> String {
-    if bytes.len() < LATIN1_BLOCK {
-        return bytes.iter().copied().map(char::from).collect();
-    }
-    let (wide, mixed) =
-        bytes
-            .chunks(LATIN1_BLOCK)
-            .fold((0_usize, 0_usize), |(wide, mixed), block| {
-                let count = block
-                    .iter()
-                    .map(|&byte| u8::from(!byte.is_ascii()))
-                    .sum::<u8>();
-                (
-                    wide.saturating_add(usize::from(count)),
-                    mixed.saturating_add(usize::from(count > 0)),
-                )
-            });
-    let mut out = String::with_capacity(bytes.len().saturating_add(wide));
-    // Text where most blocks need converting anyway, like accented prose, is
-    // faster a byte at a time throughout.
-    if mixed.saturating_mul(LATIN1_BLOCK).saturating_mul(2) > bytes.len() {
-        out.extend(bytes.iter().copied().map(char::from));
-        return out;
-    }
-    let mut span = 0;
+// Writes `c` at `at` and returns where it ends, or `None` when it does not fit.
+fn put(out: &mut [u8], at: usize, c: char) -> Option<usize> {
+    let end = at.checked_add(c.len_utf8())?;
+    c.encode_utf8(out.get_mut(at..end)?);
+    Some(end)
+}
+
+/// Writes the UTF-8 of Latin-1 `bytes` at the start of `out`, up to the last
+/// character that fits, and returns how many bytes it wrote: all
+/// `latin1_utf8_len(bytes)` of them when `out` is that long.
+pub fn latin1_to_utf8_into(bytes: &[u8], out: &mut [u8]) -> usize {
     let mut at: usize = 0;
     for block in bytes.chunks(LATIN1_BLOCK) {
-        let next = at.saturating_add(block.len());
-        if !block.is_ascii() {
-            if span < at {
-                out.push_str(ascii(bytes.get(span..at).unwrap_or_default()));
-            }
-            for &byte in block {
-                out.push(char::from(byte));
+        let end = at.saturating_add(block.len());
+        if block.is_ascii()
+            && let Some(slots) = out.get_mut(at..end)
+        {
+            slots.copy_from_slice(block);
+            at = end;
+            continue;
+        }
+        for &byte in block {
+            match put(out, at, char::from(byte)) {
+                Some(next) => at = next,
+                None => return at,
             }
-            span = next;
         }
-        at = next;
     }
-    out.push_str(ascii(bytes.get(span..).unwrap_or_default()));
-    out
+    at
 }
 
 #[must_use]
-pub fn utf16le_to_utf8(bytes: &[u8]) -> Option<String> {
+#[expect(clippy::expect_used, reason = "only whole characters are written")]
+pub fn latin1_to_utf8(bytes: &[u8]) -> String {
+    let mut out = vec![0; latin1_utf8_len(bytes)];
+    let written = latin1_to_utf8_into(bytes, &mut out);
+    out.truncate(written);
+    String::from_utf8(out).expect("Latin-1 transcodes to UTF-8")
+}
+
+fn utf16le_chars(bytes: &[u8]) -> Option<impl Iterator<Item = Result<char, ()>>> {
+    let (pairs, rest) = bytes.as_chunks::<2>();
+    let units = pairs.iter().copied().map(u16::from_le_bytes);
+    rest.is_empty()
+        .then(|| char::decode_utf16(units).map(|c| c.map_err(|_| ())))
+}
+
+/// The length in UTF-8 of UTF-16LE `bytes`, or `None` when they hold an odd
+/// byte or a lone surrogate.
+#[must_use]
+pub fn utf16le_utf8_len(bytes: &[u8]) -> Option<usize> {
     let (pairs, rest) = bytes.as_chunks::<2>();
     if !rest.is_empty() {
         return None;
     }
-    let units = pairs.iter().copied().map(u16::from_le_bytes);
-    char::decode_utf16(units)
-        .collect::<Result<String, _>>()
-        .ok()
+    // A unit takes one byte, one more from U+0080 and one more from U+0800,
+    // which counts the two units of a surrogate pair as six bytes for its four.
+    let mut len: usize = 0;
+    let mut surrogates = false;
+    for block in pairs.chunks(COUNT_BLOCK) {
+        let mut count: u8 = 0;
+        for &pair in block {
+            let unit = u16::from_le_bytes(pair);
+            count = count
+                .wrapping_add(1)
+                .wrapping_add(u8::from(unit >= 0x80))
+                .wrapping_add(u8::from(unit >= 0x800));
+            surrogates |= (0xD800..0xE000).contains(&unit);
+        }
+        len = len.saturating_add(usize::from(count));
+    }
+    if !surrogates {
+        return Some(len);
+    }
+    let mut surrogate_pairs: usize = 0;
+    let mut units = pairs.iter().copied().map(u16::from_le_bytes);
+    while let Some(unit) = units.next() {
+        if (0xD800..0xDC00).contains(&unit) {
+            units.next().filter(|low| (0xDC00..0xE000).contains(low))?;
+            surrogate_pairs = surrogate_pairs.saturating_add(1);
+        } else if (0xDC00..0xE000).contains(&unit) {
+            return None;
+        }
+    }
+    Some(len.saturating_sub(surrogate_pairs.saturating_mul(2)))
+}
+
+/// Writes the UTF-8 of UTF-16LE `bytes` at the start of `out` and returns how
+/// many bytes it wrote.
+///
+/// `None` when they hold an odd byte or a lone surrogate, or when `out` lacks
+/// room, which three bytes per unit never does.
+pub fn utf16le_to_utf8_into(bytes: &[u8], out: &mut [u8]) -> Option<usize> {
+    let mut at = 0;
+    for c in utf16le_chars(bytes)? {
+        at = put(out, at, c.ok()?)?;
+    }
+    Some(at)
+}
+
+#[must_use]
+#[expect(clippy::expect_used, reason = "only whole characters are written")]
+pub fn utf16le_to_utf8(bytes: &[u8]) -> Option<String> {
+    let mut out = vec![0; utf16le_utf8_len(bytes)?];
+    let written = utf16le_to_utf8_into(bytes, &mut out)?;
+    out.truncate(written);
+    Some(String::from_utf8(out).expect("UTF-16 transcodes to UTF-8"))
 }
 
 #[cfg(test)]
@@ -83,8 +145,38 @@ mod tests {
             utf16le_to_utf8(&[0x3D, 0xD8, 0x00, 0xDE]).as_deref(),
             Some("😀")
         );
+        assert_eq!(
+            utf16le_utf8_len(&[0x3D, 0xD8, 0x00, 0xDE, 0x41, 0x00]),
+            Some(5)
+        );
         assert_eq!(utf16le_to_utf8(&[0x41]), None);
+        assert_eq!(utf16le_utf8_len(&[0x41]), None);
         assert_eq!(utf16le_to_utf8(&[0x3D, 0xD8]), None);
+        assert_eq!(utf16le_utf8_len(&[0x41, 0x00, 0x00, 0xDC]), None);
+    }
+
+    #[test]
+    fn writers_stop_where_text_does_not_decode_or_fit() {
+        let mut out = [0; 8];
+        assert_eq!(
+            utf16le_to_utf8_into(&[0x41, 0x00, 0x00, 0xDC], &mut out),
+            None
+        );
+        assert_eq!(utf16le_to_utf8_into(&[0x41, 0x00, 0x42], &mut out), None);
+        assert_eq!(
+            utf16le_to_utf8_into(&[0x3D, 0xD8, 0x00, 0xDE], out.get_mut(..3).unwrap()),
+            None
+        );
+        assert_eq!(
+            utf16le_to_utf8_into(&[0x3D, 0xD8, 0x00, 0xDE], &mut out),
+            Some(4)
+        );
+        let written = latin1_to_utf8_into(b"ab\xE9c", out.get_mut(..3).unwrap());
+        assert_eq!(out.get(..written), Some(b"ab".as_slice()));
+    }
+
+    fn utf16le(units: &[u16]) -> Vec<u8> {
+        units.iter().flat_map(|unit| unit.to_le_bytes()).collect()
     }
 
     proptest! {
@@ -100,7 +192,26 @@ mod tests {
         )) {
             let bytes: Vec<u8> = segments.into_iter().flat_map(|(run, wide)| run.into_iter().chain(wide)).collect();
             let by_byte: String = bytes.iter().copied().map(char::from).collect();
+            prop_assert_eq!(latin1_utf8_len(&bytes), by_byte.len());
+            let mut out = vec![0; bytes.len().saturating_mul(2)];
+            let written = latin1_to_utf8_into(&bytes, &mut out);
+            prop_assert_eq!(out.get(..written), Some(by_byte.as_bytes()));
             prop_assert_eq!(latin1_to_utf8(&bytes), by_byte);
         }
+
+        // Units from each range UTF-8 sizes differently, surrogates included,
+        // so pairs, lone halves and pairs in the wrong order all come up.
+        #[test]
+        fn utf16_matches_std(units in proptest::collection::vec(
+            prop_oneof![0u16..0x80, 0x80u16..0x800, 0x800u16..0xD800, 0xD800u16..0xE000, 0xE000u16..=0xFFFF],
+            0..64,
+        )) {
+            let expected = String::from_utf16(&units).ok();
+            prop_assert_eq!(utf16le_utf8_len(&utf16le(&units)), expected.as_ref().map(String::len));
+            let mut out = vec![0; units.len().saturating_mul(3)];
+            let written = utf16le_to_utf8_into(&utf16le(&units), &mut out);
+            prop_assert_eq!(written.and_then(|n| out.get(..n)), expected.as_ref().map(String::as_bytes));
+            prop_assert_eq!(utf16le_to_utf8(&utf16le(&units)), expected);
+        }
     }
 }

data/ext/mini_racer_rs/src/decode.rs

@@ -1,3 +1,7 @@
+use std::cmp::Ordering;
+use std::ops::Range;
+
+use magnus::typed_data::Obj;
 use magnus::value::ReprValue;
 use magnus::{
     Class, Error, Fixnum, IntoValue, Module, Object, RArray, RClass, RHash, RModule, RObject,
@@ -7,7 +11,7 @@ use mini_racer_wire::{
     Begun, Container, DecodeError, Limits, Scalar, Text, Visitor, decode_value, marker, text,
 };
 
-use crate::gc_root::StaticRoot;
+use crate::gc_root::{Spill, StaticRoot};
 use crate::{errors, rb_raw};
 
 #[expect(
@@ -69,23 +73,194 @@ struct ErrorParts {
 
 const BATCH: usize = 64;
 
-#[derive(Clone, Copy)]
-enum Target {
-    Array(RArray),
-    Hash(RHash),
-}
-
-// Decoded elements and object pairs wait here so a batch of them costs one
-// rb_protect rather than one per value. Every container's begin and end
-// empties it, so only the innermost open container ever has values waiting,
-// and whatever a child does (a Map hashing an ancestor as its key) sees each
-// container with every value decoded so far, as mini_racer builds them.
+// Decoded elements wait here so a batch of them costs one rb_protect rather
+// than one per value. Every container's begin and end empties it, so only the
+// innermost open array ever has elements waiting, and whatever a child does
+// (a Map hashing an ancestor as its key) sees each array with every element
+// decoded so far, as mini_racer builds them.
 struct Pending {
-    target: Option<Target>,
+    target: Option<RArray>,
     values: [Value; BATCH],
     filled: usize,
 }
 
+const PAIRS: usize = 128;
+
+const SCRATCH: usize = 64 << 10;
+
+// Every open hash's pairs wait here, innermost last, until the hash ends and
+// takes them in one rb_hash_bulk_insert while it is still empty, so Ruby sizes
+// its table once, as json 3.1's parser builds objects. A hash's run starts
+// with the hash and the start of the run around it. Past PAIRS values the
+// runs move to a Spill, whose mark pins them.
+struct Pairs {
+    values: [Value; PAIRS],
+    spill: Option<Obj<Spill>>,
+    len: usize,
+    innermost: Option<usize>,
+    // Every pair below this is in its hash already.
+    inserted: usize,
+}
+
+impl Pairs {
+    // Out of line, as KeyCache::start is, so the values made here never take
+    // room in the decoder's recursive frames, which a deep result repeats.
+    #[inline(never)]
+    fn start<'p>(slot: &'p mut Option<Self>, ruby: &Ruby) -> &'p mut Self {
+        slot.insert(Self {
+            values: [ruby.qnil().as_value(); PAIRS],
+            spill: None,
+            len: 0,
+            innermost: None,
+            inserted: 0,
+        })
+    }
+
+    fn push(&mut self, ruby: &Ruby, value: Value) {
+        if self.spill.is_none() {
+            if let Some(slot) = self.values.get_mut(self.len) {
+                *slot = value;
+                self.len = self.len.saturating_add(1);
+                return;
+            }
+            self.spill = Some(Spill::new(ruby, &self.values));
+        }
+        if let Some(spill) = &self.spill {
+            spill.push(value);
+        }
+        self.len = self.len.saturating_add(1);
+    }
+
+    fn get(&self, ruby: &Ruby, at: usize) -> Option<Value> {
+        self.spill
+            .as_ref()
+            .map_or_else(|| self.values.get(at).copied(), |spill| spill.get(ruby, at))
+    }
+
+    fn open(&mut self, ruby: &Ruby, hash: RHash) {
+        let outer = self
+            .innermost
+            .and_then(|at| i64::try_from(at).ok())
+            .unwrap_or(-1);
+        self.innermost = Some(self.len);
+        self.push(ruby, hash.as_value());
+        self.push(ruby, ruby.integer_from_i64(outer).as_value());
+    }
+
+    fn outer(&self, ruby: &Ruby, at: usize) -> Option<usize> {
+        self.get(ruby, at.saturating_add(1))
+            .and_then(Fixnum::from_value)
+            .and_then(|outer| usize::try_from(outer.to_i64()).ok())
+    }
+
+    // An empty table takes the pairs at once; one that holds pairs already
+    // takes them one by one, since rb_hash_bulk_insert would rehash it whole.
+    fn put(&self, ruby: &Ruby, hash: RHash, range: Range<usize>) -> Result<(), Error> {
+        if range.is_empty() {
+            return Ok(());
+        }
+        let put = |pairs: &[Value]| {
+            if hash.is_empty() {
+                hash.bulk_insert(pairs)
+            } else {
+                rb_raw::hash_aset_pairs(ruby, hash, pairs.as_chunks::<2>().0)
+            }
+        };
+        match &self.spill {
+            Some(spill) => spill.with_values(ruby, range, put),
+            None => put(self.values.get(range).unwrap_or_default()),
+        }
+    }
+
+    fn close(&mut self, ruby: &Ruby, hash: RHash) -> Result<(), Error> {
+        let Some(at) = self.innermost else {
+            return Err(errors::internal(ruby, "decode pairs without a hash"));
+        };
+        self.put(
+            ruby,
+            hash,
+            at.saturating_add(2).max(self.inserted)..self.len,
+        )?;
+        self.innermost = self.outer(ruby, at);
+        self.len = at;
+        self.inserted = self.inserted.min(at);
+        if let Some(spill) = &self.spill {
+            spill.truncate(at);
+        }
+        Ok(())
+    }
+
+    fn put_all(&mut self, ruby: &Ruby) -> Result<(), Error> {
+        let mut end = self.len;
+        let mut run = self.innermost;
+        while let Some(at) = run
+            && end > self.inserted
+        {
+            let hash = self
+                .get(ruby, at)
+                .and_then(RHash::from_value)
+                .ok_or_else(|| errors::internal(ruby, "decode pairs without a hash"))?;
+            self.put(ruby, hash, at.saturating_add(2).max(self.inserted)..end)?;
+            end = at;
+            run = self.outer(ruby, at);
+        }
+        self.inserted = self.len;
+        Ok(())
+    }
+}
+
+// json 3.1's parser keeps the names of objects inside arrays, which repeat,
+// for the rest of a parse: at most this many, each at most CACHED_KEY_BYTES
+// long and starting with a letter.
+const CACHED_KEYS: usize = 63;
+const CACHED_KEY_BYTES: usize = 55;
+
+// Interned keys sorted by length, then bytes, so a repeated key skips Ruby's
+// fstring table.
+struct KeyCache {
+    keys: [Value; CACHED_KEYS],
+    len: usize,
+}
+
+impl KeyCache {
+    #[inline(never)]
+    fn start<'c>(slot: &'c mut Option<Self>, ruby: &Ruby) -> &'c mut Self {
+        slot.insert(Self {
+            keys: [ruby.qnil().as_value(); CACHED_KEYS],
+            len: 0,
+        })
+    }
+
+    fn fetch(&mut self, ruby: &Ruby, bytes: &[u8]) -> Result<Value, Error> {
+        let held = self.keys.get(..self.len).unwrap_or_default();
+        let found = held.binary_search_by(|&key| {
+            RString::from_value(key).map_or(Ordering::Less, |key| {
+                rb_raw::with_string_bytes(ruby, key, |key| {
+                    key.len().cmp(&bytes.len()).then_with(|| key.cmp(bytes))
+                })
+            })
+        });
+        let at = match found {
+            Ok(at) => {
+                return held
+                    .get(at)
+                    .copied()
+                    .ok_or_else(|| errors::internal(ruby, "key cache"));
+            }
+            Err(at) => at,
+        };
+        let key = rb_raw::interned_utf8(ruby, bytes)?.as_value();
+        if self.len < CACHED_KEYS {
+            self.keys.copy_within(at..self.len, at.saturating_add(1));
+            if let Some(slot) = self.keys.get_mut(at) {
+                *slot = key;
+            }
+            self.len = self.len.saturating_add(1);
+        }
+        Ok(key)
+    }
+}
+
 // The visitor and its frames live on the native stack for the whole decode,
 // where Ruby's GC finds them (I3); `refs` holds every value V8 gave an id,
 // made at the first, so a result without one allocates none.
@@ -93,10 +268,15 @@ struct RubyVisitor<'r> {
     ruby: &'r Ruby,
     refs: Option<RArray>,
     pending: Pending,
+    pairs: Option<Pairs>,
+    keys: Option<KeyCache>,
+    // Arrays and sets open around the current value.
+    arrays: u32,
+    scratch: Vec<u8>,
 }
 
 impl RubyVisitor<'_> {
-    fn add(&mut self, target: Target, values: &[Value]) -> Result<(), Error> {
+    fn add(&mut self, target: RArray, values: &[Value]) -> Result<(), Error> {
         self.add_with(target, values.len(), |slots| slots.copy_from_slice(values))
     }
 
@@ -104,7 +284,7 @@ impl RubyVisitor<'_> {
     // sees each one as soon as it is made.
     fn add_with(
         &mut self,
-        target: Target,
+        target: RArray,
         count: usize,
         fill: impl FnOnce(&mut [Value]),
     ) -> Result<(), Error> {
@@ -136,7 +316,7 @@ impl RubyVisitor<'_> {
     ) -> Result<(), Error> {
         let ruby = self.ruby;
         for chunk in values.chunks(BATCH) {
-            self.add_with(Target::Array(array), chunk.len(), |slots| {
+            self.add_with(array, chunk.len(), |slots| {
                 for (slot, &n) in slots.iter_mut().zip(chunk) {
                     *slot = convert(ruby, n);
                 }
@@ -164,32 +344,103 @@ impl RubyVisitor<'_> {
         let values = self.pending.values.get(..filled).unwrap_or_default();
         match self.pending.target {
             _ if filled == 0 => Ok(()),
-            Some(Target::Array(array)) => array.cat(values),
-            Some(Target::Hash(hash)) => {
-                rb_raw::hash_aset_pairs(self.ruby, hash, values.as_chunks::<2>().0)
-            }
+            Some(array) => array.cat(values),
             None => Err(errors::internal(self.ruby, "decode batch without a target")),
         }
     }
 
+    fn pairs(&mut self) -> Result<&mut Pairs, Error> {
+        let ruby = self.ruby;
+        self.pairs
+            .as_mut()
+            .ok_or_else(|| errors::internal(ruby, "decode pairs without a hash"))
+    }
+
+    fn open_hash(&mut self) -> RHash {
+        let ruby = self.ruby;
+        let hash = ruby.hash_new();
+        match &mut self.pairs {
+            Some(pairs) => pairs.open(ruby, hash),
+            None => Pairs::start(&mut self.pairs, ruby).open(ruby, hash),
+        }
+        hash
+    }
+
+    // A key whose hashing Ruby code could run for, or that holds other
+    // values, such as an Array that refers back to an open hash, first sees
+    // every open hash with all its pairs so far, as mini_racer stores each
+    // pair as it decodes it.
+    fn put_pair(&mut self, hash: RHash, key: Value, value: Value) -> Result<(), Error> {
+        let ruby = self.ruby;
+        let pairs = self.pairs()?;
+        if rb_raw::plain_key(ruby, key) {
+            pairs.push(ruby, key);
+            pairs.push(ruby, value);
+            return Ok(());
+        }
+        pairs.put_all(ruby)?;
+        rb_raw::hash_aset_pairs(ruby, hash, &[[key, value]])
+    }
+
     fn bad_state<T>(&self) -> Result<T, Error> {
         Err(errors::runtime(self.ruby, "bad state"))
     }
 
-    fn string(&self, text: Text<'_>) -> Result<Value, Error> {
+    // Text is transcoded into one buffer, then copied into its String in one
+    // call: making a String to write into costs more Ruby calls than the copy
+    // saves. Up to SCRATCH bytes it is the decode's own, with room for the
+    // longest UTF-8 the text could be and zeroed only as it grows; longer
+    // text is measured first and gets a buffer its size, freed once copied,
+    // since the longest it could be is up to three times what it takes.
+    fn transcoded(
+        &mut self,
+        most: usize,
+        len: impl FnOnce() -> Option<usize>,
+        write: impl FnOnce(&mut [u8]) -> Option<usize>,
+    ) -> Option<Value> {
+        let ruby = self.ruby;
+        let mut measured;
+        let out = if most <= SCRATCH {
+            if self.scratch.len() < most {
+                self.scratch.resize(most, 0);
+            }
+            self.scratch.get_mut(..most).unwrap_or_default()
+        } else {
+            measured = vec![0; len()?];
+            measured.as_mut_slice()
+        };
+        let written = write(out)?;
+        Some(
+            ruby.enc_str_new(out.get(..written).unwrap_or_default(), ruby.utf8_encoding())
+                .as_value(),
+        )
+    }
+
+    fn string(&mut self, text: Text<'_>) -> Result<Value, Error> {
         let ruby = self.ruby;
         Ok(match text {
             Text::Utf8(bytes) => ruby.enc_str_new(bytes, ruby.utf8_encoding()).as_value(),
             Text::Latin1(bytes) if bytes.is_ascii() => {
                 ruby.enc_str_new(bytes, ruby.utf8_encoding()).as_value()
             }
-            Text::Latin1(bytes) => ruby.str_new(&text::latin1_to_utf8(bytes)).as_value(),
+            Text::Latin1(bytes) => self
+                .transcoded(
+                    bytes.len().saturating_mul(2),
+                    || Some(text::latin1_utf8_len(bytes)),
+                    |out| Some(text::latin1_to_utf8_into(bytes, out)),
+                )
+                .ok_or_else(|| errors::internal(ruby, "Latin-1 text not transcoded"))?,
             Text::Utf16Le(bytes) if marker::is_javascript_function(bytes) => {
                 JAVASCRIPT_FUNCTION.get(ruby).new_instance(())?
             }
             Text::Utf16Le(bytes) => {
-                if let Some(utf8) = text::utf16le_to_utf8(bytes) {
-                    ruby.str_new(&utf8).as_value()
+                let most = bytes.len().saturating_mul(3).div_ceil(2);
+                if let Some(utf8) = self.transcoded(
+                    most,
+                    || text::utf16le_utf8_len(bytes),
+                    |out| text::utf16le_to_utf8_into(bytes, out),
+                ) {
+                    utf8
                 } else {
                     let utf16 = ruby
                         .find_encoding("UTF-16LE")
@@ -200,6 +451,39 @@ impl RubyVisitor<'_> {
         })
     }
 
+    // The key `Hash#[]=` would store, made interned in the first place. One
+    // with a lone surrogate stays UTF-16LE, which the hash interns itself,
+    // and the function marker stays a JavaScriptFunction.
+    fn interned(&mut self, text: Text<'_>) -> Result<Value, Error> {
+        let ruby = self.ruby;
+        match text {
+            Text::Utf8(bytes) => self.cached(bytes),
+            Text::Latin1(bytes) if bytes.is_ascii() => self.cached(bytes),
+            Text::Latin1(bytes) => {
+                Ok(rb_raw::interned_utf8(ruby, text::latin1_to_utf8(bytes).as_bytes())?.as_value())
+            }
+            Text::Utf16Le(bytes) if marker::is_javascript_function(bytes) => self.string(text),
+            Text::Utf16Le(bytes) => match text::utf16le_to_utf8(bytes) {
+                Some(utf8) => Ok(rb_raw::interned_utf8(ruby, utf8.as_bytes())?.as_value()),
+                None => self.string(text),
+            },
+        }
+    }
+
+    fn cached(&mut self, bytes: &[u8]) -> Result<Value, Error> {
+        let ruby = self.ruby;
+        if self.arrays == 0
+            || bytes.len() > CACHED_KEY_BYTES
+            || !bytes.first().is_some_and(u8::is_ascii_alphabetic)
+        {
+            return Ok(rb_raw::interned_utf8(ruby, bytes)?.as_value());
+        }
+        match &mut self.keys {
+            Some(keys) => keys.fetch(ruby, bytes),
+            None => KeyCache::start(&mut self.keys, ruby).fetch(ruby, bytes),
+        }
+    }
+
     // mini_racer splits a millisecond time into seconds and microseconds,
     // truncating each, and lets Time normalize a negative remainder.
     #[expect(
@@ -286,8 +570,8 @@ impl Visitor for RubyVisitor<'_> {
                 array: ruby.ary_new(),
                 named: false,
             },
-            Container::Object => Frame::Object(ruby.hash_new()),
-            Container::Map => Frame::Map(ruby.hash_new()),
+            Container::Object => Frame::Object(self.open_hash()),
+            Container::Map => Frame::Map(self.open_hash()),
             // Allocated now so a cause can refer back to the error itself.
             Container::Error => Frame::Error(ErrorParts {
                 error: errors::script_error(ruby).obj_alloc()?.as_value(),
@@ -297,7 +581,10 @@ impl Visitor for RubyVisitor<'_> {
             }),
         };
         let value = match &frame {
-            Frame::Array(array) | Frame::Sparse { array, .. } => array.as_value(),
+            Frame::Array(array) | Frame::Sparse { array, .. } => {
+                self.arrays = self.arrays.saturating_add(1);
+                array.as_value()
+            }
             Frame::Object(hash) | Frame::Map(hash) => hash.as_value(),
             Frame::Error(parts) => parts.error,
         };
@@ -309,9 +596,7 @@ impl Visitor for RubyVisitor<'_> {
 
     fn push(&mut self, frame: &mut Frame, value: Value) -> Result<(), Error> {
         match frame {
-            Frame::Array(array) | Frame::Sparse { array, .. } => {
-                self.add(Target::Array(*array), &[value])
-            }
+            Frame::Array(array) | Frame::Sparse { array, .. } => self.add(*array, &[value]),
             Frame::Object(_) | Frame::Map(_) | Frame::Error(_) => self.bad_state(),
         }
     }
@@ -321,7 +606,7 @@ impl Visitor for RubyVisitor<'_> {
             Frame::Array(_) => Ok(()),
             Frame::Sparse { array, named } => {
                 if !*named && is_index(key) {
-                    self.add(Target::Array(*array), &[value])
+                    self.add(*array, &[value])
                 } else {
                     *named = true;
                     Ok(())
@@ -332,9 +617,9 @@ impl Visitor for RubyVisitor<'_> {
                     Some(key) => key.as_value(),
                     None => key.funcall::<_, _, Value>("to_s", ())?,
                 };
-                self.add(Target::Hash(*hash), &[key, value])
+                self.put_pair(*hash, key, value)
             }
-            Frame::Map(hash) => hash.aset(key, value),
+            Frame::Map(hash) => self.put_pair(*hash, key, value),
             Frame::Error(parts) => {
                 let field = RString::from_value(key)
                     .map(|key| rb_raw::string_bytes(self.ruby, key))
@@ -353,12 +638,26 @@ impl Visitor for RubyVisitor<'_> {
     fn end(&mut self, frame: Frame) -> Result<Value, Error> {
         self.flush()?;
         match frame {
-            Frame::Array(array) | Frame::Sparse { array, .. } => Ok(array.as_value()),
-            Frame::Object(hash) | Frame::Map(hash) => Ok(hash.as_value()),
+            Frame::Array(array) | Frame::Sparse { array, .. } => {
+                self.arrays = self.arrays.saturating_sub(1);
+                Ok(array.as_value())
+            }
+            Frame::Object(hash) | Frame::Map(hash) => {
+                let ruby = self.ruby;
+                self.pairs()?.close(ruby, hash)?;
+                Ok(hash.as_value())
+            }
             Frame::Error(parts) => self.script_error(parts),
         }
     }
 
+    fn key(&mut self, frame: &Frame, text: Text<'_>) -> Result<Value, Error> {
+        match frame {
+            Frame::Object(_) | Frame::Map(_) => self.interned(text),
+            Frame::Array(_) | Frame::Sparse { .. } | Frame::Error(_) => self.string(text),
+        }
+    }
+
     fn register(&mut self, id: u32, value: Value) -> Result<(), Error> {
         let ruby = self.ruby;
         self.refs
@@ -429,6 +728,10 @@ pub fn value(ruby: &Ruby, bytes: &[u8]) -> Result<Value, Error> {
             values: [ruby.qnil().as_value(); BATCH],
             filled: 0,
         },
+        pairs: None,
+        keys: None,
+        arrays: 0,
+        scratch: Vec::new(),
     };
     decode_value(bytes, RESULT_LIMITS, &mut visitor).map_err(|e| match e {
         DecodeError::Visitor(error) => error,

data/ext/mini_racer_rs/src/gc_root.rs

@@ -1,4 +1,5 @@
 use std::cell::{Cell, RefCell};
+use std::ops::Range;
 use std::sync::OnceLock;
 
 use magnus::gc::Marker;
@@ -110,8 +111,72 @@ impl Pins {
     }
 }
 
+/// Ruby values a decode keeps in order past what fits on the native stack.
+/// The holder's mark pins every value. Only touched under the GVL; a borrow
+/// that spans a Ruby call is a shared one, which the mark shares, and no
+/// mutable borrow does.
+#[derive(Default, TypedData)]
+#[magnus(class = "MiniRacerRs::Spill", free_immediately, mark)]
+pub struct Spill(RefCell<Vec<Opaque<Value>>>);
+
+impl DataTypeFunctions for Spill {
+    // As for Pins, a mutable borrow at mark time would leave values unmarked.
+    fn mark(&self, marker: &Marker) {
+        let Ok(values) = self.0.try_borrow() else {
+            std::process::abort();
+        };
+        for value in values.iter() {
+            marker.mark(*value);
+        }
+    }
+}
+
+impl Spill {
+    /// Holds `values` first. Keep using the returned `Obj` while the values
+    /// are needed; a reference into its data alone does not keep the holder
+    /// alive.
+    pub fn new(ruby: &Ruby, values: &[Value]) -> Obj<Self> {
+        let held = values.iter().copied().map(Opaque::from).collect();
+        ruby.obj_wrap(Self(RefCell::new(held)))
+    }
+
+    pub fn push(&self, value: Value) {
+        self.0.borrow_mut().push(Opaque::from(value));
+    }
+
+    pub fn truncate(&self, len: usize) {
+        self.0.borrow_mut().truncate(len);
+    }
+
+    pub fn get(&self, ruby: &Ruby, index: usize) -> Option<Value> {
+        self.0
+            .borrow()
+            .get(index)
+            .map(|value| ruby.get_inner(*value))
+    }
+
+    /// Runs `read` over the values in `range`; `read` may call Ruby.
+    pub fn with_values<R>(
+        &self,
+        _ruby: &Ruby,
+        range: Range<usize>,
+        read: impl FnOnce(&[Value]) -> R,
+    ) -> R {
+        let values = self.0.borrow();
+        let held = values.get(range).unwrap_or_default();
+        // SAFETY: Opaque is a transparent wrapper, so a slice of them has the
+        // layout of a slice of the values they wrap, which the `&Ruby`
+        // argument proves this thread may use.
+        let slice =
+            unsafe { std::slice::from_raw_parts(held.as_ptr().cast::<Value>(), held.len()) };
+        read(slice)
+    }
+}
+
 pub fn init(ruby: &Ruby, rs: RModule) -> Result<(), Error> {
-    let class = rs.define_class("Pins", ruby.class_object())?;
-    class.undef_default_alloc_func();
+    for name in ["Pins", "Spill"] {
+        rs.define_class(name, ruby.class_object())?
+            .undef_default_alloc_func();
+    }
     Ok(())
 }

data/ext/mini_racer_rs/src/lib.rs

@@ -3,6 +3,10 @@ mod decode;
 mod encode;
 mod errors;
 mod fork;
+#[allow(
+    unsafe_code,
+    reason = "a decode's spilled values are lent in place as the slice Ruby reads"
+)]
 mod gc_root;
 mod guard;
 mod host;

data/ext/mini_racer_rs/src/rb_raw.rs

@@ -1,4 +1,4 @@
-use std::ffi::{c_int, c_void};
+use std::ffi::{c_int, c_long, c_void};
 
 use magnus::rb_sys::{AsRawId, AsRawValue, FromRawValue, protect};
 use magnus::value::{IntoId, LazyId, ReprValue};
@@ -185,6 +185,23 @@ pub fn ruby_type(_ruby: &Ruby, value: Value) -> RubyType {
     }
 }
 
+/// Whether a Hash stores `key` without running Ruby code or reaching any
+/// other object: Ruby hashes and compares these itself (`any_hash`,
+/// `rb_any_cmp`), a String only while its class is String itself.
+pub fn plain_key(ruby: &Ruby, key: Value) -> bool {
+    match ruby_type(ruby, key) {
+        RubyType::Fixnum
+        | RubyType::Bignum
+        | RubyType::Float
+        | RubyType::Symbol
+        | RubyType::Nil
+        | RubyType::True
+        | RubyType::False => true,
+        RubyType::String => key.class().as_raw() == ruby.class_string().as_raw(),
+        _ => false,
+    }
+}
+
 /// An object's address, the identity `mini_racer`'s encoder keys repeated
 /// containers by; stable only while the object is pinned.
 pub fn identity(value: Value) -> u64 {
@@ -221,8 +238,9 @@ pub fn call_with_array(ruby: &Ruby, receiver: Value, args: RArray) -> Result<Val
 }
 
 /// Stores each key and value as `Hash#[]=` would, under one `rb_protect` for
-/// the whole slice. `pairs` must be where the GC sees them, on the native
-/// stack: storing a key can start a compacting collection.
+/// the whole slice. `pairs` must be where the GC sees and pins them, on the
+/// native stack or in a `gc_root::Spill`: storing a key can start a
+/// compacting collection.
 // rb_hash_bulk_insert would take the slice in one call, but it rehashes the
 // whole table whenever the hash already has entries.
 pub fn hash_aset_pairs(_ruby: &Ruby, hash: RHash, pairs: &[[Value; 2]]) -> Result<(), Error> {
@@ -239,6 +257,24 @@ pub fn hash_aset_pairs(_ruby: &Ruby, hash: RHash, pairs: &[[Value; 2]]) -> Resul
     Ok(())
 }
 
+/// The interned UTF-8 String of `bytes`, the frozen String `Hash#[]=` would
+/// store as the key in place of a new one.
+pub fn interned_utf8(ruby: &Ruby, bytes: &[u8]) -> Result<RString, Error> {
+    let len = c_long::try_from(bytes.len()).unwrap_or(c_long::MAX);
+    // SAFETY: rb_utf8_encoding only reads Ruby's built-in UTF-8 encoding.
+    let utf8 = unsafe { rb_sys::rb_utf8_encoding() };
+    let raw = protect(|| {
+        // SAFETY: the `&Ruby` argument proves this thread holds the GVL,
+        // `bytes` holds `len` bytes and outlives the call, which copies them
+        // when it makes a String, and `protect` catches an allocation failure.
+        unsafe { rb_sys::rb_enc_interned_str(bytes.as_ptr().cast(), len, utf8) }
+    })?;
+    // SAFETY: `raw` is the live String rb_enc_interned_str returned.
+    let value = unsafe { Value::from_raw(raw) };
+    RString::from_value(value)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected String"))
+}
+
 /// How Ruby's own type errors name `value`: nil, true and false by value,
 /// anything else by its class, never a singleton class, printed with `to_s`
 /// as Ruby prints it, overridden or not.

data/lib/mini_racer_rs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniRacerRs
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer_rs
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Andy Aragon