mini_racer_rs 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a8339f7ec9dcc06bd136d68328c3b5a8acd48bcb59061fe0e1de97d8163e7a5
-  data.tar.gz: fdb040a4e14239cce537be6724a36410432093b6f6ca0f62d6eec5830d32c6b5
+  metadata.gz: c1f337ddf902559ced22f49783b4f541c2ead54c00d1a72ee7a354e1e0b831fc
+  data.tar.gz: 45fe66cb3b1fd6af17aa4da11fa689d387a586eaab1ffd3fe0349fddc90bbec8
 SHA512:
-  metadata.gz: e0fa4008ea43a6f4b7b23a5d324d8c58b659da2688243681b59ddb0af21b16fb54bb2677b9952f24381df1965c66ae47722f1c93d5e82d53b89748c2d7e8a60f
-  data.tar.gz: 0b8bb09c4ca879533aa582fc800c9779b56326dc1c52c61d9d78a95132efa96f0898d596a550255d77839c6c51d09695dfe042021b5992141d5dcb3bbbcc57c8
+  metadata.gz: 924bb67c0d847c12570f983e86594d3ea432f76f206f73d725c3908b272634b5252699652a46231655e714ece2822942c474832b9618681d3bea3c120f7138b4
+  data.tar.gz: 8ead9bef3dac6010fe255d66e009583a7d1e2e8dc2c07aa655dbf21a3f9cda6b0416a74d676a28ff18e916a60f6c644d54e8265d3abe65c0927f5dc6870bcf89

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.5](https://github.com/andymai/mini_racer_rs/compare/v1.0.4...v1.0.5) (2026-10-19)
+
+
+### Performance
+
+* **encode:** send Ruby strings to V8 in the form V8 stores them ([#93](https://github.com/andymai/mini_racer_rs/issues/93)) ([62f9c85](https://github.com/andymai/mini_racer_rs/commit/62f9c851917cb0ce7d760b5fc545aa014df0a53b))
+
 ## [1.0.4](https://github.com/andymai/mini_racer_rs/compare/v1.0.3...v1.0.4) (2026-10-19)
 
 

data/Cargo.lock

@@ -458,7 +458,7 @@ checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "mini_racer_engine"
-version = "1.0.4"
+version = "1.0.5"
 dependencies = [
  "deno_core_icudata",
  "libc",
@@ -470,7 +470,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_rs"
-version = "1.0.4"
+version = "1.0.5"
 dependencies = [
  "magnus",
  "mini_racer_engine",
@@ -481,7 +481,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_sync"
-version = "1.0.4"
+version = "1.0.5"
 dependencies = [
  "loom",
  "thiserror",
@@ -489,7 +489,7 @@ dependencies = [
 
 [[package]]
 name = "mini_racer_wire"
-version = "1.0.4"
+version = "1.0.5"
 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.4"
+version = "1.0.5"
 
 [workspace.dependencies]
 deno_core_icudata = "=0.78.0"

data/crates/mini_racer_engine/src/lib.rs

@@ -14,8 +14,10 @@ mod spin;
     reason = "the engine's only FFI fence: symbols the linker routes into V8"
 )]
 mod sys;
+mod text;
 
 pub use context::{ContextHandle, Host, Unparker, WaitHandle, WaitOutcome};
 pub use control::{CallRequest, CallbackReply, ContextConfig, JsText};
 pub use error::{EngineError, FlagError, InvalidSnapshot, JsError, JsErrorKind, TerminationCause};
 pub use snapshot::{SnapshotBlob, WeakSnapshotBlob};
+pub use text::{Decoded, Transcoder};

data/crates/mini_racer_engine/src/request.rs

@@ -4,6 +4,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use mini_racer_wire::{WRITE_VERSION, tag};
 use v8::ValueDeserializerHelper;
 
+use crate::sys;
+
 // Deeper values are left to V8, which reads as deep as its stack allows.
 const MAX_DEPTH: u32 = 64;
 // Far below V8's own limit on an array's length, which it enforces itself.
@@ -48,16 +50,16 @@ pub const fn worth_building(objects: usize, properties: usize) -> bool {
 /// which its deserializer makes, element by element as a sparse array, so a
 /// function returning an argument costs far more than it need.
 ///
-/// A two-byte string is read by V8's own deserializer from its bytes alone.
-/// The whole request is `Unbuilt` for anything else this would not build as V8
-/// does or that V8 would refuse (a binary, a key that is not a string or an
-/// int32, a key given twice, an array inside itself, an object of more than
-/// `MAX_KEYS` keys, nesting past `MAX_DEPTH`), decided from the bytes before
-/// any value is made. A termination requested as it reads leaves it `Unbuilt`
-/// too: V8 acts on one before each value it reads, an array or object
-/// beginning as a value does, so this looks before the request and before
-/// each value. One requested before the dispatch refused it
-/// (`TermCell::refuses`).
+/// A two-byte string whose units all fit Latin-1 is read by V8's own
+/// deserializer from its bytes alone, which keeps it two-byte as V8's read of
+/// the whole would. The whole request is `Unbuilt` for anything else this would
+/// not build as V8 does or that V8 would refuse (a binary, a key that is not a
+/// string or an int32, a key given twice, an array inside itself, an object of
+/// more than `MAX_KEYS` keys, nesting past `MAX_DEPTH`), decided from the bytes
+/// before any value is made. A termination requested as it reads leaves it
+/// `Unbuilt` too: V8 acts on one before each value it reads, an array or object
+/// beginning as a value does, so this looks before the request and before each
+/// value. One requested before the dispatch refused it (`TermCell::refuses`).
 pub fn read<'s, 'b>(
     scope: &v8::PinScope<'s, '_>,
     bytes: &'b [u8],
@@ -74,6 +76,7 @@ pub fn read<'s, 'b>(
         objects: Vec::new(),
         elements: Vec::new(),
         shapes: Vec::new(),
+        units: Vec::new(),
     };
     match builder.call() {
         Some(call) => Read::Built(call),
@@ -119,6 +122,17 @@ impl<'b> Cursor<'b> {
         }
     }
 
+    // A value's tag, past the padding V8 skips, which aligns a two-byte
+    // string's units.
+    fn tag(&mut self) -> Option<u8> {
+        loop {
+            match self.byte()? {
+                tag::PADDING => {}
+                tag => return Some(tag),
+            }
+        }
+    }
+
     fn varint(&mut self) -> Option<u64> {
         let mut value = 0u64;
         for shift in (0..64).step_by(7) {
@@ -153,9 +167,9 @@ impl<'b> Cursor<'b> {
             .filter(|text| text.len() <= v8::String::MAX_LENGTH)
     }
 
-    fn two_byte(&mut self) -> Option<()> {
-        let len = self.text()?.len();
-        (len.is_multiple_of(2) && len / 2 <= v8::String::MAX_LENGTH).then_some(())
+    fn two_byte(&mut self) -> Option<&'b [u8]> {
+        self.text()
+            .filter(|text| text.len().is_multiple_of(2) && text.len() / 2 <= v8::String::MAX_LENGTH)
     }
 
     // The length of `[path, ...arguments]`, past V8's header.
@@ -312,7 +326,7 @@ impl Check<'_> {
     }
 
     fn value(&mut self, depth: u32) -> Option<()> {
-        match self.bytes.byte()? {
+        match self.bytes.tag()? {
             tag::INT32 => {
                 self.bytes.varint_u32()?;
             }
@@ -323,7 +337,9 @@ impl Check<'_> {
             tag::UTF8_STRING | tag::ONE_BYTE_STRING => {
                 self.bytes.string()?;
             }
-            tag::TWO_BYTE_STRING => self.bytes.two_byte()?,
+            tag::TWO_BYTE_STRING => {
+                self.bytes.two_byte()?;
+            }
             tag::BIGINT => {
                 self.bytes.bigint_bytes()?;
             }
@@ -393,6 +409,9 @@ struct Builder<'s, 'b, 'p, 'i> {
     // The names last made for each key position at each depth, so objects of
     // one shape share them instead of looking each up again.
     shapes: Vec<Vec<(Key<'b>, v8::Local<'s, v8::String>)>>,
+    // A two-byte string's units where the request's bytes hold them
+    // unaligned.
+    units: Vec<u16>,
 }
 
 // Reads again what `Check` accepted, so only a termination stops it, or V8's
@@ -419,7 +438,7 @@ impl<'s, 'b> Builder<'s, 'b, '_, '_> {
         self.unterminated()?;
         let scope = self.scope;
         let at = self.bytes;
-        Some(match self.bytes.byte()? {
+        Some(match self.bytes.tag()? {
             tag::INT32 => v8::Integer::new(scope, zigzag(self.bytes.varint_u32()?)).into(),
             tag::DOUBLE => v8::Number::new(scope, self.bytes.double()?).into(),
             tag::NULL => v8::null(scope).into(),
@@ -459,17 +478,34 @@ impl<'s, 'b> Builder<'s, 'b, '_, '_> {
             tag::BEGIN_DENSE_ARRAY => self.array(depth.checked_sub(1)?)?,
             tag::BEGIN_OBJECT => self.object(depth.checked_sub(1)?)?,
             tag::TWO_BYTE_STRING => {
-                self.bytes.two_byte()?;
-                self.two_byte(at)?
+                let text = self.bytes.two_byte()?;
+                self.two_byte(text, at)?
             }
             _ => return None,
         })
     }
 
-    // Reads the string from `at` up to the cursor with V8's own deserializer,
-    // which keeps it two-byte, where V8's API makes a one-byte string of
-    // whatever fits.
-    fn two_byte(&mut self, at: Cursor<'b>) -> Option<v8::Local<'s, v8::Value>> {
+    // V8's API makes a one-byte string of units that all fit Latin-1, where
+    // its deserializer keeps them two-byte, so only a string with a wider
+    // unit is made through the API, from the request's own bytes where the
+    // padding before them aligned them.
+    fn two_byte(&mut self, text: &[u8], at: Cursor<'b>) -> Option<v8::Local<'s, v8::Value>> {
+        let pairs = text.as_chunks::<2>().0;
+        if !pairs.iter().any(|&[_, high]| high != 0) {
+            return self.deserialized(at);
+        }
+        let units = if let Some(units) = sys::units(text) {
+            units
+        } else {
+            self.units.clear();
+            self.units
+                .extend(pairs.iter().map(|&pair| u16::from_le_bytes(pair)));
+            &self.units
+        };
+        v8::String::new_from_two_byte(self.scope, units, v8::NewStringType::Normal).map(Into::into)
+    }
+
+    fn deserialized(&mut self, at: Cursor<'b>) -> Option<v8::Local<'s, v8::Value>> {
         let len = at.rest.len().checked_sub(self.bytes.rest.len())?;
         let mut bytes = vec![tag::HEADER, u8::try_from(WRITE_VERSION).ok()?];
         bytes.extend_from_slice(at.rest.get(..len)?);

data/crates/mini_racer_engine/src/sys.rs

@@ -121,6 +121,43 @@ unsafe extern "C" fn release_two_byte(data: *mut u16, length: usize) {
     }
 }
 
+/// The UTF-16 units `bytes` hold, in the host's order as V8's deserializer
+/// reads them, without a copy; `None` when they do not start where a unit
+/// can be read from or hold an odd byte.
+#[must_use]
+pub fn units(bytes: &[u8]) -> Option<&[u16]> {
+    // SAFETY: every bit pattern is a valid u16, and `align_to` hands out only
+    // the aligned middle of `bytes`, borrowed for as long as `bytes` is.
+    let (head, units, tail) = unsafe { bytes.align_to::<u16>() };
+    (head.is_empty() && tail.is_empty()).then_some(units)
+}
+
+/// Writes the Latin-1 bytes of `text` at the start of `out` when `text` is
+/// valid UTF-8 and every character in it is at most U+00FF, and returns how
+/// many; `None` otherwise, or when `out` is shorter than `text`.
+pub fn utf8_to_latin1(text: &[u8], out: &mut [u8]) -> Option<usize> {
+    if out.len() < text.len() {
+        return None;
+    }
+    // SAFETY: simdutf writes at most one byte per byte of `text`, which `out`
+    // has room for.
+    let converted = unsafe { v8::simdutf::convert_utf8_to_latin1_with_errors(text, out) };
+    converted.is_ok().then_some(converted.count)
+}
+
+/// Writes the UTF-16 units of `text` at the start of `out` when `text` is
+/// valid UTF-8, and returns how many; `None` otherwise, or when `out` is
+/// shorter than `text`.
+pub fn utf8_to_utf16(text: &[u8], out: &mut [u16]) -> Option<usize> {
+    if out.len() < text.len() {
+        return None;
+    }
+    // SAFETY: simdutf writes at most one unit per byte of `text`, which `out`
+    // has room for.
+    let converted = unsafe { v8::simdutf::convert_utf8_to_utf16le_with_errors(text, out) };
+    converted.is_ok().then_some(converted.count)
+}
+
 /// The address V8 names `isolate` by when it posts the isolate a task.
 #[must_use]
 pub fn isolate_key(isolate: &v8::Isolate) -> usize {

data/crates/mini_racer_engine/src/text.rs

@@ -0,0 +1,182 @@
+use crate::sys;
+
+// V8 decodes shorter UTF-8 faster than a conversion starts: converting all of
+// it made arrays of short BMP and emoji strings about a tenth slower to send.
+const SHORT: usize = 16;
+// UTF-8 longer than this goes to V8 as mini_racer sends it. Decoded here, it
+// takes a buffer of two bytes per byte and a request up to twice its length, both
+// under the GVL: a 100 MB String with one character past Latin-1 would peak
+// near 500 MB where its UTF-8 takes 200 MB. Below this, that extra memory
+// stays within 24 MiB, and the values measured, up to 1 MB, all gain.
+const LONG: usize = 8 << 20;
+const WIDE_LEAD: u8 = 0xC4;
+
+/// The characters of valid UTF-8 as V8 stores them once it has decoded it:
+/// one byte each when every one is at most U+00FF, UTF-16 units otherwise.
+pub enum Decoded<'a> {
+    OneByte(&'a [u8]),
+    TwoByte(&'a [u16]),
+}
+
+/// Decodes UTF-8 ahead of V8, which copies one-byte and two-byte text where
+/// it would decode UTF-8 a byte at a time, into buffers kept for the next
+/// text.
+#[derive(Default)]
+pub struct Transcoder {
+    one_byte: Vec<u8>,
+    two_byte: Vec<u16>,
+}
+
+impl Transcoder {
+    /// `text` as V8 would decode it; `None` when it is short enough for V8 to
+    /// decode as fast, past `LONG` bytes, or not valid UTF-8, whose
+    /// replacement characters are V8's to choose.
+    #[expect(
+        clippy::inline_always,
+        reason = "the encoder calls it for each non-ASCII value; outlined, it slowed short ones 12%"
+    )]
+    #[inline(always)]
+    pub fn decode(&mut self, text: &[u8]) -> Option<Decoded<'_>> {
+        if text.len() < SHORT || text.len() > LONG {
+            return None;
+        }
+        self.decode_long(text)
+    }
+
+    // One conversion each: in valid UTF-8 a byte from 0xC4 up starts a
+    // character past U+00FF, and text without one that does not convert to
+    // Latin-1 is not valid.
+    fn decode_long(&mut self, text: &[u8]) -> Option<Decoded<'_>> {
+        if text.iter().fold(0, |most, &byte| most.max(byte)) < WIDE_LEAD {
+            grow(&mut self.one_byte, text.len());
+            let count = sys::utf8_to_latin1(text, &mut self.one_byte)?;
+            return self.one_byte.get(..count).map(Decoded::OneByte);
+        }
+        grow(&mut self.two_byte, text.len());
+        let count = sys::utf8_to_utf16(text, &mut self.two_byte)?;
+        self.two_byte.get(..count).map(Decoded::TwoByte)
+    }
+}
+
+// Each has room for as many units as the text has bytes, which simdutf needs,
+// and is made afresh as it grows: the allocator hands out a long one's zeroed
+// pages untouched, where zeroing it in place would commit room for three
+// times the units a CJK text decodes to.
+fn grow<T: Copy + Default>(buffer: &mut Vec<T>, len: usize) {
+    if buffer.len() < len {
+        *buffer = vec![T::default(); len];
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Decoded, LONG, SHORT, Transcoder};
+
+    // What V8 makes of valid UTF-8, worked out from its characters.
+    fn expected(text: &str) -> (Option<Vec<u8>>, Vec<u16>) {
+        let latin1 = text.chars().map(|c| u8::try_from(c).ok()).collect();
+        (latin1, text.encode_utf16().collect())
+    }
+
+    fn check(transcoder: &mut Transcoder, text: &str) {
+        let (latin1, utf16) = expected(text);
+        match (transcoder.decode(text.as_bytes()), latin1) {
+            (Some(Decoded::OneByte(bytes)), Some(latin1)) => assert_eq!(bytes, latin1, "{text:?}"),
+            (Some(Decoded::TwoByte(units)), None) => assert_eq!(units, utf16, "{text:?}"),
+            (None, _) => assert!(text.len() < SHORT, "{text:?} left to V8"),
+            _ => panic!("{text:?} decoded in the wrong form"),
+        }
+    }
+
+    #[test]
+    fn valid_text_decodes_to_the_units_v8_stores() {
+        let mut transcoder = Transcoder::default();
+        let pad = "the quick brown fox ";
+        for text in [
+            "caf\u{e9}",
+            "caf\u{e9} na\u{ef}ve Z\u{fc}rich cr\u{e8}me \u{ff}",
+            "\u{6771}\u{4eac} \u{5927}\u{962a} \u{540d}\u{53e4}\u{5c4b}",
+            "\u{1f600} party \u{1f389} fun \u{1f680} go \u{10ffff}",
+            "0123456789abcde\u{e9}",
+            "0123456789abc\u{e9}",
+            "0123456789abcd\u{e9}",
+        ] {
+            check(&mut transcoder, text);
+        }
+        let ranges = [
+            0x80..0x100,
+            0x100..0x800,
+            0x800..0xD800,
+            0xE000..0x1_0000,
+            0x1_0000..0x11_0000,
+        ];
+        for range in ranges {
+            for start in range.clone().step_by(61) {
+                let text: String = (start..range.end.min(start + 23))
+                    .filter_map(char::from_u32)
+                    .collect();
+                check(&mut transcoder, &format!("{pad}{text}"));
+                check(&mut transcoder, &format!("{text}{pad}"));
+            }
+        }
+        let latin1: String = (0x80..0x100).filter_map(char::from_u32).collect();
+        check(&mut transcoder, &latin1.repeat(9));
+        check(&mut transcoder, &format!("{}\u{100}", latin1.repeat(9)));
+    }
+
+    // Values of a megabyte, the longest measured, are decoded; past `LONG`
+    // text goes as UTF-8.
+    #[test]
+    fn text_up_to_long_is_decoded_and_longer_is_left_to_v8() {
+        let mut transcoder = Transcoder::default();
+        let megabyte = "caf\u{e9} ".repeat((1 << 20) / 6);
+        assert!(matches!(
+            transcoder.decode(megabyte.as_bytes()),
+            Some(Decoded::OneByte(_))
+        ));
+        let megabyte = "\u{1f600} go ".repeat((1 << 20) / 8);
+        assert!(matches!(
+            transcoder.decode(megabyte.as_bytes()),
+            Some(Decoded::TwoByte(_))
+        ));
+        let wide = "\u{6771}";
+        let longest = format!("{wide}{}", "a".repeat(LONG - wide.len()));
+        assert_eq!(longest.len(), LONG);
+        match transcoder.decode(longest.as_bytes()) {
+            Some(Decoded::TwoByte(units)) => assert_eq!(units.len(), LONG - 2),
+            _ => panic!("text of `LONG` bytes is decoded"),
+        }
+        assert!(
+            transcoder
+                .decode(format!("{longest}a").as_bytes())
+                .is_none()
+        );
+        let latin1 = "\u{e9}".repeat(LONG / 2 + 1);
+        assert!(transcoder.decode(latin1.as_bytes()).is_none());
+    }
+
+    #[test]
+    fn invalid_or_short_text_is_left_to_v8() {
+        let mut transcoder = Transcoder::default();
+        let pad = b"the quick brown fox ";
+        for invalid in [
+            &b"\xff"[..],
+            b"\x80",
+            b"\xc0\x80",
+            b"\xc3",
+            b"\xed\xa0\x80",
+            b"\xed\xbf\xbf",
+            b"\xf4\x90\x80\x80",
+            b"\xf5\x80\x80\x80",
+            b"\xe0\x80\xaf",
+            b"\xf0\x9f\x98",
+            b"\xe6\x9d",
+        ] {
+            for text in [[pad, invalid].concat(), [invalid, pad].concat()] {
+                assert!(transcoder.decode(&text).is_none(), "{text:x?}");
+            }
+        }
+        assert!(transcoder.decode("caf\u{e9}".as_bytes()).is_none());
+        assert!(transcoder.decode(b"").is_none());
+    }
+}

data/crates/mini_racer_wire/src/write.rs

@@ -157,9 +157,14 @@ impl<'a> Writer<'a> {
         }
         self.out.push(tag::TWO_BYTE_STRING);
         self.len(bytes);
-        self.out.reserve(bytes);
-        for unit in units {
-            self.out.extend_from_slice(&unit.to_le_bytes());
+        // Written into slots made for them at once, which the compiler turns
+        // into wide copies; a unit at a time ran ten times slower.
+        let start = self.out.len();
+        self.out.resize(start.saturating_add(bytes), 0);
+        if let Some(slots) = self.out.get_mut(start..) {
+            for (slot, unit) in slots.as_chunks_mut::<2>().0.iter_mut().zip(units) {
+                *slot = unit.to_le_bytes();
+            }
         }
     }
 

data/ext/mini_racer_rs/src/encode.rs

@@ -9,7 +9,7 @@ use magnus::{
     Error, Fixnum, Float, Module, Object, RArray, RClass, RHash, RModule, RObject, RString, Ruby,
     Time, Value,
 };
-use mini_racer_engine::CallRequest;
+use mini_racer_engine::{CallRequest, Decoded, Transcoder};
 use mini_racer_wire::Writer;
 
 use crate::gc_root::{OnceRoot, Pins, StaticRoot};
@@ -56,6 +56,8 @@ impl From<Error> for EncodeError {
 enum Item {
     // A pinned value, by its index in the holder.
     Value(usize),
+    // A pinned key of a hash.
+    Key(usize),
     // An element read when its turn comes, as serialize1 reads them, so a
     // to_time that changes the array is seen.
     Element { array: usize, index: isize },
@@ -101,6 +103,7 @@ struct Encoder<'r, 'o> {
     // whether to build a call's arguments itself.
     objects: usize,
     properties: usize,
+    transcoder: Transcoder,
 }
 
 /// Writes `value` as `mini_racer`'s `serialize` does, with the object ids V8
@@ -131,7 +134,7 @@ pub fn call(
     let mut encoder = Encoder::new(ruby, &mut bytes);
     let count = length(args.len().saturating_add(1));
     encoder.writer.begin_array(count);
-    encoder.string(name);
+    encoder.string(name, Text::Name);
     args.iter()
         .try_for_each(|&arg| encoder.top(arg))
         .map_err(|error| error.raise(unsupported))?;
@@ -153,6 +156,22 @@ impl EncodeError {
     }
 }
 
+// How mini_racer sends a String, by its encoding's name.
+enum Sent {
+    Utf8,
+    Latin1,
+    Utf16,
+}
+
+// A key or a call's name goes in the form mini_racer sends unless it is
+// ASCII: the runner builds only calls whose keys are UTF-8 or ASCII, and one
+// is seldom long enough to be worth decoding.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Text {
+    Value,
+    Name,
+}
+
 fn length(len: usize) -> u32 {
     u32::try_from(len).unwrap_or(u32::MAX)
 }
@@ -181,6 +200,7 @@ impl<'r, 'o> Encoder<'r, 'o> {
             seen: HashMap::default(),
             objects: 0,
             properties: 0,
+            transcoder: Transcoder::default(),
         }
     }
 }
@@ -214,6 +234,10 @@ impl Encoder<'_, '_> {
                 Item::EndArray(length) => self.writer.end_array(length),
                 Item::EndObject(count) => self.writer.end_object(count),
                 Item::Value(index) => self.value(self.pinned(index))?,
+                Item::Key(index) => {
+                    let key = self.pinned(index);
+                    self.key(key, rb_raw::ruby_type(self.ruby, key));
+                }
                 Item::Element { array, index } => {
                     let element = RArray::from_value(self.pinned(array))
                         .map(|array| array.entry::<Value>(index))
@@ -239,14 +263,30 @@ impl Encoder<'_, '_> {
             RubyType::True => self.writer.bool(true),
             RubyType::False => self.writer.bool(false),
             RubyType::String => {
-                self.string(RString::from_value(value).unwrap_or_else(|| ruby.str_new("")));
+                let text = RString::from_value(value).unwrap_or_else(|| ruby.str_new(""));
+                self.string(text, Text::Value);
             }
-            RubyType::Symbol => self.string(rb_raw::sym2str(ruby, value)),
+            RubyType::Symbol => self.string(rb_raw::sym2str(ruby, value), Text::Value),
             _ => return false,
         }
         true
     }
 
+    // A String, a Symbol or an Integer, the keys `hash` sends.
+    fn key(&mut self, key: Value, kind: RubyType) {
+        let ruby = self.ruby;
+        match kind {
+            RubyType::String => {
+                let text = RString::from_value(key).unwrap_or_else(|| ruby.str_new(""));
+                self.string(text, Text::Name);
+            }
+            RubyType::Symbol => self.string(rb_raw::sym2str(ruby, key), Text::Name),
+            _ => {
+                self.immediate(key, kind);
+            }
+        }
+    }
+
     fn value(&mut self, value: Value) -> Result<(), EncodeError> {
         let kind = rb_raw::ruby_type(self.ruby, value);
         if self.immediate(value, kind) {
@@ -338,7 +378,7 @@ impl Encoder<'_, '_> {
             );
             let item_kind = rb_raw::ruby_type(self.ruby, item);
             if keys_fit && pairs.is_empty() && immediate(item_kind) {
-                self.immediate(key, key_kind);
+                self.key(key, key_kind);
                 self.immediate(item, item_kind);
                 written = written.saturating_add(1);
             } else {
@@ -357,7 +397,7 @@ impl Encoder<'_, '_> {
         self.work.push(Item::EndObject(count));
         for (key, item) in pairs.into_iter().rev() {
             self.work.push(Item::Value(item));
-            self.work.push(Item::Value(key));
+            self.work.push(Item::Key(key));
         }
         Ok(())
     }
@@ -465,21 +505,43 @@ impl Encoder<'_, '_> {
 
     // mini_racer tells encodings apart by name. The ones it sends as UTF-8
     // that strings most often have are told by index, without the lookup.
-    fn string(&mut self, text: RString) {
+    // Bytes it sends as UTF-8 that are all ASCII are the same characters as
+    // one-byte text, which V8 copies where it would decode UTF-8. A value's
+    // other valid UTF-8 goes as the one-byte or two-byte text V8 would decode
+    // it to.
+    fn string(&mut self, text: RString, kind: Text) {
         let ruby = self.ruby;
         let index = text.enc_get();
         let utf8 = index == ruby.utf8_encindex()
             || index == ruby.usascii_encindex()
             || index == ruby.ascii8bit_encindex();
-        rb_raw::with_string_bytes(ruby, text, |bytes| {
-            if utf8 {
-                return self.writer.utf8(bytes);
-            }
+        let sent = if utf8 {
+            Sent::Utf8
+        } else {
             match RbEncoding::from(index).name() {
-                "ISO-8859-1" => self.writer.latin1(bytes),
-                "UTF-16LE" => self.writer.utf16le(bytes),
-                _ => self.writer.utf8(bytes),
+                "ISO-8859-1" => Sent::Latin1,
+                "UTF-16LE" => Sent::Utf16,
+                _ => Sent::Utf8,
+            }
+        };
+        let writer = &mut self.writer;
+        match sent {
+            Sent::Latin1 => rb_raw::with_string_bytes(ruby, text, |bytes| writer.latin1(bytes)),
+            Sent::Utf16 => rb_raw::with_string_bytes(ruby, text, |bytes| writer.utf16le(bytes)),
+            Sent::Utf8 => {
+                let ascii = rb_raw::cached_ascii(ruby, text);
+                let transcoder = (kind == Text::Value).then_some(&mut self.transcoder);
+                rb_raw::with_string_bytes(ruby, text, |bytes| {
+                    if ascii.unwrap_or_else(|| bytes.is_ascii()) {
+                        return writer.latin1(bytes);
+                    }
+                    match transcoder.and_then(|transcoder| transcoder.decode(bytes)) {
+                        Some(Decoded::OneByte(latin1)) => writer.latin1(latin1),
+                        Some(Decoded::TwoByte(units)) => writer.utf16_aligned(units),
+                        None => writer.utf8(bytes),
+                    }
+                });
             }
-        });
+        }
     }
 }

data/ext/mini_racer_rs/src/rb_raw.rs

@@ -1,5 +1,6 @@
 use std::ffi::{c_int, c_long, c_void};
 
+use magnus::encoding::Coderange;
 use magnus::rb_sys::{AsRawId, AsRawValue, FromRawValue, protect};
 use magnus::value::{IntoId, LazyId, ReprValue};
 use magnus::{Error, RArray, RHash, RString, Ruby, Value};
@@ -343,6 +344,18 @@ pub fn sym2str(ruby: &Ruby, symbol: Value) -> RString {
     RString::from_value(name).unwrap_or_else(|| ruby.str_new(""))
 }
 
+/// Whether every byte of `s` is ASCII, from the coderange Ruby keeps in the
+/// String's flags; `None` while Ruby has not worked it out. Working it out
+/// here would check every character of non-ASCII text one at a time, slower
+/// than reading the bytes. Never 7-bit in an encoding that is not
+/// ASCII-compatible.
+pub fn cached_ascii(_ruby: &Ruby, s: RString) -> Option<bool> {
+    match s.enc_coderange() {
+        Coderange::Unknown => None,
+        known => Some(known == Coderange::SevenBit),
+    }
+}
+
 /// Runs `read` over the string's bytes without copying them; `read` must not
 /// call Ruby, which could change or move the string.
 pub fn with_string_bytes<R>(_ruby: &Ruby, s: RString, read: impl FnOnce(&[u8]) -> R) -> R {

data/lib/mini_racer_rs/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer_rs
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Andy Aragon
@@ -64,6 +64,7 @@ files:
 - crates/mini_racer_engine/src/snapshot.rs
 - crates/mini_racer_engine/src/spin.rs
 - crates/mini_racer_engine/src/sys.rs
+- crates/mini_racer_engine/src/text.rs
 - crates/mini_racer_sync/Cargo.toml
 - crates/mini_racer_sync/src/channel.rs
 - crates/mini_racer_sync/src/fork.rs