diff --git a/.envrc b/.envrc
index 60f1536b5..d4a7ef2b6 100644
--- a/.envrc
+++ b/.envrc
@@ -3,3 +3,4 @@ export PATH="$PWD/javascript/packages/printer/bin:$PATH"
 export PATH="$PWD/javascript/packages/formatter/bin:$PATH"
 export PATH="$PWD/javascript/packages/language-server/bin:$PATH"
 export PATH="$PWD/javascript/packages/highlighter/bin:$PATH"
+export PATH="$PWD/javascript/packages/stimulus-lint/bin:$PATH"
diff --git a/.github/workflows/build-gems.yml b/.github/workflows/build-gems.yml
index 8fa627fd9..2082d4f02 100644
--- a/.github/workflows/build-gems.yml
+++ b/.github/workflows/build-gems.yml
@@ -65,7 +65,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index cd5820660..283fa105d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,6 +1,6 @@
 name: Build
 
-on: [push]
+on: [push, pull_request]
 
 permissions:
   contents: read
@@ -18,7 +18,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
@@ -57,13 +57,13 @@ jobs:
         run: ./run_herb_tests
 
       - name: clang-format version
-        run: clang-format-19 --version
+        run: clang-format-21 --version
 
       - name: Lint
         run: bin/lint
 
       - name: clang-tidy version
-        run: clang-tidy-19 --version
+        run: clang-tidy-21 --version
 
       - name: Tidy
         run: bin/tidy
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 038be7d83..84d94d085 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -43,7 +43,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/.github/workflows/javascript.yml b/.github/workflows/javascript.yml
index 25e0de88a..35b873fc1 100644
--- a/.github/workflows/javascript.yml
+++ b/.github/workflows/javascript.yml
@@ -30,7 +30,7 @@ jobs:
       - name: Add LLVM apt Repo
         run: |-
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 main"
+          sudo add-apt-repository "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-21 main"
           sudo apt update
 
       - name: Install APT dependencies
diff --git a/Aptfile b/Aptfile
index df7a373cf..d52b811d7 100644
--- a/Aptfile
+++ b/Aptfile
@@ -1,7 +1,7 @@
 check
-clang-19
-clang-format-19
-clang-tidy-19
+clang-21
+clang-format-21
+clang-tidy-21
 emscripten
 doxygen
 xvfb
diff --git a/Brewfile b/Brewfile
index b127e58ba..c568821f3 100644
--- a/Brewfile
+++ b/Brewfile
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 brew "check"
-brew "llvm@19" # for clang, clang-format and clang-tidy
+brew "llvm@21" # for clang, clang-format and clang-tidy
 brew "emscripten"
 brew "doxygen"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e0bdc6276..04f6f9ad0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,17 +2,17 @@
 
 Pull request, bug reports, and any other forms of contribution are welcomed and highly encouraged.
 
-If you encounter any issues when following along with this file please dont hesitate to reach out and file an issue!
+If you encounter any issues when following along with this file please don't hesitate to reach out and file an issue!
 
 ## Running Locally
 
 ### Requirements
 
 - [**Check**](https://libcheck.github.io/check/): For unit testing.
-- [**Clang 19**](https://clang.llvm.org): The compiler used to build this project.
-- [**Clang Format 19**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
-- [**Clang Tidy 19**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
-- [**Prism Ruby Parser v1.5.1**](https://github.com/ruby/prism/releases/tag/v1.5.1): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
+- [**Clang 21**](https://clang.llvm.org): The compiler used to build this project.
+- [**Clang Format 21**](https://clang.llvm.org/docs/ClangFormat.html): For formatting the project.
+- [**Clang Tidy 21**](https://clang.llvm.org/extra/clang-tidy/): For linting the project.
+- [**Prism Ruby Parser v1.6.0**](https://github.com/ruby/prism/releases/tag/v1.6.0): We use Prism for Parsing the Ruby Source Code in the HTML+ERB files.
 - [**Ruby**](https://www.ruby-lang.org/en/): We need Ruby as a dependency for `bundler`.
 - [**Bundler**](https://bundler.io): We are using `bundler` to build [`prism`](https://github.com/ruby/prism) from source so we can build `herb` against it.
 - [**Emscripten**](https://emscripten.org): For the WebAssembly build of `libherb` so it can be used in the browser using the [`@herb-tools/browser`](https://github.com/marcoroth/herb/blob/main/javascript/packages/browser) package.
@@ -27,7 +27,7 @@ xargs sudo apt-get install < Aptfile
 or:
 
 ```bash
-sudo apt-get install check clang-19 clang-tidy-19 clang-format-19 emscripten doxygen
+sudo apt-get install check clang-21 clang-tidy-21 clang-format-21 emscripten doxygen
 ```
 
 ##### For macOS (using Homebrew)
@@ -38,7 +38,7 @@ brew bundle
 or:
 
 ```bash
-brew install check llvm@19 emscripten doxygen
+brew install check llvm@21 emscripten doxygen
 ```
 
 ### Building
@@ -73,7 +73,6 @@ The `herb` executable exposes a few commands for interacting with `.html.erb` fi
 Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.
 
 ./herb lex [file]      -  Lex a file
-./herb lex_json [file] -  Lex a file and return the result as json.
 ./herb parse [file]    -  Parse a file
 ./herb ruby [file]     -  Extract Ruby from a file
 ./herb html [file]     -  Extract HTML from a file
diff --git a/Gemfile b/Gemfile
index b23142024..fe40af78f 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "prism", github: "ruby/prism", tag: "v1.5.1"
+gem "prism", github: "ruby/prism", tag: "v1.6.0"
 
 gem "actionview", "~> 8.0"
 gem "lz_string"
diff --git a/Gemfile.lock b/Gemfile.lock
index 4e87cabfe..5129d66c8 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -9,15 +9,15 @@ GIT
 
 GIT
   remote: https://github.com/ruby/prism.git
-  revision: 23f16d31a7c57c4b927e1e3ec8f1281b45e7cb9f
-  tag: v1.5.1
+  revision: 2924f8f8832d57def7895cd7e2cc199ee58b3a3b
+  tag: v1.6.0
   specs:
-    prism (1.5.1)
+    prism (1.6.0)
 
 PATH
   remote: .
   specs:
-    herb (0.7.4)
+    herb (0.7.5)
 
 GEM
   remote: https://rubygems.org/
diff --git a/Makefile b/Makefile
index 8b09e67f9..137f736d9 100644
--- a/Makefile
+++ b/Makefile
@@ -61,16 +61,16 @@ shared_flags = $(production_flags) $(shared_library_flags) $(prism_flags)
 ifeq ($(os),Linux)
   test_cflags = $(test_flags) -I/usr/include/check
   test_ldflags = -L/usr/lib/x86_64-linux-gnu -lcheck -lm -lsubunit $(prism_ldflags)
-  cc = clang-19
-  clang_format = clang-format-19
-  clang_tidy = clang-tidy-19
+  cc = clang-21
+  clang_format = clang-format-21
+  clang_tidy = clang-tidy-21
 endif
 
 ifeq ($(os),Darwin)
   brew_prefix := $(shell brew --prefix check)
   test_cflags = $(test_flags) -I$(brew_prefix)/include
   test_ldflags = -L$(brew_prefix)/lib -lcheck -lm $(prism_ldflags)
-  llvm_path = $(shell brew --prefix llvm@19)
+  llvm_path = $(shell brew --prefix llvm@21)
   cc = $(llvm_path)/bin/clang
   clang_format = $(llvm_path)/bin/clang-format
   clang_tidy = $(llvm_path)/bin/clang-tidy
diff --git a/bin/leaks_parse b/bin/leaks_parse
index 603132e80..0212a2948 100755
--- a/bin/leaks_parse
+++ b/bin/leaks_parse
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 if [ -z "$1" ]; then
-  echo "Usage: $0 <file>"
+  echo "Usage: $0 <file_or_directory>"
   exit 1
 fi
 
@@ -10,4 +10,13 @@ if [[ "$(uname)" != "Darwin" ]]; then
   exit 0
 fi
 
-leaks --atExit -- ./herb parse "$1"
+TARGET="$1"
+
+if [ -d "$TARGET" ]; then
+  while IFS= read -r -d '' file; do
+    echo "Checking $file for leaks..."
+    leaks --atExit -- ./herb parse "$file" --silent || exit 1
+  done < <(find "$TARGET" -name "*.html.erb" -type f -print0)
+else
+  leaks --atExit -- ./herb parse "$TARGET" --silent
+fi
diff --git a/bin/publish_packages b/bin/publish_packages
new file mode 100755
index 000000000..10766ab81
--- /dev/null
+++ b/bin/publish_packages
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -euo pipefail
+
+echo "Building all packages..."
+yarn nx run-many -t build --all
+
+echo "Running tests in all packages..."
+yarn nx run-many -t test --all
+
+for package_dir in javascript/packages/*; do
+  if [ -d "$package_dir" ] && [ -f "$package_dir/package.json" ]; then
+    package=$(basename "$package_dir")
+
+    if [ "$package" = "vscode" ]; then
+      echo "Skipping vscode package..."
+      continue
+    fi
+
+    echo "Publishing $package..."
+    (cd "$package_dir" && yarn publish)
+  fi
+done
+
+echo "All packages published successfully!"
diff --git a/bin/setup b/bin/setup
index 361c7f2e6..bb27d1eb8 100755
--- a/bin/setup
+++ b/bin/setup
@@ -2,5 +2,7 @@
 
 set -e  # Exit on error
 
-make prism
-make all
+bundle install
+bundle exec rake templates
+yarn install
+yarn build
diff --git a/config.yml b/config.yml
index b67bfb480..df26a43fa 100644
--- a/config.yml
+++ b/config.yml
@@ -34,8 +34,8 @@ errors:
         arguments:
           - token_type_to_string(found->type)
           - token_type_to_string(expected_type)
-          - found->location->start->line
-          - found->location->start->column
+          - found->location.start.line
+          - found->location.start.column
 
       fields:
         - name: expected_type
@@ -49,8 +49,8 @@ errors:
         template: "Found closing tag `</%s>` at (%zu:%zu) without a matching opening tag."
         arguments:
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: closing_tag
@@ -61,8 +61,8 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) doesn't have a matching closing tag `</%s>`."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - opening_tag->value
 
       fields:
@@ -74,11 +74,11 @@ errors:
         template: "Opening tag `<%s>` at (%zu:%zu) closed with `</%s>` at (%zu:%zu)."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
           - closing_tag->value
-          - closing_tag->location->start->line
-          - closing_tag->location->start->column
+          - closing_tag->location.start.line
+          - closing_tag->location.start.column
 
       fields:
         - name: opening_tag
@@ -93,8 +93,8 @@ errors:
         arguments:
           - opening_quote->value
           - closing_quote->value
-          - closing_quote->location->start->line
-          - closing_quote->location->start->column
+          - closing_quote->location.start.line
+          - closing_quote->location.start.column
 
       fields:
         - name: opening_quote
@@ -127,8 +127,8 @@ errors:
         template: "Tag `<%s>` opened at (%zu:%zu) was never closed before the end of document."
         arguments:
           - opening_tag->value
-          - opening_tag->location->start->line
-          - opening_tag->location->start->column
+          - opening_tag->location.start.line
+          - opening_tag->location.start.column
 
       fields:
         - name: opening_tag
diff --git a/docs/.vitepress/theme/components/GitHubContributors.vue b/docs/.vitepress/theme/components/GitHubContributors.vue
index 5b94a1549..487728c64 100644
--- a/docs/.vitepress/theme/components/GitHubContributors.vue
+++ b/docs/.vitepress/theme/components/GitHubContributors.vue
@@ -23,7 +23,10 @@ const error = ref(null)
 
 onMounted(async () => {
   try {
-    contributors.value = contributorsFile.slice(0, props.limit)
+    const excludedUsernames = ['marcoroth', 'dependabot[bot]']
+    const filteredContributors = contributorsFile.filter(contributor => !excludedUsernames.includes(contributor.login))
+    contributors.value = filteredContributors.slice(0, props.limit)
+
     loading.value = false
   } catch (err) {
     error.value = `Failed to load contributors data for ${props.owner}/${props.repo}. Make sure the data file exists.`
diff --git a/docs/.vitepress/transformers/herb-linter-transformer.mts b/docs/.vitepress/transformers/herb-linter-transformer.mts
index 329189480..01cb4b02c 100644
--- a/docs/.vitepress/transformers/herb-linter-transformer.mts
+++ b/docs/.vitepress/transformers/herb-linter-transformer.mts
@@ -21,9 +21,9 @@ function createCustomTwoslashFunction(optionse) {
   return (code, lang, options) => {
     let fileName = undefined
 
-    // kinda of a hack to make sure we pass a `fileName` for the `erb-requires-trailing-newline` rule
+    // kind of a hack to make sure we pass a `fileName` for the `erb-require-trailing-newline` rule
     if (code.includes('▌')) {
-      fileName = "erb-requires-trailing-newline.html.erb"
+      fileName = "erb-require-trailing-newline.html.erb"
     }
 
     if (!lang || !['erb', 'html'].includes(lang)) {
diff --git a/docs/package.json b/docs/package.json
index f6685b400..cbda66736 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -19,9 +19,9 @@
     "fetch:contributors": "mkdir -p .vitepress/data/ && gh api -X get https://api.github.com/repos/marcoroth/herb/contributors > .vitepress/data/contributors.json"
   },
   "dependencies": {
-    "@herb-tools/browser": "0.7.4",
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node": "0.7.4"
+    "@herb-tools/browser": "0.7.5",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node": "0.7.5"
   },
   "devDependencies": {
     "@shikijs/vitepress-twoslash": "^3.4.2",
diff --git a/examples/block_comment.html.erb b/examples/block_comment.html.erb
new file mode 100644
index 000000000..c424fd687
--- /dev/null
+++ b/examples/block_comment.html.erb
@@ -0,0 +1,7 @@
+<%
+=begin %>
+  This, while unusual, is a legal form of commenting.
+<%
+=end %>
+
+<div>Content</div>
diff --git a/examples/case_in.html.erb b/examples/case_in.html.erb
new file mode 100644
index 000000000..ff4e756d0
--- /dev/null
+++ b/examples/case_in.html.erb
@@ -0,0 +1,6 @@
+<% case {} %>
+<% in {} %>
+  "matched"
+<% else %>
+  "not matched"
+<% end %>
diff --git a/examples/complete_erb.html.erb b/examples/complete_erb.html.erb
new file mode 100644
index 000000000..7b1b244a8
--- /dev/null
+++ b/examples/complete_erb.html.erb
@@ -0,0 +1 @@
+<%= hello %>
diff --git a/examples/incomplete_erb.invalid.html.erb b/examples/incomplete_erb.invalid.html.erb
new file mode 100644
index 000000000..56157a8bb
--- /dev/null
+++ b/examples/incomplete_erb.invalid.html.erb
@@ -0,0 +1 @@
+<%= hello
diff --git a/ext/herb/extconf.rb b/ext/herb/extconf.rb
index 5dc44cfe4..cb215e568 100644
--- a/ext/herb/extconf.rb
+++ b/ext/herb/extconf.rb
@@ -15,6 +15,7 @@
 prism_include_path = "#{prism_path}/include"
 
 $VPATH << "$(srcdir)/../../src"
+$VPATH << "$(srcdir)/../../src/util"
 $VPATH << prism_src_path
 $VPATH << "#{prism_src_path}/util"
 
diff --git a/ext/herb/extension.c b/ext/herb/extension.c
index 7f83a0090..155908ac3 100644
--- a/ext/herb/extension.c
+++ b/ext/herb/extension.c
@@ -19,7 +19,7 @@ VALUE cParseResult;
 static VALUE Herb_lex(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
 
-  array_T* tokens = herb_lex(string);
+  hb_array_T* tokens = herb_lex(string);
 
   VALUE result = create_lex_result(tokens, source);
 
@@ -30,7 +30,7 @@ static VALUE Herb_lex(VALUE self, VALUE source) {
 
 static VALUE Herb_lex_file(VALUE self, VALUE path) {
   char* file_path = (char*) check_string(path);
-  array_T* tokens = herb_lex_file(file_path);
+  hb_array_T* tokens = herb_lex_file(file_path);
 
   VALUE source_value = read_file_to_ruby_string(file_path);
   VALUE result = create_lex_result(tokens, source_value);
@@ -85,45 +85,30 @@ static VALUE Herb_parse_file(VALUE self, VALUE path) {
   return result;
 }
 
-static VALUE Herb_lex_to_json(VALUE self, VALUE source) {
-  char* string = (char*) check_string(source);
-  buffer_T output;
-
-  if (!buffer_init(&output)) { return Qnil; }
-
-  herb_lex_json_to_buffer(string, &output);
-
-  VALUE result = rb_str_new(output.value, output.length);
-
-  buffer_free(&output);
-
-  return result;
-}
-
 static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output)) { return Qnil; }
+  if (!hb_buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_ruby_to_buffer(string, &output);
 
   VALUE result = rb_utf8_str_new_cstr(output.value);
-  buffer_free(&output);
+  free(output.value);
 
   return result;
 }
 
 static VALUE Herb_extract_html(VALUE self, VALUE source) {
   char* string = (char*) check_string(source);
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output)) { return Qnil; }
+  if (!hb_buffer_init(&output, strlen(string))) { return Qnil; }
 
   herb_extract_html_to_buffer(string, &output);
 
   VALUE result = rb_utf8_str_new_cstr(output.value);
-  buffer_free(&output);
+  free(output.value);
 
   return result;
 }
@@ -151,7 +136,6 @@ void Init_herb(void) {
   rb_define_singleton_method(mHerb, "lex", Herb_lex, 1);
   rb_define_singleton_method(mHerb, "parse_file", Herb_parse_file, 1);
   rb_define_singleton_method(mHerb, "lex_file", Herb_lex_file, 1);
-  rb_define_singleton_method(mHerb, "lex_to_json", Herb_lex_to_json, 1);
   rb_define_singleton_method(mHerb, "extract_ruby", Herb_extract_ruby, 1);
   rb_define_singleton_method(mHerb, "extract_html", Herb_extract_html, 1);
   rb_define_singleton_method(mHerb, "version", Herb_version, 0);
diff --git a/ext/herb/extension_helpers.c b/ext/herb/extension_helpers.c
index 875f34d1f..2cfc0602b 100644
--- a/ext/herb/extension_helpers.c
+++ b/ext/herb/extension_helpers.c
@@ -20,32 +20,26 @@ const char* check_string(VALUE value) {
   return RSTRING_PTR(value);
 }
 
-VALUE rb_position_from_c_struct(position_T* position) {
-  if (!position) { return Qnil; }
-
+VALUE rb_position_from_c_struct(position_T position) {
   VALUE args[2];
-  args[0] = SIZET2NUM(position->line);
-  args[1] = SIZET2NUM(position->column);
+  args[0] = UINT2NUM(position.line);
+  args[1] = UINT2NUM(position.column);
 
   return rb_class_new_instance(2, args, cPosition);
 }
 
-VALUE rb_location_from_c_struct(location_T* location) {
-  if (!location) { return Qnil; }
-
+VALUE rb_location_from_c_struct(location_T location) {
   VALUE args[2];
-  args[0] = rb_position_from_c_struct(location->start);
-  args[1] = rb_position_from_c_struct(location->end);
+  args[0] = rb_position_from_c_struct(location.start);
+  args[1] = rb_position_from_c_struct(location.end);
 
   return rb_class_new_instance(2, args, cLocation);
 }
 
-VALUE rb_range_from_c_struct(range_T* range) {
-  if (!range) { return Qnil; }
-
+VALUE rb_range_from_c_struct(range_T range) {
   VALUE args[2];
-  args[0] = SIZET2NUM(range->from);
-  args[1] = SIZET2NUM(range->to);
+  args[0] = UINT2NUM(range.from);
+  args[1] = UINT2NUM(range.to);
 
   return rb_class_new_instance(2, args, cRange);
 }
@@ -64,13 +58,13 @@ VALUE rb_token_from_c_struct(token_T* token) {
   return rb_class_new_instance(4, args, cToken);
 }
 
-VALUE create_lex_result(array_T* tokens, VALUE source) {
+VALUE create_lex_result(hb_array_T* tokens, VALUE source) {
   VALUE value = rb_ary_new();
   VALUE warnings = rb_ary_new();
   VALUE errors = rb_ary_new();
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    token_T* token = hb_array_get(tokens, i);
     if (token != NULL) { rb_ary_push(value, rb_token_from_c_struct(token)); }
   }
 
diff --git a/ext/herb/extension_helpers.h b/ext/herb/extension_helpers.h
index 120cbf8ba..d4a853f07 100644
--- a/ext/herb/extension_helpers.h
+++ b/ext/herb/extension_helpers.h
@@ -12,13 +12,13 @@
 const char* check_string(VALUE value);
 VALUE read_file_to_ruby_string(const char* file_path);
 
-VALUE rb_position_from_c_struct(position_T* position);
-VALUE rb_location_from_c_struct(location_T* location);
+VALUE rb_position_from_c_struct(position_T position);
+VALUE rb_location_from_c_struct(location_T location);
 
 VALUE rb_token_from_c_struct(token_T* token);
-VALUE rb_range_from_c_struct(range_T* range);
+VALUE rb_range_from_c_struct(range_T range);
 
-VALUE create_lex_result(array_T* tokens, VALUE source);
+VALUE create_lex_result(hb_array_T* tokens, VALUE source);
 VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source);
 
 #endif
diff --git a/javascript/packages/browser/package.json b/javascript/packages/browser/package.json
index c65ea539a..55622a4ad 100644
--- a/javascript/packages/browser/package.json
+++ b/javascript/packages/browser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/browser",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "WebAssembly-based HTML-aware ERB parser for browsers.",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/browser/test/browser.test.ts b/javascript/packages/browser/test/browser.test.ts
index ff99b6553..701184766 100644
--- a/javascript/packages/browser/test/browser.test.ts
+++ b/javascript/packages/browser/test/browser.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/browser", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/browser@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (WebAssembly)")
+    expect(version).toBe("@herb-tools/browser@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/core/package.json b/javascript/packages/core/package.json
index 109a4d029..81b3c4a00 100644
--- a/javascript/packages/core/package.json
+++ b/javascript/packages/core/package.json
@@ -1,8 +1,7 @@
 {
   "name": "@herb-tools/core",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Core module exporting shared interfaces, AST node definitions, and common utilities for Herb",
-  "type": "module",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/core%60:%20",
diff --git a/javascript/packages/core/src/ast-utils.ts b/javascript/packages/core/src/ast-utils.ts
index c7f773ddb..6c844a4cd 100644
--- a/javascript/packages/core/src/ast-utils.ts
+++ b/javascript/packages/core/src/ast-utils.ts
@@ -1,6 +1,7 @@
 import {
   Node,
   LiteralNode,
+  ERBNode,
   ERBContentNode,
   ERBIfNode,
   ERBUnlessNode,
@@ -30,11 +31,17 @@ import {
 import type { Location } from "./location.js"
 import type { Position } from "./position.js"
 
+export type ERBOutputNode = ERBNode & {
+  tag_opening: {
+    value: "<%=" | "<%=="
+  }
+}
+
 /**
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
-export function isERBOutputNode(node: Node): node is ERBContentNode {
-  if (!isNode(node, ERBContentNode)) return false
+export function isERBOutputNode(node: Node): node is ERBOutputNode {
+  if (!isERBNode(node)) return false
   if (!node.tag_opening?.value) return false
 
   return ["<%=", "<%=="].includes(node.tag_opening?.value)
diff --git a/javascript/packages/core/src/glob.ts b/javascript/packages/core/src/glob.ts
new file mode 100644
index 000000000..485042c74
--- /dev/null
+++ b/javascript/packages/core/src/glob.ts
@@ -0,0 +1 @@
+export const HERB_FILES_GLOB = "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
diff --git a/javascript/packages/core/src/index.ts b/javascript/packages/core/src/index.ts
index c0858ee4e..51f88b7e2 100644
--- a/javascript/packages/core/src/index.ts
+++ b/javascript/packages/core/src/index.ts
@@ -2,11 +2,12 @@ export * from "./ast-utils.js"
 export * from "./backend.js"
 export * from "./diagnostic.js"
 export * from "./errors.js"
+export * from "./glob.js"
 export * from "./herb-backend.js"
 export * from "./lex-result.js"
 export * from "./location.js"
-export * from "./nodes.js"
 export * from "./node-type-guards.js"
+export * from "./nodes.js"
 export * from "./parse-result.js"
 export * from "./parser-options.js"
 export * from "./position.js"
diff --git a/javascript/packages/core/src/location.ts b/javascript/packages/core/src/location.ts
index e059ff734..32f38eec1 100644
--- a/javascript/packages/core/src/location.ts
+++ b/javascript/packages/core/src/location.ts
@@ -17,6 +17,10 @@ export class Location {
     return new Location(start, end)
   }
 
+  static get zero() {
+    return new Location(Position.zero, Position.zero)
+  }
+
   constructor(start: Position, end: Position) {
     this.start = start
     this.end = end
diff --git a/javascript/packages/core/src/position.ts b/javascript/packages/core/src/position.ts
index 7da697594..ec4e5ac6f 100644
--- a/javascript/packages/core/src/position.ts
+++ b/javascript/packages/core/src/position.ts
@@ -11,6 +11,10 @@ export class Position {
     return new Position(position.line, position.column)
   }
 
+  static get zero() {
+    return new Position(0, 0)
+  }
+
   constructor(line: number, column: number) {
     this.line = line
     this.column = column
diff --git a/javascript/packages/core/src/range.ts b/javascript/packages/core/src/range.ts
index 34c4de2b1..8cb031f63 100644
--- a/javascript/packages/core/src/range.ts
+++ b/javascript/packages/core/src/range.ts
@@ -8,6 +8,10 @@ export class Range {
     return new Range(range[0], range[1])
   }
 
+  static get zero() {
+    return new Range(0, 0)
+  }
+
   constructor(start: number, end: number) {
     this.start = start
     this.end = end
diff --git a/javascript/packages/dev-tools/package.json b/javascript/packages/dev-tools/package.json
index c66f0ff4e..4dbe1b66f 100644
--- a/javascript/packages/dev-tools/package.json
+++ b/javascript/packages/dev-tools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/dev-tools",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Development tools for visual debugging in HTML+ERB templates",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/dev-tools/src/herb-overlay.ts b/javascript/packages/dev-tools/src/herb-overlay.ts
index 49cc8aff3..e2b12d4a1 100644
--- a/javascript/packages/dev-tools/src/herb-overlay.ts
+++ b/javascript/packages/dev-tools/src/herb-overlay.ts
@@ -934,6 +934,7 @@ export class HerbOverlay {
       `subl://open?url=file://${absolutePath}&line=${line}&column=${column}`,
       `atom://core/open/file?filename=${absolutePath}&line=${line}&column=${column}`,
       `txmt://open?url=file://${absolutePath}&line=${line}&column=${column}`,
+      `x-mine://open?file=//${absolutePath}&line=${line}&column=${column}`,
     ];
 
     try {
diff --git a/javascript/packages/formatter/package.json b/javascript/packages/formatter/package.json
index 467e1ac21..4de78cad0 100644
--- a/javascript/packages/formatter/package.json
+++ b/javascript/packages/formatter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Auto-formatter for HTML+ERB templates with intelligent indentation, line wrapping, and ERB-aware pretty-printing.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/printer": "0.7.4"
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/printer": "0.7.5"
   },
   "devDependencies": {
     "glob": "^11.0.3"
diff --git a/javascript/packages/formatter/src/cli.ts b/javascript/packages/formatter/src/cli.ts
index 5d88c1d28..df73eb694 100644
--- a/javascript/packages/formatter/src/cli.ts
+++ b/javascript/packages/formatter/src/cli.ts
@@ -4,6 +4,8 @@ import { glob } from "glob"
 import { join, resolve } from "path"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { Formatter } from "./formatter.js"
 import { parseArgs } from "util"
 import { resolveFormatOptions } from "./options.js"
@@ -19,8 +21,8 @@ export class CLI {
     Usage: herb-format [file|directory|glob-pattern] [options]
 
     Arguments:
-      file|directory|glob-pattern   File to format, directory to format all **/*.html.erb files within,
-                                    glob pattern to match files, or '-' for stdin (omit to format all **/*.html.erb files in current directory)
+      file|directory|glob-pattern   File to format, directory to format all \`${HERB_FILES_GLOB}\` files within,
+                                    glob pattern to match files, or '-' for stdin (omit to format all \`${HERB_FILES_GLOB}\` files in current directory)
 
     Options:
       -c, --check                     check if files are formatted without modifying them
@@ -30,18 +32,20 @@ export class CLI {
       --max-line-length <number>      maximum line length before wrapping (default: 80)
 
     Examples:
-      herb-format                            # Format all **/*.html.erb files in current directory
-      herb-format index.html.erb             # Format and write single file
-      herb-format templates/index.html.erb   # Format and write single file
-      herb-format templates/                 # Format and **/*.html.erb within the given directory
-      herb-format "templates/**/*.html.erb"  # Format all .html.erb files in templates directory using glob pattern
-      herb-format "**/*.html.erb"            # Format all .html.erb files using glob pattern
-      herb-format "**/*.xml.erb"             # Format all .xml.erb files using glob pattern
-      herb-format --check                    # Check if all **/*.html.erb files are formatted
-      herb-format --check templates/         # Check if all **/*.html.erb files in templates/ are formatted
-      herb-format --indent-width 4           # Format with 4-space indentation
-      herb-format --max-line-length 100      # Format with 100-character line limit
-      cat template.html.erb | herb-format    # Format from stdin to stdout
+      herb-format                                 # Format all \`${HERB_FILES_GLOB}\` files in current directory
+      herb-format index.html.erb                  # Format and write single file
+      herb-format templates/index.html.erb        # Format and write single file
+      herb-format templates/                      # Format all \`${HERB_FILES_GLOB}\` within the given directory
+      herb-format "templates/**/*.html.erb"       # Format all \`**/*.html.erb\` files in the templates/ directory
+      herb-format "**/*.html.erb"                 # Format all \`*.html.erb\` files using glob pattern
+      herb-format "**/*.xml.erb"                  # Format all \`*.xml.erb\` files using glob pattern
+
+      herb-format --check                         # Check if all \`${HERB_FILES_GLOB}\` files are formatted
+      herb-format --check templates/              # Check if all \`${HERB_FILES_GLOB}\` files in templates/ are formatted
+
+      herb-format --indent-width 4                # Format with 4-space indentation
+      herb-format --max-line-length 100           # Format with 100-character line limit
+      cat template.html.erb | herb-format         # Format from stdin to stdout
   `
 
   private parseArguments() {
@@ -112,8 +116,8 @@ export class CLI {
         process.exit(0)
       }
 
-      console.log("⚠️  Experimental Preview: The formatter is in early development. Please report any unexpected behavior or bugs to https://github.com/marcoroth/herb/issues/new?template=formatting-issue.md")
-      console.log()
+      console.error("⚠️  Experimental Preview: The formatter is in early development. Please report any unexpected behavior or bugs to https://github.com/marcoroth/herb/issues/new?template=formatting-issue.md")
+      console.error()
 
       const formatOptions = resolveFormatOptions({
         indentWidth,
@@ -162,7 +166,7 @@ export class CLI {
         }
 
         if (isDirectory) {
-          pattern = join(file, "**/*.html.erb")
+          pattern = join(file, HERB_FILES_GLOB)
         } else if (isFile) {
           const source = readFileSync(file, "utf-8")
           const result = formatter.format(source)
@@ -245,10 +249,10 @@ export class CLI {
           process.exit(1)
         }
       } else {
-        const files = await glob("**/*.html.erb")
+        const files = await glob(HERB_FILES_GLOB)
 
         if (files.length === 0) {
-          console.log(`No files found matching pattern: ${resolve("**/*.html.erb")}`)
+          console.log(`No files found matching pattern: ${resolve(HERB_FILES_GLOB)}`)
 
           process.exit(0)
         }
diff --git a/javascript/packages/formatter/src/format-helpers.ts b/javascript/packages/formatter/src/format-helpers.ts
new file mode 100644
index 000000000..13c71fb2b
--- /dev/null
+++ b/javascript/packages/formatter/src/format-helpers.ts
@@ -0,0 +1,475 @@
+import { isNode, isERBNode, getTagName, isAnyOf, isERBControlFlowNode, hasERBOutput } from "@herb-tools/core"
+import { Node, HTMLDoctypeNode, HTMLTextNode, HTMLElementNode, HTMLCommentNode, HTMLOpenTagNode, HTMLCloseTagNode, ERBIfNode, ERBContentNode, WhitespaceNode } from "@herb-tools/core"
+
+// --- Types ---
+
+/**
+ * Analysis result for HTMLElementNode formatting decisions
+ */
+export interface ElementFormattingAnalysis {
+  openTagInline: boolean
+  elementContentInline: boolean
+  closeTagInline: boolean
+}
+
+/**
+ * Content unit represents a piece of content in text flow
+ * Can be atomic (inline elements, ERB) or splittable (text)
+ */
+export interface ContentUnit {
+  content: string
+  type: 'text' | 'inline' | 'erb' | 'block'
+  isAtomic: boolean
+  breaksFlow: boolean
+}
+
+/**
+ * Content unit paired with its source AST node
+ */
+export interface ContentUnitWithNode {
+  unit: ContentUnit
+  node: Node | null
+}
+
+// --- Constants ---
+
+// TODO: we can probably expand this list with more tags/attributes
+export const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
+  '*': ['class'],
+  'img': ['srcset', 'sizes']
+}
+
+export const INLINE_ELEMENTS = new Set([
+  'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
+  'dfn', 'em', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
+  'samp', 'small', 'span', 'strong', 'sub', 'sup',
+  'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
+])
+
+export const CONTENT_PRESERVING_ELEMENTS = new Set([
+  'script', 'style', 'pre', 'textarea'
+])
+
+export const SPACEABLE_CONTAINERS = new Set([
+  'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
+  'figure', 'details', 'summary', 'dialog', 'fieldset'
+])
+
+export const TIGHT_GROUP_PARENTS = new Set([
+  'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
+  'tbody', 'tfoot'
+])
+
+export const TIGHT_GROUP_CHILDREN = new Set([
+  'li', 'option', 'td', 'th', 'dt', 'dd'
+])
+
+export const SPACING_THRESHOLD = 3
+
+/**
+ * Token list attributes that contain space-separated values and benefit from
+ * spacing around ERB content for readability
+ */
+export const TOKEN_LIST_ATTRIBUTES = new Set([
+  'class', 'data-controller', 'data-action'
+])
+
+
+// --- Node Utility Functions ---
+
+/**
+ * Check if a node is pure whitespace (empty text node with only whitespace)
+ */
+export function isPureWhitespaceNode(node: Node): boolean {
+  return isNode(node, HTMLTextNode) && node.content.trim() === ""
+}
+
+/**
+ * Check if a node is non-whitespace (has meaningful content)
+ */
+export function isNonWhitespaceNode(node: Node): boolean {
+  if (isNode(node, WhitespaceNode)) return false
+  if (isNode(node, HTMLTextNode)) return node.content.trim() !== ""
+
+  return true
+}
+
+/**
+ * Find the previous meaningful (non-whitespace) sibling
+ * Returns -1 if no meaningful sibling is found
+ */
+export function findPreviousMeaningfulSibling(siblings: Node[], currentIndex: number): number {
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    if (isNonWhitespaceNode(siblings[i])) {
+      return i
+    }
+  }
+
+  return -1
+}
+
+/**
+ * Check if there's whitespace between two indices in children array
+ */
+export function hasWhitespaceBetween(children: Node[], startIndex: number, endIndex: number): boolean {
+  for (let j = startIndex + 1; j < endIndex; j++) {
+    if (isNode(children[j], WhitespaceNode) || isPureWhitespaceNode(children[j])) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Filter children to remove insignificant whitespace
+ */
+export function filterSignificantChildren(body: Node[]): Node[] {
+  return body.filter(child => {
+    if (isNode(child, WhitespaceNode)) return false
+
+    if (isNode(child, HTMLTextNode)) {
+      if (child.content === " ") return true
+
+      return child.content.trim() !== ""
+    }
+
+    return true
+  })
+}
+
+/**
+ * Filter out empty text nodes and whitespace nodes
+ */
+export function filterEmptyNodes(nodes: Node[]): Node[] {
+  return nodes.filter(child =>
+    !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === "")
+  )
+}
+
+// --- Punctuation and Word Spacing Functions ---
+
+/**
+ * Check if a word is standalone closing punctuation
+ */
+export function isClosingPunctuation(word: string): boolean {
+  return /^[.,;:!?)\]]+$/.test(word)
+}
+
+/**
+ * Check if a line ends with opening punctuation
+ */
+export function lineEndsWithOpeningPunctuation(line: string): boolean {
+  return /[(\[]$/.test(line)
+}
+
+/**
+ * Check if a string is an ERB tag
+ */
+export function isERBTag(text: string): boolean {
+  return /^<%.*?%>$/.test(text.trim())
+}
+
+/**
+ * Check if a string ends with an ERB tag
+ */
+export function endsWithERBTag(text: string): boolean {
+  return /%>$/.test(text.trim())
+}
+
+/**
+ * Check if a string starts with an ERB tag
+ */
+export function startsWithERBTag(text: string): boolean {
+  return /^<%/.test(text.trim())
+}
+
+/**
+ * Determine if space is needed between the current line and the next word
+ */
+export function needsSpaceBetween(currentLine: string, word: string): boolean {
+  if (isClosingPunctuation(word)) return false
+  if (lineEndsWithOpeningPunctuation(currentLine)) return false
+  if (currentLine.endsWith(' ')) return false
+  if (endsWithERBTag(currentLine) && startsWithERBTag(word)) return false
+
+  return true
+}
+
+/**
+ * Build a line by adding a word with appropriate spacing
+ */
+export function buildLineWithWord(currentLine: string, word: string): string {
+  if (!currentLine) return word
+
+  if (word === ' ') {
+    return currentLine.endsWith(' ') ? currentLine : `${currentLine} `
+  }
+
+  return needsSpaceBetween(currentLine, word) ? `${currentLine} ${word}` : `${currentLine}${word}`
+}
+
+/**
+ * Check if a node is an inline element or ERB node
+ */
+export function isInlineOrERBNode(node: Node): boolean {
+  return isERBNode(node) || (isNode(node, HTMLElementNode) && isInlineElement(getTagName(node)))
+}
+
+/**
+ * Check if an element should be treated as inline based on its tag name
+ */
+export function isInlineElement(tagName: string): boolean {
+  return INLINE_ELEMENTS.has(tagName.toLowerCase())
+}
+
+/**
+ * Check if the current inline element is adjacent to a previous inline element (no whitespace between)
+ */
+export function isAdjacentToPreviousInline(siblings: Node[], index: number): boolean {
+  const previousNode = siblings[index - 1]
+
+  if (isInlineOrERBNode(previousNode)) {
+    return true
+  }
+
+  if (index > 1 && isNode(previousNode, HTMLTextNode) && !/^\s/.test(previousNode.content)) {
+    const twoBack = siblings[index - 2]
+
+    return isInlineOrERBNode(twoBack)
+  }
+
+  return false
+}
+
+/**
+ * Check if a node should be appended to the last line (for adjacent inline elements and punctuation)
+ */
+export function shouldAppendToLastLine(child: Node, siblings: Node[], index: number): boolean {
+  if (index === 0) return false
+
+  if (isNode(child, HTMLTextNode) && !/^\s/.test(child.content)) {
+    const previousNode = siblings[index - 1]
+
+    return isInlineOrERBNode(previousNode)
+  }
+
+  if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+    return isAdjacentToPreviousInline(siblings, index)
+  }
+
+  if (isNode(child, ERBContentNode)) {
+    for (let i = index - 1; i >= 0; i--) {
+      const previousSibling = siblings[i]
+
+      if (isPureWhitespaceNode(previousSibling) || isNode(previousSibling, WhitespaceNode)) {
+        continue
+      }
+
+      if (previousSibling.location && child.location) {
+        return previousSibling.location.end.line === child.location.start.line
+      }
+
+      break
+    }
+  }
+
+  return false
+}
+
+/**
+ * Check if user-intentional spacing should be preserved (double newlines between elements)
+ */
+export function shouldPreserveUserSpacing(child: Node, siblings: Node[], index: number): boolean {
+  if (!isPureWhitespaceNode(child)) return false
+
+  const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(siblings[index - 1])
+  const hasNextNonWhitespace = index < siblings.length - 1 && isNonWhitespaceNode(siblings[index + 1])
+  const hasMultipleNewlines = isNode(child, HTMLTextNode) && child.content.includes('\n\n')
+
+  return hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines
+}
+
+
+/**
+ * Check if children contain any text content with newlines
+ */
+export function hasMultilineTextContent(children: Node[]): boolean {
+  for (const child of children) {
+    if (isNode(child, HTMLTextNode)) {
+      return child.content.includes('\n')
+    }
+
+    if (isNode(child, HTMLElementNode)) {
+      const nestedChildren = filterEmptyNodes(child.body)
+
+      if (hasMultilineTextContent(nestedChildren)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Check if all nested elements in the children are inline elements
+ */
+export function areAllNestedElementsInline(children: Node[]): boolean {
+  for (const child of children) {
+    if (isNode(child, HTMLElementNode)) {
+      if (!isInlineElement(getTagName(child))) {
+        return false
+      }
+
+      const nestedChildren = filterEmptyNodes(child.body)
+
+      if (!areAllNestedElementsInline(nestedChildren)) {
+        return false
+      }
+    } else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * Check if element has complex ERB control flow
+ */
+export function hasComplexERBControlFlow(inlineNodes: Node[]): boolean {
+  return inlineNodes.some(node => {
+    if (isNode(node, ERBIfNode)) {
+      if (node.statements.length > 0 && node.location) {
+        const startLine = node.location.start.line
+        const endLine = node.location.end.line
+
+        return startLine !== endLine
+      }
+
+      return false
+    }
+
+    return false
+  })
+}
+
+/**
+ * Check if children contain mixed text and inline elements (like "text<em>inline</em>text")
+ * or mixed ERB output and text (like "<%= value %> text")
+ * This indicates content that should be formatted inline even with structural newlines
+ */
+export function hasMixedTextAndInlineContent(children: Node[]): boolean {
+  let hasText = false
+  let hasInlineElements = false
+
+  for (const child of children) {
+    if (isNode(child, HTMLTextNode)) {
+      if (child.content.trim() !== "") {
+        hasText = true
+      }
+    } else if (isNode(child, HTMLElementNode)) {
+      if (isInlineElement(getTagName(child))) {
+        hasInlineElements = true
+      }
+    }
+  }
+
+  return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText)
+}
+
+export function isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean {
+  const tagName = getTagName(element)
+
+  return CONTENT_PRESERVING_ELEMENTS.has(tagName)
+}
+
+/**
+ * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
+ */
+export function countAdjacentInlineElements(children: Node[]): number {
+  let count = 0
+  let lastSignificantIndex = -1
+
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i]
+
+    if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+      continue
+    }
+
+    const isInlineOrERB = (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) || isNode(child, ERBContentNode)
+
+    if (!isInlineOrERB) {
+      break
+    }
+
+    if (lastSignificantIndex >= 0 && hasWhitespaceBetween(children, lastSignificantIndex, i)) {
+      break
+    }
+
+    count++
+    lastSignificantIndex = i
+  }
+
+  return count
+}
+
+/**
+ * Determine if we should wrap to the next line
+ */
+export function shouldWrapToNextLine(testLine: string, currentLine: string, word: string, wrapWidth: number): boolean {
+  if (!currentLine) return false
+  if (isClosingPunctuation(word)) return false
+
+  return testLine.length >= wrapWidth
+}
+
+/**
+ * Check if a node represents a block-level element
+ */
+export function isBlockLevelNode(node: Node): boolean {
+  if (!isNode(node, HTMLElementNode)) {
+    return false
+  }
+
+  const tagName = getTagName(node)
+
+  if (INLINE_ELEMENTS.has(tagName)) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Normalize text by replacing multiple spaces with single space and trim
+ * Then split into words
+ */
+export function normalizeAndSplitWords(text: string): string[] {
+  const normalized = text.replace(/\s+/g, ' ')
+  return normalized.trim().split(' ')
+}
+
+/**
+ * Check if text starts with an alphanumeric character (not punctuation)
+ */
+export function startsWithAlphanumeric(text: string): boolean {
+  const trimmed = text.trim()
+  return /^[a-zA-Z0-9]/.test(trimmed)
+}
+
+/**
+ * Check if text ends with an alphanumeric character (not punctuation)
+ */
+export function endsWithAlphanumeric(text: string): boolean {
+  return /[a-zA-Z0-9]$/.test(text)
+}
+
+/**
+ * Check if text ends with whitespace
+ */
+export function endsWithWhitespace(text: string): boolean {
+  return /\s$/.test(text)
+}
diff --git a/javascript/packages/formatter/src/format-printer.ts b/javascript/packages/formatter/src/format-printer.ts
index 02a6f8c66..327fef82c 100644
--- a/javascript/packages/formatter/src/format-printer.ts
+++ b/javascript/packages/formatter/src/format-printer.ts
@@ -1,4 +1,5 @@
 import dedent from "dedent"
+
 import {
   getTagName,
   getCombinedAttributeName,
@@ -6,16 +7,56 @@ import {
   isNode,
   isToken,
   isParseResult,
-  isAnyOf,
   isNoneOf,
   isERBNode,
   isCommentNode,
   isERBControlFlowNode,
   filterNodes,
-  hasERBOutput,
 } from "@herb-tools/core"
+
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
 
+import {
+  areAllNestedElementsInline,
+  buildLineWithWord,
+  countAdjacentInlineElements,
+  endsWithAlphanumeric,
+  endsWithWhitespace,
+  filterEmptyNodes,
+  filterSignificantChildren,
+  findPreviousMeaningfulSibling,
+  hasComplexERBControlFlow,
+  hasMixedTextAndInlineContent,
+  hasMultilineTextContent,
+  hasWhitespaceBetween,
+  isBlockLevelNode,
+  isContentPreserving,
+  isInlineElement,
+  isNonWhitespaceNode,
+  isPureWhitespaceNode,
+  normalizeAndSplitWords,
+  shouldAppendToLastLine,
+  shouldPreserveUserSpacing,
+  shouldWrapToNextLine,
+  startsWithAlphanumeric,
+} from "./format-helpers.js"
+
+import {
+  FORMATTABLE_ATTRIBUTES,
+  INLINE_ELEMENTS,
+  SPACEABLE_CONTAINERS,
+  SPACING_THRESHOLD,
+  TIGHT_GROUP_CHILDREN,
+  TIGHT_GROUP_PARENTS,
+  TOKEN_LIST_ATTRIBUTES,
+} from "./format-helpers.js"
+
+import type {
+  ContentUnit,
+  ContentUnitWithNode,
+  ElementFormattingAnalysis,
+} from "./format-helpers.js"
+
 import {
   ParseResult,
   Node,
@@ -56,21 +97,6 @@ import {
 import type { ERBNode } from "@herb-tools/core"
 import type { FormatOptions } from "./options.js"
 
-/**
- * Analysis result for HTMLElementNode formatting decisions
- */
-interface ElementFormattingAnalysis {
-  openTagInline: boolean
-  elementContentInline: boolean
-  closeTagInline: boolean
-}
-
-// TODO: we can probably expand this list with more tags/attributes
-const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
-  '*': ['class'],
-  'img': ['srcset', 'sizes']
-}
-
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
@@ -98,34 +124,6 @@ export class FormatPrinter extends Printer {
 
   public source: string
 
-  // TODO: extract
-  private static readonly INLINE_ELEMENTS = new Set([
-    'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
-    'dfn', 'em', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
-    'samp', 'small', 'span', 'strong', 'sub', 'sup',
-    'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
-  ])
-
-  private static readonly CONTENT_PRESERVING_ELEMENTS = new Set([
-    'script', 'style', 'pre', 'textarea'
-  ])
-
-  private static readonly SPACEABLE_CONTAINERS = new Set([
-    'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
-    'figure', 'details', 'summary', 'dialog', 'fieldset'
-  ])
-
-  private static readonly TIGHT_GROUP_PARENTS = new Set([
-    'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
-    'tbody', 'tfoot'
-  ])
-
-  private static readonly TIGHT_GROUP_CHILDREN = new Set([
-    'li', 'option', 'td', 'th', 'dt', 'dd'
-  ])
-
-  private static readonly SPACING_THRESHOLD = 3
-
   constructor(source: string, options: Required<FormatOptions>) {
     super()
 
@@ -320,26 +318,26 @@ export class FormatPrinter extends Printer {
       return false
     }
 
-    const meaningfulSiblings = siblings.filter(child => this.isNonWhitespaceNode(child))
+    const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
 
-    if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
+    if (meaningfulSiblings.length < SPACING_THRESHOLD) {
       return false
     }
 
     const parentTagName = parentElement ? getTagName(parentElement) : null
 
-    if (parentTagName && FormatPrinter.TIGHT_GROUP_PARENTS.has(parentTagName)) {
+    if (parentTagName && TIGHT_GROUP_PARENTS.has(parentTagName)) {
       return false
     }
 
-    const isSpaceableContainer = !parentTagName || (parentTagName && FormatPrinter.SPACEABLE_CONTAINERS.has(parentTagName))
+    const isSpaceableContainer = !parentTagName || (parentTagName && SPACEABLE_CONTAINERS.has(parentTagName))
 
     if (!isSpaceableContainer && meaningfulSiblings.length < 5) {
       return false
     }
 
     const currentNode = siblings[currentIndex]
-    const previousMeaningfulIndex = this.findPreviousMeaningfulSibling(siblings, currentIndex)
+    const previousMeaningfulIndex = findPreviousMeaningfulSibling(siblings, currentIndex)
     const isCurrentComment = isCommentNode(currentNode)
 
     if (previousMeaningfulIndex !== -1) {
@@ -358,11 +356,11 @@ export class FormatPrinter extends Printer {
     if (isNode(currentNode, HTMLElementNode)) {
       const currentTagName = getTagName(currentNode)
 
-      if (FormatPrinter.INLINE_ELEMENTS.has(currentTagName)) {
+      if (INLINE_ELEMENTS.has(currentTagName)) {
         return false
       }
 
-      if (FormatPrinter.TIGHT_GROUP_CHILDREN.has(currentTagName)) {
+      if (TIGHT_GROUP_CHILDREN.has(currentTagName)) {
         return false
       }
 
@@ -371,56 +369,18 @@ export class FormatPrinter extends Printer {
       }
     }
 
-    const isBlockElement = this.isBlockLevelNode(currentNode)
+    const isBlockElement = isBlockLevelNode(currentNode)
     const isERBBlock = isERBNode(currentNode) && isERBControlFlowNode(currentNode)
     const isComment = isCommentNode(currentNode)
 
     return isBlockElement || isERBBlock || isComment
   }
 
-  /**
-   * Token list attributes that contain space-separated values and benefit from
-   * spacing around ERB content for readability
-   */
-  private static readonly TOKEN_LIST_ATTRIBUTES = new Set([
-    'class', 'data-controller', 'data-action'
-  ])
-
   /**
    * Check if we're currently processing a token list attribute that needs spacing
    */
-  private isInTokenListAttribute(): boolean {
-    return this.currentAttributeName !== null &&
-           FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
-  }
-
-  /**
-   * Find the previous meaningful (non-whitespace) sibling
-   */
-  private findPreviousMeaningfulSibling(siblings: Node[], currentIndex: number): number {
-    for (let i = currentIndex - 1; i >= 0; i--) {
-      if (this.isNonWhitespaceNode(siblings[i])) {
-        return i
-      }
-    }
-    return -1
-  }
-
-  /**
-   * Check if a node represents a block-level element
-   */
-  private isBlockLevelNode(node: Node): boolean {
-    if (!isNode(node, HTMLElementNode)) {
-      return false
-    }
-
-    const tagName = getTagName(node)
-
-    if (FormatPrinter.INLINE_ELEMENTS.has(tagName)) {
-      return false
-    }
-
-    return true
+  private get isInTokenListAttribute(): boolean {
+    return this.currentAttributeName !== null && TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
   }
 
   /**
@@ -473,16 +433,13 @@ export class FormatPrinter extends Printer {
     return true
   }
 
-  private getAttributeName(attribute: HTMLAttributeNode): string {
-    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
-  }
-
   private wouldClassAttributeBeMultiline(content: string, indentLength: number): boolean {
     const normalizedContent = content.replace(/\s+/g, ' ').trim()
     const hasActualNewlines = /\r?\n/.test(content)
 
     if (hasActualNewlines && normalizedContent.length > 80) {
       const lines = content.split(/\r?\n/).map(line => line.trim()).filter(line => line)
+
       if (lines.length > 1) {
         return true
       }
@@ -504,6 +461,12 @@ export class FormatPrinter extends Printer {
     return false
   }
 
+  // TOOD: extract to core or reuse function from core
+  private getAttributeName(attribute: HTMLAttributeNode): string {
+    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
+  }
+
+  // TOOD: extract to core or reuse function from core
   private getAttributeValue(attribute: HTMLAttributeNode): string {
     if (isNode(attribute.value, HTMLAttributeValueNode)) {
       return attribute.value.children.map(child => isNode(child, HTMLTextNode) ? child.content : IdentityPrinter.print(child)).join('')
@@ -680,31 +643,30 @@ export class FormatPrinter extends Printer {
     for (let i = 0; i < node.children.length; i++) {
       const child = node.children[i]
 
-      if (isNode(child, HTMLTextNode)) {
-        const isWhitespaceOnly = child.content.trim() === ""
-
-        if (isWhitespaceOnly) {
-          const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(node.children[i - 1])
-          const hasNextNonWhitespace = i < node.children.length - 1 && this.isNonWhitespaceNode(node.children[i + 1])
-
-          const hasMultipleNewlines = child.content.includes('\n\n')
+      if (shouldPreserveUserSpacing(child, node.children, i)) {
+        this.push("")
+        hasHandledSpacing = true
+        continue
+      }
 
-          if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
-            this.push("")
-            hasHandledSpacing = true
-          }
+      if (isPureWhitespaceNode(child)) {
+        continue
+      }
 
-          continue
-        }
+      if (shouldAppendToLastLine(child, node.children, i)) {
+        this.appendChildToLastLine(child, node.children, i)
+        lastWasMeaningful = true
+        hasHandledSpacing = false
+        continue
       }
 
-      if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
         this.push("")
       }
 
       this.visit(child)
 
-      if (this.isNonWhitespaceNode(child)) {
+      if (isNonWhitespaceNode(child)) {
         lastWasMeaningful = true
         hasHandledSpacing = false
       }
@@ -729,7 +691,7 @@ export class FormatPrinter extends Printer {
   }
 
   visitHTMLElementBody(body: Node[], element: HTMLElementNode) {
-    if (this.isContentPreserving(element)) {
+    if (isContentPreserving(element)) {
       element.body.map(child => {
         if (isNode(child, HTMLElementNode)) {
           const wasInlineMode = this.inlineMode
@@ -749,7 +711,7 @@ export class FormatPrinter extends Printer {
 
     const analysis = this.elementFormattingAnalysis.get(element)
     const hasTextFlow = this.isInTextFlowContext(null, body)
-    const children = this.filterSignificantChildren(body, hasTextFlow)
+    const children = filterSignificantChildren(body)
 
     if (analysis?.elementContentInline) {
       if (children.length === 0) return
@@ -771,10 +733,13 @@ export class FormatPrinter extends Printer {
                 this.push(' ')
               }
             } else {
-              const normalizedContent = child.content.replace(/\s+/g, ' ').trim()
+              const normalizedContent = child.content.replace(/\s+/g, ' ')
+              const trimmedContent = normalizedContent.trim()
 
-              if (normalizedContent) {
-                this.push(normalizedContent)
+              if (trimmedContent) {
+                this.push(trimmedContent)
+              } else if (normalizedContent === ' ') {
+                this.push(' ')
               }
             }
           } else if (isNode(child, WhitespaceNode)) {
@@ -822,8 +787,8 @@ export class FormatPrinter extends Printer {
         const isWhitespaceOnly = child.content.trim() === ""
 
         if (isWhitespaceOnly) {
-          const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(body[i - 1])
-          const hasNextNonWhitespace = i < body.length - 1 && this.isNonWhitespaceNode(body[i + 1])
+          const hasPreviousNonWhitespace = i > 0 && isNonWhitespaceNode(body[i - 1])
+          const hasNextNonWhitespace = i < body.length - 1 && isNonWhitespaceNode(body[i + 1])
 
           const hasMultipleNewlines = child.content.includes('\n\n')
 
@@ -836,7 +801,7 @@ export class FormatPrinter extends Printer {
         }
       }
 
-      if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
         const element = body[i - 1]
         const hasExistingSpacing = i > 0 && isNode(element, HTMLTextNode) && element.content.trim() === "" && (element.content.includes('\n\n') || element.content.split('\n').length > 2)
 
@@ -854,7 +819,7 @@ export class FormatPrinter extends Printer {
 
       this.visit(child)
 
-      if (this.isNonWhitespaceNode(child)) {
+      if (isNonWhitespaceNode(child)) {
         lastWasMeaningful = true
         hasHandledSpacing = false
       }
@@ -1101,7 +1066,17 @@ export class FormatPrinter extends Printer {
 
   visitERBBlockNode(node: ERBBlockNode) {
     this.printERBNode(node)
-    this.withIndent(() => this.visitElementChildren(node.body, null))
+
+    this.withIndent(() => {
+      const hasTextFlow = this.isInTextFlowContext(null, node.body)
+
+      if (hasTextFlow) {
+        const children = filterSignificantChildren(node.body)
+        this.visitTextFlowChildren(children)
+      } else {
+        this.visitElementChildren(node.body, null)
+      }
+    })
 
     if (node.end_node) this.visit(node.end_node)
   }
@@ -1115,7 +1090,7 @@ export class FormatPrinter extends Printer {
           this.lines.push(" ")
           this.lines.push(this.renderAttribute(child))
         } else {
-          const shouldAddSpaces = this.isInTokenListAttribute()
+          const shouldAddSpaces = this.isInTokenListAttribute
 
           if (shouldAddSpaces) {
             this.lines.push(" ")
@@ -1130,7 +1105,7 @@ export class FormatPrinter extends Printer {
       })
 
       const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode))
-      const isTokenList = this.isInTokenListAttribute()
+      const isTokenList = this.isInTokenListAttribute
 
       if ((hasHTMLAttributes || isTokenList) && node.end_node) {
         this.lines.push(" ")
@@ -1242,7 +1217,7 @@ export class FormatPrinter extends Printer {
     const attributes = filterNodes(children, HTMLAttributeNode)
     const inlineNodes = this.extractInlineNodes(children)
     const hasERBControlFlow = inlineNodes.some(node => isERBControlFlowNode(node)) || children.some(node => isERBControlFlowNode(node))
-    const hasComplexERB = hasERBControlFlow && this.hasComplexERBControlFlow(inlineNodes)
+    const hasComplexERB = hasERBControlFlow && hasComplexERBControlFlow(inlineNodes)
 
     if (hasComplexERB) return false
 
@@ -1275,15 +1250,14 @@ export class FormatPrinter extends Printer {
    */
   private shouldRenderElementContentInline(node: HTMLElementNode): boolean {
     const tagName = getTagName(node)
-    const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body))
-    const isInlineElement = this.isInlineElement(tagName)
+    const children = filterSignificantChildren(node.body)
     const openTagInline = this.shouldRenderOpenTagInline(node)
 
     if (!openTagInline) return false
     if (children.length === 0) return true
 
-    if (isInlineElement) {
-      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children)
+    if (isInlineElement(tagName)) {
+      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
 
       if (fullInlineResult) {
         const totalLength = this.indent.length + fullInlineResult.length
@@ -1293,12 +1267,12 @@ export class FormatPrinter extends Printer {
       return false
     }
 
-    const allNestedAreInline = this.areAllNestedElementsInline(children)
-    const hasMultilineText = this.hasMultilineTextContent(children)
-    const hasMixedContent = this.hasMixedTextAndInlineContent(children)
+    const allNestedAreInline = areAllNestedElementsInline(children)
+    const hasMultilineText = hasMultilineTextContent(children)
+    const hasMixedContent = hasMixedTextAndInlineContent(children)
 
     if (allNestedAreInline && (!hasMultilineText || hasMixedContent)) {
-      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children)
+      const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body)
 
       if (fullInlineResult) {
         const totalLength = this.indent.length + fullInlineResult.length
@@ -1337,9 +1311,9 @@ export class FormatPrinter extends Printer {
   private shouldRenderCloseTagInline(node: HTMLElementNode, elementContentInline: boolean): boolean {
     if (node.is_void) return true
     if (node.open_tag?.tag_closing?.value === "/>") return true
-    if (this.isContentPreserving(node)) return true
+    if (isContentPreserving(node)) return true
 
-    const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body))
+    const children = filterSignificantChildren(node.body)
 
     if (children.length === 0) return true
 
@@ -1349,130 +1323,416 @@ export class FormatPrinter extends Printer {
 
   // --- Utility methods ---
 
-  private isNonWhitespaceNode(node: Node): boolean {
-    if (isNode(node, WhitespaceNode)) return false
-    if (isNode(node, HTMLTextNode)) return node.content.trim() !== ""
+  /**
+   * Append a child node to the last output line
+   */
+  private appendChildToLastLine(child: Node, siblings?: Node[], index?: number): void {
+    if (isNode(child, HTMLTextNode)) {
+      this.pushToLastLine(child.content.trim())
+    } else {
+      let hasSpaceBefore = false
+
+      if (siblings && index !== undefined && index > 0) {
+        const prevSibling = siblings[index - 1]
 
-    return true
+        if (isPureWhitespaceNode(prevSibling) || isNode(prevSibling, WhitespaceNode)) {
+          hasSpaceBefore = true
+        }
+      }
+
+      const oldInlineMode = this.inlineMode
+      this.inlineMode = true
+      const inlineContent = this.capture(() => this.visit(child)).join("")
+      this.inlineMode = oldInlineMode
+      this.pushToLastLine((hasSpaceBefore ? " " : "") + inlineContent)
+    }
   }
 
   /**
-   * Check if an element should be treated as inline based on its tag name
+   * Visit children in a text flow context (mixed text and inline elements)
+   * Handles word wrapping and keeps adjacent inline elements together
    */
-  private isInlineElement(tagName: string): boolean {
-    return FormatPrinter.INLINE_ELEMENTS.has(tagName.toLowerCase())
+  private visitTextFlowChildren(children: Node[]) {
+    const adjacentInlineCount = countAdjacentInlineElements(children)
+
+    if (adjacentInlineCount >= 2) {
+      this.renderAdjacentInlineElements(children, adjacentInlineCount)
+      this.visitRemainingChildren(children, adjacentInlineCount)
+
+      return
+    }
+
+    this.buildAndWrapTextFlow(children)
   }
 
   /**
-   * Check if we're in a text flow context (parent contains mixed text and inline elements)
+   * Render adjacent inline elements together on one line
    */
-  private visitTextFlowChildren(children: Node[]) {
-    let currentLineContent = ""
+  private renderAdjacentInlineElements(children: Node[], count: number): void {
+    let inlineContent = ""
+    let processedCount = 0
 
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        const content = child.content
+    for (let i = 0; i < children.length && processedCount < count; i++) {
+      const child = children[i]
 
-        let processedContent = content.replace(/\s+/g, ' ').trim()
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
+      }
 
-        if (processedContent) {
-          const hasLeadingSpace = /^\s/.test(content)
+      if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+        inlineContent += this.renderInlineElementAsString(child)
+        processedCount++
+      } else if (isNode(child, ERBContentNode)) {
+        inlineContent += this.renderERBAsString(child)
+        processedCount++
+      }
+    }
 
-          if (currentLineContent && hasLeadingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+    if (inlineContent) {
+      this.pushWithIndent(inlineContent)
+    }
+  }
 
-          currentLineContent += processedContent
+  /**
+   * Render an inline element as a string
+   */
+  private renderInlineElementAsString(element: HTMLElementNode): string {
+    const tagName = getTagName(element)
 
-          const hasTrailingSpace = /\s$/.test(content)
+    if (element.is_void || element.open_tag?.tag_closing?.value === "/>") {
+      const attributes = filterNodes(element.open_tag?.children, HTMLAttributeNode)
+      const attributesString = this.renderAttributesString(attributes)
+      const isSelfClosing = element.open_tag?.tag_closing?.value === "/>"
 
-          if (hasTrailingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+      return `<${tagName}${attributesString}${isSelfClosing ? " />" : ">"}`
+    }
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            children.forEach(child => this.visit(child))
+    const childInline = this.tryRenderInlineFull(element, tagName,
+      filterNodes(element.open_tag?.children, HTMLAttributeNode),
+      filterEmptyNodes(element.body)
+    )
 
-            return
-          }
+    return childInline !== null ? childInline : ""
+  }
+
+  /**
+   * Render an ERB node as a string
+   */
+  private renderERBAsString(node: ERBContentNode): string {
+    return this.capture(() => {
+      this.inlineMode = true
+      this.visit(node)
+    }).join("")
+  }
+
+  /**
+   * Visit remaining children after processing adjacent inline elements
+   */
+  private visitRemainingChildren(children: Node[], skipCount: number): void {
+    let skipped = 0
+
+    for (const child of children) {
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
+      }
+
+      if (skipped < skipCount) {
+        skipped++
+        continue
+      }
+
+      this.visit(child)
+    }
+  }
+
+  /**
+   * Build words array from text/inline/ERB and wrap them
+   */
+  private buildAndWrapTextFlow(children: Node[]): void {
+    const unitsWithNodes: ContentUnitWithNode[] = this.buildContentUnitsWithNodes(children)
+    const words: string[] = []
+
+    for (const { unit, node } of unitsWithNodes) {
+      if (unit.breaksFlow) {
+        this.flushWords(words)
+
+        if (node) {
+          this.visit(node)
         }
-      } else if (isNode(child, HTMLElementNode)) {
-        const childTagName = getTagName(child)
+      } else if (unit.isAtomic) {
+        words.push(unit.content)
+      } else {
+        const text = unit.content.replace(/\s+/g, ' ').trim()
 
-        if (this.isInlineElement(childTagName)) {
-          const childInline = this.tryRenderInlineFull(child, childTagName,
-            filterNodes(child.open_tag?.children, HTMLAttributeNode),
-            this.filterEmptyNodes(child.body)
-          )
+        if (text) {
+          words.push(...text.split(' '))
+        }
+      }
+    }
 
-          if (childInline) {
-            currentLineContent += childInline
+    this.flushWords(words)
+  }
 
-            if ((this.indent.length + currentLineContent.length) > this.maxLineLength) {
-              children.forEach(child => this.visit(child))
+  /**
+   * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace
+   * Returns true if merge was performed
+   */
+  private tryMergeTextAfterAtomic(result: ContentUnitWithNode[], textNode: HTMLTextNode): boolean {
+    if (result.length === 0) return false
 
-              return
-            }
-          } else {
-            if (currentLineContent.trim()) {
-              this.pushWithIndent(currentLineContent.trim())
-              currentLineContent = ""
-            }
+    const lastUnit = result[result.length - 1]
 
-            this.visit(child)
+    if (!lastUnit.unit.isAtomic || (lastUnit.unit.type !== 'erb' && lastUnit.unit.type !== 'inline')) {
+      return false
+    }
+
+    const words = normalizeAndSplitWords(textNode.content)
+    if (words.length === 0 || !words[0]) return false
+    if (!startsWithAlphanumeric(words[0])) return false
+
+    lastUnit.unit.content += words[0]
+
+    if (words.length > 1) {
+      const remainingText = words.slice(1).join(' ')
+
+      result.push({
+        unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+        node: textNode
+      })
+    }
+
+    return true
+  }
+
+  /**
+   * Try to merge an atomic unit (ERB/inline) with preceding text that has no whitespace
+   * Returns true if merge was performed
+   */
+  private tryMergeAtomicAfterText(result: ContentUnitWithNode[], children: Node[], lastProcessedIndex: number, atomicContent: string, atomicType: 'erb' | 'inline', atomicNode: Node): boolean {
+    if (result.length === 0) return false
+
+    const lastUnit = result[result.length - 1]
+
+    if (lastUnit.unit.type !== 'text' || lastUnit.unit.isAtomic) return false
+
+    const words = normalizeAndSplitWords(lastUnit.unit.content)
+    const lastWord = words[words.length - 1]
+
+    if (!lastWord) return false
+
+    result.pop()
+
+    if (words.length > 1) {
+      const remainingText = words.slice(0, -1).join(' ')
+
+      result.push({
+        unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+        node: children[lastProcessedIndex]
+      })
+    }
+
+    result.push({
+      unit: { content: lastWord + atomicContent, type: atomicType, isAtomic: true, breaksFlow: false },
+      node: atomicNode
+    })
+
+    return true
+  }
+
+  /**
+   * Check if there's whitespace between current node and last processed node
+   */
+  private hasWhitespaceBeforeNode(children: Node[], lastProcessedIndex: number, currentIndex: number, currentNode: Node): boolean {
+    if (hasWhitespaceBetween(children, lastProcessedIndex, currentIndex)) {
+      return true
+    }
+
+    if (isNode(currentNode, HTMLTextNode) && /^\s/.test(currentNode.content)) {
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Check if last unit in result ends with whitespace
+   */
+  private lastUnitEndsWithWhitespace(result: ContentUnitWithNode[]): boolean {
+    if (result.length === 0) return false
+
+    const lastUnit = result[result.length - 1]
+
+    return lastUnit.unit.type === 'text' && endsWithWhitespace(lastUnit.unit.content)
+  }
+
+  /**
+   * Process a text node and add it to results (with potential merging)
+   */
+  private processTextNode(result: ContentUnitWithNode[], children: Node[], child: HTMLTextNode, index: number, lastProcessedIndex: number): void {
+    const isAtomic = child.content === ' '
+
+    if (!isAtomic && lastProcessedIndex >= 0) {
+      const hasWhitespace = this.hasWhitespaceBeforeNode(children, lastProcessedIndex, index, child)
+
+      if (!hasWhitespace && this.tryMergeTextAfterAtomic(result, child)) {
+        return
+      }
+    }
+
+    result.push({
+      unit: { content: child.content, type: 'text', isAtomic, breaksFlow: false },
+      node: child
+    })
+  }
+
+  /**
+   * Process an inline element and add it to results (with potential merging)
+   */
+  private processInlineElement(result: ContentUnitWithNode[], children: Node[], child: HTMLElementNode, index: number, lastProcessedIndex: number): boolean {
+    const tagName = getTagName(child)
+    const inlineContent = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), filterEmptyNodes(child.body))
+
+    if (inlineContent === null) {
+      result.push({
+        unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+        node: child
+      })
+
+      return false
+    }
+
+    if (lastProcessedIndex >= 0) {
+      const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result)
+
+      if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, inlineContent, 'inline', child)) {
+        return true
+      }
+    }
+
+    result.push({
+      unit: { content: inlineContent, type: 'inline', isAtomic: true, breaksFlow: false },
+      node: child
+    })
+
+    return false
+  }
+
+  /**
+   * Process an ERB content node and add it to results (with potential merging)
+   */
+  private processERBContentNode(result: ContentUnitWithNode[], children: Node[], child: ERBContentNode, index: number, lastProcessedIndex: number): boolean {
+    const erbContent = this.renderERBAsString(child)
+
+    if (lastProcessedIndex >= 0) {
+      const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result)
+
+      if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, erbContent, 'erb', child)) {
+        return true
+      }
+    }
+
+    result.push({
+      unit: { content: erbContent, type: 'erb', isAtomic: true, breaksFlow: false },
+      node: child
+    })
+
+    return false
+  }
+
+  /**
+   * Convert AST nodes to content units with node references
+   */
+  private buildContentUnitsWithNodes(children: Node[]): ContentUnitWithNode[] {
+    const result: ContentUnitWithNode[] = []
+    let lastProcessedIndex = -1
+
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i]
+
+      if (isNode(child, WhitespaceNode)) continue
+      if (isPureWhitespaceNode(child) && !(isNode(child, HTMLTextNode) && child.content === ' ')) continue
+
+      if (isNode(child, HTMLTextNode)) {
+        this.processTextNode(result, children, child, i, lastProcessedIndex)
+
+        lastProcessedIndex = i
+      } else if (isNode(child, HTMLElementNode)) {
+        const tagName = getTagName(child)
+
+        if (isInlineElement(tagName)) {
+          const merged = this.processInlineElement(result, children, child, i, lastProcessedIndex)
+
+          if (merged) {
+            lastProcessedIndex = i
+
+            continue
           }
         } else {
-          if (currentLineContent.trim()) {
-            this.pushWithIndent(currentLineContent.trim())
-            currentLineContent = ""
-          }
-
-          this.visit(child)
+          result.push({
+            unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+            node: child
+          })
         }
-      } else if (isNode(child, ERBContentNode)) {
-        const oldLines = this.lines
-        const oldInlineMode = this.inlineMode
 
-        // TODO: use this.capture
-        try {
-          this.lines = []
-          this.inlineMode = true
-          this.visit(child)
-          const erbContent = this.lines.join("")
-          currentLineContent += erbContent
+        lastProcessedIndex = i
+      } else if (isNode(child, ERBContentNode)) {
+        const merged = this.processERBContentNode(result, children, child, i, lastProcessedIndex)
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            this.lines = oldLines
-            this.inlineMode = oldInlineMode
-            children.forEach(child => this.visit(child))
+        if (merged) {
+          lastProcessedIndex = i
 
-            return
-          }
-        } finally {
-          this.lines = oldLines
-          this.inlineMode = oldInlineMode
+          continue
         }
+
+        lastProcessedIndex = i
       } else {
-        if (currentLineContent.trim()) {
-          this.pushWithIndent(currentLineContent.trim())
-          currentLineContent = ""
-        }
+        result.push({
+          unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+          node: child
+        })
 
-        this.visit(child)
+        lastProcessedIndex = i
       }
     }
 
-    if (currentLineContent.trim()) {
-      const finalLine = this.indent + currentLineContent.trim()
+    return result
+  }
 
-      if (finalLine.length > Math.max(this.maxLineLength, 120)) {
-        this.visitAll(children)
+  /**
+   * Flush accumulated words to output with wrapping
+   */
+  private flushWords(words: string[]): void {
+    if (words.length > 0) {
+      this.wrapAndPushWords(words)
+      words.length = 0
+    }
+  }
 
-        return
+  /**
+   * Wrap words to fit within line length and push to output
+   * Handles punctuation spacing intelligently
+   */
+  private wrapAndPushWords(words: string[]): void {
+    const wrapWidth = this.maxLineLength - this.indent.length
+    const lines: string[] = []
+    let currentLine = ""
+
+    for (const word of words) {
+      const nextLine = buildLineWithWord(currentLine, word)
+
+      if (shouldWrapToNextLine(nextLine, currentLine, word, wrapWidth)) {
+        lines.push(this.indent + currentLine)
+        currentLine = word
+      } else {
+        currentLine = nextLine
       }
+    }
 
-      this.push(finalLine)
+    if (currentLine) {
+      lines.push(this.indent + currentLine)
     }
+
+    lines.forEach(line => this.push(line))
   }
 
   private isInTextFlowContext(_parent: Node | null, children: Node[]): boolean {
@@ -1486,7 +1746,7 @@ export class FormatPrinter extends Printer {
       if (isNode(child, ERBContentNode)) return true
 
       if (isNode(child, HTMLElementNode)) {
-        return this.isInlineElement(getTagName(child))
+        return isInlineElement(getTagName(child))
       }
 
       return false
@@ -1576,7 +1836,7 @@ export class FormatPrinter extends Printer {
         } else {
           const printed = IdentityPrinter.print(child)
 
-          if (this.currentAttributeName && FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)) {
+          if (this.isInTokenListAttribute) {
             return printed.replace(/%>([^<\s])/g, '%> $1').replace(/([^>\s])<%/g, '$1 <%')
           }
 
@@ -1632,6 +1892,7 @@ export class FormatPrinter extends Printer {
    */
   private tryRenderChildrenInline(children: Node[]): string | null {
     let result = ""
+    let hasInternalWhitespace = false
 
     for (const child of children) {
       if (isNode(child, HTMLTextNode)) {
@@ -1655,19 +1916,25 @@ export class FormatPrinter extends Printer {
         } else if (hasLeadingSpace || hasTrailingSpace) {
           if (result && !result.endsWith(' ')) {
             result += ' '
+            hasInternalWhitespace = true
           }
         }
 
+      } else if (isNode(child, WhitespaceNode)) {
+        if (result && !result.endsWith(' ')) {
+          result += ' '
+          hasInternalWhitespace = true
+        }
       } else if (isNode(child, HTMLElementNode)) {
         const tagName = getTagName(child)
 
-        if (!this.isInlineElement(tagName)) {
+        if (!isInlineElement(tagName)) {
           return null
         }
 
         const childInline = this.tryRenderInlineFull(child, tagName,
           filterNodes(child.open_tag?.children, HTMLAttributeNode),
-          this.filterEmptyNodes(child.body)
+          filterEmptyNodes(child.body)
         )
 
         if (!childInline) {
@@ -1676,11 +1943,18 @@ export class FormatPrinter extends Printer {
 
         result += childInline
       } else {
-        result += this.capture(() => this.visit(child)).join("")
+        const wasInlineMode = this.inlineMode
+        this.inlineMode = true
+
+        const captured = this.capture(() => this.visit(child)).join("")
+
+        this.inlineMode = wasInlineMode
+
+        result += captured
       }
     }
 
-    return result.trim()
+    return hasInternalWhitespace ? result : result.trim()
   }
 
   /**
@@ -1694,9 +1968,7 @@ export class FormatPrinter extends Printer {
           return null
         }
       } else if (isNode(child, HTMLElementNode)) {
-        const isInlineElement = this.isInlineElement(getTagName(child))
-
-        if (!isInlineElement) {
+        if (!isInlineElement(getTagName(child))) {
           return null
         }
       } else if (isNode(child, ERBContentNode)) {
@@ -1715,122 +1987,8 @@ export class FormatPrinter extends Printer {
     return `<${tagName}>${content}</${tagName}>`
   }
 
-  /**
-   * Check if children contain mixed text and inline elements (like "text<em>inline</em>text")
-   * or mixed ERB output and text (like "<%= value %> text")
-   * This indicates content that should be formatted inline even with structural newlines
-   */
-  private hasMixedTextAndInlineContent(children: Node[]): boolean {
-    let hasText = false
-    let hasInlineElements = false
-
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        if (child.content.trim() !== "") {
-          hasText = true
-        }
-      } else if (isNode(child, HTMLElementNode)) {
-        if (this.isInlineElement(getTagName(child))) {
-          hasInlineElements = true
-        }
-      }
-    }
-
-    return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText)
-  }
-
-  /**
-   * Check if children contain any text content with newlines
-   */
-  private hasMultilineTextContent(children: Node[]): boolean {
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        return child.content.includes('\n')
-      }
-
-      if (isNode(child, HTMLElementNode)) {
-        const nestedChildren = this.filterEmptyNodes(child.body)
-
-        if (this.hasMultilineTextContent(nestedChildren)) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  /**
-   * Check if all nested elements in the children are inline elements
-   */
-  private areAllNestedElementsInline(children: Node[]): boolean {
-    for (const child of children) {
-      if (isNode(child, HTMLElementNode)) {
-        if (!this.isInlineElement(getTagName(child))) {
-          return false
-        }
-
-        const nestedChildren = this.filterEmptyNodes(child.body)
-
-        if (!this.areAllNestedElementsInline(nestedChildren)) {
-          return false
-        }
-      } else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  /**
-   * Check if element has complex ERB control flow
-   */
-  private hasComplexERBControlFlow(inlineNodes: Node[]): boolean {
-    return inlineNodes.some(node => {
-      if (isNode(node, ERBIfNode)) {
-        if (node.statements.length > 0 && node.location) {
-          const startLine = node.location.start.line
-          const endLine = node.location.end.line
-
-          return startLine !== endLine
-        }
-
-        return false
-      }
-
-      return false
-    })
-  }
-
-  /**
-   * Filter children to remove insignificant whitespace
-   */
-  private filterSignificantChildren(body: Node[], hasTextFlow: boolean): Node[] {
-    return body.filter(child => {
-      if (isNode(child, WhitespaceNode)) return false
-
-      if (isNode(child, HTMLTextNode)) {
-        if (hasTextFlow && child.content === " ") return true
-
-        return child.content.trim() !== ""
-      }
-
-      return true
-    })
-  }
-
-  /**
-   * Filter out empty text nodes and whitespace nodes
-   */
-  private filterEmptyNodes(nodes: Node[]): Node[] {
-    return nodes.filter(child =>
-      !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === "")
-    )
-  }
-
   private renderElementInline(element: HTMLElementNode): string {
-    const children = this.filterEmptyNodes(element.body)
+    const children = filterEmptyNodes(element.body)
 
     return this.renderChildrenInline(children)
   }
@@ -1855,10 +2013,4 @@ export class FormatPrinter extends Printer {
 
     return content.replace(/\s+/g, ' ').trim()
   }
-
-  private isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean {
-    const tagName = getTagName(element)
-
-    return FormatPrinter.CONTENT_PRESERVING_ELEMENTS.has(tagName)
-  }
 }
diff --git a/javascript/packages/formatter/test/cli.test.ts b/javascript/packages/formatter/test/cli.test.ts
index 5d4d3ed46..bbb0b302d 100644
--- a/javascript/packages/formatter/test/cli.test.ts
+++ b/javascript/packages/formatter/test/cli.test.ts
@@ -155,20 +155,41 @@ describe("CLI Binary", () => {
     }
   })
 
-  it("should show experimental preview message", async () => {
+  it("should show experimental preview message on stderr", async () => {
     const result = await execBinary([])
 
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain("early development")
-    expect(result.stdout).toContain("github.com/marcoroth/herb/issues")
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stderr).toContain("early development")
+    expect(result.stderr).toContain("github.com/marcoroth/herb/issues")
+  })
+
+  it("should not include experimental preview message in stdout", async () => {
+    const input = '<div>test</div>'
+    const result = await execBinary([], input)
+
+    expectExitCode(result, 0)
+    expect(result.stdout).not.toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toContain('<div>test</div>')
+  })
+
+  it("stdout should contain only formatted output without warnings", async () => {
+    const input = '<div class="test"><p>Hello</p></div>'
+    const result = await execBinary([], input)
+
+    expectExitCode(result, 0)
+
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).not.toContain("⚠️")
+    expect(result.stdout).not.toContain("Experimental")
+    expect(result.stdout).toBe('<div class="test">\n  <p>Hello</p>\n</div>\n')
   })
 
   it("should format empty input from stdin when no args provided", async () => {
     const result = await execBinary([], "")
 
     expectExitCode(result, 0)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain("\n\n")
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe("\n")
   })
 
   it("should handle no files found in empty directory", async () => {
@@ -178,9 +199,9 @@ describe("CLI Binary", () => {
       const result = await execBinary(["test-empty-dir"])
 
       expectExitCode(result, 0)
-      expect(result.stdout).toContain("⚠️  Experimental Preview")
+      expect(result.stderr).toContain("⚠️  Experimental Preview")
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-empty-dir/**/*.html.erb")
+      expect(result.stdout).toContain("test-empty-dir/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     } finally {
       await rm("test-empty-dir", { recursive: true }).catch(() => {})
     }
@@ -232,7 +253,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern:")
-      expect(result.stdout).toContain("test-dir/**/*.html.erb")
+      expect(result.stdout).toContain("test-dir/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     } finally {
       await rm("test-dir", { recursive: true }).catch(() => {})
     }
@@ -365,12 +386,8 @@ describe("CLI Binary", () => {
 
     expectExitCode(result, 0)
     expect(result.stdout.endsWith('\n')).toBe(true)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain('<div>Hello</div>')
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('<div>Hello</div>\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('<div>Hello</div>\n')
   })
 
   it("CLI should preserve existing trailing newline", async () => {
@@ -379,12 +396,8 @@ describe("CLI Binary", () => {
 
     expectExitCode(result, 0)
     expect(result.stdout.endsWith('\n')).toBe(true)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-    expect(result.stdout).toContain('<div>Hello</div>')
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('<div>Hello</div>\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('<div>Hello</div>\n')
   })
 
   it("CLI should add trailing newline to empty input", async () => {
@@ -392,11 +405,8 @@ describe("CLI Binary", () => {
     const result = await execBinary([], input)
 
     expectExitCode(result, 0)
-    expect(result.stdout).toContain("⚠️  Experimental Preview")
-
-    const lines = result.stdout.split('\n')
-    const formattedLines = lines.slice(2) // Skip experimental preview lines
-    expect(formattedLines.join('\n')).toBe('\n')
+    expect(result.stderr).toContain("⚠️  Experimental Preview")
+    expect(result.stdout).toBe('\n')
   })
 
   it("should show --indent-width option in help", async () => {
@@ -632,7 +642,7 @@ describe("CLI Binary", () => {
 
       expectExitCode(result, 0)
       expect(result.stdout).toContain("No files found matching pattern")
-      expect(result.stdout).toContain("test-advanced/**/*.html.erb")
+      expect(result.stdout).toContain("test-advanced/**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb")
     })
 
     it("should handle mixed file arguments", async () => {
diff --git a/javascript/packages/formatter/test/document-formatting.test.ts b/javascript/packages/formatter/test/document-formatting.test.ts
index 60a3e1e5f..1f7d4c633 100644
--- a/javascript/packages/formatter/test/document-formatting.test.ts
+++ b/javascript/packages/formatter/test/document-formatting.test.ts
@@ -692,7 +692,8 @@ describe("Document-level formatting", () => {
                 </h1>
 
                 <h2 class="text-inherit opacity-60 text-sm line-clamp-1">
-                  <%= event.static_metadata.location %> • <%= event.formatted_dates %>
+                  <%= event.static_metadata.location %> •
+                  <%= event.formatted_dates %>
                 </h2>
 
                 <h2 class="text-inherit font-medium text-sm line-clamp-3 hidden lg:block">
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
index 34966f819..d9f14add6 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-additional.test.ts
@@ -44,11 +44,10 @@ describe("ERB Formatter Additional Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo
-          <span>co<strong>nse</strong>quat.</span>
-          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore
-          eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt
-          in culpa qui officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute
+          irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
+          nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa
+          qui officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
@@ -70,7 +69,8 @@ describe("ERB Formatter Additional Tests", () => {
 
     test("handles complex ERB with vite and stylesheet tags", () => {
       const source = dedent`
-        <%- vite_client_tag %> <%= vite_typescript_tag "application", "data-turbo-track": "reload", defer: true %>
+        <%- vite_client_tag %>
+        <%= vite_typescript_tag "application", "data-turbo-track": "reload", defer: true %>
         <%= stylesheet_link_tag "tailwind",
         "inter-font",
         "data-turbo-track": "reload",
diff --git a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
index 614b073e7..8bb33b5dc 100644
--- a/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
+++ b/javascript/packages/formatter/test/erb-formatter/erb-formatter-compat.test.ts
@@ -221,11 +221,10 @@ describe("ERB Formatter Compatibility Tests", () => {
           Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
           tempor incididunt ut labore et dolore magna aliqua. 🍰🍰🍰🍰🍰🍰🍰🍰🍰🍰Ut
           enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
-          aliquip ex ea commodo
-          <span>co<strong>nse</strong>quat.</span>
-          Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore
-          eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt
-          in culpa qui officia deserunt mollit anim id est laborum.
+          aliquip ex ea commodo <span>co<strong>nse</strong>quat.</span> Duis aute
+          irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat
+          nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa
+          qui officia deserunt mollit anim id est laborum.
         </p>
       `)
     })
diff --git a/javascript/packages/formatter/test/erb/erb.test.ts b/javascript/packages/formatter/test/erb/erb.test.ts
index a42a1857f..6f5e54554 100644
--- a/javascript/packages/formatter/test/erb/erb.test.ts
+++ b/javascript/packages/formatter/test/erb/erb.test.ts
@@ -12,12 +12,12 @@ describe("@herb-tools/formatter", () => {
 
     formatter = new Formatter(Herb, {
       indentWidth: 2,
-      maxLineLength: 80
+      maxLineLength: 80,
     })
   })
 
   test("formats simple HTML with ERB content", () => {
-    const source = '<div><%= "Hello" %> World</div>'
+    const source = `<div><%= "Hello" %> World</div>`
     const result = formatter.format(source)
     expect(result).toEqual(dedent`
       <div><%= "Hello" %> World</div>
@@ -25,11 +25,49 @@ describe("@herb-tools/formatter", () => {
   })
 
   test("formats standalone ERB", () => {
-    const source = '<% title %>'
+    const source = `<% title %>`
     const result = formatter.format(source)
     expect(result).toEqual(`<% title %>`)
   })
 
+  test("ERB output tags on two lines on top-level", () => {
+    const source = dedent`
+      <%= title %>
+      <%= title %>
+    `
+    const expected = dedent`
+      <%= title %>
+
+      <%= title %>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(expected)
+  })
+
+  test("adjecent ERB output tags without space on top-level", () => {
+    const source = `<%= title %><%= title %>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<%= title %><%= title %>`)
+  })
+
+  test("adjecent ERB output tags with space on top-level", () => {
+    const source = `<%= title %> <%= title %>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<%= title %> <%= title %>`)
+  })
+
+  test("adjecent ERB output tags without space within <p>", () => {
+    const source = `<p><%= title %><%= title %></p>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<p><%= title %><%= title %></p>`)
+  })
+
+  test("adjecent ERB output tags with space within <p>", () => {
+    const source = `<p><%= title %> <%= title %></p>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<p><%= title %> <%= title %></p>`)
+  })
+
   test("formats nested blocks with final example", () => {
     const source = `
       <div id="output">
@@ -105,11 +143,11 @@ describe("@herb-tools/formatter", () => {
       '<%= link_to "test" %>',
       '<%= link_to "test", class: "btn" %>',
       '<%= render "partial" %>',
-      '<% if something? %>',
-      '<%= tag.div("content") %>'
+      "<% if something? %>",
+      '<%= tag.div("content") %>',
     ]
 
-    inputs.forEach(input => {
+    inputs.forEach((input) => {
       const result = formatter.format(input)
       expect(result).not.toContain("% %>")
       expect(result).toBe(input)
@@ -127,12 +165,8 @@ describe("@herb-tools/formatter", () => {
 
     expect(result).toBe(dedent`
       <h3>
-        <%= link_to "Start", start_path %>
-        &rsquo;s overview of
-        <%= link_to "Section", section_path %>
-        ,
-        <%= link_to "End", end_path %>
-        .
+        <%= link_to "Start", start_path %> &rsquo;s overview of
+        <%= link_to "Section", section_path %>, <%= link_to "End", end_path %>.
       </h3>
     `)
   })
@@ -148,12 +182,1424 @@ describe("@herb-tools/formatter", () => {
 
     expect(result).toBe(dedent`
       <p class="info-text">
-        For assistance, contact us at
-        <%= config.phone_number %>
-        or
-        <%= mail_to(config.support_email, class: "email-link") %>
-        if you need help with your account.
+        For assistance, contact us at <%= config.phone_number %> or
+        <%= mail_to(config.support_email, class: "email-link") %> if you need help
+        with your account.
+      </p>
+    `)
+  })
+
+  test("issue 469: keeps punctuation attached to ERB interpolations and inline elements", () => {
+    const input = `<%= @user.translated_greeting %>,<br>`
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(`<%= @user.translated_greeting %>,<br>`)
+  })
+
+  test("issue 590: does not duplicate content with inline elements and long lines", () => {
+    const input = dedent`
+      <p>
+        <strong>Hi</strong><br>
+        0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567
+      </p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p>
+        <strong>Hi</strong><br>
+        0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567
+      </p>
+    `)
+  })
+
+  test("issue 588: does not recursively duplicate text and br tags", () => {
+    const input = dedent`
+      <%= form_with model: @article do |form| %>
+        <div>
+          <p>
+            Text 1
+            <br>
+            The lantern flickered softly in the wind as the old clock struck midnight
+            across the quiet village, casting long shadows that danced upon the
+            cobblestone streets.
+          </p>
+        </div>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <%= form_with model: @article do |form| %>
+        <div>
+          <p>
+            Text 1
+            <br>
+            The lantern flickered softly in the wind as the old clock struck midnight
+            across the quiet village, casting long shadows that danced upon the
+            cobblestone streets.
+          </p>
+        </div>
+      <% end %>
+    `)
+
+    const secondFormat = formatter.format(result)
+    expect(secondFormat).toBe(result)
+  })
+
+  test("issue 564: does not duplicate multiline text with br elements", () => {
+    const input = dedent`
+      <span>
+        Par défaut, un dossier déposé peut être complété ou corrigé par le demandeur jusqu'à sa mise en instruction.
+        <br>
+        Dans une démarche déclarative, une fois déposé, un dossier ne peut plus être modifié. Soit il passe immédiatement en instruction
+      </span>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <span>
+        Par défaut, un dossier déposé peut être complété ou corrigé par le demandeur
+        jusqu'à sa mise en instruction.
+        <br>
+        Dans une démarche déclarative, une fois déposé, un dossier ne peut plus être
+        modifié. Soit il passe immédiatement en instruction
+      </span>
+    `)
+
+    const secondFormat = formatter.format(result)
+    expect(secondFormat).toBe(result)
+  })
+
+  test("https://github.com/hanakai-rb/site/blob/8adc128d9d464f3e37615be2aa29d57979904533/app/templates/pages/home.html.erb", () => {
+    const input = dedent`
+      <h1>Hanakai</h1>
+
+      <p>This is the upcoming Hanakai website.</p>
+
+      <p>This will be the all-in-one home for everything to do with <a href="https://hanamirb.org">Hanami</a>, <a href="https://dry-rb.org">Dry</a> and <a href="https://rom-rb.org">Rom</a>.</p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <h1>Hanakai</h1>
+
+      <p>This is the upcoming Hanakai website.</p>
+
+      <p>
+        This will be the all-in-one home for everything to do with
+        <a href="https://hanamirb.org">Hanami</a>,
+        <a href="https://dry-rb.org">Dry</a> and <a href="https://rom-rb.org">Rom</a>.
       </p>
     `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3220198776", () => {
+    const input = dedent`
+      <p
+        style="margin: 0px; color: #2f2f2b; text-align: center; font-size: 14px; line-height: 20px;"
+      >
+        Here is some text.
+        <br />
+        Tel:
+        <a
+          href="#"
+          style="color: #2f2f2b; font-size: 16px; text-decoration: none;"
+          itemprop="telephone"
+        >
+          08-123 456 78
+        </a>
+      </p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p
+        style="margin: 0px; color: #2f2f2b; text-align: center; font-size: 14px; line-height: 20px;"
+      >
+        Here is some text.
+        <br />
+        Tel:
+        <a href="#" style="color: #2f2f2b; font-size: 16px; text-decoration: none;" itemprop="telephone">08-123 456 78</a>
+      </p>
+    `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/564#issuecomment-3371485687", () => {
+    const input = dedent`
+      <p>Should not be duplicated.<br />Text with a inline element<a href="mailto:something@something.com">something@something.com</a> and some more text after</p>
+    `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+      <p>
+        Should not be duplicated.
+        <br />
+        Text with a inline
+        element<a href="mailto:something@something.com">something@something.com</a>
+        and some more text after
+      </p>
+    `)
+
+    expect(formatter.format(result)).toBe(result)
+  })
+
+  test("handles inline HTML elements with long text content", () => {
+    const input = dedent`
+       <p>
+         Visit <a href="/products">our amazing product catalog with hundreds of items</a> or <a href="/support">contact our customer support team</a> for assistance with your order.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Visit
+         <a href="/products">our amazing product catalog with hundreds of items</a> or
+         <a href="/support">contact our customer support team</a> for assistance with
+         your order.
+       </p>
+     `)
+  })
+
+  test("handles multiple inline elements with adjacent text", () => {
+    const input = dedent`
+       <div>
+         Call us at <strong>555-123-4567</strong>, email <a href="mailto:help@example.com">help@example.com</a>, or visit <em>our downtown office</em> during business hours.
+       </div>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <div>
+         Call us at <strong>555-123-4567</strong>, email
+         <a href="mailto:help@example.com">help@example.com</a>, or visit
+         <em>our downtown office</em> during business hours.
+       </div>
+     `)
+  })
+
+  test("handles inline elements with punctuation attachment", () => {
+    const input = dedent`
+       <p>
+         Read the <a href="/terms">terms and conditions</a>, review our <a href="/privacy">privacy policy</a>, and check the <a href="/faq">frequently asked questions</a>.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Read the <a href="/terms">terms and conditions</a>, review our
+         <a href="/privacy">privacy policy</a>, and check the
+         <a href="/faq">frequently asked questions</a>.
+       </p>
+     `)
+  })
+
+  test("handles nested inline elements with line wrapping", () => {
+    const input = dedent`
+       <p>
+         Please review <strong>Chapter <em>3: Advanced Techniques</em> in the <a href="/manual">user manual</a></strong> for detailed instructions on configuration.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         Please review
+         <strong>Chapter <em>3: Advanced Techniques</em> in the <a href="/manual">user manual</a></strong>
+         for detailed instructions on configuration.
+       </p>
+     `)
+  })
+
+  test("handles inline elements immediately followed by punctuation", () => {
+    const input = dedent`
+       <div>
+         Download the <a href="/app.zip">latest version</a>; install it quickly; then restart your <strong>computer</strong>!
+       </div>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <div>
+         Download the <a href="/app.zip">latest version</a>; install it quickly; then
+         restart your <strong>computer</strong>!
+       </div>
+     `)
+  })
+
+  test("handles mixed content with inline elements and long URLs", () => {
+    const input = dedent`
+       <p>
+         For more information, visit <a href="https://example.com/very/long/path/to/documentation/page">our comprehensive documentation</a> or contact support.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         For more information, visit
+         <a href="https://example.com/very/long/path/to/documentation/page">our comprehensive documentation</a>
+         or contact support.
+       </p>
+     `)
+  })
+
+  test("handles anchor tags with content that forces line breaks", () => {
+    const input = dedent`
+       <p>
+         For more information, visit <a href="https://example.com/very/long/path/to/documentation/page/so/long/that/it/should/break/the/content/of/the/tag">our comprehensive documentation</a> or contact support.
+       </p>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <p>
+         For more information, visit
+         <a href="https://example.com/very/long/path/to/documentation/page/so/long/that/it/should/break/the/content/of/the/tag">our comprehensive documentation</a>
+         or contact support.
+       </p>
+     `)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/469#issue-3379906221", () => {
+    const input = dedent`
+       <%= @user.translated_greeting %>,<br>
+     `
+
+    const result = formatter.format(input)
+
+    expect(result).toBe(dedent`
+       <%= @user.translated_greeting %>,<br>
+     `)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issue-3351228515", () => {
+    const input = dedent`
+      <!DOCTYPE html>
+      <html xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" data-theme="light">
+        <head>
+          <meta charset="utf-8">
+          <meta http-equiv="x-ua-compatible" content="ie=edge">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <meta name="format-detection" content="telephone=no, date=no, address=no, email=no, url=no">
+          <meta name="x-apple-disable-message-reformatting">
+          <title><%= message.subject %> | Company</title>
+          <%= stylesheet_link_tag "mailer", media: "all" %>
+          <style>
+            @import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap');
+          </style>
+          <style>
+            @media only screen and (max-width: 600px) {
+              .hidden-mobile {
+                display: none !important;
+              }
+            }
+            @media only screen and (min-width: 601px) {
+              .hidden-desktop {
+                display: none !important;
+              }
+            }
+          </style>
+        </head>
+        <body  style="font-family: 'DM Sans', Arial, sans-serif;">
+          <% if content_for?(:preheader) %>
+            <div class="hidden">
+              <%= yield :preheader %>
+            </div>
+          <% end %>
+          <div role="article" aria-roledescription="email" aria-label="<%= message.subject %>" lang="en">
+            <table border="0" cellpadding="0" cellspacing="0" width="100%" class="bg-background leading-normal text-base">
+              <tr>
+                <td height="32"></td>
+              </tr>
+              <tr>
+                <td align="center">
+                  <table border="0" cellpadding="0" cellspacing="0" class="w-full max-w-[684px] px-0 sm:w-[684px] sm-px-2" width="100%">
+                    <tr>
+                      <td>
+                        <div class="shadow-xl border border-border-secondary rounded-lg overflow-hidden">
+                          <div class="space-y-2 bg-primary-foreground p-4"><% if content_for?(:header) %>
+                              <%= yield :header %>
+                            <% else %>
+                              <%= hosted_image_tag('mailer/header-logo.png', class: 'h-[35px] block mb-3') %>
+                            <% end %>
+                            <%= yield %>
+                          </div>
+                          <div class="p-4 bg-primary-foreground text-center border-t border-border-secondary">
+                            <%= hosted_image_tag('mailer/footer-logo.png', class: 'h-[48px] mb-1') %>
+                            <p class="text-muted-foreground text-sm leading-5">
+                              &copy;<%= Time.current.year %> - Company Inc, All rights reserved.
+                              <br />
+                              Main Street, San Francisco, CAs, USA 12345
+                              <br />
+                              <a href="mailto:support@company.com">Contact Support</a> | <a href="https://company.com/terms">Terms of Service</a> | <a href="https://company.com/privacy">Privacy Policy</a>
+                            </p>
+                          </div>
+                        </div>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+              <tr>
+                <td height="32"></td>
+              </tr>
+            </table>
+          </div>
+        </body>
+      </html>
+    `
+
+    const expected = dedent`
+      <!DOCTYPE html>
+
+      <html
+        xmlns:v="urn:schemas-microsoft-com:vml"
+        xmlns:o="urn:schemas-microsoft-com:office:office"
+        data-theme="light"
+      >
+        <head>
+          <meta charset="utf-8">
+
+          <meta http-equiv="x-ua-compatible" content="ie=edge">
+
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+
+          <meta
+            name="format-detection"
+            content="telephone=no, date=no, address=no, email=no, url=no"
+          >
+
+          <meta name="x-apple-disable-message-reformatting">
+
+          <title><%= message.subject %> | Company</title>
+
+          <%= stylesheet_link_tag "mailer", media: "all" %>
+          <style>
+            @import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap');
+          </style>
+
+          <style>
+            @media only screen and (max-width: 600px) {
+              .hidden-mobile {
+                display: none !important;
+              }
+            }
+            @media only screen and (min-width: 601px) {
+              .hidden-desktop {
+                display: none !important;
+              }
+            }
+          </style>
+        </head>
+        <body style="font-family: 'DM Sans', Arial, sans-serif;">
+          <% if content_for?(:preheader) %>
+            <div class="hidden"><%= yield :preheader %></div>
+          <% end %>
+          <div
+            role="article"
+            aria-roledescription="email"
+            aria-label="<%= message.subject %>"
+            lang="en"
+          >
+            <table
+              border="0"
+              cellpadding="0"
+              cellspacing="0"
+              width="100%"
+              class="bg-background leading-normal text-base"
+            >
+              <tr>
+                <td height="32"></td>
+              </tr>
+              <tr>
+                <td align="center">
+                  <table
+                    border="0"
+                    cellpadding="0"
+                    cellspacing="0"
+                    class="w-full max-w-[684px] px-0 sm:w-[684px] sm-px-2"
+                    width="100%"
+                  >
+                    <tr>
+                      <td>
+                        <div
+                          class="
+                            shadow-xl border border-border-secondary rounded-lg
+                            overflow-hidden
+                          "
+                        >
+                          <div class="space-y-2 bg-primary-foreground p-4">
+                            <% if content_for?(:header) %>
+                              <%= yield :header %>
+                            <% else %>
+                              <%= hosted_image_tag('mailer/header-logo.png', class: 'h-[35px] block mb-3') %>
+                            <% end %>
+                            <%= yield %>
+                          </div>
+                          <div
+                            class="
+                              p-4 bg-primary-foreground text-center border-t
+                              border-border-secondary
+                            "
+                          >
+                            <%= hosted_image_tag('mailer/footer-logo.png', class: 'h-[48px] mb-1') %>
+                            <p class="text-muted-foreground text-sm leading-5">
+                              &copy;<%= Time.current.year %> - Company Inc, All
+                              rights reserved.
+                              <br />
+                              Main Street, San Francisco, CAs, USA 12345
+                              <br />
+                              <a href="mailto:support@company.com">Contact Support</a>
+                              |
+                              <a href="https://company.com/terms">Terms of Service</a>
+                              |
+                              <a href="https://company.com/privacy">Privacy Policy</a>
+                            </p>
+                          </div>
+                        </div>
+                      </td>
+                    </tr>
+                  </table>
+                </td>
+              </tr>
+              <tr>
+                <td height="32"></td>
+              </tr>
+            </table>
+          </div>
+        </body>
+      </html>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 1", () => {
+    const input = dedent`
+      <% unless skip_sidebar? || sidebar_sections_for_action.blank? %>
+      <!-- <details class="d-collapse overflow-visible d-collapse-arrow border" <%= 'open' if params[:commit] == "Filter" && params[:q].present? %>> -->
+        <!-- <summary class="d-collapse-title text-xl font-medium">Filters</summary> -->
+        <!-- <div class="d-collapse-content"> </div> -->
+      <!-- </details> -->
+      <%= render "active_admin/shared/sidebar_sections" %>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% unless skip_sidebar? || sidebar_sections_for_action.blank? %>
+        <!-- <details class="d-collapse overflow-visible d-collapse-arrow border" <%= 'open' if params[:commit] == "Filter" && params[:q].present? %>> -->
+        <!-- <summary class="d-collapse-title text-xl font-medium">Filters</summary> -->
+        <!-- <div class="d-collapse-content"> </div> -->
+        <!-- </details> -->
+        <%= render "active_admin/shared/sidebar_sections" %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 2", () => {
+    const input = dedent`
+      <div class="relative">
+      <button id="column-toggle-btn" class="d-btn d-btn-sm d-btn-secondary">
+        <span>Show/Hide Columns</span>
+      </button>
+      <div id="column-dropdown" class="absolute right-0 mt-1 bg-white border rounded-md shadow-lg z-10 p-2 hidden">
+        <div class="flex flex-col space-y-1 min-w-[200px]">
+          <% columns.each do |column| %>
+            <div class="form-control">
+              <label class="cursor-pointer label justify-start gap-2">
+                <input type="checkbox" class="column-toggle checkbox checkbox-sm" data-column="<%= column[:name] %>" <%= 'checked' if column[:default_visible] %>>
+                <span class="label-text text-muted-foreground">
+                  <%= column[:label] %>
+                </span>
+              </label>
+            </div>
+          <% end %>
+        </div>
+      </div>
+      </div>
+
+      <script>
+      document.addEventListener('DOMContentLoaded', function() {
+        // Column toggle functionality
+        const columnToggleBtn = document.getElementById('column-toggle-btn');
+        const columnDropdown = document.getElementById('column-dropdown');
+
+        // Toggle dropdown visibility
+        columnToggleBtn.addEventListener('click', function() {
+          columnDropdown.classList.toggle('hidden');
+        });
+
+        // Close dropdown when clicking outside
+        document.addEventListener('click', function(event) {
+          if (!columnToggleBtn.contains(event.target) && !columnDropdown.contains(event.target)) {
+            columnDropdown.classList.add('hidden');
+          }
+        });
+
+        // Handle column visibility toggles
+        const columnToggles = document.querySelectorAll('.column-toggle');
+        columnToggles.forEach(toggle => {
+          toggle.addEventListener('change', function() {
+            const columnName = this.dataset.column;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+
+            columnCells.forEach(cell => {
+              if (this.checked) {
+                cell.style.display = '';
+              } else {
+                cell.style.display = 'none';
+              }
+            });
+
+            // Save column visibility preferences to localStorage
+            localStorage.setItem(\`column_\${columnName}\`, this.checked ? 'visible' : 'hidden');
+          });
+
+          // Apply saved preferences on load
+          const columnName = toggle.dataset.column;
+          const savedPreference = localStorage.getItem(\`column_\${columnName}\`);
+
+          if (savedPreference === 'hidden') {
+            toggle.checked = false;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+            columnCells.forEach(cell => {
+              cell.style.display = 'none';
+            });
+          }
+        });
+
+         columnToggles.forEach(toggle => {
+          if (!toggle.checked) {
+            const columnName = toggle.dataset.column;
+            const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+            columnCells.forEach(cell => {
+              cell.style.display = 'none';
+            });
+          }
+        });
+      });
+      </script>
+     `
+
+     const expected = dedent`
+       <div class="relative">
+         <button id="column-toggle-btn" class="d-btn d-btn-sm d-btn-secondary">
+           <span>Show/Hide Columns</span>
+         </button>
+         <div
+           id="column-dropdown"
+           class="
+             absolute right-0 mt-1 bg-white border rounded-md shadow-lg z-10 p-2
+             hidden
+           "
+         >
+           <div class="flex flex-col space-y-1 min-w-[200px]">
+             <% columns.each do |column| %>
+               <div class="form-control">
+                 <label class="cursor-pointer label justify-start gap-2">
+                   <input
+                     type="checkbox"
+                     class="column-toggle checkbox checkbox-sm"
+                     data-column="<%= column[:name] %>"
+                     <%= 'checked' if column[:default_visible] %>
+                   >
+                   <span class="label-text text-muted-foreground"><%= column[:label] %></span>
+                 </label>
+               </div>
+             <% end %>
+           </div>
+         </div>
+       </div>
+
+       <script>
+       document.addEventListener('DOMContentLoaded', function() {
+         // Column toggle functionality
+         const columnToggleBtn = document.getElementById('column-toggle-btn');
+         const columnDropdown = document.getElementById('column-dropdown');
+
+         // Toggle dropdown visibility
+         columnToggleBtn.addEventListener('click', function() {
+           columnDropdown.classList.toggle('hidden');
+         });
+
+         // Close dropdown when clicking outside
+         document.addEventListener('click', function(event) {
+           if (!columnToggleBtn.contains(event.target) && !columnDropdown.contains(event.target)) {
+             columnDropdown.classList.add('hidden');
+           }
+         });
+
+         // Handle column visibility toggles
+         const columnToggles = document.querySelectorAll('.column-toggle');
+         columnToggles.forEach(toggle => {
+           toggle.addEventListener('change', function() {
+             const columnName = this.dataset.column;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+
+             columnCells.forEach(cell => {
+               if (this.checked) {
+                 cell.style.display = '';
+               } else {
+                 cell.style.display = 'none';
+               }
+             });
+
+             // Save column visibility preferences to localStorage
+             localStorage.setItem(\`column_\${columnName}\`, this.checked ? 'visible' : 'hidden');
+           });
+
+           // Apply saved preferences on load
+           const columnName = toggle.dataset.column;
+           const savedPreference = localStorage.getItem(\`column_\${columnName}\`);
+
+           if (savedPreference === 'hidden') {
+             toggle.checked = false;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+             columnCells.forEach(cell => {
+               cell.style.display = 'none';
+             });
+           }
+         });
+
+          columnToggles.forEach(toggle => {
+           if (!toggle.checked) {
+             const columnName = toggle.dataset.column;
+             const columnCells = document.querySelectorAll(\`.column-\${columnName}\`);
+             columnCells.forEach(cell => {
+               cell.style.display = 'none';
+             });
+           }
+         });
+       });
+       </script>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 3", () => {
+    const input = dedent`
+      <style>
+        [data-test-page-header] {
+          margin-bottom: 0px;
+        }
+
+        @media (max-width: 768px) {
+          [data-test-page-header] nav {
+            display: none;
+          }
+        }
+      </style>
+
+      <% content_for :head do %>
+        <%= javascript_import_module_tag "src/chat" %>
+      <% end %>
+
+      <script>
+        window.chat_id = <%= chat.id %>;
+        window.chat_display_name = <%= chat.display_name.to_json.html_safe %>;
+        window.messages = <%= messages.to_json.html_safe %>;
+        window.settings = <%= chat.settings.to_json.html_safe %>;
+      </script>
+
+      <div class="pt-3" id="chat"></div>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(input)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 4", () => {
+    const input = dedent`
+      <% prices = params.dig("subscription", "prices") || resource.price_list.dig("products")&.map { |key, value| {product_id: key, stripe_price_id: value} } || [{product_id: Product::PUBLIC_IDS[:overweight]}] %>
+      <%= semantic_form_for [:admin, resource], url: override_prices_admin_subscription_path(resource), method: :post do |f| %>
+        <div>
+          <%= f.inputs do %>
+            <div id="price-inputs-container">
+              <% prices.each_with_index do |price, index| %>
+                <% stripe_price = Rails.cache.fetch("stripe_price_#{price[:stripe_price_id]}", expires_in: 1.hour) { Stripe::Price.retrieve(price[:stripe_price_id]) } if price[:stripe_price_id].present? %>
+
+                <div class="price-override-item">
+                  <%= f.input :product_id,
+                    as: :select,
+                    collection: Product.all,
+                    selected: price[:product_id],
+                    label: "Product #{index + 1}",
+                    value_field: :public_id,
+                    input_html: {
+                      name: "subscription[prices][#{index}][product_id]",
+                    } %>
+
+                  <%= f.input :amount,
+                    as: :number,
+                    label: "Price",
+                    input_html: {
+                      name: "subscription[prices][#{index}][amount]",
+                      value: price[:amount]&.to_i || stripe_price&.unit_amount&./(100) || 0,
+                      min: 0
+                    } %>
+
+                  <% if index > 0 %>
+                    <a
+                      href="#"
+                      class="remove-price-item link text-red-500 hover:text-red-700"
+                    >
+                      Remove Product
+                    </a>
+                  <% end %>
+                </div>
+              <% end %>
+            </div>
+
+            <div class="add-price-section">
+              <%= link_to "Add Another Product", "#", id: "add-price-btn", class: "button secondary" %>
+            </div>
+          <% end %>
+        </div>
+
+        <script id="price_item_template" type="text/template">
+          <div class="price-override-item">
+            <%= f.input :product_id,
+              as: :select,
+              collection: Product.all,
+              label: "Product INDEX_LABEL",
+              class: "select required",
+              value_field: :public_id,
+              input_html: {
+                id: "subscription_prices_INDEX_product_id",
+                name: "subscription[prices][INDEX][product_id]",
+                data: {
+                  searchable_field: "name",
+                  display_field: "display_name",
+                  search_url: "/admin/products.json?order=id_desc&q%5Bname_cont%5D={{query}}&commit=Filter"
+                }
+              } %>
+            <%= f.input :amount,
+              label: "Custom Price",
+              as: :number,
+              input_html: {
+                id: "subscription_prices_INDEX_amount",
+                name: "subscription[prices][INDEX][amount]",
+                value: 0,
+                min: 0,
+              } %>
+
+            <a href="#" class="remove-price-item link text-red-500 hover:text-red-700">Remove Product</a>
+          </div>
+        </script>
+
+        <div>
+          <%= f.actions do %>
+            <%= f.action :submit, label: "Override Prices" %>
+            <%= link_to "Cancel", resource_path(resource), class: "button" %>
+          <% end %>
+        </div>
+      <% end %>
+
+      <script>
+        document.addEventListener('DOMContentLoaded', function() {
+          var addPriceBtn = document.querySelector('#add-price-btn');
+          var container = document.querySelector('#price-inputs-container');
+          var template = document.querySelector('#price_item_template').innerHTML;
+          var priceItemCounter = <%= prices.length %>;
+
+          addPriceBtn.addEventListener('click', function(e) {
+            e.preventDefault();
+            var newTemplate = template
+              .replace(/INDEX_LABEL/g, priceItemCounter + 1)
+              .replace(/INDEX/g, priceItemCounter);
+            container.insertAdjacentHTML('beforeend', newTemplate);
+
+            var newItem = container.querySelector('.price-override-item:last-child');
+            var selectElement = newItem.querySelector('select');
+
+            if (selectElement && selectElement.dataset.searchUrl) {
+              new TomSelect(selectElement, {
+                allowEmptyOption: true,
+                create: false,
+                itemClass: "text-foreground px-1 py-0.5 rounded",
+                valueField: selectElement.dataset.valueField,
+                labelField: selectElement.dataset.displayField,
+                searchField: [selectElement.dataset.displayField],
+                plugins: ['dropdown_input'],
+
+                render: {
+                  option: function(data, escape) {
+                    return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                  },
+                  item: function(data, escape) {
+                    return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                  },
+                },
+
+                load: function(query, callback) {
+                  if (!query.length) return callback();
+                  fetch(selectElement.dataset.searchUrl.replace('{{query}}', encodeURIComponent(query)))
+                    .then(function(response) {
+                      return response.json();
+                    })
+                    .then(function(json) {
+                      const augmentedJson = json.map(item => ({ ...item, search_term: Object.values(item).join(' ') }))
+                      callback(augmentedJson);
+                    }).catch(function() {
+                      callback();
+                    });
+                },
+              });
+            }
+
+            priceItemCounter++;
+          });
+
+          container.addEventListener('click', function(e) {
+            if (e.target && e.target.classList.contains('remove-price-item')) {
+              e.preventDefault();
+              var priceItem = e.target.closest('.price-override-item');
+              if (priceItem) {
+                var destroyInput = priceItem.querySelector('input[type="hidden"][name*="[_destroy]"]');
+                if (destroyInput) {
+                  destroyInput.value = '1';
+                  priceItem.style.display = 'none';
+                } else {
+                  priceItem.remove();
+                }
+              }
+            }
+          });
+        });
+      </script>
+     `
+
+     const expected = dedent`
+       <% prices = params.dig("subscription", "prices") || resource.price_list.dig("products")&.map { |key, value| {product_id: key, stripe_price_id: value} } || [{product_id: Product::PUBLIC_IDS[:overweight]}] %>
+
+       <%= semantic_form_for [:admin, resource], url: override_prices_admin_subscription_path(resource), method: :post do |f| %>
+         <div>
+           <%= f.inputs do %>
+             <div id="price-inputs-container">
+               <% prices.each_with_index do |price, index| %>
+                 <% stripe_price = Rails.cache.fetch("stripe_price_#{price[:stripe_price_id]}", expires_in: 1.hour) { Stripe::Price.retrieve(price[:stripe_price_id]) } if price[:stripe_price_id].present? %>
+
+                 <div class="price-override-item">
+                   <%= f.input :product_id,
+                     as: :select,
+                     collection: Product.all,
+                     selected: price[:product_id],
+                     label: "Product #{index + 1}",
+                     value_field: :public_id,
+                     input_html: {
+                       name: "subscription[prices][#{index}][product_id]",
+                     } %>
+
+                   <%= f.input :amount,
+                     as: :number,
+                     label: "Price",
+                     input_html: {
+                       name: "subscription[prices][#{index}][amount]",
+                       value: price[:amount]&.to_i || stripe_price&.unit_amount&./(100) || 0,
+                       min: 0
+                     } %>
+
+                   <% if index > 0 %>
+                     <a
+                       href="#"
+                       class="remove-price-item link text-red-500 hover:text-red-700"
+                     >
+                       Remove Product
+                     </a>
+                   <% end %>
+                 </div>
+               <% end %>
+             </div>
+
+             <div class="add-price-section">
+               <%= link_to "Add Another Product", "#", id: "add-price-btn", class: "button secondary" %>
+             </div>
+           <% end %>
+         </div>
+
+         <script id="price_item_template" type="text/template">
+           <div class="price-override-item">
+             <%= f.input :product_id,
+               as: :select,
+               collection: Product.all,
+               label: "Product INDEX_LABEL",
+               class: "select required",
+               value_field: :public_id,
+               input_html: {
+                 id: "subscription_prices_INDEX_product_id",
+                 name: "subscription[prices][INDEX][product_id]",
+                 data: {
+                   searchable_field: "name",
+                   display_field: "display_name",
+                   search_url: "/admin/products.json?order=id_desc&q%5Bname_cont%5D={{query}}&commit=Filter"
+                 }
+               } %>
+             <%= f.input :amount,
+               label: "Custom Price",
+               as: :number,
+               input_html: {
+                 id: "subscription_prices_INDEX_amount",
+                 name: "subscription[prices][INDEX][amount]",
+                 value: 0,
+                 min: 0,
+               } %>
+
+             <a href="#" class="remove-price-item link text-red-500 hover:text-red-700">Remove Product</a>
+           </div>
+         </script>
+
+         <div>
+           <%= f.actions do %>
+             <%= f.action :submit, label: "Override Prices" %>
+             <%= link_to "Cancel", resource_path(resource), class: "button" %>
+           <% end %>
+         </div>
+       <% end %>
+
+       <script>
+         document.addEventListener('DOMContentLoaded', function() {
+           var addPriceBtn = document.querySelector('#add-price-btn');
+           var container = document.querySelector('#price-inputs-container');
+           var template = document.querySelector('#price_item_template').innerHTML;
+           var priceItemCounter = <%= prices.length %>;
+
+           addPriceBtn.addEventListener('click', function(e) {
+             e.preventDefault();
+             var newTemplate = template
+               .replace(/INDEX_LABEL/g, priceItemCounter + 1)
+               .replace(/INDEX/g, priceItemCounter);
+             container.insertAdjacentHTML('beforeend', newTemplate);
+
+             var newItem = container.querySelector('.price-override-item:last-child');
+             var selectElement = newItem.querySelector('select');
+
+             if (selectElement && selectElement.dataset.searchUrl) {
+               new TomSelect(selectElement, {
+                 allowEmptyOption: true,
+                 create: false,
+                 itemClass: "text-foreground px-1 py-0.5 rounded",
+                 valueField: selectElement.dataset.valueField,
+                 labelField: selectElement.dataset.displayField,
+                 searchField: [selectElement.dataset.displayField],
+                 plugins: ['dropdown_input'],
+
+                 render: {
+                   option: function(data, escape) {
+                     return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                   },
+                   item: function(data, escape) {
+                     return '<div>' + escape(data[selectElement.dataset.displayField] || '[blank]') + '</div>';
+                   },
+                 },
+
+                 load: function(query, callback) {
+                   if (!query.length) return callback();
+                   fetch(selectElement.dataset.searchUrl.replace('{{query}}', encodeURIComponent(query)))
+                     .then(function(response) {
+                       return response.json();
+                     })
+                     .then(function(json) {
+                       const augmentedJson = json.map(item => ({ ...item, search_term: Object.values(item).join(' ') }))
+                       callback(augmentedJson);
+                     }).catch(function() {
+                       callback();
+                     });
+                 },
+               });
+             }
+
+             priceItemCounter++;
+           });
+
+           container.addEventListener('click', function(e) {
+             if (e.target && e.target.classList.contains('remove-price-item')) {
+               e.preventDefault();
+               var priceItem = e.target.closest('.price-override-item');
+               if (priceItem) {
+                 var destroyInput = priceItem.querySelector('input[type="hidden"][name*="[_destroy]"]');
+                 if (destroyInput) {
+                   destroyInput.value = '1';
+                   priceItem.style.display = 'none';
+                 } else {
+                   priceItem.remove();
+                 }
+               }
+             }
+           });
+         });
+       </script>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 5", () => {
+    const input = dedent`
+      <%# Non-link tag that stands for skipped pages...
+        - available local variables
+          current_page:  a page object for the currently displayed page
+          total_pages:   total number of pages
+          per_page:      number of items to fetch per page
+          remote:        data-remote
+      -%>
+      <span class="flex items-center justify-center px-2.5 py-3 h-8 leading-tight text-gray-500 dark:text-gray-400">
+        <%= t('views.pagination.truncate').html_safe %>
+      </span>
+     `
+    const expected = dedent`
+      <%#
+        Non-link tag that stands for skipped pages...
+        - available local variables
+          current_page:  a page object for the currently displayed page
+          total_pages:   total number of pages
+          per_page:      number of items to fetch per page
+          remote:        data-remote
+      -%>
+
+      <span
+        class="
+          flex items-center justify-center px-2.5 py-3 h-8 leading-tight
+          text-gray-500 dark:text-gray-400
+        "
+      >
+        <%= t('views.pagination.truncate').html_safe %>
+      </span>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3219820557 Example 6", () => {
+    const input = dedent`
+      <%= render 'user_mailer/greeting' %>
+      <p>
+        Welcome back! Your subscription to the <b><%= @subscription.plan&.name || "Custom Plan" %></b> has been successfully resumed.
+      </p>
+      <p>
+      Subscription Details:<br>
+      Plan Name: <b><%= @subscription.plan&.name || "Custom Plan" %></b><br>
+      Resumption Date: <b><%= render_date(Time.current, format: '%B %e, %Y') %></b><br>
+      Pickups Left: <b><%= @subscription.credit_service.available_credits.values.first || 0 %><%= " (#{@subscription.loads * 20}lbs per pickup)" if @subscription.loads > 0 %></b><br>
+      Next Billing Date: <b><%= render_date(@subscription.current_period_end, format: '%B %e, %Y') %></b><br>
+      </p>
+
+      <p>Why wait now? Schedule your next pickup today!</p>
+
+      <%= render "user_mailer/schedule_now" %>
+      <%= render "user_subscription_mailer/more_info" %>
+      <%= render "user_mailer/questions" %>
+      <p>
+      Thank you for choosing Company again. We look forward to serving you!
+      </p>
+      <%= render "user_mailer/thanks" %>
+     `
+
+    const expected = dedent`
+      <%= render 'user_mailer/greeting' %>
+
+      <p>
+        Welcome back! Your subscription to the
+        <b><%= @subscription.plan&.name || "Custom Plan" %></b> has been successfully
+        resumed.
+      </p>
+
+      <p>
+        Subscription Details:
+        <br>
+        Plan Name: <b><%= @subscription.plan&.name || "Custom Plan" %></b>
+        <br>
+        Resumption Date: <b><%= render_date(Time.current, format: '%B %e, %Y') %></b>
+        <br>
+        Pickups Left:
+        <b><%= @subscription.credit_service.available_credits.values.first || 0 %><%= " (#{@subscription.loads * 20}lbs per pickup)" if @subscription.loads > 0 %></b>
+        <br>
+        Next Billing Date:
+        <b><%= render_date(@subscription.current_period_end, format: '%B %e, %Y') %></b>
+        <br>
+      </p>
+
+      <p>Why wait now? Schedule your next pickup today!</p>
+
+      <%= render "user_mailer/schedule_now" %>
+
+      <%= render "user_subscription_mailer/more_info" %>
+
+      <%= render "user_mailer/questions" %>
+
+      <p>
+        Thank you for choosing Company again. We look forward to serving you!
+      </p>
+
+      <%= render "user_mailer/thanks" %>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("https://github.com/marcoroth/herb/issues/436#issuecomment-3356738094", () => {
+    const input = dedent`
+      <% if cover.present? %>
+        <figure class="figure">
+          <%= image_tag attachment_url(cover), size: "460x249", class: "img-fluid figure-img" %>
+          <figcaption class="figure-caption text-center">
+            <span>
+              <strong>Cover Image</strong><br>
+              Dimensions
+              <strong><%= "#{cover.metadata['width']}x#{cover.metadata['height']}" %></strong>
+              &mdash;
+              <%= link_to "View original", rails_blob_path(cover), target: "_blank", rel: "noopener" %>
+            </span>
+          </figcaption>
+        </figure>
+      <% end %>
+     `
+
+    const result = formatter.format(input)
+    expect(result).toBe(input)
+  })
+
+  test("adjecent ERB text within elements", () => {
+    const input = dedent`
+      <div>
+        <div>
+          <div>
+            <p><%= formatted %> text that needs <%= needs %> <%= to_be_formatted %> without being reset to the <b><i>start of the line</i></b>. Text<%= also_with %><%= ERB_tags_next_to_each_other %>and after.</p>
+          </div>
+        </div>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <div>
+          <div>
+            <p>
+              <%= formatted %> text that needs <%= needs %> <%= to_be_formatted %>
+              without being reset to the <b><i>start of the line</i></b>.
+              Text<%= also_with %><%= ERB_tags_next_to_each_other %>and after.
+            </p>
+          </div>
+        </div>
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within HTML element", () => {
+    const input = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text</div>
+    `
+
+    const expected = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text</div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within HTML element", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const expected = dedent`
+      <div>some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div><%= icon("icon") %>some text some text some text some text some text some text some text</div>
+    `
+
+    const expected = dedent`
+      <div>
+        <%= icon("icon") %>some text some text some text some text some text some
+        text some text
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text some text<%= icon("icon") %></div>
+    `
+
+    const expected = dedent`
+      <div>
+        some text some text some text some text some text some
+        text<%= icon("icon") %>
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within HTML element causing line-break", () => {
+    const input = dedent`
+      <div>some text some text some text some text some text some text some<%= icon("icon") %>text some text</div>
+    `
+
+    const expected = dedent`
+      <div>
+        some text some text some text some text some text some text
+        some<%= icon("icon") %>text some text
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %><%= icon("icon") %>some text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        <%= icon("icon") %>some text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text<%= icon("icon") %><% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text<%= icon("icon") %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within ERB block", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text<%= icon("icon") %>some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text<%= icon("icon") %>some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output with adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %><%= icon("icon") %>some text some text some text some text some text some text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        <%= icon("icon") %>some text some text some text some text some text some
+        text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output after adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text some text some text some text some text some text<%= icon("icon") %><% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text some text some text some text some text some
+        text<%= icon("icon") %>
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("ERB output before and after adjecent text within ERB block causing line-break", () => {
+    const input = dedent`
+      <%= link_to "/" do %>some text some text some text some text some text some text some<%= icon("icon") %>text some text<% end %>
+    `
+
+    const expected = dedent`
+      <%= link_to "/" do %>
+        some text some text some text some text some text some text
+        some<%= icon("icon") %>text some text
+      <% end %>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
+  })
+
+  test("keeps hyphen-attached inline element together during line wrapping", () => {
+    const input = dedent`
+      <div>
+        This is a div where we still can assume that whitespace can be inserted-<b>infront or after of this bold you can not insert whitespace</b>. Next senctence.
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        This is a div where we still can assume that whitespace can be
+        inserted-<b>infront or after of this bold you can not insert whitespace</b>.
+        Next senctence.
+      </div>
+    `
+
+    const result = formatter.format(input)
+    expect(result).toBe(expected)
   })
 })
diff --git a/javascript/packages/formatter/test/html/comments.test.ts b/javascript/packages/formatter/test/html/comments.test.ts
index bfb55845b..02f70b1fe 100644
--- a/javascript/packages/formatter/test/html/comments.test.ts
+++ b/javascript/packages/formatter/test/html/comments.test.ts
@@ -36,11 +36,22 @@ describe("@herb-tools/formatter", () => {
     `)
   })
 
-  test("formats HTML comments and ERB comments", () => {
+  test("formats HTML comments and ERB comments on the same line", () => {
     const source = dedent`
       <!-- HTML Comment --><%# ERB Comment %>
     `
     const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <!-- HTML Comment --><%# ERB Comment %>
+    `)
+  })
+
+  test("formats HTML comments and ERB comments on mutli-line", () => {
+    const source = dedent`
+      <!-- HTML Comment -->
+      <%# ERB Comment %>
+    `
+    const result = formatter.format(source)
     expect(result).toEqual(dedent`
       <!-- HTML Comment -->
 
@@ -118,7 +129,7 @@ describe("@herb-tools/formatter", () => {
     `)
   })
 
-  test.todo("indents multi-line HTML comment with ERB if", () => {
+  test.fails("indents multi-line HTML comment with ERB if", () => {
     const source = dedent`
       <!--
       <% if Rails.env.development? %>
diff --git a/javascript/packages/formatter/test/html/headings.test.ts b/javascript/packages/formatter/test/html/headings.test.ts
new file mode 100644
index 000000000..7cd84551a
--- /dev/null
+++ b/javascript/packages/formatter/test/html/headings.test.ts
@@ -0,0 +1,43 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Formatter } from "../../src"
+
+import dedent from "dedent"
+
+let formatter: Formatter
+
+describe("@herb-tools/formatter", () => {
+  beforeAll(async () => {
+    await Herb.load()
+
+    formatter = new Formatter(Herb, {
+      indentWidth: 2,
+      maxLineLength: 80
+    })
+  })
+
+  test("formats headings", () => {
+    const source = dedent`
+      <h1>Heading Level 1</h1>
+      <h2>Heading Level 2</h2>
+      <h3>Heading Level 3</h3>
+      <h4>Heading Level 4</h4>
+      <h5>Heading Level 5</h5>
+      <h6>Heading Level 6</h6>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <h1>Heading Level 1</h1>
+
+      <h2>Heading Level 2</h2>
+
+      <h3>Heading Level 3</h3>
+
+      <h4>Heading Level 4</h4>
+
+      <h5>Heading Level 5</h5>
+
+      <h6>Heading Level 6</h6>
+    `)
+  })
+})
diff --git a/javascript/packages/formatter/test/html/lists.test.ts b/javascript/packages/formatter/test/html/lists.test.ts
new file mode 100644
index 000000000..3c59a19b3
--- /dev/null
+++ b/javascript/packages/formatter/test/html/lists.test.ts
@@ -0,0 +1,58 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Formatter } from "../../src"
+
+import dedent from "dedent"
+
+let formatter: Formatter
+
+describe("@herb-tools/formatter", () => {
+  beforeAll(async () => {
+    await Herb.load()
+
+    formatter = new Formatter(Herb, {
+      indentWidth: 2,
+      maxLineLength: 80
+    })
+  })
+
+  test("formats <ul>", () => {
+    const source = dedent`
+      <ul>
+      <li>List Item 1</li>
+      <li>List Item 2</li>
+      <li>List Item 3</li>
+      <li>List Item 4</li>
+      </ul>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <ul>
+        <li>List Item 1</li>
+        <li>List Item 2</li>
+        <li>List Item 3</li>
+        <li>List Item 4</li>
+      </ul>
+    `)
+  })
+
+  test("formats <ol>", () => {
+    const source = dedent`
+      <ol>
+      <li>List Item 1</li>
+      <li>List Item 2</li>
+      <li>List Item 3</li>
+      <li>List Item 4</li>
+      </ol>
+    `
+    const result = formatter.format(source)
+    expect(result).toEqual(dedent`
+      <ol>
+        <li>List Item 1</li>
+        <li>List Item 2</li>
+        <li>List Item 3</li>
+        <li>List Item 4</li>
+      </ol>
+    `)
+  })
+})
diff --git a/javascript/packages/herb-language-server/package.json b/javascript/packages/herb-language-server/package.json
index f21a0796f..e7f0e79fb 100644
--- a/javascript/packages/herb-language-server/package.json
+++ b/javascript/packages/herb-language-server/package.json
@@ -1,7 +1,7 @@
 {
   "name": "herb-language-server",
   "description": "Placeholder package to reserve the herb-language-server name on NPM; use @herb-tools/language-server instead.",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -45,6 +45,6 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/language-server": "0.7.4"
+    "@herb-tools/language-server": "0.7.5"
   }
 }
diff --git a/javascript/packages/highlighter/package.json b/javascript/packages/highlighter/package.json
index fa81157f0..4a6a07d1c 100644
--- a/javascript/packages/highlighter/package.json
+++ b/javascript/packages/highlighter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/highlighter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Syntax highlighter and diagnostic renderer for HTML+ERB templates.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -35,8 +35,8 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "glob": "^11.0.3"
   },
   "files": [
diff --git a/javascript/packages/language-server/package.json b/javascript/packages/language-server/package.json
index 224cbe31a..a5580abbb 100644
--- a/javascript/packages/language-server/package.json
+++ b/javascript/packages/language-server/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@herb-tools/language-server",
   "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -45,9 +45,9 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "dedent": "^1.6.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
diff --git a/javascript/packages/language-server/src/server.ts b/javascript/packages/language-server/src/server.ts
index 4ad761e90..09fa322e3 100644
--- a/javascript/packages/language-server/src/server.ts
+++ b/javascript/packages/language-server/src/server.ts
@@ -14,6 +14,8 @@ import {
 import { Service } from "./service"
 import { HerbSettings } from "./settings"
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 export class Server {
   private service!: Service
   private connection: Connection
@@ -62,7 +64,7 @@ export class Server {
 
       this.connection.client.register(DidChangeWatchedFilesNotification.type, {
         watchers: [
-          { globPattern: `**/**/*.html.erb` },
+          { globPattern: HERB_FILES_GLOB },
           { globPattern: `**/**/.herb-lsp/config.json` },
         ],
       })
diff --git a/javascript/packages/language-server/test/formatting_service.test.ts b/javascript/packages/language-server/test/formatting_service.test.ts
index 719f83f59..690c1fc43 100644
--- a/javascript/packages/language-server/test/formatting_service.test.ts
+++ b/javascript/packages/language-server/test/formatting_service.test.ts
@@ -403,14 +403,8 @@ describe('FormattingService', () => {
 
       expect(result[0].newText).toBe(
         '      <p>\n' +
-        '        some\n' +
-        '        <%= formatted %>\n' +
-        '        text, that needs\n' +
-        '        <% needs %>\n' +
-        '        <% to_be_formatted %>\n' +
-        '        without being reset to the\n' +
-        '        <b><i>start of the line</i></b>\n' +
-        '        .\n' +
+        '        some <%= formatted %> text, that needs <% needs %> <% to_be_formatted %>\n' +
+        '        without being reset to the <b><i>start of the line</i></b>.\n' +
         '      </p>\n'
       )
     })
diff --git a/javascript/packages/linter/README.md b/javascript/packages/linter/README.md
index f27c4c26d..77d6e4d74 100644
--- a/javascript/packages/linter/README.md
+++ b/javascript/packages/linter/README.md
@@ -67,7 +67,7 @@ After installing as a dev dependency, add a lint NPM script to your `package.jso
 ```json
 {
   "scripts": {
-    "herb:lint": "herb-lint '**/*.html.erb'"
+    "herb:lint": "herb-lint"
   }
 }
 ```
@@ -100,9 +100,11 @@ bun run herb:lint
 
 Basic usage:
 ```bash
+npx @herb-tools/linter
+npx @herb-tools/linter app/views/
 npx @herb-tools/linter template.html.erb
-npx @herb-tools/linter "**/*.html.erb"
-npx @herb-tools/linter app/
+npx @herb-tools/linter "**/*.rhtml"
+npx @herb-tools/linter "**/*.xml.erb"
 ```
 
 #### Options
@@ -184,7 +186,7 @@ npx @herb-tools/linter --format=simple --github
 
 **Example: `--github` (GitHub annotations + detailed format)**
 ```
-::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
+::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
 
 [error] Missing required `alt` attribute on `<img>` tag [html-img-require-alt]
 
@@ -199,7 +201,7 @@ template.html.erb:3:3
 
 **Example: `--format=simple --github` (GitHub annotations + simple format)**
 ```
-::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
+::error file=template.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required `alt` attribute on `<img>` tag [html-img-require-alt]%0A%0A%0Atemplate.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <span>Test content</span>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A
 
 template.html.erb:
   3:3 ✗ Missing required `alt` attribute on `<img>` tag [html-img-require-alt]
@@ -250,7 +252,7 @@ npx @herb-tools/linter template.html.erb --json
         "end": { "line": 1, "column": 22 }
       },
       "severity": "error",
-      "code": "erb-requires-trailing-newline",
+      "code": "erb-require-trailing-newline",
       "source": "Herb Linter"
     }
   ],
diff --git a/javascript/packages/linter/docs/rules/README.md b/javascript/packages/linter/docs/rules/README.md
index 689d05bc4..2d7bb6544 100644
--- a/javascript/packages/linter/docs/rules/README.md
+++ b/javascript/packages/linter/docs/rules/README.md
@@ -4,12 +4,16 @@ This page contains documentation for all Herb Linter rules.
 
 ## Available Rules
 
+- [`erb-comment-syntax`](./erb-comment-syntax.md) - Disallow Ruby comments immediately after ERB tags
+- [`erb-no-case-node-children`](./erb-no-case-node-children.md) - Don't use `children` for `case/when` and `case/in` nodes
 - [`erb-no-empty-tags`](./erb-no-empty-tags.md) - Disallow empty ERB tags
+- [`erb-no-extra-newline`](./erb-no-extra-newline.md) - Disallow extra newlines.
 - [`erb-no-output-control-flow`](./erb-no-output-control-flow.md) - Prevents outputting control flow blocks
 - [`erb-no-silent-tag-in-attribute-name`](./erb-no-silent-tag-in-attribute-name.md) - Disallow ERB silent tags in HTML attribute names
 - [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
 - [`erb-require-whitespace-inside-tags`](./erb-require-whitespace-inside-tags.md) - Requires whitespace around ERB tags
-- [`erb-requires-trailing-newline`](./erb-requires-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
+- [`erb-require-trailing-newline`](./erb-require-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
+- [`erb-right-trim`](./erb-right-trim.md) - Enforce consistent right-trimming syntax.
 - [`html-anchor-require-href`](./html-anchor-require-href.md) - Requires an href attribute on anchor tags
 - [`html-aria-attribute-must-be-valid`](./html-aria-attribute-must-be-valid.md) - Disallow invalid or unknown `aria-*` attributes.
 - [`html-aria-label-is-well-formatted`](./html-aria-label-is-well-formatted.md) - `aria-label` must be well-formatted
@@ -20,21 +24,26 @@ This page contains documentation for all Herb Linter rules.
 - [`html-attribute-equals-spacing`](./html-attribute-equals-spacing.md) - No whitespace around `=` in HTML attributes
 - [`html-attribute-values-require-quotes`](./html-attribute-values-require-quotes.md) - Requires quotes around attribute values
 - [`html-avoid-both-disabled-and-aria-disabled`](./html-avoid-both-disabled-and-aria-disabled.md) - Avoid using both `disabled` and `aria-disabled` attributes
+- [`html-body-only-elements`](./html-body-only-elements.md) - Require content elements inside `<body>`.
 - [`html-boolean-attributes-no-value`](./html-boolean-attributes-no-value.md) - Prevents values on boolean attributes
+- [`html-head-only-elements`](./html-head-only-elements.md) - Require head-scoped elements inside `<head>`.
 - [`html-iframe-has-title`](./html-iframe-has-title.md) - `iframe` elements must have a `title` attribute
+- [`html-input-require-autocomplete`](./html-input-require-autocomplete.md) - Require `autocomplete` attributes on `<input>` tags.
 - [`html-img-require-alt`](./html-img-require-alt.md) - Requires `alt` attributes on `<img>` tags
 - [`html-navigation-has-label`](./html-navigation-has-label.md) - Navigation landmarks must have accessible labels
 - [`html-no-aria-hidden-on-focusable`](./html-no-aria-hidden-on-focusable.md) - Focusable elements should not have `aria-hidden="true"`
 - [`html-no-block-inside-inline`](./html-no-block-inside-inline.md) - Prevents block-level elements inside inline elements
 - [`html-no-duplicate-attributes`](./html-no-duplicate-attributes.md) - Prevents duplicate attributes on HTML elements
 - [`html-no-duplicate-ids`](./html-no-duplicate-ids.md) - Prevents duplicate IDs within a document
+- [`html-no-duplicate-meta-names`](./html-no-duplicate-meta-names.md) - Duplicate `<meta>` name attributes are not allowed.
 - [`html-no-empty-attributes`](./html-no-empty-attributes.md) - Attributes must not have empty values
 - [`html-no-nested-links`](./html-no-nested-links.md) - Prevents nested anchor tags
 - [`html-no-positive-tab-index`](./html-no-positive-tab-index.md) - Avoid positive `tabindex` values
 - [`html-no-self-closing`](./html-no-self-closing.md) - Disallow self closing tags
+- [`html-no-space-in-tag`](./html-no-space-in-tag.md) - Disallow spaces in HTML tags
 - [`html-no-title-attribute`](./html-no-title-attribute.md) - Avoid using the `title` attribute
-- [`html-tag-name-lowercase`](./html-tag-name-lowercase.md) - Enforces lowercase tag names in HTML
 - [`html-no-underscores-in-attribute-names`](./html-no-underscores-in-attribute-names.md) - Disallow underscores in HTML attribute names
+- [`html-tag-name-lowercase`](./html-tag-name-lowercase.md) - Enforces lowercase tag names in HTML
 - [`parser-no-errors`](./parser-no-errors.md) - Disallow parser errors in HTML+ERB documents
 - [`svg-tag-name-capitalization`](./svg-tag-name-capitalization.md) - Enforces proper camelCase capitalization for SVG elements
 
diff --git a/javascript/packages/linter/docs/rules/erb-comment-syntax.md b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
new file mode 100644
index 000000000..b3c9ae781
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-comment-syntax.md
@@ -0,0 +1,44 @@
+# Linter Rule: Disallow Ruby comments immediately after ERB tags
+
+**Rule:** `erb-comment-syntax`
+
+## Description
+
+Disallow ERB tags that start with `<% #` (with a space before the `#`). Use the ERB comment syntax `<%#` instead.
+
+## Rationale
+
+Ruby comments starting immediately after an ERB tag opening (e.g., `<% # comment %>`) can cause parsing issues in some contexts. The proper ERB comment syntax `<%# comment %>` is more reliable and explicitly designed for comments in templates.
+
+For multi-line comments or actual Ruby code with comments, ensure the content starts on a new line after the opening tag.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<%# This is a proper ERB comment %>
+
+<%
+  # This is a proper ERB comment
+%>
+
+<%
+  # Multi-line Ruby comment
+  # spanning multiple lines
+%>
+```
+
+### 🚫 Bad
+
+```erb
+<% # This should be an ERB comment %>
+
+<%= # This should also be an ERB comment %>
+
+<%== # This should also be an ERB comment %>
+```
+
+## References
+
+- [Inspiration: ERB Lint `CommentSyntax` rule](https://github.com/shopify/erb_lint?tab=readme-ov-file#commentsyntax)
diff --git a/javascript/packages/linter/docs/rules/erb-no-case-node-children.md b/javascript/packages/linter/docs/rules/erb-no-case-node-children.md
new file mode 100644
index 000000000..714bb86f1
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-no-case-node-children.md
@@ -0,0 +1,50 @@
+# Linter Rule: Don't use `children` for `case/when` and `case/in` nodes
+
+**Rule:** `erb-no-case-node-children`
+
+## Description
+
+Disallow placing content or expressions directly between the opening `<% case %>` and the first `<% when %>` or `<% in %>` clause in an HTML+ERB template.
+
+In Ruby and ERB, `case` expressions are intended to branch execution. Any content placed between the `case` and its `when`/`in` clauses is not executed as part of the branching logic, and may lead to confusion, orphaned output, or silent bugs.
+
+## Rationale
+
+Including content directly inside a `case block` is likely unintended and often leads to unclear or broken rendering logic.
+
+Most developers expect that nothing happens until the first `when`/`in` matches. Content in that location is often a copy/paste or indentation mistake and should be flagged to maintain clarity and correctness in templates.
+
+This mirrors how `case` works in Ruby itself and helps avoid surprising output.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<% case variable %>
+<% when "a" %>
+  A
+<% when "b" %>
+  B
+<% else %>
+  C
+<% end %>
+```
+
+### 🚫 Bad
+
+```erb
+<% case variable %>
+  This content is outside of any when/in/else block!
+<% when "a" %>
+  A
+<% when "b" %>
+  B
+<% else %>
+  C
+<% end %>
+```
+
+## References
+
+\-
diff --git a/javascript/packages/linter/docs/rules/erb-no-extra-newline.md b/javascript/packages/linter/docs/rules/erb-no-extra-newline.md
new file mode 100644
index 000000000..0a6cfa1a1
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-no-extra-newline.md
@@ -0,0 +1,74 @@
+# Linter Rule: Disallow extra newlines
+
+**Rule:** `erb-no-extra-newline`
+
+## Description
+
+Disallow more than two consecutive blank lines in ERB templates. This rule enforces a maximum of two blank lines between content to maintain consistent vertical spacing throughout your templates.
+
+## Rationale
+
+Excessive blank lines can make templates harder to read and maintain. While some vertical spacing improves readability by visually separating logical sections, too many blank lines create unnecessary whitespace that:
+
+* Makes it harder to see related code on the same screen
+* Creates inconsistent visual rhythm in the codebase
+* Can accidentally accumulate through merge conflicts or refactoring
+* Provides no additional clarity beyond what 1-2 blank lines already achieve
+
+Limiting to two consecutive blank lines strikes a balance between allowing clear section separation while maintaining code density and readability.
+
+## Examples
+
+### ✅ Good
+
+```html
+line 1
+
+line 3
+
+<div>
+  <h1>Title</h1>
+</div>
+
+<div>
+  <h1>Section 1</h1>
+
+  <p>Content here</p>
+</div>
+
+<div>
+  <h1>Section 1</h1>
+
+
+  <h1>Section 2</h1>
+</div>
+```
+
+### 🚫 Bad
+
+```erb
+line 1
+
+
+
+line 3
+
+<div>
+  <h1>Title</h1>
+
+
+
+  <p>Content</p>
+</div>
+
+<%= user.name %>
+
+
+
+
+<%= user.email %>
+```
+
+## References
+
+- [Inspiration: ERB Lint `ExtraNewline` rule](https://github.com/Shopify/erb_lint/blob/main/README.md)
diff --git a/javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md b/javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
similarity index 96%
rename from javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md
rename to javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
index d4bc11c91..d3bd7e9c6 100644
--- a/javascript/packages/linter/docs/rules/erb-requires-trailing-newline.md
+++ b/javascript/packages/linter/docs/rules/erb-require-trailing-newline.md
@@ -1,6 +1,6 @@
 # Linter Rule: Enforce trailing newline
 
-**Rule:** `erb-requires-trailing-newline`
+**Rule:** `erb-require-trailing-newline`
 
 ## Description
 
diff --git a/javascript/packages/linter/docs/rules/erb-right-trim.md b/javascript/packages/linter/docs/rules/erb-right-trim.md
new file mode 100644
index 000000000..54dd37c42
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/erb-right-trim.md
@@ -0,0 +1,52 @@
+# Linter Rule: Enforce consistent right-trimming syntax
+
+**Rule:** `erb-right-trim`
+
+## Description
+
+This rule enforces the use of `-%>` for right-trimming ERB output tags (like `<%= %>`) instead of `=%>`.
+
+## Rationale
+
+While `=%>` can be used for right-trimming whitespace in some ERB engines (like Erubi), it is an obscure and not well-defined syntax that lacks consistent support across most ERB implementations.
+
+The `-%>` syntax is the standard, well-documented approach for right-trimming that is universally supported and consistent with left-trimming syntax (`<%-`). Using `-%>` ensures compatibility across different ERB engines, improves code clarity, and aligns with established Rails and ERB conventions.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<%= title -%>
+
+<% if condition? %>
+  <h1>Content</h1>
+<% end %>
+
+<% items.each do |item| %>
+  <li><%= item -%></li>
+<% end %>
+```
+
+### 🚫 Bad
+
+```erb
+<%= title =%>
+
+
+<% title =%>
+
+
+<% if true =%>
+  <h1>Content</h1>
+<% end %>
+
+
+<% items.each do |item| =%>
+  <li><%= item %></li>
+<% end %>
+```
+
+## References
+
+- [Inspiration: ERB Lint `RightTrim` rule](https://github.com/Shopify/erb_lint/blob/main/README.md#righttrim)
diff --git a/javascript/packages/linter/docs/rules/html-body-only-elements.md b/javascript/packages/linter/docs/rules/html-body-only-elements.md
new file mode 100644
index 000000000..a37754484
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-body-only-elements.md
@@ -0,0 +1,99 @@
+# Linter Rule: Require content elements inside `<body>`
+
+**Rule:** `html-body-only-elements`
+
+## Description
+
+Enforce that specific HTML elements are only placed within the `<body>` tag.
+
+## Rationale
+
+According to the HTML specification, certain elements are meant to contain content and should only appear within the `<body>` section of an HTML document. Placing content-bearing or interactive elements in the `<head>` section or outside the HTML structure can lead to:
+
+- Unpredictable browser rendering behavior
+- Accessibility issues for screen readers and assistive technologies
+- SEO problems as search engines may not properly index misplaced content
+- Validation errors and non-compliant HTML
+
+This rule enforces proper document structure by ensuring semantic and content elements are correctly placed within the `<body>` element.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<html>
+  <head>
+    <title>Page Title</title>
+    <meta charset="utf-8">
+  </head>
+
+  <body>
+    <header>
+      <h1>Welcome</h1>
+      <nav>
+        <ul>
+          <li>Home</li>
+        </ul>
+      </nav>
+    </header>
+
+    <main>
+      <article>
+        <section>
+          <p>This is valid content.</p>
+          <table>
+            <tr><td>Data</td></tr>
+          </table>
+        </section>
+      </article>
+      <aside>
+        <form>
+          <input type="text" autocomplete="on">
+        </form>
+      </aside>
+    </main>
+
+    <footer>
+      <h2>Footer</h2>
+    </footer>
+  </body>
+</html>
+```
+
+### 🚫 Bad
+
+```erb
+<html>
+  <head>
+    <title>Page Title</title>
+    <h1>Welcome</h1>
+
+    <p>This should not be here.</p>
+
+  </head>
+
+  <body>
+    <main>Valid content</main>
+  </body>
+</html>
+```
+
+```erb
+<html>
+  <head>
+    <nav>Navigation</nav>
+
+    <form>Form</form>
+
+  </head>
+
+  <body>
+  </body>
+</html>
+```
+
+## References
+
+- [HTML Living Standard - The `body` element](https://html.spec.whatwg.org/multipage/sections.html#the-body-element)
+- [MDN: HTML `document` structure](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/Document_and_website_structure)
diff --git a/javascript/packages/linter/docs/rules/html-head-only-elements.md b/javascript/packages/linter/docs/rules/html-head-only-elements.md
new file mode 100644
index 000000000..8a12b47f8
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-head-only-elements.md
@@ -0,0 +1,81 @@
+# Linter Rule: Require head-scoped elements inside `<head>`
+
+**Rule:** `html-head-only-elements`
+
+## Description
+
+Enforce that certain elements only appear inside the `<head>` section of the document.
+
+Elements like `<title>`, `<meta>`, `<base>`, `<link>`, and `<style>` are permitted only inside the `<head>` element. They must not appear inside `<body>` or outside of `<html>`. Placing them elsewhere produces invalid HTML and relies on browser error correction.
+
+> [!NOTE] Exception
+> `<title>` elements are allowed inside `<svg>` elements for accessibility purposes.
+
+## Rationale
+
+The HTML specification requires certain elements to appear only in the `<head>` section because they affect document metadata, resource loading, or global behavior:
+
+Placing these elements outside `<head>` leads to invalid HTML and undefined behavior across browsers.
+
+
+## Examples
+
+### ✅ Good
+
+```erb
+<head>
+  <title>My Page</title>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="stylesheet" href="/styles.css">
+</head>
+
+<body>
+  <h1>Welcome</h1>
+</body>
+```
+
+```erb
+<head>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= favicon_link_tag 'favicon.ico' %>
+  <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+  <%= javascript_include_tag "application", "data-turbo-track": "reload", defer: true %>
+
+  <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+</head>
+```
+
+```erb
+<body>
+  <svg>
+    <title>Chart Title</title>
+    <rect width="100" height="100" />
+  </svg>
+</body>
+```
+
+### 🚫 Bad
+
+```erb
+<body>
+  <title>My Page</title>
+
+  <meta charset="UTF-8">
+
+  <link rel="stylesheet" href="/styles.css">
+
+  <h1>Welcome</h1>
+</body>
+```
+
+```erb
+<body>
+  <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+</body>
+```
+
+## References
+
+* [HTML Living Standard - The `head` element](https://html.spec.whatwg.org/multipage/semantics.html#the-head-element)
diff --git a/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md b/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md
new file mode 100644
index 000000000..bb85e1f3c
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-input-require-autocomplete.md
@@ -0,0 +1,64 @@
+# Linter Rule: Require `autocomplete` attributes on `<input>` tags
+
+**Rule:** `html-input-require-autocomplete`
+
+## Description
+
+Require an `autocomplete` attribute on `<input>` elements with types that support autocomplete functionality. This rule ensures that developers explicitly declare autocomplete behavior for form inputs.
+
+
+## Rationale
+
+The HTML `autocomplete` attribute helps users complete forms by using data stored in the browser. This is particularly useful for people with motor disabilities or cognitive impairment who may have difficulties filling out forms online. Without an explicit `autocomplete` attribute, behavior varies across browsers and can lead to inconsistent user experiences.
+
+If you prefer not to specify a specific autocomplete value, use `autocomplete="on"` to enable browser defaults or `autocomplete="off"` to explicitly disable it.
+
+## Affected Input Types
+
+This rule applies to the following input types:
+
+- `color`
+- `date`
+- `datetime-local`
+- `email`
+- `month`
+- `number`
+- `password`
+- `range`
+- `search`
+- `tel`
+- `text`
+- `time`
+- `url`
+- `week`
+
+
+## Examples
+
+### ✅ Good
+
+```erb
+<input type="email" autocomplete="email">
+
+<input type="url" autocomplete="off">
+
+<input type="password" autocomplete="on">
+```
+
+
+### 🚫 Bad
+
+```erb
+<input type="email">
+
+<input type="url">
+
+<input type="password">
+```
+
+## References
+
+* [Inspiration: ERB Lint `RequireInputAutocomplete` rule](https://github.com/shopify/erb_lint?tab=readme-ov-file#requireinputautocomplete)
+* [HTML attribute: autocomplete](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete)
+* [WCAG: Using HTML autocomplete attributes](https://www.w3.org/WAI/WCAG21/Techniques/html/H98)
+* [HTML Specification: Autofill](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill)
diff --git a/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md b/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md
new file mode 100644
index 000000000..bb38e1c62
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-no-duplicate-meta-names.md
@@ -0,0 +1,64 @@
+# Linter Rule: Duplicate `<meta>` name attributes are not allowed
+
+**Rule:** `html-no-duplicate-meta-names`
+
+## Description
+
+Warn when multiple `<meta>` tags share the same `name` or `http-equiv` attribute within the same `<head>` block, unless they are wrapped in conditional comments.
+
+## Rationale
+
+In HTML, duplicate `<meta>` tags with the same `name` or `http-equiv` can cause unexpected behavior. For example, search engines or social sharing tools may use the wrong value. These duplicates are often the result of copy-paste or partial rendering logic and should be avoided.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<head>
+  <meta name="description" content="Welcome to our site">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+```
+
+```erb
+<head>
+  <% if mobile? %>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <% else %>
+    <meta name="viewport" content="width=1024">
+  <% end %>
+</head>
+```
+
+### 🚫 Bad
+
+```erb
+<head>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="viewport" content="width=1024">
+</head>
+```
+
+```erb
+<head>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta http-equiv="X-UA-Compatible" content="chrome=1">
+</head>
+```
+
+```erb
+<head>
+  <meta name="viewport" content="width=1024">
+
+  <% if mobile? %>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <% else %>
+    <meta http-equiv="refresh" content="30">  
+  <% end %>
+</head>
+```
+
+## References
+
+\-
diff --git a/javascript/packages/linter/docs/rules/html-no-space-in-tag.md b/javascript/packages/linter/docs/rules/html-no-space-in-tag.md
new file mode 100644
index 000000000..080f2e5fd
--- /dev/null
+++ b/javascript/packages/linter/docs/rules/html-no-space-in-tag.md
@@ -0,0 +1,66 @@
+# Linter Rule: Enforce consistent spacing within HTML tags
+
+**Rule:** `html-no-space-in-tag`
+
+## Description
+
+Enforce consistent spacing within HTML opening and closing tags. This rule ensures:
+- Exactly one space between tag name and first attribute
+- Exactly one space between attributes
+- No extra spaces before the closing `>` in non-self-closing tags
+- Exactly one space before `/>` in self-closing tags
+- No whitespace in closing tags (e.g., `</div>`)
+- Consistent indentation in multiline tags
+
+## Rationale
+
+Consistent spacing within HTML tags improves code readability and maintainability. Extra or missing spaces can make templates harder to scan and can indicate formatting inconsistencies across a codebase. This rule enforces a canonical style that is both readable and machine-parseable.
+
+Self-closing tags (`<img />`, `<br />`) should have exactly one space before the `/>` to maintain visual consistency with HTML5 and JSX conventions.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<div class="foo"></div>
+
+<img src="/logo.png" alt="Logo">
+
+<input class="foo" name="bar">
+
+<div class="foo" data-x="bar"></div>
+
+<div
+  class="foo"
+  data-x="bar"
+>
+  foo
+</div>
+```
+
+### 🚫 Bad
+
+```erb
+<div  class="foo"></div>
+
+<div class="foo" ></div>
+
+<img alt="Logo" src="/logo.png"/>
+
+<div class="foo"      data-x="bar"></div>
+
+<div
+   class="foo"
+    data-x="bar"
+>
+  foo
+</div>
+
+<div >
+</  div>
+```
+
+## References
+
+- [Inspiration: ERB Lint `SpaceInHtmlTag` rule](https://github.com/shopify/erb_lint)
diff --git a/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs b/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
index 2612d781b..c3a5b3df0 100644
--- a/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
+++ b/javascript/packages/linter/generators/linter-rule/generators/app/templates/rule.ts.ejs
@@ -12,7 +12,7 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLElementNode, ERBContentNode } from "@herb-tools/core"
+import type { ParseResult, HTMLElementNode, ERBContentNode } from "@herb-tools/core"
 
 class <%= visitorClassName %> extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -31,10 +31,10 @@ class <%= visitorClassName %> extends BaseRuleVisitor {
 export class <%= ruleClassName %> extends ParserRule {
   name = "<%= ruleName %>"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new <%= visitorClassName %>(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }
diff --git a/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs b/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
index 79bb036f0..ffe5f017f 100644
--- a/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
+++ b/javascript/packages/linter/generators/linter-rule/generators/app/templates/test.ts.ejs
@@ -1,44 +1,25 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { <%= ruleClassName %> } from "../../src/rules/<%= ruleName %>.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("<%= ruleClassName %>", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, expectWarning, assertOffenses } = createLinterTest(<%= ruleClassName %>)
 
+describe("<%= ruleClassName %>", () => {
   test("valid case TODO", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>
         <%%= title %>
       </h1>
-    `
-    const linter = new Linter(Herb, [<%= ruleClassName %>])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("invalid case TODO", () => {
-    const html = dedent`
+    expectError("TODO: update rule message")
+
+    assertOffenses(dedent`
       <h1>
         <%%= title %>
-    `
-    const linter = new Linter(Herb, [<%= ruleClassName %>])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("<%= ruleName %>")
-    expect(lintResult.offenses[0].message).toBe("TODO: update rule message")
-
-    // TODO: add assertions for invalid case
+    `)
   })
 })
diff --git a/javascript/packages/linter/package.json b/javascript/packages/linter/package.json
index aa3766a66..e0f6c34e3 100644
--- a/javascript/packages/linter/package.json
+++ b/javascript/packages/linter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/linter",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "HTML+ERB linter for validating HTML structure and enforcing best practices",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -39,10 +39,10 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/highlighter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
-    "@herb-tools/printer": "0.7.4",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/highlighter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
+    "@herb-tools/printer": "0.7.5",
     "glob": "^11.0.3"
   },
   "files": [
diff --git a/javascript/packages/linter/src/cli.ts b/javascript/packages/linter/src/cli.ts
index a9b32f1de..d22ab76ba 100644
--- a/javascript/packages/linter/src/cli.ts
+++ b/javascript/packages/linter/src/cli.ts
@@ -1,12 +1,16 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { existsSync, statSync } from "fs"
 import { dirname, resolve, relative } from "path"
 
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js"
+import { ArgumentParser } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
 import { OutputManager } from "./cli/output-manager.js"
 
+import type { FormatOption } from "./cli/argument-parser.js"
+
 export * from "./cli/index.js"
 
 export class CLI {
@@ -105,7 +109,7 @@ export class CLI {
 
   protected adjustPattern(pattern: string | undefined): string {
     if (!pattern) {
-      return '**/*.html.erb'
+      return HERB_FILES_GLOB
     }
 
     const resolvedPattern = resolve(pattern)
@@ -114,7 +118,7 @@ export class CLI {
       const stats = statSync(resolvedPattern)
 
       if (stats.isDirectory()) {
-        return '**/*.html.erb'
+        return HERB_FILES_GLOB
       } else if (stats.isFile()) {
         return relative(this.projectPath, resolvedPattern)
       }
@@ -124,7 +128,7 @@ export class CLI {
   }
 
   protected async beforeProcess(): Promise<void> {
-    await Herb.load()
+    // Hook for subclasses to add custom output before processing
   }
 
   protected async afterProcess(_results: any, _outputOptions: any): Promise<void> {
@@ -132,10 +136,12 @@ export class CLI {
   }
 
   async run() {
+    await Herb.load()
+
     const startTime = Date.now()
     const startDate = new Date()
 
-    let { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions } = this.argumentParser.parse(process.argv)
+    let { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix } = this.argumentParser.parse(process.argv)
 
     this.determineProjectPath(pattern)
 
@@ -163,7 +169,8 @@ export class CLI {
 
       const context = {
         projectPath: this.projectPath,
-        pattern: pattern
+        pattern,
+        fix
       }
 
       const results = await this.fileProcessor.processFiles(files, formatOption, context)
diff --git a/javascript/packages/linter/src/cli/argument-parser.ts b/javascript/packages/linter/src/cli/argument-parser.ts
index c25337b08..a4af407d6 100644
--- a/javascript/packages/linter/src/cli/argument-parser.ts
+++ b/javascript/packages/linter/src/cli/argument-parser.ts
@@ -5,11 +5,12 @@ import { statSync } from "fs"
 import { join } from "path"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
 
 import { THEME_NAMES, DEFAULT_THEME } from "@herb-tools/highlighter"
 import type { ThemeInput } from "@herb-tools/highlighter"
 
-import { name, version } from "../../package.json"
+import { name, version, dependencies } from "../../package.json"
 
 export type FormatOption = "simple" | "detailed" | "json"
 
@@ -21,6 +22,7 @@ export interface ParsedArguments {
   wrapLines: boolean
   truncateLines: boolean
   useGitHubActions: boolean
+  fix: boolean
 }
 
 export class ArgumentParser {
@@ -29,12 +31,13 @@ export class ArgumentParser {
 
     Arguments:
       file             Single file to lint
-      glob-pattern     Files to lint (defaults to **/*.html.erb)
-      directory        Directory to lint (automatically appends **/*.html.erb)
+      glob-pattern     Files to lint (defaults to \`${HERB_FILES_GLOB}\`)
+      directory        Directory to lint (automatically appends \`${HERB_FILES_GLOB}\`)
 
     Options:
       -h, --help       show help
       -v, --version    show version
+      --fix            automatically fix auto-correctable offenses
       --format         output format (simple|detailed|json) [default: detailed]
       --simple         use simple output format (shortcut for --format simple)
       --json           use JSON output format (shortcut for --format json)
@@ -53,6 +56,7 @@ export class ArgumentParser {
       options: {
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },
+        fix: { type: "boolean" },
         format: { type: "string" },
         simple: { type: "boolean" },
         json: { type: "boolean" },
@@ -74,7 +78,9 @@ export class ArgumentParser {
 
     if (values.version) {
       console.log("Versions:")
-      console.log(`  ${name}@${version}, ${Herb.version}`.split(", ").join("\n  "))
+      console.log(`  ${name}@${version}`)
+      console.log(`  @herb-tools/printer@${dependencies["@herb-tools/printer"]}`)
+      console.log(`  ${Herb.version}`.split(", ").join("\n  "))
       process.exit(0)
     }
 
@@ -121,17 +127,18 @@ export class ArgumentParser {
 
     const theme = values.theme || DEFAULT_THEME
     const pattern = this.getFilePattern(positionals)
+    const fix = values.fix || false
 
-    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions }
+    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix }
   }
 
   private getFilePattern(positionals: string[]): string {
-    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html.erb"
+    let pattern = positionals.length > 0 ? positionals[0] : HERB_FILES_GLOB
 
     try {
       const stat = statSync(pattern)
       if (stat.isDirectory()) {
-        pattern = join(pattern, "**/*.html.erb")
+        pattern = join(pattern, HERB_FILES_GLOB)
       }
     } catch {
       // Not a file/directory, treat as glob pattern
diff --git a/javascript/packages/linter/src/cli/file-processor.ts b/javascript/packages/linter/src/cli/file-processor.ts
index 9dd3b41ce..2e98cb798 100644
--- a/javascript/packages/linter/src/cli/file-processor.ts
+++ b/javascript/packages/linter/src/cli/file-processor.ts
@@ -1,8 +1,10 @@
-import { readFileSync } from "fs"
-import { resolve } from "path"
 import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "../linter.js"
+
+import { readFileSync, writeFileSync } from "fs"
+import { resolve } from "path"
 import { colorize } from "@herb-tools/highlighter"
+
 import type { Diagnostic } from "@herb-tools/core"
 import type { FormatOption } from "./argument-parser.js"
 
@@ -10,17 +12,21 @@ export interface ProcessedFile {
   filename: string
   offense: Diagnostic
   content: string
+  autocorrectable?: boolean
 }
 
 export interface ProcessingContext {
   projectPath?: string
   pattern?: string
+  fix?: boolean
 }
 
 export interface ProcessingResult {
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
+  filesFixed: number
   ruleCount: number
   allOffenses: ProcessedFile[]
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
@@ -30,17 +36,33 @@ export interface ProcessingResult {
 export class FileProcessor {
   private linter: Linter | null = null
 
+  private isRuleAutocorrectable(ruleName: string): boolean {
+    if (!this.linter) return false
+
+    const RuleClass = (this.linter as any).rules.find((rule: any) => {
+      const instance = new rule()
+
+      return instance.name === ruleName
+    })
+
+    if (!RuleClass) return false
+
+    return RuleClass.autocorrectable === true
+  }
+
   async processFiles(files: string[], formatOption: FormatOption = 'detailed', context?: ProcessingContext): Promise<ProcessingResult> {
     let totalErrors = 0
     let totalWarnings = 0
+    let totalIgnored = 0
     let filesWithOffenses = 0
+    let filesFixed = 0
     let ruleCount = 0
     const allOffenses: ProcessedFile[] = []
     const ruleOffenses = new Map<string, { count: number, files: Set<string> }>()
 
     for (const filename of files) {
       const filePath = context?.projectPath ? resolve(context.projectPath, filename) : resolve(filename)
-      const content = readFileSync(filePath, "utf-8")
+      let content = readFileSync(filePath, "utf-8")
       const parseResult = Herb.parse(content)
 
       if (parseResult.errors.length > 0) {
@@ -58,6 +80,7 @@ export class FileProcessor {
 
         totalErrors++
         filesWithOffenses++
+
         continue
       }
 
@@ -71,13 +94,52 @@ export class FileProcessor {
         ruleCount = this.linter.getRuleCount()
       }
 
-      if (lintResult.offenses.length === 0) {
+      if (context?.fix && lintResult.offenses.length > 0) {
+        const autofixResult = this.linter.autofix(content, { fileName: filename })
+
+        if (autofixResult.fixed.length > 0) {
+          writeFileSync(filePath, autofixResult.source, "utf-8")
+
+          filesFixed++
+
+          if (formatOption !== 'json') {
+            console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize(`Fixed ${autofixResult.fixed.length} offense(s)`, "green")}`)
+          }
+        }
+
+        content = autofixResult.source
+
+        for (const offense of autofixResult.unfixed) {
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
+
+          const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
+          ruleData.count++
+          ruleData.files.add(filename)
+          ruleOffenses.set(offense.rule, ruleData)
+        }
+
+        if (autofixResult.unfixed.length > 0) {
+          totalErrors += autofixResult.unfixed.filter(offense => offense.severity === "error").length
+          totalWarnings += autofixResult.unfixed.filter(offense => offense.severity === "warning").length
+          filesWithOffenses++
+        }
+      } else if (lintResult.offenses.length === 0) {
         if (files.length === 1 && formatOption !== 'json') {
           console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
         }
       } else {
         for (const offense of lintResult.offenses) {
-          allOffenses.push({ filename, offense: offense, content })
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
 
           const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
           ruleData.count++
@@ -89,8 +151,9 @@ export class FileProcessor {
         totalWarnings += lintResult.warnings
         filesWithOffenses++
       }
+      totalIgnored += lintResult.ignored
     }
 
-    return { totalErrors, totalWarnings, filesWithOffenses, ruleCount, allOffenses, ruleOffenses, context }
+    return { totalErrors, totalWarnings, totalIgnored, filesWithOffenses, filesFixed, ruleCount, allOffenses, ruleOffenses, context }
   }
 }
diff --git a/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts b/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
index 4a770d323..28b0870b2 100644
--- a/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/detailed-formatter.ts
@@ -29,7 +29,15 @@ export class DetailedFormatter extends BaseFormatter {
 
     if (isSingleFile) {
       const { filename, content } = allOffenses[0]
-      const diagnostics = allOffenses.map(item => item.offense)
+      const diagnostics = allOffenses.map(item => {
+        if (item.autocorrectable && item.offense.code) {
+          return {
+            ...item.offense,
+            message: `${item.offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+        return item.offense
+      })
 
       const highlighted = this.highlighter.highlight(filename, content, {
         diagnostics: diagnostics,
@@ -44,8 +52,18 @@ export class DetailedFormatter extends BaseFormatter {
       const totalMessageCount = allOffenses.length
 
       for (let i = 0; i < allOffenses.length; i++) {
-        const { filename, offense, content } = allOffenses[i]
-        const formatted = this.highlighter.highlightDiagnostic(filename, offense, content, {
+        const { filename, offense, content, autocorrectable } = allOffenses[i]
+
+        let modifiedOffense = offense
+
+        if (autocorrectable && offense.code) {
+          modifiedOffense = {
+            ...offense,
+            message: `${offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+
+        const formatted = this.highlighter.highlightDiagnostic(filename, modifiedOffense, content, {
           contextLines: 2,
           wrapLines: this.wrapLines,
           truncateLines: this.truncateLines
diff --git a/javascript/packages/linter/src/cli/formatters/json-formatter.ts b/javascript/packages/linter/src/cli/formatters/json-formatter.ts
index abe23e0d3..4b2708d1d 100644
--- a/javascript/packages/linter/src/cli/formatters/json-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/json-formatter.ts
@@ -12,6 +12,7 @@ interface JSONSummary {
   filesWithOffenses: number
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   totalOffenses: number
   ruleCount: number
 }
@@ -34,6 +35,7 @@ interface JSONFormatOptions {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
@@ -79,6 +81,7 @@ export class JSONFormatter extends BaseFormatter {
       filesWithOffenses: options.filesWithOffenses,
       totalErrors: options.totalErrors,
       totalWarnings: options.totalWarnings,
+      totalIgnored: options.totalIgnored,
       totalOffenses: options.totalErrors + options.totalWarnings,
       ruleCount: options.ruleCount
     }
diff --git a/javascript/packages/linter/src/cli/formatters/simple-formatter.ts b/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
index 30dd38341..a88e3a0ed 100644
--- a/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
+++ b/javascript/packages/linter/src/cli/formatters/simple-formatter.ts
@@ -9,17 +9,17 @@ export class SimpleFormatter extends BaseFormatter {
   async format(allOffenses: ProcessedFile[]): Promise<void> {
     if (allOffenses.length === 0) return
 
-    const groupedOffenses = new Map<string, Diagnostic[]>()
+    const groupedOffenses = new Map<string, ProcessedFile[]>()
 
-    for (const { filename, offense } of allOffenses) {
-      const offenses = groupedOffenses.get(filename) || []
-      offenses.push(offense)
-      groupedOffenses.set(filename, offenses)
+    for (const processedFile of allOffenses) {
+      const offenses = groupedOffenses.get(processedFile.filename) || []
+      offenses.push(processedFile)
+      groupedOffenses.set(processedFile.filename, offenses)
     }
 
-    for (const [filename, offenses] of groupedOffenses) {
+    for (const [filename, processedFiles] of groupedOffenses) {
       console.log("")
-      this.formatFile(filename, offenses)
+      this.formatFileProcessed(filename, processedFiles)
     }
   }
 
@@ -31,10 +31,26 @@ export class SimpleFormatter extends BaseFormatter {
       const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
       const rule = colorize(`(${offense.code})`, "blue")
       const locationString = `${offense.location.start.line}:${offense.location.start.column}`
-      const paddedLocation = locationString.padEnd(4) // Pad to 4 characters for alignment
+      const paddedLocation = locationString.padEnd(4)
 
       console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
     }
     console.log("")
   }
+
+  formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void {
+    console.log(`${colorize(filename, "cyan")}:`)
+
+    for (const { offense, autocorrectable } of processedFiles) {
+      const isError = offense.severity === "error"
+      const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
+      const rule = colorize(`(${offense.code})`, "blue")
+      const locationString = `${offense.location.start.line}:${offense.location.start.column}`
+      const paddedLocation = locationString.padEnd(4)
+      const correctable = autocorrectable ? colorize(colorize(" [Correctable]", "green"), "bold") : ""
+
+      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}${correctable}`)
+    }
+    console.log("")
+  }
 }
diff --git a/javascript/packages/linter/src/cli/output-manager.ts b/javascript/packages/linter/src/cli/output-manager.ts
index ae1788c1c..cb75b70df 100644
--- a/javascript/packages/linter/src/cli/output-manager.ts
+++ b/javascript/packages/linter/src/cli/output-manager.ts
@@ -27,7 +27,9 @@ export class OutputManager {
    * Output successful lint results
    */
   async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
-    const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
+    const { allOffenses, files, totalErrors, totalWarnings, totalIgnored, filesWithOffenses, ruleCount, ruleOffenses } = results
+
+    const autofixableCount = allOffenses.filter(offense => offense.autocorrectable).length
 
     if (options.useGitHubActions) {
       const githubFormatter = new GitHubActionsFormatter(options.wrapLines, options.truncateLines)
@@ -45,12 +47,14 @@ export class OutputManager {
           files,
           totalErrors,
           totalWarnings,
+          totalIgnored,
           filesWithOffenses,
           ruleCount,
           startTime: options.startTime,
           startDate: options.startDate,
           showTiming: options.showTiming,
-          ruleOffenses
+          ruleOffenses,
+          autofixableCount,
         })
       }
     } else if (options.formatOption === "json") {
@@ -68,6 +72,7 @@ export class OutputManager {
           filesWithOffenses,
           totalErrors,
           totalWarnings,
+          totalIgnored,
           totalOffenses: totalErrors + totalWarnings,
           ruleCount
         },
@@ -96,12 +101,14 @@ export class OutputManager {
         files,
         totalErrors,
         totalWarnings,
+        totalIgnored,
         filesWithOffenses,
         ruleCount,
         startTime: options.startTime,
         startDate: options.startDate,
         showTiming: options.showTiming,
-        ruleOffenses
+        ruleOffenses,
+        autofixableCount,
       })
     }
   }
@@ -120,6 +127,7 @@ export class OutputManager {
           filesWithOffenses: 0,
           totalErrors: 0,
           totalWarnings: 0,
+          totalIgnored: 0,
           totalOffenses: 0,
           ruleCount: 0
         },
diff --git a/javascript/packages/linter/src/cli/summary-reporter.ts b/javascript/packages/linter/src/cli/summary-reporter.ts
index ba1b08983..f429981f7 100644
--- a/javascript/packages/linter/src/cli/summary-reporter.ts
+++ b/javascript/packages/linter/src/cli/summary-reporter.ts
@@ -4,12 +4,14 @@ export interface SummaryData {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalIgnored: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
   startDate: Date
   showTiming: boolean
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
+  autofixableCount: number
 }
 
 export class SummaryReporter {
@@ -18,7 +20,7 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming } = data
+    const { files, totalErrors, totalWarnings, totalIgnored, filesWithOffenses, ruleCount, startTime, startDate, showTiming, autofixableCount } = data
 
     console.log("\n")
     console.log(` ${colorize("Summary:", "bold")}`)
@@ -62,6 +64,10 @@ export class SummaryReporter {
       parts.push(colorize(colorize(`${totalWarnings} ${this.pluralize(totalWarnings, "warning")}`, "green"), "bold"))
     }
 
+    if (totalIgnored > 0) {
+      parts.push(colorize(colorize(`${totalIgnored} ignored`, "gray"), "bold"))
+    }
+
     if (parts.length === 0) {
       offensesSummary = colorize(colorize("0 offenses", "green"), "bold")
     } else {
@@ -75,11 +81,25 @@ export class SummaryReporter {
         detailText = `${totalOffenses} ${this.pluralize(totalOffenses, "offense")} across ${filesWithOffenses} ${this.pluralize(filesWithOffenses, "file")}`
       }
 
-      offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      if (detailText) {
+        offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      }
     }
 
     console.log(`  ${colorize(pad("Offenses"), "gray")} ${offensesSummary}`)
 
+    if (autofixableCount > 0 || (totalErrors + totalWarnings) > 0) {
+      const totalOffenses = totalErrors + totalWarnings
+
+      let fixableLine = `${colorize(colorize(`${totalOffenses} ${this.pluralize(totalOffenses, "offense")}`, "brightRed"), "bold")}`
+
+      if (autofixableCount > 0) {
+        fixableLine += ` | ${colorize(colorize(`${autofixableCount} autocorrectable using \`--fix\``, "green"), "bold")}`
+      }
+
+      console.log(`  ${colorize(pad("Fixable"), "gray")} ${fixableLine}`)
+    }
+
     if (showTiming) {
       const duration = Date.now() - startTime
       const timeString = startDate.toTimeString().split(' ')[0]
diff --git a/javascript/packages/linter/src/default-rules.ts b/javascript/packages/linter/src/default-rules.ts
index 5e6a04926..3584854d9 100644
--- a/javascript/packages/linter/src/default-rules.ts
+++ b/javascript/packages/linter/src/default-rules.ts
@@ -1,11 +1,16 @@
 import type { RuleClass } from "./types.js"
 
+import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
+import { ERBNoCaseNodeChildrenRule } from "./rules/erb-no-case-node-children.js"
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
+import { ERBNoExtraNewLineRule } from "./rules/erb-no-extra-newline.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
 import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
-import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
+import { ERBRequireTrailingNewlineRule } from "./rules/erb-require-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
+import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
+
 import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
 import { HTMLAriaAttributeMustBeValid } from "./rules/html-aria-attribute-must-be-valid.js"
 import { HTMLAriaLabelIsWellFormattedRule } from "./rules/html-aria-label-is-well-formatted.js"
@@ -16,32 +21,44 @@ import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quo
 import { HTMLAttributeEqualsSpacingRule } from "./rules/html-attribute-equals-spacing.js"
 import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-values-require-quotes.js"
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-both-disabled-and-aria-disabled.js"
+import { HTMLBodyOnlyElementsRule } from "./rules/html-body-only-elements.js"
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
+import { HTMLHeadOnlyElementsRule } from "./rules/html-head-only-elements.js"
 import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
+import { HTMLInputRequireAutocompleteRule } from "./rules/html-input-require-autocomplete.js"
 // import { HTMLNavigationHasLabelRule } from "./rules/html-navigation-has-label.js"
 import { HTMLNoAriaHiddenOnFocusableRule } from "./rules/html-no-aria-hidden-on-focusable.js"
 // import { HTMLNoBlockInsideInlineRule } from "./rules/html-no-block-inside-inline.js"
 import { HTMLNoDuplicateAttributesRule } from "./rules/html-no-duplicate-attributes.js"
 import { HTMLNoDuplicateIdsRule } from "./rules/html-no-duplicate-ids.js"
+import { HTMLNoDuplicateMetaNamesRule } from "./rules/html-no-duplicate-meta-names.js"
 import { HTMLNoEmptyAttributesRule } from "./rules/html-no-empty-attributes.js"
 import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
 import { HTMLNoPositiveTabIndexRule } from "./rules/html-no-positive-tab-index.js"
 import { HTMLNoSelfClosingRule } from "./rules/html-no-self-closing.js"
+// import { HTMLNoSpaceInTagRule } from "./rules/html-no-space-in-tag.js"
 // import { HTMLNoTitleAttributeRule } from "./rules/html-no-title-attribute.js"
+import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
 import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
-import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
+
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
-import { HTMLNoUnderscoresInAttributeNamesRule } from "./rules/html-no-underscores-in-attribute-names.js"
+
+import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 
 export const defaultRules: RuleClass[] = [
+  ERBCommentSyntax,
+  ERBNoCaseNodeChildrenRule,
   ERBNoEmptyTagsRule,
+  ERBNoExtraNewLineRule,
   ERBNoOutputControlFlowRule,
   ERBNoSilentTagInAttributeNameRule,
   ERBPreferImageTagHelperRule,
-  ERBRequiresTrailingNewlineRule,
+  ERBRequireTrailingNewlineRule,
   ERBRequireWhitespaceRule,
+  ERBRightTrimRule,
+
   HTMLAnchorRequireHrefRule,
   HTMLAriaAttributeMustBeValid,
   HTMLAriaLabelIsWellFormattedRule,
@@ -52,22 +69,29 @@ export const defaultRules: RuleClass[] = [
   HTMLAttributeEqualsSpacingRule,
   HTMLAttributeValuesRequireQuotesRule,
   HTMLAvoidBothDisabledAndAriaDisabledRule,
+  HTMLBodyOnlyElementsRule,
   HTMLBooleanAttributesNoValueRule,
+  HTMLHeadOnlyElementsRule,
   HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,
+  HTMLInputRequireAutocompleteRule,
   // HTMLNavigationHasLabelRule,
   HTMLNoAriaHiddenOnFocusableRule,
   // HTMLNoBlockInsideInlineRule,
   HTMLNoDuplicateAttributesRule,
   HTMLNoDuplicateIdsRule,
+  HTMLNoDuplicateMetaNamesRule,
   HTMLNoEmptyAttributesRule,
   HTMLNoEmptyHeadingsRule,
   HTMLNoNestedLinksRule,
   HTMLNoPositiveTabIndexRule,
   HTMLNoSelfClosingRule,
+  // HTMLNoSpaceInTagRule,
   // HTMLNoTitleAttributeRule,
+  HTMLNoUnderscoresInAttributeNamesRule,
   HTMLTagNameLowercaseRule,
-  ParserNoErrorsRule,
+
   SVGTagNameCapitalizationRule,
-  HTMLNoUnderscoresInAttributeNamesRule,
+
+  ParserNoErrorsRule,
 ]
diff --git a/javascript/packages/linter/src/linter.ts b/javascript/packages/linter/src/linter.ts
index 1b12112a4..7c8630ef5 100644
--- a/javascript/packages/linter/src/linter.ts
+++ b/javascript/packages/linter/src/linter.ts
@@ -1,6 +1,9 @@
 import { defaultRules } from "./default-rules.js"
+import { Location } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+import { findNodeByLocation } from "./rules/rule-utils.js"
 
-import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js"
+import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext, AutofixResult } from "./types.js"
 import type { HerbBackend } from "@herb-tools/core"
 
 export class Linter {
@@ -45,6 +48,37 @@ export class Linter {
     return (rule.constructor as any).type === "source"
   }
 
+  private filterOffenses(ruleOffenses: LintOffense[], sourceLines: string[], ruleName: string): { kept: LintOffense[], ignored: LintOffense[] } {
+    const kept: LintOffense[] = [];
+    const ignored: LintOffense[] = [];
+
+    for (const offense of ruleOffenses) {
+      const line = offense.location.start.line;
+      if (line > sourceLines.length) {
+        kept.push(offense);
+        continue;
+      }
+      const lineContent = sourceLines[line - 1];
+
+      const disableCommentRegex = /<%#\s+herb:disable\s+(.*)%>/;
+      const match = lineContent.match(disableCommentRegex);
+
+      if (match) {
+        const rulesRaw = (match && match[1]) || '';
+        const rules = rulesRaw.split(",").map((rule) => rule.trim());
+        if (rules.includes(ruleName) || rules.includes("all")) {
+          ignored.push(offense);
+        } else {
+          kept.push(offense);
+        }
+      } else {
+        kept.push(offense);
+      }
+    }
+
+    return { kept, ignored };
+  }
+
   /**
    * Lint source code using Parser/AST, Lexer, and Source rules.
    * @param source - The source code to lint
@@ -52,9 +86,12 @@ export class Linter {
    */
   lint(source: string, context?: Partial<LintContext>): LintResult {
     this.offenses = []
+    let ignoredCount = 0;
 
     const parseResult = this.herb.parse(source, { track_whitespace: true })
     const lexResult = this.herb.lex(source)
+    const hasParserErrors = parseResult.recursiveErrors().length > 0
+    const sourceLines = source.split("\n");
 
     for (const RuleClass of this.rules) {
       const rule = new RuleClass()
@@ -84,6 +121,12 @@ export class Linter {
           ruleOffenses = []
         }
       } else {
+        if (hasParserErrors && rule.name !== "parser-no-errors") {
+          ruleOffenses = []
+
+          continue
+        }
+
         if (rule.isEnabled) {
           isEnabled = rule.isEnabled(parseResult, context)
         }
@@ -95,7 +138,10 @@ export class Linter {
         }
       }
 
-      this.offenses.push(...ruleOffenses)
+      const { kept, ignored } = this.filterOffenses(ruleOffenses, sourceLines, rule.name);
+      ignoredCount += ignored.length;
+
+      this.offenses.push(...kept)
     }
 
     const errors = this.offenses.filter(offense => offense.severity === "error").length
@@ -104,7 +150,140 @@ export class Linter {
     return {
       offenses: this.offenses,
       errors,
-      warnings
+      warnings,
+      ignored: ignoredCount
+    }
+  }
+
+  /**
+   * Automatically fix offenses in the source code.
+   * Uses AST mutation for parser rules and token mutation for lexer rules.
+   * @param source - The source code to fix
+   * @param context - Optional context for linting (e.g., fileName)
+   * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+   * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
+   */
+  autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult {
+    const lintResult = offensesToFix ? { offenses: offensesToFix } : this.lint(source, context)
+
+    const parserOffenses: LintOffense[] = []
+    const lexerOffenses: LintOffense[] = []
+    const sourceOffenses: LintOffense[] = []
+
+    for (const offense of lintResult.offenses) {
+      const RuleClass = this.rules.find(rule => {
+        const instance = new rule()
+        return instance.name === offense.rule
+      })
+
+      if (!RuleClass) continue
+
+      if ((RuleClass as any).type === "lexer") {
+        lexerOffenses.push(offense)
+      } else if ((RuleClass as any).type === "source") {
+        sourceOffenses.push(offense)
+      } else {
+        parserOffenses.push(offense)
+      }
+    }
+
+    let currentSource = source
+    const fixed: LintOffense[] = []
+    const unfixed: LintOffense[] = []
+
+    if (parserOffenses.length > 0) {
+      const parseResult = this.herb.parse(currentSource, { track_whitespace: true })
+
+      for (const offense of parserOffenses) {
+        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+
+        if (!RuleClass) {
+          unfixed.push(offense)
+
+          continue
+        }
+
+        const rule = new RuleClass() as ParserRule
+
+        if (!rule.autofix) {
+          unfixed.push(offense)
+
+          continue
+        }
+
+        if (offense.autofixContext) {
+          const originalNodeType = offense.autofixContext.node.type
+          const location: Location = offense.autofixContext.node.location ? Location.from(offense.autofixContext.node.location) : offense.location
+
+          const freshNode = findNodeByLocation(
+            parseResult.value,
+            location,
+            (node) => node.type === originalNodeType
+          )
+
+          if (freshNode) {
+            offense.autofixContext.node = freshNode
+          } else {
+            unfixed.push(offense)
+
+            continue
+          }
+        }
+
+        const fixedResult = rule.autofix(offense, parseResult, context)
+
+        if (fixedResult) {
+          fixed.push(offense)
+        } else {
+          unfixed.push(offense)
+        }
+      }
+
+      if (fixed.length > 0) {
+        const printer = new IdentityPrinter()
+        currentSource = printer.print(parseResult.value)
+      }
+    }
+
+    if (sourceOffenses.length > 0) {
+      const sortedSourceOffenses = sourceOffenses.sort((a, b) => {
+        if (a.location.start.line !== b.location.start.line) {
+          return b.location.start.line - a.location.start.line
+        }
+
+        return b.location.start.column - a.location.start.column
+      })
+
+      for (const offense of sortedSourceOffenses) {
+        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+
+        if (!RuleClass) {
+          unfixed.push(offense)
+          continue
+        }
+
+        const rule = new RuleClass() as SourceRule
+
+        if (!rule.autofix) {
+          unfixed.push(offense)
+          continue
+        }
+
+        const correctedSource = rule.autofix(offense, currentSource, context)
+
+        if (correctedSource) {
+          currentSource = correctedSource
+          fixed.push(offense)
+        } else {
+          unfixed.push(offense)
+        }
+      }
+    }
+
+    return {
+      source: currentSource,
+      fixed,
+      unfixed
     }
   }
 }
diff --git a/javascript/packages/linter/src/rules/erb-comment-syntax.ts b/javascript/packages/linter/src/rules/erb-comment-syntax.ts
new file mode 100644
index 000000000..aabed1d1f
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-comment-syntax.ts
@@ -0,0 +1,30 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
+
+class ERBCommentSyntaxVisitor extends BaseRuleVisitor {
+  visitERBContentNode(node: ERBContentNode): void {
+    if (node.content?.value.startsWith(" #")) {
+      const openingTag = node.tag_opening?.value
+
+      this.addOffense(
+        `Use \`<%#\` instead of \`${openingTag} #\`. Ruby comments immediately after ERB tags can cause parsing issues.`,
+        node.location
+      )
+    }
+  }
+}
+
+export class ERBCommentSyntax extends ParserRule {
+  name = "erb-comment-syntax"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBCommentSyntaxVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/erb-no-case-node-children.ts b/javascript/packages/linter/src/rules/erb-no-case-node-children.ts
new file mode 100644
index 000000000..eb149cdef
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-no-case-node-children.ts
@@ -0,0 +1,62 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+import { isWhitespaceNode, isLiteralNode, isHTMLTextNode, isCommentNode, isERBNode } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, ERBCaseNode, ERBCaseMatchNode, Node } from "@herb-tools/core"
+
+class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.checkCaseNodeChildren(node, "when")
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.checkCaseNodeChildren(node, "in")
+    this.visitChildNodes(node)
+  }
+
+  private checkCaseNodeChildren(node: ERBCaseNode | ERBCaseMatchNode, type: string): void {
+    if (!node.children || node.children.length === 0) return
+
+    const caseCode = IdentityPrinter.printERBNode(node)
+    const firstCondition = node.conditions?.[0]
+    const conditionCode = firstCondition && isERBNode(firstCondition) ? IdentityPrinter.printERBNode(firstCondition) : `<% ${type} ... %>`
+
+    for (const child of node.children) {
+      if (!this.isAllowedContent(child)) {
+        const childCode = IdentityPrinter.print(child).trim()
+
+        this.addOffense(
+          `Do not place \`${childCode}\` between \`${caseCode}\` and \`${conditionCode}\`. Content here is not part of any branch and will not be rendered.`,
+          child.location,
+          "error"
+        )
+      }
+    }
+  }
+
+  private isAllowedContent(node: Node): boolean {
+    if (isWhitespaceNode(node)) return true
+    if (isCommentNode(node)) return true
+
+    if (isLiteralNode(node) || isHTMLTextNode(node)) {
+      return /^\s*$/.test(node.content)
+    }
+
+    return false
+  }
+}
+
+export class ERBNoCaseNodeChildrenRule extends ParserRule {
+  name = "erb-no-case-node-children"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoCaseNodeChildrenVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/erb-no-extra-newline.ts b/javascript/packages/linter/src/rules/erb-no-extra-newline.ts
new file mode 100644
index 000000000..a2bf96bae
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-no-extra-newline.ts
@@ -0,0 +1,85 @@
+import { BaseSourceRuleVisitor } from "./rule-utils.js"
+import { SourceRule } from "../types.js"
+import { Location, Position } from "@herb-tools/core"
+
+import type { Node } from "@herb-tools/core"
+import type { LintOffense, LintContext, BaseAutofixContext } from "../types.js"
+
+interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
+  startOffset: number
+  endOffset: number
+}
+
+function positionFromOffset(source: string, offset: number): Position {
+  let line = 1
+  let column = 0
+  let currentOffset = 0
+
+  for (let i = 0; i < source.length && currentOffset < offset; i++) {
+    const char = source[i]
+    currentOffset++
+    if (char === "\n") {
+      line++
+      column = 0
+    } else {
+      column++
+    }
+  }
+
+  return new Position(line, column)
+}
+
+class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor<ERBNoExtraNewLineAutofixContext> {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+
+    const regex = /\n{4,}/g
+
+    let match: RegExpExecArray | null
+
+    while ((match = regex.exec(source)) !== null) {
+      const startOffset = match.index + 3
+      const endOffset = match.index + match[0].length
+      const start = positionFromOffset(source, startOffset)
+      const end = positionFromOffset(source, endOffset)
+      const location = new Location(start, end)
+
+      const extraLines = match[0].length - 3
+
+      this.addOffense(
+        `Extra blank line detected. Remove ${extraLines} blank ${extraLines === 1 ? "line" : "lines"} to maintain consistent spacing (max 2 allowed).`,
+        location,
+        "error",
+        {
+          node: null as any as Node,
+          startOffset,
+          endOffset
+        }
+      )
+    }
+  }
+}
+
+export class ERBNoExtraNewLineRule extends SourceRule {
+  static autocorrectable = true
+  name = "erb-no-extra-newline"
+
+  check(source: string, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoExtraNewLineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBNoExtraNewLineAutofixContext>, source: string, _context?: Partial<LintContext>): string | null {
+    if (!offense.autofixContext) return null
+
+    const { startOffset, endOffset } = offense.autofixContext
+
+    const before = source.substring(0, startOffset)
+    const after = source.substring(endOffset)
+
+    return before + after
+  }
+}
diff --git a/javascript/packages/linter/src/rules/erb-require-trailing-newline.ts b/javascript/packages/linter/src/rules/erb-require-trailing-newline.ts
new file mode 100644
index 000000000..52c7c4761
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-require-trailing-newline.ts
@@ -0,0 +1,42 @@
+import { SourceRule } from "../types.js"
+import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+
+class ERBRequireTrailingNewlineVisitor extends BaseSourceRuleVisitor {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+    if (!this.context.fileName) return
+
+    if (!source.endsWith('\n')) {
+      this.addOffense(
+        "File must end with trailing newline.",
+        createEndOfFileLocation(source),
+        "error"
+      )
+    } else if (source.endsWith('\n\n')) {
+      this.addOffense(
+        "File must end with exactly one trailing newline.",
+        createEndOfFileLocation(source),
+        "error"
+      )
+    }
+  }
+}
+
+export class ERBRequireTrailingNewlineRule extends SourceRule {
+  static autocorrectable = true
+  name = "erb-require-trailing-newline"
+
+  check(source: string, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBRequireTrailingNewlineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null {
+    return source.trimEnd() + "\n"
+  }
+}
diff --git a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
index 3c5b1c896..1c8fb84d8 100644
--- a/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
+++ b/javascript/packages/linter/src/rules/erb-require-whitespace-inside-tags.ts
@@ -1,20 +1,20 @@
-import type { ParseResult, Token, Node } from "@herb-tools/core"
-import { isERBNode } from "@herb-tools/core";
-import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-class RequireWhitespaceInsideTags extends BaseRuleVisitor {
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types.js"
 
-  visitChildNodes(node: Node): void {
-    this.checkWhitespace(node)
-    super.visitChildNodes(node)
-  }
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+  openTag: Token
+  closeTag: Token
+  content: string
+  fixType: "after-open" | "before-close" | "after-comment-equals"
+}
 
-  private checkWhitespace(node: Node): void {
-    if (!isERBNode(node)) {
-      return
-    }
+class RequireWhitespaceInsideTags extends BaseRuleVisitor<ERBRequireWhitespaceAutofixContext> {
+
+  visitERBNode(node: ERBNode): void {
     const openTag = node.tag_opening
     const closeTag = node.tag_closing
     const content = node.content
@@ -26,25 +26,39 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     const value = content.value
 
     if (openTag.value === "<%#") {
-      this.checkCommentTagWhitespace(openTag, closeTag, value)
+      this.checkCommentTagWhitespace(node, openTag, closeTag, value)
     } else {
-      this.checkOpenTagWhitespace(openTag, value)
-      this.checkCloseTagWhitespace(closeTag, value)
+      this.checkOpenTagWhitespace(node, openTag, closeTag, value)
+      this.checkCloseTagWhitespace(node, openTag, closeTag, value)
     }
   }
 
-  private checkCommentTagWhitespace(openTag: Token, closeTag: Token, content: string): void {
+  private checkCommentTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string): void {
     if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
       this.addOffense(
         `Add whitespace after \`${openTag.value}\`.`,
         openTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-open"
+        }
       )
     } else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
       this.addOffense(
         `Add whitespace after \`<%#=\`.`,
         openTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-comment-equals"
+        }
       )
     }
 
@@ -52,12 +66,19 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
       this.addOffense(
         `Add whitespace before \`${closeTag.value}\`.`,
         closeTag.location,
-        "error"
+        "error",
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "before-close"
+        }
       )
     }
   }
 
-  private checkOpenTagWhitespace(openTag: Token, content:string):void {
+  private checkOpenTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.startsWith(" ") || content.startsWith("\n")) {
       return
     }
@@ -65,11 +86,18 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace after \`${openTag.value}\`.`,
       openTag.location,
-      "error"
+      "error",
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "after-open"
+      }
     )
   }
 
-  private checkCloseTagWhitespace(closeTag: Token, content:string):void {
+  private checkCloseTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.endsWith(" ") || content.endsWith("\n")) {
       return
     }
@@ -77,17 +105,57 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace before \`${closeTag.value}\`.`,
       closeTag.location,
-      "error"
+      "error",
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "before-close"
+      }
     )
   }
 }
 
-export class ERBRequireWhitespaceRule extends ParserRule {
+export class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+  static autocorrectable = true
   name = "erb-require-whitespace-inside-tags"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<ERBRequireWhitespaceAutofixContext>[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, fixType } = offense.autofixContext
+
+    if (!node.content) return null
+
+    const content = node.content.value
+
+    if (fixType === "before-close") {
+      node.content.value = content + " "
+
+      return result
+    }
+
+    if (fixType === "after-open") {
+      node.content.value = " " + content
+
+      return result
+    }
+
+    if (fixType === "after-comment-equals" && content.startsWith("=")) {
+      node.content.value = "= " + content.substring(1)
+
+      return result
+    }
+
+    return null
+  }
 }
diff --git a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts b/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
deleted file mode 100644
index aadb3fd72..000000000
--- a/javascript/packages/linter/src/rules/erb-requires-trailing-newline.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
-import { SourceRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
-
-class ERBRequiresTrailingNewlineVisitor extends BaseSourceRuleVisitor {
-  protected visitSource(source: string): void {
-    if (source.length === 0) return
-    if (source.endsWith('\n')) return
-    if (!this.context.fileName) return
-
-    this.addOffense(
-      "File must end with trailing newline",
-      createEndOfFileLocation(source),
-      "error"
-    )
-  }
-}
-
-export class ERBRequiresTrailingNewlineRule extends SourceRule {
-  name = "erb-requires-trailing-newline"
-
-  check(source: string, context?: Partial<LintContext>): LintOffense[] {
-    const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context)
-
-    visitor.visit(source)
-
-    return visitor.offenses
-  }
-}
diff --git a/javascript/packages/linter/src/rules/erb-right-trim.ts b/javascript/packages/linter/src/rules/erb-right-trim.ts
new file mode 100644
index 000000000..f3cc083f2
--- /dev/null
+++ b/javascript/packages/linter/src/rules/erb-right-trim.ts
@@ -0,0 +1,62 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { isERBOutputNode } from "@herb-tools/core"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ERBNode, ParseResult } from "@herb-tools/core"
+
+interface ERBRightTrimAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+}
+
+class ERBRightTrimVisitor extends BaseRuleVisitor<ERBRightTrimAutofixContext> {
+  visitERBNode(node: ERBNode): void {
+    if (!node.tag_closing) return
+
+    const trimClosing = node.tag_closing.value
+
+    if (trimClosing !== "=%>") return
+
+    this.addOffense(
+      "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
+      node.tag_closing.location,
+      "error",
+      { node }
+    )
+  }
+}
+
+export class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+  static autocorrectable = true
+  name = "erb-right-trim"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<ERBRightTrimAutofixContext>[] {
+    const visitor = new ERBRightTrimVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    if (!node.tag_closing) return null
+
+    const closing = node.tag_closing
+
+    if (closing.value === "=%>") {
+      closing.value = "-%>"
+      return result
+    }
+
+    if (closing.value === "-%>") {
+      closing.value = "%>"
+      return result
+    }
+
+    return null
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts b/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
index c53743858..be2ee6f78 100644
--- a/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-double-quotes.ts
@@ -1,11 +1,16 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
 import { filterLiteralNodes } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeDoubleQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  valueContent: string
+}
+
+class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin<AttributeDoubleQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams) {
     if (!hasAttributeValue(attributeNode)) return
     if (getAttributeValueQuoteType(attributeNode) !== "single") return
@@ -14,7 +19,11 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${attributeValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      "warning",
+      {
+        node: attributeNode,
+        valueContent: attributeValue
+      }
     )
   }
 
@@ -26,19 +35,39 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${combinedValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      "warning",
+      {
+        node: attributeNode,
+        valueContent: combinedValue || ""
+      }
     )
   }
 }
 
-export class HTMLAttributeDoubleQuotesRule extends ParserRule {
+export class HTMLAttributeDoubleQuotesRule extends ParserRule<AttributeDoubleQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-double-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeDoubleQuotesAutofixContext>[] {
     const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeDoubleQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+    if (!value.open_quote) return  null
+    if (!value.close_quote) return  null
+
+    value.open_quote.value = '"'
+    value.close_quote.value = '"'
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts b/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
index 223bf8c96..03bfc50c0 100644
--- a/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-equals-spacing.ts
@@ -1,10 +1,14 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
+interface AttributeEqualsSpacingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor<AttributeEqualsSpacingAutofixContext> {
   visitHTMLAttributeNode(attribute: HTMLAttributeNode): void {
     if (!attribute.equals || !attribute.name || !attribute.value) {
       return
@@ -14,7 +18,8 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace before `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        "error",
+        { node: attribute }
       )
     }
 
@@ -22,20 +27,34 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace after `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        "error",
+        { node: attribute }
       )
     }
   }
 }
 
-export class HTMLAttributeEqualsSpacingRule extends ParserRule {
+export class HTMLAttributeEqualsSpacingRule extends ParserRule<AttributeEqualsSpacingAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-equals-spacing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeEqualsSpacingAutofixContext>[] {
     const visitor = new HTMLAttributeEqualsSpacingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeEqualsSpacingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { equals } } = offense.autofixContext
+
+    if (!equals) return null
+
+    equals.value = "="
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts b/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
index a0e6c069e..70024f056 100644
--- a/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
+++ b/javascript/packages/linter/src/rules/html-attribute-values-require-quotes.ts
@@ -1,10 +1,16 @@
-import { ParserRule } from "../types.js"
+import { Token, Location } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLAttributeNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
+import type { HTMLAttributeNode, ParseResult,  } from "@herb-tools/core"
 
-class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeValuesRequireQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  unquotedValue: string
+}
+
+class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin<AttributeValuesRequireQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     if (this.hasAttributeValue(attributeNode)) return
     if (this.isQuoted(attributeNode)) return
@@ -12,7 +18,11 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${attributeValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode,
+        unquotedValue: attributeValue
+      }
     )
   }
 
@@ -23,7 +33,11 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${combinedValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode,
+        unquotedValue: combinedValue || ""
+      }
     )
   }
 
@@ -32,20 +46,47 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   }
 
   private isQuoted(attributeNode: HTMLAttributeNode): boolean {
-    const valueNode = attributeNode.value as HTMLAttributeValueNode
+    const valueNode = attributeNode.value
 
-    return valueNode.quoted
+    return valueNode ? valueNode.quoted : false
   }
 }
 
-export class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
+export class HTMLAttributeValuesRequireQuotesRule extends ParserRule<AttributeValuesRequireQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-values-require-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<AttributeValuesRequireQuotesAutofixContext>[] {
     const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeValuesRequireQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+
+    const quote = Token.from({ type: "TOKEN_QUOTE", value: '"', location: Location.zero, range: [0, 0] })
+
+    if (value.open_quote) {
+      value.open_quote.value = '"'
+    } else {
+      value.open_quote = quote
+    }
+
+    if (value.close_quote) {
+      value.close_quote.value = '"'
+    } else {
+      value.close_quote = quote
+    }
+
+    value.quoted = true
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-body-only-elements.ts b/javascript/packages/linter/src/rules/html-body-only-elements.ts
new file mode 100644
index 000000000..302140bb7
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-body-only-elements.ts
@@ -0,0 +1,60 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor, getTagName, isBodyOnlyTag } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, ParseResult } from "@herb-tools/core"
+
+class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
+  private elementStack: string[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node.open_tag)?.toLowerCase()
+    if (!tagName) return
+
+    this.checkBodyOnlyElement(node, tagName)
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkBodyOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideBody) return
+    if (!this.insideHead) return
+    if (!isBodyOnlyTag(tagName)) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<body>\` tag.`,
+      node.location,
+      "error"
+    )
+  }
+
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+}
+
+export class HTMLBodyOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-body-only-elements"
+
+  isEnabled(_result: ParseResult, context?: Partial<LintContext>): boolean {
+    if (context?.fileName?.endsWith(".xml")) return false
+    if (context?.fileName?.endsWith(".xml.erb")) return false
+
+    return true
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLBodyOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts b/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
index 370872ac8..29d5466eb 100644
--- a/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
+++ b/javascript/packages/linter/src/rules/html-boolean-attributes-no-value.ts
@@ -1,11 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
 import { IdentityPrinter } from "@herb-tools/printer"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
+interface BooleanAttributeAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin<BooleanAttributeAutofixContext> {
   protected checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }: StaticAttributeStaticValueParams) {
     this.checkAttribute(originalAttributeName, attributeNode)
   }
@@ -21,19 +25,34 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
       attributeNode.value!.location,
-      "error"
+      "error",
+      {
+        node: attributeNode
+      }
     )
   }
 }
 
-export class HTMLBooleanAttributesNoValueRule extends ParserRule {
+export class HTMLBooleanAttributesNoValueRule extends ParserRule<BooleanAttributeAutofixContext> {
+  static autocorrectable = true
   name = "html-boolean-attributes-no-value"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<BooleanAttributeAutofixContext>[] {
     const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<BooleanAttributeAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    node.equals = null
+    node.value = null
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-head-only-elements.ts b/javascript/packages/linter/src/rules/html-head-only-elements.ts
new file mode 100644
index 000000000..2cf9937b0
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-head-only-elements.ts
@@ -0,0 +1,65 @@
+import { ParserRule } from "../types"
+import { BaseRuleVisitor, getTagName, isHeadOnlyTag } from "./rule-utils"
+
+import type { ParseResult, HTMLElementNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types"
+
+class HeadOnlyElementsVisitor extends BaseRuleVisitor {
+  private elementStack: string[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    this.checkHeadOnlyElement(node, tagName)
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkHeadOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideHead) return
+    if (!this.insideBody) return
+    if (!isHeadOnlyTag(tagName)) return
+    if (tagName === "title" && this.insideSVG) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<head>\` tag.`,
+      node.location,
+      "error"
+    )
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
+  private get insideSVG(): boolean {
+    return this.elementStack.includes("svg")
+  }
+}
+
+export class HTMLHeadOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-head-only-elements"
+
+  isEnabled(_result: ParseResult, context?: Partial<LintContext>): boolean {
+    if (context?.fileName?.endsWith(".xml")) return false
+    if (context?.fileName?.endsWith(".xml.erb")) return false
+
+    return true
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HeadOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts b/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts
new file mode 100644
index 000000000..ecb656f3b
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-input-require-autocomplete.ts
@@ -0,0 +1,78 @@
+import { getTagName } from "@herb-tools/core"
+import { BaseRuleVisitor, getAttribute, getAttributeValue, getStaticAttributeValueContent } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLOpenTagNode } from "@herb-tools/core"
+
+class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
+  readonly HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE = new Set([
+    "color",
+    "date",
+    "datetime-local",
+    "email",
+    "month",
+    "number",
+    "password",
+    "range",
+    "search",
+    "tel",
+    "text",
+    "time",
+    "url",
+    "week",
+  ])
+
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkInputTag(node)
+  }
+
+  private checkInputTag(node: HTMLOpenTagNode): void {
+    if (!this.isInputTag(node) || this.hasAutocomplete(node)) return
+
+    const typeAttribute = getAttribute(node, "type");
+    if (!typeAttribute) return
+
+    const typeValue = getStaticAttributeValueContent(typeAttribute)
+    if (!typeValue) return
+
+    if (!this.HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE.has(typeValue)) return
+
+    this.addOffense(
+      "Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.",
+      node.location
+    )
+  }
+
+  private hasAutocomplete(node: HTMLOpenTagNode) {
+    const autocompleteAttribute = getAttribute(node, "autocomplete");
+    if (!autocompleteAttribute) return false
+
+    const autocompleteValue = getAttributeValue(autocompleteAttribute)
+    if (!autocompleteValue) return false
+
+    return true
+  }
+
+  private isInputTag(node: HTMLOpenTagNode) {
+    const tagName = getTagName(node);
+
+    if (tagName === "input") {
+      return true
+    } else {
+      return false
+    }
+  }
+}
+
+export class HTMLInputRequireAutocompleteRule extends ParserRule {
+  name = "html-input-require-autocomplete"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLInputRequireAutocompleteVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts b/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
index 2741ec641..a56bafcfe 100644
--- a/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
+++ b/javascript/packages/linter/src/rules/html-no-duplicate-ids.ts
@@ -1,4 +1,4 @@
-import { ParserRule } from "../types"
+import { ParserRule, BaseAutofixContext } from "../types"
 import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
 import { LiteralNode } from "@herb-tools/core"
 import { Printer, IdentityPrinter } from "@herb-tools/printer"
@@ -29,7 +29,7 @@ class OutputPrinter extends Printer {
   }
 }
 
-class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState, BranchState> {
+class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
   private documentIds: Set<string> = new Set<string>()
   private currentBranchIds: Set<string> = new Set<string>()
   private controlFlowIds: Set<string> = new Set<string>()
diff --git a/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts b/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts
new file mode 100644
index 000000000..ebe45ff5e
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-no-duplicate-meta-names.ts
@@ -0,0 +1,182 @@
+import { isHTMLElementNode } from "@herb-tools/core"
+import { getTagName, getAttributeName, getAttributeValue, forEachAttribute } from "./rule-utils"
+
+import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
+import { ParserRule, BaseAutofixContext } from "../types"
+
+import type { ParseResult, HTMLElementNode, HTMLAttributeNode } from "@herb-tools/core"
+import type { LintOffense, LintContext } from "../types"
+
+interface MetaTag {
+  node: HTMLElementNode
+  nameValue?: string
+  httpEquivValue?: string
+}
+
+interface ControlFlowState {
+  previousBranchMetas: MetaTag[]
+  previousControlFlowMetas: MetaTag[]
+}
+
+interface BranchState {
+  previousBranchMetas: MetaTag[]
+}
+
+class HTMLNoDuplicateMetaNamesVisitor extends ControlFlowTrackingVisitor<BaseAutofixContext, ControlFlowState, BranchState> {
+  private elementStack: string[] = []
+  private documentMetas: MetaTag[] = []
+  private currentBranchMetas: MetaTag[] = []
+  private controlFlowMetas: MetaTag[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    if (tagName === "head") {
+      this.documentMetas = []
+      this.currentBranchMetas = []
+      this.controlFlowMetas = []
+    } else if (tagName === "meta" && this.insideHead) {
+      this.collectAndCheckMetaTag(node)
+    }
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  protected onEnterControlFlow(_controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): ControlFlowState {
+    const stateToRestore: ControlFlowState = {
+      previousBranchMetas: this.currentBranchMetas,
+      previousControlFlowMetas: this.controlFlowMetas
+    }
+
+    this.currentBranchMetas = []
+
+    if (!wasAlreadyInControlFlow) {
+      this.controlFlowMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: ControlFlowState): void {
+    if (controlFlowType === ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+      this.controlFlowMetas.forEach(meta => this.documentMetas.push(meta))
+    }
+
+    this.currentBranchMetas = stateToRestore.previousBranchMetas
+    this.controlFlowMetas = stateToRestore.previousControlFlowMetas
+  }
+
+  protected onEnterBranch(): BranchState {
+    const stateToRestore: BranchState = {
+      previousBranchMetas: this.currentBranchMetas
+    }
+
+    if (this.isInControlFlow) {
+      this.currentBranchMetas = []
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitBranch(_stateToRestore: BranchState): void {}
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private collectAndCheckMetaTag(node: HTMLElementNode): void {
+    const metaTag: MetaTag = { node }
+    this.extractAttributes(node, metaTag)
+
+    if (!metaTag.nameValue && !metaTag.httpEquivValue) return
+
+    if (this.isInControlFlow) {
+      this.handleControlFlowMeta(metaTag)
+    } else {
+      this.handleGlobalMeta(metaTag)
+    }
+
+    this.currentBranchMetas.push(metaTag)
+  }
+
+  private extractAttributes(node: HTMLElementNode, metaTag: MetaTag): void {
+    if (isHTMLElementNode(node) && node.open_tag) {
+      forEachAttribute(node.open_tag as any, (attributeNode: HTMLAttributeNode) => {
+        const name = getAttributeName(attributeNode)
+        const value = getAttributeValue(attributeNode)?.trim()
+
+        if (name === "name" && value) {
+          metaTag.nameValue = value
+        } else if (name === "http-equiv" && value) {
+          metaTag.httpEquivValue = value
+        }
+      })
+    }
+  }
+
+  private handleControlFlowMeta(metaTag: MetaTag): void {
+    if (this.currentControlFlowType === ControlFlowType.LOOP) {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same loop iteration")
+    } else {
+      this.checkAgainstMetaList(metaTag, this.currentBranchMetas, "within the same control flow branch")
+      this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+
+      this.controlFlowMetas.push(metaTag)
+    }
+  }
+
+  private handleGlobalMeta(metaTag: MetaTag): void {
+    this.checkAgainstMetaList(metaTag, this.documentMetas, "")
+    this.documentMetas.push(metaTag)
+  }
+
+  private checkAgainstMetaList(metaTag: MetaTag, existingMetas: MetaTag[], context: string): void {
+    for (const existing of existingMetas) {
+      if (this.areMetaTagsDuplicate(metaTag, existing)) {
+        const attributeDescription = metaTag.nameValue
+          ? `\`name="${metaTag.nameValue}"\``
+          : `\`http-equiv="${metaTag.httpEquivValue}"\``
+
+        const attributeType = metaTag.nameValue ? "Meta names" : "`http-equiv` values"
+
+        const contextMsg = context ? ` ${context}` : ""
+
+        this.addOffense(
+          `Duplicate \`<meta>\` tag with ${attributeDescription}${contextMsg}. ${attributeType} should be unique within the \`<head>\` section.`,
+          metaTag.node.location,
+          "error"
+        )
+
+        return
+      }
+    }
+  }
+
+  private areMetaTagsDuplicate(meta1: MetaTag, meta2: MetaTag): boolean {
+    if (meta1.nameValue && meta2.nameValue) {
+      return meta1.nameValue.toLowerCase() === meta2.nameValue.toLowerCase()
+    }
+
+    if (meta1.httpEquivValue && meta2.httpEquivValue) {
+      return meta1.httpEquivValue.toLowerCase() === meta2.httpEquivValue.toLowerCase()
+    }
+
+    return false
+  }
+}
+
+export class HTMLNoDuplicateMetaNamesRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-no-duplicate-meta-names"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLNoDuplicateMetaNamesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-no-self-closing.ts b/javascript/packages/linter/src/rules/html-no-self-closing.ts
index 410f4d6d0..05168d901 100644
--- a/javascript/packages/linter/src/rules/html-no-self-closing.ts
+++ b/javascript/packages/linter/src/rules/html-no-self-closing.ts
@@ -1,11 +1,17 @@
-import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, isVoidElement } from "./rule-utils.js"
-import { getTagName } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { isVoidElement, findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { getTagName, isWhitespaceNode, Location, HTMLCloseTagNode } from "@herb-tools/core"
 
 import type { LintContext, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
+import type { Node, HTMLOpenTagNode, HTMLElementNode, SerializedToken, ParseResult } from "@herb-tools/core"
 
-class NoSelfClosingVisitor extends BaseRuleVisitor {
+interface NoSelfClosingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode>
+  tagName: string
+  isVoid: boolean
+}
+
+class NoSelfClosingVisitor extends BaseRuleVisitor<NoSelfClosingAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node) === "svg") {
       this.visit(node.open_tag)
@@ -22,20 +28,67 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`,
         node.location,
-        "error"
+        "error",
+        {
+          node,
+          tagName,
+          isVoid: isVoidElement(tagName)
+        }
       )
     }
   }
 }
 
-export class HTMLNoSelfClosingRule extends ParserRule {
+export class HTMLNoSelfClosingRule extends ParserRule<NoSelfClosingAutofixContext> {
+  static autocorrectable = true
   name = "html-no-self-closing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<NoSelfClosingAutofixContext>[] {
     const visitor = new NoSelfClosingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<NoSelfClosingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, tagName, isVoid } = offense.autofixContext
+    const { tag_closing } = node
+
+    if (!tag_closing) return null
+
+    tag_closing.value = ">"
+
+    if (node.children && Array.isArray(node.children)) {
+      const children = node.children as Node[]
+
+      if (children.length > 0 && isWhitespaceNode(children[children.length - 1])) {
+        node.children = children.slice(0, -1)
+      }
+    }
+
+    if (!isVoid) {
+      const parent = findParent(result.value, node as any as Node) as Mutable<HTMLElementNode> | null
+
+      if (parent && parent.type === "AST_HTML_ELEMENT_NODE") {
+        const tag_opening: SerializedToken = { type: "TOKEN_HTML_TAG_START_CLOSE", value: "</", location: Location.zero, range: [0, 0] }
+        const tag_name: SerializedToken = { type: "TOKEN_IDENTIFIER", value: tagName, location: Location.zero, range: [0, 0] }
+        const tag_closing: SerializedToken = { type: "TOKEN_HTML_TAG_END", value: ">", location: Location.zero, range: [0, 0] }
+
+        parent.close_tag = HTMLCloseTagNode.from({
+          type: "AST_HTML_CLOSE_TAG_NODE",
+          tag_opening,
+          tag_name,
+          tag_closing,
+          children: [],
+          errors: [],
+          location: Location.zero,
+        })
+      }
+    }
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/html-no-space-in-tag.ts b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
new file mode 100644
index 000000000..4d064f2ef
--- /dev/null
+++ b/javascript/packages/linter/src/rules/html-no-space-in-tag.ts
@@ -0,0 +1,214 @@
+import { Token, Location, WhitespaceNode } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext } from "../types.js"
+
+import { findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { filterWhitespaceNodes, isWhitespaceNode, isHTMLOpenTagNode } from "@herb-tools/core"
+
+import type { ParseResult, Node, HTMLCloseTagNode, HTMLOpenTagNode } from "@herb-tools/core"
+import type { LintOffense, LintContext, Mutable } from "../types.js"
+
+const MESSAGES = {
+  EXTRA_SPACE_NO_SPACE: "Extra space detected where there should be no space.",
+  EXTRA_SPACE_SINGLE_SPACE: "Extra space detected where there should be a single space.",
+  EXTRA_SPACE_SINGLE_BREAK: "Extra space detected where there should be a single space or a single line break.",
+  NO_SPACE_SINGLE_SPACE: "No space detected where there should be a single space.",
+} as const
+
+interface HTMLNoSpaceInTagAutofixContext extends BaseAutofixContext {
+  node: WhitespaceNode | HTMLOpenTagNode
+  message: string
+}
+
+class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor<HTMLNoSpaceInTagAutofixContext> {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    if (node.isSingleLine) {
+      this.checkSingleLineTag(node)
+    } else {
+      this.checkMultilineTag(node)
+    }
+  }
+
+  visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
+    this.reportAllWhitespace(node.children, MESSAGES.EXTRA_SPACE_NO_SPACE)
+  }
+
+  private checkSingleLineTag(node: HTMLOpenTagNode): void {
+    const { children, tag_closing } = node
+    const isSelfClosing = tag_closing ? this.isSelfClosing(tag_closing) : false
+
+    this.checkWhitespaceInSingleLineTag(children, isSelfClosing)
+    this.checkMissingSpaceBeforeSelfClosing(node, children, isSelfClosing)
+  }
+
+  private checkWhitespaceInSingleLineTag(children: Node[], isSelfClosing: boolean): void {
+    const whitespaceNodes = filterWhitespaceNodes(children)
+
+    whitespaceNodes.forEach((whitespace) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      const isLastChild = children[children.length - 1] === whitespace
+      if (isLastChild) {
+        this.checkTrailingWhitespace(whitespace, content, isSelfClosing)
+        return
+      }
+
+      if (content.length > 1) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_SPACE })
+      }
+    })
+  }
+
+  private checkTrailingWhitespace(whitespace: WhitespaceNode, content: string, isSelfClosing: boolean): void {
+    if (isSelfClosing && content === ' ') return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private checkMissingSpaceBeforeSelfClosing(node: HTMLOpenTagNode, children: Node[], isSelfClosing: boolean): void {
+    if (!isSelfClosing) return
+
+    const lastChild = children[children.length - 1]
+    if (lastChild && isWhitespaceNode(lastChild)) return
+
+    const lastNonWhitespace = children.filter(child => !isWhitespaceNode(child)).pop()
+    const locationToReport = lastNonWhitespace?.location ?? node.tag_name?.location ?? node.location
+
+    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport, "error", { node, message: MESSAGES.NO_SPACE_SINGLE_SPACE })
+  }
+
+  private checkMultilineTag(node: HTMLOpenTagNode): void {
+    const whitespaceNodes = filterWhitespaceNodes(node.children)
+    let previousWhitespace: WhitespaceNode | null = null
+
+    whitespaceNodes.forEach((whitespace, index) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      if (this.hasConsecutiveNewlines(content, previousWhitespace)) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_BREAK })
+        previousWhitespace = whitespace
+
+        return
+      }
+
+      if (this.isNonNewlineWhitespace(content)) {
+        this.checkIndentation(whitespace, index, whitespaceNodes.length, node)
+      }
+
+      previousWhitespace = whitespace
+    })
+  }
+
+  private hasConsecutiveNewlines(content: string, previousWhitespace: WhitespaceNode | null): boolean {
+    if (content === "\n") return previousWhitespace?.value?.value === "\n"
+    if (!content.includes("\n")) return false
+
+    const newlines = content.match(/\n/g)
+
+    return (newlines?.length ?? 0) > 1
+  }
+
+  private isNonNewlineWhitespace(content: string): boolean {
+    return !content.includes("\n")
+  }
+
+  private checkIndentation(whitespace: WhitespaceNode, index: number, totalWhitespaceNodes: number, node: HTMLOpenTagNode): void {
+    const isLastWhitespace = index === totalWhitespaceNodes - 1
+    const expectedIndent = isLastWhitespace ? node.location.start.column : node.location.start.column + 2
+
+    if (whitespace.location.end.column === expectedIndent) return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, "error", { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private isSelfClosing(tag_closing: Token): boolean {
+    return tag_closing?.value?.includes('/') ?? false
+  }
+
+  private getWhitespaceContent(whitespace: WhitespaceNode): string | null {
+    return whitespace.value?.value ?? null
+  }
+
+  private reportAllWhitespace(nodes: Node[] | WhitespaceNode[], message: string): void {
+    const whitespaceNodes = Array.isArray(nodes) && nodes.length > 0 && !isWhitespaceNode(nodes[0])
+      ? filterWhitespaceNodes(nodes)
+      : nodes as WhitespaceNode[]
+
+    whitespaceNodes.forEach(whitespace => {
+      this.addOffense(message, whitespace.location, "error", { node: whitespace, message })
+    })
+  }
+}
+
+export class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
+  // TODO: enable and fix autofix
+  static autocorrectable = false
+  name = "html-no-space-in-tag"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<HTMLNoSpaceInTagAutofixContext>[] {
+    const visitor = new HTMLNoSpaceInTagVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<HTMLNoSpaceInTagAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, message } = offense.autofixContext
+    if (!node) return null
+
+    if (isHTMLOpenTagNode(node)) {
+      const token = Token.from({ type: "TOKEN_WHITESPACE", value: " ", range: [0, 0], location: Location.zero })
+      const whitespace = new WhitespaceNode({ type: "AST_WHITESPACE_NODE", value: token, location: Location.zero, errors: [] })
+
+      node.children.push(whitespace)
+
+      return result
+    }
+
+    if (!isWhitespaceNode(node)) return null
+
+    const whitespaceNode = node as Mutable<WhitespaceNode>
+    if (!whitespaceNode.value) return null
+
+    switch (message) {
+      case MESSAGES.EXTRA_SPACE_NO_SPACE: {
+        let selfClosing = false
+        let beginningOfLine = false
+
+        const parent = findParent(result.value, node)
+
+        if (parent && isHTMLOpenTagNode(parent)) {
+          selfClosing = parent.tag_closing?.value === "/>"
+          beginningOfLine = node.location.start.column === 0
+        }
+
+        whitespaceNode.value.value = selfClosing && !beginningOfLine ? " " : ""
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_BREAK: {
+        if (whitespaceNode.value.value.includes("\n")) {
+          whitespaceNode.value.value = ""
+        } else {
+          whitespaceNode.value.value = " "
+        }
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_SPACE:
+      case MESSAGES.NO_SPACE_SINGLE_SPACE: {
+        whitespaceNode.value.value = " "
+
+        return result
+      }
+
+      default: return null
+    }
+  }
+}
diff --git a/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts b/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
index e1d499ba6..31d06b701 100644
--- a/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
+++ b/javascript/packages/linter/src/rules/html-no-underscores-in-attribute-names.ts
@@ -38,7 +38,7 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
     if (attributeName.includes("_")) {
       this.addOffense(
         `Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`,
-        attributeNode.value!.location,
+        attributeNode.name?.location ?? attributeNode.location,
         "warning"
       )
     }
diff --git a/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts b/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
index a939967a7..29d0bc402 100644
--- a/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
+++ b/javascript/packages/linter/src/rules/html-tag-name-lowercase.ts
@@ -1,9 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
-
-import { isNode, getTagName, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+import { isNode, getTagName, HTMLOpenTagNode } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+
+interface TagNameAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  tagName: string
+  correctedTagName: string
+}
 
 class XMLDeclarationChecker extends BaseRuleVisitor {
   hasXMLDeclaration: boolean = false
@@ -18,7 +24,7 @@ class XMLDeclarationChecker extends BaseRuleVisitor {
   }
 }
 
-class TagNameLowercaseVisitor extends BaseRuleVisitor {
+class TagNameLowercaseVisitor extends BaseRuleVisitor<TagNameAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node).toLowerCase() === "svg") {
       this.checkTagName(node.open_tag)
@@ -52,13 +58,19 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} tag name \`${open}${tagName}>\` should be lowercase. Use \`${open}${lowercaseTagName}>\` instead.`,
         node.tag_name!.location,
-        "error"
+        "error",
+        {
+          node,
+          tagName,
+          correctedTagName: lowercaseTagName
+        }
       )
     }
   }
 }
 
-export class HTMLTagNameLowercaseRule extends ParserRule {
+export class HTMLTagNameLowercaseRule extends ParserRule<TagNameAutofixContext> {
+  static autocorrectable = true
   name = "html-tag-name-lowercase"
 
   isEnabled(result: ParseResult, context?: Partial<LintContext>): boolean {
@@ -71,9 +83,23 @@ export class HTMLTagNameLowercaseRule extends ParserRule {
     return !checker.hasXMLDeclaration
   }
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<TagNameAutofixContext>[] {
     const visitor = new TagNameLowercaseVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<TagNameAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctedTagName } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctedTagName
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/rules/index.ts b/javascript/packages/linter/src/rules/index.ts
index 29a4ce56a..182c9bb0e 100644
--- a/javascript/packages/linter/src/rules/index.ts
+++ b/javascript/packages/linter/src/rules/index.ts
@@ -1,9 +1,15 @@
 export * from "./rule-utils.js"
+
+export * from "./erb-comment-syntax.js"
+export * from "./erb-no-case-node-children.js"
 export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-extra-newline.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
-export * from "./erb-requires-trailing-newline.js"
+export * from "./erb-require-trailing-newline.js"
+export * from "./erb-right-trim.js"
+
 export * from "./html-anchor-require-href.js"
 export * from "./html-aria-label-is-well-formatted.js"
 export * from "./html-aria-level-must-be-valid.js"
@@ -13,20 +19,26 @@ export * from "./html-attribute-double-quotes.js"
 export * from "./html-attribute-equals-spacing.js"
 export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
+export * from "./html-body-only-elements.js"
 export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-head-only-elements.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
+export * from "./html-input-require-autocomplete.js"
 export * from "./html-navigation-has-label.js"
 export * from "./html-no-aria-hidden-on-focusable.js"
 export * from "./html-no-block-inside-inline.js"
 export * from "./html-no-duplicate-attributes.js"
 export * from "./html-no-duplicate-ids.js"
+export * from "./html-no-duplicate-meta-names.js"
 export * from "./html-no-empty-attributes.js"
 export * from "./html-no-empty-headings.js"
 export * from "./html-no-nested-links.js"
 export * from "./html-no-positive-tab-index.js"
 export * from "./html-no-self-closing.js"
+export * from "./html-no-space-in-tag.js"
 export * from "./html-no-title-attribute.js"
+export * from "./html-no-underscores-in-attribute-names.js"
 export * from "./html-tag-name-lowercase.js"
+
 export * from "./svg-tag-name-capitalization.js"
-export * from "./html-no-underscores-in-attribute-names.js"
diff --git a/javascript/packages/linter/src/rules/rule-utils.ts b/javascript/packages/linter/src/rules/rule-utils.ts
index 911b16783..56cbdf1b2 100644
--- a/javascript/packages/linter/src/rules/rule-utils.ts
+++ b/javascript/packages/linter/src/rules/rule-utils.ts
@@ -13,10 +13,11 @@ import {
 } from "@herb-tools/core"
 
 import type {
-  ERBNode,
+  ERBContentNode,
   HTMLAttributeNameNode,
   HTMLAttributeNode,
   HTMLAttributeValueNode,
+  HTMLElementNode,
   HTMLOpenTagNode,
   LiteralNode,
   LexResult,
@@ -27,7 +28,7 @@ import type {
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 import type * as Nodes from "@herb-tools/core"
-import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+import type { LintOffense, LintSeverity, LintContext, BaseAutofixContext } from "../types.js"
 
 export enum ControlFlowType {
   CONDITIONAL,
@@ -37,8 +38,8 @@ export enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export abstract class BaseRuleVisitor extends Visitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -52,7 +53,7 @@ export abstract class BaseRuleVisitor extends Visitor {
   /**
    * Helper method to create a lint offense
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -60,14 +61,15 @@ export abstract class BaseRuleVisitor extends Visitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 }
 
@@ -76,10 +78,11 @@ export abstract class BaseRuleVisitor extends Visitor {
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
   protected isInControlFlow: boolean = false
   protected currentControlFlowType: ControlFlowType | null = null
 
@@ -170,7 +173,9 @@ export function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[] {
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export function getTagName(node: HTMLOpenTagNode): string | null {
+export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null {
+  if (!node) return null
+
   return node.tag_name?.value.toLowerCase() || null
 }
 
@@ -300,7 +305,7 @@ export function getAttributeValue(attributeNode: HTMLAttributeNode): string | nu
   for (const child of valueNode.children) {
     switch (child.type) {
       case "AST_ERB_CONTENT_NODE": {
-        const erbNode = child as ERBNode
+        const erbNode = child as ERBContentNode
 
         if (erbNode.content) {
           result += `${erbNode.tag_opening?.value}${erbNode.content.value}${erbNode.tag_closing?.value}`
@@ -621,7 +626,7 @@ export function isBooleanAttribute(attributeName: string): boolean {
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
   constructor(ruleName: string, context?: Partial<LintContext>) {
     super(ruleName, context)
   }
@@ -735,8 +740,8 @@ export function forEachAttribute(
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export abstract class BaseLexerRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -748,7 +753,7 @@ export abstract class BaseLexerRuleVisitor {
   /**
    * Helper method to create a lint offense for lexer rules
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -756,14 +761,15 @@ export abstract class BaseLexerRuleVisitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 
   /**
@@ -791,14 +797,13 @@ export abstract class BaseLexerRuleVisitor {
   protected visitToken(_token: Token): void {
     // Default implementation does nothing
   }
-
 }
 
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export abstract class BaseSourceRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: LintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -810,7 +815,7 @@ export abstract class BaseSourceRuleVisitor {
   /**
    * Helper method to create a lint offense for source rules
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): LintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -818,14 +823,15 @@ export abstract class BaseSourceRuleVisitor {
       message,
       location,
       severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, severity: LintSeverity = "error", autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, severity, autofixContext))
   }
 
   /**
@@ -841,19 +847,222 @@ export abstract class BaseSourceRuleVisitor {
    * Override this method to implement source-level checks
    */
   protected abstract visitSource(source: string): void
+}
 
-  /**
-   * Helper method to create a location for a specific position in the source
-   */
-  protected createLocationAt(source: string, position: number): Location {
-    const beforePosition = source.substring(0, position)
-    const lines = beforePosition.split('\n')
-    const line = lines.length
-    const column = lines[lines.length - 1].length + 1
+/**
+ * Autofix utilities for applying string replacements
+ */
+
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export function locationsEqual(a: Location, b: Location): boolean {
+  return a.start.line === b.start.line &&
+         a.start.column === b.start.column &&
+         a.end.line === b.end.line &&
+         a.end.column === b.end.column
+}
+
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any {
+  const visited = new Set<any>()
+
+  function search(node: any): any {
+    if (!node || visited.has(node)) return null
+    visited.add(node)
+
+    if (node.location && locationsEqual(node.location, location)) {
+      if (!predicate || predicate(node)) {
+        return node
+      }
+    }
+
+    const propsToCheck = ['tag_opening', 'tag_closing', 'tag_name', 'name', 'equals', 'value', 'content']
+    for (const prop of propsToCheck) {
+      if (node[prop]?.location && locationsEqual(node[prop].location, location)) {
+        if (!predicate || predicate(node)) {
+          return node
+        }
+      }
+    }
+
+    if (typeof node.compactChildNodes === 'function') {
+      for (const child of node.compactChildNodes()) {
+        const found = search(child)
+        if (found) return found
+      }
+    } else {
+      if (node.children && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+
+      if (node.body && Array.isArray(node.body)) {
+        for (const child of node.body) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+    }
+
+    return null
+  }
+
+  return search(root)
+}
+
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export function findParent(root: Node, target: Node): Node | null {
+  let parentNode: Node | null = null
 
-    const start = new Position(line, column)
-    const end = new Position(line, column)
+  const search = (node: Node, _parent: Node | null = null): void => {
+    if (parentNode) return
 
-    return new Location(start, end)
+    const nodeAny = node as any
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        if (child === target) {
+          parentNode = node
+          return
+        }
+      }
+    }
+
+    const propsToCheck = ['open_tag', 'close_tag', 'body', 'name', 'value']
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (value === target) {
+        parentNode = node
+        return
+      }
+      if (Array.isArray(value) && value.includes(target)) {
+        parentNode = node
+        return
+      }
+    }
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        search(child, node)
+        if (parentNode) return
+      }
+    }
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object' && 'type' in item) {
+            search(item, node)
+            if (parentNode) return
+          }
+        }
+      } else if (value && typeof value === 'object' && 'type' in value) {
+        search(value, node)
+        if (parentNode) return
+      }
+    }
   }
+
+  search(root)
+
+  return parentNode
+}
+
+export const DOCUMENT_ONLY_TAG_NAMES = new Set<string>([
+  "html"
+])
+
+export const HTML_ONLY_TAG_NAMES = new Set<string>([
+  "head", "body"
+])
+
+export const HEAD_ONLY_TAG_NAMES = new Set<string>([
+  "base",
+  "title",
+  "style",
+  "meta",
+  "link",
+])
+
+export const HEAD_AND_BODY_TAG_NAMES = new Set<string>([
+  "script",
+  "noscript",
+  "template",
+])
+
+export function isDocumentOnlyTag(tagName: string): boolean {
+  return DOCUMENT_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHtmlOnlyTag(tagName: string): boolean {
+  return HTML_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadOnlyTag(tagName: string): boolean {
+  return HEAD_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadAndBodyTag(tagName: string): boolean {
+  return HEAD_AND_BODY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isBodyOnlyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    !isHeadOnlyTag(tag) &&
+    !isHeadAndBodyTag(tag)
+  )
+}
+
+export function isBodyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isBodyOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
+}
+
+export function isHeadTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isHeadOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
 }
diff --git a/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts b/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
index 73d45c901..1581e00d0 100644
--- a/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
+++ b/javascript/packages/linter/src/rules/svg-tag-name-capitalization.ts
@@ -1,10 +1,16 @@
+import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE } from "./rule-utils.js"
 
-import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { LintOffense, LintContext, BaseAutofixContext, Mutable } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core"
 
-class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
+interface SVGTagNameCapitalizationAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  currentTagName: string
+  correctCamelCase: string
+}
+
+class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitalizationAutofixContext> {
   private insideSVG = false
 
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -22,6 +28,7 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       if (node.open_tag) {
         this.checkTagName(node.open_tag as HTMLOpenTagNode)
       }
+
       if (node.close_tag) {
         this.checkTagName(node.close_tag as HTMLCloseTagNode)
       }
@@ -50,18 +57,38 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,
         node.tag_name!.location,
-        "error"
+        "error",
+        {
+          node,
+          currentTagName: tagName,
+          correctCamelCase
+        }
       )
     }
   }
 }
 
-export class SVGTagNameCapitalizationRule extends ParserRule {
+export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
+  static autocorrectable = true
   name = "svg-tag-name-capitalization"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense<SVGTagNameCapitalizationAutofixContext>[] {
     const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctCamelCase } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctCamelCase
+
+    return result
+  }
 }
diff --git a/javascript/packages/linter/src/types.ts b/javascript/packages/linter/src/types.ts
index 7e377301a..ab0d1d31a 100644
--- a/javascript/packages/linter/src/types.ts
+++ b/javascript/packages/linter/src/types.ts
@@ -1,5 +1,7 @@
 import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core"
+
 import type { defaultRules } from "./default-rules.js"
+import type { Node } from "@herb-tools/core"
 
 export type LintSeverity = "error" | "warning" | "info" | "hint"
 
@@ -9,22 +11,79 @@ export type LintSeverity = "error" | "warning" | "info" | "hint"
  */
 export type LinterRule = InstanceType<typeof defaultRules[number]>['name']
 
-export interface LintOffense extends Diagnostic {
+/**
+ * Recursively removes readonly modifiers from a type, making it mutable.
+ * Used internally during autofix to allow direct AST node mutation.
+ *
+ * @example
+ * const node: HTMLOpenTagNode = ...  // readonly properties
+ * const mutable = node as Mutable<HTMLOpenTagNode>  // can mutate
+ * mutable.tag_name!.value = 'div'  // ✓ allowed
+ */
+export type Mutable<T> = T extends ReadonlyArray<infer U>
+  ? Array<Mutable<U>>
+  : T extends object
+    ? { -readonly [K in keyof T]: Mutable<T[K]> }
+    : T
+
+/**
+ * Converts a readonly node or object to a mutable version.
+ * Use this in autofix methods to enable direct mutation of AST nodes.
+ * Follows the TypeScript pattern of 'as const' but for mutability.
+ *
+ * @example
+ * const mutable = asMutable(node)
+ * mutable.tag_name.value = 'div'
+ * mutable.content.value = 'updated'
+ */
+export function asMutable<T>(node: T): Mutable<T> {
+  return node as Mutable<T>
+}
+
+
+/**
+ * Base context for autofix operations. Contains the offending node.
+ * Rules can extend this interface to include rule-specific autofix data.
+ * Note: The node is typed as Mutable to allow direct mutation in autofix methods.
+ */
+export interface BaseAutofixContext {
+  /** The AST node, token, or data structure that caused the offense (mutable) */
+  node: Mutable<Node>
+}
+
+export interface LintOffense<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Diagnostic {
   rule: LinterRule
   severity: LintSeverity
+  /** Context data for autofix, including the offending node and rule-specific data */
+  autofixContext?: TAutofixContext
 }
 
-export interface LintResult {
-  offenses: LintOffense[]
+export interface LintResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  offenses: LintOffense<TAutofixContext>[]
   errors: number
   warnings: number
+  ignored: number
+}
+
+/**
+ * Result of applying autofixes to source code
+ */
+export interface AutofixResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  /** The corrected source code with all fixes applied */
+  source: string
+  /** Offenses that were successfully fixed */
+  fixed: LintOffense<TAutofixContext>[]
+  /** Offenses that could not be automatically fixed */
+  unfixed: LintOffense<TAutofixContext>[]
 }
 
-export abstract class ParserRule {
+export abstract class ParserRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "parser" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -33,13 +92,25 @@ export abstract class ParserRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(result: ParseResult, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense by mutating the AST.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param result - The parse result containing the AST (mutate it directly and return it)
+   * @param context - Optional context for linting
+   * @returns The mutated ParseResult if fixed, or null if the offense could not be fixed
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, result: ParseResult, context?: Partial<LintContext>): ParseResult | null
 }
 
-export abstract class LexerRule {
+export abstract class LexerRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "lexer" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -48,6 +119,16 @@ export abstract class LexerRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(lexResult: LexResult, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense by mutating tokens.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param lexResult - The lex result containing tokens (mutate them directly and return)
+   * @param context - Optional context for linting
+   * @returns The mutated LexResult if fixed, or null if the offense could not be fixed
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, lexResult: LexResult, context?: Partial<LintContext>): LexResult | null
 }
 
 export interface LexerRuleConstructor {
@@ -70,11 +151,13 @@ export const DEFAULT_LINT_CONTEXT: LintContext = {
   fileName: undefined
 } as const
 
-export abstract class SourceRule {
+export abstract class SourceRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
   static type = "source" as const
+  /** Indicates whether this rule supports autofix. Defaults to false. */
+  static autocorrectable = false
   abstract name: string
-  abstract check(source: string, context?: Partial<LintContext>): LintOffense[]
-  
+  abstract check(source: string, context?: Partial<LintContext>): LintOffense<TAutofixContext>[]
+
   /**
    * Optional method to determine if this rule should run.
    * If not implemented, rule is always enabled.
@@ -83,6 +166,16 @@ export abstract class SourceRule {
    * @returns true if rule should run, false to skip
    */
   isEnabled?(source: string, context?: Partial<LintContext>): boolean
+
+  /**
+   * Optional method to automatically fix an offense.
+   * If not implemented, the rule does not support autofix.
+   * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+   * @param source - The original source code
+   * @param context - Optional context for linting
+   * @returns The corrected source if the offense can be fixed, null otherwise
+   */
+  autofix?(offense: LintOffense<TAutofixContext>, source: string, context?: Partial<LintContext>): string | null
 }
 
 export interface SourceRuleConstructor {
diff --git a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
index 836e0922b..793eed204 100644
--- a/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
+++ b/javascript/packages/linter/test/__snapshots__/cli.test.ts.snap
@@ -1,11 +1,11 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`CLI Output Formatting > GitHub Actions format escapes special characters in messages 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -21,7 +21,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -34,7 +34,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -51,13 +51,14 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > GitHub Actions format includes rule codes 1`] = `
-"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-requires-trailing-newline • @herb-tools/linter@0.7.4::File must end with trailing newline [erb-requires-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
+"::error file=test/fixtures/no-trailing-newline.html.erb,line=1,col=29,title=erb-require-trailing-newline • @herb-tools/linter@0.7.5::File must end with trailing newline. [erb-require-trailing-newline]%0A%0A%0Atest/fixtures/no-trailing-newline.html.erb:1:29%0A%0A  →   1 │ <div>No trailing newline</div>%0A        │                              ~%0A
 
-[error] File must end with trailing newline (erb-requires-trailing-newline)
+[error] File must end with trailing newline. [Correctable] (erb-require-trailing-newline)
 
 test/fixtures/no-trailing-newline.html.erb:1:29
 
@@ -65,12 +66,70 @@ test/fixtures/no-trailing-newline.html.erb:1:29
         │                              ~
 
  Rule offenses:
-  erb-requires-trailing-newline (1 offense in 1 file)
+  erb-require-trailing-newline (1 offense in 1 file)
 
 
  Summary:
   Checked      1 file
-  Offenses     1 error | 0 warnings (1 offense across 1 file)"
+  Offenses     1 error | 0 warnings (1 offense across 1 file)
+  Fixable      1 offense | 1 autocorrectable using \`--fix\`"
+`;
+
+exports[`CLI Output Formatting > Ignores disabled rules 1`] = `
+"[error] Opening tag name \`<DIV>\` should be lowercase. Use \`<div>\` instead. [Correctable] (html-tag-name-lowercase)
+
+test/fixtures/ignored.html.erb:6:3
+
+      4 │   </h1>
+      5 │ 
+  →   6 │   <DIV>hello</DIV>
+        │    ~~~
+      7 │   <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+      8 │   <% %> <%# herb:disable erb-no-empty-tags %>
+
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
+
+[error] Closing tag name \`</DIV>\` should be lowercase. Use \`</div>\` instead. [Correctable] (html-tag-name-lowercase)
+
+test/fixtures/ignored.html.erb:6:14
+
+      4 │   </h1>
+      5 │ 
+  →   6 │   <DIV>hello</DIV>
+        │               ~~~
+      7 │   <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+      8 │   <% %> <%# herb:disable erb-no-empty-tags %>
+
+ Rule offenses:
+  html-tag-name-lowercase (2 offenses in 1 file)
+
+
+ Summary:
+  Checked      1 file
+  Offenses     2 errors | 0 warnings | 3 ignored (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
+`;
+
+exports[`CLI Output Formatting > diplays only parsers errors if one is present 1`] = `
+"[error] Unexpected Token. Expected: \`TOKEN_IDENTIFIER, TOKEN_AT, TOKEN_ERB_START,TOKEN_WHITESPACE, or TOKEN_NEWLINE\`, found: \`TOKEN_CHARACTER\`. (\`UNEXPECTED_ERROR\`) (parser-no-errors)
+
+test/fixtures/parser-errors.html.erb:2:16
+
+      1 │ <div id=test class=foo>
+  →   2 │   <img src=image.jpg>
+        │                 ~
+      3 │ </div>
+      4 │
+
+ Rule offenses:
+  parser-no-errors (1 offense in 1 file)
+
+
+ Summary:
+  Checked      1 file
+  Offenses     1 error | 0 warnings (1 offense across 1 file)
+  Fixable      1 offense"
 `;
 
 exports[`CLI Output Formatting > displays most violated rules with multiple offenses 1`] = `
@@ -116,7 +175,7 @@ test/fixtures/multiple-rule-offenses.html.erb:10:4
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/14] ⎯⎯⎯⎯
 
-[warning] Attribute \`class\` uses single quotes. Prefer double quotes for HTML attribute values: \`class=""\`. (html-attribute-double-quotes)
+[warning] Attribute \`class\` uses single quotes. Prefer double quotes for HTML attribute values: \`class=""\`. [Correctable] (html-attribute-double-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:20
 
@@ -130,7 +189,7 @@ test/fixtures/multiple-rule-offenses.html.erb:3:20
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/14] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`id="test1"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`id="test1"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:8
 
@@ -144,7 +203,7 @@ test/fixtures/multiple-rule-offenses.html.erb:3:8
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/14] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`data-value="bar"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`data-value="bar"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/multiple-rule-offenses.html.erb:3:34
 
@@ -256,7 +315,7 @@ test/fixtures/multiple-rule-offenses.html.erb:10:4
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [13/14] ⎯⎯⎯⎯
 
-[error] Use \`<img>\` instead of self-closing \`<img />\` for HTML compatibility. (html-no-self-closing)
+[error] Use \`<img>\` instead of self-closing \`<img />\` for HTML compatibility. [Correctable] (html-no-self-closing)
 
 test/fixtures/multiple-rule-offenses.html.erb:4:2
 
@@ -279,49 +338,50 @@ test/fixtures/multiple-rule-offenses.html.erb:4:2
 
  Summary:
   Checked      1 file
-  Offenses     10 errors | 4 warnings (14 offenses across 1 file)"
+  Offenses     10 errors | 4 warnings (14 offenses across 1 file)
+  Fixable      14 offenses | 4 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > displays rule offenses when showing all rules 1`] = `
-"[error] Attribute value should be quoted: \`id="test"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+"[error] Attribute value should be quoted: \`id="test"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:2:8
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
   →   2 │ <div id=test class=foo>
         │         ~~~~
-      3 │   <img src=image.jpg>
+      3 │   <img src=image>
       4 │ </div>
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/6] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`class="foo"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`class="foo"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:2:19
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
   →   2 │ <div id=test class=foo>
         │                    ~~~
-      3 │   <img src=image.jpg>
+      3 │   <img src=image>
       4 │ </div>
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/6] ⎯⎯⎯⎯
 
-[error] Attribute value should be quoted: \`src="image"\`. Always wrap attribute values in quotes. (html-attribute-values-require-quotes)
+[error] Attribute value should be quoted: \`src="image"\`. Always wrap attribute values in quotes. [Correctable] (html-attribute-values-require-quotes)
 
 test/fixtures/few-rule-offenses.html.erb:3:11
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
       2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
+  →   3 │   <img src=image>
         │            ~~~~~
       4 │ </div>
       5 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [3/6] ⎯⎯⎯⎯
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -329,13 +389,13 @@ test/fixtures/few-rule-offenses.html.erb:3:3
 
       1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
       2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
+  →   3 │   <img src=image>
         │    ~~~
       4 │ </div>
       5 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [4/6] ⎯⎯⎯⎯
 
 [error] Duplicate ID \`duplicate\` found. IDs must be unique within a document. (html-no-duplicate-ids)
 
@@ -348,7 +408,7 @@ test/fixtures/few-rule-offenses.html.erb:9:5
      10 │
 
 
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/7] ⎯⎯⎯⎯
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [5/6] ⎯⎯⎯⎯
 
 [error] Heading element \`<h1>\` must not be empty. Provide accessible text content for screen readers and SEO. (html-no-empty-headings)
 
@@ -361,39 +421,25 @@ test/fixtures/few-rule-offenses.html.erb:6:0
       7 │ 
       8 │ <div id="duplicate"></div>
 
-
-⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [6/7] ⎯⎯⎯⎯
-
-[error] Unexpected Token. Expected: \`TOKEN_IDENTIFIER, TOKEN_AT, TOKEN_ERB_START,TOKEN_WHITESPACE, or TOKEN_NEWLINE\`, found: \`TOKEN_CHARACTER\`. (\`UNEXPECTED_ERROR\`) (parser-no-errors)
-
-test/fixtures/few-rule-offenses.html.erb:3:16
-
-      1 │ <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
-      2 │ <div id=test class=foo>
-  →   3 │   <img src=image.jpg>
-        │                 ~
-      4 │ </div>
-      5 │
-
  Rule offenses:
   html-attribute-values-require-quotes (3 offenses in 1 file)
   html-img-require-alt (1 offense in 1 file)
   html-no-duplicate-ids (1 offense in 1 file)
   html-no-empty-headings (1 offense in 1 file)
-  parser-no-errors (1 offense in 1 file)
 
 
  Summary:
   Checked      1 file
-  Offenses     7 errors | 0 warnings (7 offenses across 1 file)"
+  Offenses     6 errors | 0 warnings (6 offenses across 1 file)
+  Fixable      6 offenses | 3 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for bad file 1`] = `
-"::error file=test/fixtures/bad-file.html.erb,line=1,col=1,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:1%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │  ~~~~%0A      2 │%0A
+"::error file=test/fixtures/bad-file.html.erb,line=1,col=1,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:1%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │  ~~~~%0A      2 │%0A
 
-::error file=test/fixtures/bad-file.html.erb,line=1,col=16,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:16%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │                 ~~~~%0A      2 │%0A
+::error file=test/fixtures/bad-file.html.erb,line=1,col=16,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/bad-file.html.erb:1:16%0A%0A  →   1 │ <SPAN>Bad file</SPAN>%0A        │                 ~~~~%0A      2 │%0A
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:1
 
@@ -404,7 +450,7 @@ test/fixtures/bad-file.html.erb:1:1
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:16
 
@@ -418,7 +464,8 @@ test/fixtures/bad-file.html.erb:1:16
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for clean file 1`] = `
@@ -431,11 +478,11 @@ exports[`CLI Output Formatting > formats GitHub Actions output correctly for cle
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output correctly for file with errors 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -451,7 +498,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -464,7 +511,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -481,11 +528,12 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats GitHub Actions output with --format=github option 1`] = `
-"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-simple.html.erb:2:3
 
@@ -498,7 +546,7 @@ test/fixtures/test-file-simple.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-simple.html.erb:2:22
 
@@ -514,7 +562,8 @@ test/fixtures/test-file-simple.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`] = `
@@ -561,8 +610,9 @@ exports[`CLI Output Formatting > formats JSON output correctly for bad file 1`]
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 31,
+    "ruleCount": 39,
     "totalErrors": 2,
+    "totalIgnored": 0,
     "totalOffenses": 2,
     "totalWarnings": 0,
   },
@@ -579,8 +629,9 @@ exports[`CLI Output Formatting > formats JSON output correctly for clean file 1`
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 0,
-    "ruleCount": 31,
+    "ruleCount": 39,
     "totalErrors": 0,
+    "totalIgnored": 0,
     "totalOffenses": 0,
     "totalWarnings": 0,
   },
@@ -649,8 +700,9 @@ exports[`CLI Output Formatting > formats JSON output correctly for file with err
   "summary": {
     "filesChecked": 1,
     "filesWithOffenses": 1,
-    "ruleCount": 31,
+    "ruleCount": 39,
     "totalErrors": 3,
+    "totalIgnored": 0,
     "totalOffenses": 3,
     "totalWarnings": 0,
   },
@@ -673,7 +725,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -686,7 +738,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -703,13 +755,14 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats simple output correctly 1`] = `
 "test/fixtures/test-file-simple.html.erb:
-  2:3  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
-  2:22 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+  2:3  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase) [Correctable]
+  2:22 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase) [Correctable]
 
  Rule offenses:
   html-tag-name-lowercase (2 offenses in 1 file)
@@ -717,13 +770,14 @@ exports[`CLI Output Formatting > formats simple output correctly 1`] = `
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats simple output for bad-file correctly 1`] = `
 "test/fixtures/bad-file.html.erb:
-  1:1  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
-  1:16 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+  1:1  ✗ Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase) [Correctable]
+  1:16 ✗ Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase) [Correctable]
 
  Rule offenses:
   html-tag-name-lowercase (2 offenses in 1 file)
@@ -731,7 +785,8 @@ exports[`CLI Output Formatting > formats simple output for bad-file correctly 1`
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > formats success output correctly 1`] = `
@@ -743,8 +798,17 @@ exports[`CLI Output Formatting > formats success output correctly 1`] = `
   Offenses     0 offenses"
 `;
 
+exports[`CLI Output Formatting > handles boolean attributes 1`] = `
+"✓ test/fixtures/boolean-attribute.html.erb - No issues found
+
+
+ Summary:
+  Checked      1 file
+  Offenses     0 offenses"
+`;
+
 exports[`CLI Output Formatting > handles multiple errors correctly 1`] = `
-"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+"[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:1
 
@@ -755,7 +819,7 @@ test/fixtures/bad-file.html.erb:1:1
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/2] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/bad-file.html.erb:1:16
 
@@ -769,15 +833,16 @@ test/fixtures/bad-file.html.erb:1:16
 
  Summary:
   Checked      1 file
-  Offenses     2 errors | 0 warnings (2 offenses across 1 file)"
+  Offenses     2 errors | 0 warnings (2 offenses across 1 file)
+  Fixable      2 offenses | 2 autocorrectable using \`--fix\`"
 `;
 
 exports[`CLI Output Formatting > uses GitHub Actions format by default when GITHUB_ACTIONS is true 1`] = `
-"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.4::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
+"::error file=test/fixtures/test-file-with-errors.html.erb,line=3,col=3,title=html-img-require-alt • @herb-tools/linter@0.7.5::Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. [html-img-require-alt]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:3:3%0A%0A      1 │ <div>%0A      2 │   <SPAN>Test content</SPAN>%0A  →   3 │   <img src="test.jpg">%0A        │    ~~~%0A      4 │ </div>%0A      5 │%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=3,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:3%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │    ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
-::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.4::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
+::error file=test/fixtures/test-file-with-errors.html.erb,line=2,col=22,title=html-tag-name-lowercase • @herb-tools/linter@0.7.5::Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [html-tag-name-lowercase]%0A%0A%0Atest/fixtures/test-file-with-errors.html.erb:2:22%0A%0A      1 │ <div>%0A  →   2 │   <SPAN>Test content</SPAN>%0A        │                       ~~~~%0A      3 │   <img src="test.jpg">%0A      4 │ </div>%0A
 
 [error] Missing required \`alt\` attribute on \`<img>\` tag. Add \`alt=""\` for decorative images or \`alt="description"\` for informative images. (html-img-require-alt)
 
@@ -793,7 +858,7 @@ test/fixtures/test-file-with-errors.html.erb:3:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [1/3] ⎯⎯⎯⎯
 
-[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. (html-tag-name-lowercase)
+[error] Opening tag name \`<SPAN>\` should be lowercase. Use \`<span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:3
 
@@ -806,7 +871,7 @@ test/fixtures/test-file-with-errors.html.erb:2:3
 
 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  [2/3] ⎯⎯⎯⎯
 
-[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. (html-tag-name-lowercase)
+[error] Closing tag name \`</SPAN>\` should be lowercase. Use \`</span>\` instead. [Correctable] (html-tag-name-lowercase)
 
 test/fixtures/test-file-with-errors.html.erb:2:22
 
@@ -823,5 +888,6 @@ test/fixtures/test-file-with-errors.html.erb:2:22
 
  Summary:
   Checked      1 file
-  Offenses     3 errors | 0 warnings (3 offenses across 1 file)"
+  Offenses     3 errors | 0 warnings (3 offenses across 1 file)
+  Fixable      3 offenses | 2 autocorrectable using \`--fix\`"
 `;
diff --git a/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts
new file mode 100644
index 000000000..668e9827b
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-no-extra-newline.autofix.test.ts
@@ -0,0 +1,283 @@
+import dedent from "dedent"
+
+import { describe, test, expect, beforeAll } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { ERBNoExtraNewLineRule } from "../../src/rules/erb-no-extra-newline.js"
+
+describe("erb-no-extra-newline autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes extra blank lines in text content", () => {
+    const input = dedent`
+      line 1
+
+
+
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify when only two blank lines present", () => {
+    const input = dedent`
+      line 1
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify when only three blank lines present", () => {
+    const input = dedent`
+      line 1
+
+
+      line 2
+    `
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes multiple occurrences of extra blank lines", () => {
+    const input = dedent`
+      line 1
+
+
+
+      line 2
+
+
+
+      line 3
+    `
+
+    const expected = dedent`
+      line 1
+
+
+      line 2
+
+
+      line 3
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes many consecutive blank lines", () => {
+    const input = dedent`
+      line 1
+
+
+
+
+      line 2
+    `
+
+    const expected = dedent`
+      line 1
+
+
+      line 2
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles HTML elements with extra blank lines", () => {
+    const input = dedent`
+      <div>Hello</div>
+
+
+
+      <div>World</div>
+    `
+
+    const expected = dedent`
+      <div>Hello</div>
+
+
+      <div>World</div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles ERB tags with extra blank lines", () => {
+    const input = dedent`
+      <%= content %>
+
+
+
+      <%= other_content %>
+    `
+
+    const expected = dedent`
+      <%= content %>
+
+
+      <%= other_content %>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not modify file with no extra blank lines", () => {
+    const input = dedent`
+      line 1
+      line 2
+      line 3
+    `
+
+    const expected = dedent`
+      line 1
+      line 2
+      line 3
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles empty file", () => {
+    const input = ''
+    const expected = ''
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles file with only newlines", () => {
+    const input = '\n\n\n\n\n'
+    const expected = '\n\n\n'
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("preserves content before and after extra blank lines", () => {
+    const input = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("preserves content before and after extra blank lines", () => {
+    const input = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const expected = dedent`
+      <div>
+        <h1>Title</h1>
+
+
+        <p>Content</p>
+      </div>
+    `
+
+    const linter = new Linter(Herb, [ERBNoExtraNewLineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts
new file mode 100644
index 000000000..d598ea87b
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-require-trailing-newline.autofix.test.ts
@@ -0,0 +1,99 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { ERBRequireTrailingNewlineRule } from "../../src/rules/erb-require-trailing-newline.js"
+
+describe("erb-require-trailing-newline autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds trailing newline to file without one", () => {
+    const input = '<div>Hello World</div>'
+    const expected = '<div>Hello World</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("does not add newline if already present", () => {
+    const input = '<div>Hello World</div>\n'
+    const expected = '<div>Hello World</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("handles multi-line files", () => {
+    const input = dedent`
+      <div>
+        <span>Hello</span>
+      </div>`
+
+    const expected = dedent`
+      <div>
+        <span>Hello</span>
+      </div>
+    ` + '\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles file with ERB tags", () => {
+    const input = '<div><%= content %></div>'
+    const expected = '<div><%= content %></div>\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles empty file", () => {
+    const input = ''
+    const expected = ''
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("removes redundant trailing newline", () => {
+    const input = '<div>Hello</div>\n\n'
+    const expected = '<div>Hello</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes redundant trailing newlines", () => {
+    const input = '<div>Hello</div>\n\n\n\n\n\n'
+    const expected = '<div>Hello</div>\n'
+
+    const linter = new Linter(Herb, [ERBRequireTrailingNewlineRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts
new file mode 100644
index 000000000..c86abef80
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-require-whitespace-inside-tags.autofix.test.ts
@@ -0,0 +1,142 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import dedent from "dedent"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { ERBRequireWhitespaceRule } from "../../src/rules/erb-require-whitespace-inside-tags.js"
+
+describe("erb-require-whitespace-inside-tags autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds space after opening tag", () => {
+    const input = '<%if true %>\n<% end %>'
+    const expected = '<% if true %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("adds space before closing tag", () => {
+    const input = '<% if admin%>\n<% end %>'
+    const expected = '<% if admin %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("adds spaces after opening and before closing", () => {
+    const input = '<%if true%><% end %>'
+    const expected = '<% if true %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes ERB output tags", () => {
+    const input = '<%=user.name%>'
+    const expected = '<%= user.name %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes ERB comment tags", () => {
+    const input = '<%#This is a comment%>'
+    const expected = '<%# This is a comment %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes multiple ERB tags", () => {
+    const input = dedent`
+      <%if admin%>
+        Hello, <%=user.name%>.
+      <%end%>
+    `
+
+    const expected = dedent`
+      <% if admin %>
+        Hello, <%= user.name %>.
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(6)
+  })
+
+  test("preserves already correct whitespace", () => {
+    const input = '<% if admin %>\n  Hello\n<% end %>'
+    const expected = '<% if admin %>\n  Hello\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("handles tags with newlines", () => {
+    const input = '<%\n  if admin\n%><% end %>'
+    const expected = '<%\n  if admin\n%><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("fixes only opening whitespace when needed", () => {
+    const input = '<%if user %><% end %>'
+    const expected = '<% if user %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("fixes only closing whitespace when needed", () => {
+    const input = '<% if admin%><% end %>'
+    const expected = '<% if admin %><% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles mixed correct and incorrect tags", () => {
+    const input = '<% if admin %>\n  <%=name%>\n<% end %>'
+    const expected = '<% if admin %>\n  <%= name %>\n<% end %>'
+
+    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
new file mode 100644
index 000000000..6a933c8e6
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/erb-right-trim.autofix.test.ts
@@ -0,0 +1,242 @@
+import dedent from "dedent"
+
+import { describe, test, expect, beforeAll } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { ERBRightTrimRule } from "../../src/rules/erb-right-trim.js"
+
+describe("erb-right-trim autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("when the erb tag close with %>", () => {
+    const input = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when output erb tag closes with -%>", () => {
+    const input = dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when non-output tag uses -%>", () => {
+    const input = dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% elsif other_condition -%>
+        <p>Content</p>
+      <% elsif yet_another_condition -%>
+        <p>Content</p>
+      <% else -%>
+        <p>Content</p>
+      <% end -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when the erb tag close with =%>", () => {
+    const input = dedent`
+      <h1>
+        <%= title =%>
+      </h1>
+    `
+
+    const expected = dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when an if block uses =%>", () => {
+    const input = dedent`
+      <% if condition =%>
+        <p>Content</p>
+      <% end =%>
+    `
+
+    const expected = dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% end -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when a loop uses =%>", () => {
+    const input = dedent`
+      <% items.each do |item| =%>
+        <li><%= item %></li>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% items.each do |item| -%>
+        <li><%= item %></li>
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when multiple lines use =%>", () => {
+    const input = dedent`
+      <%= first =%>
+      <%= second =%>
+      <%= third =%>
+    `
+
+    const expected = dedent`
+      <%= first -%>
+      <%= second -%>
+      <%= third -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when mixed valid and invalid syntax is used", () => {
+    const input = dedent`
+      <%= valid %>
+      <%= invalid_trim =%>
+      <%= valid_trim -%>
+      <%= another_invalid =%>
+    `
+
+    const expected = dedent`
+      <%= valid %>
+      <%= invalid_trim -%>
+      <%= valid_trim -%>
+      <%= another_invalid -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("when silent ERB uses =%>", () => {
+    const input = dedent`
+      <% silent_operation =%>
+    `
+
+    const expected = dedent`
+      <% silent_operation -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles =%> in nested structures", () => {
+    const input = dedent`
+      <% if outer_condition =%>
+        <% if inner_condition =%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `
+
+    const expected = dedent`
+      <% if outer_condition -%>
+        <% if inner_condition -%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("<%- with -%>", () => {
+    const input = dedent`
+      <%- something -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("<%- with -%> in if/end", () => {
+    const input = dedent`
+      <%- if true -%>
+        Something
+      <%- end -%>
+    `
+
+    const linter = new Linter(Herb, [ERBRightTrimRule])
+    const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts
new file mode 100644
index 000000000..b4f559960
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-double-quotes.autofix.test.ts
@@ -0,0 +1,76 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeDoubleQuotesRule } from "../../src/rules/html-attribute-double-quotes.js"
+
+describe("html-attribute-double-quotes autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts single quotes to double quotes", () => {
+    const input = `<div class='container'>Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts multiple attributes with single quotes", () => {
+    const input = `<div class='container' id='main' data-value='test'>Content</div>`
+    const expected = `<div class="container" id="main" data-value="test">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class='outer'><span class='inner'>Text</span></div>`
+    const expected = `<div class="outer"><span class="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves content with special characters", () => {
+    const input = `<div data-text='Hello, World!'>Content</div>`
+    const expected = `<div data-text="Hello, World!">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles multiple lines", () => {
+    const input = dedent`
+      <div class='line1'>
+            <span id='line2'>Text</span>
+        </div>
+    `
+
+    const expected = dedent`
+      <div class="line1">
+            <span id="line2">Text</span>
+        </div>
+    `
+
+    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts
new file mode 100644
index 000000000..94dc0aa3b
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-equals-spacing.autofix.test.ts
@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeEqualsSpacingRule } from "../../src/rules/html-attribute-equals-spacing.js"
+
+describe("html-attribute-equals-spacing autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes space before equals", () => {
+    const input = `<div class ="container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes space after equals", () => {
+    const input = `<div class= "container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("removes spaces on both sides of equals", () => {
+    const input = `<div class = "container">Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple attributes", () => {
+    const input = `<div class ="outer" id= "main">Content</div>`
+    const expected = `<div class="outer" id="main">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class ="outer"><span id= "inner">Text</span></div>`
+    const expected = `<div class="outer"><span id="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts b/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts
new file mode 100644
index 000000000..ff6c1b2e9
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-attribute-values-require-quotes.autofix.test.ts
@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLAttributeValuesRequireQuotesRule } from "../../src/rules/html-attribute-values-require-quotes.js"
+
+describe("html-attribute-values-require-quotes autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("adds quotes to unquoted attribute value", () => {
+    const input = `<div class=container>Content</div>`
+    const expected = `<div class="container">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("adds quotes to multiple unquoted attributes", () => {
+    const input = `<div class=container id=main data-value=test>Content</div>`
+    const expected = `<div class="container" id="main" data-value="test">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles nested elements", () => {
+    const input = `<div class=outer><span id=inner>Text</span></div>`
+    const expected = `<div class="outer"><span id="inner">Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves already quoted attributes", () => {
+    const input = `<div class="quoted" id=unquoted>Content</div>`
+    const expected = `<div class="quoted" id="unquoted">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles numeric values", () => {
+    const input = `<input type=text maxlength=100>`
+    const expected = `<input type="text" maxlength="100">`
+
+    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts b/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts
new file mode 100644
index 000000000..b1db8ad37
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-boolean-attributes-no-value.autofix.test.ts
@@ -0,0 +1,121 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLBooleanAttributesNoValueRule } from "../../src/rules/html-boolean-attributes-no-value.js"
+
+describe("html-boolean-attributes-no-value autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("removes value from single boolean attribute", () => {
+    const input = '<input type="checkbox" checked="checked">'
+    const expected = '<input type="checkbox" checked>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes values from multiple boolean attributes", () => {
+    const input = '<input type="checkbox" checked="checked" disabled="disabled">'
+    const expected = '<input type="checkbox" checked disabled>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("removes value from boolean attribute with true/false", () => {
+    const input = '<button disabled="true">Submit</button>'
+    const expected = '<button disabled>Submit</button>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles self-closing tags", () => {
+    const input = '<input type="checkbox" checked="checked" required="true" />'
+    const expected = '<input type="checkbox" checked required />'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple elements with boolean attributes", () => {
+    const input = dedent`
+      <input checked="checked">
+      <button disabled="disabled">Click</button>
+      <video controls="controls" autoplay="autoplay"></video>
+    `
+
+    const expected = dedent`
+      <input checked>
+      <button disabled>Click</button>
+      <video controls autoplay></video>
+    `
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("preserves non-boolean attributes", () => {
+    const input = '<input type="text" value="test" checked="checked">'
+    const expected = '<input type="text" value="test" checked>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles video element boolean attributes", () => {
+    const input = '<video controls="controls" autoplay="autoplay" loop="loop" muted="muted"></video>'
+    const expected = '<video controls autoplay loop muted></video>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("handles select and option boolean attributes", () => {
+    const input = '<select multiple="multiple"><option selected="selected">Option</option></select>'
+    const expected = '<select multiple><option selected>Option</option></select>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles boolean attributes with different values", () => {
+    const input = '<video controls="something-else"></video>'
+    const expected = '<video controls></video>'
+
+    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts b/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts
new file mode 100644
index 000000000..bf239e188
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-no-self-closing.autofix.test.ts
@@ -0,0 +1,98 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js"
+
+describe("html-no-self-closing autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts self-closing void element", () => {
+    const input = '<br />'
+    const expected = '<br>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts self-closing non-void element to open/close pair", () => {
+    const input = '<div />'
+    const expected = '<div></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles multiple void elements", () => {
+    const input = '<br /><hr /><img />'
+    const expected = '<br><hr><img>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(3)
+  })
+
+  test("handles self-closing div with attributes", () => {
+    const input = '<div class="test" id="main" />'
+    const expected = '<div class="test" id="main"></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles self-closing input element", () => {
+    const input = '<input type="text" />'
+    const expected = '<input type="text">'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles mixed void and non-void elements", () => {
+    const input = '<div><br /><span /></div>'
+    const expected = '<div><br><span></span></div>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves whitespace before slash", () => {
+    const input = '<input type="text" />'
+    const expected = '<input type="text">'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("does not affect SVG elements", () => {
+    const input = '<svg><circle cx="50" cy="50" r="40" /></svg>'
+
+    const linter = new Linter(Herb, [HTMLNoSelfClosingRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts b/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts
new file mode 100644
index 000000000..8e69233f7
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-no-space-in-tag.autofix.test.ts
@@ -0,0 +1,410 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import { HTMLNoSpaceInTagRule } from "../../src/rules/html-no-space-in-tag.js"
+
+describe("html-no-space-in-tag autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  describe("when space is correct", () => {
+    test("void tag", () => {
+      const input = `<img />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("plain tag with attribute", () => {
+      const input = `<div class="foo"></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between attributes", () => {
+      const input = `<input class="foo" name="bar">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("tag with erb", () => {
+      const input = dedent`<input <%= attributes %>>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag with erb", () => {
+      const input = dedent`
+        <input
+          type="password"
+          <%= attributes %>
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("multi line tag with erb nested", () => {
+      const input = dedent`
+        <div>
+          <input
+            type="password"
+            <%= attributes %>
+            class="foo"
+          >
+        </div>
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(input)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when no space should be present", () => {
+    test("after name", () => {
+      const input = dedent`<div   ></div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("before name", () => {
+      const input = dedent`<   div></div>`
+      const expected = dedent`<   div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("before start solidus", () => {
+      const input = dedent`<div><   /div>`
+      const expected = dedent`<div><   /div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("after start solidus", () => {
+      const input = dedent`<div></   div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("after end solidus", () => {
+      const input = dedent`<div><div /   >`
+      const expected = dedent`<div><div /   >`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when space is missing", () => {
+    test("between attributes", () => {
+      const input = dedent`<div foo='foo'bar='bar'></div>`
+      const expected = dedent`<div foo='foo'bar='bar'></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and solidus", () => {
+      const input = dedent`<div foo='bar'/>`
+      const expected = dedent`<div foo='bar' />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and solidus", () => {
+      const input = `<div/>`
+      const expected = `<div />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+
+  describe("when extra space is present", () => {
+    test("between name and end of tag", () => {
+      const input = dedent`<div  ></div>`
+      const expected = dedent`<div></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and first attribute", () => {
+      const input = dedent`<img   class="hide">`
+      const expected = dedent`<img class="hide">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between name and end solidus", () => {
+      const input = dedent`<br   />`
+      const expected = dedent`<br />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and solidus", () => {
+      const input = dedent`<br class="hide"   />`
+      const expected = dedent`<br class="hide" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between last attribute and end of tag", () => {
+      const input = dedent`<img class="hide"    >`
+      const expected = dedent`<img class="hide">`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("between attributes", () => {
+      const input = dedent`<div foo='foo'      bar='bar'></div>`
+      const expected = dedent`<div foo='foo' bar='bar'></div>`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between name and first attribute", () => {
+      const input = dedent`
+        <input
+
+          type="password" />
+      `
+      const expected = dedent`
+        <input
+          type="password" />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between name and end of tag", () => {
+      const input = dedent`
+        <input
+
+          />
+      `
+      const expected = dedent`
+        <input
+        />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("extra newline between attributes", () => {
+      const input = dedent`
+        <input
+          type="password"
+
+          class="foo" />
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo" />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(2)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("end solidus is on newline", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+          />
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo"
+        />
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("end of tag is on newline", () => {
+      const input = dedent`
+        <input
+          type="password"
+          class="foo"
+          >
+      `
+      const expected = dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(1)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("non-space detected between name and attribute", () => {
+      const input = `<input/class="hide" />`
+      const expected = `<input/class="hide" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+
+    test("non-space detected between attributes", () => {
+      const input = `<input class="hide"/name="foo" />`
+      const expected = `<input class="hide"/name="foo" />`
+
+      const linter = new Linter(Herb, [HTMLNoSpaceInTagRule])
+      const result = linter.autofix(input, { fileName: 'test.html.erb' })
+
+      expect(result.source).toBe(expected)
+      expect(result.fixed).toHaveLength(0)
+      expect(result.unfixed).toHaveLength(0)
+    })
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts b/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts
new file mode 100644
index 000000000..ad46af233
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/html-tag-name-lowercase.autofix.test.ts
@@ -0,0 +1,109 @@
+import dedent from "dedent"
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { HTMLTagNameLowercaseRule } from "../../src/rules/html-tag-name-lowercase.js"
+
+describe("html-tag-name-lowercase autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("converts single uppercase tag to lowercase", () => {
+    const input = `<DIV>Hello</DIV>`
+    const expected = `<div>Hello</div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("converts mixed case tags", () => {
+    const input = `<Div><Span>Text</Span></Div>`
+    const expected = `<div><span>Text</span></div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("handles self-closing tags", () => {
+    const input = `<BR />`
+    const expected = `<br />`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+  })
+
+  test("handles nested uppercase tags", () => {
+    const input = `<DIV><UL><LI>Item 1</LI><LI>Item 2</LI></UL></DIV>`
+    const expected = `<div><ul><li>Item 1</li><li>Item 2</li></ul></div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(8)
+  })
+
+  test("preserves attributes when fixing tag names", () => {
+    const input = `<DIV class="container" id="main">Content</DIV>`
+    const expected = `<div class="container" id="main">Content</div>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("handles multiple root elements", () => {
+    const input = dedent`
+      <DIV>First</DIV>
+      <SPAN>Second</SPAN>
+      <P>Third</P>
+    `
+
+    const expected = dedent`
+      <div>First</div>
+      <span>Second</span>
+      <p>Third</p>
+    `
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(6)
+  })
+
+  test("handles form elements", () => {
+    const input = `<FORM><INPUT type="text"><BUTTON>Submit</BUTTON></FORM>`
+    const expected = `<form><input type="text"><button>Submit</button></form>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(5)
+  })
+
+  test("does not affect already lowercase SVG tags", () => {
+    const input = `<svg><linearGradient></linearGradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+})
diff --git a/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts b/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts
new file mode 100644
index 000000000..3990bdbdc
--- /dev/null
+++ b/javascript/packages/linter/test/autofix/svg-tag-name-capitalization.autofix.test.ts
@@ -0,0 +1,88 @@
+import { describe, test, expect, beforeAll } from "vitest"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+import { SVGTagNameCapitalizationRule } from "../../src/rules/svg-tag-name-capitalization.js"
+
+describe("svg-tag-name-capitalization autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("fixes lowercase SVG element to camelCase", () => {
+    const input = `<svg><lineargradient></lineargradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("fixes multiple SVG elements", () => {
+    const input = `<svg><lineargradient></lineargradient><radialgradient></radialgradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient><radialGradient></radialGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(4)
+  })
+
+  test("fixes clippath element", () => {
+    const input = `<svg><clippath></clippath></svg>`
+    const expected = `<svg><clipPath></clipPath></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes textpath element", () => {
+    const input = `<svg><textpath></textpath></svg>`
+    const expected = `<svg><textPath></textPath></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("fixes nested SVG elements", () => {
+    const input = `<svg><defs><lineargradient id="grad"><stop /></lineargradient></defs></svg>`
+    const expected = `<svg><defs><linearGradient id="grad"><stop /></linearGradient></defs></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+
+  test("preserves already correct camelCase elements", () => {
+    const input = `<svg><linearGradient></linearGradient></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(0)
+  })
+
+  test("fixes mixed case issues", () => {
+    const input = `<svg><LineArGrAdIeNt></LineArGrAdIeNt></svg>`
+    const expected = `<svg><linearGradient></linearGradient></svg>`
+
+    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+  })
+})
diff --git a/javascript/packages/linter/test/cli.test.ts b/javascript/packages/linter/test/cli.test.ts
index 4d1fa047f..07d576eb5 100644
--- a/javascript/packages/linter/test/cli.test.ts
+++ b/javascript/packages/linter/test/cli.test.ts
@@ -50,6 +50,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("handles boolean attributes", () => {
+    const { output, exitCode } = runLinter("boolean-attribute.html.erb", "--no-wrap-lines")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(0)
+  })
+
   test("formats success output correctly", () => {
     const { output, exitCode } = runLinter("clean-file.html.erb", "--no-wrap-lines")
 
@@ -78,6 +85,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("diplays only parsers errors if one is present", () => {
+    const { output, exitCode } = runLinter("parser-errors.html.erb", "--no-wrap-lines")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(1)
+  })
+
   test("enables line wrapping by default", () => {
     const { output } = runLinter("long-line.html.erb")
 
@@ -91,7 +105,7 @@ describe("CLI Output Formatting", () => {
   test("correctly passes filename context for file-specific rules", () => {
     const { output, exitCode } = runLinter("no-trailing-newline.html.erb", "--simple", "--no-wrap-lines")
 
-    expect(output).toContain("erb-requires-trailing-newline")
+    expect(output).toContain("erb-require-trailing-newline")
     expect(output).toContain("File must end with trailing newline")
     expect(exitCode).toBe(1)
   })
@@ -169,6 +183,13 @@ describe("CLI Output Formatting", () => {
     expect(exitCode).toBe(1)
   })
 
+  test("Ignores disabled rules", () => {
+    const { output, exitCode } = runLinter("ignored.html.erb")
+
+    expect(output).toMatchSnapshot()
+    expect(exitCode).toBe(1)
+  })
+
   test("rejects --github with --json format", () => {
     const { output, exitCode } = runLinter("test-file-with-errors.html.erb", "--json", "--github")
 
diff --git a/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb b/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb
new file mode 100644
index 000000000..94811a213
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/boolean-attribute.html.erb
@@ -0,0 +1,3 @@
+<div id="test" hidden>
+  <%= "hi" %>
+</div>
diff --git a/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb b/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
index 0f34a9d61..154f1ff6a 100644
--- a/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
+++ b/javascript/packages/linter/test/fixtures/few-rule-offenses.html.erb
@@ -1,6 +1,6 @@
 <!-- Just a few different rule offenses to test "Rule offenses:" vs "Most frequent rule offenses:" -->
 <div id=test class=foo>
-  <img src=image.jpg>
+  <img src=image>
 </div>
 
 <h1></h1>
diff --git a/javascript/packages/linter/test/fixtures/ignored.html.erb b/javascript/packages/linter/test/fixtures/ignored.html.erb
new file mode 100644
index 000000000..45d0bfa4d
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/ignored.html.erb
@@ -0,0 +1,9 @@
+<div>
+  <h1 class="<%= classes %>">
+    <%= title %>
+  </h1>
+
+  <DIV>hello</DIV>
+  <DIV>hello</DIV> <%# herb:disable html-tag-name-lowercase %>
+  <% %> <%# herb:disable erb-no-empty-tags %>
+</div>
diff --git a/javascript/packages/linter/test/fixtures/parser-errors.html.erb b/javascript/packages/linter/test/fixtures/parser-errors.html.erb
new file mode 100644
index 000000000..ca9fc1295
--- /dev/null
+++ b/javascript/packages/linter/test/fixtures/parser-errors.html.erb
@@ -0,0 +1,3 @@
+<div id=test class=foo>
+  <img src=image.jpg>
+</div>
diff --git a/javascript/packages/linter/test/helpers/linter-test-helper.ts b/javascript/packages/linter/test/helpers/linter-test-helper.ts
new file mode 100644
index 000000000..e1f47e95b
--- /dev/null
+++ b/javascript/packages/linter/test/helpers/linter-test-helper.ts
@@ -0,0 +1,283 @@
+import { beforeAll, afterEach, expect } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../../src/linter.js"
+
+import type { RuleClass } from "../../src/types.js"
+
+interface ExpectedLocation {
+  line?: number
+  column?: number
+}
+
+type LocationInput = ExpectedLocation | [number, number] | [number]
+
+interface ExpectedOffense {
+  message: string
+  location?: ExpectedLocation
+}
+
+interface TestOptions {
+  context?: any
+  allowInvalidSyntax?: boolean
+}
+
+interface LinterTestHelpers {
+  expectNoOffenses: (html: string, options?: any | TestOptions) => void
+  expectWarning: (message: string, location?: LocationInput) => void
+  expectError: (message: string, location?: LocationInput) => void
+  assertOffenses: (html: string, options?: any | TestOptions) => void
+}
+
+/**
+ * Creates a test helper for linter rules that reduces boilerplate in tests.
+ *
+ * @param ruleClass - The rule class to test
+ * @returns Object with helper functions for testing
+ *
+ * @example
+ * ```ts
+ * const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(MyRule)
+ *
+ * test("valid case", () => {
+ *   expectNoOffenses(`<%= title %>`)
+ * })
+ *
+ * test("invalid case", () => {
+ *   expectError("Error message", { line: 1, column: 1 })
+ *   // or use array syntax
+ *   expectError("Error message", [1, 1])
+ *
+ *   assertOffenses(`<% %>`)
+ * })
+ * ```
+ */
+export function createLinterTest(ruleClass: RuleClass): LinterTestHelpers {
+  const expectedWarnings: ExpectedOffense[] = []
+  const expectedErrors: ExpectedOffense[] = []
+  let hasAsserted = false
+  const ruleInstance = new ruleClass()
+  const isParserNoErrorsRule = ruleInstance.name === "parser-no-errors"
+
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  afterEach(() => {
+    if (!hasAsserted && (expectedWarnings.length > 0 || expectedErrors.length > 0)) {
+      const pendingCount = expectedWarnings.length + expectedErrors.length
+
+      throw new Error(
+        `Test has ${pendingCount} pending expectation(s) that were never asserted. ` +
+        `Did you forget to call assertOffenses() or expectNoOffenses()?`
+      )
+    }
+
+    expectedWarnings.length = 0
+    expectedErrors.length = 0
+    hasAsserted = false
+  })
+
+  const expectNoOffenses = (html: string, options?: any | TestOptions) => {
+    if (expectedWarnings.length > 0 || expectedErrors.length > 0) {
+      throw new Error(
+        "Cannot call expectNoOffenses() after registering expectations with expectWarning() or expectError()"
+      )
+    }
+
+    hasAsserted = true
+
+    const context = options?.context ?? options
+    const allowInvalidSyntax = options?.allowInvalidSyntax ?? false
+
+    if (!isParserNoErrorsRule) {
+      const parseResult = Herb.parse(html, { track_whitespace: true })
+      const parserErrors = parseResult.recursiveErrors()
+
+      if (allowInvalidSyntax && parserErrors.length === 0) {
+        throw new Error(
+          `Test has 'allowInvalidSyntax: true' but the HTML is actually valid.\n` +
+          `Remove the 'allowInvalidSyntax' option since the HTML parses without errors.\n` +
+          `Source:\n${html}`
+        )
+      }
+
+      if (!allowInvalidSyntax && parserErrors.length > 0) {
+        const formattedErrors = parserErrors.map(error => `  - ${error.message} (${error.type}) at ${error.location.start.line}:${error.location.start.column}`).join('\n')
+
+        throw new Error(
+          `Test HTML has parser errors. Fix the HTML before testing the linter rule.\n` +
+          `Source:\n${html}\n\n` +
+          `Parser errors:\n${formattedErrors}`
+        )
+      }
+    }
+
+    const linter = new Linter(Herb, [ruleClass])
+    const lintResult = linter.lint(html, context)
+
+    expect(lintResult.errors).toBe(0)
+    expect(lintResult.warnings).toBe(0)
+    expect(lintResult.offenses).toHaveLength(0)
+  }
+
+  const normalizeLocation = (location?: LocationInput): ExpectedLocation | undefined => {
+    if (!location) return undefined
+    if (Array.isArray(location)) {
+      return location.length === 2
+        ? { line: location[0], column: location[1] }
+        : { line: location[0] }
+    }
+    return location
+  }
+
+  const expectWarning = (message: string, location?: LocationInput) => {
+    expectedWarnings.push({ message, location: normalizeLocation(location) })
+  }
+
+  const expectError = (message: string, location?: LocationInput) => {
+    expectedErrors.push({ message, location: normalizeLocation(location) })
+  }
+
+  const assertOffenses = (html: string, options?: any | TestOptions) => {
+    if (expectedWarnings.length === 0 && expectedErrors.length === 0) {
+      throw new Error(
+        "Cannot call assertOffenses() with no expectations. Use expectNoOffenses() instead."
+      )
+    }
+
+    hasAsserted = true
+
+    const context = options?.context ?? options
+    const allowInvalidSyntax = options?.allowInvalidSyntax ?? false
+
+    if (!isParserNoErrorsRule) {
+      const parseResult = Herb.parse(html, { track_whitespace: true })
+      const parserErrors = parseResult.recursiveErrors()
+
+      if (allowInvalidSyntax && parserErrors.length === 0) {
+        throw new Error(
+          `Test has 'allowInvalidSyntax: true' but the HTML is actually valid.\n` +
+          `Remove the 'allowInvalidSyntax' option since the HTML parses without errors.\n` +
+          `Source:\n${html}`
+        )
+      }
+
+      if (!allowInvalidSyntax && parserErrors.length > 0) {
+        const formattedErrors = parserErrors.map(error => `  - ${error.message} (${error.type}) at ${error.location.start.line}:${error.location.start.column}`).join('\n')
+
+        throw new Error(
+          `Test HTML has parser errors. Fix the HTML before testing the linter rule.\n` +
+          `Source:\n${html}\n\n` +
+          `Parser errors:\n${formattedErrors}`
+        )
+      }
+    }
+
+    const linter = new Linter(Herb, [ruleClass])
+    const lintResult = linter.lint(html, context)
+
+    const ruleName = ruleInstance.name
+
+    if (lintResult.errors !== expectedErrors.length) {
+      throw new Error(
+        `Expected ${expectedErrors.length} error(s) but found ${lintResult.errors}.\n` +
+        `Expected:\n${expectedErrors.map(e => `  - "${e.message}"`).join('\n')}\n` +
+        `Actual:\n${lintResult.offenses.filter(o => o.severity === 'error').map(o => `  - "${o.message}" at ${o.location.start.line}:${o.location.start.column}`).join('\n')}`
+      )
+    }
+
+    if (lintResult.warnings !== expectedWarnings.length) {
+      throw new Error(
+        `Expected ${expectedWarnings.length} warning(s) but found ${lintResult.warnings}.\n` +
+        `Expected:\n${expectedWarnings.map(w => `  - "${w.message}"`).join('\n')}\n` +
+        `Actual:\n${lintResult.offenses.filter(o => o.severity === 'warning').map(o => `  - "${o.message}" at ${o.location.start.line}:${o.location.start.column}`).join('\n')}`
+      )
+    }
+
+    lintResult.offenses.forEach(offense => {
+      expect(offense.rule).toBe(ruleName)
+    })
+
+    const actualErrors = lintResult.offenses.filter(o => o.severity === "error")
+    const actualWarnings = lintResult.offenses.filter(o => o.severity === "warning")
+
+    matchOffenses(expectedErrors, actualErrors, "error")
+    matchOffenses(expectedWarnings, actualWarnings, "warning")
+
+    expectedWarnings.length = 0
+    expectedErrors.length = 0
+  }
+
+  return {
+    expectNoOffenses,
+    expectWarning,
+    expectError,
+    assertOffenses
+  }
+}
+
+/**
+ * Matches expected offenses to actual offenses in an order-independent way
+ */
+function matchOffenses(
+  expected: ExpectedOffense[],
+  actual: any[],
+  severity: "error" | "warning"
+) {
+  const unmatched = [...expected]
+  const unmatchedActual = [...actual]
+
+  for (const actualOffense of actual) {
+    const matchIndex = unmatched.findIndex(exp => {
+      if (exp.message !== actualOffense.message) {
+        return false
+      }
+
+      if (exp.location?.line !== undefined && exp.location.line !== actualOffense.location.start.line) {
+        return false
+      }
+
+      if (exp.location?.column !== undefined && exp.location.column !== actualOffense.location.start.column) {
+        return false
+      }
+
+      return true
+    })
+
+    if (matchIndex !== -1) {
+      unmatched.splice(matchIndex, 1)
+      const actualIndex = unmatchedActual.findIndex(o => o === actualOffense)
+      if (actualIndex !== -1) {
+        unmatchedActual.splice(actualIndex, 1)
+      }
+    }
+  }
+
+  if (unmatched.length > 0 || unmatchedActual.length > 0) {
+    const errors: string[] = []
+
+    if (unmatched.length > 0) {
+      errors.push(`Expected ${severity}(s) not found:`)
+      unmatched.forEach(exp => {
+        const location = exp.location?.line !== undefined
+          ? exp.location?.column !== undefined
+            ? ` at ${exp.location.line}:${exp.location.column}`
+            : ` at line ${exp.location.line}`
+          : ""
+        errors.push(`  - "${exp.message}"${location}`)
+      })
+    }
+
+    if (unmatchedActual.length > 0) {
+      errors.push(`Unexpected ${severity}(s) found:`)
+      unmatchedActual.forEach(offense => {
+        errors.push(
+          `  - "${offense.message}" at ${offense.location.start.line}:${offense.location.start.column}`
+        )
+      })
+    }
+
+    throw new Error(errors.join("\n"))
+  }
+}
diff --git a/javascript/packages/linter/test/linter.test.ts b/javascript/packages/linter/test/linter.test.ts
index ff64a9784..bfcd750ff 100644
--- a/javascript/packages/linter/test/linter.test.ts
+++ b/javascript/packages/linter/test/linter.test.ts
@@ -193,5 +193,14 @@ describe("@herb-tools/linter", () => {
       expect(result2.offenses).toHaveLength(1)
       expect(result2.offenses[0].rule).toBe("content-based-rule")
     })
+
+    test("can disable a rule with a comment", () => {
+      const html = '<DIV>test</DIV> <%# herb:disable html-tag-name-lowercase %>'
+      const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
+      const lintResult = linter.lint(html)
+
+      expect(lintResult.offenses).toHaveLength(0)
+      expect(lintResult.ignored).toBe(2)
+    })
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
new file mode 100644
index 000000000..6b2824316
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-comment-syntax.test.ts
@@ -0,0 +1,49 @@
+import dedent from "dedent"
+import { describe, test } from "vitest"
+import { ERBCommentSyntax } from "../../src/rules/erb-comment-syntax.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBCommentSyntax)
+
+describe("ERBCommentSyntax", () => {
+  test("when the ERB comment syntax is correct", () => {
+    expectNoOffenses(dedent`
+      <%# good comment %>
+    `)
+  })
+
+  test("when the ERB multi-line comment syntax is correct", () => {
+    expectNoOffenses(dedent`
+      <%
+        # good comment
+      %>
+    `)
+  })
+
+  test("when the ERB multi-line comment syntax is correct with multiple comment lines", () => {
+    expectNoOffenses(dedent`
+      <%
+        # good comment
+        # good comment
+      %>
+    `)
+  })
+
+  test("when the ERB comment syntax is incorrect", () => {
+    expectError("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+
+    assertOffenses(dedent`
+      <% # bad comment %>
+    `)
+  })
+
+  test("when the ERB comment syntax is incorrect multiple times in one file", () => {
+    expectError("Use `<%#` instead of `<% #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+    expectError("Use `<%#` instead of `<%= #`. Ruby comments immediately after ERB tags can cause parsing issues.")
+
+    assertOffenses(dedent`
+      <% # first bad comment %>
+      <%= # second bad comment %>
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts b/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts
new file mode 100644
index 000000000..bc351e24f
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-no-case-node-children.test.ts
@@ -0,0 +1,181 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+
+import { ERBNoCaseNodeChildrenRule } from "../../src/rules/erb-no-case-node-children.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoCaseNodeChildrenRule)
+
+describe("ERBNoCaseNodeChildrenRule", () => {
+  describe("case/when", () => {
+    test("valid case/when with no children", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with only whitespace children", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with newline", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with HTML comment", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+          <!-- This is a comment -->
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/when with ERB comment", () => {
+      expectNoOffenses(dedent`
+        <% case count %>
+          <%# This is an ERB comment %>
+        <% when 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with HTML content", () => {
+      expectError("Do not place `<h1>Content</h1>` between `<% case count %>` and `<% when 1 %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case count %>
+          <h1>Content</h1>
+        <% when 1 %>
+          1
+        <% when 2 %>
+          2
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with text content", () => {
+      expectError("Do not place `This content is outside of any when/else block!` between `<% case variable %>` and `<% when \"a\" %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case variable %>
+          This content is outside of any when/else block!
+        <% when "a" %>
+          A
+        <% when "b" %>
+          B
+        <% end %>
+      `)
+    })
+
+    test("invalid case/when with mixed content", () => {
+      expectError("Do not place `<div>Invalid</div>` between `<% case status %>` and `<% when :active %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case status %>
+          <div>Invalid</div>
+        <% when :active %>
+          Active
+        <% end %>
+      `)
+    })
+  })
+
+  describe("case/in", () => {
+    test("valid case/in with no children", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% else %>
+          Other
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with only whitespace children", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with HTML comment", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+          <!-- Comment -->
+        <% in 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("valid case/in with ERB comment", () => {
+      expectNoOffenses(dedent`
+        <% case value %>
+          <%# Comment %>
+        <% in 1 %>
+          One
+        <% end %>
+      `)
+    })
+
+    test("invalid case/in with HTML content", () => {
+      expectError("Do not place `<p>Should not be here</p>` between `<% case value %>` and `<% in 1 %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case value %>
+          <p>Should not be here</p>
+        <% in 1 %>
+          One
+        <% in 2 %>
+          Two
+        <% end %>
+      `)
+    })
+
+    test("invalid case/in with text content", () => {
+      expectError("Do not place `Orphaned text` between `<% case value %>` and `<% in \"a\" %>`. Content here is not part of any branch and will not be rendered.")
+
+      assertOffenses(dedent`
+        <% case value %>
+          Orphaned text
+        <% in "a" %>
+          A
+        <% end %>
+      `)
+    })
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
index 0034528db..b96873209 100644
--- a/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-empty-tags.test.ts
@@ -1,19 +1,13 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { ERBNoEmptyTagsRule } from "../../src/rules/erb-no-empty-tags.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBNoEmptyTagsRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoEmptyTagsRule)
 
+describe("ERBNoEmptyTagsRule", () => {
   test("should not report errors for valid ERB tags with content", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>
         <%= title %>
       </h1>
@@ -27,78 +21,50 @@ describe("ERBNoEmptyTagsRule", () => {
       <% end %>
 
       <%= "" %>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should not report errors for incomplete erb tags", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { allowInvalidSyntax: true })
   })
 
   test("should not report errors for incomplete erb output tags", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <%=
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { allowInvalidSyntax: true })
   })
 
   test("should report errors for completely empty ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 2, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+
+    assertOffenses(dedent`
       <h1>
         <% %>
         <%= %>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    expect(lintResult.offenses[1].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    `)
   })
 
   test("should report errors for whitespace-only ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 2, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 4, column: 2 })
+
+    assertOffenses(dedent`
       <h1>
         <%   %>
         <%=    %>
         <%
         %>
       </h1>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(3)
-    lintResult.offenses.forEach(message => {
-      expect(message.message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    })
+    `)
   })
 
   test("should not report errors for ERB tags with meaningful content", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div>
         <%= user.name %>
         <% if condition %>
@@ -106,17 +72,14 @@ describe("ERBNoEmptyTagsRule", () => {
         <% # this is a comment %>
         <%= @variable %>
       </div>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should handle mixed valid and invalid ERB tags", () => {
-    const html = dedent`
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 3, column: 2 })
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 5, column: 2 })
+
+    assertOffenses(dedent`
       <div>
         <%= user.name %>
         <% %>
@@ -124,38 +87,18 @@ describe("ERBNoEmptyTagsRule", () => {
         <%= %>
         <% end %>
       </div>
-    `
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    lintResult.offenses.forEach(message => {
-      expect(message.message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
-    })
+    `)
   })
 
   test("should handle empty ERB tag in attribute value", () => {
-    const html = `<div class="<%= %>"></div>`
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 1, column: 12 })
+
+    assertOffenses(`<div class="<%= %>"></div>`)
   })
 
   test("should handle empty ERB tag in open tag", () => {
-    const html = `<div <%= %>></div>`
-    const linter = new Linter(Herb, [ERBNoEmptyTagsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    expectError("ERB tag should not be empty. Remove empty ERB tags or add content.", { line: 1, column: 5 })
+
+    assertOffenses(`<div <%= %>></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts b/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts
new file mode 100644
index 000000000..827cc8bc0
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-no-extra-newline.test.ts
@@ -0,0 +1,84 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { ERBNoExtraNewLineRule } from "../../src/rules/erb-no-extra-newline.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoExtraNewLineRule)
+
+describe("erb-no-extra-newline", () => {
+  describe("text content", () => {
+    test("when no new line is present", () => {
+      expectNoOffenses(dedent`
+        line 1
+      `)
+    })
+
+    test("when no blank lines are present", () => {
+      expectNoOffenses(dedent`
+        line 1
+        line 2
+        line 3
+      `)
+    })
+
+    test("when a single blank line is present", () => {
+      expectNoOffenses(dedent`
+        line 1
+
+        line 3
+      `)
+    })
+
+    test("when two blank lines follow each other", () => {
+      expectNoOffenses(dedent`
+        line 1
+
+
+        line 3
+      `)
+    })
+
+    test("when more than two newlines follow each other", () => {
+      expectError("Extra blank line detected. Remove 1 blank line to maintain consistent spacing (max 2 allowed).")
+
+      assertOffenses(dedent`
+        line 1
+
+
+
+        line 3
+      `)
+    })
+  })
+
+  describe("HTML elements", () => {
+    test("when no new line is present", () => {
+      expectNoOffenses(dedent`
+        <div>Hello</div>
+      `)
+    })
+
+    test("when two blank lines follow each other", () => {
+      expectNoOffenses(dedent`
+        <div>Hello</div>
+
+
+        <div>Hello</div>
+      `)
+    })
+
+    test("when more than two newlines follow each other", () => {
+      expectError("Extra blank line detected. Remove 1 blank line to maintain consistent spacing (max 2 allowed).")
+
+      assertOffenses(dedent`
+        <div>Hello</div>
+
+
+
+        <div>Hello</div>
+      `)
+    })
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts b/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
index 2a6777e7c..0091b7ca5 100644
--- a/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-output-control-flow.test.ts
@@ -1,15 +1,12 @@
-import { describe, it, beforeAll, expect } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
+import { describe, it } from "vitest"
 import dedent from "dedent";
 
-import { Linter } from "../../src/linter";
 import { ERBNoOutputControlFlowRule } from "../../src/rules/erb-no-output-control-flow";
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-no-output-control-flow", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoOutputControlFlowRule)
 
+describe("erb-no-output-control-flow", () => {
   it("should allow if statements without output tags", () => {
     const html = dedent`
       <% if true %>
@@ -20,12 +17,8 @@ describe("erb-no-output-control-flow", () => {
         <div>Text3</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+
+    expectNoOffenses(html)
   })
 
   it("should not allow if statments with output tags", () => {
@@ -34,13 +27,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow unless statements with output tags", () => {
@@ -49,13 +38,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `unless` should not be used with output tags. Use `<% unless ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow end statements with output tags", () => {
@@ -64,13 +49,9 @@ describe("erb-no-output-control-flow", () => {
         <div>Text1</div>
       <%= end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `end` should not be used with output tags. Use `<% end ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not allow nested control flow blocks with output tags", () => {
@@ -82,13 +63,9 @@ describe("erb-no-output-control-flow", () => {
         <% end %>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it('should show multiple errors for multiple output tags', () => {
@@ -101,13 +78,11 @@ describe("erb-no-output-control-flow", () => {
         <div>Text3</div>
       <%= end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(3)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    expectError("Control flow statements like `else` should not be used with output tags. Use `<% else ... %>` instead.")
+    expectError("Control flow statements like `end` should not be used with output tags. Use `<% end ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should show an error for outputting control flow blocks with nested control flow blocks", () => {
@@ -118,13 +93,9 @@ describe("erb-no-output-control-flow", () => {
         <% end %>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Control flow statements like `if` should not be used with output tags. Use `<% if ... %>` instead.")
+    assertOffenses(html)
   })
 
   it("should not report for link to with an if condition", () => {
@@ -133,13 +104,8 @@ describe("erb-no-output-control-flow", () => {
         Click
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should not report on form_builder.fieldset with block", () => {
@@ -158,25 +124,15 @@ describe("erb-no-output-control-flow", () => {
          <%# ... %>
      <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should not report on yield with if in the same ERB tag", () => {
    const html = dedent`
       <%= yield(:header) if content_for?(:header) %>
     `
-    
-    const linter = new Linter(Herb, [ERBNoOutputControlFlowRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts b/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
index c79738655..dbe71de41 100644
--- a/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
+++ b/javascript/packages/linter/test/rules/erb-no-silent-tag-in-attribute-name.test.ts
@@ -1,16 +1,13 @@
 import dedent from "dedent"
 
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 
 import { ERBNoSilentTagInAttributeNameRule } from "../../src/rules/erb-no-silent-tag-in-attribute-name.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ERBNoSilentTagInAttributeNameRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBNoSilentTagInAttributeNameRule)
 
+describe("ERBNoSilentTagInAttributeNameRule", () => {
   test("valid attributes with output ERB tags", () => {
     const html = dedent`
       <div data-<%= key %>-target="value"></div>
@@ -18,12 +15,7 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <input data-<%= user.id %>-field="text">
     `
 
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("valid static attribute names", () => {
@@ -32,12 +24,8 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <img src="/logo.png" alt="Logo">
       <input type="text" data-target="value">
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("valid conditional attributes with ERB control flow", () => {
@@ -46,68 +34,45 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
       <span <% if user.admin? %>class="admin"<% end %>></span>
       <input <% unless disabled %>enabled="true"<% end %>>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   test("invalid attribute with silent ERB tag", () => {
     const html = dedent`
       <div data-<% key %>-target="value"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("invalid attribute with trimming silent ERB tag", () => {
     const html = dedent`
       <div data-<%- key -%>-id="thing"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%-`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%-`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("invalid attribute with comment ERB tag", () => {
     const html = dedent`
       <div data-<%# comment %>-target="value"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("multiple invalid attributes in same element", () => {
     const html = dedent`
       <div data-<% key %>-target="value" id-<% another %>-suffix="test"></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
-    expect(lintResult.offenses[1].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("mixed valid and invalid ERB tags in different attributes", () => {
@@ -118,14 +83,9 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
         class="<%= valid_class %>"
       ></div>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("erb-no-silent-tag-in-attribute-name")
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 
   test("nested HTML elements with various ERB patterns", () => {
@@ -136,14 +96,9 @@ describe("ERBNoSilentTagInAttributeNameRule", () => {
         <select prefix-<%# comment %>-suffix="value"></select>
       </form>
     `
-    const linter = new Linter(Herb, [ERBNoSilentTagInAttributeNameRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
 
-    expect(lintResult.offenses[0].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
-    expect(lintResult.offenses[1].message).toBe("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%`) do not output content and should not be used in attribute names.")
+    expectError("Remove silent ERB tag from HTML attribute name. Silent ERB tags (`<%#`) do not output content and should not be used in attribute names.")
+    assertOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts b/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
index acdb5d7e2..abe7e70e1 100644
--- a/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
+++ b/javascript/packages/linter/test/rules/erb-prefer-image-tag-helper.test.ts
@@ -1,328 +1,134 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
 import dedent from "dedent"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { ERBPreferImageTagHelperRule } from "../../src/rules/erb-prefer-image-tag-helper.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-prefer-image-tag-helper", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(ERBPreferImageTagHelperRule)
 
+describe("erb-prefer-image-tag-helper", () => {
   test("passes for regular img tags without ERB", () => {
-    const html = '<img src="/logo.png" alt="Company logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/logo.png" alt="Company logo">')
   })
 
   test("passes for image_tag helper usage", () => {
-    const html = '<%= image_tag "logo.png", alt: "Company logo", class: "logo" %>'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<%= image_tag "logo.png", alt: "Company logo", class: "logo" %>')
   })
 
   test("fails for img with image_path helper", () => {
-    const html = '<img src="<%= image_path("logo.png") %>" alt="Logo">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= image_path("logo.png") %>" alt="Logo">')
   })
 
   test("fails for img with asset_path helper", () => {
-    const html = '<img src="<%= asset_path("banner.jpg") %>" alt="Banner">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag asset_path("banner.jpg"), alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag asset_path("banner.jpg"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= asset_path("banner.jpg") %>" alt="Banner">')
   })
 
   test("handles self-closing img tags with image_path", () => {
-    const html = '<img src="<%= image_path("logo.png") %>" alt="Logo" />'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag image_path("logo.png"), alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= image_path("logo.png") %>" alt="Logo" />')
   })
 
   test("ignores non-img tags with image_path", () => {
-    const html = '<div data-background="<%= image_path("bg.jpg") %>">Content</div>'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div data-background="<%= image_path("bg.jpg") %>">Content</div>')
   })
 
   test("fails for img with Rails URL helpers", () => {
-    const html = '<img src="<%= Rails.application.routes.url_helpers.root_url %>/icon.png" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{Rails.application.routes.url_helpers.root_url}/icon.png", alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{Rails.application.routes.url_helpers.root_url}/icon.png", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= Rails.application.routes.url_helpers.root_url %>/icon.png" alt="Logo">')
   })
 
   test("fails for img with root_url helper", () => {
-    const html = '<img src="<%= root_url %>/banner.jpg" alt="Banner">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_url}/banner.jpg", alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_url}/banner.jpg", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_url %>/banner.jpg" alt="Banner">')
   })
 
   test("fails for img with custom path helpers", () => {
-    const html = '<img src="<%= admin_path %>/icon.png" alt="Admin icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{admin_path}/icon.png", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{admin_path}/icon.png", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= admin_path %>/icon.png" alt="Admin icon">')
   })
 
   test("fails for img with dynamic user avatar URL", () => {
-    const html = '<img src="<%= user.avatar.url %>" alt="User avatar">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag user.avatar.url, alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag user.avatar.url, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= user.avatar.url %>" alt="User avatar">')
   })
 
   test("fails for img with dynamic product image", () => {
-    const html = '<img src="<%= product.image %>" alt="Product image">'
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag product.image, alt: "..." %>` instead.')
 
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag product.image, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= product.image %>" alt="Product image">')
   })
 
   test("fails for img with any ERB expression", () => {
-    const html = '<img src="<%= @company.logo_path %>" alt="Company logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag @company.logo_path, alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag @company.logo_path, alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= @company.logo_path %>" alt="Company logo">')
   })
 
   test("fails for img with multiple ERB expressions", () => {
-    const html = '<img src="<%= base_url %><%= image_path("logo.png") %>" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{base_url}#{image_path("logo.png")}", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{base_url}#{image_path("logo.png")}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= base_url %><%= image_path("logo.png") %>" alt="Logo">')
   })
 
   test("fails for img with ERB expression containing string literal", () => {
-    const html = '<img src="<%= root_path %><%= "icon.png" %>" alt="Icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}#{"icon.png"}", alt: "..." %>` instead.')
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}#{"icon.png"}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_path %><%= "icon.png" %>" alt="Icon">')
   })
 
   test("fails for img with ERB expression containing string literal followed by another ERB tag", () => {
-    const html = '<img src="<%= root_path %>/assets/<%= "icon.png" %>" alt="Icon">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectWarning('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}/assets/#{"icon.png"}", alt: "..." %>` instead.')
 
-    expect(lintResult.offenses[0].rule).toBe("erb-prefer-image-tag-helper")
-    expect(lintResult.offenses[0].message).toBe('Prefer `image_tag` helper over manual `<img>` with dynamic ERB expressions. Use `<%= image_tag "#{root_path}/assets/#{"icon.png"}", alt: "..." %>` instead.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    assertOffenses('<img src="<%= root_path %>/assets/<%= "icon.png" %>" alt="Icon">')
   })
 
   test("shouldn't flag empty src attribute", () => {
-    const html = '<img src="" alt="Empty"><img src="    " alt="Empty">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="" alt="Empty"><img src="    " alt="Empty">')
   })
 
   test("passes for img tags with static paths only", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div>
         <img src="/images/logo.png" alt="Logo">
         <img src="https://example.com/image.jpg" alt="External image">
         <img src="logo.png" alt="Relative path">
       </div>
-    `
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("passes for data URIs with embedded ERB content", () => {
-    const html = '<img src="data:image/png;base64,<%= base64_encoded_logo_image %>" alt="Logo">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,<%= base64_encoded_logo_image %>" alt="Logo">')
   })
 
   test("passes for mixed static and ERB content in src", () => {
-    const html = '<img src="https://example.com/<%= user.id %>/avatar.png" alt="User avatar">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="https://example.com/<%= user.id %>/avatar.png" alt="User avatar">')
   })
 
   test("passes for data URI with SVG and embedded ERB", () => {
-    const html = '<img src="data:image/svg+xml,<svg><text><%= user_name %></text></svg>" alt="SVG">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/svg+xml,<svg><text><%= user_name %></text></svg>" alt="SVG">')
   })
 
   test("passes for data URI with PNG", () => {
-    const html = '<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2W2n8AAAAASUVORK5CYII=" alt="1x1 transparent image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2W2n8AAAAASUVORK5CYII=" alt="1x1 transparent image">')
   })
 
   test("passes for data URI with PNG with ERB", () => {
-    const html = '<img src="data:image/png;base64,<%= File.read("image.png").to_base64 %>" alt="1x1 transparent image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="data:image/png;base64,<%= File.read("image.png").to_base64 %>" alt="1x1 transparent image">')
   })
 
   test("passes for img with only https URL", () => {
-    const html = '<img src="https://example.com/image.jpg" alt="External image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="https://example.com/image.jpg" alt="External image">')
   })
 
   test("passes for img with only http URL", () => {
-    const html = '<img src="http://example.com/image.jpg" alt="External image">'
-
-    const linter = new Linter(Herb, [ERBPreferImageTagHelperRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="http://example.com/image.jpg" alt="External image">')
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts b/javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts
new file mode 100644
index 000000000..f2113b217
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-require-trailing-newline.test.ts
@@ -0,0 +1,157 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+
+import { ERBRequireTrailingNewlineRule } from "../../src/rules/erb-require-trailing-newline.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequireTrailingNewlineRule)
+
+describe("ERBRequireTrailingNewlineRule", () => {
+  test("should not report errors for files ending with a trailing newline", () => {
+    const html = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    ` + '\n'
+
+    expectNoOffenses(html)
+  })
+
+  test("should not report errors for single newline files", () => {
+    const html = "\n"
+
+    expectNoOffenses(html)
+  })
+
+  test("should not report errors for files with multiple lines ending with newline", () => {
+    const html = dedent`
+      <%= render partial: "header" %>
+      <%= render partial: "footer" %>
+    ` + '\n'
+
+    expectNoOffenses(html)
+  })
+
+  test("should report errors for files without trailing newline", () => {
+    const html = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "test.html.erb" })
+  })
+
+  test("should report errors for single line files without newline", () => {
+    const html = `<%= render partial: "header" %>`
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "test.html.erb" })
+  })
+
+  test("should handle files with mixed content without trailing newline", () => {
+    const html = dedent`
+      <div>
+        <h1><%= @title %></h1>
+        <% @items.each do |item| %>
+          <p><%= item.name %></p>
+        <% end %>
+      </div>
+    `
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "test.html.erb" })
+  })
+
+  test("should handle files with mixed content with trailing newline", () => {
+    const html = dedent`
+      <div>
+        <h1><%= @title %></h1>
+        <% @items.each do |item| %>
+          <p><%= item.name %></p>
+        <% end %>
+      </div>
+    ` + '\n'
+
+    expectNoOffenses(html)
+  })
+
+  test("should handle ERB-only template without trailing newline", () => {
+    const html = `<%= hello world %>`
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "test.html.erb" })
+  })
+
+  test("should handle ERB-only template with trailing newline", () => {
+    const html = `<%= hello world %>` + '\n'
+
+    expectNoOffenses(html)
+  })
+
+  test("should not flag empty file", () => {
+    const html = ``
+
+    expectNoOffenses(html)
+  })
+
+  test("should flag empty file with whitespace", () => {
+    const html = ` `
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "test.html.erb" })
+  })
+
+  test("should not flag snippets without trailing newline (fileName: null)", () => {
+    const html = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+
+    expectNoOffenses(html, { fileName: null })
+  })
+
+  test("should not flag single line snippets without trailing newline (fileName: null)", () => {
+    const html = `<%= render partial: "header" %>`
+
+    expectNoOffenses(html, { fileName: null })
+  })
+
+  test("should not flag single line snippets without trailing newline (fileName: undefined)", () => {
+    const html = `<%= render partial: "header" %>`
+
+    expectNoOffenses(html, { fileName: undefined })
+  })
+
+  test("should not flag single line snippets without trailing newline with no context", () => {
+    const html = `<%= render partial: "header" %>`
+
+    expectNoOffenses(html)
+  })
+
+  test("should flag files without trailing newline when fileName is provided", () => {
+    const html = dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `
+
+    expectError("File must end with trailing newline.")
+    assertOffenses(html, { fileName: "template.html.erb" })
+  })
+
+  test("", () => {
+    expectError("File must end with exactly one trailing newline.")
+
+    assertOffenses(`<div>Hello</div>\n\n`, { fileName: "template.html.erb" })
+  })
+
+  test("", () => {
+    expectError("File must end with exactly one trailing newline.")
+
+    assertOffenses(`<div>Hello</div>\n\n\n\n\n\n`, { fileName: "template.html.erb" })
+  })
+})
diff --git a/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts b/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
index 60037d6a7..0b54e3297 100644
--- a/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
+++ b/javascript/packages/linter/test/rules/erb-require-whitespace-inside-tags.test.ts
@@ -1,15 +1,12 @@
-import { describe, it, beforeAll, expect } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
+import { describe, it } from "vitest"
 import dedent from "dedent";
 
-import { Linter } from "../../src/linter";
 import { ERBRequireWhitespaceRule } from "../../src/rules/erb-require-whitespace-inside-tags";
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("erb-require-whitespace-inside-tags", () => {
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRequireWhitespaceRule)
 
-  beforeAll(async () => {
-    await Herb.load()
-  })
+describe("erb-require-whitespace-inside-tags", () => {
 
   it("should not report for correct whitespace in ERB tags", () => {
     const html = dedent`
@@ -17,12 +14,8 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should require a space after <% and before %> in ERB tags", () => {
@@ -30,13 +23,10 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%if true%>
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should require a space after <%= and before %> in ERB output tags", () => {
@@ -44,13 +34,10 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%=user.name%>
       <%= user.name %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should report errors for only missing opening whitespace", () => {
@@ -59,12 +46,9 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, user.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toMatch(/Add whitespace after/i)
+    expectError("Add whitespace after `<%`.")
+    assertOffenses(html)
   })
 
   it("should report errors for only missing closing whitespace", () => {
@@ -73,12 +57,9 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <% end %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toMatch(/Add whitespace before/i)
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should report multiple errors for multiple offenses", () => {
@@ -88,12 +69,14 @@ describe("erb-require-whitespace-inside-tags", () => {
         Hello, admin.
       <%end%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(6)
-    expect(lintResult.offenses).toHaveLength(6)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report for non-ERB content", () => {
@@ -101,12 +84,8 @@ describe("erb-require-whitespace-inside-tags", () => {
       <div>Hello</div>
       <p>World</p>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should handle mixed correct and incorrect ERB tags", () => {
@@ -117,12 +96,12 @@ describe("erb-require-whitespace-inside-tags", () => {
         <h1>Hello, admin.</h1>
       <%end%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
+    expectError("Add whitespace after `<%=`.")
+    expectError("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should handle empty erb tags", () => {
@@ -134,12 +113,8 @@ describe("erb-require-whitespace-inside-tags", () => {
 
       %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should require whitespace after # in ERB comment tags", () => {
@@ -148,54 +123,36 @@ describe("erb-require-whitespace-inside-tags", () => {
       <%#This is a comment without spaces%>
       <%# %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].message).toBe("Add whitespace after `<%#`.")
-    expect(lintResult.offenses[1].message).toBe("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%#`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report ERB comment tags with equals signs", () => {
     const html = dedent`
       <%#= link_to "New watch list", new_watch_list_path, class: "btn btn-ghost" %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should report ERB comment tags with equals sign and no space after", () => {
     const html = dedent`
       <%#=link_to "New watch list", new_watch_list_path, class: "btn btn-ghost"%>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
 
-    expect(lintResult.offenses[0].message).toBe("Add whitespace after `<%#=`.")
-    expect(lintResult.offenses[1].message).toBe("Add whitespace before `%>`.")
+    expectError("Add whitespace after `<%#=`.")
+    expectError("Add whitespace before `%>`.")
+    assertOffenses(html)
   })
 
   it("should not report ERB comment tags with equals followed by space", () => {
     const html = dedent`
       <%# = link_to "New watch list", new_watch_list_path, class: "btn btn-ghost" %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("should handle multi-line ERB comment tags", () => {
@@ -211,11 +168,7 @@ describe("erb-require-whitespace-inside-tags", () => {
         class: "btn btn-ghost"
       %>
     `
-    
-    const linter = new Linter(Herb, [ERBRequireWhitespaceRule])
-    const lintResult = linter.lint(html)
 
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts b/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
deleted file mode 100644
index 5dc5c439d..000000000
--- a/javascript/packages/linter/test/rules/erb-requires-trailing-newline.test.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
-import { ERBRequiresTrailingNewlineRule } from "../../src/rules/erb-requires-trailing-newline.js"
-
-describe("ERBRequiresTrailingNewlineRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
-
-  test("should not report errors for files ending with a trailing newline", () => {
-    const html = dedent`
-      <h1>
-        <%= title %>
-      </h1>
-    ` + '\n'
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not report errors for single newline files", () => {
-    const html = "\n"
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not report errors for files with multiple lines ending with newline", () => {
-    const html = dedent`
-      <%= render partial: "header" %>
-      <%= render partial: "footer" %>
-    ` + '\n'
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should report errors for files without trailing newline", () => {
-    const html = dedent`
-      <h1>
-        <%= title %>
-      </h1>
-    `
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-
-  test("should report errors for single line files without newline", () => {
-    const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-
-  test("should handle files with mixed content without trailing newline", () => {
-    const html = dedent`
-      <div>
-        <h1><%= @title %></h1>
-        <% @items.each do |item| %>
-          <p><%= item.name %></p>
-        <% end %>
-      </div>
-    `
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-
-  test("should handle files with mixed content with trailing newline", () => {
-    const html = dedent`
-      <div>
-        <h1><%= @title %></h1>
-        <% @items.each do |item| %>
-          <p><%= item.name %></p>
-        <% end %>
-      </div>
-    ` + '\n'
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should handle ERB-only template without trailing newline", () => {
-    const html = `<%= hello world %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-
-  test("should handle ERB-only template with trailing newline", () => {
-    const html = `<%= hello world %>` + '\n'
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not flag empty file", () => {
-    const html = ``
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should flag empty file with whitespace", () => {
-    const html = ` `
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "test.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-
-  test("should not flag snippets without trailing newline (fileName: null)", () => {
-    const html = dedent`
-      <h1>
-        <%= title %>
-      </h1>
-    `
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: null })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not flag single line snippets without trailing newline (fileName: null)", () => {
-    const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: null })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not flag single line snippets without trailing newline (fileName: undefined)", () => {
-    const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: undefined })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should not flag single line snippets without trailing newline with no context", () => {
-    const html = `<%= render partial: "header" %>`
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
-  })
-
-  test("should flag files without trailing newline when fileName is provided", () => {
-    const html = dedent`
-      <h1>
-        <%= title %>
-      </h1>
-    `
-
-    const linter = new Linter(Herb, [ERBRequiresTrailingNewlineRule])
-    const lintResult = linter.lint(html, { fileName: "template.html.erb" })
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("erb-requires-trailing-newline")
-    expect(lintResult.offenses[0].message).toBe("File must end with trailing newline")
-  })
-})
diff --git a/javascript/packages/linter/test/rules/erb-right-trim.test.ts b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
new file mode 100644
index 000000000..d12923cca
--- /dev/null
+++ b/javascript/packages/linter/test/rules/erb-right-trim.test.ts
@@ -0,0 +1,142 @@
+import dedent from "dedent"
+import { describe, test } from "vitest"
+import { ERBRightTrimRule } from "../../src/rules/erb-right-trim.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBRightTrimRule)
+
+describe("ERBRightTrimRule", () => {
+  test("when the erb tag close with %>", () => {
+    expectNoOffenses(dedent`
+      <h1>
+        <%= title %>
+      </h1>
+    `)
+  })
+
+  test("when output erb tag closes with -%>", () => {
+    expectNoOffenses(dedent`
+      <h1>
+        <%= title -%>
+      </h1>
+    `)
+  })
+
+  test("when non-output tag uses -%>", () => {
+    expectNoOffenses(dedent`
+      <% if condition -%>
+        <p>Content</p>
+      <% elsif other_condition -%>
+        <p>Content</p>
+      <% elsif yet_another_condition -%>
+        <p>Content</p>
+      <% else -%>
+        <p>Content</p>
+      <% end -%>
+    `)
+  })
+
+  test("when the erb tag close with =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <h1>
+        <%= title =%>
+      </h1>
+    `)
+  })
+
+  test("when an if block uses =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <% if condition =%>
+        <p>Content</p>
+      <% end =%>
+    `)
+  })
+
+  test("when a loop uses =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <% items.each do |item| =%>
+        <li><%= item %></li>
+      <% end %>
+    `)
+  })
+
+  test("when multiple lines use =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <%= first =%>
+      <%= second =%>
+      <%= third =%>
+    `)
+  })
+
+  test("when mixed valid and invalid syntax is used", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <%= valid %>
+      <%= invalid_trim =%>
+      <%= valid_trim -%>
+      <%= another_invalid =%>
+    `)
+  })
+
+  test("when silent ERB uses =%>", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <% silent_operation =%>
+    `)
+  })
+
+  test("handles =%> in nested structures", () => {
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+    expectError("Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.")
+
+    assertOffenses(dedent`
+      <% if outer_condition =%>
+        <% if inner_condition =%>
+          <p>Nested content</p>
+        <% end %>
+      <% end %>
+    `)
+  })
+
+  test("<%- with -%>", () => {
+    expectNoOffenses(dedent`
+      <%- something -%>
+    `)
+  })
+
+  test("<%- with -%> in if/end", () => {
+    expectNoOffenses(dedent`
+      <%- if true -%>
+        Something
+      <%- end -%>
+    `)
+  })
+
+  test("passes for yield with -%>", () => {
+    expectNoOffenses(dedent`
+      <%= yield -%>
+    `)
+  })
+
+  test("passes for block with -%>", () => {
+    expectNoOffenses(dedent`
+      <%= content_for :content do -%>
+        Content
+      <%- end -%>
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts b/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
index 1ee7b3653..e26cd78f0 100644
--- a/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
+++ b/javascript/packages/linter/test/rules/html-anchor-require-href-rule.test.ts
@@ -1,81 +1,38 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAnchorRequireHrefRule } from "../../src/rules/html-anchor-require-href.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-anchor-require-href", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAnchorRequireHrefRule)
 
+describe("html-anchor-require-href", () => {
   test("passes for a with href attribute", () => {
-    const html = '<a href="http://example.com">My link</a>'
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<a href="http://example.com">My link</a>')
   })
 
   test("fails for a without href attribute", () => {
-    const html = "<a>My link</a>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-anchor-require-href")
-    expect(lintResult.offenses[0].message).toBe(
-      "Add an `href` attribute to `<a>` to ensure it is focusable and accessible.",
-    )
-    expect(lintResult.offenses[0].severity).toBe("error")
+    assertOffenses("<a>My link</a>")
   })
 
   test("fails for multiple a tags without href", () => {
-    const html = "<a>My link</a><a>My other link</a>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    assertOffenses("<a>My link</a><a>My other link</a>")
   })
 
   test("passes for img with ERB alt attribute", () => {
-    const html = '<a href="<%= user.home_page_url %>">My Link</a>'
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<a href="<%= user.home_page_url %>">My Link</a>')
   })
 
   test("ignores non-a tags", () => {
-    const html = "<div>My div</div>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses("<div>My div</div>")
   })
 
   test("handles mixed case a tags", () => {
-    const html = "<A>My link</A>"
-    
-    const linter = new Linter(Herb, [HTMLAnchorRequireHrefRule])
-    const lintResult = linter.lint(html)
+    expectError("Add an `href` attribute to `<a>` to ensure it is focusable and accessible.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe(
-      "Add an `href` attribute to `<a>` to ensure it is focusable and accessible.",
-    )
+    assertOffenses("<A>My link</A>")
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
index a8c13cd34..3dc0666b3 100644
--- a/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-attribute-must-be-valid.test.ts
@@ -1,76 +1,42 @@
 import dedent from "dedent"
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaAttributeMustBeValid } from "../../src/rules/html-aria-attribute-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-attribute-must-be-valid", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaAttributeMustBeValid)
 
+describe("html-aria-attribute-must-be-valid", () => {
   it("allows a div with a valid aria attribute", () => {
     const html = '<div aria-label="Section Title"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("ignores non-aria attributes", () => {
     const html = '<div class="foo"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(html)
   })
 
   it("fails when a div has an invalid aria attribute", () => {
     const html = '<div aria-bogus="foo"></div>'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-bogus` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-bogus` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for mistyped aria name", () => {
     const html = '<input type="text" aria-lable="Search" />'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-lable` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-lable` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-", () => {
     const html = '<input type="text" aria-="Search" />'
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-labelled-by", () => {
@@ -79,15 +45,8 @@ describe("html-aria-attribute-must-be-valid", () => {
       <span id="tac">I agree to the Terms and Conditions.</span>
     `
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-labelled-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-labelled-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 
   it("fails for aria-described-by", () => {
@@ -96,14 +55,7 @@ describe("html-aria-attribute-must-be-valid", () => {
       <div id="pwd-help">Password must be at least 8 characters</div>
     `
 
-    const linter = new Linter(Herb, [HTMLAriaAttributeMustBeValid])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The attribute `aria-described-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.'
-    )
+    expectError('The attribute `aria-described-by` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.')
+    assertOffenses(html)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts b/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
index 0de4b1e8f..2fc2c147e 100644
--- a/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-label-is-well-formatted.test.ts
@@ -1,165 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAriaLabelIsWellFormattedRule } from "../../src/rules/html-aria-label-is-well-formatted.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-label-is-well-formatted", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaLabelIsWellFormattedRule)
 
+describe("html-aria-label-is-well-formatted", () => {
   test("passes for properly formatted aria-label", () => {
-    const html = '<button aria-label="Close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button aria-label="Close dialog">X</button>`)
   })
 
   test("passes for aria-label with proper sentence case", () => {
-    const html = '<input aria-label="Search products" type="search">'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input aria-label="Search products" type="search">`)
   })
 
   test("fails for aria-label starting with lowercase", () => {
-    const html = '<button aria-label="close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-aria-label-is-well-formatted")
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).")
+    expectError("The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).")
+    assertOffenses(`<button aria-label="close dialog">X</button>`)
   })
 
   test("fails for aria-label with line breaks", () => {
-    const html = '<button aria-label="Close\ndialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close\ndialog">X</button>`)
   })
 
   test("fails for aria-label with carriage return", () => {
-    const html = '<button aria-label="Close\rdialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close\rdialog">X</button>`)
   })
 
   test("fails for aria-label with HTML entity line breaks", () => {
-    const html = '<button aria-label="Close&#10;dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    expectError("The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.")
+    assertOffenses(`<button aria-label="Close&#10;dialog">X</button>`)
   })
 
   test("fails for snake_case aria-label", () => {
-    const html = '<button aria-label="close_dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="close_dialog">X</button>`)
   })
 
   test("fails for kebab-case aria-label", () => {
-    const html = '<button aria-label="close-dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="close-dialog">X</button>`)
   })
 
   test("fails for camelCase aria-label", () => {
-    const html = '<button aria-label="closeDialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`<button aria-label="closeDialog">X</button>`)
   })
 
   test("passes for aria-label with spaces and proper formatting", () => {
-    const html = '<button aria-label="Close the dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="Close the dialog">X</button>`)
   })
 
   test("passes for aria-label with numbers", () => {
-    const html = '<button aria-label="Page 2 of 10">2</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="Page 2 of 10">2</button>`)
   })
 
   test("ignores other attributes", () => {
-    const html = '<button aria-labelledby="close_dialog_label">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-labelledby="close_dialog_label">X</button>`)
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    assertOffenses(`
       <button aria-label="Close dialog">X</button>
       <input aria-label="search_field" type="text">
-    `
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.")
+    `)
   })
 
   test("passes for aria-label with ERB content", () => {
-    const html = '<button aria-label="<%= action_label %>">Action</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-label="<%= action_label %>">Action</button>`)
   })
 
   test("passes for mixed case attribute name", () => {
-    const html = '<button ARIA-LABEL="Close dialog">X</button>'
-
-    const linter = new Linter(Herb, [HTMLAriaLabelIsWellFormattedRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button ARIA-LABEL="Close dialog">X</button>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
index 23edbf179..70ce675a7 100644
--- a/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-level-must-be-valid.test.ts
@@ -1,257 +1,141 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { HTMLAriaLevelMustBeValidRule } from "../../src/rules/html-aria-level-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("HTMLAriaLevelMustBeValidRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaLevelMustBeValidRule)
 
+describe("HTMLAriaLevelMustBeValidRule", () => {
   test("allows valid aria-level values 1-6", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div role="heading" aria-level="1">Main</div>
       <div role="heading" aria-level="2">Section</div>
       <div role="heading" aria-level="3">Subsection</div>
       <div role="heading" aria-level="4">Sub-subsection</div>
       <div role="heading" aria-level="5">Deep heading</div>
       <div role="heading" aria-level="6">Footnote</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("allows elements without aria-level attribute", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div role="heading">No aria-level</div>
       <h1>Regular heading</h1>
       <div>Regular div</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("flags negative aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level="-1">Negative</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `-1`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="-1">Negative</div>
+    `)
   })
 
   test("flags zero aria-level value", () => {
-    const html = dedent`
-      <div role="heading" aria-level="0">Main</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `0`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `0`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="0">Main</div>
+    `)
   })
 
   test("flags aria-level values greater than 6", () => {
-    const html = dedent`
-      <div role="heading" aria-level="7">Too deep</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `7`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `7`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="7">Too deep</div>
+    `)
   })
 
   test("flags non-numeric aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level="foo">Invalid</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `foo`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `foo`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="foo">Invalid</div>
+    `)
   })
 
   test("flags multiple invalid aria-level values", () => {
-    const html = dedent`
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `0`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `7`.')
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `foo`.')
+
+    assertOffenses(dedent`
       <div role="heading" aria-level="-1">Negative</div>
       <div role="heading" aria-level="0">Zero</div>
       <div role="heading" aria-level="7">Too deep</div>
       <div role="heading" aria-level="foo">Invalid</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `-1`.',
-    )
-    expect(lintResult.offenses[1].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `0`.',
-    )
-    expect(lintResult.offenses[2].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `7`.',
-    )
-    expect(lintResult.offenses[3].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `foo`.',
-    )
+    `)
   })
 
   test("handles floating point numbers", () => {
-    const html = dedent`
-      <div role="heading" aria-level="1.5">Float</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `1.5`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got `1.5`.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level="1.5">Float</div>
+    `)
   })
 
   test("flags whitespace in aria-level values", () => {
-    const html = dedent`
-      <div role="heading" aria-level=" 2 ">Whitespace</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got ` 2 `.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      'The `aria-level` attribute must be an integer between 1 and 6, got ` 2 `.',
-    )
+    assertOffenses(dedent`
+      <div role="heading" aria-level=" 2 ">Whitespace</div>
+    `)
   })
 
   test("allows ERB expressions in aria-level values", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="<%= @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("allows mixed ERB expressions with no output in aria-level values", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="1<% @level %>">Dynamic level</div>
       <div aria-level="<% @level %>2">Dynamic level</div>
       <div aria-level="<% @level %>3<% @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("disallows mixed ERB expressions with no output in aria-level values", () => {
-    const html = dedent`
-      <div aria-level="-1<% @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got `-1`.')
+    assertOffenses(dedent`
+      <div aria-level="-1<% @level %>">Dynamic level</div>
+    `)
   })
 
   test("disallows mixed ERB expressions with valid static value and dynamic ERB output", () => {
-    const html = dedent`
-      <div aria-level="1<%= @level %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got `1` and the ERB expression `<%= @level %>`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got `1` and the ERB expression `<%= @level %>`.')
+    assertOffenses(dedent`
+      <div aria-level="1<%= @level %>">Dynamic level</div>
+    `)
   })
 
   test.todo("allows mixed ERB expressions in aria-level values if both branches are valid", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div aria-level="<% if valid? %>1<% else %>2<% end %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test.todo("flags mixed ERB expressions in aria-level values if one branch is valid", () => {
-    const html = dedent`
-      <div aria-level="<% if valid? %>1<% else %>-1<% end %>">Dynamic level</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, at least one branch has an invlid value: `-1`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, at least one branch has an invlid value: `-1`.') // TODO: message can be tweaked
+    assertOffenses(dedent`
+      <div aria-level="<% if valid? %>1<% else %>-1<% end %>">Dynamic level</div>
+    `)
   })
 
   test("flags empty aria-level attribute", () => {
-    const html = dedent`
-      <div role="heading" aria-level="">Empty value</div>
-    `
-    const linter = new Linter(Herb, [HTMLAriaLevelMustBeValidRule])
-    const lintResult = linter.lint(html)
+    expectError('The `aria-level` attribute must be an integer between 1 and 6, got an empty value.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].code).toBe("html-aria-level-must-be-valid")
-    expect(lintResult.offenses[0].message).toBe('The `aria-level` attribute must be an integer between 1 and 6, got an empty value.')
+    assertOffenses(dedent`
+      <div role="heading" aria-level="">Empty value</div>
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts b/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
index 7229c6d36..7ad3c0c14 100644
--- a/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-role-heading-requires-level.test.ts
@@ -1,36 +1,17 @@
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaRoleHeadingRequiresLevelRule } from "../../src/rules/html-aria-role-heading-requires-level.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-role-heading-requires-level", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaRoleHeadingRequiresLevelRule)
 
+describe("html-aria-role-heading-requires-level", () => {
   it("allows a div with the proper heading", () => {
-    const html = '<div role="heading" aria-level="2">Section Title</div>'
-    
-    const linter = new Linter(Herb, [HTMLAriaRoleHeadingRequiresLevelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="heading" aria-level="2">Section Title</div>')
   })
 
   it("fails when role=heading is used without aria-level", () => {
-    const html = '<div role="heading">Section Title</div>'
-
-    
-    const linter = new Linter(Herb, [HTMLAriaRoleHeadingRequiresLevelRule])
-    const lintResult = linter.lint(html)
+    expectError(`Element with \`role="heading"\` must have an \`aria-level\` attribute.`)
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].message).toBe(
-      `Element with \`role="heading"\` must have an \`aria-level\` attribute.`
-    )
+    assertOffenses('<div role="heading">Section Title</div>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts b/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
index 79c6702cb..470ddad6d 100644
--- a/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
+++ b/javascript/packages/linter/test/rules/html-aria-role-must-be-valid.test.ts
@@ -1,55 +1,25 @@
-import { describe, it, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, it } from "vitest"
 import { HTMLAriaRoleMustBeValidRule } from "../../src/rules/html-aria-role-must-be-valid.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-aria-role-must-be-valid", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAriaRoleMustBeValidRule)
 
+describe("html-aria-role-must-be-valid", () => {
   it("should not show an error for valid attributes", () => {
-    const html = '<div role="button">Click Me</div>'
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="button">Click Me</div>')
   })
 
   it("should show an error for an invalid attrbute", () => {
-    const html = `<div role="invalid-role"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
+    expectError("The `role` attribute must be a valid ARIA role. Role `invalid-role` is not recognized.")
 
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("The `role` attribute must be a valid ARIA role. Role `invalid-role` is not recognized.")
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    assertOffenses(`<div role="invalid-role"></div>`)
   })
 
   it("should not show an error for ERB content", () => {
-    const html = `<div role="<%= role %>"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div role="<%= role %>"></div>`)
   })
 
   it("should not show an error for static and ERB content", () => {
-    const html = `<div role="invalid-role-<%= role %>"></div>`
-    const linter = new Linter(Herb, [HTMLAriaRoleMustBeValidRule])
-
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div role="invalid-role-<%= role %>"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts b/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
index 2c5d13ce5..4ef25566f 100644
--- a/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-double-quotes.test.ts
@@ -1,152 +1,67 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAttributeDoubleQuotesRule } from "../../src/rules/html-attribute-double-quotes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-attribute-double-quotes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLAttributeDoubleQuotesRule)
 
+describe("html-attribute-double-quotes", () => {
   test("passes for double quoted attributes", () => {
-    const html = '<input type="text" value="Username">'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<input type="text" value="Username">`)
   })
 
   test("fails for single quoted attributes", () => {
-    const html = "<input type='text' value='Username'>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-attribute-double-quotes")
-    expect(lintResult.offenses[0].message).toBe('Attribute `type` uses single quotes. Prefer double quotes for HTML attribute values: `type="text"`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-
-    expect(lintResult.offenses[1].rule).toBe("html-attribute-double-quotes")
-    expect(lintResult.offenses[1].message).toBe('Attribute `value` uses single quotes. Prefer double quotes for HTML attribute values: `value="Username"`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `type` uses single quotes. Prefer double quotes for HTML attribute values: `type="text"`.')
+    expectWarning('Attribute `value` uses single quotes. Prefer double quotes for HTML attribute values: `value="Username"`.')
+    assertOffenses(`<input type='text' value='Username'>`)
   })
 
   test("passes for mixed content with double quotes", () => {
-    const html = '<a href="/profile" title="User Profile" data-controller="dropdown">Profile</a>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="/profile" title="User Profile" data-controller="dropdown">Profile</a>`)
   })
 
   test("fails for mixed content with single quotes", () => {
-    const html = "<a href='/profile' title='User Profile' data-controller='dropdown'>Profile</a>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses[0].message).toBe('Attribute `href` uses single quotes. Prefer double quotes for HTML attribute values: `href="/profile"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `title` uses single quotes. Prefer double quotes for HTML attribute values: `title="User Profile"`.')
-    expect(lintResult.offenses[2].message).toBe('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="dropdown"`.')
+    expectWarning('Attribute `href` uses single quotes. Prefer double quotes for HTML attribute values: `href="/profile"`.')
+    expectWarning('Attribute `title` uses single quotes. Prefer double quotes for HTML attribute values: `title="User Profile"`.')
+    expectWarning('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="dropdown"`.')
+    assertOffenses(`<a href='/profile' title='User Profile' data-controller='dropdown'>Profile</a>`)
   })
 
   test("passes for unquoted attributes (handled by other rule)", () => {
-    const html = '<input type=text value=Username>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type=text value=Username>`)
   })
 
   test("passes for attributes without values", () => {
-    const html = '<input type="checkbox" checked disabled>'
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type="checkbox" checked disabled>`)
   })
 
   test("handles self-closing tags with single quotes", () => {
-    const html = "<img src='/image.jpg' alt='Description' />"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `src` uses single quotes. Prefer double quotes for HTML attribute values: `src="/image.jpg"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `alt` uses single quotes. Prefer double quotes for HTML attribute values: `alt="Description"`.')
+    expectWarning('Attribute `src` uses single quotes. Prefer double quotes for HTML attribute values: `src="/image.jpg"`.')
+    expectWarning('Attribute `alt` uses single quotes. Prefer double quotes for HTML attribute values: `alt="Description"`.')
+    assertOffenses(`<img src='/image.jpg' alt='Description' />`)
   })
 
   test("handles ERB with single quoted attributes", () => {
-    const html = "<div data-controller='<%= controller_name %>' data-action='click->toggle#action'>Content</div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="<%= controller_name %>"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `data-action` uses single quotes. Prefer double quotes for HTML attribute values: `data-action="click->toggle#action"`.')
+    expectWarning('Attribute `data-controller` uses single quotes. Prefer double quotes for HTML attribute values: `data-controller="<%= controller_name %>"`.')
+    expectWarning('Attribute `data-action` uses single quotes. Prefer double quotes for HTML attribute values: `data-action="click->toggle#action"`.')
+    assertOffenses(`<div data-controller='<%= controller_name %>' data-action='click->toggle#action'>Content</div>`)
   })
 
   test("handles mixed ERB with single quoted attributes", () => {
-    const html = "<div class='static <%= class_list %> another-static'>Content</div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="static <%= class_list %> another-static"`.')
+    expectWarning('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="static <%= class_list %> another-static"`.')
+    assertOffenses(`<div class='static <%= class_list %> another-static'>Content</div>`)
   })
 
   test("allows single quotes when value contains double quotes", () => {
-    const html = `<div id='"hello"' class='Say "Hello" to the world'></div>`
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id='"hello"' class='Say "Hello" to the world'></div>`)
   })
 
   test("allows single quotes when value contains double quotes and ERB content", () => {
-    const html = `<div class='Say "Hello" to <%= name %>'></div>`
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div class='Say "Hello" to <%= name %>'></div>`)
   })
 
   test("still fails for single quotes when value has no double quotes", () => {
-    const html = "<div id='hello' class='world'></div>"
-
-    const linter = new Linter(Herb, [HTMLAttributeDoubleQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` uses single quotes. Prefer double quotes for HTML attribute values: `id="hello"`.')
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="world"`.')
+    expectWarning('Attribute `id` uses single quotes. Prefer double quotes for HTML attribute values: `id="hello"`.')
+    expectWarning('Attribute `class` uses single quotes. Prefer double quotes for HTML attribute values: `class="world"`.')
+    assertOffenses(`<div id='hello' class='world'></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts b/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
index 54283b74e..a04c77769 100644
--- a/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-equals-spacing.test.ts
@@ -1,180 +1,96 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { HTMLAttributeEqualsSpacingRule } from "../../src/rules/html-attribute-equals-spacing.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("HTMLAttributeEqualsSpacingRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAttributeEqualsSpacingRule)
 
+describe("HTMLAttributeEqualsSpacingRule", () => {
   test("valid attributes with no spacing around equals", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div class="container"></div>
       <img src="/logo.png" alt="Logo">
       <input type="text" value="<%= @value %>">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("attribute with space before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class ="container"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].code).toBe("html-attribute-equals-spacing")
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with space after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <img src= "/logo.png">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].code).toBe("html-attribute-equals-spacing")
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with spaces both before and after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <input type = "text">
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
-    expect(lintResult.offenses[1].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute value without quotes and spaces after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=  data></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static and dynamic ERB before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div data-<%= key %>  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with ERB before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div <%= key %>  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static, dynamic ERB, static before equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    assertOffenses(dedent`
       <div data-<%= key %>-user  ="value"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace before `=` in HTML attribute")
+    `)
   })
 
   test("attribute value with ERB and spaces after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=   <%= key %>></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("attribute with static, dynamic ERB, static after equals", () => {
-    const html = dedent`
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class=  "data-<%= key %>-user  "></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe("Remove whitespace after `=` in HTML attribute")
+    `)
   })
 
   test("multiple attributes with various spacing issues", () => {
-    const html = dedent`
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    expectError("Remove whitespace before `=` in HTML attribute")
+    expectError("Remove whitespace after `=` in HTML attribute")
+    assertOffenses(dedent`
       <div class ="container" id= "main" data-value = "test"></div>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("attributes without values should not trigger rule", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <input disabled required>
-    `
-    const linter = new Linter(Herb, [HTMLAttributeEqualsSpacingRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
index 4a9d7de80..3260fbf50 100644
--- a/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
+++ b/javascript/packages/linter/test/rules/html-attribute-values-require-quotes.test.ts
@@ -1,119 +1,53 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAttributeValuesRequireQuotesRule } from "../../src/rules/html-attribute-values-require-quotes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-attribute-values-require-quotes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAttributeValuesRequireQuotesRule)
 
+describe("html-attribute-values-require-quotes", () => {
   test("passes for quoted attribute values", () => {
-    const html = '<div id="hello" class="container">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id="hello" class="container"></div>`)
   })
 
   test("fails for unquoted attribute values", () => {
-    const html = '<div id=hello class=container>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // Both id and class are unquoted
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-attribute-values-require-quotes")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `id="hello"`. Always wrap attribute values in quotes.')
-    expect(lintResult.offenses[1].message).toBe('Attribute value should be quoted: `class="container"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `id="hello"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `class="container"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<div id=hello class=container></div>`)
   })
 
   test("passes for single-quoted values", () => {
-    const html = "<div id='hello' class='container'>"
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div id='hello' class='container'></div>`)
   })
 
   test("passes for boolean attributes without values", () => {
-    const html = '<input type="text" disabled>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<input type="text" disabled />`)
   })
 
   test("handles mixed quoted and unquoted", () => {
-    const html = '<input type="text" name=username value="test">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1) // Only name is unquoted
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `name="username"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `name="username"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<input type="text" name=username value="test" />`)
   })
 
   test("handles ERB in quoted attributes", () => {
-    const html = '<div class="<%= classes %>" data-id="<%= item.id %>">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>"></div>`)
   })
 
   test("handles ERB in unquoted attributes", () => {
-    const html = '<div class=<%= classes %>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `class="<%= classes %>"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `class="<%= classes %>"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<div class=<%= classes %>></div>`)
   })
 
   test("handles self-closing tags", () => {
-    const html = '<img src=photo.jpg alt="Photo">'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `src="photo"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `src="photo"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<img src=photo alt="Photo" />`)
   })
 
   test("handles complex attribute values", () => {
-    const html = '<a href="/profile" title=User\\ Profile>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute value should be quoted: `title="User"`. Always wrap attribute values in quotes.')
+    expectError('Attribute value should be quoted: `title="User"`. Always wrap attribute values in quotes.')
+    assertOffenses(`<a href="/profile" title=User></a>`)
   })
 
   test("ignores closing tags", () => {
-    const html = '<div class="test"></div>'
-
-    const linter = new Linter(Herb, [HTMLAttributeValuesRequireQuotesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="test"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts b/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
index 0892eda84..dc6a08692 100644
--- a/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
+++ b/javascript/packages/linter/test/rules/html-avoid-both-disabled-and-aria-disabled.test.ts
@@ -1,170 +1,87 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "../../src/rules/html-avoid-both-disabled-and-aria-disabled.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-avoid-both-disabled-and-aria-disabled", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLAvoidBothDisabledAndAriaDisabledRule)
 
+describe("html-avoid-both-disabled-and-aria-disabled", () => {
   test("passes for button with only disabled", () => {
-    const html = '<button disabled>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button disabled>Click me</button>`)
   })
 
   test("passes for button with only aria-disabled", () => {
-    const html = '<button aria-disabled="true">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-disabled="true">Click me</button>`)
   })
 
   test("passes for button with neither attribute", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("fails for button with both disabled and aria-disabled", () => {
-    const html = '<button disabled aria-disabled="true">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-avoid-both-disabled-and-aria-disabled")
-    expect(lintResult.offenses[0].message).toBe("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button disabled aria-disabled="true">Click me</button>`)
   })
 
   test("fails for input with both attributes", () => {
-    const html = '<input type="text" disabled aria-disabled="false">'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-avoid-both-disabled-and-aria-disabled")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<input type="text" disabled aria-disabled="false">`)
   })
 
   test("fails for textarea with both attributes", () => {
-    const html = '<textarea disabled aria-disabled="true"></textarea>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<textarea disabled aria-disabled="true"></textarea>`)
   })
 
   test("fails for select with both attributes", () => {
-    const html = '<select disabled aria-disabled="true"><option>Test</option></select>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<select disabled aria-disabled="true"><option>Test</option></select>`)
   })
 
   test("fails for fieldset with both attributes", () => {
-    const html = '<fieldset disabled aria-disabled="true"><input type="text"></fieldset>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<fieldset disabled aria-disabled="true"><input type="text"></fieldset>`)
   })
 
   test("fails for option with both attributes", () => {
-    const html = '<option disabled aria-disabled="true">Test option</option>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<option disabled aria-disabled="true">Test option</option>`)
   })
 
   test("fails for optgroup with both attributes", () => {
-    const html = '<optgroup disabled aria-disabled="true" label="Test"><option>Test</option></optgroup>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<optgroup disabled aria-disabled="true" label="Test"><option>Test</option></optgroup>`)
   })
 
   test("ignores elements that don't support disabled attribute", () => {
-    const html = '<div disabled aria-disabled="true">Not a form element</div>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div disabled aria-disabled="true">Not a form element</div>`)
   })
 
   test("ignores anchor elements with both attributes", () => {
-    const html = '<a href="#" disabled aria-disabled="true">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="#" disabled aria-disabled="true">Link</a>`)
   })
 
   test("handles mixed case attribute names", () => {
-    const html = '<button DISABLED ARIA-DISABLED="true">Mixed case</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button DISABLED ARIA-DISABLED="true">Mixed case</button>`)
   })
 
   test("handles boolean disabled attribute", () => {
-    const html = '<button disabled="disabled" aria-disabled="true">Boolean disabled</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`<button disabled="disabled" aria-disabled="true">Boolean disabled</button>`)
   })
 
   test("handles multiple form elements", () => {
-    const html = `
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    expectError("aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.")
+    assertOffenses(`
       <button disabled>OK</button>
       <input type="text" disabled aria-disabled="true">
       <select aria-disabled="true"><option>Test</option></select>
       <textarea disabled aria-disabled="false"></textarea>
-    `
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes when attributes have ERB content", () => {
-    const html = '<button disabled="<%= is_disabled %>" aria-disabled="<%= aria_disabled %>">Dynamic</button>'
-
-    const linter = new Linter(Herb, [HTMLAvoidBothDisabledAndAriaDisabledRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button disabled="<%= is_disabled %>" aria-disabled="<%= aria_disabled %>">Dynamic</button>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-body-only-elements.test.ts b/javascript/packages/linter/test/rules/html-body-only-elements.test.ts
new file mode 100644
index 000000000..23c4b6b41
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-body-only-elements.test.ts
@@ -0,0 +1,147 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+import { HTMLBodyOnlyElementsRule } from "../../src/rules/html-body-only-elements.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLBodyOnlyElementsRule)
+
+describe("html-body-only-elements", () => {
+  test("passes when elements are inside body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>Test</title>
+        </head>
+        <body>
+          <header>
+            <h1>Welcome</h1>
+            <nav>
+              <ul>
+                <li>Home</li>
+              </ul>
+            </nav>
+          </header>
+          <main>
+            <article>
+              <section>
+                <p>Content</p>
+                <table>
+                  <tr><td>Data</td></tr>
+                </table>
+              </section>
+            </article>
+            <aside>
+              <form>
+                <input type="text">
+              </form>
+            </aside>
+          </main>
+          <footer>
+            <h2>Footer</h2>
+          </footer>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when header is in head", () => {
+    expectError("Element `<header>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <header>This should not be here</header>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when heading is in head", () => {
+    expectError("Element `<h1>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <h1>Wrong place</h1>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when multiple elements are in head", () => {
+    expectError("Element `<nav>` must be placed inside the `<body>` tag.")
+    expectError("Element `<p>` must be placed inside the `<body>` tag.")
+    expectError("Element `<form>` must be placed inside the `<body>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <nav>Navigation</nav>
+          <p>Paragraph</p>
+          <form>Form</form>
+        </head>
+        <body>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes with valid ERB content in body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <body>
+          <% if user_signed_in? %>
+            <header>
+              <h1><%= @title %></h1>
+            </header>
+          <% end %>
+        </body>
+      </html>
+    `)
+  })
+
+  describe("tests all body-only elements", () => {
+    const bodyOnlyElements = [
+      "header", "main", "nav", "section", "footer", "article", "aside", "form",
+      "h1", "h2", "h3", "h4", "h5", "h6", "p", "ul", "table"
+    ]
+
+    bodyOnlyElements.forEach(element => {
+      test(`tests ${element} body-only elements`, () => {
+        expectError(`Element \`<${element}>\` must be placed inside the \`<body>\` tag.`)
+
+        assertOffenses(dedent`
+          <html>
+            <head>
+              <${element}>Content</${element}>
+            </head>
+            <body>
+            </body>
+          </html>
+        `)
+      })
+    })
+  })
+
+  test("passes for allowed elements in head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>Page Title</title>
+          <meta charset="utf-8">
+          <link rel="stylesheet" href="style.css">
+          <script src="script.js"></script>
+          <style>body { margin: 0; }</style>
+        </head>
+        <body>
+          <h1>Content</h1>
+        </body>
+      </html>
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
index f125acf33..4067856a3 100644
--- a/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
+++ b/javascript/packages/linter/test/rules/html-boolean-attributes-no-value.test.ts
@@ -1,144 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLBooleanAttributesNoValueRule } from "../../src/rules/html-boolean-attributes-no-value.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-boolean-attributes-no-value", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLBooleanAttributesNoValueRule)
 
+describe("html-boolean-attributes-no-value", () => {
   test("passes for boolean attributes without values", () => {
-    const html = '<input type="checkbox" checked disabled>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<input type="checkbox" checked disabled>')
   })
 
   test("fails for boolean attributes with explicit values", () => {
-    const html = '<input type="checkbox" checked="checked" disabled="disabled">'
+    expectError('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="disabled"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
-
-    expect(lintResult.offenses[0].rule).toBe("html-boolean-attributes-no-value")
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[1].rule).toBe("html-boolean-attributes-no-value")
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="disabled"`.')
-    expect(lintResult.offenses[1].severity).toBe("error")
+    assertOffenses('<input type="checkbox" checked="checked" disabled="disabled">')
   })
 
   test("fails for boolean attributes with true/false values", () => {
-    const html = '<button disabled="true">Submit</button>'
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="true"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="true"`.')
+    assertOffenses('<button disabled="true">Submit</button>')
   })
 
   test("passes for non-boolean attributes with values", () => {
-    const html = '<input type="text" value="Username" name="user">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<input type="text" value="Username" name="user">')
   })
 
   test("handles multiple boolean attributes", () => {
-    const html = '<select multiple="multiple"><option selected="selected">Option 1</option></select>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `multiple` should not have a value. Use `multiple` instead of `multiple="multiple"`.')
+    expectError('Boolean attribute `selected` should not have a value. Use `selected` instead of `selected="selected"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `multiple` should not have a value. Use `multiple` instead of `multiple="multiple"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `selected` should not have a value. Use `selected` instead of `selected="selected"`.')
+    assertOffenses('<select multiple="multiple"><option selected="selected">Option 1</option></select>')
   })
 
   test("handles self-closing tags with boolean attributes", () => {
-    const html = '<input type="checkbox" checked="checked" required="true" />'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
+    expectError('Boolean attribute `required` should not have a value. Use `required` instead of `required="true"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `checked` should not have a value. Use `checked` instead of `checked="checked"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `required` should not have a value. Use `required` instead of `required="true"`.')
+    assertOffenses('<input type="checkbox" checked="checked" required="true" />')
   })
 
   test("handles case insensitive boolean attributes", () => {
-    const html = '<input CHECKED="CHECKED" DISABLED="disabled">'
+    expectError('Boolean attribute `CHECKED` should not have a value. Use `checked` instead of `CHECKED="CHECKED"`.')
+    expectError('Boolean attribute `DISABLED` should not have a value. Use `disabled` instead of `DISABLED="disabled"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `CHECKED` should not have a value. Use `checked` instead of `CHECKED="CHECKED"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `DISABLED` should not have a value. Use `disabled` instead of `DISABLED="disabled"`.')
+    assertOffenses('<input CHECKED="CHECKED" DISABLED="disabled">')
   })
 
   test("passes for video controls", () => {
-    const html = '<video controls>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<video controls></video>')
   })
 
   test("fails for video controls with value", () => {
-    const html = '<video controls="controls" autoplay="autoplay">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="controls"`.')
+    expectError('Boolean attribute `autoplay` should not have a value. Use `autoplay` instead of `autoplay="autoplay"`.')
 
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="controls"`.')
-    expect(lintResult.offenses[1].message).toBe('Boolean attribute `autoplay` should not have a value. Use `autoplay` instead of `autoplay="autoplay"`.')
+    assertOffenses('<video controls="controls" autoplay="autoplay"></video>')
   })
 
   test("fails for boolean attribute with different value", () => {
-    const html = '<video controls="something-else">'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="something-else"`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `controls` should not have a value. Use `controls` instead of `controls="something-else"`.')
+    assertOffenses('<video controls="something-else"></video>')
   })
 
   test("handles mixed boolean and regular attributes", () => {
-    const html = '<form novalidate="novalidate" action="/submit" method="post">'
+    expectError('Boolean attribute `novalidate` should not have a value. Use `novalidate` instead of `novalidate="novalidate"`.')
 
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `novalidate` should not have a value. Use `novalidate` instead of `novalidate="novalidate"`.')
+    assertOffenses('<form novalidate="novalidate" action="/submit" method="post"></form>')
   })
 
   test("fails for boolean attributes with ERB output value", () => {
-    const html = '<button disabled="<%= disabled? %>">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLBooleanAttributesNoValueRule])
-    const lintResult = linter.lint(html)
+    expectError('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="<%= disabled? %>"`.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Boolean attribute `disabled` should not have a value. Use `disabled` instead of `disabled="<%= disabled? %>"`.')
+    assertOffenses('<button disabled="<%= disabled? %>">Submit</button>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-head-only-elements.test.ts b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
new file mode 100644
index 000000000..97a3c28bd
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-head-only-elements.test.ts
@@ -0,0 +1,283 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+import { HTMLHeadOnlyElementsRule } from "../../src/rules/html-head-only-elements.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLHeadOnlyElementsRule)
+
+describe("html-head-only-elements", () => {
+  test("passes when head-only elements are inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+          <meta charset="UTF-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <link rel="stylesheet" href="/styles.css">
+          <style>body { color: red }</style>
+          <base href="/">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when ERB helpers are inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <%= csrf_meta_tags %>
+          <%= csp_meta_tag %>
+          <%= favicon_link_tag 'favicon.ico' %>
+          <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+          <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when title is in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <title>My Page</title>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes for head-only elements on the top-level", () => {
+    expectNoOffenses(dedent`
+      <meta>
+      <link>
+      <base>
+      <title></title>
+      <style></style>
+    `)
+  })
+
+  test.todo("fails for head-only elements on the top-level when other body-elements are present", () => {
+    expectNoOffenses(dedent`
+      <meta>
+      <link>
+      <base>
+      <title></title>
+      <style></style>
+
+      <div></div>
+    `)
+  })
+
+  test("fails when meta is in body", () => {
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <meta charset="UTF-8">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when link is in body", () => {
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <link rel="stylesheet" href="/styles.css">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when style is in body", () => {
+    expectError("Element `<style>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <style>body { color: red }</style>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when base is in body", () => {
+    expectError("Element `<base>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <base href="/">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails for multiple head-only elements in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <title>My Page</title>
+          <meta charset="UTF-8">
+          <link rel="stylesheet" href="/styles.css">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  // TODO: this should be handled in https://github.com/marcoroth/herb/issues/638
+  test.fails("fails when elements are outside html structure", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <title>My Page</title>
+      <meta charset="UTF-8">
+
+      <html>
+        <head>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("works with ERB templates in body", () => {
+    expectError("Element `<title>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+        </head>
+        <body>
+          <%= csrf_meta_tags %>
+          <%= csp_meta_tag %>
+          <%= favicon_link_tag 'favicon.ico' %>
+          <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
+          <title><%= content_for?(:title) ? yield(:title) : "Default Title" %></title>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows other elements in body", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <h1>Welcome</h1>
+          <p>This is content</p>
+          <div>
+            <span>Some text</span>
+          </div>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows title element inside SVG", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <svg>
+            <title>Chart Title</title>
+            <rect width="100" height="100"/>
+          </svg>
+        </body>
+      </html>
+    `)
+  })
+
+  test("allows nested title elements inside nested SVG", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <div>
+            <svg>
+              <g>
+                <title>Group Title</title>
+                <rect width="100" height="100"/>
+              </g>
+            </svg>
+          </div>
+        </body>
+      </html>
+    `)
+  })
+
+  test("still fails for other head-only elements inside SVG", () => {
+    expectError("Element `<meta>` must be placed inside the `<head>` tag.")
+    expectError("Element `<link>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <title>My Page</title>
+        </head>
+        <body>
+          <svg>
+            <meta charset="UTF-8" />
+            <link rel="stylesheet" href="/styles.css" />
+            <title>Chart Title</title>
+          </svg>
+        </body>
+      </html>
+    `)
+  })
+
+  test.todo("head in body", () => {
+    expectError("Element `<head>` must be placed inside the `<head>` tag.")
+
+    assertOffenses(dedent`
+      <html>
+        <body>
+          <head></head>
+        </body>
+      </html>
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
index bad9a8462..38e72e4eb 100644
--- a/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
+++ b/javascript/packages/linter/test/rules/html-iframe-has-title.test.ts
@@ -1,168 +1,78 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLIframeHasTitleRule } from "../../src/rules/html-iframe-has-title.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-iframe-has-title", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLIframeHasTitleRule)
 
+describe("html-iframe-has-title", () => {
   test("passes for iframe with title attribute", () => {
-    const html = '<iframe src="https://example.com" title="Example website content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<iframe src="https://example.com" title="Example website content"></iframe>`)
   })
 
   test("fails for iframe with empty title attribute", () => {
-    const html = '<iframe src="https://example.com" title=""></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" title=""></iframe>`)
   })
 
   test("fails for iframe with empty title attribute", () => {
-    const html = '<iframe src="https://example.com" title=" "></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" title=" "></iframe>`)
   })
 
   test("fails for iframe without title attribute", () => {
-    const html = '<iframe src="https://example.com"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
-    expect(lintResult.offenses[0].message).toBe("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com"></iframe>`)
   })
 
   test("fails for self-closing iframe without title", () => {
-    const html = '<iframe src="https://example.com" />'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" />`)
   })
 
   test("passes for iframe with descriptive title", () => {
-    const html = '<iframe src="https://youtube.com/embed/123" title="Product demonstration video"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://youtube.com/embed/123" title="Product demonstration video"></iframe>`)
   })
 
   test("ignores non-iframe elements", () => {
-    const html = '<div src="https://example.com">Not an iframe</div>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div src="https://example.com">Not an iframe</div>`)
   })
 
   test("ignores frame elements (different tag)", () => {
-    const html = '<frame src="https://example.com">'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<frame src="https://example.com"></frame>`)
   })
 
   test("handles mixed case iframe tag", () => {
-    const html = '<IFRAME src="https://example.com"></IFRAME>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<IFRAME src="https://example.com"></IFRAME>`)
   })
 
   test("passes for mixed case title attribute", () => {
-    const html = '<iframe src="https://example.com" TITLE="Example content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" TITLE="Example content"></iframe>`)
   })
 
   test("handles multiple iframe elements", () => {
-    const html = `
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`
       <iframe src="https://example1.com" title="First iframe"></iframe>
       <iframe src="https://example2.com"></iframe>
       <iframe src="https://example3.com" title="Third iframe"></iframe>
-    `
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    `)
   })
 
   test("passes for iframe with ERB title content", () => {
-    const html = '<iframe src="https://example.com" title="<%= content_title %>"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" title="<%= content_title %>"></iframe>`)
   })
 
   test("passes for iframe with multiple attributes", () => {
-    const html = '<iframe src="https://example.com" width="600" height="400" frameborder="0" title="Embedded content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe src="https://example.com" width="600" height="400" frameborder="0" title="Embedded content"></iframe>`)
   })
 
   test("fails for iframe with other attributes but no title", () => {
-    const html = '<iframe src="https://example.com" width="600" height="400" frameborder="0"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-iframe-has-title")
+    expectError("`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.")
+    assertOffenses(`<iframe src="https://example.com" width="600" height="400" frameborder="0"></iframe>`)
   })
 
   test("passes for iframe with aria-hidden='true'", () => {
-    const html = '<iframe aria-hidden="true"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLIframeHasTitleRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<iframe aria-hidden="true"></iframe>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-img-require-alt.test.ts b/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
index 42c3bd0ad..766f46751 100644
--- a/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
+++ b/javascript/packages/linter/test/rules/html-img-require-alt.test.ts
@@ -1,108 +1,48 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLImgRequireAltRule } from "../../src/rules/html-img-require-alt.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-img-require-alt", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLImgRequireAltRule)
 
+describe("html-img-require-alt", () => {
   test("passes for img with alt attribute", () => {
-    const html = '<img src="/logo.png" alt="Company logo">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/logo.png" alt="Company logo">')
   })
 
   test("passes for img with empty alt attribute", () => {
-    const html = '<img src="/divider.png" alt="">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<img src="/divider.png" alt="">')
   })
 
   test("fails for img without alt attribute", () => {
-    const html = '<img src="/logo.png">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-img-require-alt")
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png">')
   })
 
   test("fails for multiple img tags without alt", () => {
-    const html = '<img src="/logo.png"><img src="/banner.jpg">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png"><img src="/banner.jpg">')
   })
 
   test("handles mixed case img tags", () => {
-    const html = '<IMG src="/logo.png">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<IMG src="/logo.png">')
   })
 
   test("passes for img with ERB alt attribute", () => {
-    const html = '<img src="/avatar.jpg" alt="<%= user.name %>\'s profile picture">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="/avatar.jpg" alt="<%= user.name %>\'s profile picture">')
   })
 
   test("ignores non-img tags", () => {
-    const html = '<div src="/something.png"></div>'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div src="/something.png"></div>')
   })
 
   test("handles self-closing img tags", () => {
-    const html = '<img src="/logo.png" />'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    expectError('Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.')
+    assertOffenses('<img src="/logo.png" />')
   })
 
   test("passes for case-insensitive alt attribute", () => {
-    const html = '<img src="/logo.png" ALT="Logo">'
-    
-    const linter = new Linter(Herb, [HTMLImgRequireAltRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="/logo.png" ALT="Logo">')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts b/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts
new file mode 100644
index 000000000..19bd35c4b
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-input-require-autocomplete.test.ts
@@ -0,0 +1,64 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { HTMLInputRequireAutocompleteRule } from "../../src/rules/html-input-require-autocomplete.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLInputRequireAutocompleteRule)
+
+describe("HTMLInputRequireAutocompleteRule", () => {
+  test("when autocomplete is present on input types", () => {
+    expectNoOffenses(dedent`
+      <input type="email" autocomplete="foo">
+    `)
+  })
+
+  test("when input type does not require autocomplete attribute and it is not present", () => {
+    expectNoOffenses(dedent`
+      <input type="bar">
+    `)
+  })
+
+  test("when input type requires autocomplete attribute and it is not present", () => {
+    expectError("Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.")
+
+    assertOffenses(dedent`
+      <input type="email">
+    `)
+  })
+
+  describe.todo("Action View Helpers", () => {
+    const formHelpersRequiringAutocomplete = [
+      'date_field_tag',
+      'color_field_tag',
+      'email_field_tag',
+      'text_field_tag',
+      'utf8_enforcer_tag',
+      'month_field_tag',
+      'number_field_tag',
+      'password_field_tag',
+      'search_field_tag',
+      'telephone_field_tag',
+      'time_field_tag',
+      'url_field_tag',
+      'week_field_tag',
+    ]
+
+    formHelpersRequiringAutocomplete.forEach(formHelper => {
+      test(`usage of "${formHelper}" helper with autocomplete value`, () => {
+        expectNoOffenses(dedent`
+          <%= text_field_tag 'foo', autocomplete: 'foo' %>
+        `)
+      })
+
+      test(`usage of "${formHelper}" helper without autocomplete value`, () => {
+        expectError("Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.")
+
+        expectNoOffenses(dedent`
+          <%= ${formHelper} 'foo' autocomplete: 'foo' %>
+        `)
+      })
+    })
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts b/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
index b6744a93a..9a9c18dd9 100644
--- a/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
+++ b/javascript/packages/linter/test/rules/html-navigation-has-label.test.ts
@@ -1,167 +1,74 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNavigationHasLabelRule } from "../../src/rules/html-navigation-has-label.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-navigation-has-label", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNavigationHasLabelRule)
 
+describe("html-navigation-has-label", () => {
   test("passes for nav with aria-label", () => {
-    const html = '<nav aria-label="Main navigation"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<nav aria-label="Main navigation"><a href="/">Home</a></nav>`)
   })
 
   test("passes for nav with aria-labelledby", () => {
-    const html = '<nav aria-labelledby="nav-heading"><h2 id="nav-heading">Site Navigation</h2><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-labelledby="nav-heading"><h2 id="nav-heading">Site Navigation</h2><a href="/">Home</a></nav>`)
   })
 
   test("passes for nav with both aria-label and aria-labelledby", () => {
-    const html = '<nav aria-label="Primary" aria-labelledby="nav-heading"><h2 id="nav-heading">Navigation</h2><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label="Primary" aria-labelledby="nav-heading"><h2 id="nav-heading">Navigation</h2><a href="/">Home</a></nav>`)
   })
 
   test("fails for nav without aria-label or aria-labelledby", () => {
-    const html = '<nav><a href="/">Home</a><a href="/about">About</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-navigation-has-label")
-    expect(lintResult.offenses[0].message).toBe("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    assertOffenses(`<nav><a href="/">Home</a><a href="/about">About</a></nav>`)
   })
 
   test("passes for element with role=navigation and aria-label", () => {
-    const html = '<div role="navigation" aria-label="Breadcrumb navigation"><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="navigation" aria-label="Breadcrumb navigation"><a href="/">Home</a></div>`)
   })
 
   test("passes for element with role=navigation and aria-labelledby", () => {
-    const html = '<div role="navigation" aria-labelledby="breadcrumb-label"><span id="breadcrumb-label">Breadcrumb</span><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="navigation" aria-labelledby="breadcrumb-label"><span id="breadcrumb-label">Breadcrumb</span><a href="/">Home</a></div>`)
   })
 
   test("fails for element with role=navigation without labeling", () => {
-    const html = '<div role="navigation"><a href="/">Home</a><a href="/about">About</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-navigation-has-label")
-    expect(lintResult.offenses[0].message).toBe("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced. Additionally, you can safely drop the `role=\"navigation\"` and replace it with the native HTML `<nav>` element.")
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced. Additionally, you can safely drop the `role=\"navigation\"` and replace it with the native HTML `<nav>` element.")
+    assertOffenses(`<div role="navigation"><a href="/">Home</a><a href="/about">About</a></div>`)
   })
 
   test("ignores elements without navigation role", () => {
-    const html = '<div><a href="/">Home</a><a href="/about">About</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><a href="/">Home</a><a href="/about">About</a></div>`)
   })
 
   test("ignores elements with other roles", () => {
-    const html = '<div role="banner"><a href="/">Home</a></div>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div role="banner"><a href="/">Home</a></div>`)
   })
 
   test("handles mixed case attributes", () => {
-    const html = '<nav ARIA-LABEL="Main navigation"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav ARIA-LABEL="Main navigation"><a href="/">Home</a></nav>`)
   })
 
   test("handles mixed case nav tag", () => {
-    const html = '<NAV aria-label="Main navigation"><a href="/">Home</a></NAV>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<NAV aria-label="Main navigation"><a href="/">Home</a></NAV>`)
   })
 
   test("handles multiple navigation elements", () => {
-    const html = `
+    expectError("The navigation landmark should have a unique accessible name via `aria-label` or `aria-labelledby`. Remember that the name does not need to include \"navigation\" or \"nav\" since it will already be announced.")
+    assertOffenses(`
       <nav aria-label="Primary navigation"><a href="/">Home</a></nav>
       <nav><a href="/sitemap">Sitemap</a></nav>
       <div role="navigation" aria-label="Breadcrumb"><a href="/">Home</a></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
+    `)
   })
 
   test("passes for navigation with ERB content in labels", () => {
-    const html = '<nav aria-label="<%= navigation_label %>"><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label="<%= navigation_label %>"><a href="/">Home</a></nav>`)
   })
 
   test("passes for empty aria-label (technically has the attribute)", () => {
-    const html = '<nav aria-label=""><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-label=""><a href="/">Home</a></nav>`)
   })
 
   test("passes for empty aria-labelledby (technically has the attribute)", () => {
-    const html = '<nav aria-labelledby=""><a href="/">Home</a></nav>'
-
-    const linter = new Linter(Herb, [HTMLNavigationHasLabelRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<nav aria-labelledby=""><a href="/">Home</a></nav>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts b/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
index 0bfdcbb6c..1a53fd86d 100644
--- a/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-aria-hidden-on-focusable.test.ts
@@ -1,209 +1,104 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoAriaHiddenOnFocusableRule } from "../../src/rules/html-no-aria-hidden-on-focusable.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-aria-hidden-on-focusable", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoAriaHiddenOnFocusableRule)
 
+describe("html-no-aria-hidden-on-focusable", () => {
   test("passes for focusable element without aria-hidden", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("passes for focusable element with aria-hidden='false'", () => {
-    const html = '<button aria-hidden="false">Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="false">Click me</button>`)
   })
 
   test("passes for non-focusable element with aria-hidden='true'", () => {
-    const html = '<div aria-hidden="true">Hidden content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div aria-hidden="true">Hidden content</div>`)
   })
 
   test("fails for button with aria-hidden='true'", () => {
-    const html = '<button aria-hidden="true">Hidden button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-aria-hidden-on-focusable")
-    expect(lintResult.offenses[0].message).toBe("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<button aria-hidden="true">Hidden button</button>`)
   })
 
   test("fails for input with aria-hidden='true'", () => {
-    const html = '<input type="text" aria-hidden="true">'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-aria-hidden-on-focusable")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<input type="text" aria-hidden="true">`)
   })
 
   test("fails for select with aria-hidden='true'", () => {
-    const html = '<select aria-hidden="true"><option>Test</option></select>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<select aria-hidden="true"><option>Test</option></select>`)
   })
 
   test("fails for textarea with aria-hidden='true'", () => {
-    const html = '<textarea aria-hidden="true"></textarea>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<textarea aria-hidden="true"></textarea>`)
   })
 
   test("fails for anchor with href and aria-hidden='true'", () => {
-    const html = '<a href="/" aria-hidden="true">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<a href="/" aria-hidden="true">Link</a>`)
   })
 
   test("fails for summary with aria-hidden='true'", () => {
-    const html = '<details><summary aria-hidden="true">Details</summary><p>Content</p></details>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<details><summary aria-hidden="true">Details</summary><p>Content</p></details>`)
   })
 
   test("passes for anchor without href and aria-hidden='true'", () => {
-    const html = '<a aria-hidden="true">Not a link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a aria-hidden="true">Not a link</a>`)
   })
 
   test("fails for div with tabindex='0' and aria-hidden='true'", () => {
-    const html = '<div tabindex="0" aria-hidden="true">Focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<div tabindex="0" aria-hidden="true">Focusable div</div>`)
   })
 
   test("passes for div with tabindex='-1' and aria-hidden='true'", () => {
-    const html = '<div tabindex="-1" aria-hidden="true">Programmatically focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-1" aria-hidden="true">Programmatically focusable div</div>`)
   })
 
   test("fails for span with tabindex='1' and aria-hidden='true'", () => {
-    const html = '<span tabindex="1" aria-hidden="true">Focusable span</span>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<span tabindex="1" aria-hidden="true">Focusable span</span>`)
   })
 
   test("passes for button with tabindex='-1' and aria-hidden='true'", () => {
-    const html = '<button tabindex="-1" aria-hidden="true">Button removed from tab order</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button tabindex="-1" aria-hidden="true">Button removed from tab order</button>`)
   })
 
   test("handles mixed case attributes", () => {
-    const html = '<button ARIA-HIDDEN="true">Hidden button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<button ARIA-HIDDEN="true">Hidden button</button>`)
   })
 
   test("handles mixed case element names", () => {
-    const html = '<BUTTON aria-hidden="true">Hidden button</BUTTON>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`<BUTTON aria-hidden="true">Hidden button</BUTTON>`)
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    expectError("Elements that are focusable should not have `aria-hidden=\"true\"` because it will cause confusion for assistive technology users.")
+    assertOffenses(`
       <button aria-hidden="true">Bad button</button>
       <div aria-hidden="true">OK div</div>
       <input type="text" aria-hidden="true">
       <div tabindex="0" aria-hidden="false">OK focusable div</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("ignores aria-hidden with non-boolean values", () => {
-    const html = '<button aria-hidden="maybe">Button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="maybe">Button</button>`)
   })
 
   test("passes for elements with ERB content in aria-hidden", () => {
-    const html = '<button aria-hidden="<%= hidden_state %>">Dynamic button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<button aria-hidden="<%= hidden_state %>">Dynamic button</button>`)
   })
 
   test("passes for elements with ERB content in tabindex", () => {
-    const html = '<div tabindex="<%= tab_index %>" aria-hidden="true">Dynamic tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoAriaHiddenOnFocusableRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="<%= tab_index %>" aria-hidden="true">Dynamic tabindex</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts b/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
index adc2533fc..5b3597303 100644
--- a/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-block-inside-inline.test.ts
@@ -1,270 +1,130 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoBlockInsideInlineRule } from "../../src/rules/html-no-block-inside-inline.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-block-inside-inline", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoBlockInsideInlineRule)
 
+describe("html-no-block-inside-inline", () => {
   test("passes for inline elements containing other inline elements", () => {
-    const html = '<span>Hello <strong>World</strong></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<span>Hello <strong>World</strong></span>`)
   })
 
   test("passes for block elements containing block elements", () => {
-    const html = '<div><p>Paragraph inside div (valid)</p></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div><p>Paragraph inside div (valid)</p></div>`)
   })
 
   test("fails for div inside span", () => {
-    const html = '<span><div>Invalid block inside span</div></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-block-inside-inline")
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><div>Invalid block inside span</div></span>`)
   })
 
   test("fails for paragraph inside span", () => {
-    const html = '<span><p>Paragraph inside span (invalid)</p></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><p>Paragraph inside span (invalid)</p></span>`)
   })
 
   test("fails for multiple block elements inside inline", () => {
-    const html = '<span><div>First</div><p>Second</p></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<p>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><div>First</div><p>Second</p></span>`)
   })
 
   test("fails for block inside anchor tag", () => {
-    const html = '<a href="#"><div>Link with div</div></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<a>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<a>`.')
+    assertOffenses(`<a href="#"><div>Link with div</div></a>`)
   })
 
   test("fails for heading inside strong", () => {
-    const html = '<strong><h1>Heading in strong</h1></strong>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<h1>` cannot be placed inside inline element `<strong>`.')
+    expectError('Block-level element `<h1>` cannot be placed inside inline element `<strong>`.')
+    assertOffenses(`<strong><h1>Heading in strong</h1></strong>`)
   })
 
   test("fails for section inside em", () => {
-    const html = '<em><section>Section in em</section></em>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<section>` cannot be placed inside inline element `<em>`.')
+    expectError('Block-level element `<section>` cannot be placed inside inline element `<em>`.')
+    assertOffenses(`<em><section>Section in em</section></em>`)
   })
 
   test("passes for nested inline elements", () => {
-    const html = '<span><a href="#"><em><strong>Valid nesting</strong></em></a></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span><a href="#"><em><strong>Valid nesting</strong></em></a></span>`)
   })
 
   test("fails for deeply nested block in inline", () => {
-    const html = '<span><em><strong><div>Deeply nested div</div></strong></em></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<strong>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<strong>`.')
+    assertOffenses(`<span><em><strong><div>Deeply nested div</div></strong></em></span>`)
   })
 
   test("passes for inline elements with text and inline children", () => {
-    const html = '<span>Text before <code>code</code> text after</span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span>Text before <code>code</code> text after</span>`)
   })
 
   test("fails for list inside inline element", () => {
-    const html = '<span><ul><li>Item</li></ul></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<ul>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<ul>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><ul><li>Item</li></ul></span>`)
   })
 
   test("handles ERB templates correctly", () => {
-    const html = '<span><%= render partial: "some/partial" %></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<span><%= render partial: "some/partial" %></span>`)
   })
 
   test("fails for form inside button", () => {
-    const html = '<button><form action="/submit">Submit</form></button>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<form>` cannot be placed inside inline element `<button>`.')
+    expectError('Block-level element `<form>` cannot be placed inside inline element `<button>`.')
+    assertOffenses(`<button><form action="/submit">Submit</form></button>`)
   })
 
   test("fails for table inside label", () => {
-    const html = '<label><table><tr><td>Cell</td></tr></table></label>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<table>` cannot be placed inside inline element `<label>`.')
+    expectError('Block-level element `<table>` cannot be placed inside inline element `<label>`.')
+    assertOffenses(`<label><table><tr><td>Cell</td></tr></table></label>`)
   })
 
   test("fails for custom elements inside inline elements", () => {
-    const html = '<span><my-component>Custom content</my-component></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><my-component>Custom content</my-component></span>`)
   })
 
   test("passes for block elements inside custom elements", () => {
-    const html = '<my-inline-component><div>Block inside custom</div></my-inline-component>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<my-inline-component><div>Block inside custom</div></my-inline-component>`)
   })
 
   test("fails for custom elements with various naming patterns inside inline", () => {
-    const html = `
+    expectError('Unknown element `<x-button>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<app-icon>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-very-long-component-name>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`
       <span>
         <x-button>Click me</x-button>
         <app-icon></app-icon>
         <my-very-long-component-name>Content</my-very-long-component-name>
       </span>
-    `
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<x-button>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[1].message).toBe('Unknown element `<app-icon>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[2].message).toBe('Unknown element `<my-very-long-component-name>` cannot be placed inside inline element `<span>`.')
+    `)
   })
 
   test("still fails for standard block elements after custom elements", () => {
-    const html = '<span><my-component>Custom</my-component><div>Block div</div></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
-    expect(lintResult.offenses[1].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<my-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><my-component>Custom</my-component><div>Block div</div></span>`)
   })
 
   test("fails for nested custom elements inside inline", () => {
-    const html = '<span><outer-component><inner-component><div>Content</div></inner-component></outer-component></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<outer-component>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<outer-component>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><outer-component><inner-component><div>Content</div></inner-component></outer-component></span>`)
   })
 
   test("fails for single-word custom elements inside inline", () => {
-    const html = '<span><customtag><div>Block inside unknown element</div></customtag></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<customtag>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<customtag>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><customtag><div>Block inside unknown element</div></customtag></span>`)
   })
 
   test("fails for unknown elements inside inline but allows content inside unknown elements", () => {
-    const html = '<span><unknownelement><randomtag><div>Block content</div></randomtag></unknownelement></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Unknown element `<unknownelement>` cannot be placed inside inline element `<span>`.')
+    expectError('Unknown element `<unknownelement>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><unknownelement><randomtag><div>Block content</div></randomtag></unknownelement></span>`)
   })
 
   test("passes for custom elements at top level", () => {
-    const html = '<my-component><div>Block inside custom</div></my-component>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<my-component><div>Block inside custom</div></my-component>`)
   })
 
   test("fails for inline element containg erb node containing block node", () => {
-    const html = '<span><% if true %><div>Not allowed</div><% end %></span>'
-    
-    const linter = new Linter(Herb, [HTMLNoBlockInsideInlineRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    expectError('Block-level element `<div>` cannot be placed inside inline element `<span>`.')
+    assertOffenses(`<span><% if true %><div>Not allowed</div><% end %></span>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
index 37247f13e..b0b727383 100644
--- a/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-attributes.test.ts
@@ -1,97 +1,44 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoDuplicateAttributesRule } from "../../src/rules/html-no-duplicate-attributes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-duplicate-attributes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateAttributesRule)
 
+describe("html-no-duplicate-attributes", () => {
   test("passes for unique attributes", () => {
-    const html = '<input type="text" name="username" id="user-id">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<input type="text" name="username" id="user-id">`)
   })
 
   test("fails for duplicate attributes", () => {
-    const html = '<input type="text" type="password" name="username">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-duplicate-attributes")
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<input type="text" type="password" name="username">`)
   })
 
   test("fails for multiple duplicate attributes", () => {
-    const html = '<button type="submit" type="button" class="btn" class="primary">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // One for type, one for class
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError('Duplicate attribute `type` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<button type="submit" type="button" class="btn" class="primary"></button>`)
   })
 
   test("handles case-insensitive duplicates", () => {
-    const html = '<div Class="container" class="active">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `class` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<div Class="container" class="active"></div>`)
   })
 
   test("passes for different attributes", () => {
-    const html = '<div class="container" id="main" data-value="test">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="container" id="main" data-value="test"></div>`)
   })
 
   test("handles self-closing tags", () => {
-    const html = '<img src="/logo.png" src="/backup.png" alt="Logo">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Duplicate attribute `src` found on tag. Remove the duplicate occurrence.')
+    expectError('Duplicate attribute `src` found on tag. Remove the duplicate occurrence.')
+    assertOffenses(`<img src="/logo.png" src="/backup.png" alt="Logo">`)
   })
 
   test("handles ERB templates with attributes", () => {
-    const html = '<div class="<%= classes %>" data-id="<%= item.id %>">'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="<%= classes %>" data-id="<%= item.id %>"></div>`)
   })
 
   test("ignores closing tags", () => {
-    const html = '<div class="test"></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoDuplicateAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="test"></div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
index ca25f3b61..573b89f45 100644
--- a/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-ids.test.ts
@@ -1,127 +1,66 @@
 import dedent from "dedent"
-import { Herb } from "@herb-tools/node-wasm";
-import { beforeAll, describe, expect, test } from "vitest";
-import { Linter } from "../../src/linter.js";
-import { HTMLNoDuplicateIdsRule } from "../../src/rules/html-no-duplicate-ids.js";
+import { describe, test } from "vitest"
+import { HTMLNoDuplicateIdsRule } from "../../src/rules/html-no-duplicate-ids.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-duplicate-ids", () => {
-  beforeAll(async () => {
-    await Herb.load();
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateIdsRule)
 
+describe("html-no-duplicate-ids", () => {
   test("passes for unique IDs", () => {
-    const html = '<div id="unique1"></div><span id="unique2"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id="unique1"></div><span id="unique2"></span>`)
   })
 
   test("fails for duplicate IDs", () => {
-    const html = '<div id="duplicate"></div><span id="duplicate"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-duplicate-ids");
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `duplicate` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[0].severity).toBe("error");
+    expectError('Duplicate ID `duplicate` found. IDs must be unique within a document.')
+    assertOffenses(`<div id="duplicate"></div><span id="duplicate"></span>`)
   })
 
   test("passes for missing IDs", () => {
-    const html = '<div></div><span></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div></div><span></span>`)
   })
 
   test("passes for IDs without value", () => {
-    const html = '<div id=""></div><span id="  "></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id=""></div><span id="  "></span>`)
   })
 
   test("passes for other attributes with equal value", () => {
-    const html = '<div class="value"></div><div class="value"></div>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div class="value"></div><div class="value"></div>`)
   })
 
   test("passes when using ERB in ID", () => {
-    const html = '<div id="<%= user.id %>"></div>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    expectNoOffenses(`<div id="<%= user.id %>"></div>`)
   })
 
   // TODO: this should also warn if it's in the same "context"
   test.todo("fails for multiple duplicate IDs in ERB in the same context", () => {
-    const html = '<div id="<%= user.id %>"></div><span id="<%= user.id %>"></span>';
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `<%= user.id %>` found. IDs must be unique within a document.');
+    expectError('Duplicate ID `<%= user.id %>` found. IDs must be unique within a document.')
+    assertOffenses(`<div id="<%= user.id %>"></div><span id="<%= user.id %>"></span>`)
   })
 
   test("passes for IDs in mutually exclusive if/else branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if some_condition? %>
         <span id="my-id">content1</span>
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for IDs in mutually exclusive unless/else branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% unless some_condition? %>
         <span id="my-id">content1</span>
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for IDs in mutually exclusive unless/else branches and global", () => {
-    const html = dedent`
+    expectError('Duplicate ID `my-id` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `my-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <span id="my-id">content</span>
 
       <% unless some_condition? %>
@@ -129,21 +68,11 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <span id="my-id">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `my-id` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[1].message).toBe('Duplicate ID `my-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for IDs in mutually exclusive case/when branches", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% case status %>
       <% when 'active' %>
         <div id="status-indicator">Active</div>
@@ -152,18 +81,14 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="status-indicator">Unknown</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for IDs in mutually exclusive case/when branches and global", () => {
-    const html = dedent`
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    expectError('Duplicate ID `status-indicator` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="status-indicator">Active</div>
 
       <% case status %>
@@ -174,40 +99,22 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="status-indicator">Unknown</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(3);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(3);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[1].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
-    expect(lintResult.offenses[2].message).toBe('Duplicate ID `status-indicator` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for duplicate IDs within same control flow branch", () => {
-    const html = dedent`
+    expectError('Duplicate ID `duplicate-in-branch` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <span id="duplicate-in-branch">content1</span>
         <span id="duplicate-in-branch">content2</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `duplicate-in-branch` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("fails for IDs duplicated outside of control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="global-duplicate">outside</div>
 
       <% if some_condition? %>
@@ -215,58 +122,34 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside again</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside before control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <div id="global-duplicate">outside</div>
 
       <% if some_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif another_condition? %>
@@ -276,20 +159,12 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for IDs duplicated outside after control flow", () => {
-    const html = dedent`
+    expectError('Duplicate ID `global-duplicate` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif other_condition? %>
@@ -297,20 +172,11 @@ describe("html-no-duplicate-ids", () => {
       <% end %>
 
       <div id="global-duplicate">outside</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `global-duplicate` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for IDs duplicated in elsif and else", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if some_condition? %>
         <!-- empty -->
       <% elsif other_condition? %>
@@ -318,18 +184,11 @@ describe("html-no-duplicate-ids", () => {
       <% else other_condition? %>
         <span id="global-duplicate">inside branch</span>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("handles nested control flow properly", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if outer_condition? %>
         <% if inner_condition? %>
           <div id="nested-id">inner true</div>
@@ -339,33 +198,20 @@ describe("html-no-duplicate-ids", () => {
       <% else %>
         <div id="nested-id">outer false</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for ID tag.div (ERBBlockNode)", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% tag.div do %>
         <div id="user">User</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for output ERB IDs in loops (unique per iteration)", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-<%= user.id %>` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% users.each do |user| %>
         <div id="user-<%= user.id %>">User</div>
       <% end %>
@@ -373,38 +219,21 @@ describe("html-no-duplicate-ids", () => {
       <% users.each do |user| %>
         <div id="user-<%= user.id %>">User again</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-<%= user.id %>` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for non-output ERB IDs in loops (same value repeated)", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% users.each do |user| %>
         <div id="user-<% 'static' %>">User</div>
         <div id="user-<% 'static' %>">Duplicate</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("passes for output ERB IDs in while loops", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% counter = 0 %>
       <% count = 0 %>
 
@@ -414,156 +243,82 @@ describe("html-no-duplicate-ids", () => {
         <div id="post-<%= counter %>">Post</div>
         <% counter += 1 %>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for static ID in while loops", () => {
-    const html = dedent`
+    expectError('Duplicate ID `static-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% while condition %>
         <div id="static-id">Item</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `static-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("fails for non-dynamic ID in until loops", () => {
-    const html = dedent`
+    expectError('Duplicate ID `static-id` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% until condition %>
         <div id="static-id">Item</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `static-id` found. IDs must be unique within a document.');
+    `)
   })
 
   test("handles output ERB IDs in conditional flow normally", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% if condition %>
         <div id="user-<%= user.id %>">User A</div>
       <% else %>
         <div id="user-<%= user.id %>">User B</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("fails for duplicate output ERB IDs within same conditional branch", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user-<%= user.id %>` found within the same control flow branch. IDs must be unique within the same control flow branch.')
+    assertOffenses(dedent`
       <% if condition %>
         <div id="user-<%= user.id %>">User A</div>
         <div id="user-<%= user.id %>">User A duplicate</div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user-<%= user.id %>` found within the same control flow branch. IDs must be unique within the same control flow branch.');
+    `)
   })
 
   test("passes for static ID conflicting with dynamic ID prefix", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello">Static</div>
       <div id="hello<%= suffix %>">Dynamic</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for dynamic ID conflicting with existing static ID", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello<%= suffix %>">Dynamic</div>
       <div id="hello">Static</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test("passes for non-conflicting static and dynamic IDs", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div id="hello">Static</div>
       <div id="goodbye<%= suffix %>">Dynamic</div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 
   test.todo("fails for static attribute in a loop context", () => {
-    const html = dedent`
+    expectError('Duplicate ID `user` found. IDs must be unique within a document.')
+    assertOffenses(dedent`
       <% @users.each do |user| %>
         <div id="user"></div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(1);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(1);
-
-    expect(lintResult.offenses[0].message).toBe('Duplicate ID `user` found. IDs must be unique within a document.');
+    `)
   })
 
   test("passes for dynamic attribute in a ERBBlockNode each context", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <% @users.each do |user| %>
         <div id="<%= user.id %>"></div>
       <% end %>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoDuplicateIdsRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.warnings).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts b/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts
new file mode 100644
index 000000000..14e5c2b41
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-no-duplicate-meta-names.test.ts
@@ -0,0 +1,552 @@
+import dedent from "dedent"
+
+import { describe, test } from "vitest"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+import { HTMLNoDuplicateMetaNamesRule } from "../../src/rules/html-no-duplicate-meta-names.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoDuplicateMetaNamesRule)
+
+describe("html-no-duplicate-meta-names", () => {
+  test("passes when meta names are unique", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="Welcome to our site">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="author" content="John Doe">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when http-equiv values are unique", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta http-equiv="refresh" content="30">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("passes when mixing name and http-equiv attributes", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="Welcome to our site">
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when meta names are duplicated", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails when http-equiv values are duplicated", () => {
+    expectError('Duplicate `<meta>` tag with `http-equiv="X-UA-Compatible"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta http-equiv="X-UA-Compatible" content="IE=edge">
+          <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles case insensitive duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="Description" content="Welcome to our site">
+          <meta name="description" content="Another description">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("fails with multiple duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+          <meta name="description" content="First description">
+          <meta name="description" content="Second description">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("ignores meta tags without name or http-equiv attributes", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <meta charset="ISO-8859-1">
+          <meta property="og:title" content="Page Title">
+          <meta property="og:title" content="Another Title">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("only checks meta tags inside head", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        </head>
+        <body>
+          <meta name="viewport" content="width=1024">
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("works with ERB templates", () => {
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="description" content="<%= @page_description %>">
+          <meta name="description" content="<%= @fallback_description %>">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles self-closing meta tags", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+          <meta name="viewport" content="width=1024" />
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles mixed name and http-equiv duplicates", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `http-equiv="refresh"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <meta name="viewport" content="width=1024">
+          <meta http-equiv="refresh" content="30">
+          <meta http-equiv="refresh" content="60">
+        </head>
+        <body>
+          <h1>Welcome</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("handles erb conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% elsif hotwire_native_app? %>
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates when meta tags are outside and inside erb conditionals", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates between global meta tag and erb else branch", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+
+        <% if mobile? %>
+          <meta http-equiv="refresh" content="30">
+        <% else %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates when meta tag is outside erb conditional block", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta http-equiv="refresh" content="30">
+        <% else %>
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <% end %>
+
+        <meta name="viewport" content="width=1024">
+      </head>
+    `)
+  })
+
+  test("handles nested erb conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <% if ios? %>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <% else %>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test.todo("detects duplicates in nested conditionals within same execution path", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the same control flow branch.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width">
+          <% if ios? %>
+            <meta name="viewport" content="width=1024">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects static duplicate meta tags in loops", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("allows dynamic meta tags in loops", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% keywords.each do |keyword| %>
+          <meta name="keyword" content="<%= keyword %>">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicate in loop and outside loop", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="width=1024">
+        <% items.each do |item| %>
+          <meta name="viewport" content="width=device-width">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("resets checking for each head tag", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width">
+        </head>
+        <body>
+          <h1>First document</h1>
+        </body>
+      </html>
+      <html>
+        <head>
+          <meta name="viewport" content="width=1024">
+        </head>
+        <body>
+          <h1>Second document</h1>
+        </body>
+      </html>
+    `)
+  })
+
+  test("detects duplicates within each head tag separately", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="description"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <html>
+        <head>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        </head>
+      </html>
+      <html>
+        <head>
+          <meta name="description" content="First">
+          <meta name="description" content="Second">
+        </head>
+      </html>
+    `)
+  })
+
+  test("handles meta tags with whitespace in attribute values", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="  viewport  " content="width=device-width">
+        <meta name="viewport" content="width=1024">
+      </head>
+    `)
+  })
+
+  test("treats empty name attributes as different from missing", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <meta name="" content="value1">
+        <meta name="" content="value2">
+        <meta content="value3">
+        <meta content="value4">
+      </head>
+    `)
+  })
+
+  test("detects duplicates in elsif branches", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="description" content="Mobile">
+        <% elsif tablet? %>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="description" content="Desktop">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("allows same meta across if and elsif branches", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% if mobile? %>
+          <meta name="viewport" content="width=device-width">
+        <% elsif tablet? %>
+          <meta name="viewport" content="width=1024">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles conditional inside loop", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.mobile? %>
+            <meta name="viewport" content="<%= item.viewport %>">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+
+  test.todo("detects static duplicate in conditional inside loop", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the same loop iteration.')
+
+    assertOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.mobile? %>
+            <meta name="viewport" content="mobile">
+          <% else %>
+            <meta name="viewport" content="desktop">
+          <% end %>
+          <meta name="viewport" content="always">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles http-equiv case insensitivity", () => {
+    expectError('Duplicate `<meta>` tag with `http-equiv="x-ua-compatible"`. `http-equiv` values should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta http-equiv="x-ua-compatible" content="chrome=1">
+      </head>
+    `)
+  })
+
+  test("detects all duplicate occurrences when there are three or more", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" content="first">
+        <meta name="viewport" content="second">
+        <meta name="viewport" content="third">
+      </head>
+    `)
+  })
+
+  test("handles ERB output in name attribute", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <meta name="<%= meta_name_1 %>" content="value1">
+        <meta name="<%= meta_name_2 %>" content="value2">
+      </head>
+    `)
+  })
+
+  test.todo("detects duplicates with partial ERB in name", () => {
+    expectError('Duplicate `<meta>` tag with `name="prefix-viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="prefix-viewport" content="value1">
+        <meta name="prefix-<%= 'viewport' %>" content="value2">
+      </head>
+    `)
+  })
+
+  test("handles unless conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% unless mobile? %>
+          <meta name="viewport" content="width=1024">
+        <% else %>
+          <meta name="viewport" content="width=device-width">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("detects duplicates in unless branch", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"` within the same control flow branch. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <% unless mobile? %>
+          <meta name="viewport" content="width=1024">
+          <meta name="viewport" content="width=768">
+        <% end %>
+      </head>
+    `)
+  })
+
+  test("handles document without head tag", () => {
+    expectNoOffenses(dedent`
+      <html>
+        <body>
+          <meta name="viewport" content="width=device-width">
+          <meta name="viewport" content="width=1024">
+        </body>
+      </html>
+    `)
+  })
+
+  test("detects duplicate when meta has both name and http-equiv (edge case)", () => {
+    expectError('Duplicate `<meta>` tag with `name="viewport"`. Meta names should be unique within the `<head>` section.')
+
+    assertOffenses(dedent`
+      <head>
+        <meta name="viewport" http-equiv="refresh" content="value1">
+        <meta name="viewport" content="value2">
+      </head>
+    `)
+  })
+
+  test("allows same meta in different loop iterations with conditionals", () => {
+    expectNoOffenses(dedent`
+      <head>
+        <% items.each do |item| %>
+          <% if item.active? %>
+            <meta name="status" content="<%= item.id %>">
+          <% end %>
+        <% end %>
+      </head>
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts b/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
index 6a71543b4..7a4d17d21 100644
--- a/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-empty-attributes.test.ts
@@ -1,362 +1,146 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoEmptyAttributesRule } from "../../src/rules/html-no-empty-attributes.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-empty-attributes", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLNoEmptyAttributesRule)
 
+describe("html-no-empty-attributes", () => {
   test("passes for attributes with meaningful values", () => {
-    const html = '<div id="header" class="container" name="main"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div id="header" class="container" name="main"></div>`)
   })
 
   test("fails for empty id attribute", () => {
-    const html = '<div id=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div id=""></div>`)
   })
 
   test("fails for empty class attribute", () => {
-    const html = '<div class=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div class=""></div>`)
   })
 
   test("fails for empty name attribute", () => {
-    const html = '<input name="">'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `name` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `name` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<input name="">`)
   })
 
   test("fails for empty for attribute", () => {
-    const html = '<label for="">Label</label>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `for` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `for` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<label for="">Label</label>`)
   })
 
   test("fails for empty src attribute", () => {
-    const html = '<img src="" alt="Image">'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `src` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `src` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<img src="" alt="Image">`)
   })
 
   test("fails for empty href attribute", () => {
-    const html = '<a href="">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `href` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `href` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<a href="">Link</a>`)
   })
 
   test("fails for empty title attribute", () => {
-    const html = '<a href="https://example.com" title="">Link</a>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `title` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `title` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<a href="https://example.com" title="">Link</a>`)
   })
 
   test("fails for empty data attribute", () => {
-    const html = '<div data=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `data` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `data` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div data=""></div>`)
   })
 
   test("fails for data-* attributes with empty values", () => {
-    const html = '<div data-value="" data-config=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
+    expectWarning('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
+    assertOffenses(`<div data-value="" data-config=""></div>`)
   })
 
   test("fails for aria-* attributes with empty values", () => {
-    const html = '<button aria-label="" aria-describedby="">Button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `aria-label` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `aria-describedby` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `aria-label` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `aria-describedby` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<button aria-label="" aria-describedby="">Button</button>`)
   })
 
   test("fails for role attribute with empty value", () => {
-    const html = '<div role=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `role` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `role` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div role=""></div>`)
   })
 
   test("fails for multiple empty attributes", () => {
-    const html = '<div id="" class="" data-test=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(3)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
-    expect(lintResult.offenses[2].message).toBe('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
-    expect(lintResult.offenses[2].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
+    assertOffenses(`<div id="" class="" data-test=""></div>`)
   })
 
   test("fails for whitespace-only values", () => {
-    const html = '<div id="   " class=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Attribute `id` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div id="   " class=""></div>`)
   })
 
   test("passes for attributes with ERB output", () => {
-    const html = '<div id="<%= element_id %>" class="<%= css_classes %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div id="<%= element_id %>" class="<%= css_classes %>"></div>`)
   })
 
   test("passes for mixed static and ERB content", () => {
-    const html = '<div class="base <%= additional_classes %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="base <%= additional_classes %>"></div>`)
   })
 
   test("fails for dynamic data-* attribute name with empty value", () => {
-    const html = '<div data-<%= key %>=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>=""`.')
+    assertOffenses(`<div data-<%= key %>=""></div>`)
   })
 
   test("fails for dynamic data-* composite name with empty value", () => {
-    const html = '<div data-<%= key %>-id=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>-id` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>-id` instead of `data-<%= key %>-id=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>-id` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>-id` instead of `data-<%= key %>-id=""`.')
+    assertOffenses(`<div data-<%= key %>-id=""></div>`)
   })
 
   test("fails for dynamic data-* attribute name with whitespace-only value", () => {
-    const html = '<div data-<%= key %>="   "></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>="   "`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-<%= key %>` should not have an empty value. Either provide a meaningful value or use `data-<%= key %>` instead of `data-<%= key %>="   "`.')
+    assertOffenses(`<div data-<%= key %>="   "></div>`)
   })
 
   test("fails for dynamic aria-* attribute name with empty value", () => {
-    const html = '<button aria-<%= prop %>=""></button>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `aria-<%= prop %>` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Attribute `aria-<%= prop %>` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<button aria-<%= prop %>=""></button>`)
   })
 
   test("passes for dynamic attribute name with ERB value", () => {
-    const html = '<div data-<%= key %>="<%= value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div data-<%= key %>="<%= value %>"></div>`)
   })
 
   test("fails for attribute with ERB that doesn't output anything", () => {
-    const html = '<div class="<% value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    expectWarning('Attribute `class` must not be empty. Either provide a meaningful value or remove the attribute entirely.')
+    assertOffenses(`<div class="<% value %>"></div>`)
   })
 
   test("passes for attribute with static value and ERB that doesn't output anything", () => {
-    const html = '<div class="something.<% value %>"></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div class="something.<% value %>"></div>`)
   })
 
   test("passes for data-* attributes without explicit values", () => {
-    const html = '<div data-test data-value data-config></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div data-test data-value data-config></div>`)
   })
 
   test("fails for data-* attributes with explicit empty string values", () => {
-    const html = '<div data-test="" data-value=""></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(2)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
-    expect(lintResult.offenses[1].message).toBe('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
-    expect(lintResult.offenses[1].severity).toBe("warning")
+    expectWarning('Data attribute `data-test` should not have an empty value. Either provide a meaningful value or use `data-test` instead of `data-test=""`.')
+    expectWarning('Data attribute `data-value` should not have an empty value. Either provide a meaningful value or use `data-value` instead of `data-value=""`.')
+    assertOffenses(`<div data-test="" data-value=""></div>`)
   })
 
   test("mixed data attributes: passes for implicit values, fails for explicit empty values", () => {
-    const html = '<div data-test data-config="" data-value></div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-config` should not have an empty value. Either provide a meaningful value or use `data-config` instead of `data-config=""`.')
+    assertOffenses(`<div data-test data-config="" data-value></div>`)
   })
 
   test("passes for data-turbo-permanent without value", () => {
-    const html = '<div data-turbo-permanent>Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<div data-turbo-permanent>Content</div>`)
   })
 
   test("fails for data-turbo-permanent with explicit empty value", () => {
-    const html = '<div data-turbo-permanent="">Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoEmptyAttributesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(1)
-
-    expect(lintResult.offenses[0].message).toBe('Data attribute `data-turbo-permanent` should not have an empty value. Either provide a meaningful value or use `data-turbo-permanent` instead of `data-turbo-permanent=""`.')
-    expect(lintResult.offenses[0].severity).toBe("warning")
+    expectWarning('Data attribute `data-turbo-permanent` should not have an empty value. Either provide a meaningful value or use `data-turbo-permanent` instead of `data-turbo-permanent=""`.')
+    assertOffenses(`<div data-turbo-permanent="">Content</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
index a27e3e4ed..b6aeca11a 100644
--- a/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-empty-headings.test.ts
@@ -1,299 +1,138 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoEmptyHeadingsRule } from "../../src/rules/html-no-empty-headings.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-empty-headings", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoEmptyHeadingsRule)
 
+describe("html-no-empty-headings", () => {
   test("passes for heading with text content", () => {
-    const html = '<h1>Heading Content</h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h1>Heading Content</h1>')
   })
 
   test("passes for heading with nested elements", () => {
-    const html = '<h2><span>Text</span></h2>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2><span>Text</span></h2>')
   })
 
   test("passes for heading with ERB content", () => {
-    const html = '<h3><%= title %></h3>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h3><%= title %></h3>')
   })
 
   test("fails for empty heading", () => {
-    const html = '<h1></h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+
+    assertOffenses('<h1></h1>')
   })
 
   test("fails for heading with only whitespace", () => {
-    const html = '<h2>   \n\t  </h2>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<h2>   \n\t  </h2>')
   })
 
   test("fails for self-closing heading", () => {
-    const html = '<h3 />'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<h3 />')
   })
 
   test("handles all heading levels h1-h6", () => {
-    const html = '<h1></h1><h2></h2><h3></h3><h4></h4><h5></h5><h6></h6>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(6)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(6)
-
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[1].message).toBe("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[5].message).toBe("Heading element `<h6>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h4>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h5>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h6>` must not be empty. Provide accessible text content for screen readers and SEO.")
+
+    assertOffenses('<h1></h1><h2></h2><h3></h3><h4></h4><h5></h5><h6></h6>')
   })
 
   test("handles mixed case heading tags", () => {
-    const html = '<H1></H1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    assertOffenses('<H1></H1>')
   })
 
   test("ignores non-heading tags", () => {
-    const html = '<div></div><p></p>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div></div><p></p>')
   })
 
   test("passes for headings with mixed content", () => {
-    const html = '<h1>Welcome <%= user.name %>!</h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<h1>Welcome <%= user.name %>!</h1>')
   })
 
   test("passes for heading with only ERB", () => {
-    const html = '<h1><%= page.title %></h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<h1><%= page.title %></h1>')
   })
 
   test("handles multiple empty headings", () => {
-    const html = '<h1></h1><h2>Valid</h2><h3></h3>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError("Heading element `<h3>` must not be empty. Provide accessible text content for screen readers and SEO.")
+
+    assertOffenses('<h1></h1><h2>Valid</h2><h3></h3>')
   })
 
   test("passes for div with role='heading' and content", () => {
-    const html = '<div role="heading" aria-level="1">Heading Content</div>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div role="heading" aria-level="1">Heading Content</div>')
   })
 
   test("fails for empty div with role='heading'", () => {
-    const html = '<div role="heading" aria-level="1"></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+
+    assertOffenses('<div role="heading" aria-level="1"></div>')
   })
 
   test("fails for div with role='heading' containing only whitespace", () => {
-    const html = '<div role="heading" aria-level="2">   </div>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<div role="heading" aria-level="2">   </div>')
   })
 
   test("fails for self-closing div with role='heading'", () => {
-    const html = '<div role="heading" aria-level="3" />'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<div role="heading" aria-level="3" />')
   })
 
   test("ignores div without role='heading'", () => {
-    const html = '<div></div><div role="button">Button</div>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div></div><div role="button">Button</div>')
   })
 
   test("handles mixed standard headings and ARIA headings", () => {
-    const html = '<h1></h1><div role="heading">Valid</div><h2>Valid</h2><div role="heading"></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(2)
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+    expectError('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
 
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[1].message).toBe('Heading element `<div role="heading">` must not be empty. Provide accessible text content for screen readers and SEO.')
+    assertOffenses('<h1></h1><div role="heading">Valid</div><h2>Valid</h2><div role="heading"></div>')
   })
 
   test("fails for heading with only aria-hidden content", () => {
-    const html = '<h1><span aria-hidden="true">Inaccessible text</span></h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-empty-headings")
-    expect(lintResult.offenses[0].message).toBe("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError("Heading element `<h1>` must not be empty. Provide accessible text content for screen readers and SEO.")
+
+    assertOffenses('<h1><span aria-hidden="true">Inaccessible text</span></h1>')
   })
 
   test("fails for heading with mixed accessible and inaccessible content", () => {
-    const html = '<h2><span aria-hidden="true">Hidden</span><span aria-hidden="true">Also hidden</span></h2>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
+    expectError("Heading element `<h2>` must not be empty. Provide accessible text content for screen readers and SEO.")
+
+    assertOffenses('<h2><span aria-hidden="true">Hidden</span><span aria-hidden="true">Also hidden</span></h2>')
   })
 
   test("passes for heading with mix of accessible and inaccessible content", () => {
-    const html = '<h3>Visible text<span aria-hidden="true">Hidden text</span></h3>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h3>Visible text<span aria-hidden="true">Hidden text</span></h3>')
   })
 
   test("passes for heading itself with aria-hidden='true' but has content", () => {
-    const html = '<h1 aria-hidden="true">Heading Content</h1>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h1 aria-hidden="true">Heading Content</h1>')
   })
 
   test("passes for heading itself with hidden attribute but has content", () => {
-    const html = '<h2 hidden>Heading Content</h2>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2 hidden>Heading Content</h2>')
+  })
+
+  test("passes for heading with nested span containing text", () => {
+    expectNoOffenses('<h3><span>Text</span></h3>')
   })
 
   test("passes for heading with nested span containing text", () => {
-    const html = '<h3><span>Text</span></h3>'
-    
-    const linter = new Linter(Herb, [HTMLNoEmptyHeadingsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<h2 class="class" data-turbo-temporary><%= content %></h2>')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-nested-links.test.ts b/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
index 0af945fe6..ce8c051be 100644
--- a/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-nested-links.test.ts
@@ -1,108 +1,48 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoNestedLinksRule } from "../../src/rules/html-no-nested-links.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-nested-links", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoNestedLinksRule)
 
+describe("html-no-nested-links", () => {
   test("passes for separate links", () => {
-    const html = '<a href="/products">View products</a><a href="/about">About us</a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<a href="/products">View products</a><a href="/about">About us</a>`)
   })
 
   test("fails for directly nested links", () => {
-    const html = '<a href="/products">View <a href="/special-offer">special offer</a></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-nested-links")
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
-    expect(lintResult.offenses[0].severity).toBe("error")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/products">View <a href="/special-offer">special offer</a></a>`)
   })
 
   test("fails for indirectly nested links", () => {
-    const html = '<a href="/main"><div><span><a href="/nested">Nested link</a></span></div></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/main"><div><span><a href="/nested">Nested link</a></span></div></a>`)
   })
 
   test("passes for links in different containers", () => {
-    const html = '<div><a href="/products">Products</a></div><div><a href="/special-offer">Special offer</a></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><a href="/products">Products</a></div><div><a href="/special-offer">Special offer</a></div>`)
   })
 
   test("fails for multiple levels of nesting", () => {
-    const html = '<a href="/level1"><a href="/level2"><a href="/level3">Deep nesting</a></a></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // Second and third links are nested
-    expect(lintResult.warnings).toBe(0)
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/level1"><a href="/level2"><a href="/level3">Deep nesting</a></a></a>`)
   })
 
   test("handles mixed case anchor tags", () => {
-    const html = '<a href="/main"><A href="/nested">Nested</A></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    expectError("Nested `<a>` elements are not allowed. Links cannot contain other links.")
+    assertOffenses(`<a href="/main"><A href="/nested">Nested</A></a>`)
   })
 
   test("passes for links with complex content", () => {
-    const html = '<a href="/profile"><img src="/avatar.jpg" alt="Avatar"><span>User Name</span></a>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<a href="/profile"><img src="/avatar.jpg" alt="Avatar"><span>User Name</span></a>`)
   })
 
   test("handles ERB templates with links", () => {
-    const html = '<div><% items.each do |item| %><a href="<%= item.url %>"><%= item.name %></a><% end %></div>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div><% items.each do |item| %><a href="<%= item.url %>"><%= item.name %></a><% end %></div>`)
   })
 
   test("fails for nested links in ERB", () => {
-    const html = '<%= link_to "Products", products_path do %><%= link_to "Special offer", offer_path %><% end %>'
-    
-    const linter = new Linter(Herb, [HTMLNoNestedLinksRule])
-    const lintResult = linter.lint(html)
-
-    // This test might not catch ERB helpers since they're not parsed as HTML elements
-    // but we're testing the structure we can detect
-    expect(lintResult.errors).toBe(0) // ERB helper calls are not HTML elements
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<%= link_to "Products", products_path do %><%= link_to "Special offer", offer_path %><% end %>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts b/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
index 3af933582..bd0c56256 100644
--- a/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-positive-tab-index.test.ts
@@ -1,148 +1,71 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoPositiveTabIndexRule } from "../../src/rules/html-no-positive-tab-index.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-positive-tab-index", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoPositiveTabIndexRule)
 
+describe("html-no-positive-tab-index", () => {
   test("passes for element without tabindex", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses(`<button>Click me</button>`)
   })
 
   test("passes for tabindex=\"0\"", () => {
-    const html = '<div tabindex="0">Focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="0">Focusable div</div>`)
   })
 
   test("passes for tabindex=\"-1\"", () => {
-    const html = '<div tabindex="-1">Programmatically focusable div</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-1">Programmatically focusable div</div>`)
   })
 
   test("passes for negative tabindex values", () => {
-    const html = '<div tabindex="-5">Skip in tab order</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="-5">Skip in tab order</div>`)
   })
 
   test("fails for tabindex=\"1\"", () => {
-    const html = '<div tabindex="1">Bad tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
-    expect(lintResult.offenses[0].message).toBe("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div tabindex="1">Bad tabindex</div>`)
   })
 
   test("fails for tabindex=\"2\"", () => {
-    const html = '<button tabindex="2">Bad button</button>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<button tabindex="2">Bad button</button>`)
   })
 
   test("fails for high positive tabindex", () => {
-    const html = '<input tabindex="999" type="text">'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<input tabindex="999" type="text">`)
   })
 
   test("handles multiple elements with mixed tabindex values", () => {
-    const html = `
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`
       <button tabindex="0">OK</button>
       <button tabindex="1">Bad</button>
       <button tabindex="-1">Skip</button>
       <button tabindex="2">Also bad</button>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes for non-numeric tabindex values", () => {
-    const html = '<div tabindex="invalid">Should be handled by other rules</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="invalid">Should be handled by other rules</div>`)
   })
 
   test("passes for empty tabindex", () => {
-    const html = '<div tabindex="">Empty value</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="">Empty value</div>`)
   })
 
   test("passes for tabindex with ERB content", () => {
-    const html = '<div tabindex="<%= tab_index %>">Dynamic tabindex</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses(`<div tabindex="<%= tab_index %>">Dynamic tabindex</div>`)
   })
 
   test("handles mixed case attribute names", () => {
-    const html = '<div TABINDEX="1">Mixed case</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div TABINDEX="1">Mixed case</div>`)
   })
 
   test("handles tabindex with leading/trailing spaces", () => {
-    const html = '<div tabindex="  1  ">With spaces</div>'
-
-    const linter = new Linter(Herb, [HTMLNoPositiveTabIndexRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-positive-tab-index")
+    expectError("Do not use positive `tabindex` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use `tabindex=\"0\"` to make an element focusable or `tabindex=\"-1\"` to remove it from the tab sequence.")
+    assertOffenses(`<div tabindex="  1  ">With spaces</div>`)
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-self-closing.test.ts b/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
index c0d648cb5..0f7ce3523 100644
--- a/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-self-closing.test.ts
@@ -1,15 +1,12 @@
-import { Herb } from "@herb-tools/node-wasm";
-import { beforeAll, describe, expect, test } from "vitest";
-import { Linter } from "../../src/linter.js";
-import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js";
+import { describe, test } from "vitest"
+import { HTMLNoSelfClosingRule } from "../../src/rules/html-no-self-closing.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-self-closing", () => {
-  beforeAll(async () => {
-    await Herb.load();
-  });
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoSelfClosingRule)
 
+describe("html-no-self-closing", () => {
   test("passes for standard HTML tags", () => {
-    const html = `
+    expectNoOffenses(`
       <div></div>
       <span></span>
       <section></section>
@@ -18,151 +15,95 @@ describe("html-no-self-closing", () => {
       <input type="text">
       <br>
       <hr>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for self-closing non-void elements", () => {
-    const html = `
+    expectError('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
+    expectError('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
+    expectError('Use `<svg></svg>` instead of self-closing `<svg />` for HTML compatibility.')
+    assertOffenses(`
       <div />
       <span />
       <section />
       <custom-element />
       <svg />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(5);
-    expect(lintResult.offenses).toHaveLength(5);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-self-closing");
-    expect(lintResult.offenses[0].severity).toBe("error");
-
-    expect(lintResult.offenses[0].message).toBe('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[2].message).toBe('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
-    expect(lintResult.offenses[3].message).toBe('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
-    expect(lintResult.offenses[4].message).toBe('Use `<svg></svg>` instead of self-closing `<svg />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("fails for self-closing void elements", () => {
-    const html = `
+    expectError('Use `<img>` instead of self-closing `<img />` for HTML compatibility.')
+    expectError('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
+    expectError('Use `<br>` instead of self-closing `<br />` for HTML compatibility.')
+    expectError('Use `<hr>` instead of self-closing `<hr />` for HTML compatibility.')
+    assertOffenses(`
       <img src="/logo.png" alt="Logo" />
       <input type="text" />
       <br />
       <hr />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(4);
-    expect(lintResult.offenses).toHaveLength(4);
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-self-closing");
-    expect(lintResult.offenses[0].severity).toBe("error");
-
-    expect(lintResult.offenses[0].message).toBe('Use `<img>` instead of self-closing `<img />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
-    expect(lintResult.offenses[2].message).toBe('Use `<br>` instead of self-closing `<br />` for HTML compatibility.')
-    expect(lintResult.offenses[3].message).toBe('Use `<hr>` instead of self-closing `<hr />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for mixed correct and incorrect tags", () => {
-    const html = `
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
+    assertOffenses(`
       <div></div>
       <span />
       <input type="text">
       <input type="text" />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<input>` instead of self-closing `<input />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for nested non-self-closing tags", () => {
-    const html = `
+    expectNoOffenses(`
       <div>
         <span></span>
         <section></section>
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for nested self-closing tags", () => {
-    const html = `
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    expectError('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
+    assertOffenses(`
       <div>
         <span />
         <section />
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<section></section>` instead of self-closing `<section />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for custom elements without self-closing", () => {
-    const html = `
+    expectNoOffenses(`
       <custom-element></custom-element>
       <another-custom></another-custom>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for custom elements with self-closing", () => {
-    const html = `
+    expectError('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
+    expectError('Use `<another-custom></another-custom>` instead of self-closing `<another-custom />` for HTML compatibility.')
+    assertOffenses(`
       <custom-element />
       <another-custom />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<custom-element></custom-element>` instead of self-closing `<custom-element />` for HTML compatibility.')
-    expect(lintResult.offenses[1].message).toBe('Use `<another-custom></another-custom>` instead of self-closing `<another-custom />` for HTML compatibility.')
-  });
+    `)
+  })
 
   test("passes for void elements without self-closing", () => {
-    const html = `
+    expectNoOffenses(`
       <img src="/logo.png" alt="Logo">
       <input type="text">
       <br>
       <hr>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("passes for self-closing elements inside SVG", () => {
-    const html = `
+    expectNoOffenses(`
       <div class="flex items-center text-xs text-gray-500 mt-1">
         <svg class="w-3 h-3 mr-1 fill-gray-400" viewBox="0 0 24 24">
           <path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z" />
@@ -170,30 +111,19 @@ describe("html-no-self-closing", () => {
           <rect x="0" y="0" width="24" height="24" />
         </svg>
       </div>
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(0);
-    expect(lintResult.offenses).toHaveLength(0);
-  });
+    `)
+  })
 
   test("fails for self-closing elements outside SVG but passes inside SVG", () => {
-    const html = `
+    expectError('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.')
+    expectError('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.')
+    assertOffenses(`
       <div />
       <svg class="w-3 h-3" viewBox="0 0 24 24">
         <path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z" />
         <circle cx="12" cy="12" r="10" />
       </svg>
       <span />
-    `;
-    const linter = new Linter(Herb, [HTMLNoSelfClosingRule]);
-    const lintResult = linter.lint(html);
-
-    expect(lintResult.errors).toBe(2);
-    expect(lintResult.offenses).toHaveLength(2);
-
-    expect(lintResult.offenses[0].message).toBe('Use `<div></div>` instead of self-closing `<div />` for HTML compatibility.');
-    expect(lintResult.offenses[1].message).toBe('Use `<span></span>` instead of self-closing `<span />` for HTML compatibility.');
-  });
-});
+    `)
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts b/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts
new file mode 100644
index 000000000..38ade222f
--- /dev/null
+++ b/javascript/packages/linter/test/rules/html-no-space-in-tag.test.ts
@@ -0,0 +1,209 @@
+import dedent from "dedent"
+import { describe, test } from "vitest"
+import { HTMLNoSpaceInTagRule } from "../../src/rules/html-no-space-in-tag.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
+
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoSpaceInTagRule)
+
+describe("HTMLNoSpaceInTagRule", () => {
+  describe("when space is correct", () => {
+    test("plain opening tag", () => {
+      expectNoOffenses(`<div>`, { allowInvalidSyntax: true })
+    })
+
+    test("closing tag", () => {
+      expectNoOffenses(`</div>`, { allowInvalidSyntax: true })
+    })
+
+    test("tag with no name", () => {
+      expectNoOffenses(`</>`, { allowInvalidSyntax: true })
+    })
+
+    test("empty tag", () => {
+      expectNoOffenses(`<>`, { allowInvalidSyntax: true })
+    })
+
+    test("void tag", () => {
+      expectNoOffenses(`<img />`)
+    })
+
+    test("plain tag with attribute", () => {
+      expectNoOffenses(`<div class="foo"></div>`)
+    })
+
+    test("between attributes", () => {
+      expectNoOffenses(`<input class="foo" name="bar">`)
+    })
+
+    test("multi line tag", () => {
+      expectNoOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+        >
+      `)
+    })
+
+    test("tag with erb", () => {
+      expectNoOffenses(`<input <%= attributes %>>`)
+    })
+
+    test("multi line tag with erb", () => {
+      expectNoOffenses(dedent`
+        <input
+          type="password"
+          <%= attributes %>
+          class="foo"
+        >
+      `)
+    })
+
+    test("multi line tag with erb nested", () => {
+      expectNoOffenses(dedent`
+        <div>
+          <input
+            type="password"
+            <%= attributes %>
+            class="foo"
+          >
+        </div>
+      `)
+    })
+  })
+
+  describe("when no space should be present", () => {
+    test("after name", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div   ></div>`)
+    })
+
+    test("before name", () => {
+      expectNoOffenses(`<   div></div>`, { allowInvalidSyntax: true })
+    })
+
+    test("before start solidus", () => {
+      expectNoOffenses(`<div><   /div>`, { allowInvalidSyntax: true })
+    })
+
+    test("after start solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div></   div>`)
+    })
+
+    test("after end solidus", () => {
+      expectNoOffenses(`<div><div /   >`, { allowInvalidSyntax: true })
+    })
+  })
+
+  describe("when space is missing", () => {
+    test("between attributes", () => {
+      expectNoOffenses(`<div foo='foo'bar='bar'></div>`, { allowInvalidSyntax: true })
+    })
+
+    test("between last attribute and solidus", () => {
+      expectError("No space detected where there should be a single space.")
+      assertOffenses(`<div foo='bar'/>`)
+    })
+
+    test("between name and solidus", () => {
+      expectError("No space detected where there should be a single space.")
+      assertOffenses(`<div/>`)
+    })
+  })
+
+  describe("when extra space is present", () => {
+    test("between name and end of tag", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<div  ></div>`)
+    })
+
+    test("between name and first attribute", () => {
+      expectError("Extra space detected where there should be a single space.")
+      assertOffenses(`<img   class="hide">`)
+    })
+
+    test("between name and end solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<br   />`)
+    })
+
+    test("between last attribute and solidus", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<br class="hide"   />`)
+    })
+
+    test("between last attribute and end of tag", () => {
+      expectError("Extra space detected where there should be no space.")
+      assertOffenses(`<img class="hide"    >`)
+    })
+
+    test("between attributes", () => {
+      expectError("Extra space detected where there should be a single space.")
+      assertOffenses(`<div foo='foo'      bar='bar'></div>`)
+    })
+
+    test("extra newline between name and first attribute", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+
+          type="password" />
+      `)
+    })
+
+    test("extra newline between name and end of tag", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+
+          />
+      `)
+    })
+
+    test("extra newline between attributes", () => {
+      expectError("Extra space detected where there should be a single space or a single line break.")
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+
+          class="foo" />
+      `)
+    })
+
+    test("end solidus is on newline", () => {
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+          />
+      `)
+    })
+
+    test("end of tag is on newline", () => {
+      expectError("Extra space detected where there should be no space.")
+
+      assertOffenses(dedent`
+        <input
+          type="password"
+          class="foo"
+          >
+      `)
+    })
+
+    test("non-space detected between name and attribute", () => {
+      expectNoOffenses(`<input/class="hide" />`, { allowInvalidSyntax: true })
+    })
+
+    test("non-space detected between attributes", () => {
+      expectNoOffenses(`<input class="hide"/name="foo" />`, { allowInvalidSyntax: true })
+    })
+  })
+})
diff --git a/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts b/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
index 29d3f36e6..304cc0db2 100644
--- a/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-title-attribute.test.ts
@@ -1,188 +1,112 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLNoTitleAttributeRule } from "../../src/rules/html-no-title-attribute.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-title-attribute", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLNoTitleAttributeRule)
 
+describe("html-no-title-attribute", () => {
   test("passes for elements without title attribute", () => {
-    const html = '<button>Click me</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<button>Click me</button>')
   })
 
   test("passes for iframe with title attribute", () => {
-    const html = '<iframe src="https://example.com" title="Example content"></iframe>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<iframe src="https://example.com" title="Example content"></iframe>')
   })
 
   test("passes for link with title attribute", () => {
-    const html = '<link rel="stylesheet" href="styles.css" title="Main styles">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<link rel="stylesheet" href="styles.css" title="Main styles">')
   })
 
   test("fails for button with title attribute", () => {
-    const html = '<button title="Click to submit">Submit</button>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-title-attribute")
-    expect(lintResult.offenses[0].message).toBe("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+    assertOffenses('<button title="Click to submit">Submit</button>')
   })
 
   test("fails for div with title attribute", () => {
-    const html = '<div title="Additional information">Content</div>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].rule).toBe("html-no-title-attribute")
+    assertOffenses('<div title="Additional information">Content</div>')
   })
 
   test("fails for span with title attribute", () => {
-    const html = '<span title="Tooltip text">Hover me</span>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<span title="Tooltip text">Hover me</span>')
   })
 
   test("fails for input with title attribute", () => {
-    const html = '<input type="text" title="Enter your name" placeholder="Name">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<input type="text" title="Enter your name" placeholder="Name">')
   })
 
   test("fails for img with title attribute", () => {
-    const html = '<img src="image.jpg" alt="Description" title="Additional info">'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<img src="image.jpg" alt="Description" title="Additional info">')
   })
 
   test("fails for anchor with title attribute", () => {
-    const html = '<a href="/" title="Go to homepage">Home</a>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<a href="/" title="Go to homepage">Home</a>')
   })
 
   test("fails for abbr with title attribute", () => {
-    const html = '<abbr title="World Wide Web">WWW</abbr>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<abbr title="World Wide Web">WWW</abbr>')
   })
 
   test("handles mixed case element names", () => {
-    const html = '<BUTTON title="Submit form">Submit</BUTTON>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<BUTTON title="Submit form">Submit</BUTTON>')
   })
 
   test("handles mixed case title attribute", () => {
-    const html = '<button TITLE="Submit form">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button TITLE="Submit form">Submit</button>')
   })
 
   test("passes for mixed case allowed elements", () => {
-    const html = '<IFRAME src="https://example.com" title="Content"></IFRAME>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<IFRAME src="https://example.com" title="Content"></IFRAME>')
   })
 
   test("handles multiple elements", () => {
-    const html = `
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
+
+    assertOffenses(`
       <iframe src="https://example.com" title="OK iframe"></iframe>
       <button title="Bad button">Click</button>
       <link rel="stylesheet" href="styles.css" title="OK link">
       <div title="Bad div">Content</div>
       <span>OK span</span>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2)
-    expect(lintResult.offenses).toHaveLength(2)
+    `)
   })
 
   test("passes for empty title attribute", () => {
-    const html = '<button title="">Empty title</button>'
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button title="">Empty title</button>')
   })
 
   test("passes for title attribute with ERB content", () => {
-    const html = '<button title="<%= tooltip_text %>">Dynamic tooltip</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<button title="<%= tooltip_text %>">Dynamic tooltip</button>')
   })
 
   test("ignores elements with proper accessible alternatives", () => {
-    const html = '<button aria-label="Submit form">Submit</button>'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<button aria-label="Submit form">Submit</button>')
   })
 
   test("fails for self-closing elements with title", () => {
-    const html = '<input type="text" title="Enter name" />'
-
-    const linter = new Linter(Herb, [HTMLNoTitleAttributeRule])
-    const lintResult = linter.lint(html)
+    expectError("The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.")
 
-    expect(lintResult.errors).toBe(1)
+    assertOffenses('<input type="text" title="Enter name" />')
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
index bc96257d8..02a536615 100644
--- a/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
+++ b/javascript/packages/linter/test/rules/html-no-underscores-in-attribute-names.test.ts
@@ -1,78 +1,55 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src"
+import { describe, test } from "vitest"
 import { HTMLNoUnderscoresInAttributeNamesRule } from "../../src"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-no-underscores-in-attribute-names", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectWarning, assertOffenses } = createLinterTest(HTMLNoUnderscoresInAttributeNamesRule)
 
+describe("html-no-underscores-in-attribute-names", () => {
   test("passes for valid attribute names (hyphens, letters, digits, colon)", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div data-user-id="123" aria-label="Close"></div>
       <input data123-value="ok">
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("fails for attribute names with underscores", () => {
-    const html = dedent`
+    expectWarning("Attribute `data_user_id` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `aria_label` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `custom_attr` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
       <div data_user_id="123"></div>
       <img aria_label="Close">
       <custom-element custom_attr="x"></custom-element>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-
-    expect(lintResult.offenses[0].rule).toBe("html-no-underscores-in-attribute-names")
-    expect(lintResult.offenses[0].severity).toBe("warning")
-
-    expect(lintResult.offenses[0].message).toBe("Attribute `data_user_id` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[1].message).toBe("Attribute `aria_label` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[2].message).toBe("Attribute `custom_attr` should not contain underscores. Use hyphens (-) instead.")
+    `)
   })
 
   test("does not flag dynamic attribute names", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div data-<%=  %>="value"></div>
       <div <%= dynamic_name %>="value"></div>
       <div data-<%= key %>-test="value"></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("fails for dynamic attribute names with underscores", () => {
-    const html = dedent`
+    expectWarning("Attribute `data_<%= key %>` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `data_<%= key %>-test` should not contain underscores. Use hyphens (-) instead.")
+    expectWarning("Attribute `data-<%= key %>_test` should not contain underscores. Use hyphens (-) instead.")
+
+    assertOffenses(dedent`
       <div data_<%= key %>="value"></div>
       <div data_<%= key %>-test="value"></div>
       <div data-<%= key %>_test="value"></div>
-    `
-
-    const linter = new Linter(Herb, [HTMLNoUnderscoresInAttributeNamesRule])
-    const lintResult = linter.lint(html)
+    `)
+  })
 
-    expect(lintResult.warnings).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
+  test("handles malformed attributes without crashing (issue #601)", () => {
+    expectNoOffenses(`<input foo_bar=I18n.t('value')>`, { allowInvalidSyntax: true })
+  })
 
-    expect(lintResult.offenses[0].message).toBe("Attribute `data_<%= key %>` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[1].message).toBe("Attribute `data_<%= key %>-test` should not contain underscores. Use hyphens (-) instead.")
-    expect(lintResult.offenses[2].message).toBe("Attribute `data-<%= key %>_test` should not contain underscores. Use hyphens (-) instead.")
+  test("handles malformed attributes without crashing - exact snippet from issue #601", () => {
+    expectNoOffenses(`<input title=I18n.t('foo_bar')>`, { allowInvalidSyntax: true })
   })
 })
diff --git a/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts b/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
index ebe6ae896..7e1919c94 100644
--- a/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
+++ b/javascript/packages/linter/test/rules/html-tag-name-lowercase.test.ts
@@ -1,89 +1,49 @@
 import dedent from "dedent"
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { HTMLTagNameLowercaseRule } from "../../src/rules/html-tag-name-lowercase.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("html-tag-name-lowercase", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(HTMLTagNameLowercaseRule)
 
+describe("html-tag-name-lowercase", () => {
   test("passes for lowercase tag names", () => {
-    const html = '<div class="container"><span>Hello</span></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    expectNoOffenses('<div class="container"><span>Hello</span></div>')
   })
 
   test("fails for uppercase tag names", () => {
-    const html = '<DIV class="container"><SPAN>Hello</SPAN></DIV>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<SPAN>` should be lowercase. Use `<span>` instead.')
+    expectError('Closing tag name `</SPAN>` should be lowercase. Use `</span>` instead.')
+    expectError('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
 
-    expect(lintResult.errors).toBe(4) // DIV open, DIV close, SPAN open, SPAN close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("html-tag-name-lowercase")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
-    expect(lintResult.offenses[1].message).toBe('Opening tag name `<SPAN>` should be lowercase. Use `<span>` instead.')
-    expect(lintResult.offenses[2].message).toBe('Closing tag name `</SPAN>` should be lowercase. Use `</span>` instead.')
-    expect(lintResult.offenses[3].message).toBe('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
+    assertOffenses('<DIV class="container"><SPAN>Hello</SPAN></DIV>')
   })
 
   test("fails for mixed case tag names", () => {
-    const html = '<Div class="container"><Span>Hello</Span></Div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<Div>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<Span>` should be lowercase. Use `<span>` instead.')
+    expectError('Closing tag name `</Span>` should be lowercase. Use `</span>` instead.')
+    expectError('Closing tag name `</Div>` should be lowercase. Use `</div>` instead.')
 
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<Div>` should be lowercase. Use `<div>` instead.')
+    assertOffenses('<Div class="container"><Span>Hello</Span></Div>')
   })
 
   test("handles self-closing tags", () => {
-    const html = '<IMG src="photo.jpg" />'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
+    expectError('Opening tag name `<IMG>` should be lowercase. Use `<img>` instead.')
 
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<IMG>` should be lowercase. Use `<img>` instead.')
+    assertOffenses('<IMG src="photo.jpg" />')
   })
 
   test("passes for valid self-closing tags", () => {
-    const html = '<img src="photo.jpg" />'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<img src="photo.jpg" />')
   })
 
   test.skip("handles ERB templates", () => {
-    const html = '<div class="container"><%= content_tag(:DIV, "Hello world!") %></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div class="container"><%= content_tag(:DIV, "Hello world!") %></div>')
   })
 
   test("handles common HTML5 elements", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <article>
         <header><h1>Title</h1></header>
         <section>
@@ -92,17 +52,26 @@ describe("html-tag-name-lowercase", () => {
         </section>
         <footer>Footer</footer>
       </article>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("fails for uppercase HTML5 elements", () => {
-    const html = dedent`
+    expectError('Opening tag name `<ARTICLE>` should be lowercase. Use `<article>` instead.')
+    expectError('Opening tag name `<HEADER>` should be lowercase. Use `<header>` instead.')
+    expectError('Opening tag name `<H1>` should be lowercase. Use `<h1>` instead.')
+    expectError('Closing tag name `</H1>` should be lowercase. Use `</h1>` instead.')
+    expectError('Closing tag name `</HEADER>` should be lowercase. Use `</header>` instead.')
+    expectError('Opening tag name `<SECTION>` should be lowercase. Use `<section>` instead.')
+    expectError('Opening tag name `<P>` should be lowercase. Use `<p>` instead.')
+    expectError('Closing tag name `</P>` should be lowercase. Use `</p>` instead.')
+    expectError('Opening tag name `<ASIDE>` should be lowercase. Use `<aside>` instead.')
+    expectError('Closing tag name `</ASIDE>` should be lowercase. Use `</aside>` instead.')
+    expectError('Closing tag name `</SECTION>` should be lowercase. Use `</section>` instead.')
+    expectError('Opening tag name `<FOOTER>` should be lowercase. Use `<footer>` instead.')
+    expectError('Closing tag name `</FOOTER>` should be lowercase. Use `</footer>` instead.')
+    expectError('Closing tag name `</ARTICLE>` should be lowercase. Use `</article>` instead.')
+
+    assertOffenses(dedent`
       <ARTICLE>
         <HEADER><H1>Title</H1></HEADER>
         <SECTION>
@@ -111,49 +80,26 @@ describe("html-tag-name-lowercase", () => {
         </SECTION>
         <FOOTER>Footer</FOOTER>
       </ARTICLE>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(14)
-    expect(lintResult.warnings).toBe(0)
-
-    const errorMessages = lintResult.offenses.map(message => message.message)
-    expect(errorMessages.some(msg => msg.includes('ARTICLE'))).toBe(true)
-    expect(errorMessages.some(msg => msg.includes('HEADER'))).toBe(true)
-    expect(errorMessages.some(msg => msg.includes('H1'))).toBe(true)
+    `)
   })
 
   test("handles empty tags", () => {
-    const html = '<div></div>'
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    expectNoOffenses('<div></div>')
   })
 
   test("handles nested ERB within HTML", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <div class="<%= user.active? ? 'active' : 'inactive' %>">
         <h1><%= user.name %></h1>
         <% if user.admin? %>
           <span class="admin-badge">Admin</span>
         <% end %>
       </div>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("ignores SVG child elements (handled by svg-tag-name-capitalization rule)", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <linearGradient id="grad1">
           <stop offset="0%" />
@@ -165,66 +111,46 @@ describe("html-tag-name-lowercase", () => {
           <stop offset="50%" />
         </lineargradient>
       </svg>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still checks SVG tag itself for lowercase", () => {
-    const html = `
+    expectError('Opening tag name `<SVG>` should be lowercase. Use `<svg>` instead.')
+    expectError('Closing tag name `</SVG>` should be lowercase. Use `</svg>` instead.')
+
+    assertOffenses(`
       <SVG>
         <linearGradient id="grad1">
           <stop offset="0%" />
         </linearGradient>
       </SVG>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // opening and closing SVG tags
-    expect(lintResult.offenses[0].message).toBe('Opening tag name `<SVG>` should be lowercase. Use `<svg>` instead.')
-    expect(lintResult.offenses[1].message).toBe('Closing tag name `</SVG>` should be lowercase. Use `</svg>` instead.')
+    `)
   })
 
   test("is disabled when XMLDeclarationNode is present", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <?xml version="1.0" encoding="UTF-8"?>
       <ROOT>
         <ELEMENT>Content</ELEMENT>
       </ROOT>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still works normally without XMLDeclarationNode", () => {
-    const html = dedent`
+    expectError('Opening tag name `<ROOT>` should be lowercase. Use `<root>` instead.')
+    expectError('Opening tag name `<ELEMENT>` should be lowercase. Use `<element>` instead.')
+    expectError('Closing tag name `</ELEMENT>` should be lowercase. Use `</element>` instead.')
+    expectError('Closing tag name `</ROOT>` should be lowercase. Use `</root>` instead.')
+
+    assertOffenses(dedent`
       <ROOT>
         <ELEMENT>Content</ELEMENT>
       </ROOT>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4) // ROOT open, ELEMENT open, ELEMENT close, ROOT close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("is disabled with complex XML document", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <?xml version="1.0" encoding="UTF-8"?>
       <CATALOG>
         <BOOK id="1">
@@ -238,34 +164,25 @@ describe("html-tag-name-lowercase", () => {
           <PRICE>19.99</PRICE>
         </BOOK>
       </CATALOG>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("still works normally for regular .erb files", () => {
-    const htmlErb = dedent`
+    expectError('Opening tag name `<DIV>` should be lowercase. Use `<div>` instead.')
+    expectError('Opening tag name `<SECTION>` should be lowercase. Use `<section>` instead.')
+    expectError('Closing tag name `</SECTION>` should be lowercase. Use `</section>` instead.')
+    expectError('Closing tag name `</DIV>` should be lowercase. Use `</div>` instead.')
+
+    assertOffenses(dedent`
       <DIV>
         <%= render 'shared/header' %>
         <SECTION>Content</SECTION>
       </DIV>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(htmlErb, { fileName: 'template.html.erb' })
-
-    expect(lintResult.errors).toBe(4) // DIV open, DIV close, SECTION open, SECTION close
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(4)
+    `)
   })
 
   test("is disabled for .xml.erb files", () => {
-    const xmlErb = dedent`
+    expectNoOffenses(dedent`
       <CONFIGURATION>
         <%= render 'shared/settings' %>
         <DATABASE>
@@ -273,18 +190,11 @@ describe("html-tag-name-lowercase", () => {
           <PORT><%= db_port %></PORT>
         </DATABASE>
       </CONFIGURATION>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xmlErb, { fileName: 'config.xml.erb' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "config.xml.erb" })
   })
 
   test("handles .xml.erb files without XMLDeclarationNode", () => {
-    const xmlErb = dedent`
+    expectNoOffenses(dedent`
       <FEED>
         <% items.each do |item| %>
           <ITEM>
@@ -293,31 +203,17 @@ describe("html-tag-name-lowercase", () => {
           </ITEM>
         <% end %>
       </FEED>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xmlErb, { fileName: 'feed.xml.erb' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "feed.xml.erb" })
   })
 
   test("is disabled for .xml files", () => {
-    const xml = dedent`
+    expectNoOffenses(dedent`
       <CONFIGURATION>
         <DATABASE>
           <HOST>localhost</HOST>
           <PORT>5432</PORT>
         </DATABASE>
       </CONFIGURATION>
-    `
-
-    const linter = new Linter(Herb, [HTMLTagNameLowercaseRule])
-    const lintResult = linter.lint(xml, { fileName: 'config.xml' })
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `, { fileName: "config.xml" })
   })
 })
diff --git a/javascript/packages/linter/test/rules/parser-no-errors.test.ts b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
index ec1c4277b..5196c72c9 100644
--- a/javascript/packages/linter/test/rules/parser-no-errors.test.ts
+++ b/javascript/packages/linter/test/rules/parser-no-errors.test.ts
@@ -1,208 +1,119 @@
 import dedent from "dedent"
-
-import { describe, test, expect, beforeAll } from "vitest"
-
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
-
+import { describe, test } from "vitest"
 import { ParserNoErrorsRule } from "../../src/rules/parser-no-errors.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("ParserNoErrorsRule", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ParserNoErrorsRule)
 
+describe("ParserNoErrorsRule", () => {
   test("should not report errors for valid HTML", () => {
-    const html = dedent`
+    expectNoOffenses(dedent`
       <h1>Hello World</h1>
       <p>This is a paragraph.</p>
       <div>
         <%= user.name %>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("should report errors for mismatched tag names", () => {
-    const html = dedent`
+    expectError("Tag `<h3>` opened at (3:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<h3>` at (3:1) doesn't have a matching closing tag `</h3>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         Some content
       <h3>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-
-    expect(lintResult.offenses[0].message).toBe("Tag `<h3>` opened at (3:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<h3>` at (3:1) doesn't have a matching closing tag `</h3>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    `)
   })
 
   test("should report errors for unclosed elements", () => {
-    const html = dedent`
+    expectError("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<div>` at (1:1) doesn't have a matching closing tag `</div>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</div>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <div>
         <p>Some content
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    `)
   })
 
   test("should report errors for void elements with closing tags", () => {
-    const html = `<img src="test.jpg" alt="test"></img>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("`img` is a void element and should not be used as a closing tag. Use `<img>` or `<img />` instead of `</img>`. (`VOID_ELEMENT_CLOSING_TAG_ERROR`)")
+    expectError("`img` is a void element and should not be used as a closing tag. Use `<img>` or `<img />` instead of `</img>`. (`VOID_ELEMENT_CLOSING_TAG_ERROR`)")
+    assertOffenses(`<img src="test.jpg" alt="test"></img>`)
   })
 
   test("should report errors for missing opening tags", () => {
-    const html = dedent`
+    expectError("Found closing tag `</div>` at (2:2) without a matching opening tag. (`MISSING_OPENING_TAG_ERROR`)")
+    assertOffenses(dedent`
       Some content
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Found closing tag `</div>` at (2:2) without a matching opening tag. (`MISSING_OPENING_TAG_ERROR`)")
+    `)
   })
 
   test("should report errors for mismatched quotes in attributes", () => {
-    const html = `<div class="test'></div>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Found `TOKEN_EOF` when expecting `TOKEN_HTML_TAG_SELF_CLOSE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("Found `TOKEN_EOF` when expecting `TOKEN_HTML_TAG_SELF_CLOSE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("Found `TOKEN_EOF` when expecting `TOKEN_QUOTE` at (1:24). (`UNEXPECTED_TOKEN_ERROR`)")
+    expectError("String opened with \" but closed with  at (1:24). (`QUOTES_MISMATCH_ERROR`)")
+    assertOffenses(`<div class="test'></div>`)
   })
 
   test("should report Ruby parse errors in ERB tags", () => {
-    const html = `<%= 1 + %>`
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(1)
-    expect(lintResult.offenses).toHaveLength(1)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("expect_expression_after_operator: unexpected ';'; expected an expression after the operator (`RUBY_PARSE_ERROR`)")
+    expectError("expect_expression_after_operator: unexpected ';'; expected an expression after the operator (`RUBY_PARSE_ERROR`)")
+    assertOffenses(`<%= 1 + %>`)
   })
 
   test("should report multiple parser errors", () => {
-    const html = dedent`
+    expectError("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</div>` at (4:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    expectError("Opening tag `<p>` at (2:3) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         <p>Unclosed paragraph
       </h3>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<p>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<p>` at (2:3) closed with `</div>` at (4:2). (`TAG_NAMES_MISMATCH_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<p>` at (2:3) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    `)
   })
 
   test("should work alongside other linting rules", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <h2>
         <% %>
       </h3>
-    `
-    const linter = new Linter(Herb)
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(3)
-    expect(lintResult.offenses).toHaveLength(3)
-
-    const parserErrors = lintResult.offenses.filter(offense => offense.rule === "parser-no-errors")
-    const erbErrors = lintResult.offenses.filter(offense => offense.rule === "erb-no-empty-tags")
-
-    expect(parserErrors).toHaveLength(2)
-    expect(erbErrors).toHaveLength(1)
-
-    expect(parserErrors[0].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(parserErrors[1].message).toBe("Opening tag `<h2>` at (1:1) closed with `</h3>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
-    expect(erbErrors[0].message).toBe("ERB tag should not be empty. Remove empty ERB tags or add content.")
+    `)
   })
 
   test("should include error location information", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (2:3) closed with `</div>` at (3:2). (`TAG_NAMES_MISMATCH_ERROR`)")
+    expectError("Opening tag `<h2>` at (2:3) closed with `</h3>` at (2:15). (`TAG_NAMES_MISMATCH_ERROR`)")
+    assertOffenses(dedent`
       <div>
         <h2>Content</h3>
       </div>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    const offense = lintResult.offenses[0]
-    expect(offense.rule).toBe("parser-no-errors")
-    expect(offense.severity).toBe("error")
-    expect(offense.message).toBe("Tag `<h2>` opened at (2:3) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-
-    expect(offense.location).toBeDefined()
-    expect(offense.location.start).toBeDefined()
-    expect(offense.location.end).toBeDefined()
-    expect(offense.location.start.line).toBe(3)
-    expect(offense.location.start.column).toBe(6)
-
-    expect(lintResult.offenses[1].message).toBe("Tag `<div>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    `)
   })
 
   test("should handle the specific case from issue #359", () => {
-    const html = dedent`
+    expectError("Tag `<h2>` opened at (1:25) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    expectError("Opening tag `<h2>` at (1:25) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+    assertOffenses(dedent`
       <h2>Some heading content<h2>
-    `
-    const linter = new Linter(Herb, [ParserNoErrorsRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(4)
-    expect(lintResult.offenses).toHaveLength(4)
-
-    expect(lintResult.offenses[0].rule).toBe("parser-no-errors")
-    expect(lintResult.offenses[0].severity).toBe("error")
-    expect(lintResult.offenses[0].message).toBe("Tag `<h2>` opened at (1:25) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
+    `)
+  })
 
-    expect(lintResult.offenses[1].message).toBe("Tag `<h2>` opened at (1:1) was never closed before the end of document. (`UNCLOSED_ELEMENT_ERROR`)")
-    expect(lintResult.offenses[2].message).toBe("Opening tag `<h2>` at (1:1) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
-    expect(lintResult.offenses[3].message).toBe("Opening tag `<h2>` at (1:25) doesn't have a matching closing tag `</h2>`. (`MISSING_CLOSING_TAG_ERROR`)")
+  test("html element ending with boolean attribute followed by ERB tag", () => {
+    expectNoOffenses(dedent`
+      <link crossorigin>
+      <%= hello %>
+    `)
   })
 })
diff --git a/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts b/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
index f28bef453..1d93705cc 100644
--- a/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
+++ b/javascript/packages/linter/test/rules/svg-tag-name-capitalization.test.ts
@@ -1,15 +1,12 @@
-import { describe, test, expect, beforeAll } from "vitest"
-import { Herb } from "@herb-tools/node-wasm"
-import { Linter } from "../../src/linter.js"
+import { describe, test } from "vitest"
 import { SVGTagNameCapitalizationRule } from "../../src/rules/svg-tag-name-capitalization.js"
+import { createLinterTest } from "../helpers/linter-test-helper.js"
 
-describe("svg-tag-name-capitalization", () => {
-  beforeAll(async () => {
-    await Herb.load()
-  })
+const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(SVGTagNameCapitalizationRule)
 
+describe("svg-tag-name-capitalization", () => {
   test("passes for correctly cased SVG elements", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
           <stop offset="0%" style="stop-color:rgb(255,255,0);stop-opacity:1" />
@@ -29,18 +26,11 @@ describe("svg-tag-name-capitalization", () => {
           <textPath href="#path">Text along a path</textPath>
         </text>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("passes for SVG filter elements with correct camelCase", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <filter id="blur">
           <feGaussianBlur in="SourceGraphic" stdDeviation="5" />
@@ -52,17 +42,18 @@ describe("svg-tag-name-capitalization", () => {
           </feMerge>
         </filter>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("fails for incorrectly cased SVG elements", () => {
-    const html = `
+    expectError('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Opening SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Opening SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+    expectError('Closing SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+
+    assertOffenses(`
       <svg>
         <LINEARGRADIENT id="grad1">
           <stop offset="0%" />
@@ -74,22 +65,11 @@ describe("svg-tag-name-capitalization", () => {
           <rect x="0" y="0" width="100" height="100" />
         </CLIPPATH>
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(6) // 3 opening + 3 closing tags
-    expect(lintResult.offenses[0].message).toBe('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[1].message).toBe('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[2].message).toBe('Opening SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[3].message).toBe('Closing SVG tag name `lineargradient` should use proper capitalization. Use `linearGradient` instead.')
-    expect(lintResult.offenses[4].message).toBe('Opening SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
-    expect(lintResult.offenses[5].message).toBe('Closing SVG tag name `CLIPPATH` should use proper capitalization. Use `clipPath` instead.')
+    `)
   })
 
   test("passes for animateMotion and animateTransform", () => {
-    const html = `
+    expectNoOffenses(`
       <svg>
         <animateMotion dur="10s" repeatCount="indefinite">
           <mpath href="#path1" />
@@ -102,17 +82,11 @@ describe("svg-tag-name-capitalization", () => {
           dur="10s"
           repeatCount="indefinite" />
       </svg>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
+    `)
   })
 
   test("ignores non-SVG elements", () => {
-    const html = `
+    expectNoOffenses(`
       <div>
         <LINEARGRADIENT id="grad1">
           <stop offset="0%" />
@@ -121,18 +95,14 @@ describe("svg-tag-name-capitalization", () => {
           <rect x="0" y="0" width="100" height="100" />
         </clipPath>
       </div>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(0)
-    expect(lintResult.warnings).toBe(0)
-    expect(lintResult.offenses).toHaveLength(0)
+    `)
   })
 
   test("only checks elements within SVG context", () => {
-    const html = `
+    expectError('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    expectError('Closing SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+
+    assertOffenses(`
       <div>
         <P>Outside SVG</P>
         <svg>
@@ -141,12 +111,6 @@ describe("svg-tag-name-capitalization", () => {
         </svg>
         <P>Outside SVG again</P>
       </div>
-    `
-    
-    const linter = new Linter(Herb, [SVGTagNameCapitalizationRule])
-    const lintResult = linter.lint(html)
-
-    expect(lintResult.errors).toBe(2) // 1 opening + 1 closing tag
-    expect(lintResult.offenses[0].message).toBe('Opening SVG tag name `LINEARGRADIENT` should use proper capitalization. Use `linearGradient` instead.')
+    `)
   })
 })
diff --git a/javascript/packages/linter/unformatted.html.erb b/javascript/packages/linter/unformatted.html.erb
new file mode 100644
index 000000000..581b4a43e
--- /dev/null
+++ b/javascript/packages/linter/unformatted.html.erb
@@ -0,0 +1,3 @@
+<% if true %>
+<div></div>
+<% end %>
diff --git a/javascript/packages/node-wasm/package.json b/javascript/packages/node-wasm/package.json
index ae23a1a7e..da589ec3c 100644
--- a/javascript/packages/node-wasm/package.json
+++ b/javascript/packages/node-wasm/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/node-wasm",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "WebAssembly-based HTML-aware ERB parser for Node.js.",
   "type": "module",
   "license": "MIT",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4"
+    "@herb-tools/core": "0.7.5"
   },
   "files": [
     "package.json",
diff --git a/javascript/packages/node-wasm/test/node-wasm.test.ts b/javascript/packages/node-wasm/test/node-wasm.test.ts
index 7533c7b1a..cb4d19bfd 100644
--- a/javascript/packages/node-wasm/test/node-wasm.test.ts
+++ b/javascript/packages/node-wasm/test/node-wasm.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node-wasm", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node-wasm@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (WebAssembly)")
+    expect(version).toBe("@herb-tools/node-wasm@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (WebAssembly)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/node/binding.gyp b/javascript/packages/node/binding.gyp
index 95096ee66..f01664fa8 100644
--- a/javascript/packages/node/binding.gyp
+++ b/javascript/packages/node/binding.gyp
@@ -13,25 +13,20 @@
         "./extension/libherb/analyze_helpers.c",
         "./extension/libherb/analyze.c",
         "./extension/libherb/analyzed_ruby.c",
-        "./extension/libherb/array.c",
         "./extension/libherb/ast_node.c",
         "./extension/libherb/ast_nodes.c",
         "./extension/libherb/ast_pretty_print.c",
-        "./extension/libherb/buffer.c",
         "./extension/libherb/element_source.c",
         "./extension/libherb/errors.c",
         "./extension/libherb/extract.c",
         "./extension/libherb/herb.c",
         "./extension/libherb/html_util.c",
         "./extension/libherb/io.c",
-        "./extension/libherb/json.c",
         "./extension/libherb/lexer_peek_helpers.c",
         "./extension/libherb/lexer.c",
         "./extension/libherb/location.c",
-        "./extension/libherb/memory.c",
         "./extension/libherb/parser_helpers.c",
         "./extension/libherb/parser.c",
-        "./extension/libherb/position.c",
         "./extension/libherb/pretty_print.c",
         "./extension/libherb/prism_helpers.c",
         "./extension/libherb/range.c",
@@ -39,6 +34,10 @@
         "./extension/libherb/token.c",
         "./extension/libherb/utf8.c",
         "./extension/libherb/util.c",
+        "./extension/libherb/util/hb_arena.c",
+        "./extension/libherb/util/hb_array.c",
+        "./extension/libherb/util/hb_buffer.c",
+        "./extension/libherb/util/hb_string.c",
         "./extension/libherb/visitor.c",
 
         # Prism main source files
diff --git a/javascript/packages/node/extension/extension_helpers.cpp b/javascript/packages/node/extension/extension_helpers.cpp
index e64c18dc1..9ca985ef0 100644
--- a/javascript/packages/node/extension/extension_helpers.cpp
+++ b/javascript/packages/node/extension/extension_helpers.cpp
@@ -4,15 +4,15 @@
 #include <string.h>
 
 extern "C" {
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
-#include "../extension/libherb/include/buffer.h"
 #include "../extension/libherb/include/herb.h"
 #include "../extension/libherb/include/io.h"
 #include "../extension/libherb/include/location.h"
 #include "../extension/libherb/include/position.h"
 #include "../extension/libherb/include/range.h"
 #include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/util/hb_buffer.h"
 }
 
 #include "error_helpers.h"
@@ -46,19 +46,13 @@ napi_value CreateString(napi_env env, const char* str) {
   return result;
 }
 
-napi_value CreatePosition(napi_env env, position_T* position) {
-  if (!position) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreatePosition(napi_env env, position_T position) {
   napi_value result;
   napi_create_object(env, &result);
 
   napi_value line, column;
-  napi_create_uint32(env, (uint32_t)position->line, &line);
-  napi_create_uint32(env, (uint32_t)position->column, &column);
+  napi_create_uint32(env, (uint32_t)position.line, &line);
+  napi_create_uint32(env, (uint32_t)position.column, &column);
 
   napi_set_named_property(env, result, "line", line);
   napi_set_named_property(env, result, "column", column);
@@ -66,18 +60,12 @@ napi_value CreatePosition(napi_env env, position_T* position) {
   return result;
 }
 
-napi_value CreateLocation(napi_env env, location_T* location) {
-  if (!location) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreateLocation(napi_env env, location_T location) {
   napi_value result;
   napi_create_object(env, &result);
 
-  napi_value start = CreatePosition(env, location->start);
-  napi_value end = CreatePosition(env, location->end);
+  napi_value start = CreatePosition(env, location.start);
+  napi_value end = CreatePosition(env, location.end);
 
   napi_set_named_property(env, result, "start", start);
   napi_set_named_property(env, result, "end", end);
@@ -85,19 +73,13 @@ napi_value CreateLocation(napi_env env, location_T* location) {
   return result;
 }
 
-napi_value CreateRange(napi_env env, range_T* range) {
-  if (!range) {
-    napi_value null_value;
-    napi_get_null(env, &null_value);
-    return null_value;
-  }
-
+napi_value CreateRange(napi_env env, range_T range) {
   napi_value result;
   napi_create_array(env, &result);
 
   napi_value from, to;
-  napi_create_uint32(env, (uint32_t)range->from, &from);
-  napi_create_uint32(env, (uint32_t)range->to, &to);
+  napi_create_uint32(env, (uint32_t)range.from, &from);
+  napi_create_uint32(env, (uint32_t)range.to, &to);
 
   napi_set_element(env, result, 0, from);
   napi_set_element(env, result, 1, to);
@@ -154,7 +136,7 @@ napi_value ReadFileToString(napi_env env, const char* file_path) {
   return result;
 }
 
-napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
+napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source) {
   napi_value result, tokens_array, errors_array, warnings_array;
 
   napi_create_object(env, &result);
@@ -164,8 +146,8 @@ napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
 
   // Add tokens to array
   if (tokens) {
-    for (size_t i = 0; i < array_size(tokens); i++) {
-      token_T* token = (token_T*)array_get(tokens, i);
+    for (size_t i = 0; i < hb_array_size(tokens); i++) {
+      token_T* token = (token_T*)hb_array_get(tokens, i);
       if (token) {
         napi_value token_obj = CreateToken(env, token);
         napi_set_element(env, tokens_array, i, token_obj);
diff --git a/javascript/packages/node/extension/extension_helpers.h b/javascript/packages/node/extension/extension_helpers.h
index 7387ea9d8..2e3530b0c 100644
--- a/javascript/packages/node/extension/extension_helpers.h
+++ b/javascript/packages/node/extension/extension_helpers.h
@@ -4,19 +4,19 @@
 #include <node_api.h>
 
 extern "C" {
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 char* CheckString(napi_env env, napi_value value);
 napi_value CreateString(napi_env env, const char* str);
 napi_value ReadFileToString(napi_env env, const char* file_path);
-napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source);
+napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source);
 napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source);
 
-napi_value CreateLocation(napi_env env, location_T* location);
+napi_value CreateLocation(napi_env env, location_T location);
 napi_value CreateToken(napi_env env, token_T* token);
-napi_value CreatePosition(napi_env env, position_T* position);
-napi_value CreateRange(napi_env env, range_T* range);
+napi_value CreatePosition(napi_env env, position_T position);
+napi_value CreateRange(napi_env env, range_T range);
 
 #endif
diff --git a/javascript/packages/node/extension/herb.cpp b/javascript/packages/node/extension/herb.cpp
index 3b8ba8ebb..ec29d11c0 100644
--- a/javascript/packages/node/extension/herb.cpp
+++ b/javascript/packages/node/extension/herb.cpp
@@ -1,12 +1,12 @@
 extern "C" {
 #include "../extension/libherb/include/analyze.h"
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_nodes.h"
-#include "../extension/libherb/include/buffer.h"
 #include "../extension/libherb/include/herb.h"
 #include "../extension/libherb/include/location.h"
 #include "../extension/libherb/include/range.h"
 #include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
+#include "../extension/libherb/include/util/hb_buffer.h"
 }
 
 #include "error_helpers.h"
@@ -31,7 +31,7 @@ napi_value Herb_lex(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  array_T* tokens = herb_lex(string);
+  hb_array_T* tokens = herb_lex(string);
   napi_value result = CreateLexResult(env, tokens, args[0]);
 
   herb_free_tokens(&tokens);
@@ -53,7 +53,7 @@ napi_value Herb_lex_file(napi_env env, napi_callback_info info) {
   char* file_path = CheckString(env, args[0]);
   if (!file_path) { return nullptr; }
 
-  array_T* tokens = herb_lex_file(file_path);
+  hb_array_T* tokens = herb_lex_file(file_path);
   napi_value source_value = ReadFileToString(env, file_path);
   napi_value result = CreateLexResult(env, tokens, source_value);
 
@@ -142,37 +142,6 @@ napi_value Herb_parse_file(napi_env env, napi_callback_info info) {
   return result;
 }
 
-napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
-  size_t argc = 1;
-  napi_value args[1];
-  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-
-  if (argc < 1) {
-    napi_throw_error(env, nullptr, "Wrong number of arguments");
-    return nullptr;
-  }
-
-  char* string = CheckString(env, args[0]);
-  if (!string) { return nullptr; }
-
-  buffer_T output;
-  if (!buffer_init(&output)) {
-    free(string);
-    napi_throw_error(env, nullptr, "Failed to initialize buffer");
-    return nullptr;
-  }
-
-  herb_lex_json_to_buffer(string, &output);
-
-  napi_value result;
-  napi_create_string_utf8(env, output.value, output.length, &result);
-
-  buffer_free(&output);
-  free(string);
-
-  return result;
-}
-
 napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -186,8 +155,8 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  buffer_T output;
-  if (!buffer_init(&output)) {
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -198,7 +167,7 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
-  buffer_free(&output);
+  free(output.value);
   free(string);
   return result;
 }
@@ -216,8 +185,8 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  buffer_T output;
-  if (!buffer_init(&output)) {
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, strlen(string))) {
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
@@ -228,7 +197,7 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
-  buffer_free(&output);
+  free(output.value);
   free(string);
   return result;
 }
@@ -252,7 +221,6 @@ napi_value Init(napi_env env, napi_value exports) {
     { "lex", nullptr, Herb_lex, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "parseFile", nullptr, Herb_parse_file, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "lexFile", nullptr, Herb_lex_file, nullptr, nullptr, nullptr, napi_default, nullptr },
-    { "lexToJson", nullptr, Herb_lex_to_json, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "extractRuby", nullptr, Herb_extract_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "extractHTML", nullptr, Herb_extract_html, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "version", nullptr, Herb_version, nullptr, nullptr, nullptr, napi_default, nullptr },
diff --git a/javascript/packages/node/package.json b/javascript/packages/node/package.json
index f5f9e9b95..b31eae271 100644
--- a/javascript/packages/node/package.json
+++ b/javascript/packages/node/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/node",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Native Node.js addon for HTML-aware ERB parsing using Herb.",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "host": "https://github.com/marcoroth/herb/releases/download/"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
+    "@herb-tools/core": "0.7.5",
     "@mapbox/node-pre-gyp": "^2.0.0",
     "node-addon-api": "^5.1.0"
   },
diff --git a/javascript/packages/node/test/node.test.ts b/javascript/packages/node/test/node.test.ts
index 032656916..892167245 100644
--- a/javascript/packages/node/test/node.test.ts
+++ b/javascript/packages/node/test/node.test.ts
@@ -17,7 +17,7 @@ describe("@herb-tools/node", () => {
   test("version() returns a string", async () => {
     const version = Herb.version
     expect(typeof version).toBe("string")
-    expect(version).toBe("@herb-tools/node@0.7.4, @herb-tools/core@0.7.4, libprism@1.5.1, libherb@0.7.4 (Node.js C++ native extension)")
+    expect(version).toBe("@herb-tools/node@0.7.5, @herb-tools/core@0.7.5, libprism@1.6.0, libherb@0.7.5 (Node.js C++ native extension)")
   })
 
   test("parse() can process a simple template", async () => {
diff --git a/javascript/packages/printer/package.json b/javascript/packages/printer/package.json
index 16928c514..08de93261 100644
--- a/javascript/packages/printer/package.json
+++ b/javascript/packages/printer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/printer",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "AST printer infrastructure and lossless reconstruction tool for HTML+ERB templates",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -37,7 +37,7 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/core": "0.7.4",
+    "@herb-tools/core": "0.7.5",
     "glob": "^10.3.10"
   },
   "files": [
diff --git a/javascript/packages/printer/src/cli.ts b/javascript/packages/printer/src/cli.ts
index e54e00e6c..6cd8cde9d 100644
--- a/javascript/packages/printer/src/cli.ts
+++ b/javascript/packages/printer/src/cli.ts
@@ -7,6 +7,8 @@ import { resolve } from "path"
 import { glob } from "glob"
 
 import { Herb } from "@herb-tools/node-wasm"
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { IdentityPrinter } from "./index.js"
 
 interface CLIOptions {
@@ -74,7 +76,7 @@ export class CLI {
         -o, --output <file>          Output file path (defaults to stdout)
         --verify                     Verify that output matches input exactly
         --stats                      Show parsing and printing statistics
-        --glob                       Treat input as glob pattern (default: **/*.html.erb)
+        --glob                       Treat input as glob pattern (default: ${HERB_FILES_GLOB})
         -h, --help                   Show this help message
 
       Examples:
@@ -84,10 +86,10 @@ export class CLI {
         herb-print input.html.erb --stats
 
         # Glob patterns (batch verification)
-        herb-print --glob --verify                    # All .html.erb files
+        herb-print --glob --verify                         # All .html.erb files
         herb-print "app/views/**/*.html.erb" --glob --verify --stats
         herb-print "*.erb" --glob --verify
-        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /**/*.html.erb)
+        herb-print "/path/to/templates" --glob --verify    # Directory (auto-appends /${HERB_FILES_GLOB})
         herb-print "/path/to/templates/**/*.html.erb" --glob --verify
 
         # The --verify flag is useful to test parser fidelity:
@@ -108,7 +110,7 @@ export class CLI {
       await Herb.load()
 
       if (options.glob) {
-        const pattern = options.input || "**/*.html.erb"
+        const pattern = options.input || HERB_FILES_GLOB
         const files = await glob(pattern)
 
         if (files.length === 0) {
diff --git a/javascript/packages/printer/src/identity-printer.ts b/javascript/packages/printer/src/identity-printer.ts
index 6eb2c53c5..ad592cc2d 100644
--- a/javascript/packages/printer/src/identity-printer.ts
+++ b/javascript/packages/printer/src/identity-printer.ts
@@ -13,6 +13,14 @@ import type * as Nodes from "@herb-tools/core"
  * - Verifying AST round-trip fidelity
  */
 export class IdentityPrinter extends Printer {
+  static printERBNode(node: Nodes.ERBNode) {
+    const printer = new IdentityPrinter()
+
+    printer.printERBNode(node)
+
+    return printer.context.getOutput()
+  }
+
   visitLiteralNode(node: Nodes.LiteralNode): void {
     this.write(node.content)
   }
diff --git a/javascript/packages/printer/src/printer.ts b/javascript/packages/printer/src/printer.ts
index 65af1dc08..ae56187aa 100644
--- a/javascript/packages/printer/src/printer.ts
+++ b/javascript/packages/printer/src/printer.ts
@@ -1,6 +1,8 @@
 import { Node, Visitor, Token, ParseResult, isToken, isParseResult } from "@herb-tools/core"
 import { PrintContext } from "./print-context.js"
 
+import type { ERBNode } from "@herb-tools/core"
+
 /**
  * Options for controlling the printing behavior
  */
diff --git a/javascript/packages/stimulus-lint/package.json b/javascript/packages/stimulus-lint/package.json
index f6f62f9b5..3297934fc 100644
--- a/javascript/packages/stimulus-lint/package.json
+++ b/javascript/packages/stimulus-lint/package.json
@@ -1,6 +1,6 @@
 {
   "name": "stimulus-lint",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Linting rules for Stimulus controllers and HTML+ERB view templates.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -34,10 +34,10 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "dependencies": {
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/core": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
-    "@herb-tools/highlighter": "0.7.4",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/core": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
+    "@herb-tools/highlighter": "0.7.5",
     "stimulus-parser": "^0.3.0"
   },
   "files": [
diff --git a/javascript/packages/tailwind-class-sorter/package.json b/javascript/packages/tailwind-class-sorter/package.json
index 6b6d6eb0d..2bbee0cca 100644
--- a/javascript/packages/tailwind-class-sorter/package.json
+++ b/javascript/packages/tailwind-class-sorter/package.json
@@ -2,7 +2,7 @@
   "type": "module",
   "name": "@herb-tools/tailwind-class-sorter",
   "description": "Standalone Tailwind CSS class sorter with Prettier plugin compatibility, extracted from tailwindlabs/prettier-plugin-tailwindcss",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "license": "MIT",
   "main": "./dist/tailwind-class-sorter.cjs",
   "module": "./dist/tailwind-class-sorter.esm.js",
@@ -46,7 +46,7 @@
   "devDependencies": {
     "@types/node": "^24.1.0",
     "dedent": "^1.6.0",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.25.11",
     "rimraf": "^6.0.1",
     "tailwindcss": "^3.4.17",
     "tsup": "^8.5.0",
diff --git a/javascript/packages/vscode/package.json b/javascript/packages/vscode/package.json
index 8dd528949..0a26d49c8 100644
--- a/javascript/packages/vscode/package.json
+++ b/javascript/packages/vscode/package.json
@@ -2,7 +2,7 @@
   "name": "herb-lsp",
   "displayName": "Herb LSP - HTML+ERB Language Tools",
   "description": "VS Code extension for connecting with the Herb Language Server and Language Tools for HTML+ERB files",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "private": true,
   "license": "MIT",
   "pricing": "Free",
@@ -61,12 +61,16 @@
           "items": {
             "type": "string",
             "enum": [
+              "erb-comment-syntax",
+              "erb-no-case-node-children",
               "erb-no-empty-tags",
+              "erb-no-extra-newline",
               "erb-no-output-control-flow",
               "erb-no-silent-tag-in-attribute-name",
               "erb-prefer-image-tag-helper",
+              "erb-require-trailing-newline",
               "erb-require-whitespace-inside-tags",
-              "erb-requires-trailing-newline",
+              "erb-right-trim",
               "html-anchor-require-href",
               "html-aria-attribute-must-be-valid",
               "html-aria-label-is-well-formatted",
@@ -77,19 +81,24 @@
               "html-attribute-equals-spacing",
               "html-attribute-values-require-quotes",
               "html-avoid-both-disabled-and-aria-disabled",
+              "html-body-only-elements",
               "html-boolean-attributes-no-value",
+              "html-head-only-elements",
               "html-iframe-has-title",
               "html-img-require-alt",
+              "html-input-require-autocomplete",
               "html-navigation-has-label",
               "html-no-aria-hidden-on-focusable",
               "html-no-block-inside-inline",
               "html-no-duplicate-attributes",
               "html-no-duplicate-ids",
+              "html-no-duplicate-meta-names",
               "html-no-empty-attributes",
               "html-no-empty-headings",
               "html-no-nested-links",
               "html-no-positive-tab-index",
               "html-no-self-closing",
+              "html-no-space-in-tag",
               "html-no-title-attribute",
               "html-no-underscores-in-attribute-names",
               "html-tag-name-lowercase",
@@ -239,9 +248,9 @@
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "devDependencies": {
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
-    "@herb-tools/node-wasm": "0.7.4",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
+    "@herb-tools/node-wasm": "0.7.5",
     "@types/node": "20.x",
     "@types/vscode": "^1.43.0",
     "@typescript-eslint/eslint-plugin": "^8.40.0",
@@ -249,7 +258,7 @@
     "@vscode/test-cli": "^0.0.10",
     "@vscode/test-electron": "^2.5.2",
     "@vscode/vsce": "^3.5.0",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.25.11",
     "esbuild-plugin-copy": "^2.1.1",
     "eslint": "^9.25.1",
     "npm-run-all": "^4.1.5",
diff --git a/javascript/packages/vscode/scripts/sync-defaults.js b/javascript/packages/vscode/scripts/sync-defaults.js
index a177af031..892b0c702 100644
--- a/javascript/packages/vscode/scripts/sync-defaults.js
+++ b/javascript/packages/vscode/scripts/sync-defaults.js
@@ -18,7 +18,7 @@ function extractLinterRuleNames() {
     if (file.endsWith('.ts') && file !== 'index.ts' && file !== 'rule-utils.ts') {
       const filePath = path.join(rulesDir, file);
       const content = fs.readFileSync(filePath, 'utf8');
-      const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+      const match = content.match(/  name\s*=\s*["']([^"']+)["']/);
 
       if (match) {
         ruleNames.push(match[1]);
diff --git a/javascript/packages/vscode/src/client.ts b/javascript/packages/vscode/src/client.ts
index caccf60be..3679baf6a 100644
--- a/javascript/packages/vscode/src/client.ts
+++ b/javascript/packages/vscode/src/client.ts
@@ -7,7 +7,7 @@ export class Client {
   private client: LanguageClient
   private serverModule: string
   private languageClientId = "languageServerHerb"
-  private languageClientName = "Herb LSP "
+  private languageClientName = "Herb Language Server "
   private context: ExtensionContext
   private configurationListener?: Disposable
 
diff --git a/javascript/packages/vscode/src/code-action-provider.ts b/javascript/packages/vscode/src/code-action-provider.ts
index 4a97ef0ca..e03f88497 100644
--- a/javascript/packages/vscode/src/code-action-provider.ts
+++ b/javascript/packages/vscode/src/code-action-provider.ts
@@ -7,18 +7,19 @@ export class HerbCodeActionProvider implements vscode.CodeActionProvider {
     context: vscode.CodeActionContext,
     _token: vscode.CancellationToken
   ): vscode.CodeAction[] {
+    if (context.diagnostics.length === 0) {
+      return []
+    }
+
     const actions: vscode.CodeAction[] = []
 
-    if (!document.fileName.endsWith('.html.erb')) {
-      return actions
-    }
+    for (const diagnostic of context.diagnostics) {
+      const source = typeof diagnostic.source === 'string' ? diagnostic.source.trim() : undefined
 
-    const diagnostics = context.diagnostics
-    if (diagnostics.length === 0) {
-      return actions
-    }
+      if (!source || !source.includes('Herb')) {
+        continue
+      }
 
-    for (const diagnostic of diagnostics) {
       let errorType = 'UNKNOWN_ERROR'
       if (typeof diagnostic.code === 'string' && diagnostic.code) {
         errorType = diagnostic.code
diff --git a/javascript/packages/vscode/src/extension.ts b/javascript/packages/vscode/src/extension.ts
index e66b88d0c..fb4bb0e2b 100644
--- a/javascript/packages/vscode/src/extension.ts
+++ b/javascript/packages/vscode/src/extension.ts
@@ -1,5 +1,7 @@
 import * as vscode from "vscode"
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import { Client } from "./client"
 import { HerbAnalysisProvider } from "./herb-analysis-provider"
 import { HerbCodeActionProvider } from "./code-action-provider"
@@ -63,8 +65,7 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   )
 
-  // Set up file watcher for HTML+ERB files
-  const fileWatcher = vscode.workspace.createFileSystemWatcher('**/*.html.erb')
+  const fileWatcher = vscode.workspace.createFileSystemWatcher(HERB_FILES_GLOB)
 
   fileWatcher.onDidChange(async (uri) => {
     console.log(`File changed: ${uri.fsPath}`)
@@ -83,7 +84,6 @@ export async function activate(context: vscode.ExtensionContext) {
 
   context.subscriptions.push(fileWatcher)
 
-  // Auto-run analyze project if HTML+ERB files exist
   await runAutoAnalysis()
 
   console.log("Herb LSP is now active!")
@@ -94,12 +94,13 @@ async function runAutoAnalysis() {
     return
   }
 
-  const erbFiles = await vscode.workspace.findFiles('**/*.html.erb')
-  if (erbFiles.length === 0) {
+  const files = await vscode.workspace.findFiles(HERB_FILES_GLOB)
+  if (files.length === 0) {
     return
   }
 
-  console.log(`Found ${erbFiles.length} HTML+ERB files. Running auto-analysis...`)
+  console.log(`Found ${files.length} HTML+ERB files. Running auto-analysis...`)
+
   await analysisProvider.analyzeProject()
 }
 
diff --git a/javascript/packages/vscode/src/herb-analysis-provider.ts b/javascript/packages/vscode/src/herb-analysis-provider.ts
index 13d148516..1121f4825 100644
--- a/javascript/packages/vscode/src/herb-analysis-provider.ts
+++ b/javascript/packages/vscode/src/herb-analysis-provider.ts
@@ -5,6 +5,8 @@ import { VersionService } from './version-service'
 
 import { workspace, window, EventEmitter, ProgressLocation } from 'vscode'
 
+import { HERB_FILES_GLOB } from "@herb-tools/core"
+
 import type { FileStatus, TreeNode } from './types'
 import type { TreeDataProvider, Event, ExtensionContext, TreeItem, Uri } from 'vscode'
 
@@ -46,7 +48,7 @@ export class HerbAnalysisProvider implements TreeDataProvider<TreeNode> {
   }
 
   async analyzeProject(): Promise<void> {
-    const uris = await workspace.findFiles('**/*.html.erb')
+    const uris = await workspace.findFiles(HERB_FILES_GLOB)
 
     this.lastAnalysisTime = new Date()
 
diff --git a/lib/herb/engine.rb b/lib/herb/engine.rb
index 133db20d7..c4fe7752b 100644
--- a/lib/herb/engine.rb
+++ b/lib/herb/engine.rb
@@ -193,13 +193,17 @@ def add_text(text)
     def add_code(code)
       terminate_expression
 
-      @src << " " << code
-
-      # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
-      if code.include?("#")
-        @src << "\n"
+      if code.include?("=begin") || code.include?("=end")
+        @src << "\n" << code << "\n"
       else
-        @src << ";" unless code[-1] == "\n"
+        @src << " " << code
+
+        # TODO: rework and check for Prism::InlineComment as soon as we expose the Prism Nodes in the Herb AST
+        if code.include?("#")
+          @src << "\n"
+        else
+          @src << ";" unless code[-1] == "\n"
+        end
       end
 
       @buffer_on_stack = false
diff --git a/lib/herb/engine/compiler.rb b/lib/herb/engine/compiler.rb
index 3e9870265..7e8e90f66 100644
--- a/lib/herb/engine/compiler.rb
+++ b/lib/herb/engine/compiler.rb
@@ -227,7 +227,7 @@ def visit_erb_end_node(node)
       end
 
       def visit_erb_case_match_node(node)
-        visit_erb_control_with_parts(node, :children, :conditions, :else_clause, :end_node)
+        visit_erb_control_with_parts(node, :conditions, :else_clause, :end_node)
       end
 
       def visit_erb_in_node(node)
diff --git a/lib/herb/libherb.rb b/lib/herb/libherb.rb
index 401004303..ea670bc00 100644
--- a/lib/herb/libherb.rb
+++ b/lib/herb/libherb.rb
@@ -25,7 +25,6 @@ def self.library_path
     ffi_lib(library_path)
 
     attach_function :herb_lex_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_lex_json_to_buffer, [:pointer, :pointer], :void
     attach_function :herb_lex, [:pointer], :pointer
     attach_function :herb_parse, [:pointer], :pointer
     attach_function :herb_extract_ruby_to_buffer, [:pointer, :pointer], :void
diff --git a/lib/herb/libherb/array.rb b/lib/herb/libherb/array.rb
index 6ef705a1b..304252a43 100644
--- a/lib/herb/libherb/array.rb
+++ b/lib/herb/libherb/array.rb
@@ -7,9 +7,9 @@
 
 module Herb
   module LibHerb
-    attach_function :array_get, [:pointer, :int], :pointer
-    attach_function :array_capacity, [:pointer], :size_t
-    attach_function :array_size, [:pointer], :size_t
+    attach_function :hb_array_get, [:pointer, :int], :pointer
+    attach_function :hb_array_capacity, [:pointer], :size_t
+    attach_function :hb_array_size, [:pointer], :size_t
 
     class Array
       extend Forwardable
@@ -24,16 +24,16 @@ def initialize(pointer, item_class)
       end
 
       def capacity
-        LibHerb.array_capacity(pointer)
+        LibHerb.hb_array_capacity(pointer)
       end
 
       def size
-        LibHerb.array_size(pointer)
+        LibHerb.hb_array_size(pointer)
       end
 
       def item_pointers
         size.times.map { |item|
-          LibHerb.array_get(pointer, item)
+          LibHerb.hb_array_get(pointer, item)
         }
       end
 
diff --git a/lib/herb/libherb/buffer.rb b/lib/herb/libherb/buffer.rb
index d682df170..5db3858dc 100644
--- a/lib/herb/libherb/buffer.rb
+++ b/lib/herb/libherb/buffer.rb
@@ -5,16 +5,16 @@
 
 module Herb
   module LibHerb
-    attach_function :buffer_init, [:pointer], :bool
-    attach_function :buffer_free, [:pointer], :void
-    attach_function :buffer_value, [:pointer], :pointer
-    attach_function :buffer_length, [:pointer], :size_t
-    attach_function :buffer_capacity, [:pointer], :size_t
-    attach_function :buffer_sizeof, [], :size_t
-    attach_function :buffer_append, [:pointer, :pointer], :void
+    attach_function :hb_buffer_init, [:pointer], :bool
+    attach_function :hb_buffer_free, [:pointer], :void
+    attach_function :hb_buffer_value, [:pointer], :pointer
+    attach_function :hb_buffer_length, [:pointer], :size_t
+    attach_function :hb_buffer_capacity, [:pointer], :size_t
+    attach_function :hb_buffer_sizeof, [], :size_t
+    attach_function :hb_buffer_append, [:pointer, :pointer], :void
 
     class Buffer
-      SIZEOF = LibHerb.buffer_sizeof
+      SIZEOF = LibHerb.hb_buffer_sizeof
 
       attr_reader :pointer
 
@@ -23,19 +23,19 @@ def initialize(pointer)
       end
 
       def append(string)
-        LibHerb.buffer_append(pointer, string)
+        LibHerb.hb_buffer_append(pointer, string)
       end
 
       def value
-        LibHerb.buffer_value(pointer)
+        LibHerb.hb_buffer_value(pointer)
       end
 
       def length
-        LibHerb.buffer_length(pointer)
+        LibHerb.hb_buffer_length(pointer)
       end
 
       def capacity
-        LibHerb.buffer_capacity(pointer)
+        LibHerb.hb_buffer_capacity(pointer)
       end
 
       def read
@@ -44,11 +44,11 @@ def read
 
       def self.with
         FFI::MemoryPointer.new(SIZEOF) do |pointer|
-          raise "couldn't allocate Buffer" unless LibHerb.buffer_init(pointer)
+          raise "couldn't allocate Buffer" unless LibHerb.hb_buffer_init(pointer)
 
           return yield new(pointer)
         ensure
-          LibHerb.buffer_free(pointer)
+          LibHerb.hb_buffer_free(pointer)
         end
       end
     end
diff --git a/lib/herb/libherb/libherb.rb b/lib/herb/libherb/libherb.rb
index 38354e405..03c3b77d7 100644
--- a/lib/herb/libherb/libherb.rb
+++ b/lib/herb/libherb/libherb.rb
@@ -26,14 +26,6 @@ def self.lex(source)
     )
   end
 
-  def self.lex_to_json(source)
-    LibHerb::Buffer.with do |output|
-      LibHerb.herb_lex_json_to_buffer(source, output.pointer)
-
-      JSON.parse(output.read.force_encoding("utf-8"))
-    end
-  end
-
   def self.extract_ruby(source)
     LibHerb::Buffer.with do |output|
       LibHerb.herb_extract_ruby_to_buffer(source, output.pointer)
diff --git a/lib/herb/project.rb b/lib/herb/project.rb
index aade882eb..bd44dc327 100644
--- a/lib/herb/project.rb
+++ b/lib/herb/project.rb
@@ -30,7 +30,7 @@ def initialize(project_path, output_file: nil)
     end
 
     def glob
-      "**/*.html.erb"
+      "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
     end
 
     def full_path_glob
@@ -78,19 +78,23 @@ def parse!
         failed_files = []
         timeout_files = []
         error_files = []
+        compilation_failed_files = []
         error_outputs = {}
         file_contents = {}
         parse_errors = {}
+        compilation_errors = {}
 
         files.each_with_index do |file_path, index|
           total_failed = failed_files.count
           total_timeout = timeout_files.count
           total_errors = error_files.count
+          total_compilation_failed = compilation_failed_files.count
 
-          lines_to_clear = 6 + total_failed + total_timeout + total_errors
+          lines_to_clear = 6 + total_failed + total_timeout + total_errors + total_compilation_failed
           lines_to_clear += 3 if total_failed.positive?
           lines_to_clear += 3 if total_timeout.positive?
           lines_to_clear += 3 if total_errors.positive?
+          lines_to_clear += 3 if total_compilation_failed.positive?
 
           lines_to_clear.times { print "\e[1A\e[K" } if index.positive? && interactive?
 
@@ -129,6 +133,13 @@ def parse!
               error_files.each { |file| puts "  - #{file}" }
               puts
             end
+
+            if compilation_failed_files.any?
+              puts
+              puts "Files with compilation errors:"
+              compilation_failed_files.each { |file| puts "  - #{file}" }
+              puts
+            end
           end
 
           begin
@@ -173,7 +184,33 @@ def parse!
               case $CHILD_STATUS.exitstatus
               when 0
                 log.puts "✅ Parsed #{file_path} successfully"
-                successful_files << file_path
+
+                begin
+                  Herb::Engine.new(file_content, filename: file_path, escape: true)
+
+                  log.puts "✅ Compiled #{file_path} successfully"
+                  successful_files << file_path
+                rescue Herb::Engine::CompilationError => e
+                  log.puts "❌ Compilation failed for #{file_path}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: e.message,
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                rescue StandardError => e
+                  log.puts "❌ Unexpected compilation error for #{file_path}: #{e.class}: #{e.message}"
+
+                  compilation_failed_files << file_path
+                  compilation_errors[file_path] = {
+                    error: "#{e.class}: #{e.message}",
+                    backtrace: e.backtrace&.first(10) || [],
+                  }
+
+                  file_contents[file_path] = file_content
+                end
               when 2
                 message = "⚠️ Parsing #{file_path} completed with errors"
                 log.puts message
@@ -248,8 +285,11 @@ def parse!
         summary = [
           heading("Summary"),
           "Total files: #{files.count}",
-          "✅ Successful: #{successful_files.count} (#{percentage(successful_files.count, files.count)}%)",
-          "❌ Failed: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
+          "✅ Successful (parsed & compiled): #{successful_files.count} (#{percentage(successful_files.count,
+                                                                                      files.count)}%)",
+          "❌ Compilation errors: #{compilation_failed_files.count} (#{percentage(compilation_failed_files.count,
+                                                                                  files.count)}%)",
+          "❌ Failed to parse: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
           "⚠️ Parse errors: #{error_files.count} (#{percentage(error_files.count, files.count)}%)",
           "⏱️ Timed out: #{timeout_files.count} (#{percentage(timeout_files.count, files.count)}%)"
         ]
@@ -289,7 +329,17 @@ def parse!
           end
         end
 
-        problem_files = failed_files + timeout_files + error_files
+        if compilation_failed_files.any?
+          log.puts "\n#{heading("Files with compilation errors")}"
+          puts "\nFiles with compilation errors:"
+
+          compilation_failed_files.each do |f|
+            log.puts f
+            puts "  - #{f}"
+          end
+        end
+
+        problem_files = failed_files + timeout_files + error_files + compilation_failed_files
 
         if problem_files.any?
           log.puts "\n#{heading("FILE CONTENTS AND DETAILS")}"
@@ -331,28 +381,43 @@ def parse!
               end
             end
 
-            next unless parse_errors[file]
+            if parse_errors[file]
+              if parse_errors[file][:stdout].strip.length.positive?
+                log.puts "\n#{heading("STANDARD OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stdout]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stdout].strip.length.positive?
-              log.puts "\n#{heading("STANDARD OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stdout]
-              log.puts "```"
-            end
+              if parse_errors[file][:stderr].strip.length.positive?
+                log.puts "\n#{heading("ERROR OUTPUT")}"
+                log.puts "```"
+                log.puts parse_errors[file][:stderr]
+                log.puts "```"
+              end
 
-            if parse_errors[file][:stderr].strip.length.positive?
-              log.puts "\n#{heading("ERROR OUTPUT")}"
-              log.puts "```"
-              log.puts parse_errors[file][:stderr]
-              log.puts "```"
+              if parse_errors[file][:ast]
+                log.puts "\n#{heading("AST")}"
+                log.puts "```"
+                log.puts parse_errors[file][:ast]
+                log.puts "```"
+                log.puts
+              end
             end
 
-            next unless parse_errors[file][:ast]
+            next unless compilation_errors[file]
 
-            log.puts "\n#{heading("AST")}"
+            log.puts "\n#{heading("COMPILATION ERROR")}"
             log.puts "```"
-            log.puts parse_errors[file][:ast]
+            log.puts compilation_errors[file][:error]
             log.puts "```"
+
+            if compilation_errors[file][:backtrace].any?
+              log.puts "\n#{heading("BACKTRACE")}"
+              log.puts "```"
+              log.puts compilation_errors[file][:backtrace].join("\n")
+              log.puts "```"
+            end
             log.puts
           end
         end
diff --git a/lib/herb/version.rb b/lib/herb/version.rb
index 47f0c2796..b3a0aa4e9 100644
--- a/lib/herb/version.rb
+++ b/lib/herb/version.rb
@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.7.4"
+  VERSION = "0.7.5"
 end
diff --git a/package.json b/package.json
index c02b85dfb..a684519d5 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
     "minimatch": "^10.0.3",
     "nx": "21.1.2",
     "oxlint": "^1.13.0",
-    "playwright": "^1.51.0",
+    "playwright": "^1.55.1",
     "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
     "rollup": "^4.47.1",
diff --git a/playground/index.html b/playground/index.html
index 24e47c0f6..f976d6d6d 100644
--- a/playground/index.html
+++ b/playground/index.html
@@ -173,6 +173,29 @@
                   </div>
                 </div>
 
+                <div class="relative">
+                  <button
+                    data-action="click->playground#autofixEditor"
+                    data-playground-target="autofixButton"
+                    id="autofix-editor"
+                    class="text-gray-900 dark:text-gray-100 bg-gray-100 dark:bg-gray-800 hover:bg-gray-200 dark:hover:bg-gray-700 rounded-md px-3 py-1.5 text-sm font-medium"
+                  >
+                    <i class="fas fa-wand-magic-sparkles w-4"></i>
+                    <i
+                      class="fas fa-circle-check w-4 text-green-600 hidden ease-in duration-300"
+                    ></i>
+
+                    <span class="ml-1">Autofix</span>
+                  </button>
+                  <div
+                    data-playground-target="autofixTooltip"
+                    class="hidden absolute top-full left-1/2 transform -translate-x-1/2 mt-2 px-2 py-1 text-xs text-white bg-black rounded-md whitespace-nowrap z-50"
+                  >
+                    Autocorrect autocorrectable Herb Linter offenses
+                    <div class="absolute bottom-full left-1/2 transform -translate-x-1/2 w-0 h-0 border-l-4 border-r-4 border-b-4 border-transparent border-b-black"></div>
+                  </div>
+                </div>
+
                 <div class="relative">
                   <button
                     data-action="click->playground#formatEditor"
diff --git a/playground/package.json b/playground/package.json
index 31c6c5407..3cb2bb182 100644
--- a/playground/package.json
+++ b/playground/package.json
@@ -19,16 +19,16 @@
   },
   "dependencies": {
     "@alenaksu/json-viewer": "^2.0.1",
-    "@herb-tools/browser": "0.7.4",
-    "@herb-tools/formatter": "0.7.4",
-    "@herb-tools/linter": "0.7.4",
+    "@herb-tools/browser": "0.7.5",
+    "@herb-tools/formatter": "0.7.5",
+    "@herb-tools/linter": "0.7.5",
     "@hotwired/stimulus": "^3.2.2",
     "dedent": "^1.6.0",
     "express": "^5.1.0",
     "lz-string": "^1.5.0",
     "monaco-editor": "^0.52.2",
     "prismjs": "^1.30.0",
-    "vite": "^7.1.7"
+    "vite": "^7.1.11"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
diff --git a/playground/src/controllers/playground_controller.js b/playground/src/controllers/playground_controller.js
index 2ebd2e7a5..bf50285a1 100644
--- a/playground/src/controllers/playground_controller.js
+++ b/playground/src/controllers/playground_controller.js
@@ -12,6 +12,7 @@ import { replaceTextareaWithMonaco } from "../monaco"
 import { findTreeLocationItemWithSmallestRangeFromPosition } from "../ranges"
 
 import { Herb } from "@herb-tools/browser"
+import { Linter } from "@herb-tools/linter"
 import { analyze } from "../analyze"
 
 window.Herb = Herb
@@ -61,6 +62,8 @@ export default class extends Controller {
     "formatVerification",
     "formatButton",
     "formatTooltip",
+    "autofixButton",
+    "autofixTooltip",
     "printerViewer",
     "printerOutput",
     "printerVerification",
@@ -156,6 +159,7 @@ export default class extends Controller {
 
     this.setupThemeListener()
     this.setupTooltip()
+    this.setupAutofixTooltip()
     this.setupShareTooltip()
     this.setupGitHubTooltip()
     this.setupCopyTooltip()
@@ -191,6 +195,7 @@ export default class extends Controller {
   disconnect() {
     window.removeEventListener("popstate", this.handlePopState)
     this.removeTooltip()
+    this.removeAutofixTooltip()
     this.removeShareTooltip()
     this.removeGitHubTooltip()
     this.removeCopyTooltip()
@@ -621,6 +626,58 @@ export default class extends Controller {
     }
   }
 
+  async autofixEditor(event) {
+    const button = this.getClosestButton(event.target)
+
+    if (button.disabled) {
+      return
+    }
+
+    const wandIcon = button.querySelector(".fa-wand-magic-sparkles")
+    const checkIcon = button.querySelector(".fa-circle-check")
+
+    try {
+      const value = this.editor ? this.editor.getValue() : this.inputTarget.value
+      const linter = new Linter(Herb)
+      const result = linter.autofix(value)
+
+      if (result && typeof result === "object" && "source" in result) {
+        const fixedCount = Array.isArray(result.fixed) ? result.fixed.length : 0
+
+        if (fixedCount > 0 && typeof result.source === "string") {
+          if (this.editor) {
+            this.editor.setValue(result.source)
+          } else {
+            this.inputTarget.value = result.source
+          }
+
+          if (wandIcon && checkIcon) {
+            wandIcon.classList.add("hidden")
+            checkIcon.classList.remove("hidden")
+            checkIcon.style.display = ""
+
+            setTimeout(() => {
+              this.resetAutofixButtonIcons()
+            }, 1000)
+          }
+
+          const offensesLabel = fixedCount === 1 ? "offense" : "offenses"
+          this.showTemporaryMessage(`Autofixed ${fixedCount} linter ${offensesLabel}`, "success")
+
+          await this.analyze()
+          this.resetAutofixButtonIcons()
+        } else {
+          this.showTemporaryMessage("No autocorrectable linter offenses found", "info")
+        }
+      } else {
+        this.showTemporaryMessage("Failed to autofix linter offenses", "error")
+      }
+    } catch (error) {
+      console.error("Autofix error:", error)
+      this.showTemporaryMessage("Failed to autofix linter offenses", "error")
+    }
+  }
+
   async analyze() {
     this.updateURL()
 
@@ -816,6 +873,24 @@ export default class extends Controller {
       }
     }
 
+    if (this.hasAutofixButtonTarget) {
+      const hasParserErrors = result.parseResult ? result.parseResult.recursiveErrors().length > 0 : false
+      const hasLintOffenses = !!(result.lintResult && Array.isArray(result.lintResult.offenses) && result.lintResult.offenses.length > 0)
+
+      if (hasParserErrors) {
+        this.disableAutofixButton()
+        this.setupAutofixTooltip()
+        this.updateAutofixTooltipText('Cannot autofix code due to parser errors. Fix parser errors in Diagnostics tab first.')
+      } else if (!hasLintOffenses) {
+        this.disableAutofixButton()
+        this.setupAutofixTooltip()
+        this.updateAutofixTooltipText('No Herb Linter offenses found to autofix.')
+      } else {
+        this.enableAutofixButton()
+        this.updateAutofixTooltipText('Autocorrect autocorrectable Herb Linter offenses')
+      }
+    }
+
     if (this.hasRubyViewerTarget) {
       this.rubyViewerTarget.classList.add("language-ruby")
       this.rubyViewerTarget.textContent = result.ruby
@@ -1236,6 +1311,72 @@ export default class extends Controller {
     }
   }
 
+  setupAutofixTooltip() {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixButtonTarget.addEventListener('mouseenter', this.showAutofixTooltip)
+      this.autofixButtonTarget.addEventListener('mouseleave', this.hideAutofixTooltip)
+    }
+  }
+
+  removeAutofixTooltip() {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixButtonTarget.removeEventListener('mouseenter', this.showAutofixTooltip)
+      this.autofixButtonTarget.removeEventListener('mouseleave', this.hideAutofixTooltip)
+
+      this.hideAutofixTooltip()
+    }
+  }
+
+  showAutofixTooltip = () => {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixTooltipTarget.classList.remove('hidden')
+    }
+  }
+
+  hideAutofixTooltip = () => {
+    if (this.hasAutofixTooltipTarget) {
+      this.autofixTooltipTarget.classList.add('hidden')
+    }
+  }
+
+  updateAutofixTooltipText(text) {
+    if (this.hasAutofixTooltipTarget) {
+      const textNode = this.autofixTooltipTarget.firstChild
+      if (textNode && textNode.nodeType === Node.TEXT_NODE) {
+        textNode.textContent = text
+      }
+    }
+  }
+
+  enableAutofixButton() {
+    this.autofixButtonTarget.disabled = false
+    this.autofixButtonTarget.classList.remove('opacity-50', 'cursor-not-allowed')
+    this.autofixButtonTarget.classList.add('hover:bg-gray-200', 'dark:hover:bg-gray-700')
+  }
+
+  disableAutofixButton() {
+    this.autofixButtonTarget.disabled = true
+    this.autofixButtonTarget.classList.add('opacity-50', 'cursor-not-allowed')
+    this.autofixButtonTarget.classList.remove('hover:bg-gray-200', 'dark:hover:bg-gray-700')
+    this.resetAutofixButtonIcons()
+  }
+
+  resetAutofixButtonIcons() {
+    if (!this.hasAutofixButtonTarget) return
+
+    const wandIcon = this.autofixButtonTarget.querySelector(".fa-wand-magic-sparkles")
+    const checkIcon = this.autofixButtonTarget.querySelector(".fa-circle-check")
+
+    if (wandIcon) {
+      wandIcon.classList.remove("hidden")
+    }
+
+    if (checkIcon) {
+      checkIcon.classList.add("hidden")
+      checkIcon.style.display = ""
+    }
+  }
+
   setupShareTooltip() {
     if (this.hasShareButtonTarget && this.hasShareTooltipTarget) {
       this.shareButtonTarget.addEventListener('mouseenter', this.showShareTooltip)
diff --git a/printer.md b/printer.md
deleted file mode 100644
index 0bcf4fea5..000000000
--- a/printer.md
+++ /dev/null
@@ -1,472 +0,0 @@
-
-
-------
-
-
-
-
-
-
-# Printer
-
-AST-to-source code conversion for the Herb ecosystem.
-
-## Status
-**In Development** - Core functionality available
-
-## Overview
-
-The Herb Printer converts Herb AST nodes back into source code, enabling tools like the formatter and minifier to reconstruct templates after transformation. It provides fine-grained control over output formatting and serves as the foundation for code generation workflows.
-
-## Features
-
-### AST Reconstruction
-- **Complete fidelity**: Reconstructs exact source code from AST
-- **Configurable formatting**: Control indentation, spacing, and line breaks
-- **Comment preservation**: Maintains comments with position information
-- **Error handling**: Graceful handling of malformed AST nodes
-
-### Output Customization
-- **Indentation styles**: Spaces, tabs, custom patterns
-- **Line ending control**: LF, CRLF, or system default
-- **Whitespace handling**: Configurable whitespace preservation
-- **ERB tag formatting**: Control ERB tag spacing and style
-
-### Source Map Generation
-- **Position mapping**: Maps output positions back to original AST nodes
-- **Debugging support**: Enables source-level debugging of generated code
-- **Tool integration**: Compatible with development tools and debuggers
-
-## Installation
-
-```bash
-npm install @herb-tools/printer
-```
-
-For Ruby:
-```bash
-gem install herb-printer
-```
-
-## Usage
-
-### JavaScript/Node.js
-
-```javascript
-import { Printer } from '@herb-tools/printer'
-import { Herb } from '@herb-tools/node'
-
-// Parse template to AST
-const ast = Herb.parse('<div><%= @user.name %></div>')
-
-// Create printer with custom formatting
-const printer = new Printer({
-  indentSize: 2,
-  indentType: 'space',
-  lineEnding: '\n',
-  preserveWhitespace: true
-})
-
-// Convert AST back to source
-const source = printer.print(ast)
-console.log(source)
-// <div><%= @user.name %></div>
-```
-
-### Advanced Configuration
-
-```javascript
-const printer = new Printer({
-  // Indentation
-  indentSize: 2,
-  indentType: 'space', // 'space', 'tab', 'mixed'
-
-  // Line handling
-  lineEnding: '\n', // '\n', '\r\n', 'auto'
-  maxLineLength: 80,
-  wrapLongLines: true,
-
-  // ERB formatting
-  erbTagSpacing: 'compact', // 'compact', 'spaced', 'preserve'
-  erbOutputPadding: true,
-
-  // HTML formatting
-  htmlAttributeWrap: 'auto', // 'auto', 'force', 'never'
-  htmlSelfClosing: 'xml', // 'xml', 'html', 'preserve'
-
-  // Comment handling
-  preserveComments: true,
-  commentIndentation: 'align',
-
-  // Source maps
-  generateSourceMap: true,
-  sourceMapMode: 'inline' // 'inline', 'external', 'comment'
-})
-```
-
-### Ruby API
-
-```ruby
-require 'herb/printer'
-
-# Parse template
-ast = Herb.parse('<div><%= @user.name %></div>')
-
-# Create printer
-printer = Herb::Printer.new(
-  indent_size: 2,
-  indent_type: :space,
-  erb_tag_spacing: :compact
-)
-
-# Generate source code
-source = printer.print(ast)
-puts source
-```
-
-## Formatting Styles
-
-### ERB Tag Styles
-
-```javascript
-// Compact style (default)
-printer.setOption('erbTagSpacing', 'compact')
-// Output: <%=@user.name%>
-
-// Spaced style
-printer.setOption('erbTagSpacing', 'spaced')
-// Output: <%= @user.name %>
-
-// Preserve original
-printer.setOption('erbTagSpacing', 'preserve')
-// Output: (maintains original spacing)
-```
-
-### HTML Attribute Formatting
-
-```javascript
-const ast = Herb.parse('<div class="user" data-id="123" data-name="john">')
-
-// Auto wrap (default)
-printer.setOption('htmlAttributeWrap', 'auto')
-printer.setOption('maxLineLength', 40)
-// Output:
-// <div class="user"
-//      data-id="123"
-//      data-name="john">
-
-// Force single line
-printer.setOption('htmlAttributeWrap', 'never')
-// Output: <div class="user" data-id="123" data-name="john">
-```
-
-### Indentation Styles
-
-```javascript
-// Spaces (default)
-printer.setOption('indentType', 'space')
-printer.setOption('indentSize', 2)
-
-// Tabs
-printer.setOption('indentType', 'tab')
-printer.setOption('indentSize', 1)
-
-// Mixed (tabs for structure, spaces for alignment)
-printer.setOption('indentType', 'mixed')
-```
-
-## Integration with Tools
-
-### Formatter Integration
-
-```javascript
-// formatter.js
-import { Formatter } from '@herb-tools/formatter'
-import { Printer } from '@herb-tools/printer'
-
-class Formatter {
-  constructor(options) {
-    this.printer = new Printer(options.printer)
-  }
-
-  format(source) {
-    // Parse source to AST
-    const ast = this.parse(source)
-
-    // Apply formatting transformations
-    const formattedAST = this.transform(ast)
-
-    // Use printer to generate formatted source
-    return this.printer.print(formattedAST)
-  }
-}
-```
-
-### Minifier Integration
-
-```javascript
-// minifier.js
-import { Minifier } from '@herb-tools/minifier'
-import { Printer } from '@herb-tools/printer'
-
-class Minifier {
-  constructor() {
-    this.printer = new Printer({
-      indentSize: 0,
-      preserveWhitespace: false,
-      erbTagSpacing: 'compact',
-      generateSourceMap: false
-    })
-  }
-
-  minify(source) {
-    const ast = this.parse(source)
-    const minifiedAST = this.optimize(ast)
-    return this.printer.print(minifiedAST)
-  }
-}
-```
-
-### Custom Code Generator
-
-```javascript
-class TemplateGenerator {
-  constructor() {
-    this.printer = new Printer({
-      indentSize: 2,
-      erbTagSpacing: 'spaced'
-    })
-  }
-
-  generateTemplate(data) {
-    // Build AST programmatically
-    const ast = this.buildAST(data)
-
-    // Generate source code
-    return this.printer.print(ast)
-  }
-
-  buildAST(data) {
-    return {
-      type: 'Document',
-      children: [
-        {
-          type: 'HTMLElement',
-          tagName: 'div',
-          attributes: [
-            {
-              type: 'HTMLAttribute',
-              name: 'class',
-              value: data.className
-            }
-          ],
-          children: [
-            {
-              type: 'ERBContent',
-              rubyCode: `@${data.variable}.${data.method}`
-            }
-          ]
-        }
-      ]
-    }
-  }
-}
-```
-
-## Source Maps
-
-### Generating Source Maps
-
-```javascript
-const printer = new Printer({
-  generateSourceMap: true,
-  sourceMapMode: 'external'
-})
-
-const result = printer.printWithSourceMap(ast)
-console.log(result.code)     // Generated source code
-console.log(result.map)      // Source map object
-
-// Save source map to file
-fs.writeFileSync('output.erb.map', JSON.stringify(result.map))
-```
-
-### Source Map Format
-
-```json
-{
-  "version": 3,
-  "sources": ["original.erb"],
-  "names": [],
-  "mappings": "AAAA,KAAK,CAAC,KAAK",
-  "sourceRoot": "",
-  "sourcesContent": ["<div><%= @user.name %></div>"]
-}
-```
-
-### Using Source Maps
-
-```javascript
-// Debug formatted code
-const { SourceMapConsumer } = require('source-map')
-
-async function debugPosition(line, column) {
-  const consumer = await new SourceMapConsumer(sourceMap)
-  const original = consumer.originalPositionFor({ line, column })
-
-  console.log(`Generated position ${line}:${column} maps to original ${original.line}:${original.column}`)
-}
-```
-
-## API Reference
-
-### Printer Class
-
-```typescript
-class Printer {
-  constructor(options: PrinterOptions)
-
-  // Core printing methods
-  print(ast: ASTNode): string
-  printWithSourceMap(ast: ASTNode): { code: string, map: SourceMap }
-
-  // Configuration
-  setOption(key: string, value: any): void
-  setOptions(options: Partial<PrinterOptions>): void
-  getOptions(): PrinterOptions
-
-  // Utility methods
-  static defaultOptions(): PrinterOptions
-  static validateAST(ast: ASTNode): ValidationResult
-}
-
-interface PrinterOptions {
-  // Indentation
-  indentSize: number
-  indentType: 'space' | 'tab' | 'mixed'
-
-  // Line handling
-  lineEnding: '\n' | '\r\n' | 'auto'
-  maxLineLength: number
-  wrapLongLines: boolean
-
-  // ERB formatting
-  erbTagSpacing: 'compact' | 'spaced' | 'preserve'
-  erbOutputPadding: boolean
-
-  // HTML formatting
-  htmlAttributeWrap: 'auto' | 'force' | 'never'
-  htmlSelfClosing: 'xml' | 'html' | 'preserve'
-
-  // Comments
-  preserveComments: boolean
-  commentIndentation: 'align' | 'indent' | 'preserve'
-
-  // Source maps
-  generateSourceMap: boolean
-  sourceMapMode: 'inline' | 'external' | 'comment'
-}
-```
-
-### Node Handlers
-
-```javascript
-class Printer {
-  // Override specific node handlers
-  printHTMLElement(node, context) {
-    // Custom HTML element printing
-    return this.defaultPrintHTMLElement(node, context)
-  }
-
-  printERBContent(node, context) {
-    // Custom ERB content printing
-    return this.defaultPrintERBContent(node, context)
-  }
-
-  printHTMLAttribute(node, context) {
-    // Custom attribute printing
-    return this.defaultPrintHTMLAttribute(node, context)
-  }
-}
-```
-
-## Performance
-
-### Benchmarks
-
-| AST Size | Print Time | Memory Usage |
-|----------|------------|--------------|
-| Small (10 nodes) | 0.1ms | 50 KB |
-| Medium (100 nodes) | 0.8ms | 200 KB |
-| Large (1000 nodes) | 6ms | 1.5 MB |
-
-### Optimization Tips
-
-```javascript
-// Reuse printer instances
-const printer = new Printer(options)
-
-// Batch processing
-const results = asts.map(ast => printer.print(ast))
-
-// Disable source maps for production
-const prodPrinter = new Printer({
-  ...options,
-  generateSourceMap: false
-})
-
-// Stream large ASTs
-const stream = printer.printStream(largeAST)
-```
-
-## Testing
-
-### Unit Tests
-
-```javascript
-import { Printer } from '@herb-tools/printer'
-import { Herb } from '@herb-tools/node'
-
-describe('Printer', () => {
-  test('round-trip preservation', () => {
-    const source = '<div><%= @user.name %></div>'
-    const ast = Herb.parse(source)
-    const printed = new Printer().print(ast)
-
-    expect(printed).toBe(source)
-  })
-
-  test('custom formatting', () => {
-    const ast = Herb.parse('<%=@user.name%>')
-    const printer = new Printer({ erbTagSpacing: 'spaced' })
-    const printed = printer.print(ast)
-
-    expect(printed).toBe('<%= @user.name %>')
-  })
-})
-```
-
-### Integration Tests
-
-```javascript
-test('formatter integration', () => {
-  const unformatted = '<div><%=@user.name%></div>'
-  const formatted = new Formatter().format(unformatted)
-
-  expect(formatted).toBe('<div>\n  <%= @user.name %>\n</div>')
-})
-```
-
-## Contributing
-
-Areas for contribution:
-- Additional formatting options
-- Performance optimizations
-- Source map enhancements
-- Tool integrations
-
-## Resources
-
-- [GitHub Repository](https://github.com/marcoroth/herb/tree/main/javascript/packages/printer)
-- [API Documentation](https://herb-tools.dev/printer/api)
-- [Source Map Specification](https://sourcemaps.info/spec.html)
diff --git a/src/analyze.c b/src/analyze.c
index 8c0a7ea4a..c6204e27e 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -1,7 +1,6 @@
 #include "include/analyze.h"
 #include "include/analyze_helpers.h"
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/extract.h"
@@ -11,6 +10,8 @@
 #include "include/prism_helpers.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_string.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -19,7 +20,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-static analyzed_ruby_T* herb_analyze_ruby(char* source) {
+static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = init_analyzed_ruby(source);
 
   pm_visit_node(analyzed->root, search_if_nodes, analyzed);
@@ -52,9 +53,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     const char* opening = erb_content_node->tag_opening->value;
 
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
-      analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
-
-      if (false) { pretty_print_analyzed_ruby(analyzed, erb_content_node->content->value); }
+      analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string(erb_content_node->content->value));
 
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
@@ -73,16 +72,16 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
@@ -96,12 +95,8 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
 
   if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (ruby->valid) {
-    if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
-    return CONTROL_TYPE_UNKNOWN;
-  }
+  if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
   if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
   if (has_if_node(ruby)) { return CONTROL_TYPE_IF; }
   if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
@@ -119,6 +114,7 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
   if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
+  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
 
   return CONTROL_TYPE_UNKNOWN;
 }
@@ -152,22 +148,22 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 
 static AST_NODE_T* create_control_node(
   AST_ERB_CONTENT_NODE_T* erb_node,
-  array_T* children,
+  hb_array_T* children,
   AST_NODE_T* subsequent,
   AST_ERB_END_NODE_T* end_node,
   control_type_t control_type
 ) {
-  array_T* errors = array_init(8);
-  position_T* start_position = erb_node->tag_opening->location->start;
-  position_T* end_position = erb_node->tag_closing->location->end;
+  hb_array_T* errors = hb_array_init(8);
+  position_T start_position = erb_node->tag_opening->location.start;
+  position_T end_position = erb_node->tag_closing->location.end;
 
   if (end_node) {
-    end_position = end_node->base.location->end;
-  } else if (children && array_size(children) > 0) {
-    AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-    end_position = last_child->location->end;
+    end_position = end_node->base.location.end;
+  } else if (children && hb_array_size(children) > 0) {
+    AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
+    end_position = last_child->location.end;
   } else if (subsequent) {
-    end_position = subsequent->location->end;
+    end_position = subsequent->location.end;
   }
 
   token_T* tag_opening = erb_node->tag_opening;
@@ -190,30 +186,31 @@ static AST_NODE_T* create_control_node(
       );
 
     case CONTROL_TYPE_ELSE:
-      return (AST_NODE_T*)
-        ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
 
     case CONTROL_TYPE_CASE:
     case CONTROL_TYPE_CASE_MATCH: {
       AST_ERB_ELSE_NODE_T* else_node = NULL;
       if (subsequent && subsequent->type == AST_ERB_ELSE_NODE) { else_node = (AST_ERB_ELSE_NODE_T*) subsequent; }
 
-      array_T* when_conditions = array_init(8);
-      array_T* in_conditions = array_init(8);
-      array_T* non_when_non_in_children = array_init(8);
+      hb_array_T* when_conditions = hb_array_init(8);
+      hb_array_T* in_conditions = hb_array_init(8);
+      hb_array_T* non_when_non_in_children = hb_array_init(8);
 
-      for (size_t i = 0; i < array_size(children); i++) {
-        AST_NODE_T* child = array_get(children, i);
+      for (size_t i = 0; i < hb_array_size(children); i++) {
+        AST_NODE_T* child = hb_array_get(children, i);
         if (child && child->type == AST_ERB_WHEN_NODE) {
-          array_append(when_conditions, child);
+          hb_array_append(when_conditions, child);
         } else if (child && child->type == AST_ERB_IN_NODE) {
-          array_append(in_conditions, child);
+          hb_array_append(in_conditions, child);
         } else {
-          array_append(non_when_non_in_children, child);
+          hb_array_append(non_when_non_in_children, child);
         }
       }
 
-      if (array_size(in_conditions) > 0) {
+      if (hb_array_size(in_conditions) > 0) {
         return (AST_NODE_T*) ast_erb_case_match_node_init(
           tag_opening,
           content,
@@ -243,13 +240,15 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_WHEN: {
-      return (AST_NODE_T*)
-        ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_IN: {
-      return (AST_NODE_T*)
-        ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_BEGIN: {
@@ -300,8 +299,9 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_ENSURE: {
-      return (AST_NODE_T*)
-        ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_UNLESS: {
@@ -375,34 +375,35 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_YIELD: {
-      return (AST_NODE_T*)
-        ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
     }
 
-    default: array_free(&errors); return NULL;
+    default: hb_array_free(&errors); return NULL;
   }
 }
 
 static size_t process_control_structure(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* output_array,
+  hb_array_T* output_array,
   analyze_ruby_context_T* context,
   control_type_t initial_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
-  array_T* children = array_init(8);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
   if (initial_type == CONTROL_TYPE_CASE || initial_type == CONTROL_TYPE_CASE_MATCH) {
-    array_T* when_conditions = array_init(8);
-    array_T* in_conditions = array_init(8);
-    array_T* non_when_non_in_children = array_init(8);
+    hb_array_T* when_conditions = hb_array_init(8);
+    hb_array_T* in_conditions = hb_array_init(8);
+    hb_array_T* non_when_non_in_children = hb_array_init(8);
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
@@ -413,17 +414,17 @@ static size_t process_control_structure(
         if (next_type == CONTROL_TYPE_WHEN || next_type == CONTROL_TYPE_IN) { break; }
       }
 
-      array_append(non_when_non_in_children, next_node);
+      hb_array_append(non_when_non_in_children, next_node);
       index++;
     }
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
       if (next_node->type != AST_ERB_CONTENT_NODE) {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
         continue;
       }
@@ -432,101 +433,67 @@ static size_t process_control_structure(
       control_type_t next_type = detect_control_type(erb_content);
 
       if (next_type == CONTROL_TYPE_WHEN) {
-        array_T* when_statements = array_init(8);
+        hb_array_T* when_statements = hb_array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(when_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
 
         AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           when_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
-          array_init(8)
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
+          hb_array_init(8)
         );
 
-        array_append(when_conditions, (AST_NODE_T*) when_node);
+        hb_array_append(when_conditions, (AST_NODE_T*) when_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_IN) {
-        array_T* in_statements = array_init(8);
+        hb_array_T* in_statements = hb_array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(in_statements, child);
-          index++;
-        }
+        index = process_block_children(node, array, index, in_statements, context, CONTROL_TYPE_IN);
 
         AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           in_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
-          array_init(8)
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
+          hb_array_init(8)
         );
 
-        array_append(in_conditions, (AST_NODE_T*) in_node);
+        hb_array_append(in_conditions, (AST_NODE_T*) in_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_ELSE || next_type == CONTROL_TYPE_END) {
         break;
       } else {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
       }
     }
 
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -537,7 +504,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(else_children, child);
+            hb_array_append(else_children, child);
             index++;
           }
 
@@ -546,9 +513,9 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            hb_array_init(8)
           );
         }
       }
@@ -556,8 +523,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -567,8 +534,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -577,22 +544,22 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
-    } else if (array_size(when_conditions) > 0) {
-      AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
-      end_position = last_when->location->end;
-    } else if (array_size(in_conditions) > 0) {
-      AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
-      end_position = last_in->location->end;
+      end_position = else_clause->base.location.end;
+    } else if (hb_array_size(when_conditions) > 0) {
+      AST_NODE_T* last_when = hb_array_get(when_conditions, hb_array_size(when_conditions) - 1);
+      end_position = last_when->location.end;
+    } else if (hb_array_size(in_conditions) > 0) {
+      AST_NODE_T* last_in = hb_array_get(in_conditions, hb_array_size(in_conditions) - 1);
+      end_position = last_in->location.end;
     }
 
-    if (array_size(in_conditions) > 0) {
+    if (hb_array_size(in_conditions) > 0) {
       AST_ERB_CASE_MATCH_NODE_T* case_match_node = ast_erb_case_match_node_init(
         erb_node->tag_opening,
         erb_node->content,
@@ -603,10 +570,10 @@ static size_t process_control_structure(
         end_node,
         start_position,
         end_position,
-        array_init(8)
+        hb_array_init(8)
       );
 
-      array_append(output_array, (AST_NODE_T*) case_match_node);
+      hb_array_append(output_array, (AST_NODE_T*) case_match_node);
       return index;
     }
 
@@ -620,10 +587,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) case_node);
+    hb_array_append(output_array, (AST_NODE_T*) case_node);
     return index;
   }
 
@@ -634,8 +601,8 @@ static size_t process_control_structure(
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
     AST_ERB_ENSURE_NODE_T* ensure_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -649,20 +616,20 @@ static size_t process_control_structure(
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -673,7 +640,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_ENSURE || child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(else_children, child);
+            hb_array_append(else_children, child);
             index++;
           }
 
@@ -682,28 +649,28 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            hb_array_init(8)
           );
         }
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ENSURE) {
-          array_T* ensure_children = array_init(8);
+          hb_array_T* ensure_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -714,7 +681,7 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(ensure_children, child);
+            hb_array_append(ensure_children, child);
             index++;
           }
 
@@ -723,9 +690,9 @@ static size_t process_control_structure(
             next_erb->content,
             next_erb->tag_closing,
             ensure_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            hb_array_init(8)
           );
         }
       }
@@ -733,8 +700,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -744,8 +711,8 @@ static size_t process_control_structure(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
             end_erb->base.errors
           );
 
@@ -754,17 +721,17 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (ensure_clause) {
-      end_position = ensure_clause->base.location->end;
+      end_position = ensure_clause->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (rescue_clause) {
-      end_position = rescue_clause->base.location->end;
+      end_position = rescue_clause->base.location.end;
     }
 
     AST_ERB_BEGIN_NODE_T* begin_node = ast_erb_begin_node_init(
@@ -778,10 +745,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) begin_node);
+    hb_array_append(output_array, (AST_NODE_T*) begin_node);
     return index;
   }
 
@@ -790,8 +757,8 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_close = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_close = hb_array_get(array, index);
 
       if (potential_close && potential_close->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* close_erb = (AST_ERB_CONTENT_NODE_T*) potential_close;
@@ -802,8 +769,8 @@ static size_t process_control_structure(
             close_erb->tag_opening,
             close_erb->content,
             close_erb->tag_closing,
-            close_erb->tag_opening->location->start,
-            close_erb->tag_closing->location->end,
+            close_erb->tag_opening->location.start,
+            close_erb->tag_closing->location.end,
             close_erb->base.errors
           );
 
@@ -812,14 +779,14 @@ static size_t process_control_structure(
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
-    } else if (children && array_size(children) > 0) {
-      AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-      end_position = last_child->location->end;
+      end_position = end_node->base.location.end;
+    } else if (children && hb_array_size(children) > 0) {
+      AST_NODE_T* last_child = hb_array_get(children, hb_array_size(children) - 1);
+      end_position = last_child->location.end;
     }
 
     AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
@@ -830,10 +797,10 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      hb_array_init(8)
     );
 
-    array_append(output_array, (AST_NODE_T*) block_node);
+    hb_array_append(output_array, (AST_NODE_T*) block_node);
     return index;
   }
 
@@ -842,8 +809,8 @@ static size_t process_control_structure(
   AST_NODE_T* subsequent = NULL;
   AST_ERB_END_NODE_T* end_node = NULL;
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -855,8 +822,8 @@ static size_t process_control_structure(
     }
   }
 
-  if (index < array_size(array)) {
-    AST_NODE_T* potential_end = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* potential_end = hb_array_get(array, index);
 
     if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
@@ -866,8 +833,8 @@ static size_t process_control_structure(
           end_erb->tag_opening,
           end_erb->content,
           end_erb->tag_closing,
-          end_erb->tag_opening->location->start,
-          end_erb->tag_closing->location->end,
+          end_erb->tag_opening->location.start,
+          end_erb->tag_closing->location.end,
           end_erb->base.errors
         );
 
@@ -878,22 +845,22 @@ static size_t process_control_structure(
 
   AST_NODE_T* control_node = create_control_node(erb_node, children, subsequent, end_node, initial_type);
 
-  if (control_node) { array_append(output_array, control_node); }
+  if (control_node) { hb_array_append(output_array, control_node); }
 
   return index;
 }
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
   control_type_t type = detect_control_type(erb_node);
-  array_T* children = array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
@@ -901,8 +868,8 @@ static size_t process_subsequent_block(
 
   AST_NODE_T* subsequent_node = create_control_node(erb_node, children, NULL, NULL, type);
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -953,19 +920,19 @@ static size_t process_subsequent_block(
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  while (index < array_size(array)) {
-    AST_NODE_T* child = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* child = hb_array_get(array, index);
 
     if (!child) { break; }
 
     if (child->type != AST_ERB_CONTENT_NODE) {
-      array_append(children_array, child);
+      hb_array_append(children_array, child);
       index++;
       continue;
     }
@@ -978,35 +945,35 @@ static size_t process_block_children(
     if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || child_type == CONTROL_TYPE_CASE_MATCH
         || child_type == CONTROL_TYPE_BEGIN || child_type == CONTROL_TYPE_UNLESS || child_type == CONTROL_TYPE_WHILE
         || child_type == CONTROL_TYPE_UNTIL || child_type == CONTROL_TYPE_FOR || child_type == CONTROL_TYPE_BLOCK) {
-      array_T* temp_array = array_init(1);
+      hb_array_T* temp_array = hb_array_init(1);
       size_t new_index = process_control_structure(node, array, index, temp_array, context, child_type);
 
-      if (array_size(temp_array) > 0) { array_append(children_array, array_get(temp_array, 0)); }
+      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_get(temp_array, 0)); }
 
-      array_free(&temp_array);
+      hb_array_free(&temp_array);
 
       index = new_index;
       continue;
     }
 
-    array_append(children_array, child);
+    hb_array_append(children_array, child);
     index++;
   }
 
   return index;
 }
 
-static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_ruby_context_T* context) {
-  array_T* new_array = array_init(array_size(array));
+static hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context) {
+  hb_array_T* new_array = hb_array_init(hb_array_size(array));
   size_t index = 0;
 
-  while (index < array_size(array)) {
-    AST_NODE_T* item = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* item = hb_array_get(array, index);
 
     if (!item) { break; }
 
     if (item->type != AST_ERB_CONTENT_NODE) {
-      array_append(new_array, item);
+      hb_array_append(new_array, item);
       index++;
       continue;
     }
@@ -1028,12 +995,12 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
         continue;
 
       case CONTROL_TYPE_YIELD: {
-        AST_NODE_T* yield_node = create_control_node(erb_node, array_init(8), NULL, NULL, type);
+        AST_NODE_T* yield_node = create_control_node(erb_node, hb_array_init(8), NULL, NULL, type);
 
         if (yield_node) {
-          array_append(new_array, yield_node);
+          hb_array_append(new_array, yield_node);
         } else {
-          array_append(new_array, item);
+          hb_array_append(new_array, item);
         }
 
         index++;
@@ -1041,7 +1008,7 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
       }
 
       default:
-        array_append(new_array, item);
+        hb_array_append(new_array, item);
         index++;
         break;
     }
@@ -1056,30 +1023,30 @@ static bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
 
   if (node->type == AST_DOCUMENT_NODE) {
     AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
-    array_T* old_array = document_node->children;
+    hb_array_T* old_array = document_node->children;
     document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ELEMENT_NODE) {
     AST_HTML_ELEMENT_NODE_T* element_node = (AST_HTML_ELEMENT_NODE_T*) node;
-    array_T* old_array = element_node->body;
+    hb_array_T* old_array = element_node->body;
     element_node->body = rewrite_node_array((AST_NODE_T*) node, element_node->body, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_OPEN_TAG_NODE) {
     AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
-    array_T* old_array = open_tag->children;
+    hb_array_T* old_array = open_tag->children;
     open_tag->children = rewrite_node_array((AST_NODE_T*) node, open_tag->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
-    array_T* old_array = value_node->children;
+    hb_array_T* old_array = value_node->children;
     value_node->children = rewrite_node_array((AST_NODE_T*) node, value_node->children, context);
-    array_free(&old_array);
+    hb_array_free(&old_array);
   }
 
   herb_visit_child_nodes(node, transform_erb_nodes, data);
@@ -1093,19 +1060,21 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
   analyze_ruby_context_T* context = malloc(sizeof(analyze_ruby_context_T));
   context->document = document;
   context->parent = NULL;
-  context->ruby_context_stack = array_init(8);
+  context->ruby_context_stack = hb_array_init(8);
 
   herb_visit_node((AST_NODE_T*) document, transform_erb_nodes, context);
 
   herb_analyze_parse_errors(document, source);
 
-  array_free(&context->ruby_context_stack);
+  hb_array_free(&context->ruby_context_stack);
   free(context);
 }
 
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source);
 
+  if (!extracted_ruby) { return; }
+
   pm_parser_t parser;
   pm_options_t options = { 0, .partial_script = true };
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
@@ -1116,7 +1085,7 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
        error = (const pm_diagnostic_t*) error->node.next) {
 
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
-    array_append(document->base.errors, parse_error);
+    hb_array_append(document->base.errors, parse_error);
   }
 
   pm_node_destroy(&parser, root);
diff --git a/src/analyzed_ruby.c b/src/analyzed_ruby.c
index a2cd0947b..10e5f585f 100644
--- a/src/analyzed_ruby.c
+++ b/src/analyzed_ruby.c
@@ -1,12 +1,13 @@
 #include "include/analyzed_ruby.h"
+#include "include/util/hb_string.h"
 
 #include <prism.h>
 #include <string.h>
 
-analyzed_ruby_T* init_analyzed_ruby(char* source) {
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
 
-  pm_parser_init(&analyzed->parser, (const uint8_t*) source, strlen(source), NULL);
+  pm_parser_init(&analyzed->parser, (const uint8_t*) source.data, source.length, NULL);
 
   analyzed->root = pm_parse(&analyzed->parser);
   analyzed->valid = (analyzed->parser.error_list.size == 0);
diff --git a/src/ast_node.c b/src/ast_node.c
index 350599c13..e66414249 100644
--- a/src/ast_node.c
+++ b/src/ast_node.c
@@ -12,14 +12,15 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* start, position_T* end, array_T* errors) {
+void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, hb_array_T* errors) {
   if (!node) { return; }
 
   node->type = type;
-  node->location = location_init(position_copy(start), position_copy(end));
+  node->location.start = start;
+  node->location.end = end;
 
   if (errors == NULL) {
-    node->errors = array_init(8);
+    node->errors = hb_array_init(8);
   } else {
     node->errors = errors;
   }
@@ -28,7 +29,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* sta
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
   AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
 
-  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
 
   literal->content = herb_strdup(token->value);
 
@@ -40,35 +41,31 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
 }
 
 size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return array_size(node->errors);
+  return hb_array_size(node->errors);
 }
 
-array_T* ast_node_errors(const AST_NODE_T* node) {
+hb_array_T* ast_node_errors(const AST_NODE_T* node) {
   return node->errors;
 }
 
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
-  array_append(node->errors, error);
+  hb_array_append(node->errors, error);
 }
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position) {
-  if (node->location->start != NULL) { position_free(node->location->start); }
-
-  node->location->start = position_copy(position);
+void ast_node_set_start(AST_NODE_T* node, position_T position) {
+  node->location.start = position;
 }
 
-void ast_node_set_end(AST_NODE_T* node, position_T* position) {
-  if (node->location->end != NULL) { position_free(node->location->end); }
-
-  node->location->end = position_copy(position);
+void ast_node_set_end(AST_NODE_T* node, position_T position) {
+  node->location.end = position;
 }
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_start(node, token->location->start);
+  ast_node_set_start(node, token->location.start);
 }
 
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_end(node, token->location->end);
+  ast_node_set_end(node, token->location.end);
 }
 
 void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {
diff --git a/src/buffer.c b/src/buffer.c
deleted file mode 100644
index 750e2190d..000000000
--- a/src/buffer.c
+++ /dev/null
@@ -1,232 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "include/buffer.h"
-#include "include/macros.h"
-#include "include/memory.h"
-#include "include/util.h"
-
-bool buffer_init(buffer_T* buffer) {
-  buffer->capacity = 1024;
-  buffer->length = 0;
-  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
-
-  if (!buffer->value) {
-    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
-    return false;
-  }
-
-  buffer->value[0] = '\0';
-
-  return true;
-}
-
-buffer_T buffer_new(void) {
-  buffer_T buffer;
-  buffer_init(&buffer);
-  return buffer;
-}
-
-char* buffer_value(const buffer_T* buffer) {
-  return buffer->value;
-}
-
-size_t buffer_length(const buffer_T* buffer) {
-  return buffer->length;
-}
-
-size_t buffer_capacity(const buffer_T* buffer) {
-  return buffer->capacity;
-}
-
-size_t buffer_sizeof(void) {
-  return sizeof(buffer_T);
-}
-
-/**
- * Increases the capacity of the buffer if needed to accommodate additional content.
- * This function only handles memory allocation and does not modify the buffer content
- * or null termination.
- *
- * @param buffer The buffer to increase capacity for
- * @param additional_capacity The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
-  if (additional_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  const size_t new_capacity = buffer->capacity + additional_capacity;
-
-  return buffer_resize(buffer, new_capacity);
-}
-
-/**
- * Resizes the capacity of the buffer to the specified new capacity.
- *
- * @param buffer The buffer to resize
- * @param new_capacity The new capacity to resize the buffer to
- * @return true if capacity was resized, false if reallocation failed
- */
-bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
-  if (new_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  char* new_value = nullable_safe_realloc(buffer->value, new_capacity + 1);
-
-  if (unlikely(new_value == NULL)) {
-    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
-    exit(1);
-  }
-
-  buffer->value = new_value;
-  buffer->capacity = new_capacity;
-
-  return true;
-}
-
-/**
- * Expands the capacity of the buffer by doubling its current capacity.
- * This function is a convenience function that calls buffer_increase_capacity
- * with a factor of 2.
- *
- * @param buffer The buffer to expand capacity for
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_expand_capacity(buffer_T* buffer) {
-  return buffer_resize(buffer, buffer->capacity * 2);
-}
-
-/**
- * Expands the capacity of the buffer if needed to accommodate additional content.
- * This function is a convenience function that calls buffer_has_capacity and
- * buffer_expand_capacity.
- *
- * @param buffer The buffer to expand capacity for
- * @param required_length The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
-  if (buffer_has_capacity(buffer, required_length)) { return true; }
-
-  return buffer_resize(buffer, buffer->capacity + (required_length * 2));
-}
-
-/**
- * Appends a null-terminated string to the buffer.
- * @note This function requires that 'text' is a properly null-terminated string.
- * When reading data from files or other non-string sources, ensure the data is
- * null-terminated before calling this function, or use buffer_append_with_length instead.
- *
- * @param buffer The buffer to append to
- * @param text A null-terminated string to append
- * @return void
- */
-void buffer_append(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
-
-  memcpy(buffer->value + buffer->length, text, text_length);
-  buffer->length += text_length;
-  buffer->value[buffer->length] = '\0';
-}
-
-/**
- * Appends a string of specified length to the buffer.
- * Unlike buffer_append(), this function does not require the text to be
- * null-terminated as it uses the provided length instead of strlen().
- * This is particularly useful when working with data from files, network
- * buffers, or other non-null-terminated sources.
- *
- * @param buffer The buffer to append to
- * @param text The text to append (doesn't need to be null-terminated)
- * @param length The number of bytes to append from text
- * @return void
- */
-void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
-  if (!buffer || !text || length == 0) { return; }
-  if (!buffer_expand_if_needed(buffer, length)) { return; }
-
-  memcpy(buffer->value + buffer->length, text, length);
-
-  buffer->length += length;
-  buffer->value[buffer->length] = '\0';
-}
-
-void buffer_append_char(buffer_T* buffer, const char character) {
-  static char string[2];
-
-  string[0] = character;
-  string[1] = '\0';
-
-  buffer_append(buffer, string);
-}
-
-void buffer_append_repeated(buffer_T* buffer, const char character, size_t length) {
-  if (length == 0) { return; }
-
-  char* spaces = malloc(length + 1);
-  if (!spaces) { return; }
-
-  memset(spaces, character, length);
-  spaces[length] = '\0';
-
-  buffer_append(buffer, spaces);
-
-  free(spaces);
-}
-
-void buffer_append_whitespace(buffer_T* buffer, const size_t length) {
-  buffer_append_repeated(buffer, ' ', length);
-}
-
-void buffer_prepend(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
-
-  memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
-  memcpy(buffer->value, text, text_length);
-
-  buffer->length += text_length;
-}
-
-void buffer_concat(buffer_T* destination, buffer_T* source) {
-  if (source->length == 0) { return; }
-  if (!buffer_expand_if_needed(destination, source->length)) { return; }
-
-  memcpy(destination->value + destination->length, source->value, source->length);
-
-  destination->length += source->length;
-  destination->value[destination->length] = '\0';
-}
-
-bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
-  return (buffer->length + required_length <= buffer->capacity);
-}
-
-void buffer_clear(buffer_T* buffer) {
-  buffer->length = 0;
-  buffer->value[0] = '\0';
-}
-
-void buffer_free(buffer_T* buffer) {
-  if (!buffer) { return; }
-
-  if (buffer->value != NULL) { free(buffer->value); }
-
-  buffer->value = NULL;
-  buffer->length = buffer->capacity = 0;
-}
diff --git a/src/extract.c b/src/extract.c
index cc7bedb49..e927632a4 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -1,21 +1,22 @@
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/lexer.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdlib.h>
+#include <string.h>
 
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
   bool skip_erb_content = false;
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
+        hb_buffer_append(output, token->value);
         break;
       }
 
@@ -24,15 +25,15 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
           skip_erb_content = true;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       case TOKEN_ERB_CONTENT: {
         if (skip_erb_content == false) {
-          buffer_append(output, token->value);
+          hb_buffer_append(output, token->value);
         } else {
-          buffer_append_whitespace(output, range_length(token->range));
+          hb_buffer_append_whitespace(output, range_length(token->range));
         }
 
         break;
@@ -41,13 +42,13 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
       case TOKEN_ERB_END: {
         skip_erb_content = false;
 
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
+        hb_buffer_append_char(output, ';');
+        hb_buffer_append_whitespace(output, range_length(token->range) - 1);
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -55,16 +56,16 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
   bool skip_erb_content = false;
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_NEWLINE: {
-        buffer_append(output, token->value);
+        hb_buffer_append(output, token->value);
         break;
       }
 
@@ -73,15 +74,15 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
           skip_erb_content = true;
         }
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       case TOKEN_ERB_CONTENT: {
         if (skip_erb_content == false) {
-          buffer_append(output, token->value);
+          hb_buffer_append(output, token->value);
         } else {
-          buffer_append_whitespace(output, range_length(token->range));
+          hb_buffer_append_whitespace(output, range_length(token->range));
         }
 
         break;
@@ -90,12 +91,12 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
       case TOKEN_ERB_END: {
         skip_erb_content = false;
 
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
         break;
       }
 
       default: {
-        buffer_append_whitespace(output, range_length(token->range));
+        hb_buffer_append_whitespace(output, range_length(token->range));
       }
     }
   }
@@ -103,17 +104,17 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
   herb_free_tokens(&tokens);
 }
 
-void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    const token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
       case TOKEN_ERB_START:
       case TOKEN_ERB_CONTENT:
-      case TOKEN_ERB_END: buffer_append_whitespace(output, range_length(token->range)); break;
-      default: buffer_append(output, token->value);
+      case TOKEN_ERB_END: hb_buffer_append_whitespace(output, range_length(token->range)); break;
+      default: hb_buffer_append(output, token->value);
     }
   }
 
@@ -121,8 +122,10 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
 }
 
 char* herb_extract_ruby_with_semicolons(const char* source) {
-  buffer_T output;
-  buffer_init(&output);
+  if (!source) { return NULL; }
+
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   herb_extract_ruby_to_buffer_with_semicolons(source, &output);
 
@@ -130,8 +133,10 @@ char* herb_extract_ruby_with_semicolons(const char* source) {
 }
 
 char* herb_extract(const char* source, const herb_extract_language_T language) {
-  buffer_T output;
-  buffer_init(&output);
+  if (!source) { return NULL; }
+
+  hb_buffer_T output;
+  hb_buffer_init(&output, strlen(source));
 
   switch (language) {
     case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;
diff --git a/src/herb.c b/src/herb.c
index d057b28a8..a48a56f3a 100644
--- a/src/herb.c
+++ b/src/herb.c
@@ -1,97 +1,85 @@
 #include "include/herb.h"
-#include "include/array.h"
-#include "include/buffer.h"
 #include "include/io.h"
-#include "include/json.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
 #include "include/version.h"
 
 #include <prism.h>
 #include <stdlib.h>
 
-array_T* herb_lex(const char* source) {
-  lexer_T* lexer = lexer_init(source);
+hb_array_T* herb_lex(const char* source) {
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+
   token_T* token = NULL;
-  array_T* tokens = array_init(128);
+  hb_array_T* tokens = hb_array_init(128);
 
-  while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
-    array_append(tokens, token);
+  while ((token = lexer_next_token(&lexer))->type != TOKEN_EOF) {
+    hb_array_append(tokens, token);
   }
 
-  array_append(tokens, token);
-
-  lexer_free(lexer);
+  hb_array_append(tokens, token);
 
   return tokens;
 }
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
-  lexer_T* lexer = lexer_init(source);
-  parser_T* parser = herb_parser_init(lexer, options);
+  if (!source) { source = ""; }
+
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source);
+  parser_T parser = { 0 };
+
+  parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
 
-  AST_DOCUMENT_NODE_T* document = herb_parser_parse(parser);
+  if (options != NULL) { parser_options = *options; }
 
-  parser_free(parser);
+  herb_parser_init(&parser, &lexer, parser_options);
+
+  AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
+
+  herb_parser_deinit(&parser);
 
   return document;
 }
 
-array_T* herb_lex_file(const char* path) {
+hb_array_T* herb_lex_file(const char* path) {
   char* source = herb_read_file(path);
-  array_T* tokens = herb_lex(source);
+  hb_array_T* tokens = herb_lex(source);
 
   free(source);
 
   return tokens;
 }
 
-void herb_lex_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
+  hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+    token_T* token = hb_array_get(tokens, i);
 
     char* type = token_to_string(token);
-    buffer_append(output, type);
+    hb_buffer_append(output, type);
     free(type);
 
-    buffer_append(output, "\n");
-  }
-
-  herb_free_tokens(&tokens);
-}
-
-void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
-  array_T* tokens = herb_lex(source);
-
-  buffer_T json = buffer_new();
-  json_start_root_array(&json);
-
-  for (size_t i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
-    char* token_json = token_to_json(token);
-    json_add_raw_string(&json, token_json);
-    free(token_json);
+    hb_buffer_append(output, "\n");
   }
 
-  json_end_array(&json);
-  buffer_concat(output, &json);
-
-  buffer_free(&json);
   herb_free_tokens(&tokens);
 }
 
-void herb_free_tokens(array_T** tokens) {
+void herb_free_tokens(hb_array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
-  for (size_t i = 0; i < array_size(*tokens); i++) {
-    token_T* token = array_get(*tokens, i);
+  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
+    token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }
 
-  array_free(tokens);
+  hb_array_free(tokens);
 }
 
 const char* herb_version(void) {
diff --git a/src/html_util.c b/src/html_util.c
index b400d0709..4371ee5f9 100644
--- a/src/html_util.c
+++ b/src/html_util.c
@@ -1,76 +1,31 @@
 #include "include/html_util.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
-#include <strings.h>
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-bool is_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
+bool is_void_element(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
 
-  const char* void_tags[] = {
-    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr",
+  hb_string_T void_tags[14] = {
+    hb_string("area"),  hb_string("base"),   hb_string("br"),    hb_string("col"),  hb_string("embed"),
+    hb_string("hr"),    hb_string("img"),    hb_string("input"), hb_string("link"), hb_string("meta"),
+    hb_string("param"), hb_string("source"), hb_string("track"), hb_string("wbr"),
   };
 
-  for (size_t i = 0; i < sizeof(void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, void_tags[i]) == 0) { return true; }
-  }
-
-  return false;
-}
-
-bool is_html4_void_element(const char* tag_name) {
-  if (tag_name == NULL) { return false; }
-
-  const char* html4_void_tags[] = {
-    "basefont", "bgsound", "command", "frame", "image", "keygen",
-  };
-
-  for (size_t i = 0; i < sizeof(html4_void_tags) / sizeof(char*); i++) {
-    if (strcasecmp(tag_name, html4_void_tags[i]) == 0) { return true; }
+  for (size_t i = 0; i < 14; i++) {
+    if (hb_string_equals_case_insensitive(tag_name, void_tags[i])) { return true; }
   }
 
   return false;
 }
 
-/**
- * @brief Creates an opening HTML tag string like "<tag_name>"
- *
- * @param tag_name The name of the HTML tag to be enclosed in a opening tag
- * @return A newly allocated string containing the opening tag, or NULL if memory allocation fails
- * @note The caller is responsible for freeing the returned string
- *
- * Example:
- * @code
- * char* tag = html_opening_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <div>
- *   free(tag);
- * }
- * @endcode
- */
-char* html_opening_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("<>"); }
-
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 3); // +3 for '<', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
-
-  result[length + 1] = '>';
-  result[length + 2] = '\0';
-
-  return result;
-}
-
 /**
  * @brief Creates a closing HTML tag string like "</tag_name>"
  *
@@ -80,30 +35,22 @@ char* html_opening_tag_string(const char* tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_closing_tag_string("div");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: </div>
- *   free(tag);
- * }
+ * hb_string_T tag = html_closing_tag_string(hb_string("div"));
+ *
+ * printf("%.*s\n", tag.length, tag.data); // Prints: </div>
+ * free(tag.data);
  * @endcode
  */
-char* html_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("</>"); }
+hb_string_T html_closing_tag_string(hb_string_T tag_name) {
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, tag_name.length + 3);
 
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 4); // +4 for '<', '/', '>', and '\0'
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append_string(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, '>');
 
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-  result[1] = '/';
-
-  memcpy(result + 2, tag_name, length);
-
-  result[length + 2] = '>';
-  result[length + 3] = '\0';
-
-  return result;
+  return hb_string(buffer.value);
 }
 
 /**
@@ -115,29 +62,20 @@ char* html_closing_tag_string(const char* tag_name) {
  *
  * Example:
  * @code
- * char* tag = html_self_closing_tag_string("br");
- * if (tag) {
- *   printf("%s\n", tag); // Prints: <br />
- *   free(tag);
- * }
+ * hb_string_T tag = html_self_closing_tag_string(hb_string("br"));
+ * printf("%.*s\n", tag.length, tag.data); // Prints: <br />
+ * free(tag);
  * @endcode
  */
-char* html_self_closing_tag_string(const char* tag_name) {
-  if (tag_name == NULL) { return herb_strdup("< />"); }
-
-  size_t length = strlen(tag_name);
-  char* result = (char*) malloc(length + 5); // +5 for '<', ' ', '/', '>', and '\0'
-
-  if (result == NULL) { return NULL; }
-
-  result[0] = '<';
-
-  memcpy(result + 1, tag_name, length);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, tag_name.length + 4);
 
-  result[length + 1] = ' ';
-  result[length + 2] = '/';
-  result[length + 3] = '>';
-  result[length + 4] = '\0';
+  hb_buffer_append_char(&buffer, '<');
+  hb_buffer_append_string(&buffer, tag_name);
+  hb_buffer_append_char(&buffer, ' ');
+  hb_buffer_append_char(&buffer, '/');
+  hb_buffer_append_char(&buffer, '>');
 
-  return result;
+  return hb_string(buffer.value);
 }
diff --git a/src/include/analyze.h b/src/include/analyze.h
index d423856d3..d6f5a1049 100644
--- a/src/include/analyze.h
+++ b/src/include/analyze.h
@@ -2,13 +2,13 @@
 #define HERB_ANALYZE_H
 
 #include "analyzed_ruby.h"
-#include "array.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
-  array_T* ruby_context_stack;
+  hb_array_T* ruby_context_stack;
 } analyze_ruby_context_T;
 
 typedef enum {
diff --git a/src/include/analyzed_ruby.h b/src/include/analyzed_ruby.h
index 67b2aa9a9..fc31037af 100644
--- a/src/include/analyzed_ruby.h
+++ b/src/include/analyzed_ruby.h
@@ -1,7 +1,8 @@
 #ifndef HERB_ANALYZED_RUBY_H
 #define HERB_ANALYZED_RUBY_H
 
-#include "array.h"
+#include "util/hb_array.h"
+#include "util/hb_string.h"
 
 #include <prism.h>
 
@@ -30,7 +31,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_yield_node;
 } analyzed_ruby_T;
 
-analyzed_ruby_T* init_analyzed_ruby(char* source);
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
 
 #endif
diff --git a/src/include/array.h b/src/include/array.h
deleted file mode 100644
index f9715e83f..000000000
--- a/src/include/array.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef HERB_ARRAY_H
-#define HERB_ARRAY_H
-
-#include <stdlib.h>
-
-typedef struct ARRAY_STRUCT {
-  void** items;
-  size_t size;
-  size_t capacity;
-} array_T;
-
-array_T* array_init(size_t capacity);
-
-void* array_get(const array_T* array, size_t index);
-void* array_first(array_T* array);
-void* array_last(array_T* array);
-
-void array_append(array_T* array, void* item);
-void array_set(const array_T* array, size_t index, void* item);
-void array_free(array_T** array);
-void array_remove(array_T* array, size_t index);
-
-size_t array_index_of(array_T* array, void* item);
-void array_remove_item(array_T* array, void* item);
-
-void array_push(array_T* array, void* item);
-void* array_pop(array_T* array);
-
-size_t array_capacity(const array_T* array);
-size_t array_size(const array_T* array);
-size_t array_sizeof(void);
-
-#endif
diff --git a/src/include/ast_node.h b/src/include/ast_node.h
index e41ece34a..144e35334 100644
--- a/src/include/ast_node.h
+++ b/src/include/ast_node.h
@@ -6,7 +6,7 @@
 #include "position.h"
 #include "token_struct.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T* start, position_T* end, array_T* errors);
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, hb_array_T* errors);
 void ast_node_free(AST_NODE_T* node);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
@@ -18,11 +18,11 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
 char* ast_node_name(AST_NODE_T* node);
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position);
-void ast_node_set_end(AST_NODE_T* node, position_T* position);
+void ast_node_set_start(AST_NODE_T* node, position_T position);
+void ast_node_set_end(AST_NODE_T* node, position_T position);
 
 size_t ast_node_errors_count(const AST_NODE_T* node);
-array_T* ast_node_errors(const AST_NODE_T* node);
+hb_array_T* ast_node_errors(const AST_NODE_T* node);
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
diff --git a/src/include/buffer.h b/src/include/buffer.h
deleted file mode 100644
index a684e9ded..000000000
--- a/src/include/buffer.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef HERB_BUFFER_H
-#define HERB_BUFFER_H
-
-#include <stdbool.h>
-#include <stdlib.h>
-
-typedef struct BUFFER_STRUCT {
-  char* value;
-  size_t length;
-  size_t capacity;
-} buffer_T;
-
-bool buffer_init(buffer_T* buffer);
-buffer_T buffer_new(void);
-
-bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
-bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_expand_capacity(buffer_T* buffer);
-bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
-bool buffer_resize(buffer_T* buffer, size_t new_capacity);
-
-void buffer_append(buffer_T* buffer, const char* text);
-void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);
-void buffer_append_char(buffer_T* buffer, char character);
-void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
-void buffer_append_whitespace(buffer_T* buffer, size_t length);
-void buffer_prepend(buffer_T* buffer, const char* text);
-void buffer_concat(buffer_T* destination, buffer_T* source);
-
-char* buffer_value(const buffer_T* buffer);
-
-size_t buffer_length(const buffer_T* buffer);
-size_t buffer_capacity(const buffer_T* buffer);
-size_t buffer_sizeof(void);
-
-void buffer_clear(buffer_T* buffer);
-void buffer_free(buffer_T* buffer);
-
-#endif
diff --git a/src/include/extract.h b/src/include/extract.h
index 668f821a3..2f1704dcc 100644
--- a/src/include/extract.h
+++ b/src/include/extract.h
@@ -1,18 +1,18 @@
 #ifndef HERB_EXTRACT_H
 #define HERB_EXTRACT_H
 
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
   HERB_EXTRACT_LANGUAGE_RUBY,
   HERB_EXTRACT_LANGUAGE_HTML,
 } herb_extract_language_T;
 
-void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
-void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output);
 
 char* herb_extract_ruby_with_semicolons(const char* source);
-void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, hb_buffer_T* output);
 
 char* herb_extract(const char* source, herb_extract_language_T language);
 char* herb_extract_from_file(const char* path, herb_extract_language_T language);
diff --git a/src/include/herb.h b/src/include/herb.h
index d4ec2c7c6..207053e45 100644
--- a/src/include/herb.h
+++ b/src/include/herb.h
@@ -1,11 +1,11 @@
 #ifndef HERB_H
 #define HERB_H
 
-#include "array.h"
 #include "ast_node.h"
-#include "buffer.h"
 #include "extract.h"
 #include "parser.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 #include <stdint.h>
 
@@ -13,18 +13,17 @@
 extern "C" {
 #endif
 
-void herb_lex_to_buffer(const char* source, buffer_T* output);
-void herb_lex_json_to_buffer(const char* source, buffer_T* output);
+void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
 
-array_T* herb_lex(const char* source);
-array_T* herb_lex_file(const char* path);
+hb_array_T* herb_lex(const char* source);
+hb_array_T* herb_lex_file(const char* path);
 
 AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
 
 const char* herb_version(void);
 const char* herb_prism_version(void);
 
-void herb_free_tokens(array_T** tokens);
+void herb_free_tokens(hb_array_T** tokens);
 
 #ifdef __cplusplus
 }
diff --git a/src/include/html_util.h b/src/include/html_util.h
index 8412c9490..51dbaf71a 100644
--- a/src/include/html_util.h
+++ b/src/include/html_util.h
@@ -1,13 +1,12 @@
 #ifndef HERB_HTML_UTIL_H
 #define HERB_HTML_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 
-bool is_void_element(const char* tag_name);
-bool is_html4_void_element(const char* tag_name);
+bool is_void_element(hb_string_T tag_name);
 
-char* html_opening_tag_string(const char* tag_name);
-char* html_closing_tag_string(const char* tag_name);
-char* html_self_closing_tag_string(const char* tag_name);
+hb_string_T html_closing_tag_string(hb_string_T tag_name);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name);
 
 #endif
diff --git a/src/include/json.h b/src/include/json.h
deleted file mode 100644
index b48428c3a..000000000
--- a/src/include/json.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef HERB_JSON_H
-#define HERB_JSON_H
-
-#include "buffer.h"
-
-void json_start_root_object(buffer_T* json);
-void json_start_root_array(buffer_T* json);
-
-void json_escape_string(buffer_T* json, const char* string);
-
-void json_add_string(buffer_T* json, const char* key, const char* value);
-void json_add_int(buffer_T* json, const char* key, int value);
-void json_add_size_t(buffer_T* json, const char* key, size_t value);
-void json_add_double(buffer_T* json, const char* key, double value);
-void json_add_bool(buffer_T* json, const char* key, int value);
-
-void json_add_raw_string(buffer_T* json, const char* string);
-
-void json_start_object(buffer_T* json, const char* key);
-void json_end_object(buffer_T* json);
-
-void json_start_array(buffer_T* json, const char* key);
-void json_end_array(buffer_T* json);
-
-void json_double_to_string(double value, char* buffer);
-void json_int_to_string(int value, char* buffer);
-
-#endif
diff --git a/src/include/lexer.h b/src/include/lexer.h
index 01ac0551f..142f3fb1c 100644
--- a/src/include/lexer.h
+++ b/src/include/lexer.h
@@ -4,10 +4,8 @@
 #include "lexer_struct.h"
 #include "token_struct.h"
 
-lexer_T* lexer_init(const char* source);
+void lexer_init(lexer_T* lexer, const char* source);
 token_T* lexer_next_token(lexer_T* lexer);
 token_T* lexer_error(lexer_T* lexer, const char* message);
 
-void lexer_free(lexer_T* lexer);
-
 #endif
diff --git a/src/include/lexer_peek_helpers.h b/src/include/lexer_peek_helpers.h
index ae78bee03..9cc7e94c9 100644
--- a/src/include/lexer_peek_helpers.h
+++ b/src/include/lexer_peek_helpers.h
@@ -5,38 +5,40 @@
 #include "token_struct.h"
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 typedef struct {
-  size_t position;
-  size_t line;
-  size_t column;
-  size_t previous_position;
-  size_t previous_line;
-  size_t previous_column;
+  uint32_t position;
+  uint32_t line;
+  uint32_t column;
+  uint32_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
   char current_character;
   lexer_state_T state;
 } lexer_state_snapshot_T;
 
-char lexer_peek(const lexer_T* lexer, int offset);
-bool lexer_peek_for_doctype(const lexer_T* lexer, int offset);
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, int offset);
+char lexer_peek(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, int offset);
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset);
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
-bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset);
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset);
 
-char lexer_backtrack(const lexer_T* lexer, int offset);
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset);
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type);
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, int offset);
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset);
 
 lexer_state_snapshot_T lexer_save_state(lexer_T* lexer);
 void lexer_restore_state(lexer_T* lexer, lexer_state_snapshot_T snapshot);
diff --git a/src/include/lexer_struct.h b/src/include/lexer_struct.h
index 709233884..94b132559 100644
--- a/src/include/lexer_struct.h
+++ b/src/include/lexer_struct.h
@@ -1,7 +1,10 @@
 #ifndef HERB_LEXER_STRUCT_H
 #define HERB_LEXER_STRUCT_H
 
+#include "util/hb_string.h"
+
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef enum {
@@ -11,21 +14,20 @@ typedef enum {
 } lexer_state_T;
 
 typedef struct LEXER_STRUCT {
-  const char* source;
-  size_t source_length;
+  hb_string_T source;
 
-  size_t current_line;
-  size_t current_column;
-  size_t current_position;
+  uint32_t current_line;
+  uint32_t current_column;
+  uint32_t current_position;
 
-  size_t previous_line;
-  size_t previous_column;
-  size_t previous_position;
+  uint32_t previous_line;
+  uint32_t previous_column;
+  uint32_t previous_position;
 
   char current_character;
   lexer_state_T state;
-  size_t stall_counter;
-  size_t last_position;
+  uint32_t stall_counter;
+  uint32_t last_position;
   bool stalled;
 } lexer_T;
 
diff --git a/src/include/location.h b/src/include/location.h
index ef07ba688..d01c94aa9 100644
--- a/src/include/location.h
+++ b/src/include/location.h
@@ -1,25 +1,22 @@
 #ifndef HERB_LOCATION_H
 #define HERB_LOCATION_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 #include "position.h"
 
 typedef struct LOCATION_STRUCT {
-  position_T* start;
-  position_T* end;
+  position_T start;
+  position_T end;
 } location_T;
 
-location_T* location_init(position_T* start, position_T* end);
-location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column);
-
-position_T* location_start(location_T* location);
-position_T* location_end_(location_T* location);
-
-size_t location_sizeof(void);
-
-location_T* location_copy(location_T* location);
-
-void location_free(location_T* location);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+);
 
 #endif
diff --git a/src/include/memory.h b/src/include/memory.h
deleted file mode 100644
index b6f942e82..000000000
--- a/src/include/memory.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef HERB_MEMORY_H
-#define HERB_MEMORY_H
-
-#include <stddef.h>
-
-void* safe_malloc(size_t size);
-void* safe_realloc(void* pointer, size_t new_size);
-
-void* nullable_safe_malloc(size_t size);
-void* nullable_safe_realloc(void* pointer, size_t new_size);
-
-#endif
diff --git a/src/include/parser.h b/src/include/parser.h
index 138c53594..4eb92f3fb 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -1,9 +1,9 @@
 #ifndef HERB_PARSER_H
 #define HERB_PARSER_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_array.h"
 
 typedef enum {
   FOREIGN_CONTENT_UNKNOWN = 0,
@@ -19,21 +19,23 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
 } parser_options_T;
 
+extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+
 typedef struct PARSER_STRUCT {
   lexer_T* lexer;
   token_T* current_token;
-  array_T* open_tags_stack;
+  hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
-  parser_options_T* options;
+  parser_options_T options;
 } parser_T;
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options);
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options);
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
 size_t parser_sizeof(void);
 
-void parser_free(parser_T* parser);
+void herb_parser_deinit(parser_T* parser);
 
 #endif
diff --git a/src/include/parser_helpers.h b/src/include/parser_helpers.h
index aff4ac8ae..b3ab98300 100644
--- a/src/include/parser_helpers.h
+++ b/src/include/parser_helpers.h
@@ -1,47 +1,57 @@
 #ifndef HERB_PARSER_HELPERS_H
 #define HERB_PARSER_HELPERS_H
 
-#include "array.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "errors.h"
 #include "parser.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
-  position_T* start
+  hb_buffer_T* buffer,
+  hb_array_T* children,
+  position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name);
-bool parser_is_foreign_content_tag(const char* tag_name);
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
+bool parser_is_foreign_content_tag(hb_string_T tag_name);
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
 void parser_exit_foreign_content(parser_T* parser);
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type);
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
-token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
+);
+void parser_handle_mismatched_tags(
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  hb_array_T* errors
 );
-void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 
 #endif
diff --git a/src/include/position.h b/src/include/position.h
index 95e64044b..8fad03d5f 100644
--- a/src/include/position.h
+++ b/src/include/position.h
@@ -1,22 +1,11 @@
 #ifndef HERB_POSITION_H
 #define HERB_POSITION_H
 
-#include <stdlib.h>
+#include <stdint.h>
 
 typedef struct POSITION_STRUCT {
-  size_t line;
-  size_t column;
+  uint32_t line;
+  uint32_t column;
 } position_T;
 
-position_T* position_init(size_t line, size_t column);
-
-size_t position_line(const position_T* position);
-size_t position_column(const position_T* position);
-
-size_t position_sizeof(void);
-
-position_T* position_copy(position_T* position);
-
-void position_free(position_T* position);
-
 #endif
diff --git a/src/include/pretty_print.h b/src/include/pretty_print.h
index 610bc3f73..d7921a8c0 100644
--- a/src/include/pretty_print.h
+++ b/src/include/pretty_print.h
@@ -3,14 +3,20 @@
 
 #include "analyzed_ruby.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "location.h"
+#include "util/hb_buffer.h"
 
 #include <stdbool.h>
 
-void pretty_print_indent(buffer_T* buffer, size_t indent);
-void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
-void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
+void pretty_print_label(
+  const char* name,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 void pretty_print_position_property(
   position_T* position,
@@ -18,10 +24,10 @@ void pretty_print_position_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_location(location_T* location, buffer_T* buffer);
+void pretty_print_location(location_T location, hb_buffer_T* buffer);
 
 void pretty_print_property(
   const char* name,
@@ -29,7 +35,7 @@ void pretty_print_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_size_t_property(
@@ -38,7 +44,7 @@ void pretty_print_size_t_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_string_property(
@@ -47,7 +53,7 @@ void pretty_print_string_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_quoted_property(
@@ -56,7 +62,7 @@ void pretty_print_quoted_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_boolean_property(
@@ -65,7 +71,7 @@ void pretty_print_boolean_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_token_property(
@@ -74,20 +80,24 @@ void pretty_print_token_property(
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 void pretty_print_array(
   const char* name,
-  array_T* array,
+  hb_array_T* array,
   size_t indent,
   size_t relative_indent,
   bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
-void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source);
+void pretty_print_errors(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  bool last_property,
+  hb_buffer_T* buffer
+);
 
 #endif
diff --git a/src/include/prism_helpers.h b/src/include/prism_helpers.h
index 66438c342..ebfb53b4f 100644
--- a/src/include/prism_helpers.h
+++ b/src/include/prism_helpers.h
@@ -16,6 +16,6 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser
 );
 
-position_T* position_from_source_with_offset(const char* source, size_t offset);
+position_T position_from_source_with_offset(const char* source, size_t offset);
 
 #endif
diff --git a/src/include/range.h b/src/include/range.h
index c5c28f8bb..019b1962b 100644
--- a/src/include/range.h
+++ b/src/include/range.h
@@ -1,23 +1,14 @@
 #ifndef HERB_RANGE_H
 #define HERB_RANGE_H
 
+#include <stdint.h>
 #include <stdlib.h>
 
 typedef struct RANGE_STRUCT {
-  size_t from;
-  size_t to;
+  uint32_t from;
+  uint32_t to;
 } range_T;
 
-range_T* range_init(size_t from, size_t to);
-
-size_t range_from(const range_T* range);
-size_t range_to(const range_T* range);
-size_t range_length(range_T* range);
-
-range_T* range_copy(range_T* range);
-
-size_t range_sizeof(void);
-
-void range_free(range_T* range);
+uint32_t range_length(range_T range);
 
 #endif
diff --git a/src/include/token.h b/src/include/token.h
index 6930439e9..5628e2f0d 100644
--- a/src/include/token.h
+++ b/src/include/token.h
@@ -7,15 +7,11 @@
 
 token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
 char* token_to_string(const token_T* token);
-char* token_to_json(const token_T* token);
 const char* token_type_to_string(token_type_T type);
 
 char* token_value(const token_T* token);
 int token_type(const token_T* token);
 
-position_T* token_start_position(token_T* token);
-position_T* token_end_position(token_T* token);
-
 size_t token_sizeof(void);
 
 token_T* token_copy(token_T* token);
diff --git a/src/include/token_struct.h b/src/include/token_struct.h
index e5192165b..2727d2a4c 100644
--- a/src/include/token_struct.h
+++ b/src/include/token_struct.h
@@ -50,8 +50,8 @@ typedef enum {
 
 typedef struct TOKEN_STRUCT {
   char* value;
-  range_T* range;
-  location_T* location;
+  range_T range;
+  location_T location;
   token_type_T type;
 } token_T;
 
diff --git a/src/include/util.h b/src/include/util.h
index 18df10360..978abeb92 100644
--- a/src/include/util.h
+++ b/src/include/util.h
@@ -1,25 +1,14 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
-int is_whitespace(int character);
 int is_newline(int character);
 
-int count_in_string(const char* string, char character);
-int count_newlines(const char* string);
-
-char* replace_char(char* string, char find, char replace);
 char* escape_newlines(const char* input);
-char* quoted_string(const char* input);
-char* wrap_string(const char* input, char character);
-
-bool string_blank(const char* input);
-bool string_present(const char* input);
-
+hb_string_T quoted_string(hb_string_T input);
 char* herb_strdup(const char* s);
 
-char* size_t_to_string(size_t value);
-
 #endif
diff --git a/src/include/util/hb_arena.h b/src/include/util/hb_arena.h
new file mode 100644
index 000000000..f58df0a21
--- /dev/null
+++ b/src/include/util/hb_arena.h
@@ -0,0 +1,20 @@
+#ifndef HERB_ARENA_H
+#define HERB_ARENA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct HB_ARENA_ALLOCATOR_STRUCT {
+  char* memory;
+  size_t capacity;
+  size_t position;
+} hb_arena_T;
+
+bool hb_arena_init(hb_arena_T* allocator, size_t size);
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
+size_t hb_arena_position(hb_arena_T* allocator);
+void hb_arena_reset(hb_arena_T* allocator);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_free(hb_arena_T* allocator);
+
+#endif
diff --git a/src/include/util/hb_array.h b/src/include/util/hb_array.h
new file mode 100644
index 000000000..ccc3b043a
--- /dev/null
+++ b/src/include/util/hb_array.h
@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct HB_ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} hb_array_T;
+
+hb_array_T* hb_array_init(size_t capacity);
+
+void* hb_array_get(const hb_array_T* array, size_t index);
+void* hb_array_first(hb_array_T* array);
+void* hb_array_last(hb_array_T* array);
+
+void hb_array_append(hb_array_T* array, void* item);
+void hb_array_set(const hb_array_T* array, size_t index, void* item);
+void hb_array_free(hb_array_T** array);
+void hb_array_remove(hb_array_T* array, size_t index);
+
+size_t hb_array_index_of(hb_array_T* array, void* item);
+void hb_array_remove_item(hb_array_T* array, void* item);
+
+void hb_array_push(hb_array_T* array, void* item);
+void* hb_array_pop(hb_array_T* array);
+
+size_t hb_array_capacity(const hb_array_T* array);
+size_t hb_array_size(const hb_array_T* array);
+size_t hb_array_sizeof(void);
+
+#endif
diff --git a/src/include/util/hb_buffer.h b/src/include/util/hb_buffer.h
new file mode 100644
index 000000000..d9395009f
--- /dev/null
+++ b/src/include/util/hb_buffer.h
@@ -0,0 +1,34 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include "hb_string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HB_BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} hb_buffer_T;
+
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+
+void hb_buffer_append(hb_buffer_T* buffer, const char* text);
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string);
+void hb_buffer_append_char(hb_buffer_T* buffer, char character);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
+
+char* hb_buffer_value(const hb_buffer_T* buffer);
+
+size_t hb_buffer_length(const hb_buffer_T* buffer);
+size_t hb_buffer_capacity(const hb_buffer_T* buffer);
+size_t hb_buffer_sizeof(void);
+
+void hb_buffer_clear(hb_buffer_T* buffer);
+void hb_buffer_free(hb_buffer_T** buffer);
+
+#endif
diff --git a/src/include/util/hb_string.h b/src/include/util/hb_string.h
new file mode 100644
index 000000000..a0b90a5a7
--- /dev/null
+++ b/src/include/util/hb_string.h
@@ -0,0 +1,24 @@
+#ifndef HERB_STRING_H
+#define HERB_STRING_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hb_arena.h"
+
+typedef struct HB_STRING_STRUCT {
+  char* data;
+  uint32_t length;
+} hb_string_T;
+
+hb_string_T hb_string(const char* null_terminated_c_string);
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
+bool hb_string_equals(hb_string_T a, hb_string_T b);
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
+bool hb_string_is_empty(hb_string_T string);
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
+
+#endif
diff --git a/src/include/version.h b/src/include/version.h
index 4185a598a..a75f8cba0 100644
--- a/src/include/version.h
+++ b/src/include/version.h
@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.4"
+#define HERB_VERSION "0.7.5"
 
 #endif
diff --git a/src/include/visitor.h b/src/include/visitor.h
index 01d5c9e44..bc6a6414f 100644
--- a/src/include/visitor.h
+++ b/src/include/visitor.h
@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);
diff --git a/src/io.c b/src/io.c
index a1ef45632..1c6e68f6d 100644
--- a/src/io.c
+++ b/src/io.c
@@ -1,5 +1,5 @@
 #include "include/io.h"
-#include "include/buffer.h"
+#include "include/util/hb_buffer.h"
 
 #include <errno.h>
 #include <stdio.h>
@@ -8,6 +8,8 @@
 #define FILE_READ_CHUNK 4096
 
 char* herb_read_file(const char* filename) {
+  if (!filename) { return NULL; }
+
   FILE* fp = fopen(filename, "rb");
 
   if (fp == NULL) {
@@ -15,16 +17,17 @@ char* herb_read_file(const char* filename) {
     exit(1);
   }
 
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 4096);
 
   char chunk[FILE_READ_CHUNK];
   size_t bytes_read;
 
   while ((bytes_read = fread(chunk, 1, FILE_READ_CHUNK, fp)) > 0) {
-    buffer_append_with_length(&buffer, chunk, bytes_read);
+    hb_buffer_append_with_length(&buffer, chunk, bytes_read);
   }
 
   fclose(fp);
 
-  return buffer_value(&buffer);
+  return hb_buffer_value(&buffer);
 }
diff --git a/src/json.c b/src/json.c
deleted file mode 100644
index a1bc80662..000000000
--- a/src/json.c
+++ /dev/null
@@ -1,205 +0,0 @@
-#include "include/json.h"
-#include "include/buffer.h"
-
-void json_escape_string(buffer_T* json, const char* string) {
-  if (!string) {
-    buffer_append(json, "null");
-    return;
-  }
-
-  buffer_append(json, "\"");
-
-  while (*string) {
-    switch (*string) {
-      case '\"': buffer_append(json, "\\\""); break;
-      case '\\': buffer_append(json, "\\\\"); break;
-      case '\n': buffer_append(json, "\\n"); break;
-      case '\t': buffer_append(json, "\\t"); break;
-      default: buffer_append_char(json, *string); break;
-    }
-    string++;
-  }
-
-  buffer_append(json, "\"");
-}
-
-void json_int_to_string(const int value, char* buffer) {
-  char string[20]; // Enough to hold all possible int values
-  int i = 0;
-
-  // Handle negative numbers
-  unsigned int abs_value = (unsigned int) abs(value);
-
-  do {
-    string[i++] = (char) ((abs_value % 10) + '0');
-    abs_value /= 10;
-  } while (abs_value > 0);
-
-  if (value < 0) { string[i++] = '-'; }
-
-  int j = 0;
-
-  while (i > 0) {
-    buffer[j++] = string[--i];
-  }
-
-  buffer[j] = '\0';
-}
-
-void json_double_to_string(const double value, char* buffer) {
-  const int int_part = (int) value;
-  const double frac_part = value - (double) int_part;
-  const int frac_as_int = (int) (frac_part * 100); // Keep 2 decimal places
-
-  char int_buffer[20];
-  char frac_buffer[5];
-
-  json_int_to_string(int_part, int_buffer);
-  json_int_to_string(frac_as_int < 0 ? -frac_as_int : frac_as_int, frac_buffer);
-
-  char* pointer = buffer;
-  for (const char* source = int_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer++ = '.';
-
-  for (const char* source = frac_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer = '\0';
-}
-
-void json_add_string(buffer_T* json, const char* key, const char* value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  json_escape_string(json, value);
-}
-
-void json_add_double(buffer_T* json, const char* key, const double value) {
-  if (!json) { return; }
-
-  char number[32];
-  json_double_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-}
-
-void json_add_int(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  char number[20];
-  json_int_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_size_t(buffer_T* json, const char* key, size_t value) {
-  if (!json) { return; }
-
-  char number[32];
-  char temp[32];
-  int i = 0;
-
-  do {
-    temp[i++] = (char) ((value % 10) + '0');
-    value /= 10;
-  } while (value > 0);
-
-  int j = 0;
-  while (i > 0) {
-    number[j++] = temp[--i];
-  }
-  number[j] = '\0';
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_bool(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, value ? "true" : "false");
-}
-
-void json_add_raw_string(buffer_T* json, const char* string) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  buffer_append(json, string);
-}
-
-void json_start_root_object(buffer_T* json) {
-  if (json) { buffer_append(json, "{"); }
-}
-
-void json_start_object(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, "{");
-}
-
-void json_end_object(buffer_T* json) {
-  if (json) { buffer_append(json, "}"); }
-}
-
-void json_start_root_array(buffer_T* json) {
-  if (json) { buffer_append(json, "["); }
-}
-
-void json_start_array(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-  json_escape_string(json, key);
-  buffer_append(json, ": [");
-}
-
-void json_end_array(buffer_T* json) {
-  if (json) { buffer_append(json, "]"); }
-}
diff --git a/src/lexer.c b/src/lexer.c
index 6e91e180c..45995751c 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -1,24 +1,21 @@
-#include "include/buffer.h"
 #include "include/lexer_peek_helpers.h"
 #include "include/token.h"
 #include "include/utf8.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <string.h>
 
 #define LEXER_STALL_LIMIT 5
 
-static size_t lexer_sizeof(void) {
-  return sizeof(struct LEXER_STRUCT);
-}
-
 static bool lexer_eof(const lexer_T* lexer) {
   return lexer->current_character == '\0' || lexer->stalled;
 }
 
 static bool lexer_has_more_characters(const lexer_T* lexer) {
-  return lexer->current_position < lexer->source_length;
+  return lexer->current_position < lexer->source.length;
 }
 
 static bool lexer_stalled(lexer_T* lexer) {
@@ -34,17 +31,16 @@ static bool lexer_stalled(lexer_T* lexer) {
   return lexer->stalled;
 }
 
-lexer_T* lexer_init(const char* source) {
-  if (source == NULL) { source = ""; }
-
-  lexer_T* lexer = calloc(1, lexer_sizeof());
+void lexer_init(lexer_T* lexer, const char* source) {
+  if (source != NULL) {
+    lexer->source = hb_string(source);
+  } else {
+    lexer->source = hb_string("");
+  }
 
+  lexer->current_character = lexer->source.data[0];
   lexer->state = STATE_DATA;
 
-  lexer->source = source;
-  lexer->source_length = strlen(source);
-  lexer->current_character = source[0];
-
   lexer->current_line = 1;
   lexer->current_column = 0;
   lexer->current_position = 0;
@@ -56,8 +52,6 @@ lexer_T* lexer_init(const char* source) {
   lexer->stall_counter = 0;
   lexer->last_position = 0;
   lexer->stalled = false;
-
-  return lexer;
 }
 
 token_T* lexer_error(lexer_T* lexer, const char* message) {
@@ -66,7 +60,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
   snprintf(
     error_message,
     sizeof(error_message),
-    "[Lexer] Error: %s (character '%c', line %zu, col %zu)\n",
+    "[Lexer] Error: %s (character '%c', line %u, col %u)\n",
     message,
     lexer->current_character,
     lexer->current_line,
@@ -81,7 +75,7 @@ static void lexer_advance(lexer_T* lexer) {
     if (!is_newline(lexer->current_character)) { lexer->current_column++; }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 }
 
@@ -93,11 +87,11 @@ static void lexer_advance_utf8_bytes(lexer_T* lexer, int byte_count) {
 
     lexer->current_position += byte_count;
 
-    if (lexer->current_position >= lexer->source_length) {
-      lexer->current_position = lexer->source_length;
+    if (lexer->current_position >= lexer->source.length) {
+      lexer->current_position = lexer->source.length;
       lexer->current_character = '\0';
     } else {
-      lexer->current_character = lexer->source[lexer->current_position];
+      lexer->current_character = lexer->source.data[lexer->current_position];
     }
   }
 }
@@ -135,7 +129,7 @@ static token_T* lexer_advance_current(lexer_T* lexer, const token_type_T type) {
 }
 
 static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T type) {
-  int char_byte_length = utf8_sequence_length(lexer->source, lexer->current_position, lexer->source_length);
+  int char_byte_length = utf8_sequence_length(lexer->source.data, lexer->current_position, lexer->source.length);
 
   if (char_byte_length <= 1) { return lexer_advance_current(lexer, type); }
 
@@ -144,12 +138,12 @@ static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T
   if (!utf8_char) { return lexer_advance_current(lexer, type); }
 
   for (int i = 0; i < char_byte_length; i++) {
-    if (lexer->current_position + i >= lexer->source_length) {
+    if (lexer->current_position + i >= lexer->source.length) {
       free(utf8_char);
       return lexer_advance_current(lexer, type);
     }
 
-    utf8_char[i] = lexer->source[lexer->current_position + i];
+    utf8_char[i] = lexer->source.data[lexer->current_position + i];
   }
 
   utf8_char[char_byte_length] = '\0';
@@ -164,7 +158,7 @@ static token_T* lexer_advance_utf8_character(lexer_T* lexer, const token_type_T
 }
 
 static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const token_type_T type) {
-  if (strncmp(lexer->source + lexer->current_position, value, strlen(value)) == 0) {
+  if (strncmp(lexer->source.data + lexer->current_position, value, strlen(value)) == 0) {
     return lexer_advance_with(lexer, value, type);
   }
 
@@ -174,35 +168,37 @@ static token_T* lexer_match_and_advance(lexer_T* lexer, const char* value, const
 // ===== Specialized Parsers
 
 static token_T* lexer_parse_whitespace(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
 
   while (isspace(lexer->current_character) && lexer->current_character != '\n' && lexer->current_character != '\r'
          && !lexer_eof(lexer)) {
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
   token_T* token = token_init(buffer.value, TOKEN_WHITESPACE, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
 
 static token_T* lexer_parse_identifier(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
 
   while ((isalnum(lexer->current_character) || lexer->current_character == '-' || lexer->current_character == '_'
           || lexer->current_character == ':')
          && !lexer_peek_for_html_comment_end(lexer, 0) && !lexer_eof(lexer)) {
 
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
     lexer_advance(lexer);
   }
 
   token_T* token = token_init(buffer.value, TOKEN_IDENTIFIER, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
@@ -223,14 +219,19 @@ static token_T* lexer_parse_erb_open(lexer_T* lexer) {
 }
 
 static token_T* lexer_parse_erb_content(lexer_T* lexer) {
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
 
   while (!lexer_peek_erb_end(lexer, 0)) {
     if (lexer_eof(lexer)) {
-      return token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
+      token_T* token = token_init(buffer.value, TOKEN_ERROR, lexer); // Handle unexpected EOF
+
+      free(buffer.value);
+
+      return token;
     }
 
-    buffer_append_char(&buffer, lexer->current_character);
+    hb_buffer_append_char(&buffer, lexer->current_character);
 
     if (is_newline(lexer->current_character)) {
       lexer->current_line++;
@@ -240,14 +241,14 @@ static token_T* lexer_parse_erb_content(lexer_T* lexer) {
     }
 
     lexer->current_position++;
-    lexer->current_character = lexer->source[lexer->current_position];
+    lexer->current_character = lexer->source.data[lexer->current_position];
   }
 
   lexer->state = STATE_ERB_CLOSE;
 
   token_T* token = token_init(buffer.value, TOKEN_ERB_CONTENT, lexer);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return token;
 }
@@ -256,6 +257,7 @@ static token_T* lexer_parse_erb_close(lexer_T* lexer) {
   lexer->state = STATE_DATA;
 
   if (lexer_peek_erb_percent_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "%%>", TOKEN_ERB_END); }
+  if (lexer_peek_erb_equals_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "=%>", TOKEN_ERB_END); }
   if (lexer_peek_erb_dash_close_tag(lexer, 0)) { return lexer_advance_with(lexer, "-%>", TOKEN_ERB_END); }
 
   return lexer_advance_with(lexer, "%>", TOKEN_ERB_END);
@@ -353,9 +355,3 @@ token_T* lexer_next_token(lexer_T* lexer) {
     }
   }
 }
-
-void lexer_free(lexer_T* lexer) {
-  if (lexer == NULL) { return; }
-
-  free(lexer);
-}
diff --git a/src/lexer_peek_helpers.c b/src/lexer_peek_helpers.c
index ca045ba31..86cbfe72a 100644
--- a/src/lexer_peek_helpers.c
+++ b/src/lexer_peek_helpers.c
@@ -3,80 +3,83 @@
 #include "include/lexer_struct.h"
 #include "include/macros.h"
 #include "include/token.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdbool.h>
 
-char lexer_backtrack(const lexer_T* lexer, const int offset) {
-  return lexer->source[MAX(lexer->current_position - offset, 0)];
+char lexer_backtrack(const lexer_T* lexer, uint32_t offset) {
+  return lexer->source.data[MAX(lexer->current_position - offset, 0)];
 }
 
-char lexer_peek(const lexer_T* lexer, const int offset) {
-  return lexer->source[MIN(lexer->current_position + offset, lexer->source_length)];
+char lexer_peek(const lexer_T* lexer, uint32_t offset) {
+  return lexer->source.data[MIN(lexer->current_position + offset, lexer->source.length)];
 }
 
-bool lexer_peek_for(const lexer_T* lexer, const int offset, const char* pattern, const bool case_insensitive) {
-  for (int index = 0; pattern[index]; index++) {
-    const char character = lexer_peek(lexer, offset + index);
+bool lexer_peek_for(const lexer_T* lexer, uint32_t offset, hb_string_T pattern, const bool case_insensitive) {
+  hb_string_T remaining_source = hb_string_slice(lexer->source, lexer->current_position + offset);
+  remaining_source.length = MIN(pattern.length, remaining_source.length);
 
-    if (case_insensitive) {
-      if (tolower(character) != tolower(pattern[index])) { return false; }
-    } else {
-      if (character != pattern[index]) { return false; }
-    }
+  if (case_insensitive) {
+    return hb_string_equals_case_insensitive(remaining_source, pattern);
+  } else {
+    return hb_string_equals(remaining_source, pattern);
   }
+}
 
-  return true;
+bool lexer_peek_for_doctype(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<!DOCTYPE"), true);
 }
 
-bool lexer_peek_for_doctype(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!DOCTYPE", true);
+bool lexer_peek_for_xml_declaration(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<?xml"), true);
 }
 
-bool lexer_peek_for_xml_declaration(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<?xml", true);
+bool lexer_peek_for_cdata_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<![CDATA["), false);
 }
 
-bool lexer_peek_for_cdata_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<![CDATA[", false);
+bool lexer_peek_for_cdata_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("]]>"), false);
 }
 
-bool lexer_peek_for_cdata_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "]]>", false);
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("<!--"), false);
 }
 
-bool lexer_peek_for_html_comment_start(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "<!--", false);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("-->"), false);
 }
 
-bool lexer_peek_for_html_comment_end(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-->", false);
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("%>"), false);
 }
 
-bool lexer_peek_erb_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%>", false);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("-%>"), false);
 }
 
-bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "-%>", false);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("%%>"), false);
 }
 
-bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, const int offset) {
-  return lexer_peek_for(lexer, offset, "%%>", false);
+bool lexer_peek_erb_equals_close_tag(const lexer_T* lexer, uint32_t offset) {
+  return lexer_peek_for(lexer, offset, hb_string("=%>"), false);
 }
 
-bool lexer_peek_erb_end(const lexer_T* lexer, const int offset) {
+bool lexer_peek_erb_end(const lexer_T* lexer, uint32_t offset) {
   return (
     lexer_peek_erb_close_tag(lexer, offset) || lexer_peek_erb_dash_close_tag(lexer, offset)
-    || lexer_peek_erb_percent_close_tag(lexer, offset)
+    || lexer_peek_erb_percent_close_tag(lexer, offset) || lexer_peek_erb_equals_close_tag(lexer, offset)
   );
 }
 
 bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T token_type) {
-  size_t saved_position = lexer->current_position;
-  size_t saved_line = lexer->current_line;
-  size_t saved_column = lexer->current_column;
+  uint32_t saved_position = lexer->current_position;
+  uint32_t saved_line = lexer->current_line;
+  uint32_t saved_column = lexer->current_column;
   char saved_character = lexer->current_character;
+  lexer_state_T saved_state = lexer->state;
 
   token_T* token = lexer_next_token(lexer);
 
@@ -93,11 +96,12 @@ bool lexer_peek_for_token_type_after_whitespace(lexer_T* lexer, token_type_T tok
   lexer->current_line = saved_line;
   lexer->current_column = saved_column;
   lexer->current_character = saved_character;
+  lexer->state = saved_state;
 
   return result;
 }
 
-bool lexer_peek_for_close_tag_start(const lexer_T* lexer, const int offset) {
+bool lexer_peek_for_close_tag_start(const lexer_T* lexer, uint32_t offset) {
   if (lexer_peek(lexer, offset) != '<' || lexer_peek(lexer, offset + 1) != '/') { return false; }
 
   int pos = offset + 2;
diff --git a/src/location.c b/src/location.c
index 1c83c5e49..aec168d3c 100644
--- a/src/location.c
+++ b/src/location.c
@@ -1,41 +1,13 @@
 #include "include/location.h"
-#include "include/memory.h"
 #include "include/position.h"
 
-size_t location_sizeof(void) {
-  return sizeof(location_T);
-}
-
-location_T* location_init(position_T* start, position_T* end) {
-  location_T* location = safe_malloc(location_sizeof());
-
-  location->start = start;
-  location->end = end;
-
-  return location;
-}
-
-location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column) {
-  return location_init(position_init(start_line, start_column), position_init(end_line, end_column));
-}
-
-position_T* location_start(location_T* location) {
-  return location->start;
-}
-
-position_T* location_end(location_T* location) {
-  return location->end;
-}
-
-location_T* location_copy(location_T* location) {
-  if (location == NULL) { return NULL; }
-
-  return location_init(position_copy(location->start), position_copy(location->end));
-}
-
-void location_free(location_T* location) {
-  if (location->start != NULL) { position_free(location->start); }
-  if (location->end != NULL) { position_free(location->end); }
-
-  free(location);
+void location_from(
+  location_T* location,
+  uint32_t start_line,
+  uint32_t start_column,
+  uint32_t end_line,
+  uint32_t end_column
+) {
+  location->start = (position_T) { .line = start_line, .column = start_column };
+  location->end = (position_T) { .line = end_line, .column = end_column };
 }
diff --git a/src/main.c b/src/main.c
index d89af37b0..52b1f370c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -4,11 +4,11 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/extract.h"
 #include "include/herb.h"
 #include "include/io.h"
 #include "include/ruby_parser.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -39,7 +39,6 @@ int main(const int argc, char* argv[]) {
     printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
 
     printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb lex_json [file] -  Lex a file and return the result as json.\n");
     printf("./herb parse [file]    -  Parse a file\n");
     printf("./herb ruby [file]     -  Extract Ruby from a file\n");
     printf("./herb html [file]     -  Extract HTML from a file\n");
@@ -53,9 +52,9 @@ int main(const int argc, char* argv[]) {
     return 1;
   }
 
-  buffer_T output;
+  hb_buffer_T output;
 
-  if (!buffer_init(&output)) { return 1; }
+  if (!hb_buffer_init(&output, 4096)) { return 1; }
 
   char* source = herb_read_file(argv[2]);
 
@@ -74,7 +73,7 @@ int main(const int argc, char* argv[]) {
     print_time_diff(start, end, "visiting");
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -87,18 +86,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "lexing");
 
-    buffer_free(&output);
-    free(source);
-
-    return 0;
-  }
-
-  if (strcmp(argv[1], "lex_json") == 0) {
-    herb_lex_json_to_buffer(source, &output);
-
-    printf("%s\n", output.value);
-
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -106,15 +94,23 @@ int main(const int argc, char* argv[]) {
 
   if (strcmp(argv[1], "parse") == 0) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
+
+    herb_analyze_parse_tree(root, source);
+
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
+    int silent = 0;
+    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
+
+    if (!silent) {
+      ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
+      printf("%s\n", output.value);
 
-    print_time_diff(start, end, "parsing");
+      print_time_diff(start, end, "parsing");
+    }
 
     ast_node_free((AST_NODE_T*) root);
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -127,7 +123,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting Ruby");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
@@ -140,7 +136,7 @@ int main(const int argc, char* argv[]) {
     printf("%s\n", output.value);
     print_time_diff(start, end, "extracting HTML");
 
-    buffer_free(&output);
+    free(output.value);
     free(source);
 
     return 0;
diff --git a/src/memory.c b/src/memory.c
deleted file mode 100644
index f0f3ed8dc..000000000
--- a/src/memory.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "memory.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-static void* safe_malloc_internal(const size_t size, const bool fail_fast) {
-  if (size == 0) { return NULL; }
-
-  void* pointer = malloc(size);
-
-  if (!pointer) {
-    fprintf(stderr, "Error: Failed to allocate %zu bytes.\n", size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return pointer;
-}
-
-static void* safe_realloc_internal(void* pointer, const size_t new_size, const bool fail_fast) {
-  if (new_size == 0) { return NULL; }
-
-  if (!pointer) { return safe_malloc_internal(new_size, fail_fast); }
-
-  void* new_pointer = realloc(pointer, new_size);
-
-  if (!new_pointer) {
-    fprintf(stderr, "Error: Memory reallocation failed (size: %zu bytes).\n", new_size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return new_pointer;
-}
-
-void* safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, true);
-}
-
-void* nullable_safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, false);
-}
-
-void* safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, true);
-}
-
-void* nullable_safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, false);
-}
diff --git a/src/parser.c b/src/parser.c
index 3e4e4ffde..3cc25791a 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1,8 +1,6 @@
 #include "include/parser.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
@@ -11,65 +9,60 @@
 #include "include/token.h"
 #include "include/token_matchers.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors);
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors);
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors);
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors);
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser);
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children);
-static void parser_consume_whitespace(parser_T* parser, array_T* children);
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children);
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children);
 static void parser_skip_erb_content(lexer_T* lexer);
 static bool parser_lookahead_erb_is_attribute(lexer_T* lexer);
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children);
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children);
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children);
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children);
+
+const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false };
 
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
 }
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
-  parser_T* parser = calloc(1, parser_sizeof());
-
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options) {
   parser->lexer = lexer;
   parser->current_token = lexer_next_token(lexer);
-  parser->open_tags_stack = array_init(16);
+  parser->open_tags_stack = hb_array_init(16);
   parser->state = PARSER_STATE_DATA;
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
-
-  if (options) {
-    parser->options = calloc(1, sizeof(parser_options_T));
-    parser->options->track_whitespace = options->track_whitespace;
-  } else {
-    parser->options = NULL;
-  }
-
-  return parser;
+  parser->options = options;
 }
 
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 128);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_CDATA_START, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_CDATA_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      hb_array_append(children, erb_node);
+      start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -80,13 +73,12 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
-  buffer_free(&content);
+  free(content.value);
   token_free(tag_opening);
   token_free(tag_closing);
 
@@ -94,28 +86,28 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
 }
 
 static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
   token_T* comment_start = parser_consume_expected(parser, TOKEN_HTML_COMMENT_START, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
-  buffer_T comment = buffer_new();
+  hb_buffer_T comment;
+  hb_buffer_init(&comment, 512);
 
   while (token_is_none_of(parser, TOKEN_HTML_COMMENT_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &comment, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&comment, token->value);
+    hb_buffer_append(&comment, token->value);
     token_free(token);
   }
 
@@ -127,13 +119,12 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     comment_start,
     children,
     comment_end,
-    comment_start->location->start,
-    comment_end->location->end,
+    comment_start->location.start,
+    comment_end->location.end,
     errors
   );
 
-  buffer_free(&comment);
-  position_free(start);
+  free(comment.value);
   token_free(comment_start);
   token_free(comment_end);
 
@@ -141,26 +132,27 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
 }
 
 static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_DOCTYPE, errors);
 
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_HTML_TAG_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       continue;
     }
 
     token_T* token = parser_consume_expected(parser, parser->current_token->type, errors);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -172,43 +164,42 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return doctype;
 }
 
 static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_XML_DECLARATION, errors);
 
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(parser, TOKEN_XML_DECLARATION_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -220,23 +211,23 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
     tag_opening,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
-  position_free(start);
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return xml_declaration;
 }
 
-static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
-  position_T* start = position_copy(parser->current_token->location->start);
+static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, hb_array_T* document_errors) {
+  position_T start = parser->current_token->location.start;
 
-  buffer_T content = buffer_new();
+  hb_buffer_T content;
+  hb_buffer_init(&content, 2048);
 
   while (token_is_none_of(
     parser,
@@ -248,54 +239,50 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
     TOKEN_EOF
   )) {
     if (token_is(parser, TOKEN_ERROR)) {
-      buffer_free(&content);
+      free(content.value);
 
       token_T* token = parser_consume_expected(parser, TOKEN_ERROR, document_errors);
       append_unexpected_error(
         "Token Error",
         "not TOKEN_ERROR",
         token->value,
-        token->location->start,
-        token->location->end,
+        token->location.start,
+        token->location.end,
         document_errors
       );
 
       token_free(token);
-      position_free(start);
 
       return NULL;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
-  if (buffer_length(&content) > 0) {
-    AST_HTML_TEXT_NODE_T* text_node =
-      ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location->start, errors);
+  AST_HTML_TEXT_NODE_T* text_node = NULL;
 
-    position_free(start);
-    buffer_free(&content);
-
-    return text_node;
+  if (hb_buffer_length(&content) > 0) {
+    text_node =
+      ast_html_text_node_init(hb_buffer_value(&content), start, parser->current_token->location.start, errors);
+  } else {
+    text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
   }
 
-  AST_HTML_TEXT_NODE_T* text_node = ast_html_text_node_init("", start, parser->current_token->location->start, errors);
-
-  position_free(start);
-  buffer_free(&content);
+  free(content.value);
 
   return text_node;
 }
 
 static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T buffer = buffer_new();
-  position_T* start = position_copy(parser->current_token->location->start);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
+  position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(
     parser,
@@ -310,53 +297,50 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&buffer, token->value);
+    hb_buffer_append(&buffer, token->value);
     token_free(token);
   }
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-  position_T* node_start = NULL;
-  position_T* node_end = NULL;
+  position_T node_start = { 0 };
+  position_T node_end = { 0 };
 
   if (children->size > 0) {
-    AST_NODE_T* first_child = array_get(children, 0);
-    AST_NODE_T* last_child = array_get(children, children->size - 1);
+    AST_NODE_T* first_child = hb_array_get(children, 0);
+    AST_NODE_T* last_child = hb_array_get(children, children->size - 1);
 
-    node_start = position_copy(first_child->location->start);
-    node_end = position_copy(last_child->location->end);
+    node_start = first_child->location.start;
+    node_end = last_child->location.end;
   } else {
-    node_start = position_copy(parser->current_token->location->start);
-    node_end = position_copy(parser->current_token->location->start);
+    node_start = parser->current_token->location.start;
+    node_end = parser->current_token->location.start;
   }
 
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name =
     ast_html_attribute_name_node_init(children, node_start, node_end, errors);
 
-  position_free(start);
-  position_free(node_start);
-  position_free(node_end);
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return attribute_name;
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value(
   parser_T* parser,
-  array_T* children,
-  array_T* errors
+  hb_array_T* children,
+  hb_array_T* errors
 ) {
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 512);
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
-  position_T* start = position_copy(parser->current_token->location->start);
+  position_T start = parser->current_token->location.start;
 
   while (!token_is(parser, TOKEN_EOF)
          && !(
@@ -366,10 +350,9 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -381,8 +364,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       if (next_token && next_token->type == TOKEN_QUOTE && opening_quote != NULL
           && strcmp(next_token->value, opening_quote->value) == 0) {
-        buffer_append(&buffer, parser->current_token->value);
-        buffer_append(&buffer, next_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, next_token->value);
 
         token_free(parser->current_token);
         token_free(next_token);
@@ -396,7 +379,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       }
     }
 
-    buffer_append(&buffer, parser->current_token->value);
+    hb_buffer_append(&buffer, parser->current_token->value);
     token_free(parser->current_token);
 
     parser->current_token = lexer_next_token(parser->lexer);
@@ -414,8 +397,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
         "Unescaped quote character in attribute value",
         "escaped quote (\\') or different quote style (\")",
         opening_quote->value,
-        potential_closing->location->start,
-        potential_closing->location->end,
+        potential_closing->location.start,
+        potential_closing->location.end,
         errors
       );
 
@@ -424,7 +407,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       token_free(parser->current_token);
       parser->current_token = potential_closing;
 
-      buffer_append(&buffer, parser->current_token->value);
+      hb_buffer_append(&buffer, parser->current_token->value);
       token_free(parser->current_token);
       parser->current_token = lexer_next_token(parser->lexer);
 
@@ -436,15 +419,14 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
         if (token_is(parser, TOKEN_ERB_START)) {
           parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-          array_append(children, parser_parse_erb_tag(parser));
+          hb_array_append(children, parser_parse_erb_tag(parser));
 
-          position_free(start);
-          start = position_copy(parser->current_token->location->start);
+          start = parser->current_token->location.start;
 
           continue;
         }
 
-        buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
         token_free(parser->current_token);
 
         parser->current_token = lexer_next_token(parser->lexer);
@@ -458,8 +440,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
-  position_free(start);
-  buffer_free(&buffer);
+  free(buffer.value);
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
 
@@ -467,8 +448,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     append_quotes_mismatch_error(
       opening_quote,
       closing_quote,
-      closing_quote->location->start,
-      closing_quote->location->end,
+      closing_quote->location.start,
+      closing_quote->location.end,
       errors
     );
   }
@@ -478,8 +459,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     children,
     closing_quote,
     true,
-    opening_quote->location->start,
-    closing_quote->location->end,
+    opening_quote->location.start,
+    closing_quote->location.end,
     errors
   );
 
@@ -490,21 +471,21 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   // <div id=<%= "home" %>>
   if (token_is(parser, TOKEN_ERB_START)) {
     AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-    array_append(children, erb_node);
+    hb_array_append(children, erb_node);
 
     return ast_html_attribute_value_node_init(
       NULL,
       children,
       NULL,
       false,
-      erb_node->base.location->start,
-      erb_node->base.location->end,
+      erb_node->base.location.start,
+      erb_node->base.location.end,
       errors
     );
   }
@@ -515,15 +496,15 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     AST_LITERAL_NODE_T* literal = ast_literal_node_init_from_token(identifier);
     token_free(identifier);
 
-    array_append(children, literal);
+    hb_array_append(children, literal);
 
     return ast_html_attribute_value_node_init(
       NULL,
       children,
       NULL,
       false,
-      literal->base.location->start,
-      literal->base.location->end,
+      literal->base.location.start,
+      literal->base.location.end,
       errors
     );
   }
@@ -533,8 +514,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
 
   if (token_is(parser, TOKEN_BACKTICK)) {
     token_T* token = parser_advance(parser);
-    position_T* start = position_copy(token->location->start);
-    position_T* end = position_copy(token->location->end);
+    position_T start = token->location.start;
+    position_T end = token->location.end;
 
     append_unexpected_error(
       "Invalid quote character for HTML attribute",
@@ -548,8 +529,6 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* value =
       ast_html_attribute_value_node_init(NULL, children, NULL, false, start, end, errors);
 
-    position_free(start);
-    position_free(end);
     token_free(token);
 
     return value;
@@ -559,8 +538,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     "Unexpected Token",
     "TOKEN_IDENTIFIER, TOKEN_QUOTE, TOKEN_ERB_START",
     token_type_to_string(parser->current_token->type),
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 
@@ -569,8 +548,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     children,
     NULL,
     false,
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 
@@ -580,56 +559,60 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
 static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser) {
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name = parser_parse_html_attribute_name(parser);
 
-  if (parser->options && parser->options->track_whitespace) {
+  if (parser->options.track_whitespace) {
     bool has_equals = (parser->current_token->type == TOKEN_EQUALS)
                    || lexer_peek_for_token_type_after_whitespace(parser->lexer, TOKEN_EQUALS);
 
     if (has_equals) {
-      buffer_T equals_buffer = buffer_new();
-      position_T* equals_start = NULL;
-      position_T* equals_end = NULL;
-      size_t range_start = 0;
-      size_t range_end = 0;
-
+      hb_buffer_T equals_buffer;
+      hb_buffer_init(&equals_buffer, 256);
+      position_T equals_start = { 0 };
+      position_T equals_end = { 0 };
+      uint32_t range_start = 0;
+      uint32_t range_end = 0;
+
+      bool equals_start_present = false;
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
 
-        if (equals_start == NULL) {
-          equals_start = position_copy(whitespace->location->start);
-          range_start = whitespace->range->from;
+        if (equals_start_present == false) {
+          equals_start_present = true;
+          equals_start = whitespace->location.start;
+          range_start = whitespace->range.from;
         }
 
-        buffer_append(&equals_buffer, whitespace->value);
+        hb_buffer_append(&equals_buffer, whitespace->value);
         token_free(whitespace);
       }
 
       token_T* equals = parser_advance(parser);
 
-      if (equals_start == NULL) {
-        equals_start = position_copy(equals->location->start);
-        range_start = equals->range->from;
+      if (equals_start_present == false) {
+        equals_start_present = true;
+        equals_start = equals->location.start;
+        range_start = equals->range.from;
       }
 
-      buffer_append(&equals_buffer, equals->value);
-      equals_end = position_copy(equals->location->end);
-      range_end = equals->range->to;
+      hb_buffer_append(&equals_buffer, equals->value);
+      equals_end = equals->location.end;
+      range_end = equals->range.to;
       token_free(equals);
 
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
-        buffer_append(&equals_buffer, whitespace->value);
-        equals_end = position_copy(whitespace->location->end);
-        range_end = whitespace->range->to;
+        hb_buffer_append(&equals_buffer, whitespace->value);
+        equals_end = whitespace->location.end;
+        range_end = whitespace->range.to;
         token_free(whitespace);
       }
 
       token_T* equals_with_whitespace = calloc(1, sizeof(token_T));
       equals_with_whitespace->type = TOKEN_EQUALS;
       equals_with_whitespace->value = herb_strdup(equals_buffer.value);
-      equals_with_whitespace->location = location_init(equals_start, equals_end);
-      equals_with_whitespace->range = range_init(range_start, range_end);
+      equals_with_whitespace->location = (location_T) { .start = equals_start, .end = equals_end };
+      equals_with_whitespace->range = (range_T) { .from = range_start, .to = range_end };
 
-      buffer_free(&equals_buffer);
+      free(equals_buffer.value);
 
       AST_HTML_ATTRIBUTE_VALUE_NODE_T* attribute_value = parser_parse_html_attribute_value(parser);
 
@@ -637,8 +620,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         attribute_name,
         equals_with_whitespace,
         attribute_value,
-        attribute_name->base.location->start,
-        attribute_value->base.location->end,
+        attribute_name->base.location.start,
+        attribute_value->base.location.end,
         NULL
       );
     } else {
@@ -646,8 +629,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         attribute_name,
         NULL,
         NULL,
-        attribute_name->base.location->start,
-        attribute_name->base.location->end,
+        attribute_name->base.location.start,
+        attribute_name->base.location.end,
         NULL
       );
     }
@@ -666,8 +649,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       attribute_name,
       equals,
       attribute_value,
-      attribute_name->base.location->start,
-      attribute_value->base.location->end,
+      attribute_name->base.location.start,
+      attribute_value->base.location.end,
       NULL
     );
 
@@ -680,8 +663,8 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
     attribute_name,
     NULL,
     NULL,
-    attribute_name->base.location->start,
-    attribute_name->base.location->end,
+    attribute_name->base.location.start,
+    attribute_name->base.location.end,
     NULL
   );
 }
@@ -735,12 +718,12 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
   } while (true);
 }
 
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children) {
   bool is_output_tag = parser->current_token->value && strlen(parser->current_token->value) >= 3
                     && strncmp(parser->current_token->value, "<%=", 3) == 0;
 
   if (!is_output_tag) {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
 
     return;
   }
@@ -754,13 +737,13 @@ static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
   bool looks_like_attribute = parser_lookahead_erb_is_attribute(&lexer_copy);
 
   if (looks_like_attribute) {
-    array_append(children, parser_parse_html_attribute(parser));
+    hb_array_append(children, parser_parse_html_attribute(parser));
   } else {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
   }
 }
 
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children) {
   token_T* whitespace = parser_consume_if_present(parser, TOKEN_WHITESPACE);
 
   if (whitespace != NULL) {
@@ -774,8 +757,8 @@ static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* chil
 }
 
 static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_start = parser_consume_expected(parser, TOKEN_HTML_TAG_START, errors);
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
@@ -787,7 +770,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_IDENTIFIER) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -797,7 +780,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_AT) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -807,7 +790,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER) {
         token_free(next_token);
-        array_append(children, parser_parse_html_attribute(parser));
+        hb_array_append(children, parser_parse_html_attribute(parser));
 
         continue;
       }
@@ -834,8 +817,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
       token_free(tag_start);
       token_free(tag_name);
 
-      array_free(&children);
-      array_free(&errors);
+      hb_array_free(&children);
+      hb_array_free(&errors);
 
       return NULL;
     }
@@ -849,8 +832,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     tag_end,
     children,
     is_self_closing,
-    tag_start->location->start,
-    tag_end->location->end,
+    tag_start->location.start,
+    tag_end->location.end,
     errors
   );
 
@@ -862,8 +845,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 }
 
 static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
 
@@ -875,21 +858,21 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_closing = parser_consume_expected(parser, TOKEN_HTML_TAG_END, errors);
 
-  if (tag_name != NULL && is_void_element(tag_name->value) && parser_in_svg_context(parser) == false) {
-    char* expected = html_self_closing_tag_string(tag_name->value);
-    char* got = html_closing_tag_string(tag_name->value);
+  if (tag_name != NULL && is_void_element(hb_string(tag_name->value)) && parser_in_svg_context(parser) == false) {
+    hb_string_T expected = html_self_closing_tag_string(hb_string(tag_name->value));
+    hb_string_T got = html_closing_tag_string(hb_string(tag_name->value));
 
     append_void_element_closing_tag_error(
       tag_name,
-      expected,
-      got,
-      tag_opening->location->start,
-      tag_closing->location->end,
+      expected.data,
+      got.data,
+      tag_opening->location.start,
+      tag_closing->location.end,
       errors
     );
 
-    free(expected);
-    free(got);
+    free(expected.data);
+    free(got.data);
   }
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = ast_html_close_tag_node_init(
@@ -897,8 +880,8 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
     tag_name,
     children,
     tag_closing,
-    tag_opening->location->start,
-    tag_closing->location->end,
+    tag_opening->location.start,
+    tag_closing->location.end,
     errors
   );
 
@@ -921,8 +904,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_self_closing_element(
     NULL,
     true,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     NULL
   );
 }
@@ -931,13 +914,13 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
   parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag
 ) {
-  array_T* errors = array_init(8);
-  array_T* body = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* body = hb_array_init(8);
 
   parser_push_open_tag(parser, open_tag->tag_name);
 
-  if (open_tag->tag_name->value && parser_is_foreign_content_tag(open_tag->tag_name->value)) {
-    foreign_content_type_T content_type = parser_get_foreign_content_type(open_tag->tag_name->value);
+  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string(open_tag->tag_name->value))) {
+    foreign_content_type_T content_type = parser_get_foreign_content_type(hb_string(open_tag->tag_name->value));
     parser_enter_foreign_content(parser, content_type);
     parser_parse_foreign_content(parser, body, errors);
   } else {
@@ -948,13 +931,13 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-  if (parser_in_svg_context(parser) == false && is_void_element(close_tag->tag_name->value)) {
-    array_push(body, close_tag);
+  if (parser_in_svg_context(parser) == false && is_void_element(hb_string(close_tag->tag_name->value))) {
+    hb_array_push(body, close_tag);
     parser_parse_in_data_state(parser, body, errors);
     close_tag = parser_parse_html_close_tag(parser);
   }
 
-  bool matches_stack = parser_check_matching_tag(parser, close_tag->tag_name->value);
+  bool matches_stack = parser_check_matching_tag(parser, hb_string(close_tag->tag_name->value));
 
   if (matches_stack) {
     token_T* popped_token = parser_pop_open_tag(parser);
@@ -970,8 +953,8 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
     close_tag,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    close_tag->base.location->end,
+    open_tag->base.location.start,
+    close_tag->base.location.end,
     errors
   );
 }
@@ -983,14 +966,14 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
   if (open_tag->is_void) { return parser_parse_html_self_closing_element(parser, open_tag); }
 
   // <tag>, in void element list, and not in inside an <svg> element
-  if (!open_tag->is_void && is_void_element(open_tag->tag_name->value) && !parser_in_svg_context(parser)) {
+  if (!open_tag->is_void && is_void_element(hb_string(open_tag->tag_name->value)) && !parser_in_svg_context(parser)) {
     return parser_parse_html_self_closing_element(parser, open_tag);
   }
 
   AST_HTML_ELEMENT_NODE_T* regular_element = parser_parse_html_regular_element(parser, open_tag);
   if (regular_element != NULL) { return regular_element; }
 
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   parser_append_unexpected_error(parser, "Unknown HTML open tag type", "HTMLOpenTag or HTMLSelfCloseTag", errors);
 
@@ -1001,14 +984,14 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
     NULL,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     errors
   );
 }
 
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   token_T* opening_tag = parser_consume_expected(parser, TOKEN_ERB_START, errors);
   token_T* content = parser_consume_expected(parser, TOKEN_ERB_CONTENT, errors);
@@ -1021,8 +1004,8 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
     NULL,
     false,
     false,
-    opening_tag->location->start,
-    closing_tag->location->end,
+    opening_tag->location.start,
+    closing_tag->location.end,
     errors
   );
 
@@ -1033,15 +1016,15 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
   return erb_node;
 }
 
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors) {
-  buffer_T content = buffer_new();
-  position_T* start = position_copy(parser->current_token->location->start);
-  const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  hb_buffer_T content;
+  hb_buffer_init(&content, 1024);
+  position_T start = parser->current_token->location.start;
+  hb_string_T expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
-  if (expected_closing_tag == NULL) {
+  if (hb_string_is_empty(expected_closing_tag)) {
     parser_exit_foreign_content(parser);
-    position_free(start);
-    buffer_free(&content);
+    free(content.value);
 
     return;
   }
@@ -1051,10 +1034,9 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
-      position_free(start);
-      start = position_copy(parser->current_token->location->start);
+      start = parser->current_token->location.start;
 
       continue;
     }
@@ -1066,7 +1048,8 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       bool is_potential_match = false;
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER && next_token->value) {
-        is_potential_match = parser_is_expected_closing_tag_name(next_token->value, parser->foreign_content_type);
+        is_potential_match =
+          parser_is_expected_closing_tag_name(hb_string(next_token->value), parser->foreign_content_type);
       }
 
       lexer_restore_state(parser->lexer, saved_state);
@@ -1077,53 +1060,51 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
         parser_append_literal_node_from_buffer(parser, &content, children, start);
         parser_exit_foreign_content(parser);
 
-        position_free(start);
-        buffer_free(&content);
+        free(content.value);
 
         return;
       }
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
   parser_append_literal_node_from_buffer(parser, &content, children, start);
   parser_exit_foreign_content(parser);
-  position_free(start);
-  buffer_free(&content);
+  free(content.value);
 }
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors) {
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
   while (token_is_none_of(parser, TOKEN_HTML_TAG_START_CLOSE, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_DOCTYPE)) {
-      array_append(children, parser_parse_html_doctype(parser));
+      hb_array_append(children, parser_parse_html_doctype(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_XML_DECLARATION)) {
-      array_append(children, parser_parse_xml_declaration(parser));
+      hb_array_append(children, parser_parse_xml_declaration(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_CDATA_START)) {
-      array_append(children, parser_parse_cdata(parser));
+      hb_array_append(children, parser_parse_cdata(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_COMMENT_START)) {
-      array_append(children, parser_parse_html_comment(parser));
+      hb_array_append(children, parser_parse_html_comment(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_TAG_START)) {
-      array_append(children, parser_parse_html_element(parser));
+      hb_array_append(children, parser_parse_html_element(parser));
       continue;
     }
 
@@ -1131,6 +1112,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           parser,
           TOKEN_AMPERSAND,
           TOKEN_AT,
+          TOKEN_BACKSLASH,
           TOKEN_BACKTICK,
           TOKEN_CHARACTER,
           TOKEN_COLON,
@@ -1147,7 +1129,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_UNDERSCORE,
           TOKEN_WHITESPACE
         )) {
-      array_append(children, parser_parse_text_content(parser, errors));
+      hb_array_append(children, parser_parse_text_content(parser, errors));
       continue;
     }
 
@@ -1155,20 +1137,20 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
       parser,
       "Unexpected token",
       "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, "
-      "TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE",
+      "TOKEN_NBSP, TOKEN_AT, TOKEN_BACKSLASH, or TOKEN_NEWLINE",
       errors
     );
   }
 }
 
-static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* errors) {
-  while (array_size(parser->open_tags_stack) > 0) {
+static void parser_parse_unclosed_html_tags(const parser_T* parser, hb_array_T* errors) {
+  while (hb_array_size(parser->open_tags_stack) > 0) {
     token_T* unclosed_tag = parser_pop_open_tag(parser);
 
     append_unclosed_element_error(
       unclosed_tag,
-      parser->current_token->location->start,
-      parser->current_token->location->end,
+      parser->current_token->location.start,
+      parser->current_token->location.end,
       errors
     );
 
@@ -1176,7 +1158,7 @@ static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* err
   }
 }
 
-static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children, array_T* errors) {
+static void parser_parse_stray_closing_tags(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
   while (token_is_not(parser, TOKEN_EOF)) {
     if (token_is_not(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       parser_append_unexpected_token_error(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
@@ -1189,25 +1171,25 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
 
     AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-    if (!is_void_element(close_tag->tag_name->value)) {
+    if (!is_void_element(hb_string(close_tag->tag_name->value))) {
       append_missing_opening_tag_error(
         close_tag->tag_name,
-        close_tag->base.location->start,
-        close_tag->base.location->end,
+        close_tag->base.location.start,
+        close_tag->base.location.end,
         close_tag->base.errors
       );
     }
 
-    array_append(children, close_tag);
+    hb_array_append(children, close_tag);
 
     parser_parse_in_data_state(parser, children, errors);
   }
 }
 
 static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
-  position_T* start = position_copy(parser->current_token->location->start);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  position_T start = parser->current_token->location.start;
 
   parser_parse_in_data_state(parser, children, errors);
   parser_parse_unclosed_html_tags(parser, errors);
@@ -1215,9 +1197,8 @@ static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
 
   token_T* eof = parser_consume_expected(parser, TOKEN_EOF, errors);
 
-  AST_DOCUMENT_NODE_T* document_node = ast_document_node_init(children, start, eof->location->end, errors);
+  AST_DOCUMENT_NODE_T* document_node = ast_document_node_init(children, start, eof->location.end, errors);
 
-  position_free(start);
   token_free(eof);
 
   return document_node;
@@ -1227,26 +1208,26 @@ AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser) {
   return parser_parse_document(parser);
 }
 
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children) {
-  if (parser->options && parser->options->track_whitespace) {
-    array_T* errors = array_init(8);
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children) {
+  if (parser->options.track_whitespace) {
+    hb_array_T* errors = hb_array_init(8);
     AST_WHITESPACE_NODE_T* whitespace_node = ast_whitespace_node_init(
       whitespace_token,
-      whitespace_token->location->start,
-      whitespace_token->location->end,
+      whitespace_token->location.start,
+      whitespace_token->location.end,
       errors
     );
-    array_append(children, whitespace_node);
+    hb_array_append(children, whitespace_node);
   }
 
   token_free(whitespace_token);
 }
 
-static void parser_consume_whitespace(parser_T* parser, array_T* children) {
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children) {
   while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
     token_T* whitespace = parser_advance(parser);
 
-    if (parser->options && parser->options->track_whitespace && children != NULL) {
+    if (parser->options.track_whitespace && children != NULL) {
       parser_handle_whitespace(parser, whitespace, children);
     } else {
       token_free(whitespace);
@@ -1254,13 +1235,9 @@ static void parser_consume_whitespace(parser_T* parser, array_T* children) {
   }
 }
 
-void parser_free(parser_T* parser) {
+void herb_parser_deinit(parser_T* parser) {
   if (parser == NULL) { return; }
 
-  if (parser->lexer != NULL) { lexer_free(parser->lexer); }
   if (parser->current_token != NULL) { token_free(parser->current_token); }
-  if (parser->open_tags_stack != NULL) { array_free(&parser->open_tags_stack); }
-  if (parser->options != NULL) { free(parser->options); }
-
-  free(parser);
+  if (parser->open_tags_stack != NULL) { hb_array_free(&parser->open_tags_stack); }
 }
diff --git a/src/parser_helpers.c b/src/parser_helpers.c
index bf92a5523..f34d97864 100644
--- a/src/parser_helpers.c
+++ b/src/parser_helpers.c
@@ -1,36 +1,36 @@
 #include "include/parser_helpers.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
 #include "include/token_matchers.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
-#include <strings.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
   token_T* copy = token_copy(tag_name);
-  array_push(parser->open_tags_stack, copy);
+  hb_array_push(parser->open_tags_stack, copy);
 }
 
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name) {
-  if (array_size(parser->open_tags_stack) == 0) { return false; }
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
+  if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
-  token_T* top_token = array_last(parser->open_tags_stack);
+  token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return (strcasecmp(top_token->value, tag_name) == 0);
+  return hb_string_equals(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (array_size(parser->open_tags_stack) == 0) { return NULL; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
 
-  return array_pop(parser->open_tags_stack);
+  return hb_array_pop(parser->open_tags_stack);
 }
 
 /**
@@ -42,13 +42,14 @@ token_T* parser_pop_open_tag(const parser_T* parser) {
 bool parser_in_svg_context(const parser_T* parser) {
   if (!parser || !parser->open_tags_stack) { return false; }
 
-  size_t stack_size = array_size(parser->open_tags_stack);
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
 
   for (size_t i = 0; i < stack_size; i++) {
-    token_T* tag = (token_T*) array_get(parser->open_tags_stack, i);
+    token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
-      if (strcasecmp(tag->value, "svg") == 0) { return true; }
+      hb_string_T tag_value_string = hb_string(tag->value);
+      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -57,24 +58,24 @@ bool parser_in_svg_context(const parser_T* parser) {
 
 // ===== Foreign Content Handling =====
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name) {
-  if (tag_name == NULL) { return FOREIGN_CONTENT_UNKNOWN; }
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (strcasecmp(tag_name, "script") == 0) { return FOREIGN_CONTENT_SCRIPT; }
-  if (strcasecmp(tag_name, "style") == 0) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
 
-bool parser_is_foreign_content_tag(const char* tag_name) {
+bool parser_is_foreign_content_tag(hb_string_T tag_name) {
   return parser_get_foreign_content_type(tag_name) != FOREIGN_CONTENT_UNKNOWN;
 }
 
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
   switch (type) {
-    case FOREIGN_CONTENT_SCRIPT: return "script";
-    case FOREIGN_CONTENT_STYLE: return "style";
-    default: return NULL;
+    case FOREIGN_CONTENT_SCRIPT: return hb_string("script");
+    case FOREIGN_CONTENT_STYLE: return hb_string("style");
+    default: return hb_string("");
   }
 }
 
@@ -92,44 +93,49 @@ void parser_exit_foreign_content(parser_T* parser) {
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
 }
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors) {
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+) {
   token_T* token = parser_advance(parser);
 
   append_unexpected_error(
     description,
     expected,
     token_type_to_string(token->type),
-    token->location->start,
-    token->location->end,
+    token->location.start,
+    token->location.end,
     errors
   );
 
   token_free(token);
 }
 
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors) {
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors) {
   append_unexpected_token_error(
     expected_type,
     parser->current_token,
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 }
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
-  position_T* start
+  hb_buffer_T* buffer,
+  hb_array_T* children,
+  position_T start
 ) {
-  if (buffer_length(buffer) == 0) { return; }
+  if (hb_buffer_length(buffer) == 0) { return; }
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location->start, NULL);
+    ast_literal_node_init(hb_buffer_value(buffer), start, parser->current_token->location.start, NULL);
 
-  if (children != NULL) { array_append(children, literal); }
-  buffer_clear(buffer);
+  if (children != NULL) { hb_array_append(children, literal); }
+  hb_buffer_clear(buffer);
 }
 
 token_T* parser_advance(parser_T* parser) {
@@ -143,13 +149,13 @@ token_T* parser_consume_if_present(parser_T* parser, const token_type_T type) {
   return parser_advance(parser);
 }
 
-token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, array_T* array) {
+token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, hb_array_T* array) {
   token_T* token = parser_consume_if_present(parser, expected_type);
 
   if (token == NULL) {
     token = parser_advance(parser);
 
-    append_unexpected_token_error(expected_type, token, token->location->start, token->location->end, array);
+    append_unexpected_token_error(expected_type, token, token->location.start, token->location.end, array);
   }
 
   return token;
@@ -157,13 +163,13 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
-    open_tag->tag_name->location->start,
-    open_tag->tag_name->location->end,
+    open_tag->tag_name->location.start,
+    open_tag->tag_name->location.end,
     errors
   );
 
@@ -174,8 +180,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     NULL,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     errors
   );
 }
@@ -183,33 +189,33 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 void parser_handle_mismatched_tags(
   const parser_T* parser,
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
-  array_T* errors
+  hb_array_T* errors
 ) {
-  if (array_size(parser->open_tags_stack) > 0) {
-    token_T* expected_tag = array_last(parser->open_tags_stack);
+  if (hb_array_size(parser->open_tags_stack) > 0) {
+    token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 
     append_tag_names_mismatch_error(
       expected_tag,
       actual_tag,
-      actual_tag->location->start,
-      actual_tag->location->end,
+      actual_tag->location.start,
+      actual_tag->location.end,
       errors
     );
   } else {
     append_missing_opening_tag_error(
       close_tag->tag_name,
-      close_tag->tag_name->location->start,
-      close_tag->tag_name->location->end,
+      close_tag->tag_name->location.start,
+      close_tag->tag_name->location.end,
       errors
     );
   }
 }
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type) {
-  const char* expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type) {
+  hb_string_T expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
 
-  if (expected_tag_name == NULL || tag_name == NULL) { return false; }
+  if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return strcmp(tag_name, expected_tag_name) == 0;
+  return hb_string_equals(expected_tag_name, tag_name);
 }
diff --git a/src/position.c b/src/position.c
deleted file mode 100644
index 7b946b764..000000000
--- a/src/position.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "include/position.h"
-#include "include/memory.h"
-
-size_t position_sizeof(void) {
-  return sizeof(position_T);
-}
-
-position_T* position_init(const size_t line, const size_t column) {
-  position_T* position = safe_malloc(position_sizeof());
-
-  position->line = line;
-  position->column = column;
-
-  return position;
-}
-
-size_t position_line(const position_T* position) {
-  return position->line;
-}
-
-size_t position_column(const position_T* position) {
-  return position->column;
-}
-
-position_T* position_copy(position_T* position) {
-  if (position == NULL) { return NULL; }
-
-  return position_init(position_line(position), position_column(position));
-}
-
-void position_free(position_T* position) {
-  free(position);
-}
diff --git a/src/pretty_print.c b/src/pretty_print.c
index ee79d4e34..e480dd0b7 100644
--- a/src/pretty_print.c
+++ b/src/pretty_print.c
@@ -3,25 +3,26 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/ast_pretty_print.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-void pretty_print_indent(buffer_T* buffer, const size_t indent) {
+void pretty_print_indent(hb_buffer_T* buffer, const size_t indent) {
   for (size_t i = 0; i < indent; i++) {
-    buffer_append(buffer, "    ");
+    hb_buffer_append(buffer, "    ");
   }
 }
 
-void pretty_print_newline(const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void pretty_print_newline(const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_label(
@@ -29,19 +30,19 @@ void pretty_print_label(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_indent(buffer, indent);
   pretty_print_indent(buffer, relative_indent);
 
   if (last_property) {
-    buffer_append(buffer, "└── ");
+    hb_buffer_append(buffer, "└── ");
   } else {
-    buffer_append(buffer, "├── ");
+    hb_buffer_append(buffer, "├── ");
   }
 
-  buffer_append(buffer, name);
-  buffer_append(buffer, ": ");
+  hb_buffer_append(buffer, name);
+  hb_buffer_append(buffer, ": ");
 }
 
 void pretty_print_quoted_property(
@@ -50,11 +51,11 @@ void pretty_print_quoted_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  char* quoted = quoted_string(value);
-  pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
-  free(quoted);
+  hb_string_T quoted = quoted_string(hb_string(value));
+  pretty_print_property(name, quoted.data, indent, relative_indent, last_property, buffer);
+  free(quoted.data);
 }
 
 void pretty_print_boolean_property(
@@ -63,7 +64,7 @@ void pretty_print_boolean_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_property(name, value ? "true" : "false", indent, relative_indent, last_property, buffer);
 }
@@ -74,11 +75,11 @@ void pretty_print_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  buffer_append(buffer, value);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, value);
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_size_t_property(
@@ -87,22 +88,24 @@ void pretty_print_size_t_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
-  char* string = size_t_to_string(value);
-  buffer_append(buffer, string);
-  buffer_append(buffer, "\n");
-  free(string);
+
+  char size_string[21];
+  snprintf(size_string, 21, "%zu", value);
+
+  hb_buffer_append(buffer, size_string);
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_array(
   const char* name,
-  array_T* array,
+  hb_array_T* array,
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
     pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
@@ -110,7 +113,7 @@ void pretty_print_array(
     return;
   }
 
-  if (array_size(array) == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
 
     return;
@@ -118,31 +121,31 @@ void pretty_print_array(
 
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_errors(
@@ -150,27 +153,27 @@ void pretty_print_errors(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
-  if (node->errors != NULL && array_size(node->errors) > 0) {
+  if (node->errors != NULL && hb_array_size(node->errors) > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
-    buffer_append(buffer, "\n");
+    hb_buffer_append(buffer, "\n");
   }
 }
 
-void pretty_print_location(location_T* location, buffer_T* buffer) {
-  buffer_append(buffer, "(location: (");
+void pretty_print_location(location_T location, hb_buffer_T* buffer) {
+  hb_buffer_append(buffer, "(location: (");
   char location_string[128];
   sprintf(
     location_string,
-    "%zu,%zu)-(%zu,%zu",
-    (location->start && location->start->line) ? location->start->line : 0,
-    (location->start && location->start->column) ? location->start->column : 0,
-    (location->end && location->end->line) ? location->end->line : 0,
-    (location->end && location->end->column) ? location->end->column : 0
+    "%u,%u)-(%u,%u",
+    location.start.line,
+    location.start.column,
+    location.end.line,
+    location.end.column
   );
-  buffer_append(buffer, location_string);
-  buffer_append(buffer, "))");
+  hb_buffer_append(buffer, location_string);
+  hb_buffer_append(buffer, "))");
 }
 
 void pretty_print_position_property(
@@ -179,29 +182,24 @@ void pretty_print_position_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (position != NULL) {
-    buffer_append(buffer, "(");
+    hb_buffer_append(buffer, "(");
 
     char position_string[128];
 
-    sprintf(
-      position_string,
-      "%zu:%zu",
-      (position->line) ? position->line : 0,
-      (position->column) ? position->column : 0
-    );
+    sprintf(position_string, "%u:%u", (position->line) ? position->line : 0, (position->column) ? position->column : 0);
 
-    buffer_append(buffer, position_string);
-    buffer_append(buffer, ")");
+    hb_buffer_append(buffer, position_string);
+    hb_buffer_append(buffer, ")");
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_token_property(
@@ -210,22 +208,22 @@ void pretty_print_token_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
   if (token != NULL && token->value != NULL) {
-    char* quoted = quoted_string(token->value);
-    buffer_append(buffer, quoted);
-    free(quoted);
+    hb_string_T quoted = quoted_string(hb_string(token->value));
+    hb_buffer_append_string(buffer, quoted);
+    free(quoted.data);
 
-    buffer_append(buffer, " ");
+    hb_buffer_append(buffer, " ");
     pretty_print_location(token->location, buffer);
   } else {
-    buffer_append(buffer, "∅");
+    hb_buffer_append(buffer, "∅");
   }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 }
 
 void pretty_print_string_property(
@@ -234,49 +232,22 @@ void pretty_print_string_property(
   const size_t indent,
   const size_t relative_indent,
   const bool last_property,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 ) {
   const char* value = "∅";
   char* escaped = NULL;
-  char* quoted = NULL;
+  hb_string_T quoted;
 
   if (string != NULL) {
     escaped = escape_newlines(string);
-    quoted = quoted_string(escaped);
-    value = quoted;
+    quoted = quoted_string(hb_string(escaped));
+    value = quoted.data;
   }
 
   pretty_print_property(name, value, indent, relative_indent, last_property, buffer);
 
   if (string != NULL) {
     if (escaped != NULL) { free(escaped); }
-    if (quoted != NULL) { free(quoted); }
+    if (!hb_string_is_empty(quoted)) { free(quoted.data); }
   }
 }
-
-void pretty_print_analyzed_ruby(analyzed_ruby_T* analyzed, const char* source) {
-  printf(
-    "------------------------\nanalyzed (%p)\n------------------------\n%s\n------------------------\n  if:     %i\n "
-    " elsif:  %i\n  else:   %i\n  end:    %i\n  block:  %i\n  block_closing: %i\n  case:   %i\n  when:   %i\n  for:    "
-    "%i\n  while:  %i\n "
-    " until:  %i\n  begin:  %i\n  "
-    "rescue: %i\n  ensure: %i\n  unless: %i\n==================\n\n",
-    (void*) analyzed,
-    source,
-    analyzed->has_if_node,
-    analyzed->has_elsif_node,
-    analyzed->has_else_node,
-    analyzed->has_end,
-    analyzed->has_block_node,
-    analyzed->has_block_closing,
-    analyzed->has_case_node,
-    analyzed->has_when_node,
-    analyzed->has_for_node,
-    analyzed->has_while_node,
-    analyzed->has_until_node,
-    analyzed->has_begin_node,
-    analyzed->has_rescue_node,
-    analyzed->has_ensure_node,
-    analyzed->has_unless_node
-  );
-}
diff --git a/src/prism_helpers.c b/src/prism_helpers.c
index 93c4857f2..06ac155b5 100644
--- a/src/prism_helpers.c
+++ b/src/prism_helpers.c
@@ -16,15 +16,15 @@ const char* pm_error_level_to_string(pm_error_level_t level) {
   }
 }
 
-position_T* position_from_source_with_offset(const char* source, size_t offset) {
-  position_T* position = position_init(1, 0);
+position_T position_from_source_with_offset(const char* source, size_t offset) {
+  position_T position = { .line = 1, .column = 0 };
 
   for (size_t i = 0; i < offset; i++) {
     if (is_newline(source[i])) {
-      position->line++;
-      position->column = 0;
+      position.line++;
+      position.column = 0;
     } else {
-      position->column++;
+      position.column++;
     }
   }
 
@@ -40,8 +40,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   size_t start_offset = (size_t) (error->location.start - parser->start);
   size_t end_offset = (size_t) (error->location.end - parser->start);
 
-  position_T* start = position_from_source_with_offset(source, start_offset);
-  position_T* end = position_from_source_with_offset(source, end_offset);
+  position_T start = position_from_source_with_offset(source, start_offset);
+  position_T end = position_from_source_with_offset(source, end_offset);
 
   return ruby_parse_error_init(
     error->message,
diff --git a/src/range.c b/src/range.c
index 030b87b71..6e6abea50 100644
--- a/src/range.c
+++ b/src/range.c
@@ -1,38 +1,5 @@
 #include "include/range.h"
 
-size_t range_sizeof(void) {
-  return sizeof(range_T);
-}
-
-range_T* range_init(const size_t from, const size_t to) {
-  range_T* range = calloc(1, range_sizeof());
-
-  range->from = from;
-  range->to = to;
-
-  return range;
-}
-
-size_t range_from(const range_T* range) {
-  return range->from;
-}
-
-size_t range_to(const range_T* range) {
-  return range->to;
-}
-
-size_t range_length(range_T* range) {
-  return range_to(range) - range_from(range);
-}
-
-range_T* range_copy(range_T* range) {
-  if (!range) { return NULL; }
-
-  return range_init(range_from(range), range_to(range));
-}
-
-void range_free(range_T* range) {
-  if (range == NULL) { return; }
-
-  free(range);
+uint32_t range_length(range_T range) {
+  return range.to - range.from;
 }
diff --git a/src/token.c b/src/token.c
index a8cb5fb3f..b84362754 100644
--- a/src/token.c
+++ b/src/token.c
@@ -1,7 +1,7 @@
 #include "include/token.h"
-#include "include/json.h"
 #include "include/lexer.h"
 #include "include/position.h"
+#include "include/range.h"
 #include "include/token_struct.h"
 #include "include/util.h"
 
@@ -28,10 +28,15 @@ token_T* token_init(const char* value, const token_type_T type, lexer_T* lexer)
   }
 
   token->type = type;
-  token->range = range_init(lexer->previous_position, lexer->current_position);
-
-  token->location =
-    location_from(lexer->previous_line, lexer->previous_column, lexer->current_line, lexer->current_column);
+  token->range = (range_T) { .from = lexer->previous_position, .to = lexer->current_position };
+
+  location_from(
+    &token->location,
+    lexer->previous_line,
+    lexer->previous_column,
+    lexer->current_line,
+    lexer->current_column
+  );
 
   lexer->previous_line = lexer->current_line;
   lexer->previous_column = lexer->current_column;
@@ -84,7 +89,7 @@ const char* token_type_to_string(const token_type_T type) {
 
 char* token_to_string(const token_T* token) {
   const char* type_string = token_type_to_string(token->type);
-  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%d, %d] start=(%d:%d) end=(%d:%d)>";
+  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%u, %u] start=(%u:%u) end=(%u:%u)>";
 
   char* string = calloc(strlen(type_string) + strlen(template) + strlen(token->value) + 16, sizeof(char));
   char* escaped;
@@ -100,12 +105,12 @@ char* token_to_string(const token_T* token) {
     template,
     type_string,
     escaped,
-    token->range->from,
-    token->range->to,
-    token->location->start->line,
-    token->location->start->column,
-    token->location->end->line,
-    token->location->end->column
+    token->range.from,
+    token->range.to,
+    token->location.start.line,
+    token->location.start.column,
+    token->location.end.line,
+    token->location.end.column
   );
 
   free(escaped);
@@ -113,42 +118,6 @@ char* token_to_string(const token_T* token) {
   return string;
 }
 
-char* token_to_json(const token_T* token) {
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "type", token_type_to_string(token->type));
-  json_add_string(&json, "value", token->value);
-
-  buffer_T range = buffer_new();
-  json_start_array(&json, "range");
-  json_add_size_t(&range, NULL, token->range->from);
-  json_add_size_t(&range, NULL, token->range->to);
-  buffer_concat(&json, &range);
-  buffer_free(&range);
-  json_end_array(&json);
-
-  buffer_T start = buffer_new();
-  json_start_object(&json, "start");
-  json_add_size_t(&start, "line", token->location->start->line);
-  json_add_size_t(&start, "column", token->location->start->column);
-  buffer_concat(&json, &start);
-  buffer_free(&start);
-  json_end_object(&json);
-
-  buffer_T end = buffer_new();
-  json_start_object(&json, "end");
-  json_add_size_t(&end, "line", token->location->end->line);
-  json_add_size_t(&end, "column", token->location->end->column);
-  buffer_concat(&json, &end);
-  buffer_free(&end);
-  json_end_object(&json);
-
-  json_end_object(&json);
-
-  return buffer_value(&json);
-}
-
 char* token_value(const token_T* token) {
   return token->value;
 }
@@ -157,14 +126,6 @@ int token_type(const token_T* token) {
   return token->type;
 }
 
-position_T* token_start_position(token_T* token) {
-  return token->location->start;
-}
-
-position_T* token_end_position(token_T* token) {
-  return token->location->end;
-}
-
 token_T* token_copy(token_T* token) {
   if (!token) { return NULL; }
 
@@ -184,8 +145,8 @@ token_T* token_copy(token_T* token) {
   }
 
   new_token->type = token->type;
-  new_token->range = range_copy(token->range);
-  new_token->location = location_copy(token->location);
+  new_token->range = token->range;
+  new_token->location = token->location;
 
   return new_token;
 }
@@ -194,8 +155,6 @@ void token_free(token_T* token) {
   if (!token) { return; }
 
   if (token->value != NULL) { free(token->value); }
-  if (token->range != NULL) { range_free(token->range); }
-  if (token->location != NULL) { location_free(token->location); }
 
   free(token);
 }
diff --git a/src/util.c b/src/util.c
index 94589917b..95b7f4cdc 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,118 +1,56 @@
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-int is_whitespace(const int character) {
-  return character == ' ' || character == '\t';
-}
-
-int is_newline(const int character) {
-  return character == 13 || character == 10;
-}
-
-int count_in_string(const char* string, const char character) {
-  int count = 0;
-
-  while (*string != '\0') {
-    if (*string == character) { count++; }
-
-    string++;
-  }
-
-  return count;
-}
-
-int count_newlines(const char* string) {
-  int count = 0;
-
-  while (*string) {
-    if (*string == '\r') {
-      count++;
-      if (*(string + 1) == '\n') { string++; }
-    } else if (*string == '\n') {
-      count++;
-    }
-
-    string++;
-  }
-
-  return count;
-}
-
-char* replace_char(char* string, const char find, const char replace) {
-  char* original_string = string;
-
-  while (*string != '\0') {
-    if (*string == find) { *string = replace; }
-
-    string++;
-  }
-
-  return original_string;
+int is_newline(int character) {
+  return character == '\n' || character == '\r';
 }
 
 char* escape_newlines(const char* input) {
-  char* output = calloc(strlen(input) * 2 + 1, sizeof(char));
-  char* orig_output = output;
-
-  while (*input) {
-    if (*input == '\n') {
-      *output++ = '\\';
-      *output++ = 'n';
-    } else if (*input == '\r') {
-      *output++ = '\\';
-      *output++ = 'r';
-    } else {
-      *output++ = *input;
+  hb_buffer_T buffer;
+
+  hb_buffer_init(&buffer, strlen(input));
+
+  for (size_t i = 0; i < strlen(input); ++i) {
+    switch (input[i]) {
+      case '\n': {
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'n');
+      } break;
+      case '\r': {
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'r');
+      } break;
+      default: {
+        hb_buffer_append_char(&buffer, input[i]);
+      }
     }
-
-    input++;
   }
 
-  *output = '\0';
-
-  return orig_output;
+  return buffer.value;
 }
 
-char* wrap_string(const char* input, const char character) {
-  if (input == NULL) { return NULL; }
-
-  const size_t length = strlen(input);
-  char* wrapped = malloc(length + 3);
+static hb_string_T wrap_string(hb_string_T input, char character) {
+  hb_buffer_T buffer;
 
-  if (wrapped == NULL) { return NULL; }
+  hb_buffer_init(&buffer, input.length + 2);
 
-  wrapped[0] = character;
-  strcpy(wrapped + 1, input);
-  wrapped[length + 1] = character;
-  wrapped[length + 2] = '\0';
+  hb_buffer_append_char(&buffer, character);
+  hb_buffer_append_string(&buffer, input);
+  hb_buffer_append_char(&buffer, character);
 
-  return wrapped;
+  return hb_string(buffer.value);
 }
 
-char* quoted_string(const char* input) {
+hb_string_T quoted_string(hb_string_T input) {
   return wrap_string(input, '"');
 }
 
-// Check if a string is blank (NULL, empty, or only contains whitespace)
-bool string_blank(const char* input) {
-  if (input == NULL || input[0] == '\0') { return true; }
-
-  for (const char* p = input; *p != '\0'; p++) {
-    if (!isspace(*p)) { return false; }
-  }
-
-  return true;
-}
-
-// Check if a string is present (not blank)
-bool string_present(const char* input) {
-  return !string_blank(input);
-}
-
 char* herb_strdup(const char* s) {
   size_t len = strlen(s) + 1;
   char* copy = malloc(len);
@@ -121,10 +59,3 @@ char* herb_strdup(const char* s) {
 
   return copy;
 }
-
-char* size_t_to_string(const size_t value) {
-  char* buffer = malloc(21);
-  snprintf(buffer, 21, "%zu", value);
-
-  return buffer;
-}
diff --git a/src/util/hb_arena.c b/src/util/hb_arena.c
new file mode 100644
index 000000000..3eb0e70a0
--- /dev/null
+++ b/src/util/hb_arena.c
@@ -0,0 +1,62 @@
+#ifdef __linux__
+#define _GNU_SOURCE
+#endif
+
+#include "../include/util/hb_arena.h"
+
+#include <stdbool.h>
+#include <sys/mman.h>
+
+#define KB(kb) (1024 * kb)
+#define MB(mb) (1024 * KB(mb))
+
+bool hb_arena_init(hb_arena_T* allocator, size_t size) {
+  allocator->memory = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+  if (allocator->memory == MAP_FAILED) {
+    allocator->memory = NULL;
+    allocator->position = 0;
+    allocator->capacity = 0;
+
+    return false;
+  }
+
+  allocator->position = 0;
+  allocator->capacity = size;
+
+  return true;
+}
+
+void* hb_arena_alloc(hb_arena_T* allocator, size_t size) {
+  size_t required_size = ((size + 7) / 8) * 8; // rounds up to the next 8 bytes
+
+  if (allocator->position + required_size > allocator->capacity) { return NULL; }
+
+  size_t offset = allocator->position;
+  void* ptr = &allocator->memory[offset];
+  allocator->position += required_size;
+
+  return ptr;
+}
+
+size_t hb_arena_position(hb_arena_T* allocator) {
+  return allocator->position;
+}
+
+void hb_arena_reset(hb_arena_T* allocator) {
+  allocator->position = 0;
+}
+
+void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position) {
+  if (new_position <= allocator->capacity) { allocator->position = new_position; }
+}
+
+void hb_arena_free(hb_arena_T* allocator) {
+  if (allocator->memory != NULL) {
+    munmap(allocator->memory, allocator->capacity);
+
+    allocator->memory = NULL;
+    allocator->position = 0;
+    allocator->capacity = 0;
+  }
+}
diff --git a/src/array.c b/src/util/hb_array.c
similarity index 61%
rename from src/array.c
rename to src/util/hb_array.c
index cd3210b8f..4d3c26b24 100644
--- a/src/array.c
+++ b/src/util/hb_array.c
@@ -1,20 +1,19 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/macros.h"
-#include "include/memory.h"
+#include "../include/macros.h"
+#include "../include/util/hb_array.h"
 
-size_t array_sizeof(void) {
-  return sizeof(array_T);
+size_t hb_array_sizeof(void) {
+  return sizeof(hb_array_T);
 }
 
-array_T* array_init(const size_t capacity) {
-  array_T* array = safe_malloc(array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity) {
+  hb_array_T* array = malloc(hb_array_sizeof());
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = nullable_safe_malloc(sizeof(void*) * capacity);
+  array->items = malloc(capacity * sizeof(void*));
 
   if (!array->items) {
     free(array);
@@ -24,7 +23,7 @@ array_T* array_init(const size_t capacity) {
   return array;
 }
 
-void array_append(array_T* array, void* item) {
+void hb_array_append(hb_array_T* array, void* item) {
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -45,7 +44,7 @@ void array_append(array_T* array, void* item) {
     }
 
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = safe_realloc(array->items, new_size_bytes);
+    void* new_items = realloc(array->items, new_size_bytes);
 
     if (unlikely(new_items == NULL)) { return; }
 
@@ -57,29 +56,29 @@ void array_append(array_T* array, void* item) {
   array->size++;
 }
 
-void* array_get(const array_T* array, const size_t index) {
+void* hb_array_get(const hb_array_T* array, const size_t index) {
   if (index >= array->size) { return NULL; }
 
   return array->items[index];
 }
 
-void* array_first(array_T* array) {
+void* hb_array_first(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[0];
 }
 
-void* array_last(array_T* array) {
+void* hb_array_last(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[array->size - 1];
 }
 
-void array_set(const array_T* array, const size_t index, void* item) {
+void hb_array_set(const hb_array_T* array, const size_t index, void* item) {
   if (index >= array->size) { return; }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T* array, const size_t index) {
+void hb_array_remove(hb_array_T* array, const size_t index) {
   if (index >= array->size) { return; }
 
   for (size_t i = index; i < array->size - 1; i++) {
@@ -89,7 +88,7 @@ void array_remove(array_T* array, const size_t index) {
   array->size--;
 }
 
-size_t array_index_of(array_T* array, void* item) {
+size_t hb_array_index_of(hb_array_T* array, void* item) {
   for (size_t i = 0; i < array->size; i++) {
     if (array->items[i] == item) { return i; }
   }
@@ -97,37 +96,37 @@ size_t array_index_of(array_T* array, void* item) {
   return SIZE_MAX;
 }
 
-void array_remove_item(array_T* array, void* item) {
-  size_t index = array_index_of(array, item);
+void hb_array_remove_item(hb_array_T* array, void* item) {
+  size_t index = hb_array_index_of(array, item);
 
-  if (index != SIZE_MAX) { array_remove(array, index); }
+  if (index != SIZE_MAX) { hb_array_remove(array, index); }
 }
 
-// Alias for array_append
-void array_push(array_T* array, void* item) {
-  array_append(array, item);
+// Alias for hb_array_append
+void hb_array_push(hb_array_T* array, void* item) {
+  hb_array_append(array, item);
 }
 
-void* array_pop(array_T* array) {
+void* hb_array_pop(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
 
-  void* last_item = array_last(array);
+  void* last_item = hb_array_last(array);
   array->size--;
 
   return last_item;
 }
 
-size_t array_size(const array_T* array) {
+size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 
   return array->size;
 }
 
-size_t array_capacity(const array_T* array) {
+size_t hb_array_capacity(const hb_array_T* array) {
   return array->capacity;
 }
 
-void array_free(array_T** array) {
+void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
   free((*array)->items);
diff --git a/src/util/hb_buffer.c b/src/util/hb_buffer.c
new file mode 100644
index 000000000..34eae2c91
--- /dev/null
+++ b/src/util/hb_buffer.c
@@ -0,0 +1,203 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../include/macros.h"
+#include "../include/util.h"
+#include "../include/util/hb_buffer.h"
+
+static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
+  return (buffer->length + required_length <= buffer->capacity);
+}
+
+/**
+ * Resizes the capacity of the buffer to the specified new capacity.
+ *
+ * @param buffer The buffer to resize
+ * @param new_capacity The new capacity to resize the buffer to
+ * @return true if capacity was resized, false if reallocation failed
+ */
+static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
+  if (new_capacity + 1 >= SIZE_MAX) {
+    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
+    exit(1);
+  }
+
+  char* new_value = realloc(buffer->value, new_capacity + 1);
+
+  if (unlikely(new_value == NULL)) {
+    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
+    exit(1);
+  }
+
+  buffer->value = new_value;
+  buffer->capacity = new_capacity;
+
+  return true;
+}
+
+/**
+ * Expands the capacity of the buffer if needed to accommodate additional content.
+ * This function is a convenience function that calls hb_buffer_has_capacity and
+ * hb_buffer_expand_capacity.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @param required_length The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
+ */
+static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_length) {
+  if (hb_buffer_has_capacity(buffer, required_length)) { return true; }
+
+  bool should_double_capacity = required_length < buffer->capacity;
+  size_t new_capacity = 0;
+
+  if (should_double_capacity) {
+    new_capacity = buffer->capacity * 2;
+  } else {
+    new_capacity = buffer->capacity + (required_length * 2);
+  }
+
+  return hb_buffer_resize(buffer, new_capacity);
+}
+
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
+  buffer->capacity = capacity;
+  buffer->length = 0;
+  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
+
+  if (!buffer->value) {
+    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
+
+    return false;
+  }
+
+  buffer->value[0] = '\0';
+
+  return true;
+}
+
+char* hb_buffer_value(const hb_buffer_T* buffer) {
+  return buffer->value;
+}
+
+size_t hb_buffer_length(const hb_buffer_T* buffer) {
+  return buffer->length;
+}
+
+size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
+  return buffer->capacity;
+}
+
+size_t hb_buffer_sizeof(void) {
+  return sizeof(hb_buffer_T);
+}
+
+/**
+ * Appends a null-terminated string to the buffer.
+ * @note This function requires that 'text' is a properly null-terminated string.
+ * When reading data from files or other non-string sources, ensure the data is
+ * null-terminated before calling this function, or use hb_buffer_append_with_length instead.
+ *
+ * @param buffer The buffer to append to
+ * @param text A null-terminated string to append
+ * @return void
+ */
+void hb_buffer_append(hb_buffer_T* buffer, const char* text) {
+  if (!buffer || !text) { return; }
+  if (text[0] == '\0') { return; }
+
+  size_t text_length = strlen(text);
+
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
+
+  memcpy(buffer->value + buffer->length, text, text_length);
+  buffer->length += text_length;
+  buffer->value[buffer->length] = '\0';
+}
+
+/**
+ * Appends a string of specified length to the buffer.
+ * Unlike hb_buffer_append(), this function does not require the text to be
+ * null-terminated as it uses the provided length instead of strlen().
+ * This is particularly useful when working with data from files, network
+ * buffers, or other non-null-terminated sources.
+ *
+ * @param buffer The buffer to append to
+ * @param text The text to append (doesn't need to be null-terminated)
+ * @param length The number of bytes to append from text
+ * @return void
+ */
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, const size_t length) {
+  if (!buffer || !text || length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
+
+  memcpy(buffer->value + buffer->length, text, length);
+
+  buffer->length += length;
+  buffer->value[buffer->length] = '\0';
+}
+
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string) {
+  if (!hb_string_is_empty(string)) { hb_buffer_append_with_length(buffer, string.data, string.length); }
+}
+
+void hb_buffer_append_char(hb_buffer_T* buffer, const char character) {
+  static char string[2];
+
+  string[0] = character;
+  string[1] = '\0';
+
+  hb_buffer_append(buffer, string);
+}
+
+static void hb_buffer_append_repeated(hb_buffer_T* buffer, const char character, size_t length) {
+  if (!buffer || length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
+
+  memset(buffer->value + buffer->length, character, length);
+
+  buffer->length += length;
+  buffer->value[buffer->length] = '\0';
+}
+
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, const size_t length) {
+  hb_buffer_append_repeated(buffer, ' ', length);
+}
+
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text) {
+  if (!buffer || !text) { return; }
+  if (text[0] == '\0') { return; }
+
+  size_t text_length = strlen(text);
+
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
+
+  memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
+  memcpy(buffer->value, text, text_length);
+
+  buffer->length += text_length;
+}
+
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
+  if (source->length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(destination, source->length)) { return; }
+
+  memcpy(destination->value + destination->length, source->value, source->length);
+
+  destination->length += source->length;
+  destination->value[destination->length] = '\0';
+}
+
+void hb_buffer_clear(hb_buffer_T* buffer) {
+  buffer->length = 0;
+  buffer->value[0] = '\0';
+}
+
+void hb_buffer_free(hb_buffer_T** buffer) {
+  if (!buffer || !*buffer) { return; }
+
+  if ((*buffer)->value != NULL) { free((*buffer)->value); }
+
+  free(*buffer);
+  *buffer = NULL;
+}
diff --git a/src/util/hb_string.c b/src/util/hb_string.c
new file mode 100644
index 000000000..b348ef7e6
--- /dev/null
+++ b/src/util/hb_string.c
@@ -0,0 +1,63 @@
+#include "../include/util/hb_string.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+hb_string_T hb_string(const char* null_terminated_c_string) {
+  hb_string_T string;
+
+  string.data = (char*) null_terminated_c_string;
+  string.length = (uint32_t) strlen(null_terminated_c_string);
+
+  return string;
+}
+
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
+  hb_string_T slice;
+  if (string.length < offset) {
+    slice.data = NULL;
+    slice.length = 0;
+
+    return slice;
+  }
+
+  slice.data = string.data + offset;
+  slice.length = string.length - offset;
+
+  return slice;
+}
+
+bool hb_string_equals(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncasecmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix) {
+  if (hb_string_is_empty(string) || hb_string_is_empty(expected_prefix)) { return false; }
+  if (string.length < expected_prefix.length) { return false; }
+
+  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+}
+
+bool hb_string_is_empty(hb_string_T string) {
+  return string.length == 0;
+}
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string) {
+  size_t string_length_in_bytes = sizeof(char) * (string.length);
+  char* buffer = hb_arena_alloc(allocator, string_length_in_bytes + sizeof(char) * 1);
+
+  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+
+  buffer[string_length_in_bytes] = '\0';
+
+  return buffer;
+}
diff --git a/templates/ext/herb/error_helpers.c.erb b/templates/ext/herb/error_helpers.c.erb
index 5771a91eb..7ededea6d 100644
--- a/templates/ext/herb/error_helpers.c.erb
+++ b/templates/ext/herb/error_helpers.c.erb
@@ -67,12 +67,12 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
   return Qnil;
 }
 
-VALUE rb_errors_array_from_c_array(array_T* array) {
+VALUE rb_errors_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child_node = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child_node = (ERROR_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_error_from_c_struct(child_node);
diff --git a/templates/ext/herb/error_helpers.h.erb b/templates/ext/herb/error_helpers.h.erb
index d30be39ae..3a7a88c47 100644
--- a/templates/ext/herb/error_helpers.h.erb
+++ b/templates/ext/herb/error_helpers.h.erb
@@ -7,6 +7,6 @@
 #include <ruby.h>
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
-VALUE rb_errors_array_from_c_array(array_T* array);
+VALUE rb_errors_array_from_c_array(hb_array_T* array);
 
 #endif
diff --git a/templates/ext/herb/nodes.c.erb b/templates/ext/herb/nodes.c.erb
index 5fd5d677f..a778196c1 100644
--- a/templates/ext/herb/nodes.c.erb
+++ b/templates/ext/herb/nodes.c.erb
@@ -9,7 +9,7 @@
 #include "../../src/include/token.h"
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node);
-static VALUE rb_nodes_array_from_c_array(array_T* array);
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>) {
@@ -72,12 +72,12 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
   return Qnil;
 }
 
-static VALUE rb_nodes_array_from_c_array(array_T* array) {
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_node_from_c_struct(child_node);
diff --git a/templates/javascript/packages/core/src/visitor.ts.erb b/templates/javascript/packages/core/src/visitor.ts.erb
index 47a7cfade..f38a060fc 100644
--- a/templates/javascript/packages/core/src/visitor.ts.erb
+++ b/templates/javascript/packages/core/src/visitor.ts.erb
@@ -1,11 +1,27 @@
 import {
   Node,
+  ERBNode,
   <%- nodes.each do |node| -%>
   <%= node.name %>,
   <%- end -%>
 } from "./nodes.js"
 
-export class Visitor {
+/**
+ * Interface that enforces all node visit methods are implemented
+ * This ensures that any class implementing IVisitor must have a visit method for every node type
+ */
+export interface IVisitor {
+  visit(node: Node | null | undefined): void
+  visitAll(nodes: (Node | null | undefined)[]): void
+  visitChildNodes(node: Node): void
+  <%- nodes.each do |node| -%>
+  visit<%= node.name %>(node: <%= node.name %>): void
+  <%- end -%>
+  visitNode(node: Node): void
+  visitERBNode(node: ERBNode): void
+}
+
+export class Visitor implements IVisitor {
   visit(node: Node | null | undefined): void {
     if (!node) return
 
@@ -20,8 +36,20 @@ export class Visitor {
     node.compactChildNodes().forEach(node => node.accept(this))
   }
 
+  visitNode(_node: Node): void {
+    // Default implementation does nothing
+  }
+
+  visitERBNode(_node: ERBNode): void {
+    // Default implementation does nothing
+  }
+
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
+    this.visitNode(node)
+    <%- if node.name.start_with?("ERB") -%>
+    this.visitERBNode(node)
+    <%- end -%>
     this.visitChildNodes(node)
   }
 
diff --git a/templates/javascript/packages/node/extension/error_helpers.cpp.erb b/templates/javascript/packages/node/extension/error_helpers.cpp.erb
index 390848a22..712960efe 100644
--- a/templates/javascript/packages/node/extension/error_helpers.cpp.erb
+++ b/templates/javascript/packages/node/extension/error_helpers.cpp.erb
@@ -4,16 +4,16 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
-#include "../extension/libherb/include/errors.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/errors.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>) {
@@ -75,13 +75,13 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
 
 <%- end -%>
 
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array) {
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
       if (error) {
         napi_value js_error = ErrorFromCStruct(env, error);
         napi_set_element(env, result, i, js_error);
diff --git a/templates/javascript/packages/node/extension/error_helpers.h.erb b/templates/javascript/packages/node/extension/error_helpers.h.erb
index 003dd4a40..c10df4fec 100644
--- a/templates/javascript/packages/node/extension/error_helpers.h.erb
+++ b/templates/javascript/packages/node/extension/error_helpers.h.erb
@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>);
diff --git a/templates/javascript/packages/node/extension/nodes.cpp.erb b/templates/javascript/packages/node/extension/nodes.cpp.erb
index f5ecc95b7..a8de107df 100644
--- a/templates/javascript/packages/node/extension/nodes.cpp.erb
+++ b/templates/javascript/packages/node/extension/nodes.cpp.erb
@@ -4,15 +4,15 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>) {
@@ -73,13 +73,13 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
 }
 <%- end -%>
 
-napi_value NodesArrayFromCArray(napi_env env, array_T* array) {
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
         napi_value js_child = NodeFromCStruct(env, child_node);
         napi_set_element(env, result, i, js_child);
diff --git a/templates/javascript/packages/node/extension/nodes.h.erb b/templates/javascript/packages/node/extension/nodes.h.erb
index 1f83989df..78f97c849 100644
--- a/templates/javascript/packages/node/extension/nodes.h.erb
+++ b/templates/javascript/packages/node/extension/nodes.h.erb
@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>);
diff --git a/templates/src/ast_nodes.c.erb b/templates/src/ast_nodes.c.erb
index c89debea1..658bf5061 100644
--- a/templates/src/ast_nodes.c.erb
+++ b/templates/src/ast_nodes.c.erb
@@ -4,16 +4,16 @@
 #include <prism.h>
 
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
   <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
@@ -73,16 +73,14 @@ void ast_free_base_node(AST_NODE_T* node) {
   if (node == NULL) { return; }
 
   if (node->errors) {
-    for (size_t i = 0; i < array_size(node->errors); i++) {
-      ERROR_T* child = array_get(node->errors, i);
+    for (size_t i = 0; i < hb_array_size(node->errors); i++) {
+      ERROR_T* child = hb_array_get(node->errors, i);
       if (child != NULL) { error_free(child); }
     }
 
-    array_free(&node->errors);
+    hb_array_free(&node->errors);
   }
 
-  if (node->location) { location_free(node->location); }
-
   free(node);
 }
 
@@ -101,12 +99,12 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
-    for (size_t i = 0; i < array_size(<%= node.human %>-><%= field.name %>); i++) {
-      AST_NODE_T* child = array_get(<%= node.human %>-><%= field.name %>, i);
+    for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
+      AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
       if (child) { ast_node_free(child); }
     }
 
-    array_free(&<%= node.human %>-><%= field.name %>);
+    hb_array_free(&<%= node.human %>-><%= field.name %>);
   }
   <%- when Herb::Template::StringField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) { free((char*) <%= node.human %>-><%= field.name %>); }
diff --git a/templates/src/ast_pretty_print.c.erb b/templates/src/ast_pretty_print.c.erb
index 845ab35bb..78e371937 100644
--- a/templates/src/ast_pretty_print.c.erb
+++ b/templates/src/ast_pretty_print.c.erb
@@ -1,27 +1,27 @@
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/pretty_print.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 
-void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!node) { return; }
 
   bool print_location = true;
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, ast_node_human_type(node));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, ast_node_human_type(node));
+  hb_buffer_append(buffer, " ");
 
   if (print_location) { pretty_print_location(node->location, buffer); }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
   switch (node->type) {
     <%- nodes.each do |node| -%>
@@ -49,16 +49,16 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
 
       if (<%= node.human %>-><%= field.name %>) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) <%= node.human %>-><%= field.name %>, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
@@ -79,12 +79,12 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
         pretty_print_boolean_property("unless_node", <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
       } else {
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
 
       <%- when Herb::Template::VoidPointerField -%>
       pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-      buffer_append(buffer, " ?\n");
+      hb_buffer_append(buffer, " ?\n");
 
       <%- else -%>
       <%= field.inspect %>
diff --git a/templates/src/errors.c.erb b/templates/src/errors.c.erb
index a3336a711..1c8e1408c 100644
--- a/templates/src/errors.c.erb
+++ b/templates/src/errors.c.erb
@@ -1,10 +1,10 @@
-#include "include/array.h"
 #include "include/errors.h"
 #include "include/location.h"
 #include "include/position.h"
 #include "include/pretty_print.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -17,15 +17,16 @@ size_t error_sizeof(void) {
   return sizeof(struct ERROR_STRUCT);
 }
 
-void error_init(ERROR_T* error, const error_type_T type, position_T* start, position_T* end) {
+void error_init(ERROR_T* error, const error_type_T type, position_T start, position_T end) {
   if (!error) { return; }
 
   error->type = type;
-  error->location = location_init(position_copy(start), position_copy(end));
+  error->location.start = start;
+  error->location.end = end;
 }
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
   <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
@@ -72,7 +73,7 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   <%- error.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  <%= error.human %>-><%= field.name %> = position_copy(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::TokenField -%>
   <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
   <%- when Herb::Template::TokenTypeField -%>
@@ -88,8 +89,8 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   return <%= error.human %>;
 }
 
-void append_<%= error.human %>(<%= (arguments + ["array_T* errors"]).join(", ") %>) {
-  array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
+void append_<%= error.human %>(<%= (arguments + ["hb_array_T* errors"]).join(", ") %>) {
+  hb_array_append(errors, <%= error.human %>_init(<%= arguments.map { |argument| argument.split(" ").last.strip }.join(", ") %>));
 }
 <%- end -%>
 
@@ -116,7 +117,6 @@ const char* error_human_type(ERROR_T* error) {
 void error_free_base_error(ERROR_T* error) {
   if (error == NULL) { return; }
 
-  if (error->location != NULL) { location_free(error->location); }
   if (error->message != NULL) { free(error->message); }
 
   free(error);
@@ -130,8 +130,6 @@ static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.hu
   <%- end -%>
   <%- error.fields.each do |field| -%>
   <%- case field -%>
-  <%- when Herb::Template::PositionField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { position_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenField -%>
   if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenTypeField -%>
@@ -160,8 +158,8 @@ void error_free(ERROR_T* error) {
 }
 
 void error_pretty_print_array(
-  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
     pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
@@ -169,7 +167,7 @@ void error_pretty_print_array(
     return;
   }
 
-  if (array_size(array) == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
 
     return;
@@ -177,42 +175,42 @@ void error_pretty_print_array(
 
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  sprintf(count, "%zu", hb_array_size(array));
+  hb_buffer_append(buffer, count);
+  hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child = array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array_size(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }
 
 <%- errors.each do |error| -%>
-static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
   pretty_print_quoted_property("message", error->base.message, indent, relative_indent, <%= error.fields.none? %>, buffer);
   <%- error.fields.each_with_index do |field, index| -%>
@@ -234,7 +232,7 @@ static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* erro
 }
 
 <%- end -%>
-void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   switch (error->type) {
diff --git a/templates/src/include/ast_nodes.h.erb b/templates/src/include/ast_nodes.h.erb
index 9b6dca00f..9aad4ad94 100644
--- a/templates/src/include/ast_nodes.h.erb
+++ b/templates/src/include/ast_nodes.h.erb
@@ -4,13 +4,13 @@
 #include <stdbool.h>
 #include <prism.h>
 
-#include "array.h"
-#include "buffer.h"
-#include "position.h"
-#include "location.h"
-#include "token_struct.h"
 #include "analyzed_ruby.h"
 #include "element_source.h"
+#include "location.h"
+#include "position.h"
+#include "token_struct.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
 <%- nodes.each do |node| -%>
@@ -20,9 +20,9 @@ typedef enum {
 
 typedef struct AST_NODE_STRUCT {
   ast_node_type_T type;
-  location_T* location;
+  location_T location;
   // maybe a range too?
-  array_T* errors;
+  hb_array_T* errors;
 } AST_NODE_T;
 
 <%- nodes.each do |node| -%>
@@ -36,7 +36,7 @@ typedef struct <%= node.struct_name %> {
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T* start_position", "position_T* end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 
diff --git a/templates/src/include/ast_pretty_print.h.erb b/templates/src/include/ast_pretty_print.h.erb
index e0dc4052b..47f91aa13 100644
--- a/templates/src/include/ast_pretty_print.h.erb
+++ b/templates/src/include/ast_pretty_print.h.erb
@@ -2,13 +2,13 @@
 #define HERB_AST_PRETTY_PRINT_H
 
 #include "ast_nodes.h"
-#include "buffer.h"
+#include "util/hb_buffer.h"
 
 void ast_pretty_print_node(
   AST_NODE_T* node,
   size_t indent,
   size_t relative_indent,
-  buffer_T* buffer
+  hb_buffer_T* buffer
 );
 
 #endif
diff --git a/templates/src/include/errors.h.erb b/templates/src/include/errors.h.erb
index 1baca9430..4676c72d3 100644
--- a/templates/src/include/errors.h.erb
+++ b/templates/src/include/errors.h.erb
@@ -1,12 +1,12 @@
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
 
-#include "array.h"
-#include "buffer.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
 
 typedef enum {
 <%- errors.each do |error| -%>
@@ -16,7 +16,7 @@ typedef enum {
 
 typedef struct ERROR_STRUCT {
   error_type_T type;
-  location_T* location;
+  location_T location;
   char* message;
 } ERROR_T;
 
@@ -31,12 +31,12 @@ typedef struct {
 
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T* start", "position_T* end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
-void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
+void append_<%= error.human %>(<%= (arguments << "hb_array_T* errors").join(", ") %>);
 <%- end -%>
 
-void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
 size_t error_sizeof(void);
 error_type_T error_type(ERROR_T* error);
@@ -48,11 +48,11 @@ const char* error_human_type(ERROR_T* error);
 
 void error_free(ERROR_T* error);
 
-void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, hb_buffer_T* buffer);
 
 void error_pretty_print_array(
-  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  hb_buffer_T* buffer
 );
 
 #endif
diff --git a/templates/src/visitor.c.erb b/templates/src/visitor.c.erb
index 41a5afd55..ab20a5bfa 100644
--- a/templates/src/visitor.c.erb
+++ b/templates/src/visitor.c.erb
@@ -1,9 +1,9 @@
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/visitor.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
   if (visitor(node, data) && node != NULL) {
@@ -31,8 +31,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
       <%- when Herb::Template::ArrayField -%>
       if (<%= node.human %>-><%= field.name %> != NULL) {
-        for (size_t index = 0; index < array_size(<%= node.human %>-><%= field.name %>); index++) {
-          herb_visit_node(array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(<%= node.human %>-><%= field.name %>); index++) {
+          herb_visit_node(hb_array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
         }
       }
 
diff --git a/templates/template.rb b/templates/template.rb
index 4d5973703..64097371f 100755
--- a/templates/template.rb
+++ b/templates/template.rb
@@ -30,7 +30,7 @@ def ruby_type
       end
 
       def c_type
-        "array_T*"
+        "hb_array_T*"
       end
 
       def c_item_type
diff --git a/templates/wasm/error_helpers.cpp.erb b/templates/wasm/error_helpers.cpp.erb
index 427972a0f..7e0f43b7b 100644
--- a/templates/wasm/error_helpers.cpp.erb
+++ b/templates/wasm/error_helpers.cpp.erb
@@ -8,12 +8,12 @@
 #include "extension_helpers.h"
 
 extern "C" {
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
-#include "../src/include/errors.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/errors.h"
+#include "../src/include/herb.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 }
 
 using namespace emscripten;
@@ -21,9 +21,9 @@ using namespace emscripten;
 val CreateLocation(location_T* location);
 val CreateToken(token_T* token);
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 val ErrorFromCStruct(ERROR_T* error);
-val ErrorsArrayFromCArray(array_T* array);
+val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
@@ -61,13 +61,13 @@ val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
 
 <%- end -%>
 
-val ErrorsArrayFromCArray(array_T* array) {
+val ErrorsArrayFromCArray(hb_array_T* array) {
   val Array = val::global("Array");
   val result = Array.new_();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*)array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*)hb_array_get(array, i);
       if (error) {
         result.call<void>("push", ErrorFromCStruct(error));
       }
diff --git a/templates/wasm/error_helpers.h.erb b/templates/wasm/error_helpers.h.erb
index bfa8971d3..32f65cefb 100644
--- a/templates/wasm/error_helpers.h.erb
+++ b/templates/wasm/error_helpers.h.erb
@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val ErrorFromCStruct(ERROR_T* error);
-emscripten::val ErrorsArrayFromCArray(array_T* array);
+emscripten::val ErrorsArrayFromCArray(hb_array_T* array);
 
 <%- errors.each do |error| -%>
 emscripten::val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>);
diff --git a/templates/wasm/nodes.cpp.erb b/templates/wasm/nodes.cpp.erb
index 1580f22d4..d804a37c8 100644
--- a/templates/wasm/nodes.cpp.erb
+++ b/templates/wasm/nodes.cpp.erb
@@ -4,17 +4,17 @@
 #include "error_helpers.h"
 #include "extension_helpers.h"
 
-#include "../src/include/herb.h"
-#include "../src/include/token.h"
-#include "../src/include/array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
+#include "../src/include/herb.h"
 #include "../src/include/location.h"
+#include "../src/include/token.h"
+#include "../src/include/util/hb_array.h"
 
 using namespace emscripten;
 
 val NodeFromCStruct(AST_NODE_T* node);
-val NodesArrayFromCArray(array_T* array);
+val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
@@ -62,13 +62,13 @@ val NodeFromCStruct(AST_NODE_T* node) {
   }
 }
 
-val NodesArrayFromCArray(array_T* array) {
+val NodesArrayFromCArray(hb_array_T* array) {
   if (!array) return val::null();
 
   val jsArray = val::array();
 
-  for (size_t i = 0; i < array_size(array); i++) {
-    AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {
       jsArray.set(i, NodeFromCStruct(child_node));
diff --git a/templates/wasm/nodes.h.erb b/templates/wasm/nodes.h.erb
index a32c551ae..eeefc1177 100644
--- a/templates/wasm/nodes.h.erb
+++ b/templates/wasm/nodes.h.erb
@@ -6,7 +6,7 @@ extern "C" {
 }
 
 emscripten::val NodeFromCStruct(AST_NODE_T* node);
-emscripten::val NodesArrayFromCArray(array_T* array);
+emscripten::val NodesArrayFromCArray(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 emscripten::val <%= node.human %>NodeFromCStruct(<%= node.struct_type %>* <%= node.human %>);
diff --git a/test/analyze/case_in_test.rb b/test/analyze/case_in_test.rb
index a648ada19..8fb1a25ac 100644
--- a/test/analyze/case_in_test.rb
+++ b/test/analyze/case_in_test.rb
@@ -92,5 +92,41 @@ class CaseInTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "case in with block inside in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case result %>
+        <% in { status: :success } %>
+          <%= content_tag(:div) do %>
+            Success!
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case in with multiple blocks in in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case data %>
+        <% in { type: :alert } %>
+          <%= content_tag(:div) do %>
+            Alert
+          <% end %>
+          <%= content_tag(:span) do %>
+            Icon
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case in with if statement inside in clause" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case value %>
+        <% in [Integer] %>
+          <% if positive? %>
+            Positive
+          <% end %>
+        <% end %>
+      HTML
+    end
   end
 end
diff --git a/test/analyze/case_test.rb b/test/analyze/case_test.rb
index 8a7d2b538..a4b7bf5d4 100644
--- a/test/analyze/case_test.rb
+++ b/test/analyze/case_test.rb
@@ -90,5 +90,78 @@ class CaseTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "case with block inside when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case 1 %>
+        <% when 1 %>
+          <%= content_tag(:p) do %>
+            Yep
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with multiple blocks in when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case status %>
+        <% when :active %>
+          <%= content_tag(:div) do %>
+            Active
+          <% end %>
+          <%= content_tag(:span) do %>
+            Badge
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with nested blocks in when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case level %>
+        <% when 1 %>
+          <%= content_tag(:div) do %>
+            <%= content_tag(:p) do %>
+              Nested
+            <% end %>
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with block in multiple when clauses" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case type %>
+        <% when :a %>
+          <%= form_for(obj) do |f| %>
+            Form A
+          <% end %>
+        <% when :b %>
+          <%= form_for(obj) do |f| %>
+            Form B
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with if statement inside when" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case status %>
+        <% when :active %>
+          <% if admin? %>
+            Admin view
+          <% end %>
+        <% end %>
+      HTML
+    end
+
+    test "case with yield" do
+      assert_parsed_snapshot(<<~HTML)
+        <% case yield(:a) %>
+        <% when 'a' %>
+          aaa
+        <% end %>
+      HTML
+    end
   end
 end
diff --git a/test/c/main.c b/test/c/main.c
index c61106da6..ef4238806 100644
--- a/test/c/main.c
+++ b/test/c/main.c
@@ -1,12 +1,13 @@
 #include <check.h>
 #include <stdlib.h>
 
-TCase *array_tests(void);
-TCase *buffer_tests(void);
+TCase *hb_arena_tests(void);
+TCase *hb_array_tests(void);
+TCase *hb_buffer_tests(void);
+TCase *hb_string_tests(void);
 TCase *herb_tests(void);
 TCase *html_util_tests(void);
 TCase *io_tests(void);
-TCase *json_tests(void);
 TCase *lex_tests(void);
 TCase *token_tests(void);
 TCase *util_tests(void);
@@ -14,12 +15,13 @@ TCase *util_tests(void);
 Suite *herb_suite(void) {
   Suite *suite = suite_create("Herb Suite");
 
-  suite_add_tcase(suite, array_tests());
-  suite_add_tcase(suite, buffer_tests());
+  suite_add_tcase(suite, hb_arena_tests());
+  suite_add_tcase(suite, hb_array_tests());
+  suite_add_tcase(suite, hb_buffer_tests());
+  suite_add_tcase(suite, hb_string_tests());
   suite_add_tcase(suite, herb_tests());
   suite_add_tcase(suite, html_util_tests());
   suite_add_tcase(suite, io_tests());
-  suite_add_tcase(suite, json_tests());
   suite_add_tcase(suite, lex_tests());
   suite_add_tcase(suite, token_tests());
   suite_add_tcase(suite, util_tests());
diff --git a/test/c/test_array.c b/test/c/test_array.c
deleted file mode 100644
index 5473d76fc..000000000
--- a/test/c/test_array.c
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "include/test.h"
-#include "../../src/include/array.h"
-
-// Test array initialization
-TEST(test_array_init)
-  array_T* array = array_init(10);
-
-  ck_assert_ptr_nonnull(array);
-  ck_assert_int_eq(array->size, 0);
-  ck_assert_int_eq(array->capacity, 10);
-  ck_assert_ptr_nonnull(array->items);
-
-  array_free(&array);
-END
-
-// Test array appending
-TEST(test_array_append)
-  array_T* array = array_init(2);
-
-  size_t item1 = 42, item2 = 99, item3 = 100;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  ck_assert_int_eq(array->size, 2);
-  ck_assert_int_eq(array->capacity, 2);
-  ck_assert_ptr_eq(array->items[0], &item1);
-  ck_assert_ptr_eq(array->items[1], &item2);
-
-  // Trigger reallocation
-  array_append(array, &item3);
-  ck_assert_int_eq(array->size, 3);
-  ck_assert_int_eq(array->capacity, 4);
-
-  array_free(&array);
-END
-
-// Test getting elements
-TEST(test_array_get)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  ck_assert_ptr_eq(array_get(array, 0), &item1);
-  ck_assert_ptr_eq(array_get(array, 1), &item2);
-  ck_assert_ptr_null(array_get(array, 2)); // Out of bounds check
-
-  array_free(&array);
-END
-
-// Test setting elements
-TEST(test_array_set)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99;
-  array_append(array, &item1);
-  array_append(array, &item2);
-
-  size_t new_item = 77;
-  array_set(array, 1, &new_item);
-
-  ck_assert_ptr_eq(array_get(array, 1), &new_item);
-
-  array_free(&array);
-END
-
-// Test removing elements
-TEST(test_array_remove)
-  array_T* array = array_init(3);
-
-  size_t item1 = 42, item2 = 99, item3 = 100;
-  array_append(array, &item1);
-  array_append(array, &item2);
-  array_append(array, &item3);
-
-  array_remove(array, 1); // Remove item2
-  ck_assert_int_eq(array->size, 2);
-  ck_assert_ptr_eq(array_get(array, 0), &item1);
-  ck_assert_ptr_eq(array_get(array, 1), &item3); // Shifted left
-
-  array_free(&array);
-END
-
-// Test freeing the array
-TEST(test_array_free)
-  array_T* array = array_init(5);
-  array_free(&array);
-
-  ck_assert_ptr_null(array);
-END
-
-// Register test cases
-TCase *array_tests(void) {
-  TCase *array = tcase_create("Array");
-
-  tcase_add_test(array, test_array_init);
-  tcase_add_test(array, test_array_append);
-  tcase_add_test(array, test_array_get);
-  tcase_add_test(array, test_array_set);
-  tcase_add_test(array, test_array_remove);
-  tcase_add_test(array, test_array_free);
-
-  return array;
-}
diff --git a/test/c/test_buffer.c b/test/c/test_buffer.c
deleted file mode 100644
index 27d7b8609..000000000
--- a/test/c/test_buffer.c
+++ /dev/null
@@ -1,241 +0,0 @@
-#include "include/test.h"
-#include "../../src/include/buffer.h"
-
-// Test buffer initialization
-TEST(test_buffer_init)
-  buffer_T buffer;
-
-  ck_assert(buffer_init(&buffer));
-  ck_assert_int_eq(buffer.capacity, 1024);
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_ptr_nonnull(buffer.value);
-  ck_assert_str_eq(buffer.value, "");
-
-  buffer_free(&buffer);
-END
-
-// Test appending text to buffer
-TEST(test_buffer_append)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_str_eq(buffer.value, "");
-
-  buffer_append(&buffer, "Hello");
-  ck_assert_str_eq(buffer.value, "Hello");
-  ck_assert_int_eq(buffer.length, 5);
-
-  buffer_append(&buffer, " World");
-  ck_assert_str_eq(buffer.value, "Hello World");
-  ck_assert_int_eq(buffer.length, 11);
-
-  buffer_free(&buffer);
-END
-
-// Test prepending text to buffer
-TEST(test_buffer_prepend)
-  buffer_T buffer = buffer_new();
-
-  buffer_append(&buffer, "World");
-  buffer_prepend(&buffer, "Hello ");
-  ck_assert_str_eq(buffer.value, "Hello World");
-  ck_assert_int_eq(buffer.length, 11);
-
-  buffer_free(&buffer);
-END
-
-// Test concatenating two buffers
-TEST(test_buffer_concat)
-  buffer_T buffer1 = buffer_new();
-  buffer_T buffer2 = buffer_new();
-
-  buffer_append(&buffer1, "Hello");
-  buffer_append(&buffer2, " World");
-
-  buffer_concat(&buffer1, &buffer2);
-  ck_assert_str_eq(buffer1.value, "Hello World");
-  ck_assert_int_eq(buffer1.length, 11);
-
-  buffer_free(&buffer1);
-  buffer_free(&buffer2);
-END
-
-// Test increating
-TEST(test_buffer_increase_capacity)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_increase_capacity(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1025);
-
-  ck_assert(buffer_increase_capacity(&buffer, 1024 + 1));
-  ck_assert_int_eq(buffer.capacity, 2050);
-
-  buffer_free(&buffer);
-END
-
-// Test expanding capacity
-TEST(test_buffer_expand_capacity)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(buffer_expand_capacity(&buffer));
-  ck_assert_int_eq(buffer.capacity, 8192);
-
-  buffer_free(&buffer);
-END
-
-// Test expanding if needed
-TEST(test_buffer_expand_if_needed)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1023));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1024));
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_expand_if_needed(&buffer, 1025));
-  ck_assert_int_eq(buffer.capacity, 3074); // initial capacity (1024) + (required (1025) * 2) = 3074
-
-  buffer_free(&buffer);
-END
-
-// Test resizing buffer
-TEST(test_buffer_resize)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  ck_assert(buffer_resize(&buffer, 2048));
-  ck_assert_int_eq(buffer.capacity, 2048);
-
-  ck_assert(buffer_resize(&buffer, 4096));
-  ck_assert_int_eq(buffer.capacity, 4096);
-
-  ck_assert(buffer_resize(&buffer, 8192));
-  ck_assert_int_eq(buffer.capacity, 8192);
-
-  buffer_free(&buffer);
-END
-
-// Test clearing buffer without freeing memory
-TEST(test_buffer_clear)
-  buffer_T buffer = buffer_new();
-
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  buffer_append(&buffer, "Hello");
-  ck_assert_str_eq(buffer.value, "Hello");
-  ck_assert_int_eq(buffer.length, 5);
-  ck_assert_int_eq(buffer.capacity, 1024);
-
-  buffer_clear(&buffer);
-
-  ck_assert_str_eq(buffer.value, "");
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_int_eq(buffer.capacity, 1024); // Capacity should remain unchanged
-
-  buffer_free(&buffer);
-END
-
-// Test freeing buffer
-TEST(test_buffer_free)
-  buffer_T buffer = buffer_new();
-
-  buffer_append(&buffer, "Test");
-  ck_assert_int_eq(buffer.length, 4);
-  ck_assert_int_eq(buffer.capacity, 1024);
-  buffer_free(&buffer);
-
-  ck_assert_ptr_null(buffer.value);
-  ck_assert_int_eq(buffer.length, 0);
-  ck_assert_int_eq(buffer.capacity, 0);
-END
-
-// Test buffer UTF-8 integrity
-TEST(test_buffer_utf8_integrity)
-  buffer_T buffer = buffer_new();
-
-  // UTF-8 String
-  const char *utf8_text = "こんにちは";
-  buffer_append(&buffer, utf8_text);
-
-  // Ensure length matches actual UTF-8 bytes
-  ck_assert_int_eq(buffer.length, strlen(utf8_text));
-  ck_assert_int_eq(buffer.length, 15);
-  ck_assert_str_eq(buffer.value, utf8_text);
-
-  buffer_free(&buffer);
-END
-
-// Test: Buffer Appending UTF-8 Characters
-TEST(test_buffer_append_utf8)
-  buffer_T buffer = buffer_new();
-
-  // Append UTF-8 string
-  buffer_append(&buffer, "こんにちは"); // "Hello" in Japanese
-  ck_assert_int_eq(strlen("こんにちは"), 15); // UTF-8 multibyte characters
-  ck_assert_int_eq(buffer_length(&buffer), 15);
-  ck_assert_str_eq(buffer_value(&buffer), "こんにちは");
-
-  buffer_free(&buffer);
-END
-
-// Test buffer length correctness
-TEST(test_buffer_length_correctness)
-  buffer_T buffer = buffer_new();
-
-  buffer_append(&buffer, "Short");
-  size_t length = buffer_length(&buffer);
-  ck_assert_int_eq(length, 5);
-
-  buffer_append(&buffer, "er test");
-  length = buffer_length(&buffer);
-  ck_assert_int_eq(length, 12);
-
-  buffer_free(&buffer);
-END
-
-// Test: Buffer Null-Termination
-TEST(test_buffer_null_termination)
-  buffer_T buffer = buffer_new();
-
-  buffer_append(&buffer, "Test");
-  ck_assert(buffer_value(&buffer)[buffer_length(&buffer)] == '\0'); // Ensure null termination
-
-  buffer_free(&buffer);
-END
-
-TCase *buffer_tests(void) {
-  TCase *buffer = tcase_create("Buffer");
-
-  tcase_add_test(buffer, test_buffer_init);
-  tcase_add_test(buffer, test_buffer_append);
-  tcase_add_test(buffer, test_buffer_prepend);
-  tcase_add_test(buffer, test_buffer_concat);
-  tcase_add_test(buffer, test_buffer_increase_capacity);
-  tcase_add_test(buffer, test_buffer_expand_capacity);
-  tcase_add_test(buffer, test_buffer_expand_if_needed);
-  tcase_add_test(buffer, test_buffer_resize);
-  tcase_add_test(buffer, test_buffer_clear);
-  tcase_add_test(buffer, test_buffer_free);
-  tcase_add_test(buffer, test_buffer_utf8_integrity);
-  tcase_add_test(buffer, test_buffer_append_utf8);
-  tcase_add_test(buffer, test_buffer_length_correctness);
-  tcase_add_test(buffer, test_buffer_null_termination);
-
-  return buffer;
-}
diff --git a/test/c/test_hb_arena.c b/test/c/test_hb_arena.c
new file mode 100644
index 000000000..4196dfe27
--- /dev/null
+++ b/test/c/test_hb_arena.c
@@ -0,0 +1,57 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_arena.h"
+
+// Test appending text to buffer
+TEST(test_arena_alloc)
+  hb_arena_T allocator;
+
+  hb_arena_init(&allocator, 1024);
+  ck_assert_int_eq(allocator.position, 0);
+  ck_assert_int_eq(allocator.capacity, 1024);
+
+  {
+    // Ensure memory is writable
+    char *memory = hb_arena_alloc(&allocator, 1);
+    *memory = 'a';
+  }
+
+  ck_assert(allocator.position % 8 == 0);
+  ck_assert_int_eq(allocator.position, 8);
+
+  char *memory = hb_arena_alloc(&allocator, allocator.capacity - allocator.position);
+  ck_assert_ptr_nonnull(memory);
+  ck_assert(allocator.position % 8 == 0);
+END
+
+TEST(test_arena_free)
+  hb_arena_T allocator;
+
+  {
+    hb_arena_init(&allocator, 1024);
+    hb_arena_free(&allocator);
+
+    ck_assert_ptr_null(allocator.memory);
+    ck_assert_int_eq(allocator.capacity, 0);
+    ck_assert_int_eq(allocator.position, 0);
+  }
+
+  {
+    hb_arena_init(&allocator, 1024);
+    hb_arena_free(&allocator);
+    hb_arena_free(&allocator);
+
+    ck_assert_ptr_null(allocator.memory);
+    ck_assert_int_eq(allocator.capacity, 0);
+    ck_assert_int_eq(allocator.position, 0);
+  }
+END
+
+
+TCase *hb_arena_tests(void) {
+  TCase *tags = tcase_create("arena");
+
+  tcase_add_test(tags, test_arena_alloc);
+  tcase_add_test(tags, test_arena_free);
+
+  return tags;
+}
diff --git a/test/c/test_hb_array.c b/test/c/test_hb_array.c
new file mode 100644
index 000000000..1abe357cc
--- /dev/null
+++ b/test/c/test_hb_array.c
@@ -0,0 +1,105 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_array.h"
+
+// Test array initialization
+TEST(test_hb_array_init)
+  hb_array_T* array = hb_array_init(10);
+
+  ck_assert_ptr_nonnull(array);
+  ck_assert_int_eq(array->size, 0);
+  ck_assert_int_eq(array->capacity, 10);
+  ck_assert_ptr_nonnull(array->items);
+
+  hb_array_free(&array);
+END
+
+// Test array appending
+TEST(test_hb_array_append)
+  hb_array_T* array = hb_array_init(2);
+
+  size_t item1 = 42, item2 = 99, item3 = 100;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  ck_assert_int_eq(array->size, 2);
+  ck_assert_int_eq(array->capacity, 2);
+  ck_assert_ptr_eq(array->items[0], &item1);
+  ck_assert_ptr_eq(array->items[1], &item2);
+
+  // Trigger reallocation
+  hb_array_append(array, &item3);
+  ck_assert_int_eq(array->size, 3);
+  ck_assert_int_eq(array->capacity, 4);
+
+  hb_array_free(&array);
+END
+
+// Test getting elements
+TEST(test_hb_array_get)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  ck_assert_ptr_eq(hb_array_get(array, 0), &item1);
+  ck_assert_ptr_eq(hb_array_get(array, 1), &item2);
+  ck_assert_ptr_null(hb_array_get(array, 2)); // Out of bounds check
+
+  hb_array_free(&array);
+END
+
+// Test setting elements
+TEST(test_hb_array_set)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+
+  size_t new_item = 77;
+  hb_array_set(array, 1, &new_item);
+
+  ck_assert_ptr_eq(hb_array_get(array, 1), &new_item);
+
+  hb_array_free(&array);
+END
+
+// Test removing elements
+TEST(test_hb_array_remove)
+  hb_array_T* array = hb_array_init(3);
+
+  size_t item1 = 42, item2 = 99, item3 = 100;
+  hb_array_append(array, &item1);
+  hb_array_append(array, &item2);
+  hb_array_append(array, &item3);
+
+  hb_array_remove(array, 1); // Remove item2
+  ck_assert_int_eq(array->size, 2);
+  ck_assert_ptr_eq(hb_array_get(array, 0), &item1);
+  ck_assert_ptr_eq(hb_array_get(array, 1), &item3); // Shifted left
+
+  hb_array_free(&array);
+END
+
+// Test freeing the array
+TEST(test_hb_array_free)
+  hb_array_T* array = hb_array_init(5);
+  hb_array_free(&array);
+
+  ck_assert_ptr_null(array);
+END
+
+// Register test cases
+TCase *hb_array_tests(void) {
+  TCase *array = tcase_create("Herb Array");
+
+  tcase_add_test(array, test_hb_array_init);
+  tcase_add_test(array, test_hb_array_append);
+  tcase_add_test(array, test_hb_array_get);
+  tcase_add_test(array, test_hb_array_set);
+  tcase_add_test(array, test_hb_array_remove);
+  tcase_add_test(array, test_hb_array_free);
+
+  return array;
+}
diff --git a/test/c/test_hb_buffer.c b/test/c/test_hb_buffer.c
new file mode 100644
index 000000000..a5f3f169d
--- /dev/null
+++ b/test/c/test_hb_buffer.c
@@ -0,0 +1,211 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_buffer.h"
+
+// Test buffer initialization
+TEST(test_hb_buffer_init)
+  hb_buffer_T buffer;
+
+  ck_assert(hb_buffer_init(&buffer, 1024));
+  ck_assert_int_eq(buffer.capacity, 1024);
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_ptr_nonnull(buffer.value);
+  ck_assert_str_eq(buffer.value, "");
+
+  free(buffer.value);
+END
+
+// Test appending text to buffer
+TEST(test_hb_buffer_append)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_str_eq(buffer.value, "");
+
+  hb_buffer_append(&buffer, "Hello");
+  ck_assert_str_eq(buffer.value, "Hello");
+  ck_assert_int_eq(buffer.length, 5);
+
+  hb_buffer_append(&buffer, " World");
+  ck_assert_str_eq(buffer.value, "Hello World");
+  ck_assert_int_eq(buffer.length, 11);
+
+  free(buffer.value);
+END
+
+// Test prepending text to buffer
+TEST(test_hb_buffer_prepend)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "World");
+  hb_buffer_prepend(&buffer, "Hello ");
+  ck_assert_str_eq(buffer.value, "Hello World");
+  ck_assert_int_eq(buffer.length, 11);
+
+  free(buffer.value);
+END
+
+// Test concatenating two buffers
+TEST(test_hb_buffer_concat)
+  hb_buffer_T buffer1;
+  hb_buffer_init(&buffer1, 1024);
+  hb_buffer_T buffer2;
+  hb_buffer_init(&buffer2, 1024);
+
+  hb_buffer_append(&buffer1, "Hello");
+  hb_buffer_append(&buffer2, " World");
+
+  hb_buffer_concat(&buffer1, &buffer2);
+  ck_assert_str_eq(buffer1.value, "Hello World");
+  ck_assert_int_eq(buffer1.length, 11);
+
+  free(buffer1.value);
+  free(buffer2.value);
+END
+
+// Test appending a string to the buffer
+TEST(test_hb_buffer_append_string)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1);
+
+  hb_buffer_append_string(&buffer, hb_string("Hello, world"));
+
+  ck_assert_str_eq(buffer.value, "Hello, world");
+  ck_assert_int_eq(buffer.length, 12);
+
+  free(buffer.value);
+END
+
+TEST(test_hb_buffer_resizing_behavior)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_append_whitespace(&buffer, 1023);
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_append_whitespace(&buffer, 2);
+  ck_assert_int_eq(buffer.capacity, 2048);
+
+  hb_buffer_append_whitespace(&buffer, 2048);
+  ck_assert_int_eq(buffer.capacity, 6144);
+
+  free(buffer.value);
+END
+
+// Test clearing buffer without freeing memory
+TEST(test_hb_buffer_clear)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_append(&buffer, "Hello");
+  ck_assert_str_eq(buffer.value, "Hello");
+  ck_assert_int_eq(buffer.length, 5);
+  ck_assert_int_eq(buffer.capacity, 1024);
+
+  hb_buffer_clear(&buffer);
+
+  ck_assert_str_eq(buffer.value, "");
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_int_eq(buffer.capacity, 1024); // Capacity should remain unchanged
+
+  free(buffer.value);
+END
+
+// Test freeing buffer
+TEST(test_hb_buffer_free)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Test");
+  ck_assert_int_eq(buffer.length, 4);
+  ck_assert_int_eq(buffer.capacity, 1024);
+  free(buffer.value);
+  buffer.value = NULL;
+  buffer.length = 0;
+  buffer.capacity = 0;
+
+  ck_assert_ptr_null(buffer.value);
+  ck_assert_int_eq(buffer.length, 0);
+  ck_assert_int_eq(buffer.capacity, 0);
+END
+
+// Test buffer UTF-8 integrity
+TEST(test_buffer_utf8_integrity)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  // UTF-8 String
+  const char *utf8_text = "こんにちは";
+  hb_buffer_append(&buffer, utf8_text);
+
+  // Ensure length matches actual UTF-8 bytes
+  ck_assert_int_eq(buffer.length, strlen(utf8_text));
+  ck_assert_int_eq(buffer.length, 15);
+  ck_assert_str_eq(buffer.value, utf8_text);
+
+  free(buffer.value);
+END
+
+// Test: Buffer Appending UTF-8 Characters
+TEST(test_hb_buffer_append_utf8)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  // Append UTF-8 string
+  hb_buffer_append(&buffer, "こんにちは"); // "Hello" in Japanese
+  ck_assert_int_eq(strlen("こんにちは"), 15); // UTF-8 multibyte characters
+  ck_assert_int_eq(hb_buffer_length(&buffer), 15);
+  ck_assert_str_eq(hb_buffer_value(&buffer), "こんにちは");
+
+  free(buffer.value);
+END
+
+// Test buffer length correctness
+TEST(test_hb_buffer_length_correctness)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Short");
+  size_t length = hb_buffer_length(&buffer);
+  ck_assert_int_eq(length, 5);
+
+  hb_buffer_append(&buffer, "er test");
+  length = hb_buffer_length(&buffer);
+  ck_assert_int_eq(length, 12);
+
+  free(buffer.value);
+END
+
+// Test: Buffer Null-Termination
+TEST(test_buffer_null_termination)
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 1024);
+
+  hb_buffer_append(&buffer, "Test");
+  ck_assert(hb_buffer_value(&buffer)[hb_buffer_length(&buffer)] == '\0'); // Ensure null termination
+
+  free(buffer.value);
+END
+
+TCase *hb_buffer_tests(void) {
+  TCase *buffer = tcase_create("Herb Buffer");
+
+  tcase_add_test(buffer, test_hb_buffer_init);
+  tcase_add_test(buffer, test_hb_buffer_append);
+  tcase_add_test(buffer, test_hb_buffer_prepend);
+  tcase_add_test(buffer, test_hb_buffer_concat);
+  tcase_add_test(buffer, test_hb_buffer_append_string);
+  tcase_add_test(buffer, test_hb_buffer_resizing_behavior);
+  tcase_add_test(buffer, test_hb_buffer_clear);
+  tcase_add_test(buffer, test_hb_buffer_free);
+  tcase_add_test(buffer, test_buffer_utf8_integrity);
+  tcase_add_test(buffer, test_hb_buffer_append_utf8);
+  tcase_add_test(buffer, test_hb_buffer_length_correctness);
+  tcase_add_test(buffer, test_buffer_null_termination);
+
+  return buffer;
+}
diff --git a/test/c/test_hb_string.c b/test/c/test_hb_string.c
new file mode 100644
index 000000000..70ef03270
--- /dev/null
+++ b/test/c/test_hb_string.c
@@ -0,0 +1,169 @@
+#include "include/test.h"
+#include "../../src/include/util/hb_string.h"
+#include <string.h>
+
+TEST(hb_string_equals_tests)
+  {
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, world.");
+
+    ck_assert(hb_string_equals(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, world. Longer text");
+
+    ck_assert(!hb_string_equals(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("");
+
+    ck_assert(!hb_string_equals(a, b));
+  }
+END
+
+TEST(hb_string_offset_based_slice_tests)
+  {
+    hb_string_T source = hb_string("01234");
+    hb_string_T expected_slice = hb_string("234");
+
+    hb_string_T slice = hb_string_slice(source, 2);
+
+    ck_assert(hb_string_equals(slice, expected_slice));
+  }
+
+  {
+    hb_string_T source = hb_string("01234");
+    hb_string_T expected_slice = hb_string("4");
+
+    hb_string_T slice = hb_string_slice(source, 4);
+
+    ck_assert(hb_string_equals(slice, expected_slice));
+  }
+
+  {
+    hb_string_T source = hb_string("01234");
+    hb_string_T slice = hb_string_slice(source, 5);
+
+    ck_assert(hb_string_is_empty(slice));
+  }
+
+  {
+    hb_string_T source = hb_string("01234");
+    hb_string_T slice = hb_string_slice(source, 6);
+
+    ck_assert(hb_string_is_empty(slice));
+  }
+END
+
+
+TEST(hb_string_equals_case_insensitive_tests)
+  {
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, World. Really?");
+
+    ck_assert(!hb_string_equals_case_insensitive(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string("Hello, world.");
+    hb_string_T b = hb_string("Hello, World.");
+
+    ck_assert(hb_string_equals_case_insensitive(a, b));
+  }
+
+  {
+    hb_string_T a = hb_string("This.");
+    hb_string_T b = hb_string("That.");
+
+    ck_assert(!hb_string_equals_case_insensitive(a, b));
+  }
+END
+
+TEST(hb_string_is_empty_tests)
+  {
+    hb_string_T str = {
+      .length = 0,
+      .data = NULL
+    };
+
+    ck_assert(hb_string_is_empty(str));
+  }
+
+  {
+    hb_string_T str = hb_string("");
+
+    ck_assert(hb_string_is_empty(str));
+  }
+
+  {
+    hb_string_T str = hb_string("Content");
+
+    ck_assert(!hb_string_is_empty(str));
+  }
+END
+
+TEST(hb_string_starts_with_tests)
+  {
+    hb_string_T str = hb_string("This.");
+    hb_string_T prefix = {
+      .length = 0,
+      .data = NULL,
+    };
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = {
+      .length = 0,
+      .data = NULL,
+    };
+    hb_string_T prefix = hb_string("This.");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("Long text.");
+
+    ck_assert(hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("Long");
+
+    ck_assert(hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("No");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+
+  {
+    hb_string_T str = hb_string("Long text.");
+    hb_string_T prefix = hb_string("This prefix is longer than the text");
+
+    ck_assert(!hb_string_starts_with(str, prefix));
+  }
+END
+
+TCase *hb_string_tests(void) {
+  TCase *tags = tcase_create("Herb String");
+
+  tcase_add_test(tags, hb_string_equals_tests);
+  tcase_add_test(tags, hb_string_offset_based_slice_tests);
+  tcase_add_test(tags, hb_string_equals_case_insensitive_tests);
+  tcase_add_test(tags, hb_string_is_empty_tests);
+  tcase_add_test(tags, hb_string_starts_with_tests);
+
+  return tags;
+}
diff --git a/test/c/test_herb.c b/test/c/test_herb.c
index 7eab745f0..bc0c1272c 100644
--- a/test/c/test_herb.c
+++ b/test/c/test_herb.c
@@ -2,7 +2,7 @@
 #include "../../src/include/herb.h"
 
 TEST(test_herb_version)
-  ck_assert_str_eq(herb_version(), "0.7.4");
+  ck_assert_str_eq(herb_version(), "0.7.5");
 END
 
 TCase *herb_tests(void) {
diff --git a/test/c/test_html_util.c b/test/c/test_html_util.c
index 4f9d50403..dcd592bd2 100644
--- a/test/c/test_html_util.c
+++ b/test/c/test_html_util.c
@@ -1,35 +1,30 @@
-#include <stdio.h>
-#include "include/test.h"
 #include "../../src/include/herb.h"
 #include "../../src/include/html_util.h"
-
-TEST(html_util_html_opening_tag_string)
-  ck_assert_str_eq(html_opening_tag_string(NULL), "<>");
-  ck_assert_str_eq(html_opening_tag_string(""), "<>");
-  ck_assert_str_eq(html_opening_tag_string(" "), "< >");
-  ck_assert_str_eq(html_opening_tag_string("br"), "<br>");
-  ck_assert_str_eq(html_opening_tag_string("div"), "<div>");
-  ck_assert_str_eq(html_opening_tag_string("somelongerstring"), "<somelongerstring>");
-END
+#include "include/test.h"
+#include <stdio.h>
 
 TEST(html_util_html_closing_tag_string)
-  ck_assert_str_eq(html_closing_tag_string(NULL), "</>");
-  ck_assert_str_eq(html_closing_tag_string(""), "</>");
-  ck_assert_str_eq(html_closing_tag_string(" "), "</ >");
-  ck_assert_str_eq(html_closing_tag_string("div"), "</div>");
-  ck_assert_str_eq(html_closing_tag_string("somelongerstring"), "</somelongerstring>");
+  ck_assert(hb_string_equals(html_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string("")), hb_string("</>")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string(" ")), hb_string("</ >")));
+  ck_assert(hb_string_equals(html_closing_tag_string(hb_string("div")), hb_string("</div>")));
+
+  ck_assert(hb_string_equals(
+    html_closing_tag_string(hb_string("somelongerstring")),
+    hb_string("</somelongerstring>")
+  ));
 END
 
 TEST(html_util_html_self_closing_tag_string)
-  ck_assert_str_eq(html_self_closing_tag_string(NULL), "< />");
-  ck_assert_str_eq(html_self_closing_tag_string(""), "< />");
-  ck_assert_str_eq(html_self_closing_tag_string(" "), "<  />");
-  ck_assert_str_eq(html_self_closing_tag_string("br"), "<br />");
-  ck_assert_str_eq(html_self_closing_tag_string("somelongerstring"), "<somelongerstring />");
+  ck_assert(hb_string_equals(html_self_closing_tag_string((hb_string_T) { .data = NULL, .length = 0 }), hb_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("")), hb_string("< />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string(" ")), hb_string("<  />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("br")), hb_string("<br />")));
+  ck_assert(hb_string_equals(html_self_closing_tag_string(hb_string("somelongerstring")), hb_string("<somelongerstring />")));
 END
 
-TCase *html_util_tests(void) {
-  TCase *html_util = tcase_create("HTML Util");
+TCase* html_util_tests(void) {
+  TCase* html_util = tcase_create("HTML Util");
 
   tcase_add_test(html_util, html_util_html_closing_tag_string);
   tcase_add_test(html_util, html_util_html_closing_tag_string);
diff --git a/test/c/test_json.c b/test/c/test_json.c
deleted file mode 100644
index 8dec4b990..000000000
--- a/test/c/test_json.c
+++ /dev/null
@@ -1,306 +0,0 @@
-#include <limits.h>
-
-#include "include/test.h"
-#include "../../src/include/buffer.h"
-#include "../../src/include/json.h"
-
-TEST(test_json_escape_basic)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "key", "value");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"key\": \"value\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_escape_quotes)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "quote", "This is a \"quoted\" string");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"quote\": \"This is a \\\"quoted\\\" string\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_escape_backslash)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "path", "C:\\Users\\Test");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"path\": \"C:\\\\Users\\\\Test\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_escape_newline)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "text", "Line1\nLine2");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Line1\\nLine2\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_escape_tab)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "text", "Column1\tColumn2");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"text\": \"Column1\\tColumn2\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_escape_mixed)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-  json_add_string(&json, "complex", "A \"quoted\" \\ path\nwith\ttabs.");
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"complex\": \"A \\\"quoted\\\" \\\\ path\\nwith\\ttabs.\"}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_root_object)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-
-  json_add_string(&json, "name", "John");
-  json_add_int(&json, "age", 20);
-  json_add_double(&json, "score", 99.5);
-  json_add_bool(&json, "active", 1);
-
-  buffer_T address = buffer_new();
-  json_start_object(&json, "address");
-  json_add_string(&address, "city", "Basel");
-  json_add_string(&address, "country", "Switzerland");
-  buffer_concat(&json, &address);
-  json_end_object(&json);
-
-  buffer_T languages = buffer_new();
-  json_start_array(&json, "languages");
-  json_add_string(&languages, NULL, "Ruby");
-  json_add_string(&languages, NULL, "C");
-  json_add_string(&languages, NULL, "JavaScript");
-  buffer_concat(&json, &languages);
-  json_end_array(&json);
-
-  buffer_T ratings = buffer_new();
-  json_start_array(&json, "ratings");
-  json_add_double(&ratings, NULL, 4.5);
-  json_add_int(&ratings, NULL, 3);
-  json_add_double(&ratings, NULL, 5.0);
-  json_add_double(&ratings, NULL, 3.8);
-  json_add_int(&ratings, NULL, 5);
-  buffer_concat(&json, &ratings);
-  json_end_array(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"name\": \"John\", \"age\": 20, \"score\": 99.50, \"active\": true, \"address\": {\"city\": \"Basel\", \"country\": \"Switzerland\"}, \"languages\": [\"Ruby\", \"C\", \"JavaScript\"], \"ratings\": [4.50, 3, 5.0, 3.79, 5]}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_root_array)
-  buffer_T json = buffer_new();
-
-  json_start_root_array(&json);
-
-  json_add_string(&json, NULL, "Ruby");
-  json_add_string(&json, NULL, "C");
-  json_add_string(&json, NULL, "JavaScript");
-  json_add_int(&json, NULL, 42);
-  json_add_double(&json, NULL, 3.14159);
-  json_add_bool(&json, NULL, 1);
-  json_add_bool(&json, NULL, 0);
-
-  json_end_array(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "[\"Ruby\", \"C\", \"JavaScript\", 42, 3.14, true, false]");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_append_array_to_object)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-
-  buffer_T object = buffer_new();
-  json_start_object(&json, "object");
-  json_add_string(&object, "key", "value");
-
-  buffer_T array = buffer_new();
-  json_start_array(&object, "array");
-  json_add_string(&array, NULL, "One");
-  json_add_string(&array, NULL, "Two");
-
-  buffer_concat(&object, &array);
-  json_end_array(&object);
-
-  buffer_concat(&json, &object);
-  json_end_object(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"object\": {\"key\": \"value\", \"array\": [\"One\", \"Two\"]}}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_append_object_array)
-  buffer_T json = buffer_new();
-
-  json_start_root_object(&json);
-
-  buffer_T array = buffer_new();
-  json_start_array(&json, "array");
-  json_add_string(&array, NULL, "One");
-  json_add_string(&array, NULL, "Two");
-
-  buffer_T object = buffer_new();
-  json_start_object(&array, NULL);
-  json_add_string(&object, "key", "value");
-
-  buffer_concat(&array, &object);
-  json_end_object(&array);
-
-  buffer_concat(&json, &array);
-  json_end_array(&json);
-
-  json_end_object(&json);
-
-  ck_assert_str_eq(buffer_value(&json), "{\"array\": [\"One\", \"Two\", {\"key\": \"value\"}]}");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_double_to_string_precision)
-  char buffer[64];
-
-  json_double_to_string(1.234567890123456, buffer);
-  ck_assert_str_eq(buffer, "1.23");
-
-  json_double_to_string(123456.7890123456789, buffer);
-  ck_assert_str_eq(buffer, "123456.78");
-
-  json_double_to_string(0.000000000000001, buffer);
-  ck_assert_str_eq(buffer, "0.0");
-
-  json_double_to_string(-42.987654321098765, buffer);
-  ck_assert_str_eq(buffer, "-42.98");
-
-  json_double_to_string(3.141592653589793, buffer);
-  ck_assert_str_eq(buffer, "3.14");
-END
-
-TEST(test_json_int_to_string_positive)
-  char buffer[20];
-
-  json_int_to_string(12345, buffer);
-  ck_assert_str_eq(buffer, "12345");
-
-  json_int_to_string(987654321, buffer);
-  ck_assert_str_eq(buffer, "987654321");
-
-  json_int_to_string(0, buffer);
-  ck_assert_str_eq(buffer, "0");
-END
-
-TEST(test_json_int_to_string_negative)
-  char buffer[20];
-
-  json_int_to_string(-1, buffer);
-  ck_assert_str_eq(buffer, "-1");
-
-  json_int_to_string(-42, buffer);
-  ck_assert_str_eq(buffer, "-42");
-
-  json_int_to_string(-987654321, buffer);
-  ck_assert_str_eq(buffer, "-987654321");
-END
-
-TEST(test_json_int_to_string_min_max)
-  char buffer[20];
-
-  json_int_to_string(2147483647, buffer);
-  ck_assert_str_eq(buffer, "2147483647");
-
-  json_int_to_string(-2147483648, buffer);
-  ck_assert_str_eq(buffer, "-2147483648");
-END
-
-TEST(test_json_add_size_t_basic)
-  buffer_T json = buffer_new();
-
-  json_add_size_t(&json, "size", 42);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 42");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_add_size_t_large_number)
-  buffer_T json = buffer_new();
-
-  json_add_size_t(&json, "size", 9876543210UL);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 9876543210");
-
-  buffer_clear(&json);
-  json_add_size_t(&json, "size", SIZE_MAX);
-  ck_assert_str_eq(buffer_value(&json), "\"size\": 18446744073709551615");
-
-  buffer_free(&json);
-END
-
-TEST(test_json_add_size_t_in_array)
-  buffer_T json = buffer_new();
-
-  json_add_size_t(&json, NULL, 1024);
-  json_add_size_t(&json, NULL, 2048);
-  json_add_size_t(&json, NULL, 4096);
-
-  ck_assert_str_eq(buffer_value(&json), "1024, 2048, 4096");
-
-  buffer_free(&json);
-END
-
-
-TCase* json_tests(void) {
-  TCase* json = tcase_create("JSON");
-
-  tcase_add_test(json, test_json_escape_basic);
-  tcase_add_test(json, test_json_escape_quotes);
-  tcase_add_test(json, test_json_escape_backslash);
-  tcase_add_test(json, test_json_escape_tab);
-  tcase_add_test(json, test_json_escape_mixed);
-  tcase_add_test(json, test_json_root_object);
-  tcase_add_test(json, test_json_root_array);
-  tcase_add_test(json, test_json_append_array_to_object);
-  tcase_add_test(json, test_json_append_object_array);
-  tcase_add_test(json, test_json_double_to_string_precision);
-  tcase_add_test(json, test_json_int_to_string_positive);
-  tcase_add_test(json, test_json_int_to_string_negative);
-  tcase_add_test(json, test_json_int_to_string_min_max);
-  tcase_add_test(json, test_json_add_size_t_basic);
-  tcase_add_test(json, test_json_add_size_t_large_number);
-  tcase_add_test(json, test_json_add_size_t_in_array);
-
-  return json;
-}
diff --git a/test/c/test_lex.c b/test/c/test_lex.c
index d0ed240a0..568615c94 100644
--- a/test/c/test_lex.c
+++ b/test/c/test_lex.c
@@ -3,18 +3,20 @@
 
 TEST(herb_lex_to_buffer_empty_file)
   char* html = "";
-  buffer_T output = buffer_new();
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
   ck_assert_str_eq(output.value, "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[0, 0] start=(1:0) end=(1:0)>\n");
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TEST(herb_lex_to_buffer_basic_tag)
   char* html = "<html></html>";
-  buffer_T output = buffer_new();
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
 
   herb_lex_to_buffer(html, &output);
 
@@ -29,7 +31,7 @@ TEST(herb_lex_to_buffer_basic_tag)
     "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[13, 13] start=(1:13) end=(1:13)>\n"
   );
 
-  buffer_free(&output);
+  free(output.value);
 END
 
 TCase *lex_tests(void) {
diff --git a/test/c/test_token.c b/test/c/test_token.c
index a0d06daa2..69335ad9c 100644
--- a/test/c/test_token.c
+++ b/test/c/test_token.c
@@ -8,7 +8,8 @@ TEST(test_token)
 END
 
 TEST(test_token_to_string)
-  buffer_T output = buffer_new();
+  hb_buffer_T output;
+  hb_buffer_init(&output, 1024);
   herb_lex_to_buffer("hello", &output);
 
   ck_assert_str_eq(
@@ -17,21 +18,7 @@ TEST(test_token_to_string)
     "#<Herb::Token type=\"TOKEN_EOF\" value=\"<EOF>\" range=[5, 5] start=(1:5) end=(1:5)>\n"
   );
 
-  buffer_free(&output);
-END
-
-TEST(test_token_to_json)
-  buffer_T output = buffer_new();
-  herb_lex_json_to_buffer("hello", &output);
-
-  const char* expected = "["
-  "{\"type\": \"TOKEN_IDENTIFIER\", \"value\": \"hello\", \"range\": [0 , 5], \"start\": {\"line\": 1, \"column\": 0}, \"end\": {\"line\": 1, \"column\": 5}}, "
-  "{\"type\": \"TOKEN_EOF\", \"value\": \"\", \"range\": [5 , 5], \"start\": {\"line\": 1, \"column\": 5}, \"end\": {\"line\": 1, \"column\": 5}}"
-  "]";
-
-  ck_assert_str_eq(output.value, expected);
-
-  buffer_free(&output);
+  free(output.value);
 END
 
 TCase *token_tests(void) {
@@ -39,7 +26,6 @@ TCase *token_tests(void) {
 
   tcase_add_test(token, test_token);
   tcase_add_test(token, test_token_to_string);
-  tcase_add_test(token, test_token_to_json);
 
   return token;
 }
diff --git a/test/c/test_util.c b/test/c/test_util.c
index dd678f3c5..ca249c8dc 100644
--- a/test/c/test_util.c
+++ b/test/c/test_util.c
@@ -3,16 +3,6 @@
 #include "../../src/include/herb.h"
 #include "../../src/include/util.h"
 
-TEST(util_count_newlines)
-  ck_assert_int_eq(count_newlines("\n"), 1);
-  ck_assert_int_eq(count_newlines("\n\n"), 2);
-
-  ck_assert_int_eq(count_newlines("\r"), 1);
-  ck_assert_int_eq(count_newlines("\r\r"), 2);
-
-  ck_assert_int_eq(count_newlines("\r\n"), 1);
-  ck_assert_int_eq(count_newlines("\r\n\r\n"), 2);
-END
 
 TEST(util_is_newline)
   ck_assert_int_eq(is_newline('\n'), 1);
@@ -22,20 +12,10 @@ TEST(util_is_newline)
   ck_assert_int_eq(is_newline('a'), 0);
 END
 
-TEST(util_replace_char_returns_original)
-  char str[] = "abca";
-  char *returned = replace_char(str, 'a', 'x');
-
-  ck_assert_ptr_eq(returned, str);
-  ck_assert_str_eq(str, "xbcx");
-END
-
 TCase *util_tests(void) {
   TCase *util = tcase_create("Util");
 
-  tcase_add_test(util, util_count_newlines);
   tcase_add_test(util, util_is_newline);
-  tcase_add_test(util, util_replace_char_returns_original);
 
   return util;
 }
diff --git a/test/engine/block_comments_test.rb b/test/engine/block_comments_test.rb
new file mode 100644
index 000000000..b179f7854
--- /dev/null
+++ b/test/engine/block_comments_test.rb
@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+require_relative "../snapshot_utils"
+require_relative "../../lib/herb/engine"
+
+module Engine
+  class BlockCommentsTest < Minitest::Spec
+    include SnapshotUtils
+
+    test "ruby block comments with =begin and =end multiline" do
+      template = <<~ERB
+        <%
+        =begin %>
+          This, while unusual, is a legal form of commenting.
+        <%
+        =end %>
+        <div>Hey there</div>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "ruby block comments inside erb tags" do
+      template = <<~ERB
+        <%
+        =begin
+        This is a comment
+        =end
+        %>
+        <p>Content</p>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "ruby block comments with code before and after" do
+      template = <<~ERB
+        <% x = 1 %>
+        <%
+        =begin
+        Multi-line comment
+        spanning multiple lines
+        =end
+        %>
+        <% y = 2 %>
+        <div><%= x + y %></div>
+      ERB
+
+      assert_compiled_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments with =begin and =end mutliline" do
+      template = <<~ERB
+        <%
+        =begin %>
+          This, while unusual, is a legal form of commenting.
+        <%
+        =end %>
+        <div>Hey there</div>
+      ERB
+
+      assert_evaluated_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments inside erb tags" do
+      template = <<~ERB
+        <%
+        =begin
+        This is a comment
+        =end
+        %>
+        <p>Content</p>
+      ERB
+
+      assert_evaluated_snapshot(template)
+    end
+
+    test "evaluation: ruby block comments with code before and after" do
+      template = <<~ERB
+        <% x = 1 %>
+        <%
+        =begin
+        Multi-line comment
+        spanning multiple lines
+        =end
+        %>
+        <% y = 2 %>
+        <div><%= x + y %></div>
+      ERB
+
+      assert_evaluated_snapshot(template, { x: 1, y: 2 })
+    end
+  end
+end
diff --git a/test/engine/examples_compilation_test.rb b/test/engine/examples_compilation_test.rb
index 2b3f16da9..91e6b0315 100644
--- a/test/engine/examples_compilation_test.rb
+++ b/test/engine/examples_compilation_test.rb
@@ -11,6 +11,8 @@ class ExamplesCompilationTest < Minitest::Spec
     example_files = Dir.glob(File.join(examples_dir, "*.html.erb"))
 
     example_files.each do |file_path|
+      next if file_path.end_with?(".invalid.html.erb")
+
       basename = File.basename(file_path, ".html.erb")
       test_name = "#{basename.tr("-_", " ")} compilation"
 
diff --git a/test/herb_test.rb b/test/herb_test.rb
index 866423e31..e6705036c 100644
--- a/test/herb_test.rb
+++ b/test/herb_test.rb
@@ -4,6 +4,6 @@
 
 class HerbTest < Minitest::Spec
   test "version" do
-    assert_equal "herb gem v0.7.4, libprism v1.5.1, libherb v0.7.4 (Ruby C native extension)", Herb.version
+    assert_equal "herb gem v0.7.5, libprism v1.6.0, libherb v0.7.5 (Ruby C native extension)", Herb.version
   end
 end
diff --git a/test/lexer/erb_test.rb b/test/lexer/erb_test.rb
index b3c5b1ded..e821c7e8e 100644
--- a/test/lexer/erb_test.rb
+++ b/test/lexer/erb_test.rb
@@ -34,6 +34,14 @@ class ERBTest < Minitest::Spec
       assert_lexed_snapshot(%(<%%= "Test" %%>))
     end
 
+    test "erb <% =%>" do
+      assert_lexed_snapshot(%(<% "Test" =%>))
+    end
+
+    test "erb <%= =%>" do
+      assert_lexed_snapshot(%(<%= "Test" =%>))
+    end
+
     test "erb output inside HTML attribute value" do
       assert_lexed_snapshot(%(<article id="<%= dom_id(article) %>"></article>))
     end
diff --git a/test/lexer/text_content_test.rb b/test/lexer/text_content_test.rb
index 2306336a5..03934d21f 100644
--- a/test/lexer/text_content_test.rb
+++ b/test/lexer/text_content_test.rb
@@ -14,18 +14,18 @@ class TextContentTest < Minitest::Spec
       assert_lexed_snapshot("<h1>Some. Text.</h1>")
     end
 
-    test "text content that exceeds initial buffer_T size and needs to resize once (ca. 4K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((initial_buffer_capacity * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size and needs to resize once (ca. 4K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1)
       result = assert_lexed_snapshot(%(<div>#{content}</div>))
 
       identifier = result.value.find { |token| token.type == "TOKEN_IDENTIFIER" && token.value.length > 4000 }
       assert_equal content, identifier.value
     end
 
-    test "text content that exceeds initial buffer_T size and needs to resize twice (ca. 8K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((((initial_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size and needs to resize twice (ca. 8K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
       result = assert_lexed_snapshot(%(<div>#{content}</div>))
 
       identifier = result.value.find { |token| token.type == "TOKEN_IDENTIFIER" && token.value.length > 4000 }
diff --git a/test/parser/boolean_attributes_test.rb b/test/parser/boolean_attributes_test.rb
index 076935b8f..24d96191c 100644
--- a/test/parser/boolean_attributes_test.rb
+++ b/test/parser/boolean_attributes_test.rb
@@ -29,5 +29,21 @@ class BooleanAttributesTest < Minitest::Spec
     test "boolean attribute surrounded by regular attributes" do
       assert_parsed_snapshot(%(<input class="classes" required id="ids"/>))
     end
+
+    test "boolean attribute on void element followed by newline and ERB tag with track_whitespace" do
+      assert_parsed_snapshot(%(<link crossorigin>\n<%= hello %>), track_whitespace: true)
+    end
+
+    test "boolean attribute on void element followed by ERB tag with track_whitespace" do
+      assert_parsed_snapshot(%(<link crossorigin><%= hello %>), track_whitespace: true)
+    end
+
+    test "boolean attribute on void element followed by ERB tag with track_whitespace" do
+      assert_parsed_snapshot(<<~HTML, track_whitespace: true)
+        <div id="test" hidden>
+          <%= "hi" %>
+        </div>
+      HTML
+    end
   end
 end
diff --git a/test/parser/erb_test.rb b/test/parser/erb_test.rb
index 1c95ef3f6..142a25eab 100644
--- a/test/parser/erb_test.rb
+++ b/test/parser/erb_test.rb
@@ -181,5 +181,29 @@ class ERBTest < Minitest::Spec
         %>
       HTML
     end
+
+    test "erb output with =%> close tag" do
+      assert_parsed_snapshot(%(<%= "hello" =%>))
+    end
+
+    test "erb if with =%> close tag" do
+      assert_parsed_snapshot(<<~HTML)
+        <% if true =%>
+          <p>Content</p>
+        <% end =%>
+      HTML
+    end
+
+    test "erb if-elsif-else with =%> close tag" do
+      assert_parsed_snapshot(<<~HTML)
+        <% if condition =%>
+          <p>True</p>
+        <% elsif other =%>
+          <p>Other</p>
+        <% else =%>
+          <p>False</p>
+        <% end =%>
+      HTML
+    end
   end
 end
diff --git a/test/parser/text_content_test.rb b/test/parser/text_content_test.rb
index 84e4e8d80..2f9686da7 100644
--- a/test/parser/text_content_test.rb
+++ b/test/parser/text_content_test.rb
@@ -26,17 +26,17 @@ class TextContentTest < Minitest::Spec
       assert_parsed_snapshot("Hello<span></span>World")
     end
 
-    test "text content that exceeds initial buffer_T size (ca. 4K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((initial_buffer_capacity * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size (ca. 4K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1)
       result = assert_parsed_snapshot(%(<div>#{content}</div>))
 
       assert_equal content, result.value.children.first.body.first.content
     end
 
-    test "text content that exceeds initial buffer_T size (ca. 8K)" do
-      initial_buffer_capacity = 1024 # bytes
-      content = cyclic_string((((((initial_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
+    test "text content that exceeds initial hb_buffer_T size (ca. 8K)" do
+      initial_hb_buffer_capacity = 1024 # bytes
+      content = cyclic_string((((((initial_hb_buffer_capacity * 2) + 1) * 2) + 1) * 2) + 1)
       result = assert_parsed_snapshot(%(<div>#{content}</div>))
 
       assert_equal content, result.value.children.first.body.first.content
@@ -145,5 +145,16 @@ class TextContentTest < Minitest::Spec
     test "backtick with HTML tags - issue 467" do
       assert_parsed_snapshot("a `<b></b>` c")
     end
+
+    test "backslash-prefixed text stays literal - issue 635" do
+      assert_parsed_snapshot("<p>\\Asome-regexp\\z</p>")
+    end
+
+    # https://github.com/lobsters/lobsters/blob/75f9a53077d5aeaeadbb8271def0479dd8fcd761/app/views/domains/edit.html.erb#L11
+    test "backslash-prefixed text - issue 633" do
+      assert_parsed_snapshot <<~HTML
+        <p class="help">Regexp with captures, must consume whole string like: <kbd>\\Ahttps?://github.com/+([^/]+).*\\z</kbd></p>
+      HTML
+    end
   end
 end
diff --git a/test/snapshot_utils.rb b/test/snapshot_utils.rb
index 2034fc552..4f848230d 100644
--- a/test/snapshot_utils.rb
+++ b/test/snapshot_utils.rb
@@ -145,7 +145,7 @@ def snapshot_file(source, options = {})
 
     content_hash = Digest::MD5.hexdigest(source || "#{source.class}-#{source.inspect}")
 
-    test_name = name.gsub(" ", "_").gsub("/", "_")
+    test_name = sanitize_name_for_filesystem(name)
 
     if options && !options.empty?
       options_hash = Digest::MD5.hexdigest(options.inspect)
@@ -178,6 +178,23 @@ def snapshot_file(source, options = {})
 
   private
 
+  def sanitize_name_for_filesystem(name)
+    [
+      # ntfs reserved characters
+      # https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+      ["<", "lt"],
+      [">", "gt"],
+      [":", ""],
+      ["/", "_"],
+      ["\\", ""],
+      ["|", ""],
+      ["?", ""],
+      ["*", ""],
+
+      [" ", "_"]
+    ].inject(name) { |name, substitution| name.gsub(substitution[0], substitution[1]) }
+  end
+
   def underscore(string)
     string.gsub("::", "/")
           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
diff --git a/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt b/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt
new file mode 100644
index 000000000..c29867eb1
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0008_case_in_with_block_inside_in_clause_a5d7393ef0ab780cd777fd4d09413ac8.txt
@@ -0,0 +1,48 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case result " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:29))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in { status: :success } " (location: (2:2)-(2:27))
+    │   │       ├── tag_closing: "%>" (location: (2:27)-(2:29))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:29)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Success!\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt b/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt
new file mode 100644
index 000000000..15df4180f
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0009_case_in_with_multiple_blocks_in_in_clause_8cdfe954fcb68cf29f71d5c05893547c.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(10:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(9:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case data " (location: (1:2)-(1:13))
+    │   ├── tag_closing: "%>" (location: (1:13)-(1:15))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:15)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:25))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in { type: :alert } " (location: (2:2)-(2:23))
+    │   │       ├── tag_closing: "%>" (location: (2:23)-(2:25))
+    │   │       └── statements: (5 items)
+    │   │           ├── @ HTMLTextNode (location: (2:25)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Alert\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (6:2)-(8:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (6:2)-(6:5))
+    │   │           │   ├── content: " content_tag(:span) do " (location: (6:5)-(6:28))
+    │   │           │   ├── tag_closing: "%>" (location: (6:28)-(6:30))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (6:30)-(8:2))
+    │   │           │   │       └── content: "\n    Icon\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (8:2)-(8:11))
+    │   │           │           ├── tag_opening: "<%" (location: (8:2)-(8:4))
+    │   │           │           ├── content: " end " (location: (8:4)-(8:9))
+    │   │           │           └── tag_closing: "%>" (location: (8:9)-(8:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (8:11)-(9:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (9:0)-(9:9))
+    │           ├── tag_opening: "<%" (location: (9:0)-(9:2))
+    │           ├── content: " end " (location: (9:2)-(9:7))
+    │           └── tag_closing: "%>" (location: (9:7)-(9:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (9:9)-(10:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt b/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt
new file mode 100644
index 000000000..5acba3aa5
--- /dev/null
+++ b/test/snapshots/analyze/case_in_test/test_0010_case_in_with_if_statement_inside_in_clause_51fcf7566215a5284ae1ee34c920837e.txt
@@ -0,0 +1,49 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseMatchNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case value " (location: (1:2)-(1:14))
+    │   ├── tag_closing: "%>" (location: (1:14)-(1:16))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:16)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBInNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " in [Integer] " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBIfNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%" (location: (3:2)-(3:4))
+    │   │           │   ├── content: " if positive? " (location: (3:4)-(3:18))
+    │   │           │   ├── tag_closing: "%>" (location: (3:18)-(3:20))
+    │   │           │   ├── statements: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:20)-(5:2))
+    │   │           │   │       └── content: "\n    Positive\n  "
+    │   │           │   │
+    │   │           │   ├── subsequent: ∅
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt b/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt
new file mode 100644
index 000000000..e2e329787
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0008_case_with_block_inside_when_adb20c2773fe1206d2b47123f8001e22.txt
@@ -0,0 +1,48 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case 1 " (location: (1:2)-(1:10))
+    │   ├── tag_closing: "%>" (location: (1:10)-(1:12))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:12)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:12))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 1 " (location: (2:2)-(2:10))
+    │   │       ├── tag_closing: "%>" (location: (2:10)-(2:12))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:12)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:p) do " (location: (3:5)-(3:25))
+    │   │           │   ├── tag_closing: "%>" (location: (3:25)-(3:27))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:27)-(5:2))
+    │   │           │   │       └── content: "\n    Yep\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt b/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt
new file mode 100644
index 000000000..ff5e466ab
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0009_case_with_multiple_blocks_in_when_05f7d387314a95620a58ddc7f7d31b7b.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(10:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(9:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case status " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when :active " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (5 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │           │   │       └── content: "\n    Active\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (6:2)-(8:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (6:2)-(6:5))
+    │   │           │   ├── content: " content_tag(:span) do " (location: (6:5)-(6:28))
+    │   │           │   ├── tag_closing: "%>" (location: (6:28)-(6:30))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (6:30)-(8:2))
+    │   │           │   │       └── content: "\n    Badge\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (8:2)-(8:11))
+    │   │           │           ├── tag_opening: "<%" (location: (8:2)-(8:4))
+    │   │           │           ├── content: " end " (location: (8:4)-(8:9))
+    │   │           │           └── tag_closing: "%>" (location: (8:9)-(8:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (8:11)-(9:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (9:0)-(9:9))
+    │           ├── tag_opening: "<%" (location: (9:0)-(9:2))
+    │           ├── content: " end " (location: (9:2)-(9:7))
+    │           └── tag_closing: "%>" (location: (9:7)-(9:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (9:9)-(10:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt b/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt
new file mode 100644
index 000000000..857244cb8
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0010_case_with_nested_blocks_in_when_6e70c1bf60788969969296d35c409a47.txt
@@ -0,0 +1,66 @@
+@ DocumentNode (location: (1:0)-(9:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(8:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case level " (location: (1:2)-(1:14))
+    │   ├── tag_closing: "%>" (location: (1:14)-(1:16))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:16)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:12))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 1 " (location: (2:2)-(2:10))
+    │   │       ├── tag_closing: "%>" (location: (2:10)-(2:12))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:12)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (3:2)-(7:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │           │   ├── content: " content_tag(:div) do " (location: (3:5)-(3:27))
+    │   │           │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │           │   ├── body: (3 items)
+    │   │           │   │   ├── @ HTMLTextNode (location: (3:29)-(4:4))
+    │   │           │   │   │   └── content: "\n    "
+    │   │           │   │   │
+    │   │           │   │   ├── @ ERBBlockNode (location: (4:4)-(6:13))
+    │   │           │   │   │   ├── tag_opening: "<%=" (location: (4:4)-(4:7))
+    │   │           │   │   │   ├── content: " content_tag(:p) do " (location: (4:7)-(4:27))
+    │   │           │   │   │   ├── tag_closing: "%>" (location: (4:27)-(4:29))
+    │   │           │   │   │   ├── body: (1 item)
+    │   │           │   │   │   │   └── @ HTMLTextNode (location: (4:29)-(6:4))
+    │   │           │   │   │   │       └── content: "\n      Nested\n    "
+    │   │           │   │   │   │
+    │   │           │   │   │   └── end_node:
+    │   │           │   │   │       └── @ ERBEndNode (location: (6:4)-(6:13))
+    │   │           │   │   │           ├── tag_opening: "<%" (location: (6:4)-(6:6))
+    │   │           │   │   │           ├── content: " end " (location: (6:6)-(6:11))
+    │   │           │   │   │           └── tag_closing: "%>" (location: (6:11)-(6:13))
+    │   │           │   │   │
+    │   │           │   │   │
+    │   │           │   │   └── @ HTMLTextNode (location: (6:13)-(7:2))
+    │   │           │   │       └── content: "\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (7:2)-(7:11))
+    │   │           │           ├── tag_opening: "<%" (location: (7:2)-(7:4))
+    │   │           │           ├── content: " end " (location: (7:4)-(7:9))
+    │   │           │           └── tag_closing: "%>" (location: (7:9)-(7:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (7:11)-(8:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (8:0)-(8:9))
+    │           ├── tag_opening: "<%" (location: (8:0)-(8:2))
+    │           ├── content: " end " (location: (8:2)-(8:7))
+    │           └── tag_closing: "%>" (location: (8:7)-(8:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (8:9)-(9:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt b/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt
new file mode 100644
index 000000000..818e209a5
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0011_case_with_block_in_multiple_when_clauses_3f35d3ebf6ea6eaf8e7b9bc7f8393a0f.txt
@@ -0,0 +1,75 @@
+@ DocumentNode (location: (1:0)-(11:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(10:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case type " (location: (1:2)-(1:13))
+    │   ├── tag_closing: "%>" (location: (1:13)-(1:15))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:15)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (2 items)
+    │   │   ├── @ ERBWhenNode (location: (2:0)-(2:13))
+    │   │   │   ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │   │   ├── content: " when :a " (location: (2:2)-(2:11))
+    │   │   │   ├── tag_closing: "%>" (location: (2:11)-(2:13))
+    │   │   │   └── statements: (3 items)
+    │   │   │       ├── @ HTMLTextNode (location: (2:13)-(3:2))
+    │   │   │       │   └── content: "\n  "
+    │   │   │       │
+    │   │   │       ├── @ ERBBlockNode (location: (3:2)-(5:11))
+    │   │   │       │   ├── tag_opening: "<%=" (location: (3:2)-(3:5))
+    │   │   │       │   ├── content: " form_for(obj) do |f| " (location: (3:5)-(3:27))
+    │   │   │       │   ├── tag_closing: "%>" (location: (3:27)-(3:29))
+    │   │   │       │   ├── body: (1 item)
+    │   │   │       │   │   └── @ HTMLTextNode (location: (3:29)-(5:2))
+    │   │   │       │   │       └── content: "\n    Form A\n  "
+    │   │   │       │   │
+    │   │   │       │   └── end_node:
+    │   │   │       │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │   │       │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │   │       │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │   │       │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │   │       │
+    │   │   │       │
+    │   │   │       └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │   │           └── content: "\n"
+    │   │   │
+    │   │   │
+    │   │   └── @ ERBWhenNode (location: (6:0)-(6:13))
+    │   │       ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │   │       ├── content: " when :b " (location: (6:2)-(6:11))
+    │   │       ├── tag_closing: "%>" (location: (6:11)-(6:13))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (6:13)-(7:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBBlockNode (location: (7:2)-(9:11))
+    │   │           │   ├── tag_opening: "<%=" (location: (7:2)-(7:5))
+    │   │           │   ├── content: " form_for(obj) do |f| " (location: (7:5)-(7:27))
+    │   │           │   ├── tag_closing: "%>" (location: (7:27)-(7:29))
+    │   │           │   ├── body: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (7:29)-(9:2))
+    │   │           │   │       └── content: "\n    Form B\n  "
+    │   │           │   │
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (9:2)-(9:11))
+    │   │           │           ├── tag_opening: "<%" (location: (9:2)-(9:4))
+    │   │           │           ├── content: " end " (location: (9:4)-(9:9))
+    │   │           │           └── tag_closing: "%>" (location: (9:9)-(9:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (9:11)-(10:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (10:0)-(10:9))
+    │           ├── tag_opening: "<%" (location: (10:0)-(10:2))
+    │           ├── content: " end " (location: (10:2)-(10:7))
+    │           └── tag_closing: "%>" (location: (10:7)-(10:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (10:9)-(11:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt b/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt
new file mode 100644
index 000000000..5cef31f1d
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0012_case_with_if_statement_inside_when_ccc0bd511203c41d9274ccc360e736c2.txt
@@ -0,0 +1,49 @@
+@ DocumentNode (location: (1:0)-(7:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(6:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case status " (location: (1:2)-(1:15))
+    │   ├── tag_closing: "%>" (location: (1:15)-(1:17))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:17)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:18))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when :active " (location: (2:2)-(2:16))
+    │   │       ├── tag_closing: "%>" (location: (2:16)-(2:18))
+    │   │       └── statements: (3 items)
+    │   │           ├── @ HTMLTextNode (location: (2:18)-(3:2))
+    │   │           │   └── content: "\n  "
+    │   │           │
+    │   │           ├── @ ERBIfNode (location: (3:2)-(5:11))
+    │   │           │   ├── tag_opening: "<%" (location: (3:2)-(3:4))
+    │   │           │   ├── content: " if admin? " (location: (3:4)-(3:15))
+    │   │           │   ├── tag_closing: "%>" (location: (3:15)-(3:17))
+    │   │           │   ├── statements: (1 item)
+    │   │           │   │   └── @ HTMLTextNode (location: (3:17)-(5:2))
+    │   │           │   │       └── content: "\n    Admin view\n  "
+    │   │           │   │
+    │   │           │   ├── subsequent: ∅
+    │   │           │   └── end_node:
+    │   │           │       └── @ ERBEndNode (location: (5:2)-(5:11))
+    │   │           │           ├── tag_opening: "<%" (location: (5:2)-(5:4))
+    │   │           │           ├── content: " end " (location: (5:4)-(5:9))
+    │   │           │           └── tag_closing: "%>" (location: (5:9)-(5:11))
+    │   │           │
+    │   │           │
+    │   │           └── @ HTMLTextNode (location: (5:11)-(6:0))
+    │   │               └── content: "\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (6:0)-(6:9))
+    │           ├── tag_opening: "<%" (location: (6:0)-(6:2))
+    │           ├── content: " end " (location: (6:2)-(6:7))
+    │           └── tag_closing: "%>" (location: (6:7)-(6:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (6:9)-(7:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt b/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt
new file mode 100644
index 000000000..1a4e6654e
--- /dev/null
+++ b/test/snapshots/analyze/case_test/test_0013_case_with_yield_dc59b65969b8ef95076abc05c3907392.txt
@@ -0,0 +1,30 @@
+@ DocumentNode (location: (1:0)-(5:0))
+└── children: (2 items)
+    ├── @ ERBCaseNode (location: (1:0)-(4:9))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " case yield(:a) " (location: (1:2)-(1:18))
+    │   ├── tag_closing: "%>" (location: (1:18)-(1:20))
+    │   ├── children: (1 item)
+    │   │   └── @ HTMLTextNode (location: (1:20)-(2:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── conditions: (1 item)
+    │   │   └── @ ERBWhenNode (location: (2:0)-(2:14))
+    │   │       ├── tag_opening: "<%" (location: (2:0)-(2:2))
+    │   │       ├── content: " when 'a' " (location: (2:2)-(2:12))
+    │   │       ├── tag_closing: "%>" (location: (2:12)-(2:14))
+    │   │       └── statements: (1 item)
+    │   │           └── @ HTMLTextNode (location: (2:14)-(4:0))
+    │   │               └── content: "\n  aaa\n"
+    │   │
+    │   │
+    │   ├── else_clause: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (4:0)-(4:9))
+    │           ├── tag_opening: "<%" (location: (4:0)-(4:2))
+    │           ├── content: " end " (location: (4:2)-(4:7))
+    │           └── tag_closing: "%>" (location: (4:7)-(4:9))
+    │
+    │
+    └── @ HTMLTextNode (location: (4:9)-(5:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt b/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt
new file mode 100644
index 000000000..b86d395f2
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0001_ruby_block_comments_with_=begin_and_=end_multiline_ff404c4e708f59f532b4042441e458ad.txt
@@ -0,0 +1,11 @@
+_buf = ::String.new;
+
+=begin
+ _buf << '
+  This, while unusual, is a legal form of commenting.
+'.freeze;
+=end
+ _buf << '
+<div>Hey there</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt b/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt
new file mode 100644
index 000000000..467a7f23a
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0002_ruby_block_comments_inside_erb_tags_95bcfa3f3e28634bf923f18df0cd38a1.txt
@@ -0,0 +1,9 @@
+_buf = ::String.new;
+
+=begin
+This is a comment
+=end
+ _buf << '
+<p>Content</p>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt b/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt
new file mode 100644
index 000000000..545dc4e42
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0003_ruby_block_comments_with_code_before_and_after_0ee0ba8a9a25359175b884cf66f37b2c.txt
@@ -0,0 +1,12 @@
+_buf = ::String.new;
+ x = 1; _buf << '
+'.freeze;
+=begin
+Multi-line comment
+spanning multiple lines
+=end
+ _buf << '
+'.freeze; y = 2; _buf << '
+<div>'.freeze; _buf << (x + y).to_s; _buf << '</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/block_comments_test/test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt b/test/snapshots/engine/block_comments_test/test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
new file mode 100644
index 000000000..a6a4497b5
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0004_evaluation_ruby_block_comments_with_=begin_and_=end_mutliline_6bf3affa07b559b73f6428e0dbd270d2.txt
@@ -0,0 +1,2 @@
+
+<div>Hey there</div>
diff --git a/test/snapshots/engine/block_comments_test/test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt b/test/snapshots/engine/block_comments_test/test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
new file mode 100644
index 000000000..1efa30582
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0005_evaluation_ruby_block_comments_inside_erb_tags_8a842d797202d0b31c9832cd43a22686.txt
@@ -0,0 +1,2 @@
+
+<p>Content</p>
diff --git a/test/snapshots/engine/block_comments_test/test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt b/test/snapshots/engine/block_comments_test/test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
new file mode 100644
index 000000000..d630b5b60
--- /dev/null
+++ b/test/snapshots/engine/block_comments_test/test_0006_evaluation_ruby_block_comments_with_code_before_and_after_c5e6a4e1e9e691af8dcc74ae6c9564c9.txt
@@ -0,0 +1,4 @@
+
+
+
+<div>3</div>
diff --git a/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt b/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt
new file mode 100644
index 000000000..dd6f62d48
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0004_block_comment_compilation_d5c98b9f230e001f8aabf838d3774698.txt
@@ -0,0 +1,12 @@
+_buf = ::String.new;
+
+=begin
+ _buf << '
+  This, while unusual, is a legal form of commenting.
+'.freeze;
+=end
+ _buf << '
+
+<div>Content</div>
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt b/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt
new file mode 100644
index 000000000..218a1f6eb
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0005_case_in_compilation_6f13b7233db413c987e289ad2b3e3a3a.txt
@@ -0,0 +1,8 @@
+_buf = ::String.new;
+ case {}; in {}; _buf << '
+  "matched"
+'.freeze; else; _buf << '
+  "not matched"
+'.freeze; end; _buf << '
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0004_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt b/test/snapshots/engine/examples_compilation_test/test_0006_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0004_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
rename to test/snapshots/engine/examples_compilation_test/test_0006_case_when_compilation_3ee70e5b90c1ff368a7783c49c6dc611.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0005_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt b/test/snapshots/engine/examples_compilation_test/test_0007_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0005_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
rename to test/snapshots/engine/examples_compilation_test/test_0007_comment_compilation_da96aac1987dbb33d41eb4a121419b47.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0006_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt b/test/snapshots/engine/examples_compilation_test/test_0008_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0006_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
rename to test/snapshots/engine/examples_compilation_test/test_0008_comment_before_content_compilation_2b3c4e3c244db77468813a7472298e82.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt b/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt
new file mode 100644
index 000000000..f48818019
--- /dev/null
+++ b/test/snapshots/engine/examples_compilation_test/test_0009_complete_erb_compilation_a33dd3e79d24b4f31f6d4e92611f3f63.txt
@@ -0,0 +1,4 @@
+_buf = ::String.new;
+ _buf << (hello).to_s; _buf << '
+'.freeze;
+_buf.to_s
diff --git a/test/snapshots/engine/examples_compilation_test/test_0007_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt b/test/snapshots/engine/examples_compilation_test/test_0010_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0007_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
rename to test/snapshots/engine/examples_compilation_test/test_0010_doctype_compilation_8c18fb8399a2fd1e65b0333bc01e041c.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0008_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt b/test/snapshots/engine/examples_compilation_test/test_0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0008_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
rename to test/snapshots/engine/examples_compilation_test/test_0011_erb_compilation_0109f6af5a474973b8b1b52636135c4f.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0009_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt b/test/snapshots/engine/examples_compilation_test/test_0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0009_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
rename to test/snapshots/engine/examples_compilation_test/test_0012_for_compilation_eeecb969def01ab8005c7b9f23686fed.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0010_if_else_compilation_1437d0425640509570342c24b30de571.txt b/test/snapshots/engine/examples_compilation_test/test_0013_if_else_compilation_1437d0425640509570342c24b30de571.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0010_if_else_compilation_1437d0425640509570342c24b30de571.txt
rename to test/snapshots/engine/examples_compilation_test/test_0013_if_else_compilation_1437d0425640509570342c24b30de571.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0011_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt b/test/snapshots/engine/examples_compilation_test/test_0014_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0011_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
rename to test/snapshots/engine/examples_compilation_test/test_0014_line_wrap_compilation_ba78b92bec7a4692a2043f2ba2ebe057.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0012_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt b/test/snapshots/engine/examples_compilation_test/test_0015_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0012_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
rename to test/snapshots/engine/examples_compilation_test/test_0015_link_to_with_block_compilation_4ddb2a17755d3e775e3225970bc60a96.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0013_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt b/test/snapshots/engine/examples_compilation_test/test_0016_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0013_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
rename to test/snapshots/engine/examples_compilation_test/test_0016_nested_if_and_blocks_compilation_aa8aed9ef61b138a28efed42f4b72251.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0014_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt b/test/snapshots/engine/examples_compilation_test/test_0017_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0014_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
rename to test/snapshots/engine/examples_compilation_test/test_0017_simple_block_compilation_1729fad3a77618acdc687c9fb671b75b.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0015_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt b/test/snapshots/engine/examples_compilation_test/test_0018_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0015_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
rename to test/snapshots/engine/examples_compilation_test/test_0018_simple_erb_compilation_d81de4ca83482c4836215ef7177d9eec.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0016_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt b/test/snapshots/engine/examples_compilation_test/test_0019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0016_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
rename to test/snapshots/engine/examples_compilation_test/test_0019_test_compilation_9c22f391d1d03fa66b3d18095354a236.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0017_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt b/test/snapshots/engine/examples_compilation_test/test_0020_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0017_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
rename to test/snapshots/engine/examples_compilation_test/test_0020_until_compilation_0b1269c00fd15a74df125278ed6a9fc4.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0018_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt b/test/snapshots/engine/examples_compilation_test/test_0021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0018_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
rename to test/snapshots/engine/examples_compilation_test/test_0021_utf8_compilation_45fa7aa654c0dc06d1a1b9504002dfba.txt
diff --git a/test/snapshots/engine/examples_compilation_test/test_0019_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt b/test/snapshots/engine/examples_compilation_test/test_0022_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
similarity index 100%
rename from test/snapshots/engine/examples_compilation_test/test_0019_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
rename to test/snapshots/engine/examples_compilation_test/test_0022_while_compilation_a705eb5ed83b4db368d7204baa136b36.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_>_value_2e196056650e47d46886938eb88136f7.txt b/test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_gt_value_2e196056650e47d46886938eb88136f7.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_>_value_2e196056650e47d46886938eb88136f7.txt
rename to test/snapshots/lexer/attributes_test/test_0009_attribute_value_single_quotes_with_gt_value_2e196056650e47d46886938eb88136f7.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0013_Alpine.js_:class_attribute_af387b2d214ba9baadbd062f15508d2d.txt b/test/snapshots/lexer/attributes_test/test_0013_Alpine.js_class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0013_Alpine.js_:class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
rename to test/snapshots/lexer/attributes_test/test_0013_Alpine.js_class_attribute_af387b2d214ba9baadbd062f15508d2d.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0014_Alpine.js_:value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt b/test/snapshots/lexer/attributes_test/test_0014_Alpine.js_value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0014_Alpine.js_:value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
rename to test/snapshots/lexer/attributes_test/test_0014_Alpine.js_value_attribute_dbd22dd4679133f8be271e39a3a16b03.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0017_Alpine.js_:_without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt b/test/snapshots/lexer/attributes_test/test_0017_Alpine.js__without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0017_Alpine.js_:_without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
rename to test/snapshots/lexer/attributes_test/test_0017_Alpine.js__without_identifier_ad89c5b890e891eda58e590a3eaf2e82.txt
diff --git a/test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_>_value_bf55684b694d2aa471b24fa539546339.txt b/test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_gt_value_bf55684b694d2aa471b24fa539546339.txt
similarity index 100%
rename from test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_>_value_bf55684b694d2aa471b24fa539546339.txt
rename to test/snapshots/lexer/attributes_test/test_0018_attribute_value_double_quotes_with_gt_value_bf55684b694d2aa471b24fa539546339.txt
diff --git a/test/snapshots/lexer/erb_test/test_0001_erb_<%_%>_e97ed3ba194342cfe8febc1a40a3d603.txt b/test/snapshots/lexer/erb_test/test_0001_erb_lt%_%gt_e97ed3ba194342cfe8febc1a40a3d603.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0001_erb_<%_%>_e97ed3ba194342cfe8febc1a40a3d603.txt
rename to test/snapshots/lexer/erb_test/test_0001_erb_lt%_%gt_e97ed3ba194342cfe8febc1a40a3d603.txt
diff --git a/test/snapshots/lexer/erb_test/test_0002_erb_<%=_%>_2d5c53c5a986076f8a5df2585ce5aa74.txt b/test/snapshots/lexer/erb_test/test_0002_erb_lt%=_%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0002_erb_<%=_%>_2d5c53c5a986076f8a5df2585ce5aa74.txt
rename to test/snapshots/lexer/erb_test/test_0002_erb_lt%=_%gt_2d5c53c5a986076f8a5df2585ce5aa74.txt
diff --git a/test/snapshots/lexer/erb_test/test_0003_erb_<%-_%>_b305aff64a566ea549c116aacb0ce86c.txt b/test/snapshots/lexer/erb_test/test_0003_erb_lt%-_%gt_b305aff64a566ea549c116aacb0ce86c.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0003_erb_<%-_%>_b305aff64a566ea549c116aacb0ce86c.txt
rename to test/snapshots/lexer/erb_test/test_0003_erb_lt%-_%gt_b305aff64a566ea549c116aacb0ce86c.txt
diff --git a/test/snapshots/lexer/erb_test/test_0004_erb_<%-_-%>_34d2696185efe003bf3f2c2dddb924e3.txt b/test/snapshots/lexer/erb_test/test_0004_erb_lt%-_-%gt_34d2696185efe003bf3f2c2dddb924e3.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0004_erb_<%-_-%>_34d2696185efe003bf3f2c2dddb924e3.txt
rename to test/snapshots/lexer/erb_test/test_0004_erb_lt%-_-%gt_34d2696185efe003bf3f2c2dddb924e3.txt
diff --git a/test/snapshots/lexer/erb_test/test_0005_erb_<%#_%>_d59bec1a45925c1618c6d42541cb652b.txt b/test/snapshots/lexer/erb_test/test_0005_erb_lt%#_%gt_d59bec1a45925c1618c6d42541cb652b.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0005_erb_<%#_%>_d59bec1a45925c1618c6d42541cb652b.txt
rename to test/snapshots/lexer/erb_test/test_0005_erb_lt%#_%gt_d59bec1a45925c1618c6d42541cb652b.txt
diff --git a/test/snapshots/lexer/erb_test/test_0006_erb_<%%_%%>_5856d025d70301b0cc95e2287a1d324f.txt b/test/snapshots/lexer/erb_test/test_0006_erb_lt%%_%%gt_5856d025d70301b0cc95e2287a1d324f.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0006_erb_<%%_%%>_5856d025d70301b0cc95e2287a1d324f.txt
rename to test/snapshots/lexer/erb_test/test_0006_erb_lt%%_%%gt_5856d025d70301b0cc95e2287a1d324f.txt
diff --git a/test/snapshots/lexer/erb_test/test_0007_erb_<%%=_%%>_8bba62f5739809ebc6cf44f4206dd610.txt b/test/snapshots/lexer/erb_test/test_0007_erb_lt%%=_%%gt_8bba62f5739809ebc6cf44f4206dd610.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0007_erb_<%%=_%%>_8bba62f5739809ebc6cf44f4206dd610.txt
rename to test/snapshots/lexer/erb_test/test_0007_erb_lt%%=_%%gt_8bba62f5739809ebc6cf44f4206dd610.txt
diff --git a/test/snapshots/lexer/erb_test/test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt b/test/snapshots/lexer/erb_test/test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt
new file mode 100644
index 000000000..f84f7c4c9
--- /dev/null
+++ b/test/snapshots/lexer/erb_test/test_0008_erb_lt%_=%gt_344eadf6b1e04a6f534a3c7e38bbadf1.txt
@@ -0,0 +1,4 @@
+#<Herb::Token type="TOKEN_ERB_START" value="<%" range=[0, 2] start=(1:0) end=(1:2)>
+#<Herb::Token type="TOKEN_ERB_CONTENT" value=" \"Test\" " range=[2, 10] start=(1:2) end=(1:10)>
+#<Herb::Token type="TOKEN_ERB_END" value="=%>" range=[10, 13] start=(1:10) end=(1:13)>
+#<Herb::Token type="TOKEN_EOF" value="<EOF>" range=[13, 13] start=(1:13) end=(1:13)>
diff --git a/test/snapshots/lexer/erb_test/test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt b/test/snapshots/lexer/erb_test/test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt
new file mode 100644
index 000000000..62d751f5b
--- /dev/null
+++ b/test/snapshots/lexer/erb_test/test_0009_erb_lt%=_=%gt_273e03432c2039cc05443a602e8c633a.txt
@@ -0,0 +1,4 @@
+#<Herb::Token type="TOKEN_ERB_START" value="<%=" range=[0, 3] start=(1:0) end=(1:3)>
+#<Herb::Token type="TOKEN_ERB_CONTENT" value=" \"Test\" " range=[3, 11] start=(1:3) end=(1:11)>
+#<Herb::Token type="TOKEN_ERB_END" value="=%>" range=[11, 14] start=(1:11) end=(1:14)>
+#<Herb::Token type="TOKEN_EOF" value="<EOF>" range=[14, 14] start=(1:14) end=(1:14)>
diff --git a/test/snapshots/lexer/erb_test/test_0008_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt b/test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0008_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
rename to test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_91d881ce0dd66286e4866c07a91e025c.txt
diff --git a/test/snapshots/lexer/erb_test/test_0009_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt b/test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0009_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
rename to test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_before_e474134558bf8ffccb829ba880271d99.txt
diff --git a/test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt b/test/snapshots/lexer/erb_test/test_0012_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0010_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
rename to test/snapshots/lexer/erb_test/test_0012_erb_output_inside_HTML_attribute_value_with_value_before_and_after_4ce9cd67e9f49e97d785cb27fb5e287a.txt
diff --git a/test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt b/test/snapshots/lexer/erb_test/test_0013_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0011_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
rename to test/snapshots/lexer/erb_test/test_0013_erb_output_inside_HTML_attribute_value_with_value_and_after_e07f0e9a593189f256789bd0ab7b5a82.txt
diff --git a/test/snapshots/lexer/erb_test/test_0012_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt b/test/snapshots/lexer/erb_test/test_0014_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0012_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
rename to test/snapshots/lexer/erb_test/test_0014_multi-line_erb_content_3b1dbeebb7d6cc88ee758abcd174c7c4.txt
diff --git a/test/snapshots/lexer/erb_test/test_0013_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt b/test/snapshots/lexer/erb_test/test_0015_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0013_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
rename to test/snapshots/lexer/erb_test/test_0015_multi-line_erb_content_with_complex_ruby_71e2451824a84db91b7e1cf752872168.txt
diff --git a/test/snapshots/lexer/erb_test/test_0014_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt b/test/snapshots/lexer/erb_test/test_0016_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
similarity index 100%
rename from test/snapshots/lexer/erb_test/test_0014_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
rename to test/snapshots/lexer/erb_test/test_0016_multi-line_erb_silent_tag_fae7aab59f46d7906cdeccfc1fa2cb3e.txt
diff --git a/test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt b/test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
similarity index 100%
rename from test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
rename to test/snapshots/lexer/text_content_test/test_0003_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_once_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
diff --git a/test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt b/test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
similarity index 100%
rename from test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
rename to test/snapshots/lexer/text_content_test/test_0004_text_content_that_exceeds_initial_hb_buffer_T_size_and_needs_to_resize_twice_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..6574e7dac
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0007_boolean_attribute_on_void_element_followed_by_newline_and_ERB_tag_with_track_whitespace_865f46b916df0289c3b60c880f529e8b-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,40 @@
+@ DocumentNode (location: (1:0)-(2:12))
+└── children: (3 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:18))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:18))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   │       ├── tag_closing: ">" (location: (1:17)-(1:18))
+    │   │       ├── children: (2 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:5)-(1:6))
+    │   │       │   │   └── value: " " (location: (1:5)-(1:6))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:6)-(1:17))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:6)-(1:17))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:6)-(1:17))
+    │   │       │       │               └── content: "crossorigin"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   ├── body: []
+    │   ├── close_tag: ∅
+    │   ├── is_void: true
+    │   └── source: "HTML"
+    │
+    ├── @ HTMLTextNode (location: (2:3)-(2:0))
+    │   └── content: "\n"
+    │
+    └── @ ERBContentNode (location: (2:0)-(2:12))
+        ├── tag_opening: "<%=" (location: (2:0)-(2:3))
+        ├── content: " hello " (location: (2:3)-(2:10))
+        ├── tag_closing: "%>" (location: (2:10)-(2:12))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..535ea29fc
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0008_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_7a98c943c925e6943aaa2bec978901a9-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,37 @@
+@ DocumentNode (location: (1:0)-(1:30))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:18))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:18))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   │       ├── tag_closing: ">" (location: (1:17)-(1:18))
+    │   │       ├── children: (2 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:5)-(1:6))
+    │   │       │   │   └── value: " " (location: (1:5)-(1:6))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:6)-(1:17))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:6)-(1:17))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:6)-(1:17))
+    │   │       │       │               └── content: "crossorigin"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "link" (location: (1:1)-(1:5))
+    │   ├── body: []
+    │   ├── close_tag: ∅
+    │   ├── is_void: true
+    │   └── source: "HTML"
+    │
+    └── @ ERBContentNode (location: (1:21)-(1:30))
+        ├── tag_opening: "<%=" (location: (1:21)-(1:21))
+        ├── content: " hello " (location: (1:21)-(1:28))
+        ├── tag_closing: "%>" (location: (1:28)-(1:30))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt b/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt
new file mode 100644
index 000000000..3dce31a53
--- /dev/null
+++ b/test/snapshots/parser/boolean_attributes_test/test_0009_boolean_attribute_on_void_element_followed_by_ERB_tag_with_track_whitespace_1d3295149578acc142f855bb3b75b3ec-b26dbda6d8a652930695c93bd07179f4.txt
@@ -0,0 +1,75 @@
+@ DocumentNode (location: (1:0)-(4:0))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(3:6))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:22))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "div" (location: (1:1)-(1:4))
+    │   │       ├── tag_closing: ">" (location: (1:21)-(1:22))
+    │   │       ├── children: (4 items)
+    │   │       │   ├── @ WhitespaceNode (location: (1:4)-(1:5))
+    │   │       │   │   └── value: " " (location: (1:4)-(1:5))
+    │   │       │   │
+    │   │       │   ├── @ HTMLAttributeNode (location: (1:5)-(1:14))
+    │   │       │   │   ├── name:
+    │   │       │   │   │   └── @ HTMLAttributeNameNode (location: (1:5)-(1:7))
+    │   │       │   │   │       └── children: (1 item)
+    │   │       │   │   │           └── @ LiteralNode (location: (1:5)-(1:7))
+    │   │       │   │   │               └── content: "id"
+    │   │       │   │   │
+    │   │       │   │   │
+    │   │       │   │   ├── equals: "=" (location: (1:7)-(1:8))
+    │   │       │   │   └── value:
+    │   │       │   │       └── @ HTMLAttributeValueNode (location: (1:8)-(1:14))
+    │   │       │   │           ├── open_quote: """ (location: (1:8)-(1:9))
+    │   │       │   │           ├── children: (1 item)
+    │   │       │   │           │   └── @ LiteralNode (location: (1:9)-(1:13))
+    │   │       │   │           │       └── content: "test"
+    │   │       │   │           │
+    │   │       │   │           ├── close_quote: """ (location: (1:13)-(1:14))
+    │   │       │   │           └── quoted: true
+    │   │       │   │
+    │   │       │   │
+    │   │       │   ├── @ WhitespaceNode (location: (1:14)-(1:15))
+    │   │       │   │   └── value: " " (location: (1:14)-(1:15))
+    │   │       │   │
+    │   │       │   └── @ HTMLAttributeNode (location: (1:15)-(1:21))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:15)-(1:21))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:15)-(1:21))
+    │   │       │       │               └── content: "hidden"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: ∅
+    │   │       │       └── value: ∅
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "div" (location: (1:1)-(1:4))
+    │   ├── body: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (2:5)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ ERBContentNode (location: (2:2)-(2:13))
+    │   │   │   ├── tag_opening: "<%=" (location: (2:2)-(2:5))
+    │   │   │   ├── content: " "hi" " (location: (2:5)-(2:11))
+    │   │   │   ├── tag_closing: "%>" (location: (2:11)-(2:13))
+    │   │   │   ├── parsed: true
+    │   │   │   └── valid: true
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:13)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── close_tag:
+    │   │   └── @ HTMLCloseTagNode (location: (3:0)-(3:6))
+    │   │       ├── tag_opening: "</" (location: (3:0)-(3:2))
+    │   │       ├── tag_name: "div" (location: (3:2)-(3:5))
+    │   │       ├── children: []
+    │   │       └── tag_closing: ">" (location: (3:5)-(3:6))
+    │   │
+    │   ├── is_void: false
+    │   └── source: "HTML"
+    │
+    └── @ HTMLTextNode (location: (3:6)-(4:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt b/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
new file mode 100644
index 000000000..06e906b7b
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0033_erb_output_with_=%gt_close_tag_e5e99c2c84b3c9a106b8cf08b02ce9d6.txt
@@ -0,0 +1,8 @@
+@ DocumentNode (location: (1:0)-(1:15))
+└── children: (1 item)
+    └── @ ERBContentNode (location: (1:0)-(1:15))
+        ├── tag_opening: "<%=" (location: (1:0)-(1:3))
+        ├── content: " "hello" " (location: (1:3)-(1:12))
+        ├── tag_closing: "=%>" (location: (1:12)-(1:15))
+        ├── parsed: true
+        └── valid: true
\ No newline at end of file
diff --git a/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt b/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
new file mode 100644
index 000000000..5ac9012b3
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0034_erb_if_with_=%gt_close_tag_040322f44f30d4766dc7bfe98114d53f.txt
@@ -0,0 +1,47 @@
+@ DocumentNode (location: (1:0)-(4:0))
+└── children: (2 items)
+    ├── @ ERBIfNode (location: (1:0)-(3:10))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " if true " (location: (1:2)-(1:11))
+    │   ├── tag_closing: "=%>" (location: (1:11)-(1:14))
+    │   ├── statements: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (1:14)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ HTMLElementNode (location: (2:2)-(2:16))
+    │   │   │   ├── open_tag:
+    │   │   │   │   └── @ HTMLOpenTagNode (location: (2:2)-(2:5))
+    │   │   │   │       ├── tag_opening: "<" (location: (2:2)-(2:3))
+    │   │   │   │       ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   │       ├── tag_closing: ">" (location: (2:4)-(2:5))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── is_void: false
+    │   │   │   │
+    │   │   │   ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   ├── body: (1 item)
+    │   │   │   │   └── @ HTMLTextNode (location: (2:5)-(2:12))
+    │   │   │   │       └── content: "Content"
+    │   │   │   │
+    │   │   │   ├── close_tag:
+    │   │   │   │   └── @ HTMLCloseTagNode (location: (2:12)-(2:16))
+    │   │   │   │       ├── tag_opening: "</" (location: (2:12)-(2:14))
+    │   │   │   │       ├── tag_name: "p" (location: (2:14)-(2:15))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── tag_closing: ">" (location: (2:15)-(2:16))
+    │   │   │   │
+    │   │   │   ├── is_void: false
+    │   │   │   └── source: "HTML"
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:16)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── subsequent: ∅
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (3:0)-(3:10))
+    │           ├── tag_opening: "<%" (location: (3:0)-(3:2))
+    │           ├── content: " end " (location: (3:2)-(3:7))
+    │           └── tag_closing: "=%>" (location: (3:7)-(3:10))
+    │
+    │
+    └── @ HTMLTextNode (location: (3:10)-(4:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt b/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
new file mode 100644
index 000000000..8c281e427
--- /dev/null
+++ b/test/snapshots/parser/erb_test/test_0035_erb_if-elsif-else_with_=%gt_close_tag_276e28a241d24b1f8016400a1c84fef1.txt
@@ -0,0 +1,121 @@
+@ DocumentNode (location: (1:0)-(8:0))
+└── children: (2 items)
+    ├── @ ERBIfNode (location: (1:0)-(7:10))
+    │   ├── tag_opening: "<%" (location: (1:0)-(1:2))
+    │   ├── content: " if condition " (location: (1:2)-(1:16))
+    │   ├── tag_closing: "=%>" (location: (1:16)-(1:19))
+    │   ├── statements: (3 items)
+    │   │   ├── @ HTMLTextNode (location: (1:19)-(2:2))
+    │   │   │   └── content: "\n  "
+    │   │   │
+    │   │   ├── @ HTMLElementNode (location: (2:2)-(2:13))
+    │   │   │   ├── open_tag:
+    │   │   │   │   └── @ HTMLOpenTagNode (location: (2:2)-(2:5))
+    │   │   │   │       ├── tag_opening: "<" (location: (2:2)-(2:3))
+    │   │   │   │       ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   │       ├── tag_closing: ">" (location: (2:4)-(2:5))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── is_void: false
+    │   │   │   │
+    │   │   │   ├── tag_name: "p" (location: (2:3)-(2:4))
+    │   │   │   ├── body: (1 item)
+    │   │   │   │   └── @ HTMLTextNode (location: (2:5)-(2:9))
+    │   │   │   │       └── content: "True"
+    │   │   │   │
+    │   │   │   ├── close_tag:
+    │   │   │   │   └── @ HTMLCloseTagNode (location: (2:9)-(2:13))
+    │   │   │   │       ├── tag_opening: "</" (location: (2:9)-(2:11))
+    │   │   │   │       ├── tag_name: "p" (location: (2:11)-(2:12))
+    │   │   │   │       ├── children: []
+    │   │   │   │       └── tag_closing: ">" (location: (2:12)-(2:13))
+    │   │   │   │
+    │   │   │   ├── is_void: false
+    │   │   │   └── source: "HTML"
+    │   │   │
+    │   │   └── @ HTMLTextNode (location: (2:13)-(3:0))
+    │   │       └── content: "\n"
+    │   │
+    │   ├── subsequent:
+    │   │   └── @ ERBIfNode (location: (3:0)-(5:0))
+    │   │       ├── tag_opening: "<%" (location: (3:0)-(3:2))
+    │   │       ├── content: " elsif other " (location: (3:2)-(3:15))
+    │   │       ├── tag_closing: "=%>" (location: (3:15)-(3:18))
+    │   │       ├── statements: (3 items)
+    │   │       │   ├── @ HTMLTextNode (location: (3:18)-(4:2))
+    │   │       │   │   └── content: "\n  "
+    │   │       │   │
+    │   │       │   ├── @ HTMLElementNode (location: (4:2)-(4:14))
+    │   │       │   │   ├── open_tag:
+    │   │       │   │   │   └── @ HTMLOpenTagNode (location: (4:2)-(4:5))
+    │   │       │   │   │       ├── tag_opening: "<" (location: (4:2)-(4:3))
+    │   │       │   │   │       ├── tag_name: "p" (location: (4:3)-(4:4))
+    │   │       │   │   │       ├── tag_closing: ">" (location: (4:4)-(4:5))
+    │   │       │   │   │       ├── children: []
+    │   │       │   │   │       └── is_void: false
+    │   │       │   │   │
+    │   │       │   │   ├── tag_name: "p" (location: (4:3)-(4:4))
+    │   │       │   │   ├── body: (1 item)
+    │   │       │   │   │   └── @ HTMLTextNode (location: (4:5)-(4:10))
+    │   │       │   │   │       └── content: "Other"
+    │   │       │   │   │
+    │   │       │   │   ├── close_tag:
+    │   │       │   │   │   └── @ HTMLCloseTagNode (location: (4:10)-(4:14))
+    │   │       │   │   │       ├── tag_opening: "</" (location: (4:10)-(4:12))
+    │   │       │   │   │       ├── tag_name: "p" (location: (4:12)-(4:13))
+    │   │       │   │   │       ├── children: []
+    │   │       │   │   │       └── tag_closing: ">" (location: (4:13)-(4:14))
+    │   │       │   │   │
+    │   │       │   │   ├── is_void: false
+    │   │       │   │   └── source: "HTML"
+    │   │       │   │
+    │   │       │   └── @ HTMLTextNode (location: (4:14)-(5:0))
+    │   │       │       └── content: "\n"
+    │   │       │
+    │   │       ├── subsequent:
+    │   │       │   └── @ ERBElseNode (location: (5:0)-(7:0))
+    │   │       │       ├── tag_opening: "<%" (location: (5:0)-(5:2))
+    │   │       │       ├── content: " else " (location: (5:2)-(5:8))
+    │   │       │       ├── tag_closing: "=%>" (location: (5:8)-(5:11))
+    │   │       │       └── statements: (3 items)
+    │   │       │           ├── @ HTMLTextNode (location: (5:11)-(6:2))
+    │   │       │           │   └── content: "\n  "
+    │   │       │           │
+    │   │       │           ├── @ HTMLElementNode (location: (6:2)-(6:14))
+    │   │       │           │   ├── open_tag:
+    │   │       │           │   │   └── @ HTMLOpenTagNode (location: (6:2)-(6:5))
+    │   │       │           │   │       ├── tag_opening: "<" (location: (6:2)-(6:3))
+    │   │       │           │   │       ├── tag_name: "p" (location: (6:3)-(6:4))
+    │   │       │           │   │       ├── tag_closing: ">" (location: (6:4)-(6:5))
+    │   │       │           │   │       ├── children: []
+    │   │       │           │   │       └── is_void: false
+    │   │       │           │   │
+    │   │       │           │   ├── tag_name: "p" (location: (6:3)-(6:4))
+    │   │       │           │   ├── body: (1 item)
+    │   │       │           │   │   └── @ HTMLTextNode (location: (6:5)-(6:10))
+    │   │       │           │   │       └── content: "False"
+    │   │       │           │   │
+    │   │       │           │   ├── close_tag:
+    │   │       │           │   │   └── @ HTMLCloseTagNode (location: (6:10)-(6:14))
+    │   │       │           │   │       ├── tag_opening: "</" (location: (6:10)-(6:12))
+    │   │       │           │   │       ├── tag_name: "p" (location: (6:12)-(6:13))
+    │   │       │           │   │       ├── children: []
+    │   │       │           │   │       └── tag_closing: ">" (location: (6:13)-(6:14))
+    │   │       │           │   │
+    │   │       │           │   ├── is_void: false
+    │   │       │           │   └── source: "HTML"
+    │   │       │           │
+    │   │       │           └── @ HTMLTextNode (location: (6:14)-(7:0))
+    │   │       │               └── content: "\n"
+    │   │       │
+    │   │       │
+    │   │       └── end_node: ∅
+    │   │
+    │   └── end_node:
+    │       └── @ ERBEndNode (location: (7:0)-(7:10))
+    │           ├── tag_opening: "<%" (location: (7:0)-(7:2))
+    │           ├── content: " end " (location: (7:2)-(7:7))
+    │           └── tag_closing: "=%>" (location: (7:7)-(7:10))
+    │
+    │
+    └── @ HTMLTextNode (location: (7:10)-(8:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt b/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
index 43d5aa8af..48469075a 100644
--- a/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
+++ b/test/snapshots/parser/script_style_test/test_0035_script_tag_with_escaped_quotes_in_strings_3217a5ed01ac8ce6c44f9e106f9b4017.txt
@@ -1,11 +1,4 @@
 @ DocumentNode (location: (1:0)-(1:59))
-├── errors: (1 error)
-│   └── @ UnexpectedError (location: (1:36)-(1:37))
-│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_BACKSLASH`."
-│       ├── description: "Unexpected token"
-│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE"
-│       └── found: "TOKEN_BACKSLASH"
-│
 └── children: (3 items)
     ├── @ HTMLElementNode (location: (1:0)-(1:36))
     │   ├── open_tag:
@@ -31,8 +24,8 @@
     │   ├── is_void: false
     │   └── source: "HTML"
     │
-    ├── @ HTMLTextNode (location: (1:37)-(1:50))
-    │   └── content: "\" yesterday\";"
+    ├── @ HTMLTextNode (location: (1:36)-(1:50))
+    │   └── content: "\\\" yesterday\";"
     │
     └── @ HTMLCloseTagNode (location: (1:50)-(1:59))
         ├── errors: (1 error)
diff --git a/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt b/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
index 2a55af7ab..1bebae8b0 100644
--- a/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
+++ b/test/snapshots/parser/tags_test/test_0027_stray_closing_tag_with_whitespace_0ee4b96cac701f87a8b6cb0cf5ad48bc.txt
@@ -1,9 +1,9 @@
 @ DocumentNode (location: (1:0)-(1:24))
 ├── errors: (1 error)
 │   └── @ UnexpectedError (location: (1:16)-(1:17))
-│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKE`, found: `TOKEN_LT`."
+│       ├── message: "Unexpected token. Expected: `TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, TOKEN_B`, found: `TOKEN_LT`."
 │       ├── description: "Unexpected token"
-│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE"
+│       ├── expected: "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, TOKEN_NBSP, TOKEN_AT, TOKEN_BACKSLASH, or TOKEN_NEWLINE"
 │       └── found: "TOKEN_LT"
 │
 └── children: (2 items)
diff --git a/test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_>_045e6b8518e8214f621854f251d1f323.txt b/test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_gt_045e6b8518e8214f621854f251d1f323.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_>_045e6b8518e8214f621854f251d1f323.txt
rename to test/snapshots/parser/tags_test/test_0047_closing_tag_with_newline_before_gt_045e6b8518e8214f621854f251d1f323.txt
diff --git a/test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_>_c39bc3d537f50940f8301bcf5be6a5e9.txt b/test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_>_c39bc3d537f50940f8301bcf5be6a5e9.txt
rename to test/snapshots/parser/tags_test/test_0048_closing_tag_with_whitespace_and_newline_before_gt_c39bc3d537f50940f8301bcf5be6a5e9.txt
diff --git a/test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_>_c9d0ca9f702b1a3786a1a8ba835fb475.txt b/test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_>_c9d0ca9f702b1a3786a1a8ba835fb475.txt
rename to test/snapshots/parser/tags_test/test_0049_multiple_closing_tags_with_newlines_before_gt_c9d0ca9f702b1a3786a1a8ba835fb475.txt
diff --git a/test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_>_004b02b673d57d73eb07a649eb08e705.txt b/test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_gt_004b02b673d57d73eb07a649eb08e705.txt
similarity index 100%
rename from test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_>_004b02b673d57d73eb07a649eb08e705.txt
rename to test/snapshots/parser/tags_test/test_0051_self-closing_tag_with_closing_tag_having_newline_before_gt_004b02b673d57d73eb07a649eb08e705.txt
diff --git a/test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt b/test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
similarity index 100%
rename from test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
rename to test/snapshots/parser/text_content_test/test_0006_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._4K)_998d9cbd9b8794fa030c888bfa09cad4.txt
diff --git a/test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt b/test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
similarity index 100%
rename from test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
rename to test/snapshots/parser/text_content_test/test_0007_text_content_that_exceeds_initial_hb_buffer_T_size_(ca._8K)_45e3ecb8edc7dbec7d68b72b5d083439.txt
diff --git a/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt b/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt
new file mode 100644
index 000000000..e75b2ccb2
--- /dev/null
+++ b/test/snapshots/parser/text_content_test/test_0034_backslash-prefixed_text_stays_literal_-_issue_635_816fd02d8670264d606d92812679f159.txt
@@ -0,0 +1,25 @@
+@ DocumentNode (location: (1:0)-(1:22))
+└── children: (1 item)
+    └── @ HTMLElementNode (location: (1:0)-(1:22))
+        ├── open_tag:
+        │   └── @ HTMLOpenTagNode (location: (1:0)-(1:3))
+        │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+        │       ├── tag_name: "p" (location: (1:1)-(1:2))
+        │       ├── tag_closing: ">" (location: (1:2)-(1:3))
+        │       ├── children: []
+        │       └── is_void: false
+        │
+        ├── tag_name: "p" (location: (1:1)-(1:2))
+        ├── body: (1 item)
+        │   └── @ HTMLTextNode (location: (1:3)-(1:18))
+        │       └── content: "\\Asome-regexp\\z"
+        │
+        ├── close_tag:
+        │   └── @ HTMLCloseTagNode (location: (1:18)-(1:22))
+        │       ├── tag_opening: "</" (location: (1:18)-(1:20))
+        │       ├── tag_name: "p" (location: (1:20)-(1:21))
+        │       ├── children: []
+        │       └── tag_closing: ">" (location: (1:21)-(1:22))
+        │
+        ├── is_void: false
+        └── source: "HTML"
\ No newline at end of file
diff --git a/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt b/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt
new file mode 100644
index 000000000..e2d4e504d
--- /dev/null
+++ b/test/snapshots/parser/text_content_test/test_0035_backslash-prefixed_text_-_issue_633_fd1ab6af93689cddc537bac4cbdaefde.txt
@@ -0,0 +1,72 @@
+@ DocumentNode (location: (1:0)-(2:0))
+└── children: (2 items)
+    ├── @ HTMLElementNode (location: (1:0)-(1:119))
+    │   ├── open_tag:
+    │   │   └── @ HTMLOpenTagNode (location: (1:0)-(1:16))
+    │   │       ├── tag_opening: "<" (location: (1:0)-(1:1))
+    │   │       ├── tag_name: "p" (location: (1:1)-(1:2))
+    │   │       ├── tag_closing: ">" (location: (1:15)-(1:16))
+    │   │       ├── children: (1 item)
+    │   │       │   └── @ HTMLAttributeNode (location: (1:3)-(1:15))
+    │   │       │       ├── name:
+    │   │       │       │   └── @ HTMLAttributeNameNode (location: (1:3)-(1:8))
+    │   │       │       │       └── children: (1 item)
+    │   │       │       │           └── @ LiteralNode (location: (1:3)-(1:8))
+    │   │       │       │               └── content: "class"
+    │   │       │       │
+    │   │       │       │
+    │   │       │       ├── equals: "=" (location: (1:8)-(1:9))
+    │   │       │       └── value:
+    │   │       │           └── @ HTMLAttributeValueNode (location: (1:9)-(1:15))
+    │   │       │               ├── open_quote: """ (location: (1:9)-(1:10))
+    │   │       │               ├── children: (1 item)
+    │   │       │               │   └── @ LiteralNode (location: (1:10)-(1:14))
+    │   │       │               │       └── content: "help"
+    │   │       │               │
+    │   │       │               ├── close_quote: """ (location: (1:14)-(1:15))
+    │   │       │               └── quoted: true
+    │   │       │
+    │   │       │
+    │   │       └── is_void: false
+    │   │
+    │   ├── tag_name: "p" (location: (1:1)-(1:2))
+    │   ├── body: (2 items)
+    │   │   ├── @ HTMLTextNode (location: (1:16)-(1:70))
+    │   │   │   └── content: "Regexp with captures, must consume whole string like: "
+    │   │   │
+    │   │   └── @ HTMLElementNode (location: (1:70)-(1:115))
+    │   │       ├── open_tag:
+    │   │       │   └── @ HTMLOpenTagNode (location: (1:70)-(1:75))
+    │   │       │       ├── tag_opening: "<" (location: (1:70)-(1:71))
+    │   │       │       ├── tag_name: "kbd" (location: (1:71)-(1:74))
+    │   │       │       ├── tag_closing: ">" (location: (1:74)-(1:75))
+    │   │       │       ├── children: []
+    │   │       │       └── is_void: false
+    │   │       │
+    │   │       ├── tag_name: "kbd" (location: (1:71)-(1:74))
+    │   │       ├── body: (1 item)
+    │   │       │   └── @ HTMLTextNode (location: (1:75)-(1:109))
+    │   │       │       └── content: "\\Ahttps?://github.com/+([^/]+).*\\z"
+    │   │       │
+    │   │       ├── close_tag:
+    │   │       │   └── @ HTMLCloseTagNode (location: (1:109)-(1:115))
+    │   │       │       ├── tag_opening: "</" (location: (1:109)-(1:111))
+    │   │       │       ├── tag_name: "kbd" (location: (1:111)-(1:114))
+    │   │       │       ├── children: []
+    │   │       │       └── tag_closing: ">" (location: (1:114)-(1:115))
+    │   │       │
+    │   │       ├── is_void: false
+    │   │       └── source: "HTML"
+    │   │
+    │   ├── close_tag:
+    │   │   └── @ HTMLCloseTagNode (location: (1:115)-(1:119))
+    │   │       ├── tag_opening: "</" (location: (1:115)-(1:117))
+    │   │       ├── tag_name: "p" (location: (1:117)-(1:118))
+    │   │       ├── children: []
+    │   │       └── tag_closing: ">" (location: (1:118)-(1:119))
+    │   │
+    │   ├── is_void: false
+    │   └── source: "HTML"
+    │
+    └── @ HTMLTextNode (location: (1:119)-(2:0))
+        └── content: "\n"
\ No newline at end of file
diff --git a/wasm/extension_helpers.cpp b/wasm/extension_helpers.cpp
index 490a81412..3118cf13e 100644
--- a/wasm/extension_helpers.cpp
+++ b/wasm/extension_helpers.cpp
@@ -7,12 +7,12 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../src/include/array.h"
+#include "../src/include/util/hb_array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
 #include "../src/include/pretty_print.h"
 #include "../src/include/ast_pretty_print.h"
-#include "../src/include/buffer.h"
+#include "../src/include/util/hb_buffer.h"
 #include "../src/include/herb.h"
 #include "../src/include/token.h"
 #include "../src/include/position.h"
@@ -27,44 +27,32 @@ val CreateString(const char* string) {
   return string ? val(string) : val::null();
 }
 
-val CreatePosition(position_T* position) {
-  if (!position) {
-    return val::null();
-  }
-
+val CreatePosition(position_T position) {
   val Object = val::global("Object");
   val result = Object.new_();
 
-  result.set("line", position->line);
-  result.set("column", position->column);
+  result.set("line", position.line);
+  result.set("column", position.column);
 
   return result;
 }
 
-val CreateLocation(location_T* location) {
-  if (!location) {
-    return val::null();
-  }
-
+val CreateLocation(location_T location) {
   val Object = val::global("Object");
   val result = Object.new_();
 
-  result.set("start", CreatePosition(location->start));
-  result.set("end", CreatePosition(location->end));
+  result.set("start", CreatePosition(location.start));
+  result.set("end", CreatePosition(location.end));
 
   return result;
 }
 
-val CreateRange(range_T* range) {
-  if (!range) {
-    return val::null();
-  }
-
+val CreateRange(range_T range) {
   val Array = val::global("Array");
   val result = Array.new_();
 
-  result.call<void>("push", range->from);
-  result.call<void>("push", range->to);
+  result.call<void>("push", range.from);
+  result.call<void>("push", range.to);
 
   return result;
 }
@@ -90,7 +78,7 @@ val CreateToken(token_T* token) {
   return result;
 }
 
-val CreateLexResult(array_T* tokens, const std::string& source) {
+val CreateLexResult(hb_array_T* tokens, const std::string& source) {
   val Object = val::global("Object");
   val Array = val::global("Array");
 
@@ -100,8 +88,8 @@ val CreateLexResult(array_T* tokens, const std::string& source) {
   val warningsArray = Array.new_();
 
   if (tokens) {
-    for (size_t i = 0; i < array_size(tokens); i++) {
-      token_T* token = (token_T*)array_get(tokens, i);
+    for (size_t i = 0; i < hb_array_size(tokens); i++) {
+      token_T* token = (token_T*)hb_array_get(tokens, i);
       if (token) {
         tokensArray.call<void>("push", CreateToken(token));
       }
diff --git a/wasm/extension_helpers.h b/wasm/extension_helpers.h
index 923df6f3b..e4d2332f4 100644
--- a/wasm/extension_helpers.h
+++ b/wasm/extension_helpers.h
@@ -14,11 +14,11 @@ extern "C" {
 }
 
 emscripten::val CreateString(const char* string);
-emscripten::val CreatePosition(position_T* position);
-emscripten::val CreateLocation(location_T* location);
-emscripten::val CreateRange(range_T* range);
+emscripten::val CreatePosition(position_T position);
+emscripten::val CreateLocation(location_T location);
+emscripten::val CreateRange(range_T range);
 emscripten::val CreateToken(token_T* token);
-emscripten::val CreateLexResult(array_T* tokens, const std::string& source);
+emscripten::val CreateLexResult(hb_array_T* tokens, const std::string& source);
 emscripten::val CreateParseResult(AST_DOCUMENT_NODE_T *root, const std::string& source);
 
 #endif
diff --git a/wasm/herb-wasm.cpp b/wasm/herb-wasm.cpp
index 91d270fdb..e1e5ce06e 100644
--- a/wasm/herb-wasm.cpp
+++ b/wasm/herb-wasm.cpp
@@ -8,11 +8,11 @@
 
 extern "C" {
 #include "../src/include/analyze.h"
-#include "../src/include/array.h"
+#include "../src/include/util/hb_array.h"
 #include "../src/include/ast_node.h"
 #include "../src/include/ast_nodes.h"
 #include "../src/include/ast_pretty_print.h"
-#include "../src/include/buffer.h"
+#include "../src/include/util/hb_buffer.h"
 #include "../src/include/extract.h"
 #include "../src/include/herb.h"
 #include "../src/include/location.h"
@@ -25,7 +25,7 @@ extern "C" {
 using namespace emscripten;
 
 val Herb_lex(const std::string& source) {
-  array_T* tokens = herb_lex(source.c_str());
+  hb_array_T* tokens = herb_lex(source.c_str());
 
   val result = CreateLexResult(tokens, source);
 
@@ -60,20 +60,22 @@ val Herb_parse(const std::string& source, val options) {
 }
 
 std::string Herb_extract_ruby(const std::string& source) {
-  buffer_T output;
-  buffer_init(&output);
+  hb_buffer_T output;
+  hb_buffer_init(&output, source.length());
+
   herb_extract_ruby_to_buffer(source.c_str(), &output);
-  std::string result(buffer_value(&output));
-  buffer_free(&output);
+  std::string result(hb_buffer_value(&output));
+  free(output.value);
   return result;
 }
 
 std::string Herb_extract_html(const std::string& source) {
-  buffer_T output;
-  buffer_init(&output);
+  hb_buffer_T output;
+  hb_buffer_init(&output, source.length());
+
   herb_extract_html_to_buffer(source.c_str(), &output);
-  std::string result(buffer_value(&output));
-  buffer_free(&output);
+  std::string result(hb_buffer_value(&output));
+  free(output.value);
   return result;
 }
 
diff --git a/yarn.lock b/yarn.lock
index 67c73992f..bd70e0153 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -219,135 +219,135 @@
   dependencies:
     tslib "^2.4.0"
 
-"@esbuild/aix-ppc64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz#ee6b7163a13528e099ecf562b972f2bcebe0aa97"
-  integrity sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==
-
-"@esbuild/android-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz#115fc76631e82dd06811bfaf2db0d4979c16e2cb"
-  integrity sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==
-
-"@esbuild/android-arm@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.10.tgz#8d5811912da77f615398611e5bbc1333fe321aa9"
-  integrity sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==
-
-"@esbuild/android-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.10.tgz#e3e96516b2d50d74105bb92594c473e30ddc16b1"
-  integrity sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==
-
-"@esbuild/darwin-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz#6af6bb1d05887dac515de1b162b59dc71212ed76"
-  integrity sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==
-
-"@esbuild/darwin-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz#99ae82347fbd336fc2d28ffd4f05694e6e5b723d"
-  integrity sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==
-
-"@esbuild/freebsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz#0c6d5558a6322b0bdb17f7025c19bd7d2359437d"
-  integrity sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==
-
-"@esbuild/freebsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz#8c35873fab8c0857a75300a3dcce4324ca0b9844"
-  integrity sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==
-
-"@esbuild/linux-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz#3edc2f87b889a15b4cedaf65f498c2bed7b16b90"
-  integrity sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==
-
-"@esbuild/linux-arm@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz#86501cfdfb3d110176d80c41b27ed4611471cde7"
-  integrity sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==
-
-"@esbuild/linux-ia32@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz#e6589877876142537c6864680cd5d26a622b9d97"
-  integrity sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==
-
-"@esbuild/linux-loong64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz#11119e18781f136d8083ea10eb6be73db7532de8"
-  integrity sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==
-
-"@esbuild/linux-mips64el@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz#3052f5436b0c0c67a25658d5fc87f045e7def9e6"
-  integrity sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==
-
-"@esbuild/linux-ppc64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz#2f098920ee5be2ce799f35e367b28709925a8744"
-  integrity sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==
-
-"@esbuild/linux-riscv64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz#fa51d7fd0a22a62b51b4b94b405a3198cf7405dd"
-  integrity sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==
-
-"@esbuild/linux-s390x@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz#a27642e36fc282748fdb38954bd3ef4f85791e8a"
-  integrity sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==
-
-"@esbuild/linux-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz#9d9b09c0033d17529570ced6d813f98315dfe4e9"
-  integrity sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==
-
-"@esbuild/netbsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz#25c09a659c97e8af19e3f2afd1c9190435802151"
-  integrity sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==
-
-"@esbuild/netbsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz#7fa5f6ffc19be3a0f6f5fd32c90df3dc2506937a"
-  integrity sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==
-
-"@esbuild/openbsd-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz#8faa6aa1afca0c6d024398321d6cb1c18e72a1c3"
-  integrity sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==
-
-"@esbuild/openbsd-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz#a42979b016f29559a8453d32440d3c8cd420af5e"
-  integrity sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==
-
-"@esbuild/openharmony-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz#fd87bfeadd7eeb3aa384bbba907459ffa3197cb1"
-  integrity sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==
-
-"@esbuild/sunos-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.10.tgz#3a18f590e36cb78ae7397976b760b2b8c74407f4"
-  integrity sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ==
-
-"@esbuild/win32-arm64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz#e71741a251e3fd971408827a529d2325551f530c"
-  integrity sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==
-
-"@esbuild/win32-ia32@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz#c6f010b5d3b943d8901a0c87ea55f93b8b54bf94"
-  integrity sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==
-
-"@esbuild/win32-x64@0.25.10":
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz#e4b3e255a1b4aea84f6e1d2ae0b73f826c3785bd"
-  integrity sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==
+"@esbuild/aix-ppc64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.11.tgz#2ae33300598132cc4cf580dbbb28d30fed3c5c49"
+  integrity sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg==
+
+"@esbuild/android-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.11.tgz#927708b3db5d739d6cb7709136924cc81bec9b03"
+  integrity sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ==
+
+"@esbuild/android-arm@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.11.tgz#571f94e7f4068957ec4c2cfb907deae3d01b55ae"
+  integrity sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg==
+
+"@esbuild/android-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.11.tgz#8a3bf5cae6c560c7ececa3150b2bde76e0fb81e6"
+  integrity sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g==
+
+"@esbuild/darwin-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.11.tgz#0a678c4ac4bf8717e67481e1a797e6c152f93c84"
+  integrity sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w==
+
+"@esbuild/darwin-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.11.tgz#70f5e925a30c8309f1294d407a5e5e002e0315fe"
+  integrity sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ==
+
+"@esbuild/freebsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.11.tgz#4ec1db687c5b2b78b44148025da9632397553e8a"
+  integrity sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA==
+
+"@esbuild/freebsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.11.tgz#4c81abd1b142f1e9acfef8c5153d438ca53f44bb"
+  integrity sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw==
+
+"@esbuild/linux-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.11.tgz#69517a111acfc2b93aa0fb5eaeb834c0202ccda5"
+  integrity sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA==
+
+"@esbuild/linux-arm@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.11.tgz#58dac26eae2dba0fac5405052b9002dac088d38f"
+  integrity sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw==
+
+"@esbuild/linux-ia32@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.11.tgz#b89d4efe9bdad46ba944f0f3b8ddd40834268c2b"
+  integrity sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw==
+
+"@esbuild/linux-loong64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.11.tgz#11f603cb60ad14392c3f5c94d64b3cc8b630fbeb"
+  integrity sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw==
+
+"@esbuild/linux-mips64el@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.11.tgz#b7d447ff0676b8ab247d69dac40a5cf08e5eeaf5"
+  integrity sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ==
+
+"@esbuild/linux-ppc64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.11.tgz#b3a28ed7cc252a61b07ff7c8fd8a984ffd3a2f74"
+  integrity sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw==
+
+"@esbuild/linux-riscv64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.11.tgz#ce75b08f7d871a75edcf4d2125f50b21dc9dc273"
+  integrity sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww==
+
+"@esbuild/linux-s390x@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.11.tgz#cd08f6c73b6b6ff9ccdaabbd3ff6ad3dca99c263"
+  integrity sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw==
+
+"@esbuild/linux-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.11.tgz#3c3718af31a95d8946ebd3c32bb1e699bdf74910"
+  integrity sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ==
+
+"@esbuild/netbsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.11.tgz#b4c767082401e3a4e8595fe53c47cd7f097c8077"
+  integrity sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg==
+
+"@esbuild/netbsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.11.tgz#f2a930458ed2941d1f11ebc34b9c7d61f7a4d034"
+  integrity sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A==
+
+"@esbuild/openbsd-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.11.tgz#b4ae93c75aec48bc1e8a0154957a05f0641f2dad"
+  integrity sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg==
+
+"@esbuild/openbsd-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.11.tgz#b42863959c8dcf9b01581522e40012d2c70045e2"
+  integrity sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw==
+
+"@esbuild/openharmony-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.11.tgz#b2e717141c8fdf6bddd4010f0912e6b39e1640f1"
+  integrity sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ==
+
+"@esbuild/sunos-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.11.tgz#9fbea1febe8778927804828883ec0f6dd80eb244"
+  integrity sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA==
+
+"@esbuild/win32-arm64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.11.tgz#501539cedb24468336073383989a7323005a8935"
+  integrity sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q==
+
+"@esbuild/win32-ia32@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.11.tgz#8ac7229aa82cef8f16ffb58f1176a973a7a15343"
+  integrity sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA==
+
+"@esbuild/win32-x64@0.25.11":
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.11.tgz#5ecda6f3fe138b7e456f4e429edde33c823f392f"
+  integrity sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.7.0":
   version "4.7.0"
@@ -3930,37 +3930,37 @@ esbuild-plugin-copy@^2.1.1:
     fs-extra "^10.0.1"
     globby "^11.0.3"
 
-esbuild@^0.25.0, esbuild@^0.25.10, esbuild@~0.25.0:
-  version "0.25.10"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.25.10.tgz#37f5aa5cd14500f141be121c01b096ca83ac34a9"
-  integrity sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==
+esbuild@^0.25.0, esbuild@^0.25.11, esbuild@~0.25.0:
+  version "0.25.11"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.25.11.tgz#0f31b82f335652580f75ef6897bba81962d9ae3d"
+  integrity sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q==
   optionalDependencies:
-    "@esbuild/aix-ppc64" "0.25.10"
-    "@esbuild/android-arm" "0.25.10"
-    "@esbuild/android-arm64" "0.25.10"
-    "@esbuild/android-x64" "0.25.10"
-    "@esbuild/darwin-arm64" "0.25.10"
-    "@esbuild/darwin-x64" "0.25.10"
-    "@esbuild/freebsd-arm64" "0.25.10"
-    "@esbuild/freebsd-x64" "0.25.10"
-    "@esbuild/linux-arm" "0.25.10"
-    "@esbuild/linux-arm64" "0.25.10"
-    "@esbuild/linux-ia32" "0.25.10"
-    "@esbuild/linux-loong64" "0.25.10"
-    "@esbuild/linux-mips64el" "0.25.10"
-    "@esbuild/linux-ppc64" "0.25.10"
-    "@esbuild/linux-riscv64" "0.25.10"
-    "@esbuild/linux-s390x" "0.25.10"
-    "@esbuild/linux-x64" "0.25.10"
-    "@esbuild/netbsd-arm64" "0.25.10"
-    "@esbuild/netbsd-x64" "0.25.10"
-    "@esbuild/openbsd-arm64" "0.25.10"
-    "@esbuild/openbsd-x64" "0.25.10"
-    "@esbuild/openharmony-arm64" "0.25.10"
-    "@esbuild/sunos-x64" "0.25.10"
-    "@esbuild/win32-arm64" "0.25.10"
-    "@esbuild/win32-ia32" "0.25.10"
-    "@esbuild/win32-x64" "0.25.10"
+    "@esbuild/aix-ppc64" "0.25.11"
+    "@esbuild/android-arm" "0.25.11"
+    "@esbuild/android-arm64" "0.25.11"
+    "@esbuild/android-x64" "0.25.11"
+    "@esbuild/darwin-arm64" "0.25.11"
+    "@esbuild/darwin-x64" "0.25.11"
+    "@esbuild/freebsd-arm64" "0.25.11"
+    "@esbuild/freebsd-x64" "0.25.11"
+    "@esbuild/linux-arm" "0.25.11"
+    "@esbuild/linux-arm64" "0.25.11"
+    "@esbuild/linux-ia32" "0.25.11"
+    "@esbuild/linux-loong64" "0.25.11"
+    "@esbuild/linux-mips64el" "0.25.11"
+    "@esbuild/linux-ppc64" "0.25.11"
+    "@esbuild/linux-riscv64" "0.25.11"
+    "@esbuild/linux-s390x" "0.25.11"
+    "@esbuild/linux-x64" "0.25.11"
+    "@esbuild/netbsd-arm64" "0.25.11"
+    "@esbuild/netbsd-x64" "0.25.11"
+    "@esbuild/openbsd-arm64" "0.25.11"
+    "@esbuild/openbsd-x64" "0.25.11"
+    "@esbuild/openharmony-arm64" "0.25.11"
+    "@esbuild/sunos-x64" "0.25.11"
+    "@esbuild/win32-arm64" "0.25.11"
+    "@esbuild/win32-ia32" "0.25.11"
+    "@esbuild/win32-x64" "0.25.11"
 
 escalade@^3.1.1, escalade@^3.2.0:
   version "3.2.0"
@@ -7462,17 +7462,17 @@ pkg-types@^2.3.0:
     exsolve "^1.0.7"
     pathe "^2.0.3"
 
-playwright-core@1.55.0:
-  version "1.55.0"
-  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.55.0.tgz#ec8a9f8ef118afb3e86e0f46f1393e3bea32adf4"
-  integrity sha512-GvZs4vU3U5ro2nZpeiwyb0zuFaqb9sUiAJuyrWpcGouD8y9/HLgGbNRjIph7zU9D3hnPaisMl9zG9CgFi/biIg==
+playwright-core@1.55.1:
+  version "1.55.1"
+  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.55.1.tgz#5d3bb1846bc4289d364ea1a9dcb33f14545802e9"
+  integrity sha512-Z6Mh9mkwX+zxSlHqdr5AOcJnfp+xUWLCt9uKV18fhzA8eyxUd8NUWzAjxUh55RZKSYwDGX0cfaySdhZJGMoJ+w==
 
-playwright@^1.51.0:
-  version "1.55.0"
-  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.55.0.tgz#7aca7ac3ffd9e083a8ad8b2514d6f9ba401cc78b"
-  integrity sha512-sdCWStblvV1YU909Xqx0DhOjPZE4/5lJsIS84IfN9dAZfcl/CIZ5O8l3o0j7hPMjDvqoTF8ZUcc+i/GL5erstA==
+playwright@^1.55.1:
+  version "1.55.1"
+  resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.55.1.tgz#8a9954e9e61ed1ab479212af9be336888f8b3f0e"
+  integrity sha512-cJW4Xd/G3v5ovXtJJ52MAOclqeac9S/aGGgRzLabuF8TnIb6xHvMzKIa6JmrRzUkeXJgfL1MhukP0NK6l39h3A==
   dependencies:
-    playwright-core "1.55.0"
+    playwright-core "1.55.1"
   optionalDependencies:
     fsevents "2.3.2"
 
@@ -9757,10 +9757,10 @@ vite-node@3.2.4:
     pathe "^2.0.3"
     vite "^5.0.0 || ^6.0.0 || ^7.0.0-0"
 
-"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.2, vite@^7.1.7:
-  version "7.1.7"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.7.tgz#ed3f9f06e21d6574fe1ad425f6b0912d027ffc13"
-  integrity sha512-VbA8ScMvAISJNJVbRDTJdCwqQoAareR/wutevKanhR2/1EkoXVZVkkORaYm/tNVCjP/UDTKtcw3bAkwOUdedmA==
+"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0", vite@^7.1.11, vite@^7.1.2:
+  version "7.1.11"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-7.1.11.tgz#4d006746112fee056df64985191e846ebfb6007e"
+  integrity sha512-uzcxnSDVjAopEUjljkWh8EIrg6tlzrjFUfMcR1EVsRDGwf/ccef0qQPRyOrROwhrTDaApueq+ja+KLPlzR/zdg==
   dependencies:
     esbuild "^0.25.0"
     fdir "^6.5.0"