From 28db1a6f5a5c9c61363f02d31eaf43f86498d75d Mon Sep 17 00:00:00 2001
From: vinicius pereira <niviciusdev@gmail.com>
Date: Sun, 14 Dec 2025 23:28:43 -0300
Subject: [PATCH 01/33] feat: add binary_to_term/1 implementation and
 EtfDecoder class

- Implemented the binary_to_term/1 function in erlang.mjs to decode binary representations of Erlang terms.
- Added a new EtfDecoder class in etf_decoder.mjs to handle the decoding of the Erlang External Term Format (ETF).
- Created comprehensive tests for binary_to_term/1 in both JavaScript and Elixir to ensure correct decoding of various Erlang data types, including integers, atoms, binaries, tuples, lists, and maps.
- Included error handling for invalid inputs and edge cases in the tests.
---
 assets/js/erlang/erlang.mjs                   |  13 +
 assets/js/erlang/etf_decoder.mjs              | 321 ++++++++++++++++++
 .../ex_js_consistency/erlang/erlang_test.exs  | 147 ++++++++
 test/javascript/erlang/etf_decoder_test.mjs   | 283 +++++++++++++++
 4 files changed, 764 insertions(+)
 create mode 100644 assets/js/erlang/etf_decoder.mjs
 create mode 100644 test/javascript/erlang/etf_decoder_test.mjs

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 9d7ab01c49..05e88fec21 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -599,6 +599,19 @@ const Erlang = {
   // End binary_to_list/1
   // Deps: []
 
+  // Start binary_to_term/1
+  "binary_to_term/1": (binary) => {
+    if (!Type.isBinary(binary)) {
+      Interpreter.raiseArgumentError(
+        Interpreter.buildArgumentErrorMsg(1, "not a binary"),
+      );
+    }
+
+    return EtfDecoder.decode(binary);
+  },
+  // End binary_to_term/1
+  // Deps: []
+
   // Start bit_size/1
   "bit_size/1": (term) => {
     if (!Type.isBitstring(term)) {
diff --git a/assets/js/erlang/etf_decoder.mjs b/assets/js/erlang/etf_decoder.mjs
new file mode 100644
index 0000000000..0baa8b1655
--- /dev/null
+++ b/assets/js/erlang/etf_decoder.mjs
@@ -0,0 +1,321 @@
+"use strict";
+
+import Bitstring from "../bitstring.mjs";
+import Interpreter from "../interpreter.mjs";
+import Type from "../type.mjs";
+
+// Erlang External Term Format (ETF) Decoder
+// See: https://www.erlang.org/doc/apps/erts/erl_ext_dist.html
+
+export default class EtfDecoder {
+  // ETF tag constants
+  static #SMALL_INTEGER_EXT = 97;
+  static #INTEGER_EXT = 98;
+  static #ATOM_EXT = 100;
+  static #SMALL_TUPLE_EXT = 104;
+  static #LARGE_TUPLE_EXT = 105;
+  static #NIL_EXT = 106;
+  static #STRING_EXT = 107;
+  static #LIST_EXT = 108;
+  static #BINARY_EXT = 109;
+  static #SMALL_BIG_EXT = 110;
+  static #LARGE_BIG_EXT = 111;
+  static #SMALL_ATOM_EXT = 115;
+  static #MAP_EXT = 116;
+  static #ATOM_UTF8_EXT = 118;
+  static #SMALL_ATOM_UTF8_EXT = 119;
+
+  static decode(binary) {
+    Bitstring.maybeSetBytesFromText(binary);
+
+    const bytes = binary.bytes;
+    const dataView = new DataView(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength,
+    );
+
+    // Check ETF version byte (must be 131)
+    if (dataView.getUint8(0) !== 131) {
+      Interpreter.raiseArgumentError(
+        Interpreter.buildArgumentErrorMsg(
+          1,
+          "invalid external representation of a term",
+        ),
+      );
+    }
+
+    const result = $.#decodeTerm(dataView, bytes, 1);
+    return result.term;
+  }
+
+  static #decodeTerm(dataView, bytes, offset) {
+    if (offset >= bytes.length) {
+      Interpreter.raiseArgumentError(
+        Interpreter.buildArgumentErrorMsg(
+          1,
+          "invalid external representation of a term",
+        ),
+      );
+    }
+
+    const tag = dataView.getUint8(offset);
+
+    switch (tag) {
+      case $.#SMALL_INTEGER_EXT:
+        return $.#decodeSmallInteger(dataView, offset + 1);
+
+      case $.#INTEGER_EXT:
+        return $.#decodeInteger(dataView, offset + 1);
+
+      case $.#SMALL_BIG_EXT:
+        return $.#decodeSmallBig(dataView, bytes, offset + 1);
+
+      case $.#LARGE_BIG_EXT:
+        return $.#decodeLargeBig(dataView, bytes, offset + 1);
+
+      case $.#ATOM_EXT:
+        return $.#decodeAtom(dataView, bytes, offset + 1, false);
+
+      case $.#SMALL_ATOM_EXT:
+        return $.#decodeSmallAtom(dataView, bytes, offset + 1, false);
+
+      case $.#ATOM_UTF8_EXT:
+        return $.#decodeAtom(dataView, bytes, offset + 1, true);
+
+      case $.#SMALL_ATOM_UTF8_EXT:
+        return $.#decodeSmallAtom(dataView, bytes, offset + 1, true);
+
+      case $.#BINARY_EXT:
+        return $.#decodeBinary(dataView, bytes, offset + 1);
+
+      case $.#SMALL_TUPLE_EXT:
+        return $.#decodeSmallTuple(dataView, bytes, offset + 1);
+
+      case $.#LARGE_TUPLE_EXT:
+        return $.#decodeLargeTuple(dataView, bytes, offset + 1);
+
+      case $.#NIL_EXT:
+        return {term: Type.list(), newOffset: offset + 1};
+
+      case $.#STRING_EXT:
+        return $.#decodeString(dataView, bytes, offset + 1);
+
+      case $.#LIST_EXT:
+        return $.#decodeList(dataView, bytes, offset + 1);
+
+      case $.#MAP_EXT:
+        return $.#decodeMap(dataView, bytes, offset + 1);
+
+      default:
+        Interpreter.raiseArgumentError(
+          `unsupported external term format tag: ${tag}`,
+        );
+    }
+  }
+
+  // Integer decoders
+
+  static #decodeSmallInteger(dataView, offset) {
+    const value = dataView.getUint8(offset);
+    return {
+      term: Type.integer(value),
+      newOffset: offset + 1,
+    };
+  }
+
+  static #decodeInteger(dataView, offset) {
+    const value = dataView.getInt32(offset);
+    return {
+      term: Type.integer(value),
+      newOffset: offset + 4,
+    };
+  }
+
+  static #decodeSmallBig(dataView, bytes, offset) {
+    const n = dataView.getUint8(offset);
+    const sign = dataView.getUint8(offset + 1);
+
+    let value = 0n;
+    for (let i = 0; i < n; i++) {
+      const byte = BigInt(bytes[offset + 2 + i]);
+      value += byte << BigInt(i * 8);
+    }
+
+    if (sign === 1) {
+      value = -value;
+    }
+
+    return {
+      term: Type.integer(value),
+      newOffset: offset + 2 + n,
+    };
+  }
+
+  static #decodeLargeBig(dataView, bytes, offset) {
+    const n = dataView.getUint32(offset);
+    const sign = dataView.getUint8(offset + 4);
+
+    let value = 0n;
+    for (let i = 0; i < n; i++) {
+      const byte = BigInt(bytes[offset + 5 + i]);
+      value += byte << BigInt(i * 8);
+    }
+
+    if (sign === 1) {
+      value = -value;
+    }
+
+    return {
+      term: Type.integer(value),
+      newOffset: offset + 5 + n,
+    };
+  }
+
+  // Atom decoders
+
+  static #decodeAtom(dataView, bytes, offset, isUtf8) {
+    const length = dataView.getUint16(offset);
+    const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
+
+    const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
+    const atomString = decoder.decode(atomBytes);
+
+    return {
+      term: Type.atom(atomString),
+      newOffset: offset + 2 + length,
+    };
+  }
+
+  static #decodeSmallAtom(dataView, bytes, offset, isUtf8) {
+    const length = dataView.getUint8(offset);
+    const atomBytes = bytes.slice(offset + 1, offset + 1 + length);
+
+    const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
+    const atomString = decoder.decode(atomBytes);
+
+    return {
+      term: Type.atom(atomString),
+      newOffset: offset + 1 + length,
+    };
+  }
+
+  // Binary decoder
+
+  static #decodeBinary(dataView, bytes, offset) {
+    const length = dataView.getUint32(offset);
+    const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
+
+    return {
+      term: Bitstring.fromBytes(new Uint8Array(binaryBytes)),
+      newOffset: offset + 4 + length,
+    };
+  }
+
+  // Tuple decoders
+
+  static #decodeSmallTuple(dataView, bytes, offset) {
+    const arity = dataView.getUint8(offset);
+    const elements = [];
+    let currentOffset = offset + 1;
+
+    for (let i = 0; i < arity; i++) {
+      const result = $.#decodeTerm(dataView, bytes, currentOffset);
+      elements.push(result.term);
+      currentOffset = result.newOffset;
+    }
+
+    return {
+      term: Type.tuple(elements),
+      newOffset: currentOffset,
+    };
+  }
+
+  static #decodeLargeTuple(dataView, bytes, offset) {
+    const arity = dataView.getUint32(offset);
+    const elements = [];
+    let currentOffset = offset + 4;
+
+    for (let i = 0; i < arity; i++) {
+      const result = $.#decodeTerm(dataView, bytes, currentOffset);
+      elements.push(result.term);
+      currentOffset = result.newOffset;
+    }
+
+    return {
+      term: Type.tuple(elements),
+      newOffset: currentOffset,
+    };
+  }
+
+  // List decoders
+
+  static #decodeString(dataView, bytes, offset) {
+    const length = dataView.getUint16(offset);
+    const elements = [];
+
+    for (let i = 0; i < length; i++) {
+      const byte = bytes[offset + 2 + i];
+      elements.push(Type.integer(byte));
+    }
+
+    return {
+      term: Type.list(elements),
+      newOffset: offset + 2 + length,
+    };
+  }
+
+  static #decodeList(dataView, bytes, offset) {
+    const length = dataView.getUint32(offset);
+    const elements = [];
+    let currentOffset = offset + 4;
+
+    for (let i = 0; i < length; i++) {
+      const result = $.#decodeTerm(dataView, bytes, currentOffset);
+      elements.push(result.term);
+      currentOffset = result.newOffset;
+    }
+
+    // Decode the tail
+    const tailResult = $.#decodeTerm(dataView, bytes, currentOffset);
+    currentOffset = tailResult.newOffset;
+
+    // If tail is NIL (empty list), it's a proper list
+    if (Type.isList(tailResult.term) && tailResult.term.data.length === 0) {
+      return {
+        term: Type.list(elements),
+        newOffset: currentOffset,
+      };
+    }
+
+    // Otherwise, it's an improper list
+    elements.push(tailResult.term);
+    return {
+      term: Type.improperList(elements),
+      newOffset: currentOffset,
+    };
+  }
+
+  // Map decoder
+
+  static #decodeMap(dataView, bytes, offset) {
+    const arity = dataView.getUint32(offset);
+    const entries = [];
+    let currentOffset = offset + 4;
+
+    for (let i = 0; i < arity; i++) {
+      const keyResult = $.#decodeTerm(dataView, bytes, currentOffset);
+      const valueResult = $.#decodeTerm(dataView, bytes, keyResult.newOffset);
+
+      entries.push([keyResult.term, valueResult.term]);
+      currentOffset = valueResult.newOffset;
+    }
+
+    return {
+      term: Type.map(entries),
+      newOffset: currentOffset,
+    };
+  }
+}
+
+const $ = EtfDecoder;
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 41ecdfaab1..3c73abba8c 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1946,6 +1946,153 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     end
   end
 
+  describe "binary_to_term/1" do
+    test "decodes small positive integer (SMALL_INTEGER_EXT)" do
+      binary = :erlang.term_to_binary(42)
+      assert :erlang.binary_to_term(binary) == 42
+    end
+
+    test "decodes small positive integer (max value 255)" do
+      binary = :erlang.term_to_binary(255)
+      assert :erlang.binary_to_term(binary) == 255
+    end
+
+    test "decodes positive integer (INTEGER_EXT)" do
+      binary = :erlang.term_to_binary(1000)
+      assert :erlang.binary_to_term(binary) == 1000
+    end
+
+    test "decodes negative integer (INTEGER_EXT)" do
+      binary = :erlang.term_to_binary(-100)
+      assert :erlang.binary_to_term(binary) == -100
+    end
+
+    test "decodes large positive integer (SMALL_BIG_EXT)" do
+      binary = :erlang.term_to_binary(1_000_000_000_000)
+      assert :erlang.binary_to_term(binary) == 1_000_000_000_000
+    end
+
+    test "decodes large negative integer (SMALL_BIG_EXT)" do
+      binary = :erlang.term_to_binary(-1_000_000_000_000)
+      assert :erlang.binary_to_term(binary) == -1_000_000_000_000
+    end
+
+    test "decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)" do
+      binary = :erlang.term_to_binary(:test)
+      assert :erlang.binary_to_term(binary) == :test
+    end
+
+    test "decodes longer atom" do
+      binary = :erlang.term_to_binary(:test_atom)
+      assert :erlang.binary_to_term(binary) == :test_atom
+    end
+
+    test "decodes true atom" do
+      binary = :erlang.term_to_binary(true)
+      assert :erlang.binary_to_term(binary) == true
+    end
+
+    test "decodes false atom" do
+      binary = :erlang.term_to_binary(false)
+      assert :erlang.binary_to_term(binary) == false
+    end
+
+    test "decodes binary string (BINARY_EXT)" do
+      binary = :erlang.term_to_binary("hello")
+      assert :erlang.binary_to_term(binary) == "hello"
+    end
+
+    test "decodes empty binary" do
+      binary = :erlang.term_to_binary("")
+      assert :erlang.binary_to_term(binary) == ""
+    end
+
+    test "decodes small tuple (SMALL_TUPLE_EXT)" do
+      binary = :erlang.term_to_binary({1, 2, 3})
+      assert :erlang.binary_to_term(binary) == {1, 2, 3}
+    end
+
+    test "decodes empty tuple" do
+      binary = :erlang.term_to_binary({})
+      assert :erlang.binary_to_term(binary) == {}
+    end
+
+    test "decodes nested tuple" do
+      binary = :erlang.term_to_binary({1, {2, 3}})
+      assert :erlang.binary_to_term(binary) == {1, {2, 3}}
+    end
+
+    test "decodes empty list (NIL_EXT)" do
+      binary = :erlang.term_to_binary([])
+      assert :erlang.binary_to_term(binary) == []
+    end
+
+    test "decodes string list (STRING_EXT)" do
+      binary = :erlang.term_to_binary([1, 2, 3])
+      assert :erlang.binary_to_term(binary) == [1, 2, 3]
+    end
+
+    test "decodes proper list (LIST_EXT)" do
+      binary = :erlang.term_to_binary([100, 200, 300])
+      assert :erlang.binary_to_term(binary) == [100, 200, 300]
+    end
+
+    test "decodes empty map" do
+      binary = :erlang.term_to_binary(%{})
+      assert :erlang.binary_to_term(binary) == %{}
+    end
+
+    test "decodes map with atom keys" do
+      binary = :erlang.term_to_binary(%{a: 1, b: 2})
+      assert :erlang.binary_to_term(binary) == %{a: 1, b: 2}
+    end
+
+    test "decodes Code.fetch_docs/1 style tuple" do
+      term = {:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []}
+      binary = :erlang.term_to_binary(term)
+      assert :erlang.binary_to_term(binary) == term
+    end
+
+    test "decodes complex nested structure" do
+      term =
+        {:docs_v1, 1, :elixir, "text/markdown", %{"en" => "Module docs"}, %{since: "1.0.0"},
+         [{{:function, :my_func, 2}, 10, ["signature"], %{}, %{}}]}
+
+      binary = :erlang.term_to_binary(term)
+      assert :erlang.binary_to_term(binary) == term
+    end
+
+    test "raises ArgumentError if argument is not a binary" do
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "not a binary"),
+                   {:erlang, :binary_to_term, [:test]}
+    end
+
+    test "raises ArgumentError if argument is a non-binary bitstring" do
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "not a binary"),
+                   {:erlang, :binary_to_term, [<<1::1, 0::1, 1::1>>]}
+    end
+
+    test "raises ArgumentError if binary has invalid version byte" do
+      # Wrong version byte (130 instead of 131)
+      binary = <<130, 97, 42>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
+    test "raises ArgumentError if binary is truncated" do
+      # Only version byte, no data
+      binary = <<131>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+  end
+
   describe "bit_size/1" do
     test "bitstring" do
       assert :erlang.bit_size(<<2::7>>) == 7
diff --git a/test/javascript/erlang/etf_decoder_test.mjs b/test/javascript/erlang/etf_decoder_test.mjs
new file mode 100644
index 0000000000..df02f14c2a
--- /dev/null
+++ b/test/javascript/erlang/etf_decoder_test.mjs
@@ -0,0 +1,283 @@
+"use strict";
+
+import {
+  assert,
+  assertBoxedError,
+  assertBoxedStrictEqual,
+  defineGlobalErlangAndElixirModules,
+} from "../support/helpers.mjs";
+
+import Bitstring from "../../../assets/js/bitstring.mjs";
+import Erlang from "../../../assets/js/erlang/erlang.mjs";
+import Type from "../../../assets/js/type.mjs";
+
+defineGlobalErlangAndElixirModules();
+
+describe("binary_to_term/1", () => {
+  const testedFun = Erlang["binary_to_term/1"];
+
+  describe("integers", () => {
+    it("decodes small positive integer (SMALL_INTEGER_EXT)", () => {
+      // :erlang.term_to_binary(42) = <<131, 97, 42>>
+      const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 42]));
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(42));
+    });
+
+    it("decodes small positive integer (max value 255)", () => {
+      // :erlang.term_to_binary(255) = <<131, 97, 255>>
+      const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 255]));
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(255));
+    });
+
+    it("decodes positive integer (INTEGER_EXT)", () => {
+      // :erlang.term_to_binary(1000) = <<131, 98, 0, 0, 3, 232>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 98, 0, 0, 3, 232]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(1000));
+    });
+
+    it("decodes negative integer (INTEGER_EXT)", () => {
+      // :erlang.term_to_binary(-100) = <<131, 98, 255, 255, 255, 156>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 98, 255, 255, 255, 156]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(-100));
+    });
+
+    it("decodes large positive integer (SMALL_BIG_EXT)", () => {
+      // :erlang.term_to_binary(1000000000000) = <<131, 110, 5, 0, 0, 16, 165, 212, 232>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(1000000000000n));
+    });
+
+    it("decodes large negative integer (SMALL_BIG_EXT)", () => {
+      // :erlang.term_to_binary(-1000000000000) = <<131, 110, 5, 1, 0, 16, 165, 212, 232>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 110, 5, 1, 0, 16, 165, 212, 232]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.integer(-1000000000000n));
+    });
+  });
+
+  describe("atoms", () => {
+    it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", () => {
+      // :erlang.term_to_binary(:test) = <<131, 119, 4, 116, 101, 115, 116>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 119, 4, 116, 101, 115, 116]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.atom("test"));
+    });
+
+    it("decodes longer atom", () => {
+      // :erlang.term_to_binary(:test_atom) = <<131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([
+          131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109,
+        ]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.atom("test_atom"));
+    });
+
+    it("decodes boolean atoms", () => {
+      // :erlang.term_to_binary(true) = <<131, 119, 4, 116, 114, 117, 101>>
+      const trueBinary = Bitstring.fromBytes(
+        new Uint8Array([131, 119, 4, 116, 114, 117, 101]),
+      );
+      const trueResult = testedFun(trueBinary);
+      assert.deepStrictEqual(trueResult, Type.atom("true"));
+
+      // :erlang.term_to_binary(false) = <<131, 119, 5, 102, 97, 108, 115, 101>>
+      const falseBinary = Bitstring.fromBytes(
+        new Uint8Array([131, 119, 5, 102, 97, 108, 115, 101]),
+      );
+      const falseResult = testedFun(falseBinary);
+      assert.deepStrictEqual(falseResult, Type.atom("false"));
+    });
+  });
+
+  describe("binaries", () => {
+    it("decodes binary string (BINARY_EXT)", () => {
+      // :erlang.term_to_binary("hello") = <<131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111]),
+      );
+      const result = testedFun(binary);
+      assertBoxedStrictEqual(result, Type.bitstring("hello"));
+    });
+
+    it("decodes empty binary", () => {
+      // :erlang.term_to_binary("") = <<131, 109, 0, 0, 0, 0>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 109, 0, 0, 0, 0]),
+      );
+      const result = testedFun(binary);
+      assertBoxedStrictEqual(result, Type.bitstring(""));
+    });
+  });
+
+  describe("tuples", () => {
+    it("decodes small tuple (SMALL_TUPLE_EXT)", () => {
+      // :erlang.term_to_binary({1, 2, 3}) = <<131, 104, 3, 97, 1, 97, 2, 97, 3>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 104, 3, 97, 1, 97, 2, 97, 3]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(
+        result,
+        Type.tuple([Type.integer(1), Type.integer(2), Type.integer(3)]),
+      );
+    });
+
+    it("decodes empty tuple", () => {
+      // :erlang.term_to_binary({}) = <<131, 104, 0>>
+      const binary = Bitstring.fromBytes(new Uint8Array([131, 104, 0]));
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.tuple([]));
+    });
+
+    it("decodes nested tuple", () => {
+      // :erlang.term_to_binary({1, {2, 3}}) = <<131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(
+        result,
+        Type.tuple([
+          Type.integer(1),
+          Type.tuple([Type.integer(2), Type.integer(3)]),
+        ]),
+      );
+    });
+  });
+
+  describe("lists", () => {
+    it("decodes empty list (NIL_EXT)", () => {
+      // :erlang.term_to_binary([]) = <<131, 106>>
+      const binary = Bitstring.fromBytes(new Uint8Array([131, 106]));
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.list([]));
+    });
+
+    it("decodes string list (STRING_EXT)", () => {
+      // :erlang.term_to_binary([1, 2, 3]) = <<131, 107, 0, 3, 1, 2, 3>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 107, 0, 3, 1, 2, 3]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(
+        result,
+        Type.list([Type.integer(1), Type.integer(2), Type.integer(3)]),
+      );
+    });
+
+    it("decodes proper list (LIST_EXT)", () => {
+      // :erlang.term_to_binary([100, 200, 300]) = <<131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([
+          131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106,
+        ]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(
+        result,
+        Type.list([Type.integer(100), Type.integer(200), Type.integer(300)]),
+      );
+    });
+  });
+
+  describe("maps", () => {
+    it("decodes empty map", () => {
+      // :erlang.term_to_binary(%{}) = <<131, 116, 0, 0, 0, 0>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([131, 116, 0, 0, 0, 0]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(result, Type.map([]));
+    });
+
+    it("decodes map with atom keys", () => {
+      // :erlang.term_to_binary(%{a: 1, b: 2}) = <<131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2>>
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([
+          131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2,
+        ]),
+      );
+      const result = testedFun(binary);
+      assert.deepStrictEqual(
+        result,
+        Type.map([
+          [Type.atom("a"), Type.integer(1)],
+          [Type.atom("b"), Type.integer(2)],
+        ]),
+      );
+    });
+  });
+
+  describe("complex nested structures", () => {
+    it("decodes Code.fetch_docs/1 style tuple", () => {
+      // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})
+      const binary = Bitstring.fromBytes(
+        new Uint8Array([
+          131, 104, 7, 119, 7, 100, 111, 99, 115, 95, 118, 49, 97, 1, 119, 6,
+          101, 108, 105, 120, 105, 114, 109, 0, 0, 0, 13, 116, 101, 120, 116,
+          47, 109, 97, 114, 107, 100, 111, 119, 110, 116, 0, 0, 0, 0, 116, 0, 0,
+          0, 0, 106,
+        ]),
+      );
+      const result = testedFun(binary);
+
+      assertBoxedStrictEqual(
+        result,
+        Type.tuple([
+          Type.atom("docs_v1"),
+          Type.integer(1),
+          Type.atom("elixir"),
+          Type.bitstring("text/markdown"),
+          Type.map([]),
+          Type.map([]),
+          Type.list([]),
+        ]),
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("raises ArgumentError if argument is not a binary", () => {
+      assertBoxedError(
+        () => testedFun(Type.atom("test")),
+        "ArgumentError",
+        "errors were found at the given arguments:\n\n  * 1st argument: not a binary\n",
+      );
+    });
+
+    it("raises ArgumentError if binary has invalid version byte", () => {
+      const binary = Bitstring.fromBytes(new Uint8Array([130, 97, 42])); // Wrong version
+      assertBoxedError(
+        () => testedFun(binary),
+        "ArgumentError",
+        "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+      );
+    });
+
+    it("raises ArgumentError if binary is truncated", () => {
+      const binary = Bitstring.fromBytes(new Uint8Array([131])); // Only version byte
+      assertBoxedError(
+        () => testedFun(binary),
+        "ArgumentError",
+        "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+      );
+    });
+  });
+});

From d538490e838eea20f1e157e269b76f8179066fc5 Mon Sep 17 00:00:00 2001
From: vinicius pereira <niviciusdev@gmail.com>
Date: Mon, 15 Dec 2025 00:03:33 -0300
Subject: [PATCH 02/33] Enhance Erlang tests with describetags for binary
 functions

- Added @describetag :binary to the test cases for binary_to_list/1 and binary_to_term/1 in erlang_test.exs to improve test organization and clarity.
---
 test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 3c73abba8c..c6b3a1ca76 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1917,6 +1917,7 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
   end
 
   describe "binary_to_list/1" do
+    @describetag :binary
     test "converts a bytes-based binary to a list of integers" do
       assert :erlang.binary_to_list(<<1, 2, 3>>) == [1, 2, 3]
     end
@@ -1947,6 +1948,7 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
   end
 
   describe "binary_to_term/1" do
+    @describetag :binary
     test "decodes small positive integer (SMALL_INTEGER_EXT)" do
       binary = :erlang.term_to_binary(42)
       assert :erlang.binary_to_term(binary) == 42

From dd7846b2533ff3c658f8377d1be1a3611a1f6cb8 Mon Sep 17 00:00:00 2001
From: vinicius pereira <niviciusdev@gmail.com>
Date: Mon, 15 Dec 2025 00:22:28 -0300
Subject: [PATCH 03/33] chore: removed describe tag, out of scope of this pr

---
 test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index c6b3a1ca76..d8e171cc7d 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1917,7 +1917,6 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
   end
 
   describe "binary_to_list/1" do
-    @describetag :binary
     test "converts a bytes-based binary to a list of integers" do
       assert :erlang.binary_to_list(<<1, 2, 3>>) == [1, 2, 3]
     end

From 2e68feef4720c9ec8673dc55d18b6c3ed3885d00 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 16 Jan 2026 23:36:01 -0300
Subject: [PATCH 04/33] wip: migrating etf decoder logic to erlang.mjs [skip
 ci]

---
 assets/js/erlang/erlang.mjs      | 285 +++++++++++++++++++++++++++++++
 assets/js/erlang/etf_decoder.mjs |   1 +
 2 files changed, 286 insertions(+)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 05e88fec21..992037676a 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -607,6 +607,291 @@ const Erlang = {
       );
     }
 
+    // ETF tag constants
+    const SMALL_INTEGER_EXT = 97;
+    const INTEGER_EXT = 98;
+    const ATOM_EXT = 100;
+    const SMALL_TUPLE_EXT = 104;
+    const LARGE_TUPLE_EXT = 105;
+    const NIL_EXT = 106;
+    const STRING_EXT = 107;
+    const LIST_EXT = 108;
+    const BINARY_EXT = 109;
+    const SMALL_BIG_EXT = 110;
+    const LARGE_BIG_EXT = 111;
+    const SMALL_ATOM_EXT = 115;
+    const MAP_EXT = 116;
+    const ATOM_UTF8_EXT = 118;
+    const SMALL_ATOM_UTF8_EXT = 119;
+
+    const decodeTerm = (dataView, bytes, offset) => {
+      if (offset >= bytes.length) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
+      const tag = dataView.getUint8(offset);
+
+      switch (tag) {
+        case SMALL_INTEGER_EXT:
+          return decodeSmallInteger(dataView, offset + 1);
+
+        case INTEGER_EXT:
+          return decodeInteger(dataView, offset + 1);
+
+        case SMALL_BIG_EXT:
+          return decodeSmallBig(dataView, bytes, offset + 1);
+
+        case LARGE_BIG_EXT:
+          return decodeLargeBig(dataView, bytes, offset + 1);
+
+        case ATOM_EXT:
+          return decodeAtom(dataView, bytes, offset + 1, false);
+
+        case SMALL_ATOM_EXT:
+          return decodeSmallAtom(dataView, bytes, offset + 1, false);
+
+        case ATOM_UTF8_EXT:
+          return decodeAtom(dataView, bytes, offset + 1, true);
+
+        case SMALL_ATOM_UTF8_EXT:
+          return decodeSmallAtom(dataView, bytes, offset + 1, true);
+
+        case BINARY_EXT:
+          return decodeBinary(dataView, bytes, offset + 1);
+
+        case SMALL_TUPLE_EXT:
+          return decodeSmallTuple(dataView, bytes, offset + 1);
+
+        case LARGE_TUPLE_EXT:
+          return decodeLargeTuple(dataView, bytes, offset + 1);
+
+        case NIL_EXT:
+          return {term: Type.list(), newOffset: offset + 1};
+
+        case STRING_EXT:
+          return decodeString(dataView, bytes, offset + 1);
+
+        case LIST_EXT:
+          return decodeList(dataView, bytes, offset + 1);
+
+        case MAP_EXT:
+          return decodeMap(dataView, bytes, offset + 1);
+
+        default:
+          Interpreter.raiseArgumentError(
+            `unsupported external term format tag: ${tag}`,
+          );
+      }
+    };
+
+    // Integer decoders
+
+    const decodeSmallInteger = (dataView, offset) => {
+      const value = dataView.getUint8(offset);
+      return {
+        term: Type.integer(value),
+        newOffset: offset + 1,
+      };
+    };
+
+    const decodeInteger = (dataView, offset) => {
+      const value = dataView.getInt32(offset);
+      return {
+        term: Type.integer(value),
+        newOffset: offset + 4,
+      };
+    };
+
+    const decodeSmallBig = (dataView, bytes, offset) => {
+      const n = dataView.getUint8(offset);
+      const sign = dataView.getUint8(offset + 1);
+
+      let value = 0n;
+      for (let i = 0; i < n; i++) {
+        const byte = BigInt(bytes[offset + 2 + i]);
+        value += byte << BigInt(i * 8);
+      }
+
+      if (sign === 1) {
+        value = -value;
+      }
+
+      return {
+        term: Type.integer(value),
+        newOffset: offset + 2 + n,
+      };
+    };
+
+    const decodeLargeBig = (dataView, bytes, offset) => {
+      const n = dataView.getUint32(offset);
+      const sign = dataView.getUint8(offset + 4);
+
+      let value = 0n;
+      for (let i = 0; i < n; i++) {
+        const byte = BigInt(bytes[offset + 5 + i]);
+        value += byte << BigInt(i * 8);
+      }
+
+      if (sign === 1) {
+        value = -value;
+      }
+
+      return {
+        term: Type.integer(value),
+        newOffset: offset + 5 + n,
+      };
+    };
+
+    // Atom decoders
+
+    const decodeAtom = (dataView, bytes, offset, isUtf8) => {
+      const length = dataView.getUint16(offset);
+      const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
+
+      const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
+      const atomString = decoder.decode(atomBytes);
+
+      return {
+        term: Type.atom(atomString),
+        newOffset: offset + 2 + length,
+      };
+    };
+
+    const decodeSmallAtom = (dataView, bytes, offset, isUtf8) => {
+      const length = dataView.getUint8(offset);
+      const atomBytes = bytes.slice(offset + 1, offset + 1 + length);
+
+      const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
+      const atomString = decoder.decode(atomBytes);
+
+      return {
+        term: Type.atom(atomString),
+        newOffset: offset + 1 + length,
+      };
+    };
+
+    // Binary decoder
+
+    const decodeBinary = (dataView, bytes, offset) => {
+      const length = dataView.getUint32(offset);
+      const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
+
+      return {
+        term: Bitstring.fromBytes(new Uint8Array(binaryBytes)),
+        newOffset: offset + 4 + length,
+      };
+    };
+
+    // Tuple decoders
+
+    const decodeSmallTuple = (dataView, bytes, offset) => {
+      const arity = dataView.getUint8(offset);
+      const elements = [];
+      let currentOffset = offset + 1;
+
+      for (let i = 0; i < arity; i++) {
+        const result = decodeTerm(dataView, bytes, currentOffset);
+        elements.push(result.term);
+        currentOffset = result.newOffset;
+      }
+
+      return {
+        term: Type.tuple(elements),
+        newOffset: currentOffset,
+      };
+    };
+
+    const decodeLargeTuple = (dataView, bytes, offset) => {
+      const arity = dataView.getUint32(offset);
+      const elements = [];
+      let currentOffset = offset + 4;
+
+      for (let i = 0; i < arity; i++) {
+        const result = decodeTerm(dataView, bytes, currentOffset);
+        elements.push(result.term);
+        currentOffset = result.newOffset;
+      }
+
+      return {
+        term: Type.tuple(elements),
+        newOffset: currentOffset,
+      };
+    };
+
+    // List decoders
+
+    const decodeString = (dataView, bytes, offset) => {
+      const length = dataView.getUint16(offset);
+      const elements = [];
+
+      for (let i = 0; i < length; i++) {
+        const byte = bytes[offset + 2 + i];
+        elements.push(Type.integer(byte));
+      }
+
+      return {
+        term: Type.list(elements),
+        newOffset: offset + 2 + length,
+      };
+    };
+
+    const decodeList = (dataView, bytes, offset) => {
+      const length = dataView.getUint32(offset);
+      const elements = [];
+      let currentOffset = offset + 4;
+
+      for (let i = 0; i < length; i++) {
+        const result = decodeTerm(dataView, bytes, currentOffset);
+        elements.push(result.term);
+        currentOffset = result.newOffset;
+      }
+
+      // Decode the tail
+      const tailResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = tailResult.newOffset;
+
+      // If tail is NIL (empty list), it's a proper list
+      if (Type.isList(tailResult.term) && tailResult.term.data.length === 0) {
+        return {
+          term: Type.list(elements),
+          newOffset: currentOffset,
+        };
+      }
+
+      // Otherwise, it's an improper list
+      elements.push(tailResult.term);
+      return {
+        term: Type.improperList(elements),
+        newOffset: currentOffset,
+      };
+    };
+
+    // Map decoder
+
+    const decodeMap = (dataView, bytes, offset) => {
+      const arity = dataView.getUint32(offset);
+      const entries = [];
+      let currentOffset = offset + 4;
+
+      for (let i = 0; i < arity; i++) {
+        const keyResult = decodeTerm(dataView, bytes, currentOffset);
+        const valueResult = decodeTerm(dataView, bytes, keyResult.newOffset);
+
+        entries.push([keyResult.term, valueResult.term]);
+        currentOffset = valueResult.newOffset;
+      }
+
+      return {
+        term: Type.map(entries),
+        newOffset: currentOffset,
+      };
+    };
+
     return EtfDecoder.decode(binary);
   },
   // End binary_to_term/1
diff --git a/assets/js/erlang/etf_decoder.mjs b/assets/js/erlang/etf_decoder.mjs
index 0baa8b1655..2017ecdf7b 100644
--- a/assets/js/erlang/etf_decoder.mjs
+++ b/assets/js/erlang/etf_decoder.mjs
@@ -25,6 +25,7 @@ export default class EtfDecoder {
   static #ATOM_UTF8_EXT = 118;
   static #SMALL_ATOM_UTF8_EXT = 119;
 
+  // TODO: migrate main logic
   static decode(binary) {
     Bitstring.maybeSetBytesFromText(binary);
 

From 426a2bcd22c2eb7c5c60a951057919af414f7e20 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Sun, 18 Jan 2026 22:22:19 -0300
Subject: [PATCH 05/33] chore: added main logic

- removed old file
---
 assets/js/erlang/erlang.mjs      |  21 +-
 assets/js/erlang/etf_decoder.mjs | 322 -------------------------------
 2 files changed, 20 insertions(+), 323 deletions(-)
 delete mode 100644 assets/js/erlang/etf_decoder.mjs

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 992037676a..d57b94b54f 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -892,7 +892,26 @@ const Erlang = {
       };
     };
 
-    return EtfDecoder.decode(binary);
+    Bitstring.maybeSetBytesFromText(binary);
+
+    const bytes = binary.bytes;
+    const dataView = new DataView(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength,
+    );
+
+    // Check ETF version byte (must be 131)
+    if (dataView.getUint8(0) !== 131) {
+      Interpreter.raiseArgumentError(
+        Interpreter.buildArgumentErrorMsg(
+          1,
+          "invalid external representation of a term",
+        ),
+      );
+    }
+
+    return decodeTerm(dataView, bytes, 1);
   },
   // End binary_to_term/1
   // Deps: []
diff --git a/assets/js/erlang/etf_decoder.mjs b/assets/js/erlang/etf_decoder.mjs
deleted file mode 100644
index 2017ecdf7b..0000000000
--- a/assets/js/erlang/etf_decoder.mjs
+++ /dev/null
@@ -1,322 +0,0 @@
-"use strict";
-
-import Bitstring from "../bitstring.mjs";
-import Interpreter from "../interpreter.mjs";
-import Type from "../type.mjs";
-
-// Erlang External Term Format (ETF) Decoder
-// See: https://www.erlang.org/doc/apps/erts/erl_ext_dist.html
-
-export default class EtfDecoder {
-  // ETF tag constants
-  static #SMALL_INTEGER_EXT = 97;
-  static #INTEGER_EXT = 98;
-  static #ATOM_EXT = 100;
-  static #SMALL_TUPLE_EXT = 104;
-  static #LARGE_TUPLE_EXT = 105;
-  static #NIL_EXT = 106;
-  static #STRING_EXT = 107;
-  static #LIST_EXT = 108;
-  static #BINARY_EXT = 109;
-  static #SMALL_BIG_EXT = 110;
-  static #LARGE_BIG_EXT = 111;
-  static #SMALL_ATOM_EXT = 115;
-  static #MAP_EXT = 116;
-  static #ATOM_UTF8_EXT = 118;
-  static #SMALL_ATOM_UTF8_EXT = 119;
-
-  // TODO: migrate main logic
-  static decode(binary) {
-    Bitstring.maybeSetBytesFromText(binary);
-
-    const bytes = binary.bytes;
-    const dataView = new DataView(
-      bytes.buffer,
-      bytes.byteOffset,
-      bytes.byteLength,
-    );
-
-    // Check ETF version byte (must be 131)
-    if (dataView.getUint8(0) !== 131) {
-      Interpreter.raiseArgumentError(
-        Interpreter.buildArgumentErrorMsg(
-          1,
-          "invalid external representation of a term",
-        ),
-      );
-    }
-
-    const result = $.#decodeTerm(dataView, bytes, 1);
-    return result.term;
-  }
-
-  static #decodeTerm(dataView, bytes, offset) {
-    if (offset >= bytes.length) {
-      Interpreter.raiseArgumentError(
-        Interpreter.buildArgumentErrorMsg(
-          1,
-          "invalid external representation of a term",
-        ),
-      );
-    }
-
-    const tag = dataView.getUint8(offset);
-
-    switch (tag) {
-      case $.#SMALL_INTEGER_EXT:
-        return $.#decodeSmallInteger(dataView, offset + 1);
-
-      case $.#INTEGER_EXT:
-        return $.#decodeInteger(dataView, offset + 1);
-
-      case $.#SMALL_BIG_EXT:
-        return $.#decodeSmallBig(dataView, bytes, offset + 1);
-
-      case $.#LARGE_BIG_EXT:
-        return $.#decodeLargeBig(dataView, bytes, offset + 1);
-
-      case $.#ATOM_EXT:
-        return $.#decodeAtom(dataView, bytes, offset + 1, false);
-
-      case $.#SMALL_ATOM_EXT:
-        return $.#decodeSmallAtom(dataView, bytes, offset + 1, false);
-
-      case $.#ATOM_UTF8_EXT:
-        return $.#decodeAtom(dataView, bytes, offset + 1, true);
-
-      case $.#SMALL_ATOM_UTF8_EXT:
-        return $.#decodeSmallAtom(dataView, bytes, offset + 1, true);
-
-      case $.#BINARY_EXT:
-        return $.#decodeBinary(dataView, bytes, offset + 1);
-
-      case $.#SMALL_TUPLE_EXT:
-        return $.#decodeSmallTuple(dataView, bytes, offset + 1);
-
-      case $.#LARGE_TUPLE_EXT:
-        return $.#decodeLargeTuple(dataView, bytes, offset + 1);
-
-      case $.#NIL_EXT:
-        return {term: Type.list(), newOffset: offset + 1};
-
-      case $.#STRING_EXT:
-        return $.#decodeString(dataView, bytes, offset + 1);
-
-      case $.#LIST_EXT:
-        return $.#decodeList(dataView, bytes, offset + 1);
-
-      case $.#MAP_EXT:
-        return $.#decodeMap(dataView, bytes, offset + 1);
-
-      default:
-        Interpreter.raiseArgumentError(
-          `unsupported external term format tag: ${tag}`,
-        );
-    }
-  }
-
-  // Integer decoders
-
-  static #decodeSmallInteger(dataView, offset) {
-    const value = dataView.getUint8(offset);
-    return {
-      term: Type.integer(value),
-      newOffset: offset + 1,
-    };
-  }
-
-  static #decodeInteger(dataView, offset) {
-    const value = dataView.getInt32(offset);
-    return {
-      term: Type.integer(value),
-      newOffset: offset + 4,
-    };
-  }
-
-  static #decodeSmallBig(dataView, bytes, offset) {
-    const n = dataView.getUint8(offset);
-    const sign = dataView.getUint8(offset + 1);
-
-    let value = 0n;
-    for (let i = 0; i < n; i++) {
-      const byte = BigInt(bytes[offset + 2 + i]);
-      value += byte << BigInt(i * 8);
-    }
-
-    if (sign === 1) {
-      value = -value;
-    }
-
-    return {
-      term: Type.integer(value),
-      newOffset: offset + 2 + n,
-    };
-  }
-
-  static #decodeLargeBig(dataView, bytes, offset) {
-    const n = dataView.getUint32(offset);
-    const sign = dataView.getUint8(offset + 4);
-
-    let value = 0n;
-    for (let i = 0; i < n; i++) {
-      const byte = BigInt(bytes[offset + 5 + i]);
-      value += byte << BigInt(i * 8);
-    }
-
-    if (sign === 1) {
-      value = -value;
-    }
-
-    return {
-      term: Type.integer(value),
-      newOffset: offset + 5 + n,
-    };
-  }
-
-  // Atom decoders
-
-  static #decodeAtom(dataView, bytes, offset, isUtf8) {
-    const length = dataView.getUint16(offset);
-    const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
-
-    const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
-    const atomString = decoder.decode(atomBytes);
-
-    return {
-      term: Type.atom(atomString),
-      newOffset: offset + 2 + length,
-    };
-  }
-
-  static #decodeSmallAtom(dataView, bytes, offset, isUtf8) {
-    const length = dataView.getUint8(offset);
-    const atomBytes = bytes.slice(offset + 1, offset + 1 + length);
-
-    const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
-    const atomString = decoder.decode(atomBytes);
-
-    return {
-      term: Type.atom(atomString),
-      newOffset: offset + 1 + length,
-    };
-  }
-
-  // Binary decoder
-
-  static #decodeBinary(dataView, bytes, offset) {
-    const length = dataView.getUint32(offset);
-    const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
-
-    return {
-      term: Bitstring.fromBytes(new Uint8Array(binaryBytes)),
-      newOffset: offset + 4 + length,
-    };
-  }
-
-  // Tuple decoders
-
-  static #decodeSmallTuple(dataView, bytes, offset) {
-    const arity = dataView.getUint8(offset);
-    const elements = [];
-    let currentOffset = offset + 1;
-
-    for (let i = 0; i < arity; i++) {
-      const result = $.#decodeTerm(dataView, bytes, currentOffset);
-      elements.push(result.term);
-      currentOffset = result.newOffset;
-    }
-
-    return {
-      term: Type.tuple(elements),
-      newOffset: currentOffset,
-    };
-  }
-
-  static #decodeLargeTuple(dataView, bytes, offset) {
-    const arity = dataView.getUint32(offset);
-    const elements = [];
-    let currentOffset = offset + 4;
-
-    for (let i = 0; i < arity; i++) {
-      const result = $.#decodeTerm(dataView, bytes, currentOffset);
-      elements.push(result.term);
-      currentOffset = result.newOffset;
-    }
-
-    return {
-      term: Type.tuple(elements),
-      newOffset: currentOffset,
-    };
-  }
-
-  // List decoders
-
-  static #decodeString(dataView, bytes, offset) {
-    const length = dataView.getUint16(offset);
-    const elements = [];
-
-    for (let i = 0; i < length; i++) {
-      const byte = bytes[offset + 2 + i];
-      elements.push(Type.integer(byte));
-    }
-
-    return {
-      term: Type.list(elements),
-      newOffset: offset + 2 + length,
-    };
-  }
-
-  static #decodeList(dataView, bytes, offset) {
-    const length = dataView.getUint32(offset);
-    const elements = [];
-    let currentOffset = offset + 4;
-
-    for (let i = 0; i < length; i++) {
-      const result = $.#decodeTerm(dataView, bytes, currentOffset);
-      elements.push(result.term);
-      currentOffset = result.newOffset;
-    }
-
-    // Decode the tail
-    const tailResult = $.#decodeTerm(dataView, bytes, currentOffset);
-    currentOffset = tailResult.newOffset;
-
-    // If tail is NIL (empty list), it's a proper list
-    if (Type.isList(tailResult.term) && tailResult.term.data.length === 0) {
-      return {
-        term: Type.list(elements),
-        newOffset: currentOffset,
-      };
-    }
-
-    // Otherwise, it's an improper list
-    elements.push(tailResult.term);
-    return {
-      term: Type.improperList(elements),
-      newOffset: currentOffset,
-    };
-  }
-
-  // Map decoder
-
-  static #decodeMap(dataView, bytes, offset) {
-    const arity = dataView.getUint32(offset);
-    const entries = [];
-    let currentOffset = offset + 4;
-
-    for (let i = 0; i < arity; i++) {
-      const keyResult = $.#decodeTerm(dataView, bytes, currentOffset);
-      const valueResult = $.#decodeTerm(dataView, bytes, keyResult.newOffset);
-
-      entries.push([keyResult.term, valueResult.term]);
-      currentOffset = valueResult.newOffset;
-    }
-
-    return {
-      term: Type.map(entries),
-      newOffset: currentOffset,
-    };
-  }
-}
-
-const $ = EtfDecoder;

From cdc6fff5c3ffb65b3437c99ffb43b7af2dafae67 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Sun, 18 Jan 2026 23:26:30 -0300
Subject: [PATCH 06/33] fix: adjust mix aliases

- remove unused import from erlan.mjs
- adjust type hint in test function and renderer_dom
- 'mix f' formatted renderer_test.exs
---
 assets/js/erlang/erlang.mjs                          |  3 +++
 lib/hologram/template/renderer.ex                    |  8 ++++----
 test/elixir/hologram/template/renderer_test.exs      | 12 ++++++------
 .../fixtures/compiler/transformer/module_109.ex      |  2 +-
 4 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index d57b94b54f..e4bfd7ae60 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -1,7 +1,10 @@
 "use strict";
 
 import Bitstring from "../bitstring.mjs";
+<<<<<<< HEAD
 import ERTS from "../erts.mjs";
+=======
+>>>>>>> 992abcfdf (fix: adjust mix aliases)
 import HologramBoxedError from "../errors/boxed_error.mjs";
 import HologramInterpreterError from "../errors/interpreter_error.mjs";
 import Interpreter from "../interpreter.mjs";
diff --git a/lib/hologram/template/renderer.ex b/lib/hologram/template/renderer.ex
index 8a76e2739d..cd040e4ae9 100644
--- a/lib/hologram/template/renderer.ex
+++ b/lib/hologram/template/renderer.ex
@@ -64,11 +64,11 @@ defmodule Hologram.Template.Renderer do
     {"<!DOCTYPE #{content}>", %{}, server_struct}
   end
 
-  def render_dom({:element, "slot", _attrs_dom, []}, env, server_struct) do
+  def render_dom({:element, "slot", _attrs_dom, []}, %Env{} = env, server_struct) do
     render_dom(env.slots[:default], %Env{env | slots: []}, server_struct)
   end
 
-  def render_dom({:element, tag_name, attrs_dom, children_dom}, env, server_struct) do
+  def render_dom({:element, tag_name, attrs_dom, children_dom}, %Env{} = env, server_struct) do
     attrs_html = render_attributes(attrs_dom)
 
     children_env = %Env{env | node_type: :element, tag_name: tag_name}
@@ -90,7 +90,7 @@ defmodule Hologram.Template.Renderer do
     {stringify_for_interpolation(value), %{}, server_struct}
   end
 
-  def render_dom({:public_comment, children_dom}, env, server_struct) do
+  def render_dom({:public_comment, children_dom}, %Env{} = env, server_struct) do
     children_env = %Env{env | node_type: :public_comment}
 
     {children_html, component_registry, mutated_server_struct} =
@@ -192,7 +192,7 @@ defmodule Hologram.Template.Renderer do
 
       iex> stringify_for_interpolation("hello")
       "hello"
-      
+
       iex> stringify_for_interpolation("<script>")
       "&lt;script&gt;"
   """
diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 14f61e9c45..1f1903371d 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module25, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module27, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module24, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do
diff --git a/test/elixir/support/fixtures/compiler/transformer/module_109.ex b/test/elixir/support/fixtures/compiler/transformer/module_109.ex
index 4c4970eff4..192af48982 100644
--- a/test/elixir/support/fixtures/compiler/transformer/module_109.ex
+++ b/test/elixir/support/fixtures/compiler/transformer/module_109.ex
@@ -4,7 +4,7 @@ defmodule Hologram.Test.Fixtures.Compiler.Tranformer.Module109 do
 
   defstruct [:a, :b]
 
-  def test(x) do
+  def test(%Module109{} = x) do
     %Module109{x | a: 1, b: 2}
   end
 end

From 9f020a4173191bb0ca7553d880cc4d438eb12e90 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Sun, 18 Jan 2026 23:55:48 -0300
Subject: [PATCH 07/33] chore: moved etf decoder mjs tests to erlang_test.exs

- removed describe tag from erlang_test.exs as recommended
---
 assets/js/erlang/erlang.mjs                   |  64 ++--
 mix.exs                                       |   4 +-
 .../ex_js_consistency/erlang/erlang_test.exs  |   1 -
 test/javascript/erlang/erlang_test.mjs        | 271 +++++++++++++++++
 test/javascript/erlang/etf_decoder_test.mjs   | 283 ------------------
 5 files changed, 310 insertions(+), 313 deletions(-)
 delete mode 100644 test/javascript/erlang/etf_decoder_test.mjs

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index e4bfd7ae60..a18b1b96c8 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -1,10 +1,7 @@
 "use strict";
 
 import Bitstring from "../bitstring.mjs";
-<<<<<<< HEAD
 import ERTS from "../erts.mjs";
-=======
->>>>>>> 992abcfdf (fix: adjust mix aliases)
 import HologramBoxedError from "../errors/boxed_error.mjs";
 import HologramInterpreterError from "../errors/interpreter_error.mjs";
 import Interpreter from "../interpreter.mjs";
@@ -858,12 +855,13 @@ const Erlang = {
       const tailResult = decodeTerm(dataView, bytes, currentOffset);
       currentOffset = tailResult.newOffset;
 
-      // If tail is NIL (empty list), it's a proper list
-      if (Type.isList(tailResult.term) && tailResult.term.data.length === 0) {
-        return {
-          term: Type.list(elements),
-          newOffset: currentOffset,
-        };
+      // If tail is a list, merge it to preserve proper list semantics
+      if (Type.isList(tailResult.term)) {
+        const merged = elements.concat(tailResult.term.data);
+
+        return Type.isProperList(tailResult.term)
+          ? {term: Type.list(merged), newOffset: currentOffset}
+          : {term: Type.improperList(merged), newOffset: currentOffset};
       }
 
       // Otherwise, it's an improper list
@@ -873,7 +871,6 @@ const Erlang = {
         newOffset: currentOffset,
       };
     };
-
     // Map decoder
 
     const decodeMap = (dataView, bytes, offset) => {
@@ -895,26 +892,39 @@ const Erlang = {
       };
     };
 
-    Bitstring.maybeSetBytesFromText(binary);
+    try {
+      Bitstring.maybeSetBytesFromText(binary);
 
-    const bytes = binary.bytes;
-    const dataView = new DataView(
-      bytes.buffer,
-      bytes.byteOffset,
-      bytes.byteLength,
-    );
-
-    // Check ETF version byte (must be 131)
-    if (dataView.getUint8(0) !== 131) {
-      Interpreter.raiseArgumentError(
-        Interpreter.buildArgumentErrorMsg(
-          1,
-          "invalid external representation of a term",
-        ),
+      const bytes = binary.bytes;
+      const dataView = new DataView(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
       );
-    }
 
-    return decodeTerm(dataView, bytes, 1);
+      // Check ETF version byte (must be 131)
+      if (dataView.getUint8(0) !== 131) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
+      const result = decodeTerm(dataView, bytes, 1);
+      return result.term;
+    } catch (err) {
+      if (err instanceof RangeError || err instanceof TypeError) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+      throw err;
+    }
   },
   // End binary_to_term/1
   // Deps: []
diff --git a/mix.exs b/mix.exs
index 0e2bb66a5c..39270a6fcc 100644
--- a/mix.exs
+++ b/mix.exs
@@ -11,9 +11,9 @@ defmodule Hologram.MixProject do
     [
       eslint:
         "cmd assets/node_modules/.bin/eslint --color --config assets/eslint.config.mjs assets/js/** benchmarks/javascript/** scripts/** test/javascript/** --no-error-on-unmatched-pattern",
-      f: ["format", "format.js", "cmd cd test/features && mix format"],
+      f: ["format", "format.js", "cmd --cd test/features mix format"],
       "format.js":
-        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
+        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' ''scripts/**/*.{mjs,js,json}'' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
       "format.js.check":
         "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**' 'test/javascript/**' --check --config 'assets/.prettierrc.json' --no-error-on-unmatched-pattern",
       setup: [
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index d8e171cc7d..3c73abba8c 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1947,7 +1947,6 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
   end
 
   describe "binary_to_term/1" do
-    @describetag :binary
     test "decodes small positive integer (SMALL_INTEGER_EXT)" do
       binary = :erlang.term_to_binary(42)
       assert :erlang.binary_to_term(binary) == 42
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 50eed6368b..76b48a5f11 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -18,6 +18,7 @@ import ERTS from "../../../assets/js/erts.mjs";
 import HologramInterpreterError from "../../../assets/js/errors/interpreter_error.mjs";
 import Interpreter from "../../../assets/js/interpreter.mjs";
 import Type from "../../../assets/js/type.mjs";
+import {describe} from "node:test";
 
 defineGlobalErlangAndElixirModules();
 defineErlangModule1Fixture();
@@ -2753,6 +2754,276 @@ describe("Erlang", () => {
     });
   });
 
+  describe("binary_to_term/1", () => {
+    const binary_to_term = Erlang["binary_to_term/1"];
+
+    describe("integers", () => {
+      it("decodes small positive integer (SMALL_INTEGER_EXT)", () => {
+        // :erlang.term_to_binary(42) = <<131, 97, 42>>
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 42]));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(42));
+      });
+
+      it("decodes small positive integer (max value 255)", () => {
+        // :erlang.term_to_binary(255) = <<131, 97, 255>>
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 255]));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(255));
+      });
+
+      it("decodes positive integer (INTEGER_EXT)", () => {
+        // :erlang.term_to_binary(1000) = <<131, 98, 0, 0, 3, 232>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 98, 0, 0, 3, 232]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(1000));
+      });
+
+      it("decodes negative integer (INTEGER_EXT)", () => {
+        // :erlang.term_to_binary(-100) = <<131, 98, 255, 255, 255, 156>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 98, 255, 255, 255, 156]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(-100));
+      });
+
+      it("decodes large positive integer (SMALL_BIG_EXT)", () => {
+        // :erlang.term_to_binary(1000000000000) = <<131, 110, 5, 0, 0, 16, 165, 212, 232>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(1000000000000n));
+      });
+
+      it("decodes large negative integer (SMALL_BIG_EXT)", () => {
+        // :erlang.term_to_binary(-1000000000000) = <<131, 110, 5, 1, 0, 16, 165, 212, 232>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 110, 5, 1, 0, 16, 165, 212, 232]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(-1000000000000n));
+      });
+    });
+
+    describe("atoms", () => {
+      it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", () => {
+        // :erlang.term_to_binary(:test) = <<131, 119, 4, 116, 101, 115, 116>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 119, 4, 116, 101, 115, 116]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom("test"));
+      });
+
+      it("decodes longer atom", () => {
+        // :erlang.term_to_binary(:test_atom) = <<131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom("test_atom"));
+      });
+
+      it("decodes boolean atoms", () => {
+        // :erlang.term_to_binary(true) = <<131, 119, 4, 116, 114, 117, 101>>
+        const trueBinary = Bitstring.fromBytes(
+          new Uint8Array([131, 119, 4, 116, 114, 117, 101]),
+        );
+        const trueResult = binary_to_term(trueBinary);
+        assert.deepStrictEqual(trueResult, Type.atom("true"));
+
+        // :erlang.term_to_binary(false) = <<131, 119, 5, 102, 97, 108, 115, 101>>
+        const falseBinary = Bitstring.fromBytes(
+          new Uint8Array([131, 119, 5, 102, 97, 108, 115, 101]),
+        );
+        const falseResult = binary_to_term(falseBinary);
+        assert.deepStrictEqual(falseResult, Type.atom("false"));
+      });
+    });
+
+    describe("binaries", () => {
+      it("decodes binary string (BINARY_EXT)", () => {
+        // :erlang.term_to_binary("hello") = <<131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111]),
+        );
+        const result = binary_to_term(binary);
+        assertBoxedStrictEqual(result, Type.bitstring("hello"));
+      });
+
+      it("decodes empty binary", () => {
+        // :erlang.term_to_binary("") = <<131, 109, 0, 0, 0, 0>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 109, 0, 0, 0, 0]),
+        );
+        const result = binary_to_term(binary);
+        assertBoxedStrictEqual(result, Type.bitstring(""));
+      });
+    });
+
+    describe("tuples", () => {
+      it("decodes small tuple (SMALL_TUPLE_EXT)", () => {
+        // :erlang.term_to_binary({1, 2, 3}) = <<131, 104, 3, 97, 1, 97, 2, 97, 3>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 104, 3, 97, 1, 97, 2, 97, 3]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.tuple([Type.integer(1), Type.integer(2), Type.integer(3)]),
+        );
+      });
+
+      it("decodes empty tuple", () => {
+        // :erlang.term_to_binary({}) = <<131, 104, 0>>
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 104, 0]));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.tuple([]));
+      });
+
+      it("decodes nested tuple", () => {
+        // :erlang.term_to_binary({1, {2, 3}}) = <<131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.tuple([
+            Type.integer(1),
+            Type.tuple([Type.integer(2), Type.integer(3)]),
+          ]),
+        );
+      });
+    });
+
+    describe("lists", () => {
+      it("decodes empty list (NIL_EXT)", () => {
+        // :erlang.term_to_binary([]) = <<131, 106>>
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 106]));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.list([]));
+      });
+
+      it("decodes string list (STRING_EXT)", () => {
+        // :erlang.term_to_binary([1, 2, 3]) = <<131, 107, 0, 3, 1, 2, 3>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 107, 0, 3, 1, 2, 3]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.list([Type.integer(1), Type.integer(2), Type.integer(3)]),
+        );
+      });
+
+      it("decodes proper list (LIST_EXT)", () => {
+        // :erlang.term_to_binary([100, 200, 300]) = <<131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44,
+            106,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.list([Type.integer(100), Type.integer(200), Type.integer(300)]),
+        );
+      });
+    });
+
+    describe("maps", () => {
+      it("decodes empty map", () => {
+        // :erlang.term_to_binary(%{}) = <<131, 116, 0, 0, 0, 0>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 116, 0, 0, 0, 0]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.map([]));
+      });
+
+      it("decodes map with atom keys", () => {
+        // :erlang.term_to_binary(%{a: 1, b: 2}) = <<131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.map([
+            [Type.atom("a"), Type.integer(1)],
+            [Type.atom("b"), Type.integer(2)],
+          ]),
+        );
+      });
+    });
+
+    describe("complex nested structures", () => {
+      it("decodes Code.fetch_docs/1 style tuple", () => {
+        // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 104, 7, 119, 7, 100, 111, 99, 115, 95, 118, 49, 97, 1, 119, 6,
+            101, 108, 105, 120, 105, 114, 109, 0, 0, 0, 13, 116, 101, 120, 116,
+            47, 109, 97, 114, 107, 100, 111, 119, 110, 116, 0, 0, 0, 0, 116, 0,
+            0, 0, 0, 106,
+          ]),
+        );
+        const result = binary_to_term(binary);
+
+        assertBoxedStrictEqual(
+          result,
+          Type.tuple([
+            Type.atom("docs_v1"),
+            Type.integer(1),
+            Type.atom("elixir"),
+            Type.bitstring("text/markdown"),
+            Type.map([]),
+            Type.map([]),
+            Type.list([]),
+          ]),
+        );
+      });
+    });
+
+    describe("error handling", () => {
+      it("raises ArgumentError if argument is not a binary", () => {
+        assertBoxedError(
+          () => binary_to_term(Type.atom("test")),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: not a binary\n",
+        );
+      });
+
+      it("raises ArgumentError if binary has invalid version byte", () => {
+        const binary = Bitstring.fromBytes(new Uint8Array([130, 97, 42])); // Wrong version
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError if binary is truncated", () => {
+        const binary = Bitstring.fromBytes(new Uint8Array([131])); // Only version byte
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+    });
+  });
+
   describe("bit_size/1", () => {
     const bit_size = Erlang["bit_size/1"];
 
diff --git a/test/javascript/erlang/etf_decoder_test.mjs b/test/javascript/erlang/etf_decoder_test.mjs
deleted file mode 100644
index df02f14c2a..0000000000
--- a/test/javascript/erlang/etf_decoder_test.mjs
+++ /dev/null
@@ -1,283 +0,0 @@
-"use strict";
-
-import {
-  assert,
-  assertBoxedError,
-  assertBoxedStrictEqual,
-  defineGlobalErlangAndElixirModules,
-} from "../support/helpers.mjs";
-
-import Bitstring from "../../../assets/js/bitstring.mjs";
-import Erlang from "../../../assets/js/erlang/erlang.mjs";
-import Type from "../../../assets/js/type.mjs";
-
-defineGlobalErlangAndElixirModules();
-
-describe("binary_to_term/1", () => {
-  const testedFun = Erlang["binary_to_term/1"];
-
-  describe("integers", () => {
-    it("decodes small positive integer (SMALL_INTEGER_EXT)", () => {
-      // :erlang.term_to_binary(42) = <<131, 97, 42>>
-      const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 42]));
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(42));
-    });
-
-    it("decodes small positive integer (max value 255)", () => {
-      // :erlang.term_to_binary(255) = <<131, 97, 255>>
-      const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 255]));
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(255));
-    });
-
-    it("decodes positive integer (INTEGER_EXT)", () => {
-      // :erlang.term_to_binary(1000) = <<131, 98, 0, 0, 3, 232>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 98, 0, 0, 3, 232]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(1000));
-    });
-
-    it("decodes negative integer (INTEGER_EXT)", () => {
-      // :erlang.term_to_binary(-100) = <<131, 98, 255, 255, 255, 156>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 98, 255, 255, 255, 156]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(-100));
-    });
-
-    it("decodes large positive integer (SMALL_BIG_EXT)", () => {
-      // :erlang.term_to_binary(1000000000000) = <<131, 110, 5, 0, 0, 16, 165, 212, 232>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(1000000000000n));
-    });
-
-    it("decodes large negative integer (SMALL_BIG_EXT)", () => {
-      // :erlang.term_to_binary(-1000000000000) = <<131, 110, 5, 1, 0, 16, 165, 212, 232>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 110, 5, 1, 0, 16, 165, 212, 232]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.integer(-1000000000000n));
-    });
-  });
-
-  describe("atoms", () => {
-    it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", () => {
-      // :erlang.term_to_binary(:test) = <<131, 119, 4, 116, 101, 115, 116>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 119, 4, 116, 101, 115, 116]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.atom("test"));
-    });
-
-    it("decodes longer atom", () => {
-      // :erlang.term_to_binary(:test_atom) = <<131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([
-          131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109,
-        ]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.atom("test_atom"));
-    });
-
-    it("decodes boolean atoms", () => {
-      // :erlang.term_to_binary(true) = <<131, 119, 4, 116, 114, 117, 101>>
-      const trueBinary = Bitstring.fromBytes(
-        new Uint8Array([131, 119, 4, 116, 114, 117, 101]),
-      );
-      const trueResult = testedFun(trueBinary);
-      assert.deepStrictEqual(trueResult, Type.atom("true"));
-
-      // :erlang.term_to_binary(false) = <<131, 119, 5, 102, 97, 108, 115, 101>>
-      const falseBinary = Bitstring.fromBytes(
-        new Uint8Array([131, 119, 5, 102, 97, 108, 115, 101]),
-      );
-      const falseResult = testedFun(falseBinary);
-      assert.deepStrictEqual(falseResult, Type.atom("false"));
-    });
-  });
-
-  describe("binaries", () => {
-    it("decodes binary string (BINARY_EXT)", () => {
-      // :erlang.term_to_binary("hello") = <<131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111]),
-      );
-      const result = testedFun(binary);
-      assertBoxedStrictEqual(result, Type.bitstring("hello"));
-    });
-
-    it("decodes empty binary", () => {
-      // :erlang.term_to_binary("") = <<131, 109, 0, 0, 0, 0>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 109, 0, 0, 0, 0]),
-      );
-      const result = testedFun(binary);
-      assertBoxedStrictEqual(result, Type.bitstring(""));
-    });
-  });
-
-  describe("tuples", () => {
-    it("decodes small tuple (SMALL_TUPLE_EXT)", () => {
-      // :erlang.term_to_binary({1, 2, 3}) = <<131, 104, 3, 97, 1, 97, 2, 97, 3>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 104, 3, 97, 1, 97, 2, 97, 3]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(
-        result,
-        Type.tuple([Type.integer(1), Type.integer(2), Type.integer(3)]),
-      );
-    });
-
-    it("decodes empty tuple", () => {
-      // :erlang.term_to_binary({}) = <<131, 104, 0>>
-      const binary = Bitstring.fromBytes(new Uint8Array([131, 104, 0]));
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.tuple([]));
-    });
-
-    it("decodes nested tuple", () => {
-      // :erlang.term_to_binary({1, {2, 3}}) = <<131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(
-        result,
-        Type.tuple([
-          Type.integer(1),
-          Type.tuple([Type.integer(2), Type.integer(3)]),
-        ]),
-      );
-    });
-  });
-
-  describe("lists", () => {
-    it("decodes empty list (NIL_EXT)", () => {
-      // :erlang.term_to_binary([]) = <<131, 106>>
-      const binary = Bitstring.fromBytes(new Uint8Array([131, 106]));
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.list([]));
-    });
-
-    it("decodes string list (STRING_EXT)", () => {
-      // :erlang.term_to_binary([1, 2, 3]) = <<131, 107, 0, 3, 1, 2, 3>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 107, 0, 3, 1, 2, 3]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(
-        result,
-        Type.list([Type.integer(1), Type.integer(2), Type.integer(3)]),
-      );
-    });
-
-    it("decodes proper list (LIST_EXT)", () => {
-      // :erlang.term_to_binary([100, 200, 300]) = <<131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([
-          131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106,
-        ]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(
-        result,
-        Type.list([Type.integer(100), Type.integer(200), Type.integer(300)]),
-      );
-    });
-  });
-
-  describe("maps", () => {
-    it("decodes empty map", () => {
-      // :erlang.term_to_binary(%{}) = <<131, 116, 0, 0, 0, 0>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([131, 116, 0, 0, 0, 0]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(result, Type.map([]));
-    });
-
-    it("decodes map with atom keys", () => {
-      // :erlang.term_to_binary(%{a: 1, b: 2}) = <<131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2>>
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([
-          131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2,
-        ]),
-      );
-      const result = testedFun(binary);
-      assert.deepStrictEqual(
-        result,
-        Type.map([
-          [Type.atom("a"), Type.integer(1)],
-          [Type.atom("b"), Type.integer(2)],
-        ]),
-      );
-    });
-  });
-
-  describe("complex nested structures", () => {
-    it("decodes Code.fetch_docs/1 style tuple", () => {
-      // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})
-      const binary = Bitstring.fromBytes(
-        new Uint8Array([
-          131, 104, 7, 119, 7, 100, 111, 99, 115, 95, 118, 49, 97, 1, 119, 6,
-          101, 108, 105, 120, 105, 114, 109, 0, 0, 0, 13, 116, 101, 120, 116,
-          47, 109, 97, 114, 107, 100, 111, 119, 110, 116, 0, 0, 0, 0, 116, 0, 0,
-          0, 0, 106,
-        ]),
-      );
-      const result = testedFun(binary);
-
-      assertBoxedStrictEqual(
-        result,
-        Type.tuple([
-          Type.atom("docs_v1"),
-          Type.integer(1),
-          Type.atom("elixir"),
-          Type.bitstring("text/markdown"),
-          Type.map([]),
-          Type.map([]),
-          Type.list([]),
-        ]),
-      );
-    });
-  });
-
-  describe("error handling", () => {
-    it("raises ArgumentError if argument is not a binary", () => {
-      assertBoxedError(
-        () => testedFun(Type.atom("test")),
-        "ArgumentError",
-        "errors were found at the given arguments:\n\n  * 1st argument: not a binary\n",
-      );
-    });
-
-    it("raises ArgumentError if binary has invalid version byte", () => {
-      const binary = Bitstring.fromBytes(new Uint8Array([130, 97, 42])); // Wrong version
-      assertBoxedError(
-        () => testedFun(binary),
-        "ArgumentError",
-        "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
-      );
-    });
-
-    it("raises ArgumentError if binary is truncated", () => {
-      const binary = Bitstring.fromBytes(new Uint8Array([131])); // Only version byte
-      assertBoxedError(
-        () => testedFun(binary),
-        "ArgumentError",
-        "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
-      );
-    });
-  });
-});

From 0008ef7bde168879a7714a14aa95676d715d808f Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Mon, 19 Jan 2026 10:51:37 -0300
Subject: [PATCH 08/33] chore: add limit check for decode atom, small atom,
 binary and string.

- fix typo in mix.exs js format.
---
 assets/js/erlang/erlang.mjs | 20 ++++++++++++++++++++
 mix.exs                     |  2 +-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index a18b1b96c8..eba6621633 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -751,6 +751,11 @@ const Erlang = {
 
     const decodeAtom = (dataView, bytes, offset, isUtf8) => {
       const length = dataView.getUint16(offset);
+      if (offset + 2 + length > bytes.length) {
+        Interpreter.raiseArgumentError(
+          `atom length exceeds available bytes: ${length}`,
+        );
+      }
       const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
 
       const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
@@ -764,6 +769,11 @@ const Erlang = {
 
     const decodeSmallAtom = (dataView, bytes, offset, isUtf8) => {
       const length = dataView.getUint8(offset);
+      if (offset + 2 + length > bytes.length) {
+        Interpreter.raiseArgumentError(
+          `atom length exceeds available bytes: ${length}`,
+        );
+      }
       const atomBytes = bytes.slice(offset + 1, offset + 1 + length);
 
       const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
@@ -779,6 +789,11 @@ const Erlang = {
 
     const decodeBinary = (dataView, bytes, offset) => {
       const length = dataView.getUint32(offset);
+      if (offset + 2 + length > bytes.length) {
+        Interpreter.raiseArgumentError(
+          `atom length exceeds available bytes: ${length}`,
+        );
+      }
       const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
 
       return {
@@ -827,6 +842,11 @@ const Erlang = {
 
     const decodeString = (dataView, bytes, offset) => {
       const length = dataView.getUint16(offset);
+      if (offset + 2 + length > bytes.length) {
+        Interpreter.raiseArgumentError(
+          `string length exceeds available bytes: ${length}`,
+        );
+      }
       const elements = [];
 
       for (let i = 0; i < length; i++) {
diff --git a/mix.exs b/mix.exs
index 39270a6fcc..d650081fa5 100644
--- a/mix.exs
+++ b/mix.exs
@@ -13,7 +13,7 @@ defmodule Hologram.MixProject do
         "cmd assets/node_modules/.bin/eslint --color --config assets/eslint.config.mjs assets/js/** benchmarks/javascript/** scripts/** test/javascript/** --no-error-on-unmatched-pattern",
       f: ["format", "format.js", "cmd --cd test/features mix format"],
       "format.js":
-        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' ''scripts/**/*.{mjs,js,json}'' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
+        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**/*.{mjs,js,json}' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
       "format.js.check":
         "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**' 'test/javascript/**' --check --config 'assets/.prettierrc.json' --no-error-on-unmatched-pattern",
       setup: [

From e479beacff9ccadc542716a69b62742f2d463832 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 00:25:54 -0300
Subject: [PATCH 09/33] fix: small atom bounds and add tests for extended ERL
 terms

---
 assets/js/erlang/erlang.mjs                   |   2 +-
 .../ex_js_consistency/erlang/erlang_test.exs  |  39 ++++++
 test/javascript/erlang/erlang_test.mjs        | 112 ++++++++++++++++--
 3 files changed, 144 insertions(+), 9 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index eba6621633..54db2f1147 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -769,7 +769,7 @@ const Erlang = {
 
     const decodeSmallAtom = (dataView, bytes, offset, isUtf8) => {
       const length = dataView.getUint8(offset);
-      if (offset + 2 + length > bytes.length) {
+      if (offset + 1 + length > bytes.length) {
         Interpreter.raiseArgumentError(
           `atom length exceeds available bytes: ${length}`,
         );
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 3c73abba8c..658185ddc1 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1977,11 +1977,34 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == -1_000_000_000_000
     end
 
+    test "decodes large positive integer (LARGE_BIG_EXT)" do
+      binary = :erlang.term_to_binary(1_000_000_000_000)
+      assert :erlang.binary_to_term(binary) == 1_000_000_000_000
+    end
+
+    test "decodes atom UTF-8 (ATOM_UTF8_EXT)" do
+      name = "élixir"
+      binary = <<131, 118, byte_size(name)::16, name::binary>>
+      assert :erlang.binary_to_term(binary) == String.to_atom(name)
+    end
+
     test "decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)" do
       binary = :erlang.term_to_binary(:test)
       assert :erlang.binary_to_term(binary) == :test
     end
 
+    test "decodes atom (ATOM_EXT)" do
+      name = "elixir"
+      binary = <<131, 100, byte_size(name)::16, name::binary>>
+      assert :erlang.binary_to_term(binary) == :elixir
+    end
+
+    test "decodes small atom (SMALL_ATOM_EXT)" do
+      name = "elixir"
+      binary = <<131, 115, byte_size(name)::8, name::binary>>
+      assert :erlang.binary_to_term(binary) == :elixir
+    end
+
     test "decodes longer atom" do
       binary = :erlang.term_to_binary(:test_atom)
       assert :erlang.binary_to_term(binary) == :test_atom
@@ -2012,6 +2035,17 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == {1, 2, 3}
     end
 
+    test "decodes large tuple (LARGE_TUPLE_EXT)" do
+      arity = 300
+      elements = for i <- 1..arity, do: <<97, i::8>>, into: <<>>
+      binary = <<131, 105, arity::32>> <> elements
+      result = :erlang.binary_to_term(binary)
+
+      assert is_tuple(result)
+      assert tuple_size(result) == arity
+      assert elem(result, 0) == 1
+    end
+
     test "decodes empty tuple" do
       binary = :erlang.term_to_binary({})
       assert :erlang.binary_to_term(binary) == {}
@@ -2037,6 +2071,11 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == [100, 200, 300]
     end
 
+    test "decodes improper list (LIST_EXT)" do
+      binary = :erlang.term_to_binary([1 | [2 | [3 | 4]]])
+      assert :erlang.binary_to_term(binary) == [1 | [2 | [3 | 4]]]
+    end
+
     test "decodes empty map" do
       binary = :erlang.term_to_binary(%{})
       assert :erlang.binary_to_term(binary) == %{}
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 76b48a5f11..1ed582484d 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -10,7 +10,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -18,7 +18,7 @@ import ERTS from "../../../assets/js/erts.mjs";
 import HologramInterpreterError from "../../../assets/js/errors/interpreter_error.mjs";
 import Interpreter from "../../../assets/js/interpreter.mjs";
 import Type from "../../../assets/js/type.mjs";
-import {describe} from "node:test";
+import { describe } from "node:test";
 
 defineGlobalErlangAndElixirModules();
 defineErlangModule1Fixture();
@@ -1419,7 +1419,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1433,7 +1433,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1459,7 +1459,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(
@@ -2807,9 +2807,33 @@ describe("Erlang", () => {
         const result = binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(-1000000000000n));
       });
+
+      it("decodes large positive integer (LARGE_BIG_EXT)", () => {
+        // :erlang.term_to_binary(1000000000000) but manually crafted with LARGE_BIG_EXT tag
+        // Note: In practice, Erlang might use SMALL_BIG_EXT for this, but we test LARGE_BIG_EXT support
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.integer(1000000000000n));
+      });
     });
 
     describe("atoms", () => {
+      it("decodes atom UTF-8 (ATOM_UTF8_EXT)", () => {
+        // élixir as UTF-8 atom using ATOM_UTF8_EXT (tag 118)
+        const name = "élixir";
+        const nameBytes = new TextEncoder().encode(name);
+        // ATOM_UTF8_EXT uses 16-bit big-endian length
+        const lengthHigh = (nameBytes.length >> 8) & 0xff;
+        const lengthLow = nameBytes.length & 0xff;
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 118, lengthHigh, lengthLow, ...nameBytes]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom(name));
+      });
+
       it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", () => {
         // :erlang.term_to_binary(:test) = <<131, 119, 4, 116, 101, 115, 116>>
         const binary = Bitstring.fromBytes(
@@ -2819,6 +2843,31 @@ describe("Erlang", () => {
         assert.deepStrictEqual(result, Type.atom("test"));
       });
 
+      it("decodes atom (ATOM_EXT)", () => {
+        // elixir as Latin-1 atom using ATOM_EXT (tag 100)
+        const name = "elixir";
+        const nameBytes = new TextEncoder().encode(name);
+        // ATOM_EXT uses 16-bit big-endian length
+        const lengthHigh = (nameBytes.length >> 8) & 0xff;
+        const lengthLow = nameBytes.length & 0xff;
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 100, lengthHigh, lengthLow, ...nameBytes]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom(name));
+      });
+
+      it("decodes small atom (SMALL_ATOM_EXT)", () => {
+        // elixir as Latin-1 atom using SMALL_ATOM_EXT (tag 115)
+        const name = "elixir";
+        const nameBytes = new TextEncoder().encode(name);
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 115, nameBytes.length, ...nameBytes]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom(name));
+      });
+
       it("decodes longer atom", () => {
         // :erlang.term_to_binary(:test_atom) = <<131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109>>
         const binary = Bitstring.fromBytes(
@@ -2880,6 +2929,35 @@ describe("Erlang", () => {
         );
       });
 
+      it("decodes large tuple (LARGE_TUPLE_EXT)", () => {
+        // Create a tuple with 300 elements using LARGE_TUPLE_EXT (tag 105)
+        const arity = 300;
+        // Header: version (131) + LARGE_TUPLE_EXT tag (105) + arity as 32-bit big-endian
+        const arityBytes = [
+          (arity >> 24) & 0xff,
+          (arity >> 16) & 0xff,
+          (arity >> 8) & 0xff,
+          arity & 0xff,
+        ];
+        const header = new Uint8Array([131, 105, ...arityBytes]);
+
+        // Create element bytes: each element is SMALL_INTEGER_EXT (tag 97) + value
+        // Values 1 to 300, but modulo 256 for values > 255
+        const elementBytes = [];
+        for (let i = 1; i <= arity; i++) {
+          elementBytes.push(97, i & 0xff); // SMALL_INTEGER_EXT + value (wraps at 256)
+        }
+
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([...header, ...elementBytes]),
+        );
+        const result = binary_to_term(binary);
+
+        assert.strictEqual(Type.isTuple(result), true);
+        assert.strictEqual(result.data.length, arity);
+        assert.deepStrictEqual(result.data[0], Type.integer(1));
+      });
+
       it("decodes empty tuple", () => {
         // :erlang.term_to_binary({}) = <<131, 104, 0>>
         const binary = Bitstring.fromBytes(new Uint8Array([131, 104, 0]));
@@ -2937,6 +3015,24 @@ describe("Erlang", () => {
           Type.list([Type.integer(100), Type.integer(200), Type.integer(300)]),
         );
       });
+
+      it("decodes improper list (LIST_EXT)", () => {
+        // :erlang.term_to_binary([1 | [2 | [3 | 4]]]) - improper list
+        // The tail is 4 instead of empty list (NIL_EXT)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 108, 0, 0, 0, 3, 97, 1, 97, 2, 97, 3, 97, 4]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(
+          result,
+          Type.improperList([
+            Type.integer(1),
+            Type.integer(2),
+            Type.integer(3),
+            Type.integer(4),
+          ]),
+        );
+      });
     });
 
     describe("maps", () => {
@@ -6704,7 +6800,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -6718,7 +6814,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -6744,7 +6840,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(

From fce9a6e000eff2042b4e1e9dffc372e1640bc205 Mon Sep 17 00:00:00 2001
From: Vinicius de Freitas Pereira <nivi@Viniciuss-MacBook-Pro.local>
Date: Thu, 22 Jan 2026 20:47:30 -0300
Subject: [PATCH 10/33] Add support for new ETF term tags

- Implement decoding for NEW_FLOAT_EXT, FLOAT_EXT, BIT_BINARY_EXT,
  NEW_REFERENCE_EXT, NEWER_REFERENCE_EXT, PID_EXT, NEW_PID_EXT,
  PORT_EXT, NEW_PORT_EXT and V4_PORT_EXT; add corresponding constants.
- Extend tests in Elixir and JS to cover these formats,
  including references, pids, ports, and bitstrings.
---
 assets/js/erlang/erlang.mjs                   | 253 ++++++++++++++++++
 .../ex_js_consistency/erlang/erlang_test.exs  | 101 +++++++
 test/javascript/erlang/erlang_test.mjs        | 230 ++++++++++++++++
 3 files changed, 584 insertions(+)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 54db2f1147..0a70a3cb2c 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -608,9 +608,17 @@ const Erlang = {
     }
 
     // ETF tag constants
+    const NEW_FLOAT_EXT = 70;
+    const BIT_BINARY_EXT = 77;
+    const NEW_PID_EXT = 88;
+    const NEW_PORT_EXT = 89;
+    const NEWER_REFERENCE_EXT = 90;
     const SMALL_INTEGER_EXT = 97;
     const INTEGER_EXT = 98;
+    const FLOAT_EXT = 99;
     const ATOM_EXT = 100;
+    const PORT_EXT = 102;
+    const PID_EXT = 103;
     const SMALL_TUPLE_EXT = 104;
     const LARGE_TUPLE_EXT = 105;
     const NIL_EXT = 106;
@@ -619,10 +627,12 @@ const Erlang = {
     const BINARY_EXT = 109;
     const SMALL_BIG_EXT = 110;
     const LARGE_BIG_EXT = 111;
+    const NEW_REFERENCE_EXT = 114;
     const SMALL_ATOM_EXT = 115;
     const MAP_EXT = 116;
     const ATOM_UTF8_EXT = 118;
     const SMALL_ATOM_UTF8_EXT = 119;
+    const V4_PORT_EXT = 120;
 
     const decodeTerm = (dataView, bytes, offset) => {
       if (offset >= bytes.length) {
@@ -682,6 +692,36 @@ const Erlang = {
         case MAP_EXT:
           return decodeMap(dataView, bytes, offset + 1);
 
+        case NEW_FLOAT_EXT:
+          return decodeNewFloat(dataView, offset + 1);
+
+        case FLOAT_EXT:
+          return decodeFloatExt(dataView, bytes, offset + 1);
+
+        case BIT_BINARY_EXT:
+          return decodeBitBinary(dataView, bytes, offset + 1);
+
+        case NEW_REFERENCE_EXT:
+          return decodeNewReference(dataView, bytes, offset + 1);
+
+        case NEWER_REFERENCE_EXT:
+          return decodeNewerReference(dataView, bytes, offset + 1);
+
+        case PID_EXT:
+          return decodePid(dataView, bytes, offset + 1);
+
+        case NEW_PID_EXT:
+          return decodeNewPid(dataView, bytes, offset + 1);
+
+        case PORT_EXT:
+          return decodePort(dataView, bytes, offset + 1);
+
+        case NEW_PORT_EXT:
+          return decodeNewPort(dataView, bytes, offset + 1);
+
+        case V4_PORT_EXT:
+          return decodeV4Port(dataView, bytes, offset + 1);
+
         default:
           Interpreter.raiseArgumentError(
             `unsupported external term format tag: ${tag}`,
@@ -912,6 +952,219 @@ const Erlang = {
       };
     };
 
+    // Float decoders
+
+    const decodeNewFloat = (dataView, offset) => {
+      const value = dataView.getFloat64(offset);
+      return {
+        term: Type.float(value),
+        newOffset: offset + 8,
+      };
+    };
+
+    const decodeFloatExt = (dataView, bytes, offset) => {
+      // FLOAT_EXT: 31-byte null-terminated string (deprecated format)
+      if (offset + 31 > bytes.length) {
+        Interpreter.raiseArgumentError("float string exceeds available bytes");
+      }
+      const floatBytes = bytes.slice(offset, offset + 31);
+      const decoder = new TextDecoder("latin1");
+      const floatString = decoder.decode(floatBytes).replace(/\0.*$/, "");
+      const value = parseFloat(floatString);
+
+      return {
+        term: Type.float(value),
+        newOffset: offset + 31,
+      };
+    };
+
+    // Bitstring decoder
+
+    const decodeBitBinary = (dataView, bytes, offset) => {
+      const length = dataView.getUint32(offset);
+      const bits = dataView.getUint8(offset + 4);
+
+      if (offset + 5 + length > bytes.length) {
+        Interpreter.raiseArgumentError(
+          `bit binary length exceeds available bytes: ${length}`,
+        );
+      }
+
+      const binaryBytes = bytes.slice(offset + 5, offset + 5 + length);
+      const bitstring = Bitstring.fromBytes(new Uint8Array(binaryBytes));
+
+      // Adjust leftoverBitCount based on the bits field
+      // If bits is 0, all bytes are full (leftoverBitCount = 0)
+      // If bits is 1-7, the last byte is partial (leftoverBitCount = bits)
+      if (bits > 0 && bits < 8) {
+        bitstring.leftoverBitCount = bits;
+      }
+      // If bits is 0 or 8, leftoverBitCount is already 0 (all full bytes)
+
+      return {
+        term: bitstring,
+        newOffset: offset + 5 + length,
+      };
+    };
+
+    // Reference decoders
+
+    const decodeNewReference = (dataView, bytes, offset) => {
+      const len = dataView.getUint16(offset);
+      let currentOffset = offset + 2;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      const creation = dataView.getUint8(currentOffset);
+      currentOffset += 1;
+
+      const idWords = [];
+      for (let i = 0; i < len; i++) {
+        idWords.push(dataView.getUint32(currentOffset));
+        currentOffset += 4;
+      }
+
+      return {
+        term: Type.reference(nodeResult.term, creation, idWords),
+        newOffset: currentOffset,
+      };
+    };
+
+    const decodeNewerReference = (dataView, bytes, offset) => {
+      const len = dataView.getUint16(offset);
+      let currentOffset = offset + 2;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      const creation = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const idWords = [];
+      for (let i = 0; i < len; i++) {
+        idWords.push(dataView.getUint32(currentOffset));
+        currentOffset += 4;
+      }
+
+      return {
+        term: Type.reference(nodeResult.term, creation, idWords),
+        newOffset: currentOffset,
+      };
+    };
+
+    // PID decoders
+
+    const decodePid = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      // Read ID (4 bytes), Serial (4 bytes), Creation (1 byte)
+      const id = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const serial = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const creation = dataView.getUint8(currentOffset);
+      currentOffset += 1;
+
+      return {
+        term: Type.pid(nodeResult.term, [id, serial, creation]),
+        newOffset: currentOffset,
+      };
+    };
+
+    const decodeNewPid = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      // Read ID (4 bytes), Serial (4 bytes), Creation (4 bytes)
+      const id = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const serial = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const creation = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      return {
+        term: Type.pid(nodeResult.term, [id, serial, creation]),
+        newOffset: currentOffset,
+      };
+    };
+
+    // Port decoders
+
+    const decodePort = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      // Read ID (4 bytes), Creation (1 byte)
+      const id = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const creation = dataView.getUint8(currentOffset);
+      currentOffset += 1;
+
+      return {
+        term: Type.port(nodeResult.term, [id, creation]),
+        newOffset: currentOffset,
+      };
+    };
+
+    const decodeNewPort = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      // Read ID (4 bytes), Creation (4 bytes)
+      const id = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      const creation = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      return {
+        term: Type.port(nodeResult.term, [id, creation]),
+        newOffset: currentOffset,
+      };
+    };
+
+    const decodeV4Port = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode node name (atom)
+      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = nodeResult.newOffset;
+
+      // Read ID (8 bytes as BigUint64), Creation (4 bytes)
+      const id = dataView.getBigUint64(currentOffset);
+      currentOffset += 8;
+
+      const creation = dataView.getUint32(currentOffset);
+      currentOffset += 4;
+
+      return {
+        term: Type.port(nodeResult.term, [id, creation]),
+        newOffset: currentOffset,
+      };
+    };
+
     try {
       Bitstring.maybeSetBytesFromText(binary);
 
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 658185ddc1..2d7418322d 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2086,6 +2086,107 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == %{a: 1, b: 2}
     end
 
+    test "decodes NEW_FLOAT_EXT (IEEE 754 double)" do
+      binary = :erlang.term_to_binary(3.14159)
+      assert :erlang.binary_to_term(binary) == 3.14159
+    end
+
+    test "decodes NEW_FLOAT_EXT for negative float" do
+      binary = :erlang.term_to_binary(-2.5)
+      assert :erlang.binary_to_term(binary) == -2.5
+    end
+
+    test "decodes NEW_FLOAT_EXT for zero" do
+      binary = :erlang.term_to_binary(0.0)
+      assert :erlang.binary_to_term(binary) == 0.0
+    end
+
+    test "decodes BIT_BINARY_EXT with partial byte" do
+      # Bitstring with 5 bits
+      bitstring = <<1::5>>
+      binary = :erlang.term_to_binary(bitstring)
+      assert :erlang.binary_to_term(binary) == bitstring
+    end
+
+    test "decodes BIT_BINARY_EXT with full bytes" do
+      # Bitstring with 16 bits (2 full bytes)
+      bitstring = <<255, 0>>
+      binary = :erlang.term_to_binary(bitstring)
+      assert :erlang.binary_to_term(binary) == bitstring
+    end
+
+    test "decodes NEW_REFERENCE_EXT" do
+      # Create a reference and encode/decode it
+      ref = make_ref()
+      binary = :erlang.term_to_binary(ref)
+      decoded = :erlang.binary_to_term(binary)
+      assert is_reference(decoded)
+    end
+
+    test "decodes NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT" do
+      # Manually construct NEWER_REFERENCE_EXT binary
+      binary =
+        <<131, 90, 0, 3, 119, 13, "nonode@nohost", 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0,
+          3>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_reference(decoded)
+    end
+
+    test "decodes NEWER_REFERENCE_EXT with ATOM_EXT" do
+      # Manually construct NEWER_REFERENCE_EXT binary with ATOM_EXT node
+      binary =
+        <<131, 90, 0, 3, 100, 0, 13, "nonode@nohost", 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0,
+          3>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_reference(decoded)
+    end
+
+    test "decodes PID_EXT" do
+      # Manually construct PID_EXT binary
+      # 131 - VERSION, 103 - PID_EXT, then node atom, ID, Serial, Creation
+      binary =
+        <<131, 103, 119, 13, "nonode@nohost", 0, 0, 0, 100, 0, 0, 0, 50, 0>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_pid(decoded)
+    end
+
+    test "decodes NEW_PID_EXT" do
+      # Create a PID and encode/decode it
+      pid = self()
+      binary = :erlang.term_to_binary(pid)
+      decoded = :erlang.binary_to_term(binary)
+      assert is_pid(decoded)
+    end
+
+    test "decodes PORT_EXT" do
+      # Manually construct PORT_EXT binary
+      # 131 - VERSION, 102 - PORT_EXT, then node atom, ID, Creation
+      binary = <<131, 102, 119, 13, "nonode@nohost", 0, 0, 0, 5, 0>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_port(decoded)
+    end
+
+    test "decodes NEW_PORT_EXT" do
+      # Manually construct NEW_PORT_EXT binary
+      # 131 - VERSION, 89 - NEW_PORT_EXT, then node atom, ID (4 bytes), Creation (4 bytes)
+      binary = <<131, 89, 119, 13, "nonode@nohost", 0, 0, 0, 5, 0, 0, 0, 0>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_port(decoded)
+    end
+
+    test "decodes V4_PORT_EXT" do
+      # Create a port and encode/decode it (modern Erlang uses V4_PORT_EXT)
+      port = hd(Port.list())
+      binary = :erlang.term_to_binary(port)
+      decoded = :erlang.binary_to_term(binary)
+      assert is_port(decoded)
+    end
+
     test "decodes Code.fetch_docs/1 style tuple" do
       term = {:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []}
       binary = :erlang.term_to_binary(term)
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 1ed582484d..49fd9cf387 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3063,6 +3063,236 @@ describe("Erlang", () => {
       });
     });
 
+    describe("floats", () => {
+      it("decodes NEW_FLOAT_EXT (IEEE 754 double)", () => {
+        // :erlang.term_to_binary(3.14159) with NEW_FLOAT_EXT tag
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 70, 64, 9, 33, 249, 240, 27, 134, 110]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(3.14159));
+      });
+
+      it("decodes NEW_FLOAT_EXT for negative float", () => {
+        // :erlang.term_to_binary(-2.5)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 70, 192, 4, 0, 0, 0, 0, 0, 0]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(-2.5));
+      });
+
+      it("decodes NEW_FLOAT_EXT for zero", () => {
+        // :erlang.term_to_binary(0.0)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 70, 0, 0, 0, 0, 0, 0, 0, 0]),
+        );
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(0.0));
+      });
+    });
+
+    describe("bitstrings", () => {
+      it("decodes BIT_BINARY_EXT with partial byte", () => {
+        // Bitstring with 5 bits: <<1::5>>
+        // 131 - VERSION_NUMBER
+        // 77 - BIT_BINARY_EXT
+        // 0, 0, 0, 1 - length (1 byte)
+        // 5 - bits in last byte
+        // 0b00001000 (8) - the byte with 5 bits set
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 77, 0, 0, 0, 1, 5, 8]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(Bitstring.calculateBitCount(result), 5);
+      });
+
+      it("decodes BIT_BINARY_EXT with full bytes", () => {
+        // Bitstring with 16 bits (2 full bytes): <<255, 0>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 77, 0, 0, 0, 2, 0, 255, 0]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(Bitstring.calculateBitCount(result), 16);
+      });
+    });
+
+    describe("references", () => {
+      it("decodes NEW_REFERENCE_EXT", () => {
+        // NEW_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT node
+        // 131 - VERSION_NUMBER
+        // 114 - NEW_REFERENCE_EXT
+        // 0, 3 - number of ID words (3)
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // 0 - creation (1 byte)
+        // ID words: 1, 2, 3 (each 4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 114, 0, 3, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111,
+            104, 111, 115, 116, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 0);
+        assert.deepStrictEqual(result.idWords, [1, 2, 3]);
+      });
+
+      it("decodes NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT", () => {
+        // NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT node
+        // 131 - VERSION_NUMBER
+        // 90 - NEWER_REFERENCE_EXT
+        // 0, 3 - number of ID words (3)
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // 0, 0, 0, 0 - creation (4 bytes)
+        // ID words: 1, 2, 3 (each 4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 90, 0, 3, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111,
+            104, 111, 115, 116, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 0);
+        assert.deepStrictEqual(result.idWords, [1, 2, 3]);
+      });
+
+      it("decodes NEWER_REFERENCE_EXT with ATOM_EXT", () => {
+        // NEWER_REFERENCE_EXT with ATOM_EXT node
+        // 131 - VERSION_NUMBER
+        // 90 - NEWER_REFERENCE_EXT
+        // 0, 3 - number of ID words (3)
+        // 100 - ATOM_EXT
+        // 0, 13 - node name length (2 bytes)
+        // "nonode@nohost" - node name
+        // 0, 0, 0, 0 - creation (4 bytes)
+        // ID words: 1, 2, 3 (each 4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 90, 0, 3, 100, 0, 13, 110, 111, 110, 111, 100, 101, 64, 110,
+            111, 104, 111, 115, 116, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0,
+            0, 3,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 0);
+        assert.deepStrictEqual(result.idWords, [1, 2, 3]);
+      });
+    });
+
+    describe("pids", () => {
+      it("decodes PID_EXT", () => {
+        // PID_EXT format
+        // 131 - VERSION_NUMBER
+        // 103 - PID_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // ID (4 bytes), Serial (4 bytes), Creation (1 byte)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 103, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 100, 0, 0, 0, 50, 0,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "pid");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.deepStrictEqual(result.segments, [100, 50, 0]);
+      });
+
+      it("decodes NEW_PID_EXT", () => {
+        // NEW_PID_EXT format
+        // 131 - VERSION_NUMBER
+        // 88 - NEW_PID_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // ID (4 bytes), Serial (4 bytes), Creation (4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 88, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 100, 0, 0, 0, 50, 0, 0, 0, 0,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "pid");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.deepStrictEqual(result.segments, [100, 50, 0]);
+      });
+    });
+
+    describe("ports", () => {
+      it("decodes PORT_EXT", () => {
+        // PORT_EXT format
+        // 131 - VERSION_NUMBER
+        // 102 - PORT_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // ID (4 bytes), Creation (1 byte)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 102, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 5, 0,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "port");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.deepStrictEqual(result.segments, [5, 0]);
+      });
+
+      it("decodes NEW_PORT_EXT", () => {
+        // NEW_PORT_EXT format
+        // 131 - VERSION_NUMBER
+        // 89 - NEW_PORT_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // ID (4 bytes), Creation (4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 89, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 5, 0, 0, 0, 0,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "port");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.deepStrictEqual(result.segments, [5, 0]);
+      });
+
+      it("decodes V4_PORT_EXT", () => {
+        // V4_PORT_EXT format (64-bit port ID)
+        // 131 - VERSION_NUMBER
+        // 120 - V4_PORT_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // ID (8 bytes as BigUint64), Creation (4 bytes)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 120, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        assert.strictEqual(result.type, "port");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.deepStrictEqual(result.segments, [5n, 0]);
+      });
+    });
+
     describe("complex nested structures", () => {
       it("decodes Code.fetch_docs/1 style tuple", () => {
         // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})

From a7a0cda1899fe9bd2662798e8da5b63b4f4c695b Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 22:04:51 -0300
Subject: [PATCH 11/33] Update renderer.ex

---
 lib/hologram/template/renderer.ex | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/hologram/template/renderer.ex b/lib/hologram/template/renderer.ex
index cd040e4ae9..8a76e2739d 100644
--- a/lib/hologram/template/renderer.ex
+++ b/lib/hologram/template/renderer.ex
@@ -64,11 +64,11 @@ defmodule Hologram.Template.Renderer do
     {"<!DOCTYPE #{content}>", %{}, server_struct}
   end
 
-  def render_dom({:element, "slot", _attrs_dom, []}, %Env{} = env, server_struct) do
+  def render_dom({:element, "slot", _attrs_dom, []}, env, server_struct) do
     render_dom(env.slots[:default], %Env{env | slots: []}, server_struct)
   end
 
-  def render_dom({:element, tag_name, attrs_dom, children_dom}, %Env{} = env, server_struct) do
+  def render_dom({:element, tag_name, attrs_dom, children_dom}, env, server_struct) do
     attrs_html = render_attributes(attrs_dom)
 
     children_env = %Env{env | node_type: :element, tag_name: tag_name}
@@ -90,7 +90,7 @@ defmodule Hologram.Template.Renderer do
     {stringify_for_interpolation(value), %{}, server_struct}
   end
 
-  def render_dom({:public_comment, children_dom}, %Env{} = env, server_struct) do
+  def render_dom({:public_comment, children_dom}, env, server_struct) do
     children_env = %Env{env | node_type: :public_comment}
 
     {children_html, component_registry, mutated_server_struct} =
@@ -192,7 +192,7 @@ defmodule Hologram.Template.Renderer do
 
       iex> stringify_for_interpolation("hello")
       "hello"
-
+      
       iex> stringify_for_interpolation("<script>")
       "&lt;script&gt;"
   """

From 14cdb571b1e1239dd75369dedfd954bd06570238 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 22:18:33 -0300
Subject: [PATCH 12/33] Update test for LARGE_BIG_EXT encoding

---
 .../hologram/ex_js_consistency/erlang/erlang_test.exs  | 10 ++++++++--
 test/javascript/erlang/erlang_test.mjs                 |  1 -
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 2d7418322d..8e960abd1f 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1978,8 +1978,14 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     end
 
     test "decodes large positive integer (LARGE_BIG_EXT)" do
-      binary = :erlang.term_to_binary(1_000_000_000_000)
-      assert :erlang.binary_to_term(binary) == 1_000_000_000_000
+      # LARGE_BIG_EXT requires integers with >255 bytes +
+      # 2^2048 requires 257 bytes, triggering LARGE_BIG_EXT encoding
+      large_int =
+        Integer.pow(2, 2048)
+        |> trunc()
+
+      binary = :erlang.term_to_binary(large_int)
+      assert :erlang.binary_to_term(binary) == large_int
     end
 
     test "decodes atom UTF-8 (ATOM_UTF8_EXT)" do
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 49fd9cf387..97d09afffc 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -18,7 +18,6 @@ import ERTS from "../../../assets/js/erts.mjs";
 import HologramInterpreterError from "../../../assets/js/errors/interpreter_error.mjs";
 import Interpreter from "../../../assets/js/interpreter.mjs";
 import Type from "../../../assets/js/type.mjs";
-import { describe } from "node:test";
 
 defineGlobalErlangAndElixirModules();
 defineErlangModule1Fixture();

From 0c2cf946baa1d96d4db60c9b3a6f6abfa250f427 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 22:50:08 -0300
Subject: [PATCH 13/33] Add tests for ETF tags and malformed binaries

---
 test/javascript/erlang/erlang_test.mjs | 211 +++++++++++++++++++++++++
 1 file changed, 211 insertions(+)

diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 97d09afffc..2ec3d0948d 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3346,6 +3346,217 @@ describe("Erlang", () => {
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
+
+      it("raises ArgumentError for unsupported ETF tag (tag 50)", () => {
+        // Tag 50 is not a valid ETF tag
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 50]));
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "unsupported external term format tag: 50",
+        );
+      });
+
+      it("raises ArgumentError for unsupported ETF tag (tag 255)", () => {
+        // Tag 255 is not a valid ETF tag
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 255]));
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "unsupported external term format tag: 255",
+        );
+      });
+
+      it("raises ArgumentError for unsupported ETF tag (tag 1)", () => {
+        // Tag 1 is not a valid ETF tag
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 1]));
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "unsupported external term format tag: 1",
+        );
+      });
+
+      it("raises ArgumentError for malformed BINARY_EXT with length exceeding data", () => {
+        // BINARY_EXT (109) with length 10 but only 2 bytes of data
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 109, 0, 0, 0, 10, 65, 66]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "atom length exceeds available bytes: 10",
+        );
+      });
+
+      it("raises ArgumentError for malformed STRING_EXT with length exceeding data", () => {
+        // STRING_EXT (107) with length 100 but only 2 bytes of data
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 107, 0, 100, 65, 66]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "string length exceeds available bytes: 100",
+        );
+      });
+
+      it("raises ArgumentError for malformed SMALL_TUPLE_EXT with arity exceeding available data", () => {
+        // SMALL_TUPLE_EXT (104) with arity 5 but only 1 element
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 104, 5, 97, 1]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for malformed LIST_EXT with length exceeding data", () => {
+        // LIST_EXT (108) with length 10 but no elements
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 108, 0, 0, 0, 10]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for malformed MAP_EXT with arity exceeding data", () => {
+        // MAP_EXT (116) with arity 10 but no key-value pairs
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 116, 0, 0, 0, 10]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for malformed ATOM_EXT with length exceeding data", () => {
+        // ATOM_EXT (100) with length 100 but only 2 bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 100, 0, 100, 65, 66]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "atom length exceeds available bytes: 100",
+        );
+      });
+
+      it("raises ArgumentError for malformed SMALL_ATOM_UTF8_EXT with length exceeding data", () => {
+        // SMALL_ATOM_UTF8_EXT (119) with length 50 but only 2 bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 119, 50, 65, 66]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "atom length exceeds available bytes: 50",
+        );
+      });
+
+      it("raises ArgumentError for malformed SMALL_BIG_EXT with n exceeding data", () => {
+        // SMALL_BIG_EXT (110) with n=100 but insufficient bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 110, 100, 0, 1, 2, 3]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for malformed LARGE_BIG_EXT with n exceeding data", () => {
+        // LARGE_BIG_EXT (111) with large n but insufficient bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 111, 0, 0, 1, 0, 0, 1, 2, 3]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for malformed BIT_BINARY_EXT with length exceeding data", () => {
+        // BIT_BINARY_EXT (77) with length 100 but only 2 bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 77, 0, 0, 0, 100, 5, 65, 66]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "bit binary length exceeds available bytes: 100",
+        );
+      });
+
+      it("raises ArgumentError for malformed NEW_REFERENCE_EXT with len exceeding data", () => {
+        // NEW_REFERENCE_EXT (114) with len=10 but insufficient id bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 114, 0, 10, 119, 4, 110, 111, 100, 101, 0, 0, 0, 1,
+          ]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for INTEGER_EXT boundary - value truncated", () => {
+        // INTEGER_EXT (98) but only 2 bytes instead of 4
+        const binary = Bitstring.fromBytes(new Uint8Array([131, 98, 0, 0]));
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for NEW_FLOAT_EXT truncated", () => {
+        // NEW_FLOAT_EXT (70) but only 4 bytes instead of 8
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 70, 0, 0, 0, 0]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for nested term truncation", () => {
+        // SMALL_TUPLE_EXT with 2 elements, but second element is truncated
+        // [131, 104, 2, 97, 1, 97] - missing last byte
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 104, 2, 97, 1, 97]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for LARGE_TUPLE_EXT with zero arity but missing NIL_EXT", () => {
+        // LARGE_TUPLE_EXT (105) with arity 0 - should work, but let's test malformed version
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 105, 0, 0, 0, 1]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
     });
   });
 

From 508197a65e52fc11a5f0437cbaef6c15d9b4e983 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 23:00:34 -0300
Subject: [PATCH 14/33] feat: add EXPORT_EXT decoding for function captures

---
 assets/js/erlang/erlang.mjs                   | 37 +++++++++++++++++++
 .../ex_js_consistency/erlang/erlang_test.exs  |  8 ++++
 test/javascript/erlang/erlang_test.mjs        | 21 +++++++++++
 3 files changed, 66 insertions(+)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 0a70a3cb2c..c1df24c6b3 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -627,6 +627,7 @@ const Erlang = {
     const BINARY_EXT = 109;
     const SMALL_BIG_EXT = 110;
     const LARGE_BIG_EXT = 111;
+    const EXPORT_EXT = 113;
     const NEW_REFERENCE_EXT = 114;
     const SMALL_ATOM_EXT = 115;
     const MAP_EXT = 116;
@@ -722,6 +723,9 @@ const Erlang = {
         case V4_PORT_EXT:
           return decodeV4Port(dataView, bytes, offset + 1);
 
+        case EXPORT_EXT:
+          return decodeExport(dataView, bytes, offset + 1);
+
         default:
           Interpreter.raiseArgumentError(
             `unsupported external term format tag: ${tag}`,
@@ -1165,6 +1169,39 @@ const Erlang = {
       };
     };
 
+    // EXPORT_EXT decoder (function capture)
+    const decodeExport = (dataView, bytes, offset) => {
+      let currentOffset = offset;
+
+      // Decode module (atom)
+      const moduleResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = moduleResult.newOffset;
+
+      // Decode function (atom)
+      const functionResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = functionResult.newOffset;
+
+      // Decode arity (small integer)
+      const arityResult = decodeTerm(dataView, bytes, currentOffset);
+      currentOffset = arityResult.newOffset;
+
+      const context = Interpreter.buildContext();
+
+      // Convert arity from BigInt to Number
+      const arity = Number(arityResult.term.value);
+
+      return {
+        term: Type.functionCapture(
+          moduleResult.term.value,
+          functionResult.term.value,
+          arity,
+          [],
+          context,
+        ),
+        newOffset: currentOffset,
+      };
+    };
+
     try {
       Bitstring.maybeSetBytesFromText(binary);
 
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 8e960abd1f..410736adab 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2193,6 +2193,14 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert is_port(decoded)
     end
 
+    test "decodes EXPORT_EXT (function capture)" do
+      # Create a function capture and encode/decode it
+      fun = &Enum.map/2
+      binary = :erlang.term_to_binary(fun)
+      decoded = :erlang.binary_to_term(binary)
+      assert is_function(decoded, 2)
+    end
+
     test "decodes Code.fetch_docs/1 style tuple" do
       term = {:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []}
       binary = :erlang.term_to_binary(term)
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 2ec3d0948d..0061441e9a 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3292,6 +3292,27 @@ describe("Erlang", () => {
       });
     });
 
+    describe("exports (function captures)", () => {
+      it("decodes EXPORT_EXT (function capture)", () => {
+        // &Enum.map/2
+        // :erlang.term_to_binary(&Enum.map/2) =
+        // <<131, 113, 119, 11, 69, 108, 105, 120, 105, 114, 46, 69, 110, 117, 109, 119, 3, 109, 97, 112, 97, 2>>
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 113, 119, 11, 69, 108, 105, 120, 105, 114, 46, 69, 110, 117,
+            109, 119, 3, 109, 97, 112, 97, 2,
+          ]),
+        );
+        const result = binary_to_term(binary);
+
+        assert.strictEqual(result.type, "anonymous_function");
+        assert.strictEqual(result.capturedModule, "Elixir.Enum");
+        assert.strictEqual(result.capturedFunction, "map");
+        assert.strictEqual(result.arity, 2);
+        assert.deepStrictEqual(result.clauses, []);
+      });
+    });
+
     describe("complex nested structures", () => {
       it("decodes Code.fetch_docs/1 style tuple", () => {
         // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})

From 59c96a37f5429b68c8c24fd34cd0a61f6e855bad Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Thu, 22 Jan 2026 23:08:52 -0300
Subject: [PATCH 15/33] fix: decodeBinary condition

---
 assets/js/erlang/erlang.mjs                    |  4 ++--
 mix.exs                                        | 10 ++++++----
 .../ex_js_consistency/erlang/erlang_test.exs   |  4 ++--
 test/javascript/erlang/erlang_test.mjs         | 18 +++++++++---------
 4 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index c1df24c6b3..0b19e2822f 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -833,9 +833,9 @@ const Erlang = {
 
     const decodeBinary = (dataView, bytes, offset) => {
       const length = dataView.getUint32(offset);
-      if (offset + 2 + length > bytes.length) {
+      if (offset + 4 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `atom length exceeds available bytes: ${length}`,
+          `binary length exceeds available bytes: ${length}`,
         );
       }
       const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
diff --git a/mix.exs b/mix.exs
index d650081fa5..5067d08ba1 100644
--- a/mix.exs
+++ b/mix.exs
@@ -97,10 +97,12 @@ defmodule Hologram.MixProject do
     ]
   end
 
-  def preferred_cli_env do
+  def cli do
     [
-      t: :test,
-      "test.js": :test
+      preferred_envs: [
+        t: :test,
+        "test.js": :test
+      ]
     ]
   end
 
@@ -108,6 +110,7 @@ defmodule Hologram.MixProject do
     [
       aliases: aliases(),
       app: :hologram,
+      cli: cli(),
       deps: deps(),
       description:
         "Full stack isomorphic Elixir web framework that can be used on top of Phoenix.",
@@ -143,7 +146,6 @@ defmodule Hologram.MixProject do
       elixirc_paths: elixirc_paths(Mix.env()),
       homepage_url: "https://hologram.page/",
       package: package(),
-      preferred_cli_env: preferred_cli_env(),
       start_permanent: Mix.env() == :prod,
       source_url: "https://github.com/bartblast/hologram",
       test_paths: ["test/elixir"],
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 410736adab..31b0db3ec3 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2043,8 +2043,8 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
 
     test "decodes large tuple (LARGE_TUPLE_EXT)" do
       arity = 300
-      elements = for i <- 1..arity, do: <<97, i::8>>, into: <<>>
-      binary = <<131, 105, arity::32>> <> elements
+      tuple = 1..arity |> Enum.to_list() |> List.to_tuple()
+      binary = :erlang.term_to_binary(tuple)
       result = :erlang.binary_to_term(binary)
 
       assert is_tuple(result)
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 0061441e9a..2bc98fe614 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -10,7 +10,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -1418,7 +1418,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1432,7 +1432,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1458,7 +1458,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(
@@ -2811,7 +2811,7 @@ describe("Erlang", () => {
         // :erlang.term_to_binary(1000000000000) but manually crafted with LARGE_BIG_EXT tag
         // Note: In practice, Erlang might use SMALL_BIG_EXT for this, but we test LARGE_BIG_EXT support
         const binary = Bitstring.fromBytes(
-          new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
+          new Uint8Array([131, 111, 0, 0, 0, 5, 0, 0, 16, 165, 212, 232]),
         );
         const result = binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(1000000000000n));
@@ -3406,7 +3406,7 @@ describe("Erlang", () => {
         assertBoxedError(
           () => binary_to_term(binary),
           "ArgumentError",
-          "atom length exceeds available bytes: 10",
+          "binary length exceeds available bytes: 10",
         );
       });
 
@@ -7261,7 +7261,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7275,7 +7275,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7301,7 +7301,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(

From 1edbabb8599c56850d13750dd18b35a8813144e0 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 23 Jan 2026 00:08:17 -0300
Subject: [PATCH 16/33] revert: revert renderer_Test.exs

---
 .../ex_js_consistency/erlang/erlang_test.exs         |  1 -
 test/elixir/hologram/template/renderer_test.exs      | 12 ++++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 31b0db3ec3..c68d3e2c4f 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2115,7 +2115,6 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     end
 
     test "decodes BIT_BINARY_EXT with full bytes" do
-      # Bitstring with 16 bits (2 full bytes)
       bitstring = <<255, 0>>
       binary = :erlang.term_to_binary(bitstring)
       assert :erlang.binary_to_term(binary) == bitstring
diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 1f1903371d..14f61e9c45 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module25, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module27, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module24, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do

From 4f2565f24e16eac4354eb71583090dff14202aed Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 23 Jan 2026 13:17:31 -0300
Subject: [PATCH 17/33] fix: adjust code to be idiomatic and avoid credo
 warnings

---
 assets/js/erlang/erlang.mjs                      | 10 +++++++---
 .../ex_js_consistency/erlang/erlang_test.exs     | 13 ++++++++-----
 test/javascript/erlang/erlang_test.mjs           | 16 +++++++++-------
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 0b19e2822f..510f39fd66 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -728,7 +728,10 @@ const Erlang = {
 
         default:
           Interpreter.raiseArgumentError(
-            `unsupported external term format tag: ${tag}`,
+            Interpreter.buildArgumentErrorMsg(
+              1,
+              "invalid external representation of a term",
+            ),
           );
       }
     };
@@ -802,8 +805,9 @@ const Erlang = {
       }
       const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
 
-      const decoder = new TextDecoder(isUtf8 ? "utf-8" : "latin1");
-      const atomString = decoder.decode(atomBytes);
+      const atomString = isUtf8
+        ? new TextDecoder("utf-8").decode(atomBytes)
+        : String.fromCharCode(...atomBytes);
 
       return {
         term: Type.atom(atomString),
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index c68d3e2c4f..f455917513 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1980,9 +1980,7 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     test "decodes large positive integer (LARGE_BIG_EXT)" do
       # LARGE_BIG_EXT requires integers with >255 bytes +
       # 2^2048 requires 257 bytes, triggering LARGE_BIG_EXT encoding
-      large_int =
-        Integer.pow(2, 2048)
-        |> trunc()
+      large_int = trunc(Integer.pow(2, 2048))
 
       binary = :erlang.term_to_binary(large_int)
       assert :erlang.binary_to_term(binary) == large_int
@@ -1991,7 +1989,7 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     test "decodes atom UTF-8 (ATOM_UTF8_EXT)" do
       name = "élixir"
       binary = <<131, 118, byte_size(name)::16, name::binary>>
-      assert :erlang.binary_to_term(binary) == String.to_atom(name)
+      assert :erlang.binary_to_term(binary) == String.to_existing_atom(name)
     end
 
     test "decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)" do
@@ -2043,7 +2041,12 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
 
     test "decodes large tuple (LARGE_TUPLE_EXT)" do
       arity = 300
-      tuple = 1..arity |> Enum.to_list() |> List.to_tuple()
+
+      tuple =
+        1..arity
+        |> Enum.to_list()
+        |> List.to_tuple()
+
       binary = :erlang.term_to_binary(tuple)
       result = :erlang.binary_to_term(binary)
 
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 2bc98fe614..92b09b7223 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -2878,20 +2878,22 @@ describe("Erlang", () => {
         assert.deepStrictEqual(result, Type.atom("test_atom"));
       });
 
-      it("decodes boolean atoms", () => {
+      it("decodes true atom", () => {
         // :erlang.term_to_binary(true) = <<131, 119, 4, 116, 114, 117, 101>>
-        const trueBinary = Bitstring.fromBytes(
+        const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 4, 116, 114, 117, 101]),
         );
-        const trueResult = binary_to_term(trueBinary);
-        assert.deepStrictEqual(trueResult, Type.atom("true"));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom("true"));
+      });
 
+      it("decodes false atom", () => {
         // :erlang.term_to_binary(false) = <<131, 119, 5, 102, 97, 108, 115, 101>>
-        const falseBinary = Bitstring.fromBytes(
+        const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 5, 102, 97, 108, 115, 101]),
         );
-        const falseResult = binary_to_term(falseBinary);
-        assert.deepStrictEqual(falseResult, Type.atom("false"));
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.atom("false"));
       });
     });
 

From d8821cb7fdda4ef6f4201122da49b31bfa201ae0 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Mon, 26 Jan 2026 20:23:09 -0300
Subject: [PATCH 18/33] chore: add compressed term decoder

---
 assets/js/erlang/erlang.mjs                   |  54 +++++++-
 assets/js/utils.mjs                           |   9 ++
 assets/package-lock.json                      |   7 ++
 assets/package.json                           |   1 +
 .../ex_js_consistency/erlang/erlang_test.exs  |  60 +++++++++
 test/javascript/erlang/erlang_test.mjs        | 116 ++++++++++++++++--
 6 files changed, 236 insertions(+), 11 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 510f39fd66..c9a316761f 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -610,6 +610,7 @@ const Erlang = {
     // ETF tag constants
     const NEW_FLOAT_EXT = 70;
     const BIT_BINARY_EXT = 77;
+    const COMPRESSED = 80;
     const NEW_PID_EXT = 88;
     const NEW_PORT_EXT = 89;
     const NEWER_REFERENCE_EXT = 90;
@@ -648,6 +649,9 @@ const Erlang = {
       const tag = dataView.getUint8(offset);
 
       switch (tag) {
+        case COMPRESSED:
+          return decodeCompressed(dataView, bytes, offset + 1);
+
         case SMALL_INTEGER_EXT:
           return decodeSmallInteger(dataView, offset + 1);
 
@@ -736,6 +740,53 @@ const Erlang = {
       }
     };
 
+    // Compressed term decoder
+    // Format: COMPRESSED (80) | UncompressedSize (4 bytes, big-endian) | ZlibCompressedData
+    // The decompressed data contains the ETF representation of the term without the version byte
+
+    const decodeCompressed = (dataView, bytes, offset) => {
+      if (offset + 4 > bytes.length) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
+      const uncompressedSize = dataView.getUint32(offset, false);
+      const compressedData = bytes.slice(offset + 4);
+
+      try {
+        // Use Utils.zlibInflate for zlib decompression
+        const decompressed = Utils.zlibInflate(compressedData);
+
+        if (decompressed.length !== uncompressedSize) {
+          Interpreter.raiseArgumentError(
+            Interpreter.buildArgumentErrorMsg(
+              1,
+              "invalid external representation of a term",
+            ),
+          );
+        }
+
+        const decompressedView = new DataView(
+          decompressed.buffer,
+          decompressed.byteOffset,
+          decompressed.byteLength,
+        );
+
+        return decodeTerm(decompressedView, decompressed, 0);
+      } catch {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+    };
+
     // Integer decoders
 
     const decodeSmallInteger = (dataView, offset) => {
@@ -939,8 +990,9 @@ const Erlang = {
         newOffset: currentOffset,
       };
     };
+    
     // Map decoder
-
+ 
     const decodeMap = (dataView, bytes, offset) => {
       const arity = dataView.getUint32(offset);
       const entries = [];
diff --git a/assets/js/utils.mjs b/assets/js/utils.mjs
index b13f732b6f..2ceda10506 100644
--- a/assets/js/utils.mjs
+++ b/assets/js/utils.mjs
@@ -1,5 +1,7 @@
 "use strict";
 
+import pako from "pako";
+
 export default class Utils {
   static capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
@@ -85,4 +87,11 @@ export default class Utils {
     // see benchmarks here: https://thecodebarbarian.com/object-assign-vs-object-spread.html
     return {...obj};
   }
+
+  // Decompresses zlib-compressed data using pako
+  // Returns a Uint8Array with the decompressed data
+  // Throws an error if decompression fails
+  static zlibInflate(compressedData) {
+    return pako.inflate(compressedData);
+  }
 }
diff --git a/assets/package-lock.json b/assets/package-lock.json
index b31d6a6390..44b7b53b11 100644
--- a/assets/package-lock.json
+++ b/assets/package-lock.json
@@ -8,6 +8,7 @@
         "@biomejs/biome": "^2",
         "esbuild": "^0.27",
         "lodash": "^4",
+        "pako": "^2",
         "snabbdom": "^3",
         "snabbdom-to-html": "^7"
       },
@@ -2474,6 +2475,12 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
+    "node_modules/pako": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
+      "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
diff --git a/assets/package.json b/assets/package.json
index 32af64f27e..1305efe842 100644
--- a/assets/package.json
+++ b/assets/package.json
@@ -3,6 +3,7 @@
     "@biomejs/biome": "^2",
     "esbuild": "^0.27",
     "lodash": "^4",
+    "pako": "^2",
     "snabbdom": "^3",
     "snabbdom-to-html": "^7"
   },
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index f455917513..c2c8b06bf6 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2218,6 +2218,66 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == term
     end
 
+    test "decodes compressed term (COMPRESSED tag 80) with repeated string" do
+      # Real Erlang-generated compressed term for String.duplicate("hello", 100)
+      # Generated with: :erlang.term_to_binary(String.duplicate("hello", 100), [compressed: 9])
+      binary =
+        <<131, 80, 0, 0, 1, 249, 120, 218, 203, 101, 96, 96, 252, 146, 145, 154, 147, 147, 63, 74,
+          140, 40, 2, 0, 21, 94, 209, 51>>
+
+      expected = String.duplicate("hello", 100)
+      assert :erlang.binary_to_term(binary) == expected
+    end
+
+    test "decodes compressed term with list of tuples" do
+      # Real Erlang-generated compressed term for a list of 50 identical tuples
+      # Generated with: :erlang.term_to_binary(List.duplicate({:ok, 42}, 50), [compressed: 9])
+      binary =
+        <<131, 80, 0, 0, 1, 150, 120, 218, 203, 97, 96, 96, 48, 202, 96, 42, 103, 202, 207, 78,
+          212, 26, 165, 7, 7, 157, 5, 0, 189, 136, 115, 25>>
+
+      expected = List.duplicate({:ok, 42}, 50)
+      assert :erlang.binary_to_term(binary) == expected
+    end
+
+    test "decodes compressed term round-trip" do
+      # Test that we can decode Erlang's compressed format
+      term = %{
+        data: List.duplicate({:item, "value", 123}, 100),
+        metadata: %{compressed: true, version: 1}
+      }
+
+      binary = :erlang.term_to_binary(term, compressed: 9)
+      assert :erlang.binary_to_term(binary) == term
+    end
+
+    test "raises ArgumentError for compressed term with truncated uncompressed size" do
+      # COMPRESSED tag but missing uncompressed size bytes
+      binary = <<131, 80, 0, 0>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
+    test "raises ArgumentError for compressed term with invalid zlib data" do
+      # COMPRESSED tag with invalid compressed data
+      binary = <<131, 80, 0, 0, 0, 2, 255, 255, 255>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
+    test "raises ArgumentError for compressed term with size mismatch" do
+      # COMPRESSED tag where decompressed size doesn't match declared size
+      binary = <<131, 80, 0, 0, 0, 10, 120, 156, 74, 180, 2, 0, 0, 121, 0, 121>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
     test "raises ArgumentError if argument is not a binary" do
       assert_error ArgumentError,
                    build_argument_error_msg(1, "not a binary"),
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 92b09b7223..286c946ab4 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -10,7 +10,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -1418,7 +1418,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1432,7 +1432,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1458,7 +1458,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(
@@ -3343,6 +3343,102 @@ describe("Erlang", () => {
       });
     });
 
+    describe("compressed terms", () => {
+      it("decodes compressed term (COMPRESSED tag 80) with repeated string", () => {
+        // Real Erlang-generated compressed term for String.duplicate("hello", 100)
+        // Generated with: :erlang.term_to_binary(String.duplicate("hello", 100), [compressed: 9])
+        // Format: 131 (version) + 80 (COMPRESSED) + uncompressed_size (4 bytes) + zlib compressed data
+        // Uncompressed size = 505 bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 80, 0, 0, 1, 249, 120, 218, 203, 101, 96, 96, 252, 146, 145,
+            154, 147, 147, 63, 74, 140, 40, 2, 0, 21, 94, 209, 51,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        const expected = Type.bitstring("hello".repeat(100));
+        assertBoxedStrictEqual(result, expected);
+      });
+
+      it("decodes compressed term with list of tuples", () => {
+        // Real Erlang-generated compressed term for a list of 50 identical tuples
+        // Generated with: :erlang.term_to_binary(List.duplicate({:ok, 42}, 50), [compressed: 9])
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 80, 0, 0, 1, 150, 120, 218, 203, 97, 96, 96, 48, 202, 96, 42,
+            103, 202, 207, 78, 212, 26, 165, 7, 7, 157, 5, 0, 189, 136, 115, 25,
+          ]),
+        );
+        const result = binary_to_term(binary);
+        const expectedTuple = Type.tuple([Type.atom("ok"), Type.integer(42)]);
+        const expectedList = Type.list(Array(50).fill(expectedTuple));
+        assertBoxedStrictEqual(result, expectedList);
+      });
+
+      it("raises ArgumentError for compressed term with truncated uncompressed size", () => {
+        // COMPRESSED tag but missing uncompressed size bytes
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([131, 80, 0, 0]), // Only 2 bytes of size instead of 4
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for compressed term with invalid zlib data", () => {
+        // COMPRESSED tag with invalid compressed data
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131,
+            80,
+            0,
+            0,
+            0,
+            2, // version, COMPRESSED tag, uncompressed size = 2
+            255,
+            255,
+            255, // invalid zlib data
+          ]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+
+      it("raises ArgumentError for compressed term with size mismatch", () => {
+        // COMPRESSED tag where decompressed size doesn't match declared size
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131,
+            80,
+            0,
+            0,
+            0,
+            10, // version, COMPRESSED tag, uncompressed size = 10 (wrong!)
+            120,
+            156,
+            74,
+            180,
+            2,
+            0,
+            0,
+            121,
+            0,
+            121, // zlib data that decompresses to 2 bytes
+          ]),
+        );
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+        );
+      });
+    });
+
     describe("error handling", () => {
       it("raises ArgumentError if argument is not a binary", () => {
         assertBoxedError(
@@ -3376,7 +3472,7 @@ describe("Erlang", () => {
         assertBoxedError(
           () => binary_to_term(binary),
           "ArgumentError",
-          "unsupported external term format tag: 50",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
@@ -3386,7 +3482,7 @@ describe("Erlang", () => {
         assertBoxedError(
           () => binary_to_term(binary),
           "ArgumentError",
-          "unsupported external term format tag: 255",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
@@ -3396,7 +3492,7 @@ describe("Erlang", () => {
         assertBoxedError(
           () => binary_to_term(binary),
           "ArgumentError",
-          "unsupported external term format tag: 1",
+          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
@@ -7263,7 +7359,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -7277,7 +7373,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -7303,7 +7399,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(

From ec735ac5d95451def7cf363e6258659ca70ac3ab Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Mon, 26 Jan 2026 20:56:44 -0300
Subject: [PATCH 19/33] chore: adjust large big ext test to use a value that
 generate a LARGE_BIG_EXT term.

---
 test/javascript/erlang/erlang_test.mjs | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 286c946ab4..bc7c6f857b 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -2808,13 +2808,22 @@ describe("Erlang", () => {
       });
 
       it("decodes large positive integer (LARGE_BIG_EXT)", () => {
-        // :erlang.term_to_binary(1000000000000) but manually crafted with LARGE_BIG_EXT tag
-        // Note: In practice, Erlang might use SMALL_BIG_EXT for this, but we test LARGE_BIG_EXT support
-        const binary = Bitstring.fromBytes(
-          new Uint8Array([131, 111, 0, 0, 0, 5, 0, 0, 16, 165, 212, 232]),
-        );
+        // 2^2048 requires 257 bytes (bit 2048 is in byte 256), which requires LARGE_BIG_EXT (SMALL_BIG_EXT max is 255 bytes)
+        // Format: [131, 111, length(4 bytes BE), sign(1 byte), data bytes(LE)]
+        const bytes = new Uint8Array(1 + 1 + 4 + 1 + 257);
+        bytes[0] = 131;
+        bytes[1] = 111;
+        bytes[2] = 0; // Length: 257 (0x00000101 in big-endian)
+        bytes[3] = 0;
+        bytes[4] = 1;
+        bytes[5] = 1;
+        bytes[6] = 0; // Sign: 0 (positive)
+        // 2^2048 in little-endian: byte 256 (index 7+256=263) has bit 0 set (0x01), all others are 0x00
+        bytes[263] = 1; // byte at index 7 + 256 = 263
+
+        const binary = Bitstring.fromBytes(bytes);
         const result = binary_to_term(binary);
-        assert.deepStrictEqual(result, Type.integer(1000000000000n));
+        assert.deepStrictEqual(result, Type.integer(2n ** 2048n));
       });
     });
 

From a06b2dfce75df765a783a8c9cb0e01bf40e5c065 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Mon, 26 Jan 2026 21:05:33 -0300
Subject: [PATCH 20/33] chore: added tests to FLOAT_EXT

---
 test/javascript/erlang/erlang_test.mjs | 89 +++++++++++++++++++++++++-
 1 file changed, 88 insertions(+), 1 deletion(-)

diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index bc7c6f857b..4fdc86220b 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3072,7 +3072,7 @@ describe("Erlang", () => {
         );
       });
     });
-
+    
     describe("floats", () => {
       it("decodes NEW_FLOAT_EXT (IEEE 754 double)", () => {
         // :erlang.term_to_binary(3.14159) with NEW_FLOAT_EXT tag
@@ -3100,6 +3100,93 @@ describe("Erlang", () => {
         const result = binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(0.0));
       });
+
+      it("decodes FLOAT_EXT (deprecated 31-byte string format) for positive float", () => {
+        // FLOAT_EXT: tag 99, followed by 31 bytes (null-terminated string)
+        // Encoding 3.14159 as "3.14159000000000000000e+00" (31 bytes with null padding)
+        const floatStr = "3.14159000000000000000e+00";
+        const bytes = new Uint8Array(33);
+        bytes[0] = 131; // ETF version
+        bytes[1] = 99; // FLOAT_EXT tag
+        for (let i = 0; i < floatStr.length; i++) {
+          bytes[2 + i] = floatStr.charCodeAt(i);
+        }
+        // Remaining bytes are 0 (null padding)
+        const binary = Bitstring.fromBytes(bytes);
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(3.14159));
+      });
+
+      it("decodes FLOAT_EXT for negative float", () => {
+        // Encoding -2.5 as "-2.50000000000000000000e+00"
+        const floatStr = "-2.50000000000000000000e+00";
+        const bytes = new Uint8Array(33);
+        bytes[0] = 131;
+        bytes[1] = 99;
+        for (let i = 0; i < floatStr.length; i++) {
+          bytes[2 + i] = floatStr.charCodeAt(i);
+        }
+        const binary = Bitstring.fromBytes(bytes);
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(-2.5));
+      });
+
+      it("decodes FLOAT_EXT for zero", () => {
+        // Encoding 0.0 as "0.00000000000000000000e+00"
+        const floatStr = "0.00000000000000000000e+00";
+        const bytes = new Uint8Array(33);
+        bytes[0] = 131;
+        bytes[1] = 99;
+        for (let i = 0; i < floatStr.length; i++) {
+          bytes[2 + i] = floatStr.charCodeAt(i);
+        }
+        const binary = Bitstring.fromBytes(bytes);
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(0.0));
+      });
+
+      it("decodes FLOAT_EXT with shorter string (null-terminated)", () => {
+        // Encoding 1.5 as "1.5" with null termination
+        const floatStr = "1.5";
+        const bytes = new Uint8Array(33);
+        bytes[0] = 131;
+        bytes[1] = 99;
+        for (let i = 0; i < floatStr.length; i++) {
+          bytes[2 + i] = floatStr.charCodeAt(i);
+        }
+        bytes[2 + floatStr.length] = 0; // null terminator
+        // Remaining bytes are already 0
+        const binary = Bitstring.fromBytes(bytes);
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(1.5));
+      });
+
+      it("decodes FLOAT_EXT with negative exponent", () => {
+        // Encoding 0.00625 as "6.25000000000000000000e-03"
+        const floatStr = "6.25000000000000000000e-03";
+        const bytes = new Uint8Array(33);
+        bytes[0] = 131;
+        bytes[1] = 99;
+        for (let i = 0; i < floatStr.length; i++) {
+          bytes[2 + i] = floatStr.charCodeAt(i);
+        }
+        const binary = Bitstring.fromBytes(bytes);
+        const result = binary_to_term(binary);
+        assert.deepStrictEqual(result, Type.float(0.00625));
+      });
+
+      it("raises ArgumentError for FLOAT_EXT with truncated data", () => {
+        // Only 10 bytes after tag instead of 31
+        const bytes = new Uint8Array([
+          131, 99, 49, 46, 50, 51, 0, 0, 0, 0, 0, 0,
+        ]);
+        const binary = Bitstring.fromBytes(bytes);
+        assertBoxedError(
+          () => binary_to_term(binary),
+          "ArgumentError",
+          "float string exceeds available bytes",
+        );
+      });
     });
 
     describe("bitstrings", () => {

From 19d4a3cf1abe6de6131dac56589abdeebf15b7d6 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 27 Jan 2026 02:31:21 -0300
Subject: [PATCH 21/33] chore: add peer flags

---
 assets/js/erlang/erlang.mjs                     |  4 ++--
 test/elixir/hologram/template/renderer_test.exs | 12 ++++++------
 test/javascript/erlang/erlang_test.mjs          | 16 ++++++++--------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index c9a316761f..2c5f63b687 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -990,9 +990,9 @@ const Erlang = {
         newOffset: currentOffset,
       };
     };
-    
+
     // Map decoder
- 
+
     const decodeMap = (dataView, bytes, offset) => {
       const arity = dataView.getUint32(offset);
       const entries = [];
diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 14f61e9c45..1f1903371d 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module25, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module27, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module24, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 4fdc86220b..0b99c2fbbe 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -10,7 +10,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -1418,7 +1418,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1432,7 +1432,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1458,7 +1458,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(
@@ -3072,7 +3072,7 @@ describe("Erlang", () => {
         );
       });
     });
-    
+
     describe("floats", () => {
       it("decodes NEW_FLOAT_EXT (IEEE 754 double)", () => {
         // :erlang.term_to_binary(3.14159) with NEW_FLOAT_EXT tag
@@ -7455,7 +7455,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7469,7 +7469,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7495,7 +7495,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(

From 9f7fc5789dc55208801a7a5dc408206ff86531c7 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 01:48:05 -0300
Subject: [PATCH 22/33] wip: add compressed term and updated needed tests and
 functions

---
 assets/js/erlang/erlang.mjs                   | 103 +++++++++---------
 assets/js/utils.mjs                           |  44 ++++++--
 assets/package-lock.json                      |   7 --
 assets/package.json                           |   1 -
 .../ex_js_consistency/erlang/erlang_test.exs  |  11 +-
 .../compiler/transformer/module_109.ex        |   2 +-
 test/javascript/erlang/erlang_test.mjs        |   4 +-
 test/javascript/utils_test.mjs                |  74 +++++++++++++
 8 files changed, 178 insertions(+), 68 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 2c5f63b687..a6e332d070 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -600,7 +600,7 @@ const Erlang = {
   // Deps: []
 
   // Start binary_to_term/1
-  "binary_to_term/1": (binary) => {
+  "binary_to_term/1": async (binary) => {
     if (!Type.isBinary(binary)) {
       Interpreter.raiseArgumentError(
         Interpreter.buildArgumentErrorMsg(1, "not a binary"),
@@ -636,7 +636,7 @@ const Erlang = {
     const SMALL_ATOM_UTF8_EXT = 119;
     const V4_PORT_EXT = 120;
 
-    const decodeTerm = (dataView, bytes, offset) => {
+    const decodeTerm = async (dataView, bytes, offset) => {
       if (offset >= bytes.length) {
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
@@ -650,7 +650,7 @@ const Erlang = {
 
       switch (tag) {
         case COMPRESSED:
-          return decodeCompressed(dataView, bytes, offset + 1);
+          return await decodeCompressed(dataView, bytes, offset + 1);
 
         case SMALL_INTEGER_EXT:
           return decodeSmallInteger(dataView, offset + 1);
@@ -680,10 +680,10 @@ const Erlang = {
           return decodeBinary(dataView, bytes, offset + 1);
 
         case SMALL_TUPLE_EXT:
-          return decodeSmallTuple(dataView, bytes, offset + 1);
+          return await decodeSmallTuple(dataView, bytes, offset + 1);
 
         case LARGE_TUPLE_EXT:
-          return decodeLargeTuple(dataView, bytes, offset + 1);
+          return await decodeLargeTuple(dataView, bytes, offset + 1);
 
         case NIL_EXT:
           return {term: Type.list(), newOffset: offset + 1};
@@ -692,10 +692,10 @@ const Erlang = {
           return decodeString(dataView, bytes, offset + 1);
 
         case LIST_EXT:
-          return decodeList(dataView, bytes, offset + 1);
+          return await decodeList(dataView, bytes, offset + 1);
 
         case MAP_EXT:
-          return decodeMap(dataView, bytes, offset + 1);
+          return await decodeMap(dataView, bytes, offset + 1);
 
         case NEW_FLOAT_EXT:
           return decodeNewFloat(dataView, offset + 1);
@@ -707,28 +707,28 @@ const Erlang = {
           return decodeBitBinary(dataView, bytes, offset + 1);
 
         case NEW_REFERENCE_EXT:
-          return decodeNewReference(dataView, bytes, offset + 1);
+          return await decodeNewReference(dataView, bytes, offset + 1);
 
         case NEWER_REFERENCE_EXT:
-          return decodeNewerReference(dataView, bytes, offset + 1);
+          return await decodeNewerReference(dataView, bytes, offset + 1);
 
         case PID_EXT:
-          return decodePid(dataView, bytes, offset + 1);
+          return await decodePid(dataView, bytes, offset + 1);
 
         case NEW_PID_EXT:
-          return decodeNewPid(dataView, bytes, offset + 1);
+          return await decodeNewPid(dataView, bytes, offset + 1);
 
         case PORT_EXT:
-          return decodePort(dataView, bytes, offset + 1);
+          return await decodePort(dataView, bytes, offset + 1);
 
         case NEW_PORT_EXT:
-          return decodeNewPort(dataView, bytes, offset + 1);
+          return await decodeNewPort(dataView, bytes, offset + 1);
 
         case V4_PORT_EXT:
-          return decodeV4Port(dataView, bytes, offset + 1);
+          return await decodeV4Port(dataView, bytes, offset + 1);
 
         case EXPORT_EXT:
-          return decodeExport(dataView, bytes, offset + 1);
+          return await decodeExport(dataView, bytes, offset + 1);
 
         default:
           Interpreter.raiseArgumentError(
@@ -744,7 +744,7 @@ const Erlang = {
     // Format: COMPRESSED (80) | UncompressedSize (4 bytes, big-endian) | ZlibCompressedData
     // The decompressed data contains the ETF representation of the term without the version byte
 
-    const decodeCompressed = (dataView, bytes, offset) => {
+    const decodeCompressed = async (dataView, bytes, offset) => {
       if (offset + 4 > bytes.length) {
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
@@ -758,8 +758,8 @@ const Erlang = {
       const compressedData = bytes.slice(offset + 4);
 
       try {
-        // Use Utils.zlibInflate for zlib decompression
-        const decompressed = Utils.zlibInflate(compressedData);
+        // Use native DecompressionStream for zlib decompression
+        const decompressed = await Utils.zlibInflate(compressedData);
 
         if (decompressed.length !== uncompressedSize) {
           Interpreter.raiseArgumentError(
@@ -776,8 +776,9 @@ const Erlang = {
           decompressed.byteLength,
         );
 
-        return decodeTerm(decompressedView, decompressed, 0);
-      } catch {
+        return await decodeTerm(decompressedView, decompressed, 0);
+      } catch (error) {
+        console.error("Decode error:", error);
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
             1,
@@ -903,13 +904,13 @@ const Erlang = {
 
     // Tuple decoders
 
-    const decodeSmallTuple = (dataView, bytes, offset) => {
+    const decodeSmallTuple = async (dataView, bytes, offset) => {
       const arity = dataView.getUint8(offset);
       const elements = [];
       let currentOffset = offset + 1;
 
       for (let i = 0; i < arity; i++) {
-        const result = decodeTerm(dataView, bytes, currentOffset);
+        const result = await decodeTerm(dataView, bytes, currentOffset);
         elements.push(result.term);
         currentOffset = result.newOffset;
       }
@@ -920,13 +921,13 @@ const Erlang = {
       };
     };
 
-    const decodeLargeTuple = (dataView, bytes, offset) => {
+    const decodeLargeTuple = async (dataView, bytes, offset) => {
       const arity = dataView.getUint32(offset);
       const elements = [];
       let currentOffset = offset + 4;
 
       for (let i = 0; i < arity; i++) {
-        const result = decodeTerm(dataView, bytes, currentOffset);
+        const result = await decodeTerm(dataView, bytes, currentOffset);
         elements.push(result.term);
         currentOffset = result.newOffset;
       }
@@ -959,19 +960,19 @@ const Erlang = {
       };
     };
 
-    const decodeList = (dataView, bytes, offset) => {
+    const decodeList = async (dataView, bytes, offset) => {
       const length = dataView.getUint32(offset);
       const elements = [];
       let currentOffset = offset + 4;
 
       for (let i = 0; i < length; i++) {
-        const result = decodeTerm(dataView, bytes, currentOffset);
+        const result = await decodeTerm(dataView, bytes, currentOffset);
         elements.push(result.term);
         currentOffset = result.newOffset;
       }
 
       // Decode the tail
-      const tailResult = decodeTerm(dataView, bytes, currentOffset);
+      const tailResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = tailResult.newOffset;
 
       // If tail is a list, merge it to preserve proper list semantics
@@ -993,14 +994,18 @@ const Erlang = {
 
     // Map decoder
 
-    const decodeMap = (dataView, bytes, offset) => {
+    const decodeMap = async (dataView, bytes, offset) => {
       const arity = dataView.getUint32(offset);
       const entries = [];
       let currentOffset = offset + 4;
 
       for (let i = 0; i < arity; i++) {
-        const keyResult = decodeTerm(dataView, bytes, currentOffset);
-        const valueResult = decodeTerm(dataView, bytes, keyResult.newOffset);
+        const keyResult = await decodeTerm(dataView, bytes, currentOffset);
+        const valueResult = await decodeTerm(
+          dataView,
+          bytes,
+          keyResult.newOffset,
+        );
 
         entries.push([keyResult.term, valueResult.term]);
         currentOffset = valueResult.newOffset;
@@ -1069,12 +1074,12 @@ const Erlang = {
 
     // Reference decoders
 
-    const decodeNewReference = (dataView, bytes, offset) => {
+    const decodeNewReference = async (dataView, bytes, offset) => {
       const len = dataView.getUint16(offset);
       let currentOffset = offset + 2;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       const creation = dataView.getUint8(currentOffset);
@@ -1092,12 +1097,12 @@ const Erlang = {
       };
     };
 
-    const decodeNewerReference = (dataView, bytes, offset) => {
+    const decodeNewerReference = async (dataView, bytes, offset) => {
       const len = dataView.getUint16(offset);
       let currentOffset = offset + 2;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       const creation = dataView.getUint32(currentOffset);
@@ -1117,11 +1122,11 @@ const Erlang = {
 
     // PID decoders
 
-    const decodePid = (dataView, bytes, offset) => {
+    const decodePid = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       // Read ID (4 bytes), Serial (4 bytes), Creation (1 byte)
@@ -1140,11 +1145,11 @@ const Erlang = {
       };
     };
 
-    const decodeNewPid = (dataView, bytes, offset) => {
+    const decodeNewPid = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       // Read ID (4 bytes), Serial (4 bytes), Creation (4 bytes)
@@ -1165,11 +1170,11 @@ const Erlang = {
 
     // Port decoders
 
-    const decodePort = (dataView, bytes, offset) => {
+    const decodePort = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       // Read ID (4 bytes), Creation (1 byte)
@@ -1185,11 +1190,11 @@ const Erlang = {
       };
     };
 
-    const decodeNewPort = (dataView, bytes, offset) => {
+    const decodeNewPort = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       // Read ID (4 bytes), Creation (4 bytes)
@@ -1205,11 +1210,11 @@ const Erlang = {
       };
     };
 
-    const decodeV4Port = (dataView, bytes, offset) => {
+    const decodeV4Port = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode node name (atom)
-      const nodeResult = decodeTerm(dataView, bytes, currentOffset);
+      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
       // Read ID (8 bytes as BigUint64), Creation (4 bytes)
@@ -1226,19 +1231,19 @@ const Erlang = {
     };
 
     // EXPORT_EXT decoder (function capture)
-    const decodeExport = (dataView, bytes, offset) => {
+    const decodeExport = async (dataView, bytes, offset) => {
       let currentOffset = offset;
 
       // Decode module (atom)
-      const moduleResult = decodeTerm(dataView, bytes, currentOffset);
+      const moduleResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = moduleResult.newOffset;
 
       // Decode function (atom)
-      const functionResult = decodeTerm(dataView, bytes, currentOffset);
+      const functionResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = functionResult.newOffset;
 
       // Decode arity (small integer)
-      const arityResult = decodeTerm(dataView, bytes, currentOffset);
+      const arityResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = arityResult.newOffset;
 
       const context = Interpreter.buildContext();
@@ -1278,7 +1283,7 @@ const Erlang = {
         );
       }
 
-      const result = decodeTerm(dataView, bytes, 1);
+      const result = await decodeTerm(dataView, bytes, 1);
       return result.term;
     } catch (err) {
       if (err instanceof RangeError || err instanceof TypeError) {
diff --git a/assets/js/utils.mjs b/assets/js/utils.mjs
index 2ceda10506..349b9c74c0 100644
--- a/assets/js/utils.mjs
+++ b/assets/js/utils.mjs
@@ -1,7 +1,5 @@
 "use strict";
 
-import pako from "pako";
-
 export default class Utils {
   static capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
@@ -88,10 +86,42 @@ export default class Utils {
     return {...obj};
   }
 
-  // Decompresses zlib-compressed data using pako
-  // Returns a Uint8Array with the decompressed data
-  // Throws an error if decompression fails
-  static zlibInflate(compressedData) {
-    return pako.inflate(compressedData);
+  // Decompresses zlib-compressed data using native DecompressionStream API
+  // Returns a Promise that resolves to a Uint8Array with the decompressed data
+  // Throws an error if decompression fai
+  static async zlibInflate(compressedData) {
+    const stream = new ReadableStream({
+      start(controller) {
+        // Ensure we are passing a standard Uint8Array to the stream
+        // This solves the Buffer/Uint8Array mismatch in Node.js
+        const data =
+          compressedData instanceof Uint8Array
+            ? compressedData
+            : new Uint8Array(compressedData);
+
+        controller.enqueue(data);
+        controller.close();
+      },
+    });
+
+    const decompressedStream = stream.pipeThrough(
+      new DecompressionStream("deflate"),
+    );
+
+    const reader = decompressedStream.getReader();
+    const chunks = [];
+
+    try {
+      while (true) {
+        const {done, value} = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+    } catch (err) {
+      // In Node, stream errors often need to be caught during the read loop
+      throw new Error(`Decompression failed: ${err.message}`);
+    }
+
+    return this.concatUint8Arrays(chunks);
   }
 }
diff --git a/assets/package-lock.json b/assets/package-lock.json
index 44b7b53b11..b31d6a6390 100644
--- a/assets/package-lock.json
+++ b/assets/package-lock.json
@@ -8,7 +8,6 @@
         "@biomejs/biome": "^2",
         "esbuild": "^0.27",
         "lodash": "^4",
-        "pako": "^2",
         "snabbdom": "^3",
         "snabbdom-to-html": "^7"
       },
@@ -2475,12 +2474,6 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
-    "node_modules/pako": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
-      "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==",
-      "license": "(MIT AND Zlib)"
-    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
diff --git a/assets/package.json b/assets/package.json
index 1305efe842..32af64f27e 100644
--- a/assets/package.json
+++ b/assets/package.json
@@ -3,7 +3,6 @@
     "@biomejs/biome": "^2",
     "esbuild": "^0.27",
     "lodash": "^4",
-    "pako": "^2",
     "snabbdom": "^3",
     "snabbdom-to-html": "^7"
   },
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index c2c8b06bf6..b11677fd23 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2109,7 +2109,16 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       binary = :erlang.term_to_binary(0.0)
       assert :erlang.binary_to_term(binary) == 0.0
     end
-
+    
+    test "decodes FLOAT_EXT (deprecated string format)" do
+      # Manually construct FLOAT_EXT binary
+      float_str = :io_lib.format("~.20e", [1.5]) |> IO.iodata_to_binary()
+      padded = String.pad_trailing(float_str, 31, <<0>>)
+      binary = <<131, 99, padded::binary>>
+    
+      assert :erlang.binary_to_term(binary) == 1.5
+    end
+    
     test "decodes BIT_BINARY_EXT with partial byte" do
       # Bitstring with 5 bits
       bitstring = <<1::5>>
diff --git a/test/elixir/support/fixtures/compiler/transformer/module_109.ex b/test/elixir/support/fixtures/compiler/transformer/module_109.ex
index 192af48982..4c4970eff4 100644
--- a/test/elixir/support/fixtures/compiler/transformer/module_109.ex
+++ b/test/elixir/support/fixtures/compiler/transformer/module_109.ex
@@ -4,7 +4,7 @@ defmodule Hologram.Test.Fixtures.Compiler.Tranformer.Module109 do
 
   defstruct [:a, :b]
 
-  def test(%Module109{} = x) do
+  def test(x) do
     %Module109{x | a: 1, b: 2}
   end
 end
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 0b99c2fbbe..f8f1cf80b6 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3456,7 +3456,7 @@ describe("Erlang", () => {
         assertBoxedStrictEqual(result, expected);
       });
 
-      it("decodes compressed term with list of tuples", () => {
+      it("decodes compressed term with list of tuples", async () => {
         // Real Erlang-generated compressed term for a list of 50 identical tuples
         // Generated with: :erlang.term_to_binary(List.duplicate({:ok, 42}, 50), [compressed: 9])
         const binary = Bitstring.fromBytes(
@@ -3465,7 +3465,7 @@ describe("Erlang", () => {
             103, 202, 207, 78, 212, 26, 165, 7, 7, 157, 5, 0, 189, 136, 115, 25,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         const expectedTuple = Type.tuple([Type.atom("ok"), Type.integer(42)]);
         const expectedList = Type.list(Array(50).fill(expectedTuple));
         assertBoxedStrictEqual(result, expectedList);
diff --git a/test/javascript/utils_test.mjs b/test/javascript/utils_test.mjs
index 48bc25df6c..d9b9289055 100644
--- a/test/javascript/utils_test.mjs
+++ b/test/javascript/utils_test.mjs
@@ -196,4 +196,78 @@ describe("Utils", () => {
     assert.deepStrictEqual(obj, {a: 1, b: {c: 30, d: 4}});
     assert.deepStrictEqual(clone, {a: 10, b: {c: 30, d: 4}});
   });
+
+  describe("Utils.zlibInflate", () => {
+    // Test 1: Your original test, but verifying content, not just length
+    it("should decompress a known valid zlib buffer correctly", async () => {
+      const compressedData = new Uint8Array([
+        120, 218, 203, 101, 96, 96, 252, 146, 145, 154, 147, 147, 63, 74, 140,
+        40, 2, 0, 21, 94, 209, 51,
+      ]);
+      const expectedSize = 505;
+
+      const decompressed = await Utils.zlibInflate(compressedData);
+
+      assert.strictEqual(decompressed.length, expectedSize);
+
+      // 109 is 'm'. Let's verify the first few bytes to be sure.
+      assert.strictEqual(decompressed[0], 109);
+
+      // Optional: Convert to string to see what's actually inside
+      // const text = new TextDecoder().decode(decompressed);
+      // console.log("Decompressed content sample:", text.substring(0, 20));
+    });
+
+    // Test 2: Empty Data (Zlib header for an empty string)
+    it("should handle an empty compressed string", async () => {
+      const emptyZlib = new Uint8Array([120, 156, 3, 0, 0, 0, 0, 1]);
+      const decompressed = await Utils.zlibInflate(emptyZlib);
+
+      assert.strictEqual(decompressed.length, 0);
+    });
+
+    // Test 3: Large Data (Testing the chunking logic)
+    it("should decompress larger datasets that require multiple chunks", async () => {
+      const originalString = "hello world ".repeat(1000);
+      const encoder = new TextEncoder();
+      const data = encoder.encode(originalString);
+
+      // We use CompressionStream to generate the test data dynamically
+      const cs = new CompressionStream("deflate");
+      const writer = cs.writable.getWriter();
+      writer.write(data);
+      writer.close();
+
+      const compressedResponse = await new Response(cs.readable).arrayBuffer();
+      const compressedUint8 = new Uint8Array(compressedResponse);
+
+      const result = await Utils.zlibInflate(compressedUint8);
+      const resultString = new TextDecoder().decode(result);
+
+      assert.strictEqual(resultString, originalString);
+      assert.strictEqual(result.length, data.length);
+    });
+
+    // Test 4: Error Handling (Corrupt Data)
+    it("should throw an error when given invalid/corrupt data", async () => {
+      const corruptData = new Uint8Array([0, 1, 2, 3, 4, 5]); // Not a valid zlib stream
+
+      try {
+        await Utils.zlibInflate(corruptData);
+        assert.fail("Should have thrown a decompression error");
+      } catch (e) {
+        // DecompressionStream throws a TypeError or DOMException on failure
+        assert.ok(e instanceof Error);
+      }
+    });
+
+    // Test 5: Type Safety
+    it("should handle input as a Buffer or Uint8Array interchangeably", async () => {
+      // Small valid zlib: "hi"
+      const input = new Uint8Array([120, 156, 203, 200, 4, 0, 1, 43, 0, 201]);
+      const decompressed = await Utils.zlibInflate(input);
+
+      assert.strictEqual(new TextDecoder().decode(decompressed), "hi");
+    });
+  });
 });

From d383a67779ff564df323ca56b92c3d641fd46a97 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 12:53:14 -0300
Subject: [PATCH 23/33] chore: adjusted tests to handle async.

- Create async assertBoxedErrorAsync function.
---
 .../ex_js_consistency/erlang/erlang_test.exs  |   6 +-
 test/javascript/erlang/erlang_test.mjs        | 289 +++++++++---------
 test/javascript/support/helpers.mjs           |  51 ++++
 test/javascript/utils_test.mjs                |   2 +-
 4 files changed, 200 insertions(+), 148 deletions(-)

diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index b11677fd23..f6b3436cb1 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2109,16 +2109,16 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       binary = :erlang.term_to_binary(0.0)
       assert :erlang.binary_to_term(binary) == 0.0
     end
-    
+
     test "decodes FLOAT_EXT (deprecated string format)" do
       # Manually construct FLOAT_EXT binary
       float_str = :io_lib.format("~.20e", [1.5]) |> IO.iodata_to_binary()
       padded = String.pad_trailing(float_str, 31, <<0>>)
       binary = <<131, 99, padded::binary>>
-    
+
       assert :erlang.binary_to_term(binary) == 1.5
     end
-    
+
     test "decodes BIT_BINARY_EXT with partial byte" do
       # Bitstring with 5 bits
       bitstring = <<1::5>>
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index f8f1cf80b6..9ef362e2bd 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3,6 +3,7 @@
 import {
   assert,
   assertBoxedError,
+  assertBoxedErrorAsync,
   assertBoxedFalse,
   assertBoxedStrictEqual,
   assertBoxedTrue,
@@ -2757,57 +2758,57 @@ describe("Erlang", () => {
     const binary_to_term = Erlang["binary_to_term/1"];
 
     describe("integers", () => {
-      it("decodes small positive integer (SMALL_INTEGER_EXT)", () => {
+      it("decodes small positive integer (SMALL_INTEGER_EXT)", async () => {
         // :erlang.term_to_binary(42) = <<131, 97, 42>>
         const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 42]));
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(42));
       });
 
-      it("decodes small positive integer (max value 255)", () => {
+      it("decodes small positive integer (max value 255)", async () => {
         // :erlang.term_to_binary(255) = <<131, 97, 255>>
         const binary = Bitstring.fromBytes(new Uint8Array([131, 97, 255]));
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(255));
       });
 
-      it("decodes positive integer (INTEGER_EXT)", () => {
+      it("decodes positive integer (INTEGER_EXT)", async () => {
         // :erlang.term_to_binary(1000) = <<131, 98, 0, 0, 3, 232>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 98, 0, 0, 3, 232]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(1000));
       });
 
-      it("decodes negative integer (INTEGER_EXT)", () => {
+      it("decodes negative integer (INTEGER_EXT)", async () => {
         // :erlang.term_to_binary(-100) = <<131, 98, 255, 255, 255, 156>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 98, 255, 255, 255, 156]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(-100));
       });
 
-      it("decodes large positive integer (SMALL_BIG_EXT)", () => {
+      it("decodes large positive integer (SMALL_BIG_EXT)", async () => {
         // :erlang.term_to_binary(1000000000000) = <<131, 110, 5, 0, 0, 16, 165, 212, 232>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 110, 5, 0, 0, 16, 165, 212, 232]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(1000000000000n));
       });
 
-      it("decodes large negative integer (SMALL_BIG_EXT)", () => {
+      it("decodes large negative integer (SMALL_BIG_EXT)", async () => {
         // :erlang.term_to_binary(-1000000000000) = <<131, 110, 5, 1, 0, 16, 165, 212, 232>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 110, 5, 1, 0, 16, 165, 212, 232]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(-1000000000000n));
       });
 
-      it("decodes large positive integer (LARGE_BIG_EXT)", () => {
+      it("decodes large positive integer (LARGE_BIG_EXT)", async () => {
         // 2^2048 requires 257 bytes (bit 2048 is in byte 256), which requires LARGE_BIG_EXT (SMALL_BIG_EXT max is 255 bytes)
         // Format: [131, 111, length(4 bytes BE), sign(1 byte), data bytes(LE)]
         const bytes = new Uint8Array(1 + 1 + 4 + 1 + 257);
@@ -2822,13 +2823,13 @@ describe("Erlang", () => {
         bytes[263] = 1; // byte at index 7 + 256 = 263
 
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.integer(2n ** 2048n));
       });
     });
 
     describe("atoms", () => {
-      it("decodes atom UTF-8 (ATOM_UTF8_EXT)", () => {
+      it("decodes atom UTF-8 (ATOM_UTF8_EXT)", async () => {
         // élixir as UTF-8 atom using ATOM_UTF8_EXT (tag 118)
         const name = "élixir";
         const nameBytes = new TextEncoder().encode(name);
@@ -2838,20 +2839,20 @@ describe("Erlang", () => {
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 118, lengthHigh, lengthLow, ...nameBytes]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom(name));
       });
 
-      it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", () => {
+      it("decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)", async () => {
         // :erlang.term_to_binary(:test) = <<131, 119, 4, 116, 101, 115, 116>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 4, 116, 101, 115, 116]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom("test"));
       });
 
-      it("decodes atom (ATOM_EXT)", () => {
+      it("decodes atom (ATOM_EXT)", async () => {
         // elixir as Latin-1 atom using ATOM_EXT (tag 100)
         const name = "elixir";
         const nameBytes = new TextEncoder().encode(name);
@@ -2861,85 +2862,85 @@ describe("Erlang", () => {
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 100, lengthHigh, lengthLow, ...nameBytes]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom(name));
       });
 
-      it("decodes small atom (SMALL_ATOM_EXT)", () => {
+      it("decodes small atom (SMALL_ATOM_EXT)", async () => {
         // elixir as Latin-1 atom using SMALL_ATOM_EXT (tag 115)
         const name = "elixir";
         const nameBytes = new TextEncoder().encode(name);
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 115, nameBytes.length, ...nameBytes]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom(name));
       });
 
-      it("decodes longer atom", () => {
+      it("decodes longer atom", async () => {
         // :erlang.term_to_binary(:test_atom) = <<131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([
             131, 119, 9, 116, 101, 115, 116, 95, 97, 116, 111, 109,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom("test_atom"));
       });
 
-      it("decodes true atom", () => {
+      it("decodes true atom", async () => {
         // :erlang.term_to_binary(true) = <<131, 119, 4, 116, 114, 117, 101>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 4, 116, 114, 117, 101]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom("true"));
       });
 
-      it("decodes false atom", () => {
+      it("decodes false atom", async () => {
         // :erlang.term_to_binary(false) = <<131, 119, 5, 102, 97, 108, 115, 101>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 5, 102, 97, 108, 115, 101]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.atom("false"));
       });
     });
 
     describe("binaries", () => {
-      it("decodes binary string (BINARY_EXT)", () => {
+      it("decodes binary string (BINARY_EXT)", async () => {
         // :erlang.term_to_binary("hello") = <<131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 109, 0, 0, 0, 5, 104, 101, 108, 108, 111]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assertBoxedStrictEqual(result, Type.bitstring("hello"));
       });
 
-      it("decodes empty binary", () => {
+      it("decodes empty binary", async () => {
         // :erlang.term_to_binary("") = <<131, 109, 0, 0, 0, 0>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 109, 0, 0, 0, 0]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assertBoxedStrictEqual(result, Type.bitstring(""));
       });
     });
 
     describe("tuples", () => {
-      it("decodes small tuple (SMALL_TUPLE_EXT)", () => {
+      it("decodes small tuple (SMALL_TUPLE_EXT)", async () => {
         // :erlang.term_to_binary({1, 2, 3}) = <<131, 104, 3, 97, 1, 97, 2, 97, 3>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 104, 3, 97, 1, 97, 2, 97, 3]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.tuple([Type.integer(1), Type.integer(2), Type.integer(3)]),
         );
       });
 
-      it("decodes large tuple (LARGE_TUPLE_EXT)", () => {
+      it("decodes large tuple (LARGE_TUPLE_EXT)", async () => {
         // Create a tuple with 300 elements using LARGE_TUPLE_EXT (tag 105)
         const arity = 300;
         // Header: version (131) + LARGE_TUPLE_EXT tag (105) + arity as 32-bit big-endian
@@ -2961,26 +2962,26 @@ describe("Erlang", () => {
         const binary = Bitstring.fromBytes(
           new Uint8Array([...header, ...elementBytes]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
 
         assert.strictEqual(Type.isTuple(result), true);
         assert.strictEqual(result.data.length, arity);
         assert.deepStrictEqual(result.data[0], Type.integer(1));
       });
 
-      it("decodes empty tuple", () => {
+      it("decodes empty tuple", async () => {
         // :erlang.term_to_binary({}) = <<131, 104, 0>>
         const binary = Bitstring.fromBytes(new Uint8Array([131, 104, 0]));
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.tuple([]));
       });
 
-      it("decodes nested tuple", () => {
+      it("decodes nested tuple", async () => {
         // :erlang.term_to_binary({1, {2, 3}}) = <<131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 104, 2, 97, 1, 104, 2, 97, 2, 97, 3]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.tuple([
@@ -2992,26 +2993,26 @@ describe("Erlang", () => {
     });
 
     describe("lists", () => {
-      it("decodes empty list (NIL_EXT)", () => {
+      it("decodes empty list (NIL_EXT)", async () => {
         // :erlang.term_to_binary([]) = <<131, 106>>
         const binary = Bitstring.fromBytes(new Uint8Array([131, 106]));
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.list([]));
       });
 
-      it("decodes string list (STRING_EXT)", () => {
+      it("decodes string list (STRING_EXT)", async () => {
         // :erlang.term_to_binary([1, 2, 3]) = <<131, 107, 0, 3, 1, 2, 3>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 107, 0, 3, 1, 2, 3]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.list([Type.integer(1), Type.integer(2), Type.integer(3)]),
         );
       });
 
-      it("decodes proper list (LIST_EXT)", () => {
+      it("decodes proper list (LIST_EXT)", async () => {
         // :erlang.term_to_binary([100, 200, 300]) = <<131, 108, 0, 0, 0, 3, 97, 100, 98, 0, 0, 0, 200, 98, 0, 0, 1, 44, 106>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([
@@ -3019,20 +3020,20 @@ describe("Erlang", () => {
             106,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.list([Type.integer(100), Type.integer(200), Type.integer(300)]),
         );
       });
 
-      it("decodes improper list (LIST_EXT)", () => {
+      it("decodes improper list (LIST_EXT)", async () => {
         // :erlang.term_to_binary([1 | [2 | [3 | 4]]]) - improper list
         // The tail is 4 instead of empty list (NIL_EXT)
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 108, 0, 0, 0, 3, 97, 1, 97, 2, 97, 3, 97, 4]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.improperList([
@@ -3046,23 +3047,23 @@ describe("Erlang", () => {
     });
 
     describe("maps", () => {
-      it("decodes empty map", () => {
+      it("decodes empty map", async () => {
         // :erlang.term_to_binary(%{}) = <<131, 116, 0, 0, 0, 0>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 116, 0, 0, 0, 0]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.map([]));
       });
 
-      it("decodes map with atom keys", () => {
+      it("decodes map with atom keys", async () => {
         // :erlang.term_to_binary(%{a: 1, b: 2}) = <<131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([
             131, 116, 0, 0, 0, 2, 119, 1, 97, 97, 1, 119, 1, 98, 97, 2,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(
           result,
           Type.map([
@@ -3074,34 +3075,34 @@ describe("Erlang", () => {
     });
 
     describe("floats", () => {
-      it("decodes NEW_FLOAT_EXT (IEEE 754 double)", () => {
+      it("decodes NEW_FLOAT_EXT (IEEE 754 double)", async () => {
         // :erlang.term_to_binary(3.14159) with NEW_FLOAT_EXT tag
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 70, 64, 9, 33, 249, 240, 27, 134, 110]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(3.14159));
       });
 
-      it("decodes NEW_FLOAT_EXT for negative float", () => {
+      it("decodes NEW_FLOAT_EXT for negative float", async () => {
         // :erlang.term_to_binary(-2.5)
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 70, 192, 4, 0, 0, 0, 0, 0, 0]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(-2.5));
       });
 
-      it("decodes NEW_FLOAT_EXT for zero", () => {
+      it("decodes NEW_FLOAT_EXT for zero", async () => {
         // :erlang.term_to_binary(0.0)
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 70, 0, 0, 0, 0, 0, 0, 0, 0]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(0.0));
       });
 
-      it("decodes FLOAT_EXT (deprecated 31-byte string format) for positive float", () => {
+      it("decodes FLOAT_EXT (deprecated 31-byte string format) for positive float", async () => {
         // FLOAT_EXT: tag 99, followed by 31 bytes (null-terminated string)
         // Encoding 3.14159 as "3.14159000000000000000e+00" (31 bytes with null padding)
         const floatStr = "3.14159000000000000000e+00";
@@ -3113,11 +3114,11 @@ describe("Erlang", () => {
         }
         // Remaining bytes are 0 (null padding)
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(3.14159));
       });
 
-      it("decodes FLOAT_EXT for negative float", () => {
+      it("decodes FLOAT_EXT for negative float", async () => {
         // Encoding -2.5 as "-2.50000000000000000000e+00"
         const floatStr = "-2.50000000000000000000e+00";
         const bytes = new Uint8Array(33);
@@ -3127,11 +3128,11 @@ describe("Erlang", () => {
           bytes[2 + i] = floatStr.charCodeAt(i);
         }
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(-2.5));
       });
 
-      it("decodes FLOAT_EXT for zero", () => {
+      it("decodes FLOAT_EXT for zero", async () => {
         // Encoding 0.0 as "0.00000000000000000000e+00"
         const floatStr = "0.00000000000000000000e+00";
         const bytes = new Uint8Array(33);
@@ -3141,11 +3142,11 @@ describe("Erlang", () => {
           bytes[2 + i] = floatStr.charCodeAt(i);
         }
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(0.0));
       });
 
-      it("decodes FLOAT_EXT with shorter string (null-terminated)", () => {
+      it("decodes FLOAT_EXT with shorter string (null-terminated)", async () => {
         // Encoding 1.5 as "1.5" with null termination
         const floatStr = "1.5";
         const bytes = new Uint8Array(33);
@@ -3157,11 +3158,11 @@ describe("Erlang", () => {
         bytes[2 + floatStr.length] = 0; // null terminator
         // Remaining bytes are already 0
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(1.5));
       });
 
-      it("decodes FLOAT_EXT with negative exponent", () => {
+      it("decodes FLOAT_EXT with negative exponent", async () => {
         // Encoding 0.00625 as "6.25000000000000000000e-03"
         const floatStr = "6.25000000000000000000e-03";
         const bytes = new Uint8Array(33);
@@ -3171,17 +3172,17 @@ describe("Erlang", () => {
           bytes[2 + i] = floatStr.charCodeAt(i);
         }
         const binary = Bitstring.fromBytes(bytes);
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.deepStrictEqual(result, Type.float(0.00625));
       });
 
-      it("raises ArgumentError for FLOAT_EXT with truncated data", () => {
+      it("raises ArgumentError for FLOAT_EXT with truncated data", async () => {
         // Only 10 bytes after tag instead of 31
         const bytes = new Uint8Array([
           131, 99, 49, 46, 50, 51, 0, 0, 0, 0, 0, 0,
         ]);
         const binary = Bitstring.fromBytes(bytes);
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "float string exceeds available bytes",
@@ -3190,7 +3191,7 @@ describe("Erlang", () => {
     });
 
     describe("bitstrings", () => {
-      it("decodes BIT_BINARY_EXT with partial byte", () => {
+      it("decodes BIT_BINARY_EXT with partial byte", async () => {
         // Bitstring with 5 bits: <<1::5>>
         // 131 - VERSION_NUMBER
         // 77 - BIT_BINARY_EXT
@@ -3200,22 +3201,22 @@ describe("Erlang", () => {
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 77, 0, 0, 0, 1, 5, 8]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(Bitstring.calculateBitCount(result), 5);
       });
 
-      it("decodes BIT_BINARY_EXT with full bytes", () => {
+      it("decodes BIT_BINARY_EXT with full bytes", async () => {
         // Bitstring with 16 bits (2 full bytes): <<255, 0>>
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 77, 0, 0, 0, 2, 0, 255, 0]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(Bitstring.calculateBitCount(result), 16);
       });
     });
 
     describe("references", () => {
-      it("decodes NEW_REFERENCE_EXT", () => {
+      it("decodes NEW_REFERENCE_EXT", async () => {
         // NEW_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT node
         // 131 - VERSION_NUMBER
         // 114 - NEW_REFERENCE_EXT
@@ -3231,14 +3232,14 @@ describe("Erlang", () => {
             104, 111, 115, 116, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "reference");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.strictEqual(result.creation, 0);
         assert.deepStrictEqual(result.idWords, [1, 2, 3]);
       });
 
-      it("decodes NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT", () => {
+      it("decodes NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT", async () => {
         // NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT node
         // 131 - VERSION_NUMBER
         // 90 - NEWER_REFERENCE_EXT
@@ -3254,14 +3255,14 @@ describe("Erlang", () => {
             104, 111, 115, 116, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "reference");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.strictEqual(result.creation, 0);
         assert.deepStrictEqual(result.idWords, [1, 2, 3]);
       });
 
-      it("decodes NEWER_REFERENCE_EXT with ATOM_EXT", () => {
+      it("decodes NEWER_REFERENCE_EXT with ATOM_EXT", async () => {
         // NEWER_REFERENCE_EXT with ATOM_EXT node
         // 131 - VERSION_NUMBER
         // 90 - NEWER_REFERENCE_EXT
@@ -3278,7 +3279,7 @@ describe("Erlang", () => {
             0, 3,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "reference");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.strictEqual(result.creation, 0);
@@ -3287,7 +3288,7 @@ describe("Erlang", () => {
     });
 
     describe("pids", () => {
-      it("decodes PID_EXT", () => {
+      it("decodes PID_EXT", async () => {
         // PID_EXT format
         // 131 - VERSION_NUMBER
         // 103 - PID_EXT
@@ -3301,13 +3302,13 @@ describe("Erlang", () => {
             111, 115, 116, 0, 0, 0, 100, 0, 0, 0, 50, 0,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "pid");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.deepStrictEqual(result.segments, [100, 50, 0]);
       });
 
-      it("decodes NEW_PID_EXT", () => {
+      it("decodes NEW_PID_EXT", async () => {
         // NEW_PID_EXT format
         // 131 - VERSION_NUMBER
         // 88 - NEW_PID_EXT
@@ -3321,7 +3322,7 @@ describe("Erlang", () => {
             111, 115, 116, 0, 0, 0, 100, 0, 0, 0, 50, 0, 0, 0, 0,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "pid");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.deepStrictEqual(result.segments, [100, 50, 0]);
@@ -3329,7 +3330,7 @@ describe("Erlang", () => {
     });
 
     describe("ports", () => {
-      it("decodes PORT_EXT", () => {
+      it("decodes PORT_EXT", async () => {
         // PORT_EXT format
         // 131 - VERSION_NUMBER
         // 102 - PORT_EXT
@@ -3343,13 +3344,13 @@ describe("Erlang", () => {
             111, 115, 116, 0, 0, 0, 5, 0,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "port");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.deepStrictEqual(result.segments, [5, 0]);
       });
 
-      it("decodes NEW_PORT_EXT", () => {
+      it("decodes NEW_PORT_EXT", async () => {
         // NEW_PORT_EXT format
         // 131 - VERSION_NUMBER
         // 89 - NEW_PORT_EXT
@@ -3363,13 +3364,13 @@ describe("Erlang", () => {
             111, 115, 116, 0, 0, 0, 5, 0, 0, 0, 0,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "port");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.deepStrictEqual(result.segments, [5, 0]);
       });
 
-      it("decodes V4_PORT_EXT", () => {
+      it("decodes V4_PORT_EXT", async () => {
         // V4_PORT_EXT format (64-bit port ID)
         // 131 - VERSION_NUMBER
         // 120 - V4_PORT_EXT
@@ -3383,7 +3384,7 @@ describe("Erlang", () => {
             111, 115, 116, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         assert.strictEqual(result.type, "port");
         assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
         assert.deepStrictEqual(result.segments, [5n, 0]);
@@ -3391,7 +3392,7 @@ describe("Erlang", () => {
     });
 
     describe("exports (function captures)", () => {
-      it("decodes EXPORT_EXT (function capture)", () => {
+      it("decodes EXPORT_EXT (function capture)", async () => {
         // &Enum.map/2
         // :erlang.term_to_binary(&Enum.map/2) =
         // <<131, 113, 119, 11, 69, 108, 105, 120, 105, 114, 46, 69, 110, 117, 109, 119, 3, 109, 97, 112, 97, 2>>
@@ -3401,7 +3402,7 @@ describe("Erlang", () => {
             109, 119, 3, 109, 97, 112, 97, 2,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
 
         assert.strictEqual(result.type, "anonymous_function");
         assert.strictEqual(result.capturedModule, "Elixir.Enum");
@@ -3412,7 +3413,7 @@ describe("Erlang", () => {
     });
 
     describe("complex nested structures", () => {
-      it("decodes Code.fetch_docs/1 style tuple", () => {
+      it("decodes Code.fetch_docs/1 style tuple", async () => {
         // :erlang.term_to_binary({:docs_v1, 1, :elixir, "text/markdown", %{}, %{}, []})
         const binary = Bitstring.fromBytes(
           new Uint8Array([
@@ -3422,7 +3423,7 @@ describe("Erlang", () => {
             0, 0, 0, 106,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
 
         assertBoxedStrictEqual(
           result,
@@ -3440,7 +3441,7 @@ describe("Erlang", () => {
     });
 
     describe("compressed terms", () => {
-      it("decodes compressed term (COMPRESSED tag 80) with repeated string", () => {
+      it("decodes compressed term (COMPRESSED tag 80) with repeated string", async () => {
         // Real Erlang-generated compressed term for String.duplicate("hello", 100)
         // Generated with: :erlang.term_to_binary(String.duplicate("hello", 100), [compressed: 9])
         // Format: 131 (version) + 80 (COMPRESSED) + uncompressed_size (4 bytes) + zlib compressed data
@@ -3451,7 +3452,7 @@ describe("Erlang", () => {
             154, 147, 147, 63, 74, 140, 40, 2, 0, 21, 94, 209, 51,
           ]),
         );
-        const result = binary_to_term(binary);
+        const result = await binary_to_term(binary);
         const expected = Type.bitstring("hello".repeat(100));
         assertBoxedStrictEqual(result, expected);
       });
@@ -3471,19 +3472,19 @@ describe("Erlang", () => {
         assertBoxedStrictEqual(result, expectedList);
       });
 
-      it("raises ArgumentError for compressed term with truncated uncompressed size", () => {
+      it("raises ArgumentError for compressed term with truncated uncompressed size", async () => {
         // COMPRESSED tag but missing uncompressed size bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 80, 0, 0]), // Only 2 bytes of size instead of 4
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for compressed term with invalid zlib data", () => {
+      it("raises ArgumentError for compressed term with invalid zlib data", async () => {
         // COMPRESSED tag with invalid compressed data
         const binary = Bitstring.fromBytes(
           new Uint8Array([
@@ -3498,14 +3499,14 @@ describe("Erlang", () => {
             255, // invalid zlib data
           ]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for compressed term with size mismatch", () => {
+      it("raises ArgumentError for compressed term with size mismatch", async () => {
         // COMPRESSED tag where decompressed size doesn't match declared size
         const binary = Bitstring.fromBytes(
           new Uint8Array([
@@ -3527,7 +3528,7 @@ describe("Erlang", () => {
             121, // zlib data that decompresses to 2 bytes
           ]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
@@ -3536,237 +3537,237 @@ describe("Erlang", () => {
     });
 
     describe("error handling", () => {
-      it("raises ArgumentError if argument is not a binary", () => {
-        assertBoxedError(
+      it("raises ArgumentError if argument is not a binary", async () => {
+        await assertBoxedErrorAsync(
           () => binary_to_term(Type.atom("test")),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: not a binary\n",
         );
       });
 
-      it("raises ArgumentError if binary has invalid version byte", () => {
+      it("raises ArgumentError if binary has invalid version byte", async () => {
         const binary = Bitstring.fromBytes(new Uint8Array([130, 97, 42])); // Wrong version
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError if binary is truncated", () => {
+      it("raises ArgumentError if binary is truncated", async () => {
         const binary = Bitstring.fromBytes(new Uint8Array([131])); // Only version byte
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for unsupported ETF tag (tag 50)", () => {
+      it("raises ArgumentError for unsupported ETF tag (tag 50)", async () => {
         // Tag 50 is not a valid ETF tag
         const binary = Bitstring.fromBytes(new Uint8Array([131, 50]));
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for unsupported ETF tag (tag 255)", () => {
+      it("raises ArgumentError for unsupported ETF tag (tag 255)", async () => {
         // Tag 255 is not a valid ETF tag
         const binary = Bitstring.fromBytes(new Uint8Array([131, 255]));
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for unsupported ETF tag (tag 1)", () => {
+      it("raises ArgumentError for unsupported ETF tag (tag 1)", async () => {
         // Tag 1 is not a valid ETF tag
         const binary = Bitstring.fromBytes(new Uint8Array([131, 1]));
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed BINARY_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed BINARY_EXT with length exceeding data", async () => {
         // BINARY_EXT (109) with length 10 but only 2 bytes of data
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 109, 0, 0, 0, 10, 65, 66]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "binary length exceeds available bytes: 10",
         );
       });
 
-      it("raises ArgumentError for malformed STRING_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed STRING_EXT with length exceeding data", async () => {
         // STRING_EXT (107) with length 100 but only 2 bytes of data
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 107, 0, 100, 65, 66]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "string length exceeds available bytes: 100",
         );
       });
 
-      it("raises ArgumentError for malformed SMALL_TUPLE_EXT with arity exceeding available data", () => {
+      it("raises ArgumentError for malformed SMALL_TUPLE_EXT with arity exceeding available data", async () => {
         // SMALL_TUPLE_EXT (104) with arity 5 but only 1 element
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 104, 5, 97, 1]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed LIST_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed LIST_EXT with length exceeding data", async () => {
         // LIST_EXT (108) with length 10 but no elements
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 108, 0, 0, 0, 10]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed MAP_EXT with arity exceeding data", () => {
+      it("raises ArgumentError for malformed MAP_EXT with arity exceeding data", async () => {
         // MAP_EXT (116) with arity 10 but no key-value pairs
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 116, 0, 0, 0, 10]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed ATOM_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed ATOM_EXT with length exceeding data", async () => {
         // ATOM_EXT (100) with length 100 but only 2 bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 100, 0, 100, 65, 66]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "atom length exceeds available bytes: 100",
         );
       });
 
-      it("raises ArgumentError for malformed SMALL_ATOM_UTF8_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed SMALL_ATOM_UTF8_EXT with length exceeding data", async () => {
         // SMALL_ATOM_UTF8_EXT (119) with length 50 but only 2 bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 119, 50, 65, 66]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "atom length exceeds available bytes: 50",
         );
       });
 
-      it("raises ArgumentError for malformed SMALL_BIG_EXT with n exceeding data", () => {
+      it("raises ArgumentError for malformed SMALL_BIG_EXT with n exceeding data", async () => {
         // SMALL_BIG_EXT (110) with n=100 but insufficient bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 110, 100, 0, 1, 2, 3]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed LARGE_BIG_EXT with n exceeding data", () => {
+      it("raises ArgumentError for malformed LARGE_BIG_EXT with n exceeding data", async () => {
         // LARGE_BIG_EXT (111) with large n but insufficient bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 111, 0, 0, 1, 0, 0, 1, 2, 3]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for malformed BIT_BINARY_EXT with length exceeding data", () => {
+      it("raises ArgumentError for malformed BIT_BINARY_EXT with length exceeding data", async () => {
         // BIT_BINARY_EXT (77) with length 100 but only 2 bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 77, 0, 0, 0, 100, 5, 65, 66]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "bit binary length exceeds available bytes: 100",
         );
       });
 
-      it("raises ArgumentError for malformed NEW_REFERENCE_EXT with len exceeding data", () => {
+      it("raises ArgumentError for malformed NEW_REFERENCE_EXT with len exceeding data", async () => {
         // NEW_REFERENCE_EXT (114) with len=10 but insufficient id bytes
         const binary = Bitstring.fromBytes(
           new Uint8Array([
             131, 114, 0, 10, 119, 4, 110, 111, 100, 101, 0, 0, 0, 1,
           ]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for INTEGER_EXT boundary - value truncated", () => {
+      it("raises ArgumentError for INTEGER_EXT boundary - value truncated", async () => {
         // INTEGER_EXT (98) but only 2 bytes instead of 4
         const binary = Bitstring.fromBytes(new Uint8Array([131, 98, 0, 0]));
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for NEW_FLOAT_EXT truncated", () => {
+      it("raises ArgumentError for NEW_FLOAT_EXT truncated", async () => {
         // NEW_FLOAT_EXT (70) but only 4 bytes instead of 8
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 70, 0, 0, 0, 0]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for nested term truncation", () => {
+      it("raises ArgumentError for nested term truncation", async () => {
         // SMALL_TUPLE_EXT with 2 elements, but second element is truncated
         // [131, 104, 2, 97, 1, 97] - missing last byte
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 104, 2, 97, 1, 97]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
         );
       });
 
-      it("raises ArgumentError for LARGE_TUPLE_EXT with zero arity but missing NIL_EXT", () => {
+      it("raises ArgumentError for LARGE_TUPLE_EXT with zero arity but missing NIL_EXT", async () => {
         // LARGE_TUPLE_EXT (105) with arity 0 - should work, but let's test malformed version
         const binary = Bitstring.fromBytes(
           new Uint8Array([131, 105, 0, 0, 0, 1]),
         );
-        assertBoxedError(
+        await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
           "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
diff --git a/test/javascript/support/helpers.mjs b/test/javascript/support/helpers.mjs
index 211198454c..5421739823 100644
--- a/test/javascript/support/helpers.mjs
+++ b/test/javascript/support/helpers.mjs
@@ -93,6 +93,57 @@ export function assertBoxedError(
   }
 }
 
+export async function assertBoxedErrorAsync(
+  asyncCallable,
+  expectedErrorType,
+  expectedErrorMessage,
+) {
+  const isRegex = expectedErrorMessage instanceof RegExp;
+
+  const expectedMessageDisplay = isRegex
+    ? expectedErrorMessage.toString()
+    : expectedErrorMessage;
+
+  const failMessagePrefix = `\nexpected:\n${expectedErrorType}: ${expectedMessageDisplay}\n`;
+
+  let error;
+
+  try {
+    await asyncCallable();
+  } catch (e) {
+    error = e;
+  }
+
+  if (!error) {
+    assert.fail(failMessagePrefix + "but got no error");
+  }
+
+  if (!(error instanceof HologramBoxedError)) {
+    assert.fail(
+      failMessagePrefix + `but got:\n${error.name}: ${error.message}`,
+    );
+  }
+
+  const receivedErrorType = Interpreter.getErrorType(error);
+  const receivedErrorMessage = Interpreter.getErrorMessage(error);
+
+  const typeMatches = receivedErrorType === expectedErrorType;
+
+  const messageMatches = isRegex
+    ? expectedErrorMessage.test(receivedErrorMessage)
+    : Interpreter.isStrictlyEqual(
+        error.struct,
+        Type.errorStruct(expectedErrorType, expectedErrorMessage),
+      );
+
+  if (!typeMatches || !messageMatches) {
+    assert.fail(
+      failMessagePrefix +
+        `but got:\n${receivedErrorType}: ${receivedErrorMessage}`,
+    );
+  }
+}
+
 export function assertBoxedFalse(boxed) {
   assert.isTrue(Type.isFalse(boxed));
 }
diff --git a/test/javascript/utils_test.mjs b/test/javascript/utils_test.mjs
index d9b9289055..94fe508f80 100644
--- a/test/javascript/utils_test.mjs
+++ b/test/javascript/utils_test.mjs
@@ -264,7 +264,7 @@ describe("Utils", () => {
     // Test 5: Type Safety
     it("should handle input as a Buffer or Uint8Array interchangeably", async () => {
       // Small valid zlib: "hi"
-      const input = new Uint8Array([120, 156, 203, 200, 4, 0, 1, 43, 0, 201]);
+      const input = new Uint8Array([120, 156, 203, 200, 4, 0, 1, 59, 0, 210]);
       const decompressed = await Utils.zlibInflate(input);
 
       assert.strictEqual(new TextDecoder().decode(decompressed), "hi");

From 94785b8dcabb83ede7a4961f1f2c5daa733acf36 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 13:17:24 -0300
Subject: [PATCH 24/33] chore: Move zlibInflate into Erlang binary_to_term

Remove Utils.zlibInflate and add equivalent function inside the
binary_to_term implementation. Update callsites and add a test to
validate internal zlibInflate behavior for compressed terms.
---
 assets/js/erlang/erlang.mjs            | 41 +++++++++++++-
 assets/js/utils.mjs                    | 39 --------------
 test/javascript/erlang/erlang_test.mjs | 20 +++++++
 test/javascript/utils_test.mjs         | 74 --------------------------
 4 files changed, 60 insertions(+), 114 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index a6e332d070..7c28bc29d2 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -636,6 +636,45 @@ const Erlang = {
     const SMALL_ATOM_UTF8_EXT = 119;
     const V4_PORT_EXT = 120;
 
+    // Decompresses zlib-compressed data using native DecompressionStream API
+    // Returns a Promise that resolves to a Uint8Array with the decompressed data
+    // Throws an error if decompression fails
+    const zlibInflate = async (compressedData) => {
+      const stream = new ReadableStream({
+        start(controller) {
+          // Ensure we are passing a standard Uint8Array to the stream
+          // This solves the Buffer/Uint8Array mismatch in Node.js
+          const data =
+            compressedData instanceof Uint8Array
+              ? compressedData
+              : new Uint8Array(compressedData);
+
+          controller.enqueue(data);
+          controller.close();
+        },
+      });
+
+      const decompressedStream = stream.pipeThrough(
+        new DecompressionStream("deflate"),
+      );
+
+      const reader = decompressedStream.getReader();
+      const chunks = [];
+
+      try {
+        while (true) {
+          const {done, value} = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+      } catch (err) {
+        // In Node, stream errors often need to be caught during the read loop
+        throw new Error(`Decompression failed: ${err.message}`);
+      }
+
+      return Utils.concatUint8Arrays(chunks);
+    };
+
     const decodeTerm = async (dataView, bytes, offset) => {
       if (offset >= bytes.length) {
         Interpreter.raiseArgumentError(
@@ -759,7 +798,7 @@ const Erlang = {
 
       try {
         // Use native DecompressionStream for zlib decompression
-        const decompressed = await Utils.zlibInflate(compressedData);
+        const decompressed = await zlibInflate(compressedData);
 
         if (decompressed.length !== uncompressedSize) {
           Interpreter.raiseArgumentError(
diff --git a/assets/js/utils.mjs b/assets/js/utils.mjs
index 349b9c74c0..b13f732b6f 100644
--- a/assets/js/utils.mjs
+++ b/assets/js/utils.mjs
@@ -85,43 +85,4 @@ export default class Utils {
     // see benchmarks here: https://thecodebarbarian.com/object-assign-vs-object-spread.html
     return {...obj};
   }
-
-  // Decompresses zlib-compressed data using native DecompressionStream API
-  // Returns a Promise that resolves to a Uint8Array with the decompressed data
-  // Throws an error if decompression fai
-  static async zlibInflate(compressedData) {
-    const stream = new ReadableStream({
-      start(controller) {
-        // Ensure we are passing a standard Uint8Array to the stream
-        // This solves the Buffer/Uint8Array mismatch in Node.js
-        const data =
-          compressedData instanceof Uint8Array
-            ? compressedData
-            : new Uint8Array(compressedData);
-
-        controller.enqueue(data);
-        controller.close();
-      },
-    });
-
-    const decompressedStream = stream.pipeThrough(
-      new DecompressionStream("deflate"),
-    );
-
-    const reader = decompressedStream.getReader();
-    const chunks = [];
-
-    try {
-      while (true) {
-        const {done, value} = await reader.read();
-        if (done) break;
-        chunks.push(value);
-      }
-    } catch (err) {
-      // In Node, stream errors often need to be caught during the read loop
-      throw new Error(`Decompression failed: ${err.message}`);
-    }
-
-    return this.concatUint8Arrays(chunks);
-  }
 }
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 9ef362e2bd..c37e703bfe 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3472,6 +3472,26 @@ describe("Erlang", () => {
         assertBoxedStrictEqual(result, expectedList);
       });
 
+      it("validates internal zlibInflate functionality within binary_to_term context", async () => {
+        // This test validates that the zlibInflate function was successfully moved from Utils
+        // to within the binary_to_term context and still works correctly for compressed terms.
+
+        // Use the same working test data as the first compressed test
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 80, 0, 0, 1, 249, 120, 218, 203, 101, 96, 96, 252, 146, 145,
+            154, 147, 147, 63, 74, 140, 40, 2, 0, 21, 94, 209, 51,
+          ]),
+        );
+
+        const result = await binary_to_term(binary);
+        const expected = Type.bitstring("hello".repeat(100));
+
+        // Verify the result to ensure zlibInflate worked correctly
+        // This confirms that the moved zlibInflate function is working properly
+        assertBoxedStrictEqual(result, expected);
+      });
+
       it("raises ArgumentError for compressed term with truncated uncompressed size", async () => {
         // COMPRESSED tag but missing uncompressed size bytes
         const binary = Bitstring.fromBytes(
diff --git a/test/javascript/utils_test.mjs b/test/javascript/utils_test.mjs
index 94fe508f80..48bc25df6c 100644
--- a/test/javascript/utils_test.mjs
+++ b/test/javascript/utils_test.mjs
@@ -196,78 +196,4 @@ describe("Utils", () => {
     assert.deepStrictEqual(obj, {a: 1, b: {c: 30, d: 4}});
     assert.deepStrictEqual(clone, {a: 10, b: {c: 30, d: 4}});
   });
-
-  describe("Utils.zlibInflate", () => {
-    // Test 1: Your original test, but verifying content, not just length
-    it("should decompress a known valid zlib buffer correctly", async () => {
-      const compressedData = new Uint8Array([
-        120, 218, 203, 101, 96, 96, 252, 146, 145, 154, 147, 147, 63, 74, 140,
-        40, 2, 0, 21, 94, 209, 51,
-      ]);
-      const expectedSize = 505;
-
-      const decompressed = await Utils.zlibInflate(compressedData);
-
-      assert.strictEqual(decompressed.length, expectedSize);
-
-      // 109 is 'm'. Let's verify the first few bytes to be sure.
-      assert.strictEqual(decompressed[0], 109);
-
-      // Optional: Convert to string to see what's actually inside
-      // const text = new TextDecoder().decode(decompressed);
-      // console.log("Decompressed content sample:", text.substring(0, 20));
-    });
-
-    // Test 2: Empty Data (Zlib header for an empty string)
-    it("should handle an empty compressed string", async () => {
-      const emptyZlib = new Uint8Array([120, 156, 3, 0, 0, 0, 0, 1]);
-      const decompressed = await Utils.zlibInflate(emptyZlib);
-
-      assert.strictEqual(decompressed.length, 0);
-    });
-
-    // Test 3: Large Data (Testing the chunking logic)
-    it("should decompress larger datasets that require multiple chunks", async () => {
-      const originalString = "hello world ".repeat(1000);
-      const encoder = new TextEncoder();
-      const data = encoder.encode(originalString);
-
-      // We use CompressionStream to generate the test data dynamically
-      const cs = new CompressionStream("deflate");
-      const writer = cs.writable.getWriter();
-      writer.write(data);
-      writer.close();
-
-      const compressedResponse = await new Response(cs.readable).arrayBuffer();
-      const compressedUint8 = new Uint8Array(compressedResponse);
-
-      const result = await Utils.zlibInflate(compressedUint8);
-      const resultString = new TextDecoder().decode(result);
-
-      assert.strictEqual(resultString, originalString);
-      assert.strictEqual(result.length, data.length);
-    });
-
-    // Test 4: Error Handling (Corrupt Data)
-    it("should throw an error when given invalid/corrupt data", async () => {
-      const corruptData = new Uint8Array([0, 1, 2, 3, 4, 5]); // Not a valid zlib stream
-
-      try {
-        await Utils.zlibInflate(corruptData);
-        assert.fail("Should have thrown a decompression error");
-      } catch (e) {
-        // DecompressionStream throws a TypeError or DOMException on failure
-        assert.ok(e instanceof Error);
-      }
-    });
-
-    // Test 5: Type Safety
-    it("should handle input as a Buffer or Uint8Array interchangeably", async () => {
-      // Small valid zlib: "hi"
-      const input = new Uint8Array([120, 156, 203, 200, 4, 0, 1, 59, 0, 210]);
-      const decompressed = await Utils.zlibInflate(input);
-
-      assert.strictEqual(new TextDecoder().decode(decompressed), "hi");
-    });
-  });
 });

From c24913e1322da96d10f1e4357a3e410d9f2710c7 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 13:35:53 -0300
Subject: [PATCH 25/33] revert: renderer_test.exs

---
 test/elixir/hologram/template/renderer_test.exs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 1f1903371d..14f61e9c45 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module25, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module27, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module24, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do

From eb71e5c419ebdaa8bc3b3bac3fabe851ce3e1644 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 14:08:03 -0300
Subject: [PATCH 26/33] Use preferred_cli_env in mix.exs

Replace cli with preferred_cli_env in the project config.
Update format aliases: use 'cmd cd test/features && mix format' and
broaden the prettier scripts glob.
---
 mix.exs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/mix.exs b/mix.exs
index 5067d08ba1..0e2bb66a5c 100644
--- a/mix.exs
+++ b/mix.exs
@@ -11,9 +11,9 @@ defmodule Hologram.MixProject do
     [
       eslint:
         "cmd assets/node_modules/.bin/eslint --color --config assets/eslint.config.mjs assets/js/** benchmarks/javascript/** scripts/** test/javascript/** --no-error-on-unmatched-pattern",
-      f: ["format", "format.js", "cmd --cd test/features mix format"],
+      f: ["format", "format.js", "cmd cd test/features && mix format"],
       "format.js":
-        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**/*.{mjs,js,json}' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
+        "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**' 'test/javascript/**' --config 'assets/.prettierrc.json' --write",
       "format.js.check":
         "cmd assets/node_modules/.bin/prettier '*.yml' '.github/**' 'assets/*.json' 'assets/*.mjs' 'assets/js/**' 'benchmarks/javascript/**' 'scripts/**' 'test/javascript/**' --check --config 'assets/.prettierrc.json' --no-error-on-unmatched-pattern",
       setup: [
@@ -97,12 +97,10 @@ defmodule Hologram.MixProject do
     ]
   end
 
-  def cli do
+  def preferred_cli_env do
     [
-      preferred_envs: [
-        t: :test,
-        "test.js": :test
-      ]
+      t: :test,
+      "test.js": :test
     ]
   end
 
@@ -110,7 +108,6 @@ defmodule Hologram.MixProject do
     [
       aliases: aliases(),
       app: :hologram,
-      cli: cli(),
       deps: deps(),
       description:
         "Full stack isomorphic Elixir web framework that can be used on top of Phoenix.",
@@ -146,6 +143,7 @@ defmodule Hologram.MixProject do
       elixirc_paths: elixirc_paths(Mix.env()),
       homepage_url: "https://hologram.page/",
       package: package(),
+      preferred_cli_env: preferred_cli_env(),
       start_permanent: Mix.env() == :prod,
       source_url: "https://github.com/bartblast/hologram",
       test_paths: ["test/elixir"],

From a8674d4f00d13e667ce541d792ac0c18675ffd4d Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Fri, 30 Jan 2026 14:23:39 -0300
Subject: [PATCH 27/33] Validate bit count for bit binary decoding

Raise ArgumentError when BIT_BINARY_EXT 'bits' byte is not 1..8. Update
tests to use bits=8 for the full-byte case and apply minor formatting
fixes in test fixtures.
---
 assets/js/erlang/erlang.mjs                   | 42 +++++++++++++++++--
 .../ex_js_consistency/erlang/erlang_test.exs  |  5 ++-
 test/javascript/erlang/erlang_test.mjs        | 15 ++++---
 3 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 7c28bc29d2..b3f1d94362 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -784,6 +784,17 @@ const Erlang = {
     // The decompressed data contains the ETF representation of the term without the version byte
 
     const decodeCompressed = async (dataView, bytes, offset) => {
+      // Disallow nested COMPRESSED: verify it is only used at top-level
+      // For top-level usage, offset should be 2 (version byte + COMPRESSED tag consumed)
+      if (offset !== 2) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
       if (offset + 4 > bytes.length) {
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
@@ -815,7 +826,14 @@ const Erlang = {
           decompressed.byteLength,
         );
 
-        return await decodeTerm(decompressedView, decompressed, 0);
+        const result = await decodeTerm(decompressedView, decompressed, 0);
+
+        // Return with newOffset pointing to end of original bytes since
+        // COMPRESSED must consume the entire remaining buffer at top-level
+        return {
+          term: result.term,
+          newOffset: bytes.length,
+        };
       } catch (error) {
         console.error("Decode error:", error);
         Interpreter.raiseArgumentError(
@@ -891,7 +909,7 @@ const Erlang = {
       const length = dataView.getUint16(offset);
       if (offset + 2 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `atom length exceeds available bytes: ${length}`,
+          "invalid external representation of a term",
         );
       }
       const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
@@ -983,7 +1001,7 @@ const Erlang = {
       const length = dataView.getUint16(offset);
       if (offset + 2 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `string length exceeds available bytes: ${length}`,
+          "invalid external representation of a term",
         );
       }
       const elements = [];
@@ -1076,6 +1094,15 @@ const Erlang = {
       const floatString = decoder.decode(floatBytes).replace(/\0.*$/, "");
       const value = parseFloat(floatString);
 
+      if (Number.isNaN(value)) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
       return {
         term: Type.float(value),
         newOffset: offset + 31,
@@ -1088,6 +1115,15 @@ const Erlang = {
       const length = dataView.getUint32(offset);
       const bits = dataView.getUint8(offset + 4);
 
+      if (bits < 1 || bits > 8) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
       if (offset + 5 + length > bytes.length) {
         Interpreter.raiseArgumentError(
           `bit binary length exceeds available bytes: ${length}`,
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index f6b3436cb1..1b49a51180 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -1989,7 +1989,7 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
     test "decodes atom UTF-8 (ATOM_UTF8_EXT)" do
       name = "élixir"
       binary = <<131, 118, byte_size(name)::16, name::binary>>
-      assert :erlang.binary_to_term(binary) == String.to_existing_atom(name)
+      assert :erlang.binary_to_term(binary) == :élixir
     end
 
     test "decodes UTF-8 atom (SMALL_ATOM_UTF8_EXT)" do
@@ -2112,7 +2112,8 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
 
     test "decodes FLOAT_EXT (deprecated string format)" do
       # Manually construct FLOAT_EXT binary
-      float_str = :io_lib.format("~.20e", [1.5]) |> IO.iodata_to_binary()
+      iodata = :io_lib.format("~.20e", [1.5])
+      float_str = IO.iodata_to_binary(iodata)
       padded = String.pad_trailing(float_str, 31, <<0>>)
       binary = <<131, 99, padded::binary>>
 
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index c37e703bfe..eaf4697fc6 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3205,10 +3205,15 @@ describe("Erlang", () => {
         assert.strictEqual(Bitstring.calculateBitCount(result), 5);
       });
 
-      it("decodes BIT_BINARY_EXT with full bytes", async () => {
-        // Bitstring with 16 bits (2 full bytes): <<255, 0>>
+      it("decodes BIT_BINARY_EXT with full bytes (Bits=8)", async () => {
+        // BIT_BINARY_EXT with 2 bytes, 8 bits used in last byte
+        // 131 - VERSION_MAGIC
+        // 77 - BIT_BINARY_EXT
+        // 0, 0, 0, 2 - length (2 bytes)
+        // 8 - bits used in last byte (8 = full byte)
+        // 255, 0 - the actual data bytes
         const binary = Bitstring.fromBytes(
-          new Uint8Array([131, 77, 0, 0, 0, 2, 0, 255, 0]),
+          new Uint8Array([131, 77, 0, 0, 0, 2, 8, 255, 0]),
         );
         const result = await binary_to_term(binary);
         assert.strictEqual(Bitstring.calculateBitCount(result), 16);
@@ -3633,7 +3638,7 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "string length exceeds available bytes: 100",
+          "invalid external representation of a term",
         );
       });
 
@@ -3681,7 +3686,7 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "atom length exceeds available bytes: 100",
+          "invalid external representation of a term",
         );
       });
 

From 906b4ee84b8111d6c3de0d994b03fd5c38107dc8 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 3 Feb 2026 17:03:25 -0300
Subject: [PATCH 28/33] feat: handle binary_to_term

---
 assets/js/erlang/erlang.mjs                   | 100 +++++++++++-----
 .../ex_js_consistency/erlang/erlang_test.exs  |  16 +++
 test/javascript/erlang/erlang_test.mjs        | 109 +++++++++++++++++-
 3 files changed, 194 insertions(+), 31 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index b3f1d94362..d6f7be949e 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -618,6 +618,7 @@ const Erlang = {
     const INTEGER_EXT = 98;
     const FLOAT_EXT = 99;
     const ATOM_EXT = 100;
+    const REFERENCE_EXT = 101;
     const PORT_EXT = 102;
     const PID_EXT = 103;
     const SMALL_TUPLE_EXT = 104;
@@ -745,6 +746,9 @@ const Erlang = {
         case BIT_BINARY_EXT:
           return decodeBitBinary(dataView, bytes, offset + 1);
 
+        case REFERENCE_EXT:
+          return await decodeReference(dataView, bytes, offset + 1);
+
         case NEW_REFERENCE_EXT:
           return await decodeNewReference(dataView, bytes, offset + 1);
 
@@ -1148,22 +1152,64 @@ const Erlang = {
     };
 
     // Reference decoders
+    //
+    // REFERENCE_EXT (tag 101) - Deprecated format for backward compatibility
+    // Format: Node | ID | Creation
+    // Where:
+    // - Node: atom (encoded with various atom formats)
+    // - ID: single 32-bit word
+    // - Creation: 8-bit value (only 2 bits significant)
+    //
+    // This format was used in older Erlang versions and is kept for
+    // compatibility with legacy external term format data.
+
+    // Common reference decoder helper
+    const decodeReferenceWithOptions = async (
+      dataView,
+      bytes,
+      offset,
+      options,
+    ) => {
+      let currentOffset = offset;
 
-    const decodeNewReference = async (dataView, bytes, offset) => {
-      const len = dataView.getUint16(offset);
-      let currentOffset = offset + 2;
+      // Read length prefix if present
+      let idWordCount = 1; // Default for REFERENCE_EXT
+      if (options.hasLengthPrefix) {
+        idWordCount = dataView.getUint16(currentOffset);
+        currentOffset += 2;
+      }
 
       // Decode node name (atom)
       const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
       currentOffset = nodeResult.newOffset;
 
-      const creation = dataView.getUint8(currentOffset);
-      currentOffset += 1;
+      // For REFERENCE_EXT: read ID words first, then creation
+      // For NEW/NEWER_REFERENCE_EXT: read creation first, then ID words
+      let creation, idWords;
+
+      if (options.hasLengthPrefix) {
+        // NEW_REFERENCE_EXT and NEWER_REFERENCE_EXT: Creation | ID words
+        creation =
+          options.creationSize === 4
+            ? dataView.getUint32(currentOffset)
+            : dataView.getUint8(currentOffset);
+        currentOffset += options.creationSize;
+
+        idWords = [];
+        for (let i = 0; i < idWordCount; i++) {
+          idWords.push(dataView.getUint32(currentOffset));
+          currentOffset += 4;
+        }
+      } else {
+        // REFERENCE_EXT: ID | Creation
+        idWords = [];
+        for (let i = 0; i < idWordCount; i++) {
+          idWords.push(dataView.getUint32(currentOffset));
+          currentOffset += 4;
+        }
 
-      const idWords = [];
-      for (let i = 0; i < len; i++) {
-        idWords.push(dataView.getUint32(currentOffset));
-        currentOffset += 4;
+        creation = dataView.getUint8(currentOffset);
+        currentOffset += 1;
       }
 
       return {
@@ -1172,27 +1218,25 @@ const Erlang = {
       };
     };
 
-    const decodeNewerReference = async (dataView, bytes, offset) => {
-      const len = dataView.getUint16(offset);
-      let currentOffset = offset + 2;
-
-      // Decode node name (atom)
-      const nodeResult = await decodeTerm(dataView, bytes, currentOffset);
-      currentOffset = nodeResult.newOffset;
-
-      const creation = dataView.getUint32(currentOffset);
-      currentOffset += 4;
+    const decodeReference = async (dataView, bytes, offset) => {
+      return await decodeReferenceWithOptions(dataView, bytes, offset, {
+        hasLengthPrefix: false,
+        creationSize: 1,
+      });
+    };
 
-      const idWords = [];
-      for (let i = 0; i < len; i++) {
-        idWords.push(dataView.getUint32(currentOffset));
-        currentOffset += 4;
-      }
+    const decodeNewReference = async (dataView, bytes, offset) => {
+      return await decodeReferenceWithOptions(dataView, bytes, offset, {
+        hasLengthPrefix: true,
+        creationSize: 1,
+      });
+    };
 
-      return {
-        term: Type.reference(nodeResult.term, creation, idWords),
-        newOffset: currentOffset,
-      };
+    const decodeNewerReference = async (dataView, bytes, offset) => {
+      return await decodeReferenceWithOptions(dataView, bytes, offset, {
+        hasLengthPrefix: true,
+        creationSize: 4,
+      });
     };
 
     // PID decoders
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 1b49a51180..8109c9fe51 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2133,6 +2133,14 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert :erlang.binary_to_term(binary) == bitstring
     end
 
+    test "decodes REFERENCE_EXT" do
+      binary =
+        <<131, 101, 119, 13, "nonode@nohost", 0, 0, 0, 42, 1>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_reference(decoded)
+    end
+
     test "decodes NEW_REFERENCE_EXT" do
       # Create a reference and encode/decode it
       ref = make_ref()
@@ -2141,6 +2149,14 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
       assert is_reference(decoded)
     end
 
+    test "decodes NEW_REFERENCE_EXT with ATOM_EXT" do
+      binary =
+        <<131, 114, 0, 3, 100, 0, 13, "nonode@nohost", 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3>>
+
+      decoded = :erlang.binary_to_term(binary)
+      assert is_reference(decoded)
+    end
+
     test "decodes NEWER_REFERENCE_EXT with SMALL_ATOM_UTF8_EXT" do
       # Manually construct NEWER_REFERENCE_EXT binary
       binary =
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index eaf4697fc6..597f6be5d1 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -2952,11 +2952,22 @@ describe("Erlang", () => {
         ];
         const header = new Uint8Array([131, 105, ...arityBytes]);
 
-        // Create element bytes: each element is SMALL_INTEGER_EXT (tag 97) + value
-        // Values 1 to 300, but modulo 256 for values > 255
+        // Create element bytes: use SMALL_INTEGER_EXT (tag 97) for values <=255,
+        // INTEGER_EXT (tag 98) for values >255
         const elementBytes = [];
         for (let i = 1; i <= arity; i++) {
-          elementBytes.push(97, i & 0xff); // SMALL_INTEGER_EXT + value (wraps at 256)
+          if (i <= 255) {
+            elementBytes.push(97, i); // SMALL_INTEGER_EXT + value
+          } else {
+            // INTEGER_EXT (tag 98) + 4 bytes big-endian signed integer
+            elementBytes.push(
+              98,
+              (i >> 24) & 0xff,
+              (i >> 16) & 0xff,
+              (i >> 8) & 0xff,
+              i & 0xff,
+            );
+          }
         }
 
         const binary = Bitstring.fromBytes(
@@ -2967,6 +2978,8 @@ describe("Erlang", () => {
         assert.strictEqual(Type.isTuple(result), true);
         assert.strictEqual(result.data.length, arity);
         assert.deepStrictEqual(result.data[0], Type.integer(1));
+        assert.deepStrictEqual(result.data[255], Type.integer(256)); // Verify no wraparound
+        assert.deepStrictEqual(result.data[299], Type.integer(300)); // Verify last element
       });
 
       it("decodes empty tuple", async () => {
@@ -3290,6 +3303,96 @@ describe("Erlang", () => {
         assert.strictEqual(result.creation, 0);
         assert.deepStrictEqual(result.idWords, [1, 2, 3]);
       });
+      it("decodes REFERENCE_EXT with SMALL_ATOM_UTF8_EXT", async () => {
+        // REFERENCE_EXT with SMALL_ATOM_UTF8_EXT node (deprecated format)
+        // 131 - VERSION_NUMBER
+        // 101 - REFERENCE_EXT
+        // 119 - SMALL_ATOM_UTF8_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // 0, 0, 0, 42 - single ID word (32-bit)
+        // 1 - creation (8-bit)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 101, 119, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 0, 42, 1,
+          ]),
+        );
+        const result = await binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 1);
+        assert.deepStrictEqual(result.idWords, [42]);
+      });
+
+      it("decodes REFERENCE_EXT with ATOM_EXT", async () => {
+        // REFERENCE_EXT with ATOM_EXT node (deprecated format)
+        // 131 - VERSION_NUMBER
+        // 101 - REFERENCE_EXT
+        // 100 - ATOM_EXT
+        // 0, 13 - node name length (16-bit)
+        // "nonode@nohost" - node name
+        // 0, 0, 0, 123 - single ID word (32-bit)
+        // 2 - creation (8-bit)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 101, 100, 0, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111,
+            104, 111, 115, 116, 0, 0, 0, 123, 2,
+          ]),
+        );
+        const result = await binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 2);
+        assert.deepStrictEqual(result.idWords, [123]);
+      });
+
+      it("decodes REFERENCE_EXT with SMALL_ATOM_EXT", async () => {
+        // REFERENCE_EXT with SMALL_ATOM_EXT node (deprecated format)
+        // 131 - VERSION_NUMBER
+        // 101 - REFERENCE_EXT
+        // 115 - SMALL_ATOM_EXT
+        // 13 - node name length
+        // "nonode@nohost" - node name
+        // 0, 0, 1, 200 - single ID word (32-bit)
+        // 3 - creation (8-bit)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 101, 115, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111, 104,
+            111, 115, 116, 0, 0, 1, 200, 3,
+          ]),
+        );
+        const result = await binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 3);
+        assert.deepStrictEqual(result.idWords, [456]);
+      });
+
+      it("decodes NEW_REFERENCE_EXT with ATOM_EXT", async () => {
+        // NEW_REFERENCE_EXT with ATOM_EXT node (deprecated format)
+        // 131 - VERSION_NUMBER
+        // 114 - NEW_REFERENCE_EXT
+        // 0, 3 - number of ID words (16-bit big-endian)
+        // 100 - ATOM_EXT
+        // 0, 13 - node name length (16-bit)
+        // "nonode@nohost" - node name
+        // 1 - creation (8-bit)
+        // 0, 0, 0, 1 - ID word 1 (32-bit)
+        // 0, 0, 0, 2 - ID word 2 (32-bit)
+        // 0, 0, 0, 3 - ID word 3 (32-bit)
+        const binary = Bitstring.fromBytes(
+          new Uint8Array([
+            131, 114, 0, 3, 100, 0, 13, 110, 111, 110, 111, 100, 101, 64, 110,
+            111, 104, 111, 115, 116, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3,
+          ]),
+        );
+        const result = await binary_to_term(binary);
+        assert.strictEqual(result.type, "reference");
+        assert.deepStrictEqual(result.node, Type.atom("nonode@nohost"));
+        assert.strictEqual(result.creation, 1);
+        assert.deepStrictEqual(result.idWords, [1, 2, 3]);
+      });
     });
 
     describe("pids", () => {

From 5c709b5614afaff558ef4065a4e03e0642d25ed6 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 3 Feb 2026 17:33:21 -0300
Subject: [PATCH 29/33] Use Interpreter.buildArgumentErrorMsg in tests

Replace hard-coded argument-error strings with
Interpreter.buildArgumentErrorMsg
calls in erlang_test.mjs. Also normalize spacing in imports and
object-literal
entries for consistent formatting.
---
 test/javascript/erlang/erlang_test.mjs | 106 +++++++++++++++++++------
 1 file changed, 80 insertions(+), 26 deletions(-)

diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 597f6be5d1..005ca570e7 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -11,7 +11,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -1419,7 +1419,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1433,7 +1433,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = andalso(
@@ -1459,7 +1459,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(
@@ -3608,7 +3608,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3630,7 +3633,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3659,7 +3665,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
     });
@@ -3669,7 +3678,7 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(Type.atom("test")),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: not a binary\n",
+          Interpreter.buildArgumentErrorMsg(1, "not a binary"),
         );
       });
 
@@ -3678,7 +3687,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3687,7 +3699,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3697,7 +3712,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3707,7 +3725,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3717,7 +3738,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3753,7 +3777,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3765,7 +3792,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3777,7 +3807,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3813,7 +3846,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3825,7 +3861,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3851,7 +3890,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3861,7 +3903,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3873,7 +3918,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3886,7 +3934,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3898,7 +3949,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "errors were found at the given arguments:\n\n  * 1st argument: invalid external representation of a term\n",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
     });
@@ -7584,7 +7638,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(true), right: Type.atom("abc")},
+        vars: { left: Type.boolean(true), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -7598,7 +7652,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: {left: Type.boolean(false), right: Type.atom("abc")},
+        vars: { left: Type.boolean(false), right: Type.atom("abc") },
       });
 
       const result = orelse(
@@ -7624,7 +7678,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: {left: Type.nil(), right: Type.boolean(true)},
+        vars: { left: Type.nil(), right: Type.boolean(true) },
       });
 
       assertBoxedError(

From 28c6ab59bc68fab09a9c22bcbc858bac759965e4 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 3 Feb 2026 18:01:17 -0300
Subject: [PATCH 30/33] chore: Add Erlang external-term format consistency
 tests

---
 assets/js/erlang/erlang.mjs                   |  18 +--
 .../ex_js_consistency/erlang/erlang_test.exs  | 122 ++++++++++++++++++
 test/javascript/erlang/erlang_test.mjs        |  14 +-
 3 files changed, 133 insertions(+), 21 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index d6f7be949e..016a380002 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -788,17 +788,6 @@ const Erlang = {
     // The decompressed data contains the ETF representation of the term without the version byte
 
     const decodeCompressed = async (dataView, bytes, offset) => {
-      // Disallow nested COMPRESSED: verify it is only used at top-level
-      // For top-level usage, offset should be 2 (version byte + COMPRESSED tag consumed)
-      if (offset !== 2) {
-        Interpreter.raiseArgumentError(
-          Interpreter.buildArgumentErrorMsg(
-            1,
-            "invalid external representation of a term",
-          ),
-        );
-      }
-
       if (offset + 4 > bytes.length) {
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
@@ -832,11 +821,12 @@ const Erlang = {
 
         const result = await decodeTerm(decompressedView, decompressed, 0);
 
-        // Return with newOffset pointing to end of original bytes since
-        // COMPRESSED must consume the entire remaining buffer at top-level
+        // Compute newOffset relative to the original bytes buffer
+        const newOffset = offset + 4 + compressedData.length;
+
         return {
           term: result.term,
-          newOffset: bytes.length,
+          newOffset: newOffset,
         };
       } catch (error) {
         console.error("Decode error:", error);
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 8109c9fe51..f791fa8d91 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2333,6 +2333,128 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
                    build_argument_error_msg(1, "invalid external representation of a term"),
                    {:erlang, :binary_to_term, [binary]}
     end
+
+    # Consistency tests for specific external term formats
+
+    test "STRING_EXT format with various byte values" do
+      # Test STRING_EXT (tag 107) with different byte ranges
+      test_cases = [
+        [0, 1, 2],
+        [255, 254, 253],
+        # ABC
+        [65, 66, 67],
+        [128, 129, 130],
+        # empty string
+        []
+      ]
+
+      for bytes <- test_cases do
+        binary = :erlang.term_to_binary(bytes)
+        assert :erlang.binary_to_term(binary) == bytes
+      end
+    end
+
+    test "ATOM_EXT format with Latin-1 atoms" do
+      # Test ATOM_EXT (tag 100) with various atom names
+      test_atoms = [
+        :test,
+        :hello_world,
+        :a,
+        # empty atom
+        :"",
+        :"special-atom!@#",
+        :atom_with_underscores_123
+      ]
+
+      for atom <- test_atoms do
+        # Manually construct ATOM_EXT binary
+        name = Atom.to_string(atom)
+        binary = <<131, 100, byte_size(name)::16, name::binary>>
+        assert :erlang.binary_to_term(binary) == atom
+      end
+    end
+
+    test "SMALL_ATOM_UTF8_EXT format with UTF-8 atoms" do
+      # Test SMALL_ATOM_UTF8_EXT (tag 119) with UTF-8 characters
+      test_atoms = [
+        :élixir,
+        :café,
+        :测试,
+        :"🚀",
+        :ñoño,
+        # regular ASCII for comparison
+        :test
+      ]
+
+      for atom <- test_atoms do
+        binary = :erlang.term_to_binary(atom)
+        assert :erlang.binary_to_term(binary) == atom
+      end
+    end
+
+    test "BINARY_EXT format with various binary data" do
+      # Test BINARY_EXT (tag 109) with different binary content
+      test_binaries = [
+        "",
+        "hello",
+        "world with spaces",
+        "binary\0with\0nulls",
+        "UTF-8: élixir café 测试 🚀",
+        <<0, 1, 2, 255, 254, 253>>,
+        # larger binary
+        String.duplicate("x", 1000)
+      ]
+
+      for bin <- test_binaries do
+        binary = :erlang.term_to_binary(bin)
+        assert :erlang.binary_to_term(binary) == bin
+      end
+    end
+
+    test "BIT_BINARY_EXT format with partial bytes" do
+      # Test BIT_BINARY_EXT (tag 77) with various bit lengths
+      test_bitstrings = [
+        <<1::1>>,
+        <<1::3>>,
+        <<15::4>>,
+        <<31::5>>,
+        # full byte
+        <<255::8>>,
+        # mixed bytes and bits
+        <<1, 2, 3::6>>,
+        # multiple bytes + 1 bit
+        <<255, 255, 1::1>>
+      ]
+
+      for bitstring <- test_bitstrings do
+        binary = :erlang.term_to_binary(bitstring)
+        assert :erlang.binary_to_term(binary) == bitstring
+      end
+    end
+
+    test "FLOAT_EXT format (deprecated string format)" do
+      # Test FLOAT_EXT (tag 99) - manually constructed deprecated format
+      test_floats = [
+        1.5,
+        -2.5,
+        3.14159,
+        0.0,
+        -0.0,
+        1.0e10,
+        1.23e-5
+      ]
+
+      for float_val <- test_floats do
+        # Manually construct FLOAT_EXT binary (31-byte null-terminated string)
+        iodata = :io_lib.format("~.20e", [float_val])
+        float_str = IO.iodata_to_binary(iodata)
+        padded = String.pad_trailing(float_str, 31, <<0>>)
+        binary = <<131, 99, padded::binary>>
+
+        decoded = :erlang.binary_to_term(binary)
+        assert_in_delta decoded, float_val, 1.0e-15
+      end
+    end
   end
 
   describe "bit_size/1" do
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 005ca570e7..04605485f2 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -11,7 +11,7 @@ import {
   defineGlobalErlangAndElixirModules,
 } from "../support/helpers.mjs";
 
-import { defineModule1Fixture as defineErlangModule1Fixture } from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
+import {defineModule1Fixture as defineErlangModule1Fixture} from "../support/fixtures/ex_js_consistency/erlang/module_1.mjs";
 
 import Bitstring from "../../../assets/js/bitstring.mjs";
 import Erlang from "../../../assets/js/erlang/erlang.mjs";
@@ -1419,7 +1419,7 @@ describe("Erlang", () => {
 
     it("returns false if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1433,7 +1433,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = andalso(
@@ -1459,7 +1459,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(
@@ -7638,7 +7638,7 @@ describe("Erlang", () => {
 
     it("returns true if the first argument is true", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(true), right: Type.atom("abc") },
+        vars: {left: Type.boolean(true), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7652,7 +7652,7 @@ describe("Erlang", () => {
 
     it("returns the second argument if the first argument is false", () => {
       const context = contextFixture({
-        vars: { left: Type.boolean(false), right: Type.atom("abc") },
+        vars: {left: Type.boolean(false), right: Type.atom("abc")},
       });
 
       const result = orelse(
@@ -7678,7 +7678,7 @@ describe("Erlang", () => {
 
     it("raises ArgumentError if the first argument is not a boolean", () => {
       const context = contextFixture({
-        vars: { left: Type.nil(), right: Type.boolean(true) },
+        vars: {left: Type.nil(), right: Type.boolean(true)},
       });
 
       assertBoxedError(

From 62e8464f19eba85714108190c11f772ef888bdaa Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 3 Feb 2026 18:27:47 -0300
Subject: [PATCH 31/33] chore: add bitstring js test

---
 assets/js/erlang/erlang.mjs                       |  9 +++++++--
 .../ex_js_consistency/erlang/erlang_test.exs      |  9 +++++++++
 test/elixir/hologram/template/renderer_test.exs   | 12 ++++++------
 test/javascript/erlang/erlang_test.mjs            | 15 ++++++++++++++-
 4 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 016a380002..668965d459 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -1081,7 +1081,12 @@ const Erlang = {
     const decodeFloatExt = (dataView, bytes, offset) => {
       // FLOAT_EXT: 31-byte null-terminated string (deprecated format)
       if (offset + 31 > bytes.length) {
-        Interpreter.raiseArgumentError("float string exceeds available bytes");
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
       }
       const floatBytes = bytes.slice(offset, offset + 31);
       const decoder = new TextDecoder("latin1");
@@ -1128,7 +1133,7 @@ const Erlang = {
       const bitstring = Bitstring.fromBytes(new Uint8Array(binaryBytes));
 
       // Adjust leftoverBitCount based on the bits field
-      // If bits is 0, all bytes are full (leftoverBitCount = 0)
+      // If bits is 8, all bytes are full (leftoverBitCount = 0)
       // If bits is 1-7, the last byte is partial (leftoverBitCount = bits)
       if (bits > 0 && bits < 8) {
         bitstring.leftoverBitCount = bits;
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index f791fa8d91..860c7f4b66 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2334,6 +2334,15 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
                    {:erlang, :binary_to_term, [binary]}
     end
 
+    test "raises ArgumentError for FLOAT_EXT with truncated data" do
+      # FLOAT_EXT (tag 99) with only 10 bytes instead of required 31
+      binary = <<131, 99, "1.23", 0, 0, 0, 0, 0, 0>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
     # Consistency tests for specific external term formats
 
     test "STRING_EXT format with various byte values" do
diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 14f61e9c45..1f1903371d 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module25, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module27, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry,
-              _server_struct} = render_page(Module24, @params, @server, @opts)
+              _component_registry, _server_struct} =
+               render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 04605485f2..081f1e6040 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3198,7 +3198,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "float string exceeds available bytes",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
     });
@@ -3682,6 +3685,16 @@ describe("Erlang", () => {
         );
       });
 
+      it("raises ArgumentError if argument is a non-binary bitstring", async () => {
+        const bits = Bitstring.fromBits([1, 0, 1]);
+
+        await assertBoxedErrorAsync(
+          () => binary_to_term(bits),
+          "ArgumentError",
+          Interpreter.buildArgumentErrorMsg(1, "not a binary"),
+        );
+      });
+
       it("raises ArgumentError if binary has invalid version byte", async () => {
         const binary = Bitstring.fromBytes(new Uint8Array([130, 97, 42])); // Wrong version
         await assertBoxedErrorAsync(

From 6a2cc8734a9cf2f4bb7743f54a4c5f23c55f0f46 Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Tue, 3 Feb 2026 18:56:16 -0300
Subject: [PATCH 32/33] chore: fix error message to match with erlang error
 message.

---
 assets/js/erlang/erlang.mjs                   | 77 ++++++++++++++++---
 .../ex_js_consistency/erlang/erlang_test.exs  | 27 +++++++
 .../hologram/template/renderer_test.exs       | 12 +--
 test/javascript/erlang/erlang_test.mjs        | 45 +++++------
 4 files changed, 119 insertions(+), 42 deletions(-)

diff --git a/assets/js/erlang/erlang.mjs b/assets/js/erlang/erlang.mjs
index 668965d459..e68ff6a026 100644
--- a/assets/js/erlang/erlang.mjs
+++ b/assets/js/erlang/erlang.mjs
@@ -638,7 +638,7 @@ const Erlang = {
     const V4_PORT_EXT = 120;
 
     // Decompresses zlib-compressed data using native DecompressionStream API
-    // Returns a Promise that resolves to a Uint8Array with the decompressed data
+    // Returns a Promise that resolves to {data: Uint8Array, bytesRead: number}
     // Throws an error if decompression fails
     const zlibInflate = async (compressedData) => {
       const stream = new ReadableStream({
@@ -673,7 +673,12 @@ const Erlang = {
         throw new Error(`Decompression failed: ${err.message}`);
       }
 
-      return Utils.concatUint8Arrays(chunks);
+      // NOTE: This is a simplified approach - in a full implementation,
+      // we would need to parse the zlib stream to determine exact bytes consumed
+      return {
+        data: Utils.concatUint8Arrays(chunks),
+        bytesRead: compressedData.length,
+      };
     };
 
     const decodeTerm = async (dataView, bytes, offset) => {
@@ -802,7 +807,8 @@ const Erlang = {
 
       try {
         // Use native DecompressionStream for zlib decompression
-        const decompressed = await zlibInflate(compressedData);
+        const {data: decompressed, bytesRead} =
+          await zlibInflate(compressedData);
 
         if (decompressed.length !== uncompressedSize) {
           Interpreter.raiseArgumentError(
@@ -821,15 +827,23 @@ const Erlang = {
 
         const result = await decodeTerm(decompressedView, decompressed, 0);
 
+        if (result.newOffset !== decompressed.length) {
+          Interpreter.raiseArgumentError(
+            Interpreter.buildArgumentErrorMsg(
+              1,
+              "invalid external representation of a term",
+            ),
+          );
+        }
+
         // Compute newOffset relative to the original bytes buffer
-        const newOffset = offset + 4 + compressedData.length;
+        const newOffset = offset + 4 + bytesRead;
 
         return {
           term: result.term,
           newOffset: newOffset,
         };
-      } catch (error) {
-        console.error("Decode error:", error);
+      } catch {
         Interpreter.raiseArgumentError(
           Interpreter.buildArgumentErrorMsg(
             1,
@@ -861,6 +875,15 @@ const Erlang = {
       const n = dataView.getUint8(offset);
       const sign = dataView.getUint8(offset + 1);
 
+      if (sign !== 0 && sign !== 1) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
       let value = 0n;
       for (let i = 0; i < n; i++) {
         const byte = BigInt(bytes[offset + 2 + i]);
@@ -881,6 +904,15 @@ const Erlang = {
       const n = dataView.getUint32(offset);
       const sign = dataView.getUint8(offset + 4);
 
+      if (sign !== 0 && sign !== 1) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
+
       let value = 0n;
       for (let i = 0; i < n; i++) {
         const byte = BigInt(bytes[offset + 5 + i]);
@@ -903,7 +935,10 @@ const Erlang = {
       const length = dataView.getUint16(offset);
       if (offset + 2 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          "invalid external representation of a term",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       }
       const atomBytes = bytes.slice(offset + 2, offset + 2 + length);
@@ -922,7 +957,10 @@ const Erlang = {
       const length = dataView.getUint8(offset);
       if (offset + 1 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `atom length exceeds available bytes: ${length}`,
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       }
       const atomBytes = bytes.slice(offset + 1, offset + 1 + length);
@@ -942,7 +980,10 @@ const Erlang = {
       const length = dataView.getUint32(offset);
       if (offset + 4 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `binary length exceeds available bytes: ${length}`,
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       }
       const binaryBytes = bytes.slice(offset + 4, offset + 4 + length);
@@ -995,7 +1036,10 @@ const Erlang = {
       const length = dataView.getUint16(offset);
       if (offset + 2 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          "invalid external representation of a term",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       }
       const elements = [];
@@ -1125,7 +1169,10 @@ const Erlang = {
 
       if (offset + 5 + length > bytes.length) {
         Interpreter.raiseArgumentError(
-          `bit binary length exceeds available bytes: ${length}`,
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       }
 
@@ -1398,6 +1445,14 @@ const Erlang = {
       }
 
       const result = await decodeTerm(dataView, bytes, 1);
+      if (result.newOffset !== bytes.length) {
+        Interpreter.raiseArgumentError(
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
+        );
+      }
       return result.term;
     } catch (err) {
       if (err instanceof RangeError || err instanceof TypeError) {
diff --git a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
index 860c7f4b66..10cc266645 100644
--- a/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
+++ b/test/elixir/hologram/ex_js_consistency/erlang/erlang_test.exs
@@ -2343,6 +2343,33 @@ defmodule Hologram.ExJsConsistency.Erlang.ErlangTest do
                    {:erlang, :binary_to_term, [binary]}
     end
 
+    test "raises ArgumentError for malformed SMALL_ATOM_UTF8_EXT with length exceeding data" do
+      # SMALL_ATOM_UTF8_EXT (119) with length 50 but only 2 bytes
+      binary = <<131, 119, 50, 65, 66>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
+    test "raises ArgumentError for malformed ATOM_EXT with length exceeding data" do
+      # ATOM_EXT (100) with length 100 but only 2 bytes
+      binary = <<131, 100, 0, 100, 65, 66>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
+    test "raises ArgumentError for malformed STRING_EXT with length exceeding data" do
+      # STRING_EXT (107) with length 100 but only 2 bytes of data
+      binary = <<131, 107, 0, 100, 65, 66>>
+
+      assert_error ArgumentError,
+                   build_argument_error_msg(1, "invalid external representation of a term"),
+                   {:erlang, :binary_to_term, [binary]}
+    end
+
     # Consistency tests for specific external term formats
 
     test "STRING_EXT format with various byte values" do
diff --git a/test/elixir/hologram/template/renderer_test.exs b/test/elixir/hologram/template/renderer_test.exs
index 1f1903371d..14f61e9c45 100644
--- a/test/elixir/hologram/template/renderer_test.exs
+++ b/test/elixir/hologram/template/renderer_test.exs
@@ -933,16 +933,16 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module25, :dummy_module_25_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module25, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module25, @params, @server, @opts)
     end
 
     test "cast layout props passed implicitely from page state" do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module27, :dummy_module_27_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, prop_1: &quot;prop_value_1&quot;, prop_3: &quot;prop_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module27, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module27, @params, @server, @opts)
     end
 
     test "aggregate page vars, giving state vars priority over param vars when there are name conflicts" do
@@ -958,8 +958,8 @@ defmodule Hologram.Template.RendererTest do
       ETS.put(PageDigestRegistryStub.ets_table_name(), Module24, :dummy_module_24_digest)
 
       assert {~s'layout vars = %{cid: &quot;layout&quot;, key_1: &quot;prop_value_1&quot;, key_2: &quot;state_value_2&quot;, key_3: &quot;state_value_3&quot;}',
-              _component_registry, _server_struct} =
-               render_page(Module24, @params, @server, @opts)
+              _component_registry,
+              _server_struct} = render_page(Module24, @params, @server, @opts)
     end
 
     test "merge the page component struct into the result" do
diff --git a/test/javascript/erlang/erlang_test.mjs b/test/javascript/erlang/erlang_test.mjs
index 081f1e6040..c3f0685bdf 100644
--- a/test/javascript/erlang/erlang_test.mjs
+++ b/test/javascript/erlang/erlang_test.mjs
@@ -3583,26 +3583,6 @@ describe("Erlang", () => {
         assertBoxedStrictEqual(result, expectedList);
       });
 
-      it("validates internal zlibInflate functionality within binary_to_term context", async () => {
-        // This test validates that the zlibInflate function was successfully moved from Utils
-        // to within the binary_to_term context and still works correctly for compressed terms.
-
-        // Use the same working test data as the first compressed test
-        const binary = Bitstring.fromBytes(
-          new Uint8Array([
-            131, 80, 0, 0, 1, 249, 120, 218, 203, 101, 96, 96, 252, 146, 145,
-            154, 147, 147, 63, 74, 140, 40, 2, 0, 21, 94, 209, 51,
-          ]),
-        );
-
-        const result = await binary_to_term(binary);
-        const expected = Type.bitstring("hello".repeat(100));
-
-        // Verify the result to ensure zlibInflate worked correctly
-        // This confirms that the moved zlibInflate function is working properly
-        assertBoxedStrictEqual(result, expected);
-      });
-
       it("raises ArgumentError for compressed term with truncated uncompressed size", async () => {
         // COMPRESSED tag but missing uncompressed size bytes
         const binary = Bitstring.fromBytes(
@@ -3766,7 +3746,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "binary length exceeds available bytes: 10",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3778,7 +3761,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "invalid external representation of a term",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3835,7 +3821,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "invalid external representation of a term",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3847,7 +3836,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "atom length exceeds available bytes: 50",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 
@@ -3889,7 +3881,10 @@ describe("Erlang", () => {
         await assertBoxedErrorAsync(
           () => binary_to_term(binary),
           "ArgumentError",
-          "bit binary length exceeds available bytes: 100",
+          Interpreter.buildArgumentErrorMsg(
+            1,
+            "invalid external representation of a term",
+          ),
         );
       });
 

From 268786a7c6a60e3df7521830502ed4e8dfad8a8b Mon Sep 17 00:00:00 2001
From: vinicius <niviciusdev@gmail.com>
Date: Wed, 4 Feb 2026 00:25:50 -0300
Subject: [PATCH 33/33] refactor: Extract validateBoxedError helper

---
 test/javascript/support/helpers.mjs | 69 +++++++----------------------
 1 file changed, 16 insertions(+), 53 deletions(-)

diff --git a/test/javascript/support/helpers.mjs b/test/javascript/support/helpers.mjs
index 5421739823..248dfd784c 100644
--- a/test/javascript/support/helpers.mjs
+++ b/test/javascript/support/helpers.mjs
@@ -42,27 +42,14 @@ export {h as vnode} from "../../../assets/node_modules/snabbdom/build/index.js";
 export const UUID_REGEX =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 
-export function assertBoxedError(
-  callable,
-  expectedErrorType,
-  expectedErrorMessage,
-) {
+function validateBoxedError(error, expectedErrorType, expectedErrorMessage) {
   const isRegex = expectedErrorMessage instanceof RegExp;
-
   const expectedMessageDisplay = isRegex
     ? expectedErrorMessage.toString()
     : expectedErrorMessage;
 
   const failMessagePrefix = `\nexpected:\n${expectedErrorType}: ${expectedMessageDisplay}\n`;
 
-  let error;
-
-  try {
-    callable();
-  } catch (e) {
-    error = e;
-  }
-
   if (!error) {
     assert.fail(failMessagePrefix + "but got no error");
   }
@@ -77,7 +64,6 @@ export function assertBoxedError(
   const receivedErrorMessage = Interpreter.getErrorMessage(error);
 
   const typeMatches = receivedErrorType === expectedErrorType;
-
   const messageMatches = isRegex
     ? expectedErrorMessage.test(receivedErrorMessage)
     : Interpreter.isStrictlyEqual(
@@ -93,55 +79,32 @@ export function assertBoxedError(
   }
 }
 
+export function assertBoxedError(
+  callable,
+  expectedErrorType,
+  expectedErrorMessage,
+) {
+  let error;
+  try {
+    callable();
+  } catch (e) {
+    error = e;
+  }
+  validateBoxedError(error, expectedErrorType, expectedErrorMessage);
+}
+
 export async function assertBoxedErrorAsync(
   asyncCallable,
   expectedErrorType,
   expectedErrorMessage,
 ) {
-  const isRegex = expectedErrorMessage instanceof RegExp;
-
-  const expectedMessageDisplay = isRegex
-    ? expectedErrorMessage.toString()
-    : expectedErrorMessage;
-
-  const failMessagePrefix = `\nexpected:\n${expectedErrorType}: ${expectedMessageDisplay}\n`;
-
   let error;
-
   try {
     await asyncCallable();
   } catch (e) {
     error = e;
   }
-
-  if (!error) {
-    assert.fail(failMessagePrefix + "but got no error");
-  }
-
-  if (!(error instanceof HologramBoxedError)) {
-    assert.fail(
-      failMessagePrefix + `but got:\n${error.name}: ${error.message}`,
-    );
-  }
-
-  const receivedErrorType = Interpreter.getErrorType(error);
-  const receivedErrorMessage = Interpreter.getErrorMessage(error);
-
-  const typeMatches = receivedErrorType === expectedErrorType;
-
-  const messageMatches = isRegex
-    ? expectedErrorMessage.test(receivedErrorMessage)
-    : Interpreter.isStrictlyEqual(
-        error.struct,
-        Type.errorStruct(expectedErrorType, expectedErrorMessage),
-      );
-
-  if (!typeMatches || !messageMatches) {
-    assert.fail(
-      failMessagePrefix +
-        `but got:\n${receivedErrorType}: ${receivedErrorMessage}`,
-    );
-  }
+  validateBoxedError(error, expectedErrorType, expectedErrorMessage);
 }
 
 export function assertBoxedFalse(boxed) {