mini_racer_rs 1.0.3 → 1.0.5

data/crates/mini_racer_engine/src/process/sources.rs

@@ -9,6 +9,7 @@ use crate::process::code_cache::Key;
 const MAX_SOURCES: usize = 8;
 const MAX_BYTES: usize = 256 << 20;
 const MAX_REFUSED: usize = 8;
+const MAX_SWEPT: usize = 8;
 
 /// A large script's source as V8 stores a string of it: a byte a unit when
 /// every unit fits Latin-1, two otherwise. Never changed once made.
@@ -63,8 +64,9 @@ impl Units {
 
 /// One copy of each large script's source, outside every V8 heap.
 ///
-/// A script is kept once the process has seen it before, and every context
-/// compiling it then reads the kept copy in place of one on its own heap.
+/// A script is kept by the first context to compile it, and every context
+/// compiling it, that one included, reads the kept copy in place of one on
+/// its own heap.
 /// Each string V8 makes from one holds a reference to it, which V8 hands back
 /// when the string dies (`sys::external_string`). A source is dropped only
 /// when no string holds one, so V8 never releases the last reference itself.
@@ -72,6 +74,8 @@ pub struct Sources {
     list: Mutex<List>,
     // How many sources, and how many bytes of them, may be kept and read.
     bounds: (usize, usize),
+    // The number the next context's reads are told apart by.
+    next_reader: AtomicU64,
     made: AtomicU64,
     reads: AtomicU64,
     conversions: AtomicU64,
@@ -91,6 +95,9 @@ struct List {
     // left or, as invalid UTF-8, unbounded, so that while it is among the last
     // `MAX_REFUSED` refused it is not converted again without room for it.
     refused: Vec<(Key, usize)>,
+    // The last `MAX_SWEPT` sources swept, so one made again, which a second
+    // context has now read after all, is kept as such.
+    swept: Vec<Key>,
 }
 
 struct Kept {
@@ -99,23 +106,60 @@ struct Kept {
     // The references from this process's list and every ancestor's, which a
     // forked child never touches again; the strings reading it hold the rest.
     held: usize,
+    readers: Readers,
+}
+
+// The contexts that have read a kept source. One alone, as a script evaluated
+// once has, gains nothing from a copy no string reads any more; a source more
+// have read is likely to be read again, and an inherited one is only copied
+// again if a child drops it, so both stay until a new source needs the room.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Readers {
+    One(u64),
+    Many,
 }
 
 impl Kept {
     fn unread(&self) -> bool {
         self.units.references() == self.held
     }
+
+    fn spent(&self) -> bool {
+        matches!(self.readers, Readers::One(_)) && self.unread()
+    }
 }
 
 impl List {
-    fn find(&mut self, key: &Key) -> Option<Units> {
+    fn find(&mut self, key: &Key, reader: u64) -> Option<Units> {
         let at = self.kept.iter().position(|kept| kept.key == *key)?;
-        let found = self.kept.remove(at);
+        let mut found = self.kept.remove(at);
+        if found.readers != Readers::One(reader) {
+            found.readers = Readers::Many;
+        }
         let units = found.units.clone();
         self.kept.push(found);
         Some(units)
     }
 
+    // V8's release of a string touches only the count, so a copy whose last
+    // string has gone waits for the next `Sources::units` call.
+    fn sweep(&mut self) -> Vec<Kept> {
+        let spent: Vec<Kept> = self.kept.extract_if(.., |kept| kept.spent()).collect();
+        for kept in &spent {
+            if self.swept.len() >= MAX_SWEPT {
+                self.swept.remove(0);
+            }
+            self.swept.push(kept.key.clone());
+        }
+        spent
+    }
+
+    fn unswept(&mut self, key: &Key) -> bool {
+        let before = self.swept.len();
+        self.swept.retain(|swept| swept != key);
+        self.swept.len() < before
+    }
+
     // Whether `bytes` more fit beside what strings still read, which nothing
     // can drop.
     fn room(&self, bytes: usize, (sources, most): (usize, usize)) -> bool {
@@ -161,30 +205,43 @@ impl Sources {
         Self {
             list: Mutex::default(),
             bounds: (sources, bytes),
+            next_reader: AtomicU64::new(0),
             made: AtomicU64::new(0),
             reads: AtomicU64::new(0),
             conversions: AtomicU64::new(0),
         }
     }
 
+    /// A number for a new context to read shared sources as, told apart from
+    /// every other context of this process.
+    pub(crate) fn reader(&self) -> u64 {
+        self.next_reader.fetch_add(1, Ordering::Relaxed)
+    }
+
     /// The shared source of the script `text` under `key`, kept from the first
-    /// context that asks for it. `None` leaves the context its own copy: the
-    /// source is invalid UTF-8, or too large for what is kept and still read.
-    /// Only a source that may fit is converted, outside the lock.
-    pub(crate) fn units(&self, key: &Key, text: &JsText) -> Option<Units> {
+    /// context that asks for it, for the context `reader`. `None` leaves the
+    /// context its own copy: the source is invalid UTF-8, or too large for
+    /// what is kept and still read. Only a source that may fit is converted,
+    /// outside the lock. Every call looks up the requested source, then drops
+    /// each other copy that no string reads and that one context alone ever
+    /// read.
+    pub(crate) fn units(&self, key: &Key, text: &JsText, reader: u64) -> Option<Units> {
         let mut list = lock(&self.list);
-        if let Some(units) = list.find(key) {
-            return Some(units);
-        }
-        if !list.room(list.least_bytes(key, text), self.bounds) {
-            return None;
-        }
+        // Found before the sweep, so a copy the context before this one left
+        // unread is read again, and kept, rather than copied again.
+        let found = list.find(key, reader);
+        let spent = list.sweep();
+        let room = found.is_none() && list.room(list.least_bytes(key, text), self.bounds);
         drop(list);
+        drop(spent);
+        if !room {
+            return found;
+        }
         self.conversions.fetch_add(1, Ordering::Relaxed);
         let units = Units::of(text);
         let mut list = lock(&self.list);
         // Made meanwhile by a context loading the same script.
-        if let Some(found) = list.find(key) {
+        if let Some(found) = list.find(key, reader) {
             return Some(found);
         }
         let bytes = units.as_ref().map_or(usize::MAX, Units::bytes);
@@ -211,13 +268,20 @@ impl Sources {
             };
             dropped.push(list.kept.remove(at));
         }
+        let readers = if list.unswept(key) {
+            Readers::Many
+        } else {
+            Readers::One(reader)
+        };
         list.kept.push(Kept {
             key: key.clone(),
             units: units.clone(),
             held: 1,
+            readers,
         });
         drop(list);
-        // Freed once the lock is released, as a large source takes a while.
+        // Freed once the lock is released, as a large source takes a while,
+        // like the spent copies above.
         drop(dropped);
         self.made.fetch_add(1, Ordering::Relaxed);
         Some(units)
@@ -242,9 +306,11 @@ impl Sources {
                         key: kept.key.clone(),
                         units: kept.units.clone(),
                         held: kept.held + 1,
+                        readers: Readers::Many,
                     })
                     .collect(),
                 refused: list.refused.clone(),
+                swept: list.swept.clone(),
             })
             .unwrap_or_default();
         Self {
@@ -291,16 +357,14 @@ mod tests {
     use crate::control::JsText;
     use crate::process::code_cache::{CodeCache, Key};
 
-    // A script's key once the code cache has seen it twice.
+    // A script's key, as its first sighting in a context sharing it has it.
     fn key(text: &JsText) -> Key {
         let cache: &'static CodeCache = Box::leak(Box::default());
-        let name = JsText::from("bundle.js");
-        let _ = cache.plan(&name, text, None);
         cache
-            .plan(&name, text, None)
+            .plan(&JsText::from("bundle.js"), text, None, true)
             .key()
             .cloned()
-            .unwrap_or_else(|| panic!("a second sighting has a key"))
+            .unwrap_or_else(|| panic!("a shared first sighting has a key"))
     }
 
     fn script(seed: u8) -> JsText {
@@ -356,8 +420,8 @@ mod tests {
         let sources = Sources::default();
         let text = script(1);
         let key = key(&text);
-        let first = one_byte(sources.units(&key, &text));
-        let second = one_byte(sources.units(&key, &text));
+        let first = one_byte(sources.units(&key, &text, sources.reader()));
+        let second = one_byte(sources.units(&key, &text, sources.reader()));
         assert!(Arc::ptr_eq(&first, &second));
         assert_eq!(sources.made(), 1);
         assert_eq!(sources.reading(), 2);
@@ -377,6 +441,12 @@ mod tests {
         }
     }
 
+    // A copy two contexts have read, the second still reading it.
+    fn shared(sources: &Sources, key: &Key, text: &JsText) -> Option<Units> {
+        drop(sources.units(key, text, sources.reader()));
+        sources.units(key, text, sources.reader())
+    }
+
     #[test]
     fn a_source_still_read_is_kept_and_an_unread_one_makes_room() {
         let sources = Sources::default();
@@ -386,31 +456,108 @@ mod tests {
         let mut read: Vec<Option<Units>> = texts
             .iter()
             .zip(&keys)
-            .map(|(text, key)| sources.units(key, text))
+            .map(|(text, key)| shared(&sources, key, text))
             .collect();
         let extra = script(100);
         let extra_key = key(&extra);
-        assert!(sources.units(&extra_key, &extra).is_none());
+        assert!(shared(&sources, &extra_key, &extra).is_none());
         drop(read.remove(3));
         drop(read.remove(0));
-        drop(sources.units(&keys[3], &texts[3]));
+        drop(sources.units(&keys[3], &texts[3], sources.reader()));
         // Of the two unread, the least recently used makes room.
-        assert!(sources.units(&extra_key, &extra).is_some());
+        assert!(shared(&sources, &extra_key, &extra).is_some());
         let made = sources.made();
         assert_eq!(made, u64::from(count) + 1);
-        drop(sources.units(&keys[3], &texts[3]));
+        drop(sources.units(&keys[3], &texts[3], sources.reader()));
         assert_eq!(sources.made(), made);
-        drop(sources.units(&keys[0], &texts[0]));
+        drop(sources.units(&keys[0], &texts[0], sources.reader()));
         assert_eq!(sources.made(), made + 1);
         for (at, held) in [1, 2, 4, 5, 6, 7].into_iter().zip(&read) {
             assert!(same(
-                sources.units(&keys[at], &texts[at]).as_ref(),
+                sources
+                    .units(&keys[at], &texts[at], sources.reader())
+                    .as_ref(),
                 held.as_ref()
             ));
         }
         assert_eq!(sources.made(), made + 1);
     }
 
+    // One context's copy, however often it read it, waits for no new source
+    // once no string reads it: the next call drops and frees it.
+    #[test]
+    fn a_copy_one_context_read_goes_at_the_next_call_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(70), script(71));
+        let (key, other_key) = (key(&text), key(&other));
+        let reader = sources.reader();
+        let first = one_byte(sources.units(&key, &text, reader));
+        let again = one_byte(sources.units(&key, &text, reader));
+        assert!(Arc::ptr_eq(&first, &again));
+        let copy = Arc::downgrade(&first);
+        drop((first, again));
+        assert!(copy.upgrade().is_some());
+        drop(sources.units(&other_key, &other, sources.reader()));
+        assert!(copy.upgrade().is_none());
+        drop(sources.units(&key, &text, sources.reader()));
+        assert_eq!(sources.made(), 3);
+    }
+
+    #[test]
+    fn a_copy_two_contexts_read_in_turn_stays_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(72), script(73));
+        let (key, other_key) = (key(&text), key(&other));
+        let copy = Arc::downgrade(&one_byte(shared(&sources, &key, &text)));
+        drop(sources.units(&other_key, &other, sources.reader()));
+        let again = one_byte(sources.units(&key, &text, sources.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
+        );
+        assert_eq!(sources.made(), 2);
+    }
+
+    #[test]
+    fn a_copy_a_second_context_reads_while_the_first_does_stays_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(74), script(75));
+        let (key, other_key) = (key(&text), key(&other));
+        let first = one_byte(sources.units(&key, &text, sources.reader()));
+        let second = one_byte(sources.units(&key, &text, sources.reader()));
+        let copy = Arc::downgrade(&first);
+        drop((first, second));
+        drop(sources.units(&other_key, &other, sources.reader()));
+        let again = one_byte(sources.units(&key, &text, sources.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
+        );
+        assert_eq!(sources.made(), 2);
+    }
+
+    // Contexts loading two scripts in turn, each gone before the next, sweep
+    // each other's copy; a copy made again after its sweep is kept as one more
+    // than one context read, so each script is converted twice in all.
+    #[test]
+    fn scripts_loaded_in_turn_by_short_lived_contexts_stay_after_their_second_copy() {
+        let sources = Sources::default();
+        let texts = [script(78), script(79)];
+        let keys = texts.each_ref().map(key);
+        for _ in 0..2 {
+            for (key, text) in keys.iter().zip(&texts) {
+                drop(sources.units(key, text, sources.reader()));
+            }
+        }
+        assert_eq!(sources.made(), 4);
+        for _ in 0..3 {
+            for (key, text) in keys.iter().zip(&texts) {
+                drop(sources.units(key, text, sources.reader()));
+            }
+        }
+        assert_eq!(sources.made(), 4);
+    }
+
     #[test]
     fn a_full_list_converts_nothing() {
         let sources = Sources::default();
@@ -418,18 +565,26 @@ mod tests {
         let read: Vec<Option<Units>> = (40..40 + count)
             .map(|seed| {
                 let text = script(seed);
-                sources.units(&key(&text), &text)
+                sources.units(&key(&text), &text, sources.reader())
             })
             .collect();
         let converted = sources.conversions();
         let extra = script(100);
         let extra_key = key(&extra);
         for _ in 0..3 {
-            assert!(sources.units(&extra_key, &extra).is_none());
+            assert!(
+                sources
+                    .units(&extra_key, &extra, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!(sources.conversions(), converted);
         drop(read);
-        assert!(sources.units(&extra_key, &extra).is_some());
+        assert!(
+            sources
+                .units(&extra_key, &extra, sources.reader())
+                .is_some()
+        );
         assert_eq!(sources.conversions(), converted + 1);
     }
 
@@ -440,21 +595,29 @@ mod tests {
     fn a_source_is_converted_only_while_it_may_fit() {
         let sources = Sources::bounded(MAX_SOURCES, 5 << 20);
         let read = script(50);
-        let still_read = sources.units(&key(&read), &read);
+        let still_read = sources.units(&key(&read), &read, sources.reader());
         assert!(still_read.is_some());
         let too_large = JsText::Latin1(vec![51; 4 << 20]);
-        assert!(sources.units(&key(&too_large), &too_large).is_none());
+        assert!(
+            sources
+                .units(&key(&too_large), &too_large, sources.reader())
+                .is_none()
+        );
         assert_eq!(sources.conversions(), 1);
         let mut astral = vec![b'a'; 2 << 20];
         astral.extend_from_slice("\u{1F600}".as_bytes());
         let astral = JsText::Utf8(astral);
         let astral_key = key(&astral);
         for _ in 0..3 {
-            assert!(sources.units(&astral_key, &astral).is_none());
+            assert!(
+                sources
+                    .units(&astral_key, &astral, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!(sources.conversions(), 2);
         drop(still_read);
-        assert!(two_byte(sources.units(&astral_key, &astral)).len() > 2 << 20);
+        assert!(two_byte(sources.units(&astral_key, &astral, sources.reader())).len() > 2 << 20);
         assert_eq!((sources.conversions(), sources.made()), (3, 2));
     }
 
@@ -466,7 +629,11 @@ mod tests {
         let invalid = JsText::Utf8(invalid);
         let invalid_key = key(&invalid);
         for _ in 0..3 {
-            assert!(sources.units(&invalid_key, &invalid).is_none());
+            assert!(
+                sources
+                    .units(&invalid_key, &invalid, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!((sources.conversions(), sources.made()), (1, 0));
     }
@@ -476,32 +643,56 @@ mod tests {
         let parent: &'static Sources = Box::leak(Box::default());
         let text = script(2);
         let key = key(&text);
-        let shared = parent.units(&key, &text);
+        let shared = parent.units(&key, &text, parent.reader());
         let child = parent.inherited();
-        let in_child = child.units(&key, &text);
+        let in_child = child.units(&key, &text, child.reader());
         assert!(same(shared.as_ref(), in_child.as_ref()));
         assert_eq!(child.reading(), 2);
         let copy = Arc::downgrade(&one_byte(shared));
         drop(in_child);
+        // Sources the child still reads fill its list, so the unread
+        // inherited copy makes room.
         let count = u8::try_from(MAX_SOURCES).unwrap_or(u8::MAX);
-        for seed in 30..30 + count {
-            let other = script(seed);
-            drop(child.units(&self::key(&other), &other));
-        }
+        let others: Vec<Option<Units>> = (30..30 + count)
+            .map(|seed| {
+                let other = script(seed);
+                child.units(&self::key(&other), &other, child.reader())
+            })
+            .collect();
         assert_eq!(copy.strong_count(), 1);
-        let again = one_byte(child.units(&key, &text));
+        drop(others);
+        let again = one_byte(child.units(&key, &text, child.reader()));
         assert!(
             !copy
                 .upgrade()
                 .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
         );
-        let from_parent = one_byte(parent.units(&key, &text));
+        let from_parent = one_byte(parent.units(&key, &text, parent.reader()));
         assert!(
             copy.upgrade()
                 .is_some_and(|copy| Arc::ptr_eq(&copy, &from_parent))
         );
     }
 
+    // Dropping an inherited copy frees nothing in a child, and its next
+    // context loading the script would copy it again, so the child keeps
+    // one only its parent's context read.
+    #[test]
+    fn a_child_keeps_an_inherited_copy_one_context_read() {
+        let parent: &'static Sources = Box::leak(Box::default());
+        let (text, other) = (script(76), script(77));
+        let (key, other_key) = (key(&text), key(&other));
+        let copy = Arc::downgrade(&one_byte(parent.units(&key, &text, parent.reader())));
+        let child = parent.inherited();
+        drop(child.units(&other_key, &other, child.reader()));
+        let in_child = one_byte(child.units(&key, &text, child.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &in_child))
+        );
+        assert_eq!(child.made(), 1);
+    }
+
     // A child's inherited copies stay read while its parent's strings hold
     // them, so a child forked with a full list must not convert either.
     #[test]
@@ -511,14 +702,14 @@ mod tests {
         let read: Vec<Option<Units>> = (60..60 + count)
             .map(|seed| {
                 let text = script(seed);
-                parent.units(&key(&text), &text)
+                parent.units(&key(&text), &text, parent.reader())
             })
             .collect();
         let child = parent.inherited();
         let extra = script(110);
         let extra_key = key(&extra);
         for _ in 0..3 {
-            assert!(child.units(&extra_key, &extra).is_none());
+            assert!(child.units(&extra_key, &extra, child.reader()).is_none());
         }
         assert_eq!(child.conversions(), 0);
         drop(read);
@@ -529,11 +720,14 @@ mod tests {
         let parent = Sources::default();
         let text = script(3);
         let key = key(&text);
-        let shared = one_byte(parent.units(&key, &text));
+        let shared = one_byte(parent.units(&key, &text, parent.reader()));
         let held = parent.list.lock();
         let child = parent.inherited();
         drop(held);
-        assert!(!Arc::ptr_eq(&shared, &one_byte(child.units(&key, &text))));
+        assert!(!Arc::ptr_eq(
+            &shared,
+            &one_byte(child.units(&key, &text, child.reader()))
+        ));
         assert_eq!(child.made(), 1);
     }
 }

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)?);