@miaskiewicz/turbo-dom 0.1.55 → 0.1.56

package/README.md

@@ -14,7 +14,7 @@ npm install -D @miaskiewicz/turbo-dom
 
 - ✅ **More compatible than happy-dom** — 99.72% on html5lib-tests vs happy-dom's 37%.
   Runs React Testing Library, `user-event`, downshift, Radix UI, and Headless UI unmodified.
-- ⚡ **Faster than both** — ~130× jsdom / ~45× happy-dom on a realistic suite (parse-memoized repeated shells), ~8–35× faster HTML parsing on real pages, and ~2.2× happy-dom on repeated queries while staying 99.7% spec-correct.
+- ⚡ **Faster than both** — ~130× jsdom / ~45× happy-dom on a realistic suite (parse-memoized repeated shells), ~8–44× faster HTML parsing on real pages, and ~2.7× happy-dom on repeated queries while staying 99.7% spec-correct.
 - 🎯 **Honest, not lying** — no fake layout numbers; `getBoundingClientRect()` is zeros.
   `getComputedStyle` runs a **partial cascade**: it resolves real injected `<style>` rules
   (emotion/MUI `.css-HASH{…}`) + inline styles with proper specificity/source order — but only
@@ -109,16 +109,16 @@ the suite row (ms/file, lower = faster):
 
 | benchmark | turbo-dom | happy-dom | jsdom |
 |---|---:|---:|---:|
-| **realistic suite**, 200 files (ms/file) | **~0.025** | 1.13 | 3.40 |
-| **cold per-file construct + query** (ops/s) | **~200k** | 579 | 266 |
-| **parse 56 KB SSR** (ops/s) | **510** | 48 | 66 |
-| **parse 20 KB real page** (ops/s) | **3,628** | 161 | 105 |
-| repeated query throughput (iters/s) | **~1.5M** | 680k | 3.3k |
+| **realistic suite**, 200 files (ms/file) | **~0.025** | 1.08 | 3.20 |
+| **cold per-file construct + query** (ops/s) | **~230k** | 575 | 267 |
+| **parse 56 KB SSR** (ops/s) | **528** | 48 | 65 |
+| **parse 20 KB real page** (ops/s) | **4,353** | 135 | 99 |
+| repeated query throughput (iters/s) | **~1.8M** | 661k | 3.3k |
 | html5lib conformance | **99.72%** | 37.35% | 97.03% |
 
 On a realistic suite — 200 files of construct + queries + events — turbo-dom is
-**~45× happy-dom and ~130× jsdom**, runs repeated queries **~2.2× happy-dom**
-(~460× jsdom), and parses real pages/SSR documents **~8–35×** faster, all at 99.7%
+**~45× happy-dom and ~130× jsdom**, runs repeated queries **~2.7× happy-dom**
+(~550× jsdom), and parses real pages/SSR documents **~8–44×** faster, all at 99.7%
 conformance.
 
 The per-file setup number is so high because the parser **memoizes the read-only

package/index.d.ts

@@ -37,11 +37,8 @@ export interface JsSoa {
   packed: Uint8Array
   n: number
   m: number
-  tagNames: Array<string>
-  attrNames: Array<string>
-  attrPrefixes: Array<string>
-  attrValues: Array<string>
-  strings: Array<string>
+  strBlob: Uint8Array
+  strMeta: Uint32Array
 }
 /** Parse a document into the SoA flat buffer (the fast runtime path). */
 export declare function parseBuffer(html: string): JsSoa

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miaskiewicz/turbo-dom",
-  "version": "0.1.55",
+  "version": "0.1.56",
   "description": "Faster, more spec-correct DOM for test runners — native html5ever (Rust/WASM) parser + lazy copy-on-write DOM. A drop-in-style alternative to jsdom/happy-dom for vitest & jest.",
   "license": "MIT",
   "main": "index.js",

package/src/lib.rs

@@ -82,11 +82,14 @@ mod napi_front {
         pub packed: Uint8Array,
         pub n: u32,
         pub m: u32,
-        pub tag_names: Vec<String>,
-        pub attr_names: Vec<String>,
-        pub attr_prefixes: Vec<String>,
-        pub attr_values: Vec<String>,
-        pub strings: Vec<String>,
+        // The five string tables (tag_names, attr_names, attr_prefixes, attr_values,
+        // strings) are shipped as ONE raw UTF-8 byte blob + a meta array, NOT as
+        // Vec<String>. Vec<String> forces napi to UTF-8→UTF-16 convert every string
+        // at the boundary (~12% of parse, even for strings a test never reads). The
+        // blob crosses with zero conversion; JS decodes once, lazily, in unpack().
+        // str_meta = [count0..count4, then every string's byte length in table order].
+        pub str_blob: Uint8Array,
+        pub str_meta: Uint32Array,
     }
 
     impl From<core::Soa> for JsSoa {
@@ -104,15 +107,27 @@ mod napi_front {
             for v in s.attr_count.iter() { buf.extend_from_slice(&v.to_le_bytes()); }
             buf.extend_from_slice(&s.node_type);
             buf.extend_from_slice(&s.ns);
+            // pack all five string tables into one byte blob + meta (5 counts, then
+            // per-string byte lengths in table order). Zero napi string conversion.
+            let tables: [&Vec<String>; 5] =
+                [&s.tag_names, &s.attr_names, &s.attr_prefixes, &s.attr_values, &s.strings];
+            let total_strs: usize = tables.iter().map(|t| t.len()).sum();
+            let total_bytes: usize = tables.iter().flat_map(|t| t.iter()).map(|x| x.len()).sum();
+            let mut str_blob: Vec<u8> = Vec::with_capacity(total_bytes);
+            let mut str_meta: Vec<u32> = Vec::with_capacity(5 + total_strs);
+            for t in &tables { str_meta.push(t.len() as u32); }
+            for t in &tables {
+                for x in t.iter() {
+                    str_meta.push(x.len() as u32);
+                    str_blob.extend_from_slice(x.as_bytes());
+                }
+            }
             JsSoa {
                 packed: Uint8Array::new(buf),
                 n: n as u32,
                 m: m as u32,
-                tag_names: s.tag_names,
-                attr_names: s.attr_names,
-                attr_prefixes: s.attr_prefixes,
-                attr_values: s.attr_values,
-                strings: s.strings,
+                str_blob: Uint8Array::new(str_blob),
+                str_meta: Uint32Array::new(str_meta),
             }
         }
     }

package/src/runtime/buffer.mjs

@@ -19,13 +19,30 @@ export function unpack(soa) {
   const attrCount = new Uint16Array(ab, off, n); off += n * 2;
   const nodeType = new Uint8Array(ab, off, n); off += n;
   const ns = new Uint8Array(ab, off, n); off += n;
+  // Decode the five string tables from the raw byte blob (one pass per string),
+  // done ONCE here per cached parse. The native side ships bytes with no per-string
+  // napi UTF-8→UTF-16 conversion; the accessors below read plain arrays (hot path
+  // unchanged). meta = [5 counts, then every string's byte length in table order].
+  const meta = soa.strMeta, blob = soa.strBlob;
+  let mi = 5, bo = 0;
+  const table = (count) => {
+    const arr = new Array(count);
+    for (let k = 0; k < count; k++) {
+      const len = meta[mi++];
+      arr[k] = len === 0 ? '' : STR_DECODER.decode(blob.subarray(bo, bo + len));
+      bo += len;
+    }
+    return arr;
+  };
+  const tagNames = table(meta[0]), attrNames = table(meta[1]), attrPrefixes = table(meta[2]),
+    attrValues = table(meta[3]), strings = table(meta[4]);
   return {
     nodeType, ns, tagId, parent, firstChild, nextSib, textId, pubId, sysId,
     attrStart, attrCount, attrNameId, attrValueId, attrPrefixId,
-    tagNames: soa.tagNames, attrNames: soa.attrNames, attrPrefixes: soa.attrPrefixes,
-    attrValues: soa.attrValues, strings: soa.strings,
+    tagNames, attrNames, attrPrefixes, attrValues, strings,
   };
 }
+const STR_DECODER = new TextDecoder();
 
 export class Buffer {
   constructor(soa) {