feat: implement decodeNode function to convert WhatsApp binary format to BinaryNode object using packed LNP buffer

Author: jlucaso1

src/binary.rs

@@ -341,6 +341,7 @@ impl InternalBinaryNode {
 thread_local! {
     static ENCODE_BUF: UnsafeCell<Vec<u8>> = const { UnsafeCell::new(Vec::new()) };
     static INPUT_BUF: UnsafeCell<Vec<u8>> = const { UnsafeCell::new(Vec::new()) };
+    static DECODE_BUF: UnsafeCell<Vec<u8>> = const { UnsafeCell::new(Vec::new()) };
 }
 
 // ── Zero-alloc result passing ───────────────────────────────────────────
@@ -486,3 +487,89 @@ pub fn decode_node(data: Vec<u8>) -> Result<InternalBinaryNode, JsValue> {
         cached_content: UnsafeCell::new(None),
     })
 }
+
+// ── Packed decode: NodeRef → LNP buffer ─────────────────────────────────
+//
+// Reverse of parse_packed_node: serializes a NodeRef into the same packed
+// binary format that JS uses for encode input. JS reads this from WASM memory
+// and constructs plain { tag, attrs, content } objects — zero FFI wrappers.
+
+#[inline]
+fn write_packed_str(buf: &mut Vec<u8>, s: &str) {
+    buf.extend_from_slice(&(s.len() as u16).to_le_bytes());
+    buf.extend_from_slice(s.as_bytes());
+}
+
+fn write_packed_node(node: &NodeRef, buf: &mut Vec<u8>) {
+    // Tag
+    write_packed_str(buf, &node.tag);
+
+    // Attrs
+    buf.extend_from_slice(&(node.attrs.len() as u16).to_le_bytes());
+    for (k, v) in &node.attrs {
+        write_packed_str(buf, k);
+        match v.as_str() {
+            Some(s) => write_packed_str(buf, s),
+            None => {
+                let s = v.to_string();
+                write_packed_str(buf, &s);
+            }
+        }
+    }
+
+    // Content
+    match node.content.as_deref() {
+        None => buf.push(0),
+        Some(NodeContentRef::String(s)) => {
+            buf.push(1);
+            buf.extend_from_slice(&(s.len() as u32).to_le_bytes());
+            buf.extend_from_slice(s.as_bytes());
+        }
+        Some(NodeContentRef::Bytes(b)) => {
+            buf.push(2);
+            buf.extend_from_slice(&(b.len() as u32).to_le_bytes());
+            buf.extend_from_slice(b);
+        }
+        Some(NodeContentRef::Nodes(nodes)) => {
+            buf.push(3);
+            buf.extend_from_slice(&(nodes.len() as u16).to_le_bytes());
+            for child in nodes.iter() {
+                write_packed_node(child, buf);
+            }
+        }
+    }
+}
+
+/// Release memory held by internal buffers (after processing large messages).
+#[wasm_bindgen(js_name = shrinkBuffers)]
+pub fn shrink_buffers() {
+    ENCODE_BUF.with(|c| unsafe { (&mut *c.get()).shrink_to_fit() });
+    INPUT_BUF.with(|c| unsafe { (&mut *c.get()).shrink_to_fit() });
+    DECODE_BUF.with(|c| unsafe { (&mut *c.get()).shrink_to_fit() });
+}
+
+/// Decode WhatsApp binary format → packed LNP buffer in WASM memory.
+/// JS reads ptr+len from ENCODE_RESULT and constructs plain JS objects.
+#[wasm_bindgen(js_name = decodeNodeToPacked)]
+pub fn decode_node_to_packed(data: &[u8]) -> Result<(), JsValue> {
+    if data.is_empty() {
+        return Err(JsValue::from_str("Input data cannot be empty"));
+    }
+
+    let unpacked_cow = unpack(data).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let node_ref = unmarshal_ref(&unpacked_cow).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+    DECODE_BUF.with(|cell| {
+        // SAFETY: WASM is single-threaded
+        let buf = unsafe { &mut *cell.get() };
+        buf.clear();
+        write_packed_node(&node_ref, buf);
+        unsafe {
+            let result = &mut *ENCODE_RESULT.0.get();
+            result[0] = buf.as_ptr() as u32;
+            result[1] = buf.len() as u32;
+        }
+    });
+
+    Ok(())
+}

ts/index.ts

@@ -3,6 +3,8 @@ import {
   inputBufGrow,
   encodeFromInputBuf,
   encodeResultPtr,
+  decodeNodeToPacked,
+  shrinkBuffers,
   type BinaryNode,
 } from "../pkg/whatsapp_rust_bridge.js";
 
@@ -194,3 +196,111 @@ export function encodeNode(node: BinaryNode): Uint8Array {
   // Single JS-native slice: one alloc + one memcpy, no FFI crossings
   return new Uint8Array(wasmMemory.buffer, ptr, len).slice();
 }
+
+// ── Fast decodeNode via packed binary protocol ──────────────────────────
+//
+// Rust decodes WA binary → NodeRef → packed LNP buffer in WASM memory.
+// JS reads the buffer and constructs plain { tag, attrs, content } objects.
+// One FFI call, zero wrappers, zero FinalizationRegistry.
+
+const textDecoder = new TextDecoder();
+
+/** Read a u16-LE-prefixed UTF-8 string. ASCII fast path for short strings. */
+function readStr16(mem: Uint8Array, p: number[]): string {
+  const len = mem[p[0]] | (mem[p[0] + 1] << 8);
+  p[0] += 2;
+  if (len < 64) {
+    const start = p[0];
+    for (let i = 0; i < len; i++) {
+      if (mem[start + i] > 0x7f) {
+        // Non-ASCII: fall back to TextDecoder
+        const str = textDecoder.decode(
+          new Uint8Array(mem.buffer, mem.byteOffset + start, len),
+        );
+        p[0] += len;
+        return str;
+      }
+    }
+    // All ASCII: build string from char codes
+    let s = "";
+    for (let i = 0; i < len; i++) {
+      s += String.fromCharCode(mem[start + i]);
+    }
+    p[0] += len;
+    return s;
+  }
+  const str = textDecoder.decode(
+    new Uint8Array(mem.buffer, mem.byteOffset + p[0], len),
+  );
+  p[0] += len;
+  return str;
+}
+
+/** Unpack a single BinaryNode from packed LNP buffer. */
+function unpackNode(mem: Uint8Array, p: number[]): BinaryNode {
+  const tag = readStr16(mem, p);
+
+  const attrCount = mem[p[0]] | (mem[p[0] + 1] << 8);
+  p[0] += 2;
+  const attrs: Record<string, string> = {};
+  for (let i = 0; i < attrCount; i++) {
+    const k = readStr16(mem, p);
+    attrs[k] = readStr16(mem, p);
+  }
+
+  const contentType = mem[p[0]++];
+  let content: BinaryNode["content"] = undefined;
+
+  if (contentType === 1) {
+    // String
+    const len =
+      mem[p[0]] |
+      (mem[p[0] + 1] << 8) |
+      (mem[p[0] + 2] << 16) |
+      (mem[p[0] + 3] << 24);
+    p[0] += 4;
+    content = textDecoder.decode(
+      new Uint8Array(mem.buffer, mem.byteOffset + p[0], len),
+    );
+    p[0] += len;
+  } else if (contentType === 2) {
+    // Bytes — .slice() to avoid retaining WASM memory
+    const len =
+      (mem[p[0]] |
+        (mem[p[0] + 1] << 8) |
+        (mem[p[0] + 2] << 16) |
+        (mem[p[0] + 3] << 24)) >>>
+      0;
+    p[0] += 4;
+    content = mem.slice(p[0], p[0] + len);
+    p[0] += len;
+  } else if (contentType === 3) {
+    // Child nodes
+    const count = mem[p[0]] | (mem[p[0] + 1] << 8);
+    p[0] += 2;
+    const children: BinaryNode[] = new Array(count);
+    for (let i = 0; i < count; i++) {
+      children[i] = unpackNode(mem, p);
+    }
+    content = children;
+  }
+
+  return { tag, attrs, content };
+}
+
+/**
+ * Decode WhatsApp binary format to a plain BinaryNode object.
+ * Rust decodes + serializes to packed LNP → JS reads from WASM memory.
+ * One FFI call, zero wrappers, zero FinalizationRegistry.
+ */
+export function decodeNode(data: Uint8Array): BinaryNode {
+  decodeNodeToPacked(data);
+
+  const mem = new Uint8Array(wasmMemory.buffer);
+  const a = encResultAddr;
+  const ptr =
+    (mem[a] | (mem[a + 1] << 8) | (mem[a + 2] << 16) | (mem[a + 3] << 24)) >>>
+    0;
+
+  return unpackNode(mem, [ptr]);
+}