@miaskiewicz/turbo-dom 0.1.26 → 0.1.28

package/index.d.ts

@@ -34,23 +34,13 @@ export declare function parseRaw(html: string): number
  * objects lazily from this — no eager full-tree allocation. The fast path.
  */
 export interface JsSoa {
-  nodeType: Uint8Array
-  ns: Uint8Array
-  tagId: Uint32Array
-  parent: Int32Array
-  firstChild: Int32Array
-  nextSib: Int32Array
-  textId: Int32Array
-  pubId: Int32Array
-  sysId: Int32Array
-  attrStart: Int32Array
-  attrCount: Uint16Array
-  attrNameId: Uint32Array
-  attrValue: Array<string>
-  attrPrefixId: Uint32Array
+  packed: Uint8Array
+  n: number
+  m: number
   tagNames: Array<string>
   attrNames: Array<string>
   attrPrefixes: Array<string>
+  attrValues: Array<string>
   strings: Array<string>
 }
 /** Parse a document into the SoA flat buffer (the fast runtime path). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miaskiewicz/turbo-dom",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "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/core.rs

@@ -89,12 +89,13 @@ pub struct Soa {
     pub attr_count: Vec<u16>,  // attrs for this node
     // flat attr tables — names/prefixes interned (highly repetitive), values pooled
     pub attr_name_id: Vec<u32>, // index into attr_names
-    pub attr_value: Vec<String>,
+    pub attr_value_id: Vec<u32>, // index into attr_values (interned, deduped)
     pub attr_prefix_id: Vec<u32>, // index into attr_prefixes
     // string tables (interned, deduped)
     pub tag_names: Vec<String>,
     pub attr_names: Vec<String>,
     pub attr_prefixes: Vec<String>,
+    pub attr_values: Vec<String>, // interned attr value dictionary
     pub strings: Vec<String>,   // text/comment/doctype data, pooled
 }
 
@@ -103,6 +104,7 @@ struct SoaBuilder {
     tag_map: std::collections::HashMap<String, u32>,
     attr_name_map: std::collections::HashMap<String, u32>,
     attr_prefix_map: std::collections::HashMap<String, u32>,
+    attr_value_map: std::collections::HashMap<String, u32>,
 }
 
 impl SoaBuilder {
@@ -133,6 +135,15 @@ impl SoaBuilder {
         self.attr_prefix_map.insert(prefix.to_string(), id);
         id
     }
+    fn intern_attr_value(&mut self, value: &str) -> u32 {
+        if let Some(&id) = self.attr_value_map.get(value) {
+            return id;
+        }
+        let id = self.soa.attr_values.len() as u32;
+        self.soa.attr_values.push(value.to_string());
+        self.attr_value_map.insert(value.to_string(), id);
+        id
+    }
     fn push_string(&mut self, s: &str) -> i32 {
         let id = self.soa.strings.len() as i32;
         self.soa.strings.push(s.to_string());
@@ -184,12 +195,13 @@ impl SoaBuilder {
                 self.soa.tag_id[idx] = self.intern_tag(&name.local);
                 let borrowed = attrs.borrow();
                 if !borrowed.is_empty() {
-                    self.soa.attr_start[idx] = self.soa.attr_value.len() as i32;
+                    self.soa.attr_start[idx] = self.soa.attr_name_id.len() as i32;
                     self.soa.attr_count[idx] = borrowed.len() as u16;
                     for attr in borrowed.iter() {
                         let nid = self.intern_attr_name(&attr.name.local);
                         self.soa.attr_name_id.push(nid);
-                        self.soa.attr_value.push(attr.value.to_string());
+                        let vid = self.intern_attr_value(&attr.value);
+                        self.soa.attr_value_id.push(vid);
                         let pfx = attr.name.prefix.as_ref().map(|p| p.to_string()).unwrap_or_default();
                         let pid = self.intern_attr_prefix(&pfx);
                         self.soa.attr_prefix_id.push(pid);
@@ -252,6 +264,7 @@ pub fn parse_html_soa(html: &str) -> Soa {
         tag_map: std::collections::HashMap::new(),
         attr_name_map: std::collections::HashMap::new(),
         attr_prefix_map: std::collections::HashMap::new(),
+        attr_value_map: std::collections::HashMap::new(),
     };
     b.alloc(&dom.document, -1);
     b.soa

package/src/lib.rs

@@ -71,48 +71,47 @@ mod napi_front {
 
     /// SoA flat buffer: structure as typed arrays, crossed once. JS inflates node
     /// objects lazily from this — no eager full-tree allocation. The fast path.
+    // All numeric columns packed into ONE little-endian byte blob (1 ArrayBuffer +
+    // zero-copy views in JS, vs 13 separate addon buffers + finalizers per parse).
+    // Layout — 4-byte block first (keeps every Int32/Uint32 view 4-aligned), then
+    // u16, then u8.  Length-N: tag_id,parent,first_child,next_sib,text_id,pub_id,
+    // sys_id,attr_start | Length-M: attr_name_id,attr_value_id,attr_prefix_id |
+    // u16 N: attr_count | u8 N: node_type, ns.  JS unpack must mirror this order.
     #[napi(object)]
     pub struct JsSoa {
-        pub node_type: Uint8Array,
-        pub ns: Uint8Array,
-        pub tag_id: Uint32Array,
-        pub parent: Int32Array,
-        pub first_child: Int32Array,
-        pub next_sib: Int32Array,
-        pub text_id: Int32Array,
-        pub pub_id: Int32Array,
-        pub sys_id: Int32Array,
-        pub attr_start: Int32Array,
-        pub attr_count: Uint16Array,
-        pub attr_name_id: Uint32Array,
-        pub attr_value: Vec<String>,
-        pub attr_prefix_id: Uint32Array,
+        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>,
     }
 
     impl From<core::Soa> for JsSoa {
         fn from(s: core::Soa) -> Self {
+            let n = s.node_type.len();
+            let m = s.attr_name_id.len();
+            let mut buf: Vec<u8> = Vec::with_capacity(36 * n + 12 * m);
+            for col in [&s.tag_id] { for v in col.iter() { buf.extend_from_slice(&v.to_le_bytes()); } }
+            for col in [&s.parent, &s.first_child, &s.next_sib, &s.text_id, &s.pub_id, &s.sys_id, &s.attr_start] {
+                for v in col.iter() { buf.extend_from_slice(&v.to_le_bytes()); }
+            }
+            for col in [&s.attr_name_id, &s.attr_value_id, &s.attr_prefix_id] {
+                for v in col.iter() { buf.extend_from_slice(&v.to_le_bytes()); }
+            }
+            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);
             JsSoa {
-                node_type: Uint8Array::new(s.node_type),
-                ns: Uint8Array::new(s.ns),
-                tag_id: Uint32Array::new(s.tag_id),
-                parent: Int32Array::new(s.parent),
-                first_child: Int32Array::new(s.first_child),
-                next_sib: Int32Array::new(s.next_sib),
-                text_id: Int32Array::new(s.text_id),
-                pub_id: Int32Array::new(s.pub_id),
-                sys_id: Int32Array::new(s.sys_id),
-                attr_start: Int32Array::new(s.attr_start),
-                attr_count: Uint16Array::new(s.attr_count),
-                attr_name_id: Uint32Array::new(s.attr_name_id),
-                attr_value: s.attr_value,
-                attr_prefix_id: Uint32Array::new(s.attr_prefix_id),
+                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,
             }
         }

package/src/runtime/buffer.mjs

@@ -3,10 +3,32 @@
 
 const NS_SHORT = ['', 'svg', 'math'];
 
+// Inflate the packed byte blob into named typed-array views (zero-copy).
+// Mirrors the column order in lib.rs JsSoa::from. One ArrayBuffer, ~13 views.
+function unpack(soa) {
+  const u8 = soa.packed, ab = u8.buffer, base = u8.byteOffset, n = soa.n, m = soa.m;
+  let off = base;
+  const i32 = () => { const a = new Int32Array(ab, off, n); off += n * 4; return a; };
+  const u32n = () => { const a = new Uint32Array(ab, off, n); off += n * 4; return a; };
+  const u32m = () => { const a = new Uint32Array(ab, off, m); off += m * 4; return a; };
+  const tagId = u32n(), parent = i32(), firstChild = i32(), nextSib = i32(),
+    textId = i32(), pubId = i32(), sysId = i32(), attrStart = i32();
+  const attrNameId = u32m(), attrValueId = u32m(), attrPrefixId = u32m();
+  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;
+  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,
+  };
+}
+
 export class Buffer {
   constructor(soa) {
-    this.soa = soa;
-    this.length = soa.nodeType.length;
+    this.soa = soa.packed ? unpack(soa) : soa;
+    this.length = this.soa.nodeType.length;
   }
   nodeType(i) { return this.soa.nodeType[i]; }
   ns(i) { return NS_SHORT[this.soa.ns[i]] || ''; }
@@ -17,16 +39,35 @@ export class Buffer {
   text(i) { const t = this.soa.textId[i]; return t < 0 ? '' : this.soa.strings[t]; }
   publicId(i) { const t = this.soa.pubId[i]; return t < 0 ? '' : this.soa.strings[t]; }
   systemId(i) { const t = this.soa.sysId[i]; return t < 0 ? '' : this.soa.strings[t]; }
+  // Read a single attr value / presence straight from the columns — no array,
+  // no {name,value,prefix} objects. The hot read path (selectors hammer
+  // getAttribute('class')/('id')) never materializes the attr list.
+  attrGet(i, name) {
+    const start = this.soa.attrStart[i];
+    if (start < 0) return null;
+    const count = this.soa.attrCount[i];
+    const { attrNameId, attrNames, attrValueId, attrValues } = this.soa;
+    for (let k = 0; k < count; k++) if (attrNames[attrNameId[start + k]] === name) return attrValues[attrValueId[start + k]];
+    return null;
+  }
+  attrHas(i, name) {
+    const start = this.soa.attrStart[i];
+    if (start < 0) return false;
+    const count = this.soa.attrCount[i];
+    const { attrNameId, attrNames } = this.soa;
+    for (let k = 0; k < count; k++) if (attrNames[attrNameId[start + k]] === name) return true;
+    return false;
+  }
   attrs(i) {
     const start = this.soa.attrStart[i];
     if (start < 0) return [];
     const count = this.soa.attrCount[i];
     const out = new Array(count);
-    const { attrNameId, attrNames, attrValue, attrPrefixId, attrPrefixes } = this.soa;
+    const { attrNameId, attrNames, attrValueId, attrValues, attrPrefixId, attrPrefixes } = this.soa;
     for (let k = 0; k < count; k++) {
       out[k] = {
         name: attrNames[attrNameId[start + k]],
-        value: attrValue[start + k],
+        value: attrValues[attrValueId[start + k]],
         prefix: attrPrefixes[attrPrefixId[start + k]] || '',
       };
     }

package/src/runtime/dom.mjs

@@ -354,8 +354,18 @@ export class Element extends Node {
   // builds the array from the SoA only when an attribute is first touched (many
   // elements are inflated for traversal but never have attrs read).
   __buildAttrs() { const doc = this.ownerDocument, buf = doc && doc.__buf; return (this.__attrIdx >= 0 && buf) ? buf.attrs(this.__attrIdx) : []; }
-  getAttribute(name) { const at = this.__attrs ?? (this.__attrs = this.__buildAttrs()); for (let i = 0; i < at.length; i++) if (at[i].name === name) return at[i].value; return null; }
-  hasAttribute(name) { const at = this.__attrs ?? (this.__attrs = this.__buildAttrs()); for (let i = 0; i < at.length; i++) if (at[i].name === name) return true; return false; }
+  getAttribute(name) {
+    const at = this.__attrs;
+    if (at !== undefined) { for (let i = 0; i < at.length; i++) if (at[i].name === name) return at[i].value; return null; }
+    const doc = this.ownerDocument, buf = doc && doc.__buf;        // lazy: read column, don't materialize
+    return (this.__attrIdx >= 0 && buf) ? buf.attrGet(this.__attrIdx, name) : null;
+  }
+  hasAttribute(name) {
+    const at = this.__attrs;
+    if (at !== undefined) { for (let i = 0; i < at.length; i++) if (at[i].name === name) return true; return false; }
+    const doc = this.ownerDocument, buf = doc && doc.__buf;
+    return (this.__attrIdx >= 0 && buf) ? buf.attrHas(this.__attrIdx, name) : false;
+  }
   getAttributeNames() { return (this.__attrs ?? (this.__attrs = this.__buildAttrs())).map((a) => a.name); }
   setAttribute(name, value) {
     if (this.__attrs === undefined) this.__attrs = this.__buildAttrs();

package/src/runtime/html-serialize.mjs

@@ -20,7 +20,10 @@ function serializeNode(node, out) {
     case 1: { // element
       const tag = node.localName;
       out.push('<' + tag);
-      for (const a of node.__attrs) {
+      // __attrs is lazy: buffer-backed elements leave it undefined (store __attrIdx).
+      // Build from the SoA on first touch, matching every other __attrs read site.
+      const attrs = node.__attrs ?? (node.__attrs = node.__buildAttrs());
+      for (const a of attrs) {
         const name = a.prefix ? `${a.prefix}:${a.name}` : a.name;
         out.push(` ${name}="${escapeAttr(a.value)}"`);
       }